From dbab71e348caaade850dce3106ce4b789380077d Mon Sep 17 00:00:00 2001 From: Agus Zubiaga Date: Mon, 15 Dec 2025 16:32:32 -0300 Subject: [PATCH 001/266] Add `.claude/settings.local.json` to `.gitignore` (#44905) Ignore people's local Claude Code settings Release Notes: - N/A --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index ccf4f471d5a7b70be0dc8d619ac64050dd6681ec..54faaf1374299ee8f97925a95a93b375c349d707 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ .DS_Store .blob_store .build +.claude/settings.local.json .envrc .flatpak-builder .idea @@ -41,4 +42,4 @@ xcuserdata/ .env.secret.toml # `nix build` output -/result +/result From 969e9a6707218c6f705132720810cec1f50c70e7 Mon Sep 17 00:00:00 2001 From: Casper van Elteren Date: Tue, 16 Dec 2025 06:04:50 +1000 Subject: [PATCH 002/266] Fix micromamba not initializing shell (#44646) Closes #44645 This is a continuation of #40577 Release Notes: - initializes micromamba based on the shell --- crates/languages/src/python.rs | 40 ++++++++++++++++++++++++---------- 1 file changed, 28 insertions(+), 12 deletions(-) diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs index 730470d17958f4db02f1ac8c570ffeb83109112c..fbdeb59b7f15a22d4f4097a3b0e60b4aeb9bf202 100644 --- a/crates/languages/src/python.rs +++ b/crates/languages/src/python.rs @@ -1131,6 +1131,18 @@ fn wr_distance( } } +fn micromamba_shell_name(kind: ShellKind) -> &'static str { + match kind { + ShellKind::Csh => "csh", + ShellKind::Fish => "fish", + ShellKind::Nushell => "nu", + ShellKind::PowerShell => "powershell", + ShellKind::Cmd => "cmd.exe", + // default / catch-all: + _ => "posix", + } +} + #[async_trait] impl ToolchainLister for PythonToolchainProvider { async fn list( @@ -1297,24 +1309,28 @@ impl ToolchainLister for PythonToolchainProvider { .as_option() .map(|venv| venv.conda_manager) .unwrap_or(settings::CondaManager::Auto); - let manager = match conda_manager { settings::CondaManager::Conda => "conda", settings::CondaManager::Mamba => "mamba", settings::CondaManager::Micromamba => "micromamba", - settings::CondaManager::Auto => { - // When auto, prefer the detected manager or fall back to conda - toolchain - .environment - .manager - .as_ref() - .and_then(|m| m.executable.file_name()) - .and_then(|name| name.to_str()) - .filter(|name| matches!(*name, "conda" | "mamba" | "micromamba")) - .unwrap_or("conda") - } + settings::CondaManager::Auto => toolchain + .environment + .manager + .as_ref() + .and_then(|m| m.executable.file_name()) + .and_then(|name| name.to_str()) + .filter(|name| matches!(*name, "conda" | "mamba" | "micromamba")) + .unwrap_or("conda"), }; + // Activate micromamba shell in the child shell + // [required for micromamba] + if manager == "micromamba" { + let shell = micromamba_shell_name(shell); + activation_script + .push(format!(r#"eval "$({manager} shell hook --shell {shell})""#)); + } + if let Some(name) = &toolchain.environment.name { activation_script.push(format!("{manager} activate {name}")); } else { From 2441dc3f6637431a781ae10b2e1aa8c4704b9502 Mon Sep 17 00:00:00 2001 From: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> Date: Mon, 15 Dec 2025 21:33:15 +0100 Subject: [PATCH 003/266] gpui: Take advantage of unified memory on Apple silicon (#44273) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Metal chooses a buffer’s default storage mode based on the type of GPU in use. On Apple GPUs, the default mode is shared, which allows the CPU and GPU to access the same memory without requiring explicit synchronization. On discrete or external GPUs, Metal instead defaults to managed storage, which does require explicit CPU–GPU memory synchronization. This change aligns our buffer usage with Metal’s default behavior and avoids unnecessary synchronization on Apple-silicon Macs. As a result, memory usage on Apple hardware is reduced and performance improves due to fewer sync operations. Ref: https://developer.apple.com/documentation/metal/setting-resource-storage-modes Ref: https://developer.apple.com/documentation/metal/synchronizing-a-managed-resource-in-macos With the storage mode: image On main branch: image That's a 44% reduction of memory usage. Release Notes: - Reduced memory usage on Apple-silicon Macs by using shared memory where appropriate --------- Signed-off-by: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> --- crates/gpui/src/platform/mac/metal_atlas.rs | 9 +++ .../gpui/src/platform/mac/metal_renderer.rs | 61 +++++++++++++++---- 2 files changed, 58 insertions(+), 12 deletions(-) diff --git a/crates/gpui/src/platform/mac/metal_atlas.rs b/crates/gpui/src/platform/mac/metal_atlas.rs index 8282530c5efdc13ca95a1f04c0f6ef1a23c8366c..9b43efe361a0816e32e858a44cafec66c42e7f85 100644 --- a/crates/gpui/src/platform/mac/metal_atlas.rs +++ b/crates/gpui/src/platform/mac/metal_atlas.rs @@ -15,6 +15,9 @@ pub(crate) struct MetalAtlas(Mutex); impl MetalAtlas { pub(crate) fn new(device: Device) -> Self { MetalAtlas(Mutex::new(MetalAtlasState { + // Shared memory can be used only if CPU and GPU share the same memory space. + // https://developer.apple.com/documentation/metal/setting-resource-storage-modes + unified_memory: device.has_unified_memory(), device: AssertSend(device), monochrome_textures: Default::default(), polychrome_textures: Default::default(), @@ -29,6 +32,7 @@ impl MetalAtlas { struct MetalAtlasState { device: AssertSend, + unified_memory: bool, monochrome_textures: AtlasTextureList, polychrome_textures: AtlasTextureList, tiles_by_key: FxHashMap, @@ -146,6 +150,11 @@ impl MetalAtlasState { } texture_descriptor.set_pixel_format(pixel_format); texture_descriptor.set_usage(usage); + texture_descriptor.set_storage_mode(if self.unified_memory { + metal::MTLStorageMode::Shared + } else { + metal::MTLStorageMode::Managed + }); let metal_texture = self.device.new_texture(&texture_descriptor); let texture_list = match kind { diff --git a/crates/gpui/src/platform/mac/metal_renderer.rs b/crates/gpui/src/platform/mac/metal_renderer.rs index 550041a0ccb4cd39bc7a86317d9540e806af2a28..6d7b82507fb581ec1f124e153e5bb91d3eaf9d25 100644 --- a/crates/gpui/src/platform/mac/metal_renderer.rs +++ b/crates/gpui/src/platform/mac/metal_renderer.rs @@ -76,12 +76,22 @@ impl InstanceBufferPool { self.buffers.clear(); } - pub(crate) fn acquire(&mut self, device: &metal::Device) -> InstanceBuffer { + pub(crate) fn acquire( + &mut self, + device: &metal::Device, + unified_memory: bool, + ) -> InstanceBuffer { let buffer = self.buffers.pop().unwrap_or_else(|| { - device.new_buffer( - self.buffer_size as u64, - MTLResourceOptions::StorageModeManaged, - ) + let options = if unified_memory { + MTLResourceOptions::StorageModeShared + // Buffers are write only which can benefit from the combined cache + // https://developer.apple.com/documentation/metal/mtlresourceoptions/cpucachemodewritecombined + | MTLResourceOptions::CPUCacheModeWriteCombined + } else { + MTLResourceOptions::StorageModeManaged + }; + + device.new_buffer(self.buffer_size as u64, options) }); InstanceBuffer { metal_buffer: buffer, @@ -99,6 +109,7 @@ impl InstanceBufferPool { pub(crate) struct MetalRenderer { device: metal::Device, layer: metal::MetalLayer, + unified_memory: bool, presents_with_transaction: bool, command_queue: CommandQueue, paths_rasterization_pipeline_state: metal::RenderPipelineState, @@ -179,6 +190,10 @@ impl MetalRenderer { output } + // Shared memory can be used only if CPU and GPU share the same memory space. + // https://developer.apple.com/documentation/metal/setting-resource-storage-modes + let unified_memory = device.has_unified_memory(); + let unit_vertices = [ to_float2_bits(point(0., 0.)), to_float2_bits(point(1., 0.)), @@ -190,7 +205,12 @@ impl MetalRenderer { let unit_vertices = device.new_buffer_with_data( unit_vertices.as_ptr() as *const c_void, mem::size_of_val(&unit_vertices) as u64, - MTLResourceOptions::StorageModeManaged, + if unified_memory { + MTLResourceOptions::StorageModeShared + | MTLResourceOptions::CPUCacheModeWriteCombined + } else { + MTLResourceOptions::StorageModeManaged + }, ); let paths_rasterization_pipeline_state = build_path_rasterization_pipeline_state( @@ -268,6 +288,7 @@ impl MetalRenderer { device, layer, presents_with_transaction: false, + unified_memory, command_queue, paths_rasterization_pipeline_state, path_sprites_pipeline_state, @@ -337,14 +358,23 @@ impl MetalRenderer { texture_descriptor.set_width(size.width.0 as u64); texture_descriptor.set_height(size.height.0 as u64); texture_descriptor.set_pixel_format(metal::MTLPixelFormat::BGRA8Unorm); + texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private); texture_descriptor .set_usage(metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead); self.path_intermediate_texture = Some(self.device.new_texture(&texture_descriptor)); if self.path_sample_count > 1 { + // https://developer.apple.com/documentation/metal/choosing-a-resource-storage-mode-for-apple-gpus + // Rendering MSAA textures are done in a single pass, so we can use memory-less storage on Apple Silicon + let storage_mode = if self.unified_memory { + metal::MTLStorageMode::Memoryless + } else { + metal::MTLStorageMode::Private + }; + let mut msaa_descriptor = texture_descriptor; msaa_descriptor.set_texture_type(metal::MTLTextureType::D2Multisample); - msaa_descriptor.set_storage_mode(metal::MTLStorageMode::Private); + msaa_descriptor.set_storage_mode(storage_mode); msaa_descriptor.set_sample_count(self.path_sample_count as _); self.path_intermediate_msaa_texture = Some(self.device.new_texture(&msaa_descriptor)); } else { @@ -378,7 +408,10 @@ impl MetalRenderer { }; loop { - let mut instance_buffer = self.instance_buffer_pool.lock().acquire(&self.device); + let mut instance_buffer = self + .instance_buffer_pool + .lock() + .acquire(&self.device, self.unified_memory); let command_buffer = self.draw_primitives(scene, &mut instance_buffer, drawable, viewport_size); @@ -550,10 +583,14 @@ impl MetalRenderer { command_encoder.end_encoding(); - instance_buffer.metal_buffer.did_modify_range(NSRange { - location: 0, - length: instance_offset as NSUInteger, - }); + if !self.unified_memory { + // Sync the instance buffer to the GPU + instance_buffer.metal_buffer.did_modify_range(NSRange { + location: 0, + length: instance_offset as NSUInteger, + }); + } + Ok(command_buffer.to_owned()) } From 523f093c8e5685cf4169eefa37072377cf7d7729 Mon Sep 17 00:00:00 2001 From: Mayank Verma Date: Tue, 16 Dec 2025 02:09:07 +0530 Subject: [PATCH 004/266] editor: Use Tree-sitter scopes to calculate quote autoclose (#44281) Closes #44233 Release Notes: - Fixed quote autoclose incorrectly counting quotes inside strings --------- Co-authored-by: Ben Kunkle --- crates/editor/src/editor.rs | 42 +++++++++++- crates/editor/src/editor_tests.rs | 109 ++++++++++++++++++++++++++++++ 2 files changed, 150 insertions(+), 1 deletion(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 3a6fc630e650ecfbd6f95cf0df30ac9f0228f050..797a2c9121d7742b4d3e6948c74eb61731b66856 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -4394,10 +4394,50 @@ impl Editor { && bracket_pair.start.len() == 1 { let target = bracket_pair.start.chars().next().unwrap(); + let mut byte_offset = 0u32; let current_line_count = snapshot .reversed_chars_at(selection.start) .take_while(|&c| c != '\n') - .filter(|&c| c == target) + .filter(|c| { + byte_offset += c.len_utf8() as u32; + if *c != target { + return false; + } + + let point = Point::new( + selection.start.row, + selection.start.column.saturating_sub(byte_offset), + ); + + let is_enabled = snapshot + .language_scope_at(point) + .and_then(|scope| { + scope + .brackets() + .find(|(pair, _)| { + pair.start == bracket_pair.start + }) + .map(|(_, enabled)| enabled) + }) + .unwrap_or(true); + + let is_delimiter = snapshot + .language_scope_at(Point::new( + point.row, + point.column + 1, + )) + .and_then(|scope| { + scope + .brackets() + .find(|(pair, _)| { + pair.start == bracket_pair.start + }) + .map(|(_, enabled)| !enabled) + }) + .unwrap_or(false); + + is_enabled && !is_delimiter + }) .count(); current_line_count % 2 == 1 } else { diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 9b04a6ea2bc7aef4e5a90b7d823e50857cff2172..a020b977c779a9b59a442170f7cc24f87ff54e2b 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -10869,6 +10869,115 @@ async fn test_autoclose_with_overrides(cx: &mut TestAppContext) { ); } +#[gpui::test] +async fn test_autoclose_quotes_with_scope_awareness(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + + let mut cx = EditorTestContext::new(cx).await; + let language = languages::language("python", tree_sitter_python::LANGUAGE.into()); + + cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx)); + + // Double quote inside single-quoted string + cx.set_state(indoc! {r#" + def main(): + items = ['"', ˇ] + "#}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("\"", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ['"', "ˇ"] + "#}); + + // Two double quotes inside single-quoted string + cx.set_state(indoc! {r#" + def main(): + items = ['""', ˇ] + "#}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("\"", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ['""', "ˇ"] + "#}); + + // Single quote inside double-quoted string + cx.set_state(indoc! {r#" + def main(): + items = ["'", ˇ] + "#}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("'", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ["'", 'ˇ'] + "#}); + + // Two single quotes inside double-quoted string + cx.set_state(indoc! {r#" + def main(): + items = ["''", ˇ] + "#}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("'", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ["''", 'ˇ'] + "#}); + + // Mixed quotes on same line + cx.set_state(indoc! {r#" + def main(): + items = ['"""', "'''''", ˇ] + "#}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("\"", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ['"""', "'''''", "ˇ"] + "#}); + cx.update_editor(|editor, window, cx| { + editor.move_right(&MoveRight, window, cx); + }); + cx.update_editor(|editor, window, cx| { + editor.handle_input(", ", window, cx); + }); + cx.update_editor(|editor, window, cx| { + editor.handle_input("'", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ['"""', "'''''", "", 'ˇ'] + "#}); +} + +#[gpui::test] +async fn test_autoclose_quotes_with_multibyte_characters(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + + let mut cx = EditorTestContext::new(cx).await; + let language = languages::language("python", tree_sitter_python::LANGUAGE.into()); + cx.update_buffer(|buffer, cx| buffer.set_language(Some(language), cx)); + + cx.set_state(indoc! {r#" + def main(): + items = ["🎉", ˇ] + "#}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("\"", window, cx); + }); + cx.assert_editor_state(indoc! {r#" + def main(): + items = ["🎉", "ˇ"] + "#}); +} + #[gpui::test] async fn test_surround_with_pair(cx: &mut TestAppContext) { init_test(cx, |_| {}); From fb574d88697afc2d3bd8469df004876402eea0f2 Mon Sep 17 00:00:00 2001 From: Michael Benfield Date: Mon, 15 Dec 2025 12:56:22 -0800 Subject: [PATCH 005/266] Inline assistant: Clear failure text when regenerating (#44911) Release Notes: - N/A --- crates/agent_ui/src/buffer_codegen.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/agent_ui/src/buffer_codegen.rs b/crates/agent_ui/src/buffer_codegen.rs index d8d0efda0fbd70153b02452f6281ee66b90eca92..25395278745a9eb18fbbfa1cd920af3e3b26e24d 100644 --- a/crates/agent_ui/src/buffer_codegen.rs +++ b/crates/agent_ui/src/buffer_codegen.rs @@ -409,6 +409,9 @@ impl CodegenAlternative { model: Arc, cx: &mut Context, ) -> Result<()> { + // Clear the model explanation since the user has started a new generation. + self.description = None; + if let Some(transformation_transaction_id) = self.transformation_transaction_id.take() { self.buffer.update(cx, |buffer, cx| { buffer.undo_transaction(transformation_transaction_id, cx); From 9e11aaec517c8ef51ad0b8a8255be25bce42fa31 Mon Sep 17 00:00:00 2001 From: pedroni <69983330+pedroni@users.noreply.github.com> Date: Mon, 15 Dec 2025 18:04:28 -0300 Subject: [PATCH 006/266] Add ZoomIn and ZoomOut actions for independent zoom control (#44587) Closes #14472 Introduces `workspace::ZoomIn` and `workspace::ZoomOut` actions that complement the existing `workspace::ToggleZoom` action. ZoomIn only zooms if not already zoomed, and ZoomOut only zooms out if currently zoomed. This enables composing zoom actions with `workspace::SendKeystrokes` for workflows like "focus terminal then zoom in".
Example usage

Example keybindings: ```json [ { "bindings": { "ctrl-cmd-,": "terminal_panel::ToggleFocus", "ctrl-cmd-.": "workspace::ZoomIn", } }, { "context": "Terminal", "bindings": { "cmd-.": "terminal_panel::ToggleFocus" } }, { "context": "!Terminal", "bindings": { "cmd-.": ["workspace::SendKeystrokes", "ctrl-cmd-, ctrl-cmd-."] } }, ] ``` Demo: https://github.com/user-attachments/assets/1b1deda9-7775-4d78-a281-dc9622032ead

Release Notes: - Added the actions: `workspace::ZoomIn` and `workspace::ZoomOut` that complement the existing `workspace::ToggleZoom` action --- crates/workspace/src/pane.rs | 23 ++++++- crates/workspace/src/workspace.rs | 103 ++++++++++++++++++++++++++++++ 2 files changed, 125 insertions(+), 1 deletion(-) diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index 50ba58926ece8818ac5a4f44103c3b86eb2b672d..338a858f3c774deb1cc0750c56afd678f4eadf4a 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -1,7 +1,7 @@ use crate::{ CloseWindow, NewFile, NewTerminal, OpenInTerminal, OpenOptions, OpenTerminal, OpenVisible, SplitDirection, ToggleFileFinder, ToggleProjectSymbols, ToggleZoom, Workspace, - WorkspaceItemBuilder, + WorkspaceItemBuilder, ZoomIn, ZoomOut, invalid_item_view::InvalidItemView, item::{ ActivateOnClose, ClosePosition, Item, ItemBufferKind, ItemHandle, ItemSettings, @@ -1306,6 +1306,25 @@ impl Pane { } } + pub fn zoom_in(&mut self, _: &ZoomIn, window: &mut Window, cx: &mut Context) { + if !self.can_toggle_zoom { + cx.propagate(); + } else if !self.zoomed && !self.items.is_empty() { + if !self.focus_handle.contains_focused(window, cx) { + cx.focus_self(window); + } + cx.emit(Event::ZoomIn); + } + } + + pub fn zoom_out(&mut self, _: &ZoomOut, _window: &mut Window, cx: &mut Context) { + if !self.can_toggle_zoom { + cx.propagate(); + } else if self.zoomed { + cx.emit(Event::ZoomOut); + } + } + pub fn activate_item( &mut self, index: usize, @@ -3900,6 +3919,8 @@ impl Render for Pane { cx.emit(Event::JoinAll); })) .on_action(cx.listener(Pane::toggle_zoom)) + .on_action(cx.listener(Pane::zoom_in)) + .on_action(cx.listener(Pane::zoom_out)) .on_action(cx.listener(Self::navigate_backward)) .on_action(cx.listener(Self::navigate_forward)) .on_action( diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 0a50faf867c2647874c1c7bb6d7887da6fee1388..7dfa5d634c73ee639be1e24373ca86b548180547 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -272,6 +272,10 @@ actions!( ToggleRightDock, /// Toggles zoom on the active pane. ToggleZoom, + /// Zooms in on the active pane. + ZoomIn, + /// Zooms out of the active pane. + ZoomOut, /// Stops following a collaborator. Unfollow, /// Restores the banner. @@ -9594,6 +9598,105 @@ mod tests { }); } + #[gpui::test] + async fn test_pane_zoom_in_out(cx: &mut TestAppContext) { + init_test(cx); + let fs = FakeFs::new(cx.executor()); + + let project = Project::test(fs, [], cx).await; + let (workspace, cx) = + cx.add_window_view(|window, cx| Workspace::test_new(project, window, cx)); + + let pane = workspace.update_in(cx, |workspace, _window, _cx| { + workspace.active_pane().clone() + }); + + // Add an item to the pane so it can be zoomed + workspace.update_in(cx, |workspace, window, cx| { + let item = cx.new(TestItem::new); + workspace.add_item(pane.clone(), Box::new(item), None, true, true, window, cx); + }); + + // Initially not zoomed + workspace.update_in(cx, |workspace, _window, cx| { + assert!(!pane.read(cx).is_zoomed(), "Pane starts unzoomed"); + assert!( + workspace.zoomed.is_none(), + "Workspace should track no zoomed pane" + ); + assert!(pane.read(cx).items_len() > 0, "Pane should have items"); + }); + + // Zoom In + pane.update_in(cx, |pane, window, cx| { + pane.zoom_in(&crate::ZoomIn, window, cx); + }); + + workspace.update_in(cx, |workspace, window, cx| { + assert!( + pane.read(cx).is_zoomed(), + "Pane should be zoomed after ZoomIn" + ); + assert!( + workspace.zoomed.is_some(), + "Workspace should track the zoomed pane" + ); + assert!( + pane.read(cx).focus_handle(cx).contains_focused(window, cx), + "ZoomIn should focus the pane" + ); + }); + + // Zoom In again is a no-op + pane.update_in(cx, |pane, window, cx| { + pane.zoom_in(&crate::ZoomIn, window, cx); + }); + + workspace.update_in(cx, |workspace, window, cx| { + assert!(pane.read(cx).is_zoomed(), "Second ZoomIn keeps pane zoomed"); + assert!( + workspace.zoomed.is_some(), + "Workspace still tracks zoomed pane" + ); + assert!( + pane.read(cx).focus_handle(cx).contains_focused(window, cx), + "Pane remains focused after repeated ZoomIn" + ); + }); + + // Zoom Out + pane.update_in(cx, |pane, window, cx| { + pane.zoom_out(&crate::ZoomOut, window, cx); + }); + + workspace.update_in(cx, |workspace, _window, cx| { + assert!( + !pane.read(cx).is_zoomed(), + "Pane should unzoom after ZoomOut" + ); + assert!( + workspace.zoomed.is_none(), + "Workspace clears zoom tracking after ZoomOut" + ); + }); + + // Zoom Out again is a no-op + pane.update_in(cx, |pane, window, cx| { + pane.zoom_out(&crate::ZoomOut, window, cx); + }); + + workspace.update_in(cx, |workspace, _window, cx| { + assert!( + !pane.read(cx).is_zoomed(), + "Second ZoomOut keeps pane unzoomed" + ); + assert!( + workspace.zoomed.is_none(), + "Workspace remains without zoomed pane" + ); + }); + } + #[gpui::test] async fn test_toggle_all_docks(cx: &mut gpui::TestAppContext) { init_test(cx); From ee6469d60e4ae1de2e84239db836c767d34958ef Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Mon, 15 Dec 2025 22:13:25 +0100 Subject: [PATCH 007/266] project: Clear worktree settings when worktrees get removed (#44913) Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/project/src/project_settings.rs | 21 ++++++++++++++------- crates/settings/src/settings_store.rs | 11 +++++++++++ 2 files changed, 25 insertions(+), 7 deletions(-) diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs index b7dadc52f74f4800741f5cf537ac9f52c09643e3..8494eac5b33e7e1f231f9c62010c49aec345229f 100644 --- a/crates/project/src/project_settings.rs +++ b/crates/project/src/project_settings.rs @@ -792,13 +792,20 @@ impl SettingsObserver { event: &WorktreeStoreEvent, cx: &mut Context, ) { - if let WorktreeStoreEvent::WorktreeAdded(worktree) = event { - cx.subscribe(worktree, |this, worktree, event, cx| { - if let worktree::Event::UpdatedEntries(changes) = event { - this.update_local_worktree_settings(&worktree, changes, cx) - } - }) - .detach() + match event { + WorktreeStoreEvent::WorktreeAdded(worktree) => cx + .subscribe(worktree, |this, worktree, event, cx| { + if let worktree::Event::UpdatedEntries(changes) = event { + this.update_local_worktree_settings(&worktree, changes, cx) + } + }) + .detach(), + WorktreeStoreEvent::WorktreeRemoved(_, worktree_id) => { + cx.update_global::(|store, cx| { + store.clear_local_settings(*worktree_id, cx).log_err(); + }); + } + _ => {} } } diff --git a/crates/settings/src/settings_store.rs b/crates/settings/src/settings_store.rs index 72e2d3ef099659c5ad27e7f1aaafaee24354d4a9..abd45a141647f6ba13708c549188a22988c78069 100644 --- a/crates/settings/src/settings_store.rs +++ b/crates/settings/src/settings_store.rs @@ -247,6 +247,7 @@ pub trait AnySettingValue: 'static + Send + Sync { fn all_local_values(&self) -> Vec<(WorktreeId, Arc, &dyn Any)>; fn set_global_value(&mut self, value: Box); fn set_local_value(&mut self, root_id: WorktreeId, path: Arc, value: Box); + fn clear_local_values(&mut self, root_id: WorktreeId); } /// Parameters that are used when generating some JSON schemas at runtime. @@ -971,6 +972,11 @@ impl SettingsStore { pub fn clear_local_settings(&mut self, root_id: WorktreeId, cx: &mut App) -> Result<()> { self.local_settings .retain(|(worktree_id, _), _| worktree_id != &root_id); + self.raw_editorconfig_settings + .retain(|(worktree_id, _), _| worktree_id != &root_id); + for setting_value in self.setting_values.values_mut() { + setting_value.clear_local_values(root_id); + } self.recompute_values(Some((root_id, RelPath::empty())), cx); Ok(()) } @@ -1338,6 +1344,11 @@ impl AnySettingValue for SettingValue { Err(ix) => self.local_values.insert(ix, (root_id, path, value)), } } + + fn clear_local_values(&mut self, root_id: WorktreeId) { + self.local_values + .retain(|(worktree_id, _, _)| *worktree_id != root_id); + } } #[cfg(test)] From c7a1852e366dd2df779e652ad86e4df4a2626524 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Mon, 15 Dec 2025 22:14:04 +0100 Subject: [PATCH 008/266] collab: Add `dependabot[bot]` to the `GET /contributor` endpoint (#44919) This PR adds the `dependabot[bot]` user to the `GET /contributor` endpoint so that it passes the CLA check. Release Notes: - N/A --- crates/collab/src/api/contributors.rs | 40 +++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/crates/collab/src/api/contributors.rs b/crates/collab/src/api/contributors.rs index 574667c723dce62b905e3d2a0b34de1ca4c88c8e..549a9346b57c0a9801fe791826e9346e3f0350df 100644 --- a/crates/collab/src/api/contributors.rs +++ b/crates/collab/src/api/contributors.rs @@ -54,6 +54,16 @@ async fn check_is_contributor( ) -> Result> { let params = params.into_contributor_selector()?; + if Dependabot::is_dependabot(¶ms) { + return Ok(Json(CheckIsContributorResponse { + signed_at: Some( + Dependabot::created_at() + .and_utc() + .to_rfc3339_opts(SecondsFormat::Millis, true), + ), + })); + } + if RenovateBot::is_renovate_bot(¶ms) { return Ok(Json(CheckIsContributorResponse { signed_at: Some( @@ -83,6 +93,36 @@ async fn check_is_contributor( })) } +/// The Dependabot bot GitHub user (`dependabot[bot]`). +/// +/// https://api.github.com/users/dependabot[bot] +struct Dependabot; + +impl Dependabot { + const LOGIN: &'static str = "dependabot[bot]"; + const USER_ID: i32 = 49699333; + + /// Returns the `created_at` timestamp for the Dependabot bot user. + fn created_at() -> &'static NaiveDateTime { + static CREATED_AT: OnceLock = OnceLock::new(); + CREATED_AT.get_or_init(|| { + chrono::DateTime::parse_from_rfc3339("2019-04-16T22:34:25Z") + .expect("failed to parse 'created_at' for 'dependabot[bot]'") + .naive_utc() + }) + } + + /// Returns whether the given contributor selector corresponds to the Dependabot bot user. + fn is_dependabot(contributor: &ContributorSelector) -> bool { + match contributor { + ContributorSelector::GitHubLogin { github_login } => github_login == Self::LOGIN, + ContributorSelector::GitHubUserId { github_user_id } => { + github_user_id == &Self::USER_ID + } + } + } +} + /// The Renovate bot GitHub user (`renovate[bot]`). /// /// https://api.github.com/users/renovate[bot] From 47a6bd22e4335d6ebe4df0e051b672790f2602e2 Mon Sep 17 00:00:00 2001 From: Matt Miller Date: Mon, 15 Dec 2025 15:37:00 -0600 Subject: [PATCH 009/266] Terminal ANSI colors (#44912) Closes #38992 Release Notes: - N/A --------- Co-authored-by: dangooddd --- assets/themes/one/one.json | 104 ++++++++++++++++++------------------- 1 file changed, 52 insertions(+), 52 deletions(-) diff --git a/assets/themes/one/one.json b/assets/themes/one/one.json index c72c92471761c473bea05edc37b1f96f18b2f683..13f94991ad44fc997144a3d44527dcbce5231504 100644 --- a/assets/themes/one/one.json +++ b/assets/themes/one/one.json @@ -68,34 +68,34 @@ "editor.active_wrap_guide": "#c8ccd41a", "editor.document_highlight.read_background": "#74ade81a", "editor.document_highlight.write_background": "#555a6366", - "terminal.background": "#282c33ff", - "terminal.foreground": "#dce0e5ff", + "terminal.background": "#282c34ff", + "terminal.foreground": "#abb2bfff", "terminal.bright_foreground": "#dce0e5ff", - "terminal.dim_foreground": "#282c33ff", - "terminal.ansi.black": "#282c33ff", - "terminal.ansi.bright_black": "#525561ff", - "terminal.ansi.dim_black": "#dce0e5ff", - "terminal.ansi.red": "#d07277ff", - "terminal.ansi.bright_red": "#673a3cff", - "terminal.ansi.dim_red": "#eab7b9ff", - "terminal.ansi.green": "#a1c181ff", - "terminal.ansi.bright_green": "#4d6140ff", - "terminal.ansi.dim_green": "#d1e0bfff", - "terminal.ansi.yellow": "#dec184ff", - "terminal.ansi.bright_yellow": "#e5c07bff", - "terminal.ansi.dim_yellow": "#f1dfc1ff", - "terminal.ansi.blue": "#74ade8ff", - "terminal.ansi.bright_blue": "#385378ff", - "terminal.ansi.dim_blue": "#bed5f4ff", - "terminal.ansi.magenta": "#b477cfff", - "terminal.ansi.bright_magenta": "#d6b4e4ff", - "terminal.ansi.dim_magenta": "#612a79ff", - "terminal.ansi.cyan": "#6eb4bfff", - "terminal.ansi.bright_cyan": "#3a565bff", - "terminal.ansi.dim_cyan": "#b9d9dfff", - "terminal.ansi.white": "#dce0e5ff", + "terminal.dim_foreground": "#636d83ff", + "terminal.ansi.black": "#282c34ff", + "terminal.ansi.bright_black": "#636d83ff", + "terminal.ansi.dim_black": "#3b3f4aff", + "terminal.ansi.red": "#e06c75ff", + "terminal.ansi.bright_red": "#EA858Bff", + "terminal.ansi.dim_red": "#a7545aff", + "terminal.ansi.green": "#98c379ff", + "terminal.ansi.bright_green": "#AAD581ff", + "terminal.ansi.dim_green": "#6d8f59ff", + "terminal.ansi.yellow": "#e5c07bff", + "terminal.ansi.bright_yellow": "#FFD885ff", + "terminal.ansi.dim_yellow": "#b8985bff", + "terminal.ansi.blue": "#61afefff", + "terminal.ansi.bright_blue": "#85C1FFff", + "terminal.ansi.dim_blue": "#457cadff", + "terminal.ansi.magenta": "#c678ddff", + "terminal.ansi.bright_magenta": "#D398EBff", + "terminal.ansi.dim_magenta": "#8d54a0ff", + "terminal.ansi.cyan": "#56b6c2ff", + "terminal.ansi.bright_cyan": "#6ED5DEff", + "terminal.ansi.dim_cyan": "#3c818aff", + "terminal.ansi.white": "#abb2bfff", "terminal.ansi.bright_white": "#fafafaff", - "terminal.ansi.dim_white": "#575d65ff", + "terminal.ansi.dim_white": "#8f969bff", "link_text.hover": "#74ade8ff", "version_control.added": "#27a657ff", "version_control.modified": "#d3b020ff", @@ -473,33 +473,33 @@ "editor.document_highlight.read_background": "#5c78e225", "editor.document_highlight.write_background": "#a3a3a466", "terminal.background": "#fafafaff", - "terminal.foreground": "#242529ff", - "terminal.bright_foreground": "#242529ff", - "terminal.dim_foreground": "#fafafaff", - "terminal.ansi.black": "#242529ff", - "terminal.ansi.bright_black": "#747579ff", - "terminal.ansi.dim_black": "#97979aff", - "terminal.ansi.red": "#d36151ff", - "terminal.ansi.bright_red": "#f0b0a4ff", - "terminal.ansi.dim_red": "#6f312aff", - "terminal.ansi.green": "#669f59ff", - "terminal.ansi.bright_green": "#b2cfa9ff", - "terminal.ansi.dim_green": "#354d2eff", - "terminal.ansi.yellow": "#dec184ff", - "terminal.ansi.bright_yellow": "#826221ff", - "terminal.ansi.dim_yellow": "#786441ff", - "terminal.ansi.blue": "#5c78e2ff", - "terminal.ansi.bright_blue": "#b5baf2ff", - "terminal.ansi.dim_blue": "#2d3d75ff", - "terminal.ansi.magenta": "#984ea5ff", - "terminal.ansi.bright_magenta": "#cea6d3ff", - "terminal.ansi.dim_magenta": "#4b2a50ff", - "terminal.ansi.cyan": "#3a82b7ff", - "terminal.ansi.bright_cyan": "#a3bedaff", - "terminal.ansi.dim_cyan": "#254058ff", - "terminal.ansi.white": "#fafafaff", + "terminal.foreground": "#2a2c33ff", + "terminal.bright_foreground": "#2a2c33ff", + "terminal.dim_foreground": "#bbbbbbff", + "terminal.ansi.black": "#000000ff", + "terminal.ansi.bright_black": "#000000ff", + "terminal.ansi.dim_black": "#555555ff", + "terminal.ansi.red": "#de3e35ff", + "terminal.ansi.bright_red": "#de3e35ff", + "terminal.ansi.dim_red": "#9c2b26ff", + "terminal.ansi.green": "#3f953aff", + "terminal.ansi.bright_green": "#3f953aff", + "terminal.ansi.dim_green": "#2b6927ff", + "terminal.ansi.yellow": "#d2b67cff", + "terminal.ansi.bright_yellow": "#d2b67cff", + "terminal.ansi.dim_yellow": "#a48c5aff", + "terminal.ansi.blue": "#2f5af3ff", + "terminal.ansi.bright_blue": "#2f5af3ff", + "terminal.ansi.dim_blue": "#2140abff", + "terminal.ansi.magenta": "#950095ff", + "terminal.ansi.bright_magenta": "#a00095ff", + "terminal.ansi.dim_magenta": "#6a006aff", + "terminal.ansi.cyan": "#3f953aff", + "terminal.ansi.bright_cyan": "#3f953aff", + "terminal.ansi.dim_cyan": "#2b6927ff", + "terminal.ansi.white": "#bbbbbbff", "terminal.ansi.bright_white": "#ffffffff", - "terminal.ansi.dim_white": "#aaaaaaff", + "terminal.ansi.dim_white": "#888888ff", "link_text.hover": "#5c78e2ff", "version_control.added": "#27a657ff", "version_control.modified": "#d3b020ff", From faef5c9eace02d0e8da87411b1ad4b01ae9e8c12 Mon Sep 17 00:00:00 2001 From: Kunall Banerjee Date: Mon, 15 Dec 2025 17:04:03 -0500 Subject: [PATCH 010/266] docs: Drop deprecated key from settings for Agent Panel (#44923) The `version` key was deprecated a while ago. Release Notes: - N/A --- docs/src/git.md | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/src/git.md b/docs/src/git.md index d562eb4d0a3b07f4de7df1b0831f6e91a2767c1d..8a94a79973b390f1d4e8075469b610d51b6f2016 100644 --- a/docs/src/git.md +++ b/docs/src/git.md @@ -145,7 +145,6 @@ You can specify your preferred model to use by providing a `commit_message_model ```json [settings] { "agent": { - "version": "2", "commit_message_model": { "provider": "anthropic", "model": "claude-3-5-haiku" From eceece8ce5e98d59ab30be8a0e50677b22c82515 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Mon, 15 Dec 2025 17:11:42 -0500 Subject: [PATCH 011/266] docs: Update links to account page (#44924) This PR updates the links to the account page to point to the Dashboard. Release Notes: - N/A --- docs/src/ai/billing.md | 4 ++-- docs/src/ai/plans-and-usage.md | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/src/ai/billing.md b/docs/src/ai/billing.md index 64ff871ce1b629fad72d4ddd6f9c8f42f2bf92da..788c0c1cf7cb0bfd64bdd83812e1e62bf51abf88 100644 --- a/docs/src/ai/billing.md +++ b/docs/src/ai/billing.md @@ -5,7 +5,7 @@ For invoice-based billing, a Business plan is required. Contact [sales@zed.dev]( ## Billing Information {#settings} -You can access billing information and settings at [zed.dev/account](https://zed.dev/account). +You can access billing information and settings at [dashboard.zed.dev/account](https://dashboard.zed.dev/account). Most of the page embeds information from our invoicing/metering partner, Orb (we're planning on a more native experience soon!). ## Billing Cycles {#billing-cycles} @@ -28,7 +28,7 @@ If payment of an invoice fails, Zed will block usage of our hosted models until ## Invoice History {#invoice-history} -You can access your invoice history by navigating to [zed.dev/account](https://zed.dev/account) and clicking `Invoice history` within the embedded Orb portal. +You can access your invoice history by navigating to [dashboard.zed.dev/account](https://dashboard.zed.dev/account) and clicking `Invoice history` within the embedded Orb portal. If you require historical Stripe invoices, email [billing-support@zed.dev](mailto:billing-support@zed.dev) diff --git a/docs/src/ai/plans-and-usage.md b/docs/src/ai/plans-and-usage.md index fc59a894aacd524a10e31b65ababd4f8d79e3b8e..63f72211aa70b19b820fb9b368d47a3b008b726d 100644 --- a/docs/src/ai/plans-and-usage.md +++ b/docs/src/ai/plans-and-usage.md @@ -12,11 +12,11 @@ Usage of Zed's hosted models is measured on a token basis, converted to dollars Zed Pro comes with $5 of monthly dollar credit. A trial of Zed Pro includes $20 of credit, usable for 14 days. Monthly included credit resets on your monthly billing date. -To view your current usage, you can visit your account at [zed.dev/account](https://zed.dev/account). Information from our metering and billing provider, Orb, is embedded on that page. +To view your current usage, you can visit your account at [dashboard.zed.dev/account](https://dashboard.zed.dev/account). Information from our metering and billing provider, Orb, is embedded on that page. ## Spend Limits {#usage-spend-limits} -At the top of [the Account page](https://zed.dev/account), you'll find an input for `Maximum Token Spend`. The dollar amount here specifies your _monthly_ limit for spend on tokens, _not counting_ the $5/month included with your Pro subscription. +At the top of [the Account page](https://dashboard.zed.dev/account), you'll find an input for `Maximum Token Spend`. The dollar amount here specifies your _monthly_ limit for spend on tokens, _not counting_ the $5/month included with your Pro subscription. The default value for all Pro users is $10, for a total monthly spend with Zed of $20 ($10 for your Pro subscription, $10 in incremental token spend). This can be set to $0 to limit your spend with Zed to exactly $10/month. If you adjust this limit _higher_ than $10 and consume more than $10 of incremental token spend, you'll be billed via [threshold billing](./billing.md#threshold-billing). From 5987dff7e481f2c3fcc6fc89ffd6ae254bfe638f Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Mon, 15 Dec 2025 15:15:09 -0700 Subject: [PATCH 012/266] Add save_file and restore_file_from_disk agent tools (#44789) Release Notes: - Added `save_file` and `restore_file_from_disk` tools to the agent, allowing it to resolve dirty buffer conflicts when editing files. When the agent encounters a file with unsaved changes, it will now ask whether you want to keep or discard those changes before proceeding. --- crates/agent/src/thread.rs | 5 +- crates/agent/src/tools.rs | 8 +- crates/agent/src/tools/edit_file_tool.rs | 23 +- .../src/tools/restore_file_from_disk_tool.rs | 352 ++++++++++++++++++ crates/agent/src/tools/save_file_tool.rs | 351 +++++++++++++++++ 5 files changed, 732 insertions(+), 7 deletions(-) create mode 100644 crates/agent/src/tools/restore_file_from_disk_tool.rs create mode 100644 crates/agent/src/tools/save_file_tool.rs diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index a51dd3bf9fd5213c88a0ab56ef9ec9b563a90756..b61c0ad0840475c3b5f6d4c0a7082a26d4d44a58 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2,7 +2,8 @@ use crate::{ ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DbLanguageModel, DbThread, DeletePathTool, DiagnosticsTool, EditFileTool, FetchTool, FindPathTool, GrepTool, ListDirectoryTool, MovePathTool, NowTool, OpenTool, ProjectSnapshot, ReadFileTool, - SystemPromptTemplate, Template, Templates, TerminalTool, ThinkingTool, WebSearchTool, + RestoreFileFromDiskTool, SaveFileTool, SystemPromptTemplate, Template, Templates, TerminalTool, + ThinkingTool, WebSearchTool, }; use acp_thread::{MentionUri, UserMessageId}; use action_log::ActionLog; @@ -1002,6 +1003,8 @@ impl Thread { self.project.clone(), self.action_log.clone(), )); + self.add_tool(SaveFileTool::new(self.project.clone())); + self.add_tool(RestoreFileFromDiskTool::new(self.project.clone())); self.add_tool(TerminalTool::new(self.project.clone(), environment)); self.add_tool(ThinkingTool); self.add_tool(WebSearchTool); diff --git a/crates/agent/src/tools.rs b/crates/agent/src/tools.rs index 62a52998a705e11d1c9e69cbade7f427cc9cfc32..358903a32baa5ead9b073642015e6829501307a2 100644 --- a/crates/agent/src/tools.rs +++ b/crates/agent/src/tools.rs @@ -4,7 +4,6 @@ mod create_directory_tool; mod delete_path_tool; mod diagnostics_tool; mod edit_file_tool; - mod fetch_tool; mod find_path_tool; mod grep_tool; @@ -13,6 +12,8 @@ mod move_path_tool; mod now_tool; mod open_tool; mod read_file_tool; +mod restore_file_from_disk_tool; +mod save_file_tool; mod terminal_tool; mod thinking_tool; @@ -27,7 +28,6 @@ pub use create_directory_tool::*; pub use delete_path_tool::*; pub use diagnostics_tool::*; pub use edit_file_tool::*; - pub use fetch_tool::*; pub use find_path_tool::*; pub use grep_tool::*; @@ -36,6 +36,8 @@ pub use move_path_tool::*; pub use now_tool::*; pub use open_tool::*; pub use read_file_tool::*; +pub use restore_file_from_disk_tool::*; +pub use save_file_tool::*; pub use terminal_tool::*; pub use thinking_tool::*; @@ -92,6 +94,8 @@ tools! { NowTool, OpenTool, ReadFileTool, + RestoreFileFromDiskTool, + SaveFileTool, TerminalTool, ThinkingTool, WebSearchTool, diff --git a/crates/agent/src/tools/edit_file_tool.rs b/crates/agent/src/tools/edit_file_tool.rs index 0ab99426e2e9645adf3f837d21c28dc285ab6ea2..c08300e19541cad49033093f0d2bbe3a5b233683 100644 --- a/crates/agent/src/tools/edit_file_tool.rs +++ b/crates/agent/src/tools/edit_file_tool.rs @@ -316,9 +316,9 @@ impl AgentTool for EditFileTool { // Check for unsaved changes first - these indicate modifications we don't know about if is_dirty { anyhow::bail!( - "This file cannot be written to because it has unsaved changes. \ - Please end the current conversation immediately by telling the user you want to write to this file (mention its path explicitly) but you can't write to it because it has unsaved changes. \ - Ask the user to save that buffer's changes and to inform you when it's ok to proceed." + "This file has unsaved changes. Ask the user whether they want to keep or discard those changes. \ + If they want to keep them, ask for confirmation then use the save_file tool to save the file, then retry this edit. \ + If they want to discard them, ask for confirmation then use the restore_file_from_disk tool to restore the on-disk contents, then retry this edit." ); } @@ -2202,9 +2202,24 @@ mod tests { assert!(result.is_err(), "Edit should fail when buffer is dirty"); let error_msg = result.unwrap_err().to_string(); assert!( - error_msg.contains("cannot be written to because it has unsaved changes"), + error_msg.contains("This file has unsaved changes."), "Error should mention unsaved changes, got: {}", error_msg ); + assert!( + error_msg.contains("keep or discard"), + "Error should ask whether to keep or discard changes, got: {}", + error_msg + ); + assert!( + error_msg.contains("save_file"), + "Error should reference save_file tool, got: {}", + error_msg + ); + assert!( + error_msg.contains("restore_file_from_disk"), + "Error should reference restore_file_from_disk tool, got: {}", + error_msg + ); } } diff --git a/crates/agent/src/tools/restore_file_from_disk_tool.rs b/crates/agent/src/tools/restore_file_from_disk_tool.rs new file mode 100644 index 0000000000000000000000000000000000000000..f5723f6ee3ee46144152dd3ed2939ab2cfaca9c0 --- /dev/null +++ b/crates/agent/src/tools/restore_file_from_disk_tool.rs @@ -0,0 +1,352 @@ +use agent_client_protocol as acp; +use anyhow::Result; +use collections::FxHashSet; +use gpui::{App, Entity, SharedString, Task}; +use language::Buffer; +use project::Project; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use std::sync::Arc; + +use crate::{AgentTool, ToolCallEventStream}; + +/// Discards unsaved changes in open buffers by reloading file contents from disk. +/// +/// Use this tool when: +/// - You attempted to edit files but they have unsaved changes the user does not want to keep. +/// - You want to reset files to the on-disk state before retrying an edit. +/// +/// Only use this tool after asking the user for permission, because it will discard unsaved changes. +#[derive(Debug, Serialize, Deserialize, JsonSchema)] +pub struct RestoreFileFromDiskToolInput { + /// The paths of the files to restore from disk. + pub paths: Vec, +} + +pub struct RestoreFileFromDiskTool { + project: Entity, +} + +impl RestoreFileFromDiskTool { + pub fn new(project: Entity) -> Self { + Self { project } + } +} + +impl AgentTool for RestoreFileFromDiskTool { + type Input = RestoreFileFromDiskToolInput; + type Output = String; + + fn name() -> &'static str { + "restore_file_from_disk" + } + + fn kind() -> acp::ToolKind { + acp::ToolKind::Other + } + + fn initial_title( + &self, + input: Result, + _cx: &mut App, + ) -> SharedString { + match input { + Ok(input) if input.paths.len() == 1 => "Restore file from disk".into(), + Ok(input) => format!("Restore {} files from disk", input.paths.len()).into(), + Err(_) => "Restore files from disk".into(), + } + } + + fn run( + self: Arc, + input: Self::Input, + _event_stream: ToolCallEventStream, + cx: &mut App, + ) -> Task> { + let project = self.project.clone(); + let input_paths = input.paths; + + cx.spawn(async move |cx| { + let mut buffers_to_reload: FxHashSet> = FxHashSet::default(); + + let mut restored_paths: Vec = Vec::new(); + let mut clean_paths: Vec = Vec::new(); + let mut not_found_paths: Vec = Vec::new(); + let mut open_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut dirty_check_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut reload_errors: Vec = Vec::new(); + + for path in input_paths { + let project_path = + project.read_with(cx, |project, cx| project.find_project_path(&path, cx)); + + let project_path = match project_path { + Ok(Some(project_path)) => project_path, + Ok(None) => { + not_found_paths.push(path); + continue; + } + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let open_buffer_task = + project.update(cx, |project, cx| project.open_buffer(project_path, cx)); + + let buffer = match open_buffer_task { + Ok(task) => match task.await { + Ok(buffer) => buffer, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let is_dirty = match buffer.read_with(cx, |buffer, _| buffer.is_dirty()) { + Ok(is_dirty) => is_dirty, + Err(error) => { + dirty_check_errors.push((path, error.to_string())); + continue; + } + }; + + if is_dirty { + buffers_to_reload.insert(buffer); + restored_paths.push(path); + } else { + clean_paths.push(path); + } + } + + if !buffers_to_reload.is_empty() { + let reload_task = project.update(cx, |project, cx| { + project.reload_buffers(buffers_to_reload, true, cx) + }); + + match reload_task { + Ok(task) => { + if let Err(error) = task.await { + reload_errors.push(error.to_string()); + } + } + Err(error) => { + reload_errors.push(error.to_string()); + } + } + } + + let mut lines: Vec = Vec::new(); + + if !restored_paths.is_empty() { + lines.push(format!("Restored {} file(s).", restored_paths.len())); + } + if !clean_paths.is_empty() { + lines.push(format!("{} clean.", clean_paths.len())); + } + + if !not_found_paths.is_empty() { + lines.push(format!("Not found ({}):", not_found_paths.len())); + for path in ¬_found_paths { + lines.push(format!("- {}", path.display())); + } + } + if !open_errors.is_empty() { + lines.push(format!("Open failed ({}):", open_errors.len())); + for (path, error) in &open_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !dirty_check_errors.is_empty() { + lines.push(format!( + "Dirty check failed ({}):", + dirty_check_errors.len() + )); + for (path, error) in &dirty_check_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !reload_errors.is_empty() { + lines.push(format!("Reload failed ({}):", reload_errors.len())); + for error in &reload_errors { + lines.push(format!("- {}", error)); + } + } + + if lines.is_empty() { + Ok("No paths provided.".to_string()) + } else { + Ok(lines.join("\n")) + } + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use fs::Fs; + use gpui::TestAppContext; + use language::LineEnding; + use project::FakeFs; + use serde_json::json; + use settings::SettingsStore; + use util::path; + + fn init_test(cx: &mut TestAppContext) { + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + }); + } + + #[gpui::test] + async fn test_restore_file_from_disk_output_and_effects(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + "/root", + json!({ + "dirty.txt": "on disk: dirty\n", + "clean.txt": "on disk: clean\n", + }), + ) + .await; + + let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await; + let tool = Arc::new(RestoreFileFromDiskTool::new(project.clone())); + + // Make dirty.txt dirty in-memory by saving different content into the buffer without saving to disk. + let dirty_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/dirty.txt", cx) + .expect("dirty.txt should exist in project") + }); + + let dirty_buffer = project + .update(cx, |project, cx| { + project.open_buffer(dirty_project_path, cx) + }) + .await + .unwrap(); + dirty_buffer.update(cx, |buffer, cx| { + buffer.edit([(0..buffer.len(), "in memory: dirty\n")], None, cx); + }); + assert!( + dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should be dirty before restore" + ); + + // Ensure clean.txt is opened but remains clean. + let clean_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/clean.txt", cx) + .expect("clean.txt should exist in project") + }); + + let clean_buffer = project + .update(cx, |project, cx| { + project.open_buffer(clean_project_path, cx) + }) + .await + .unwrap(); + assert!( + !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "clean.txt buffer should start clean" + ); + + let output = cx + .update(|cx| { + tool.clone().run( + RestoreFileFromDiskToolInput { + paths: vec![ + PathBuf::from("root/dirty.txt"), + PathBuf::from("root/clean.txt"), + ], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + + // Output should mention restored + clean. + assert!( + output.contains("Restored 1 file(s)."), + "expected restored count line, got:\n{output}" + ); + assert!( + output.contains("1 clean."), + "expected clean count line, got:\n{output}" + ); + + // Effect: dirty buffer should be restored back to disk content and become clean. + let dirty_text = dirty_buffer.read_with(cx, |buffer, _| buffer.text()); + assert_eq!( + dirty_text, "on disk: dirty\n", + "dirty.txt buffer should be restored to disk contents" + ); + assert!( + !dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should not be dirty after restore" + ); + + // Disk contents should be unchanged (restore-from-disk should not write). + let disk_dirty = fs.load(path!("/root/dirty.txt").as_ref()).await.unwrap(); + assert_eq!(disk_dirty, "on disk: dirty\n"); + + // Sanity: clean buffer should remain clean and unchanged. + let clean_text = clean_buffer.read_with(cx, |buffer, _| buffer.text()); + assert_eq!(clean_text, "on disk: clean\n"); + assert!( + !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "clean.txt buffer should remain clean" + ); + + // Test empty paths case. + let output = cx + .update(|cx| { + tool.clone().run( + RestoreFileFromDiskToolInput { paths: vec![] }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert_eq!(output, "No paths provided."); + + // Test not-found path case (path outside the project root). + let output = cx + .update(|cx| { + tool.clone().run( + RestoreFileFromDiskToolInput { + paths: vec![PathBuf::from("nonexistent/path.txt")], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert!( + output.contains("Not found (1):"), + "expected not-found header line, got:\n{output}" + ); + assert!( + output.contains("- nonexistent/path.txt"), + "expected not-found path bullet, got:\n{output}" + ); + + let _ = LineEnding::Unix; // keep import used if the buffer edit API changes + } +} diff --git a/crates/agent/src/tools/save_file_tool.rs b/crates/agent/src/tools/save_file_tool.rs new file mode 100644 index 0000000000000000000000000000000000000000..429352200109c52303c9f6f94a28a49136af1a61 --- /dev/null +++ b/crates/agent/src/tools/save_file_tool.rs @@ -0,0 +1,351 @@ +use agent_client_protocol as acp; +use anyhow::Result; +use collections::FxHashSet; +use gpui::{App, Entity, SharedString, Task}; +use language::Buffer; +use project::Project; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use std::sync::Arc; + +use crate::{AgentTool, ToolCallEventStream}; + +/// Saves files that have unsaved changes. +/// +/// Use this tool when you need to edit files but they have unsaved changes that must be saved first. +/// Only use this tool after asking the user for permission to save their unsaved changes. +#[derive(Debug, Serialize, Deserialize, JsonSchema)] +pub struct SaveFileToolInput { + /// The paths of the files to save. + pub paths: Vec, +} + +pub struct SaveFileTool { + project: Entity, +} + +impl SaveFileTool { + pub fn new(project: Entity) -> Self { + Self { project } + } +} + +impl AgentTool for SaveFileTool { + type Input = SaveFileToolInput; + type Output = String; + + fn name() -> &'static str { + "save_file" + } + + fn kind() -> acp::ToolKind { + acp::ToolKind::Other + } + + fn initial_title( + &self, + input: Result, + _cx: &mut App, + ) -> SharedString { + match input { + Ok(input) if input.paths.len() == 1 => "Save file".into(), + Ok(input) => format!("Save {} files", input.paths.len()).into(), + Err(_) => "Save files".into(), + } + } + + fn run( + self: Arc, + input: Self::Input, + _event_stream: ToolCallEventStream, + cx: &mut App, + ) -> Task> { + let project = self.project.clone(); + let input_paths = input.paths; + + cx.spawn(async move |cx| { + let mut buffers_to_save: FxHashSet> = FxHashSet::default(); + + let mut saved_paths: Vec = Vec::new(); + let mut clean_paths: Vec = Vec::new(); + let mut not_found_paths: Vec = Vec::new(); + let mut open_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut dirty_check_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut save_errors: Vec<(String, String)> = Vec::new(); + + for path in input_paths { + let project_path = + project.read_with(cx, |project, cx| project.find_project_path(&path, cx)); + + let project_path = match project_path { + Ok(Some(project_path)) => project_path, + Ok(None) => { + not_found_paths.push(path); + continue; + } + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let open_buffer_task = + project.update(cx, |project, cx| project.open_buffer(project_path, cx)); + + let buffer = match open_buffer_task { + Ok(task) => match task.await { + Ok(buffer) => buffer, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let is_dirty = match buffer.read_with(cx, |buffer, _| buffer.is_dirty()) { + Ok(is_dirty) => is_dirty, + Err(error) => { + dirty_check_errors.push((path, error.to_string())); + continue; + } + }; + + if is_dirty { + buffers_to_save.insert(buffer); + saved_paths.push(path); + } else { + clean_paths.push(path); + } + } + + // Save each buffer individually since there's no batch save API. + for buffer in buffers_to_save { + let path_for_buffer = match buffer.read_with(cx, |buffer, _| { + buffer + .file() + .map(|file| file.path().to_rel_path_buf()) + .map(|path| path.as_rel_path().as_unix_str().to_owned()) + }) { + Ok(path) => path.unwrap_or_else(|| "".to_string()), + Err(error) => { + save_errors.push(("".to_string(), error.to_string())); + continue; + } + }; + + let save_task = project.update(cx, |project, cx| project.save_buffer(buffer, cx)); + + match save_task { + Ok(task) => { + if let Err(error) = task.await { + save_errors.push((path_for_buffer, error.to_string())); + } + } + Err(error) => { + save_errors.push((path_for_buffer, error.to_string())); + } + } + } + + let mut lines: Vec = Vec::new(); + + if !saved_paths.is_empty() { + lines.push(format!("Saved {} file(s).", saved_paths.len())); + } + if !clean_paths.is_empty() { + lines.push(format!("{} clean.", clean_paths.len())); + } + + if !not_found_paths.is_empty() { + lines.push(format!("Not found ({}):", not_found_paths.len())); + for path in ¬_found_paths { + lines.push(format!("- {}", path.display())); + } + } + if !open_errors.is_empty() { + lines.push(format!("Open failed ({}):", open_errors.len())); + for (path, error) in &open_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !dirty_check_errors.is_empty() { + lines.push(format!( + "Dirty check failed ({}):", + dirty_check_errors.len() + )); + for (path, error) in &dirty_check_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !save_errors.is_empty() { + lines.push(format!("Save failed ({}):", save_errors.len())); + for (path, error) in &save_errors { + lines.push(format!("- {}: {}", path, error)); + } + } + + if lines.is_empty() { + Ok("No paths provided.".to_string()) + } else { + Ok(lines.join("\n")) + } + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use fs::Fs; + use gpui::TestAppContext; + use project::FakeFs; + use serde_json::json; + use settings::SettingsStore; + use util::path; + + fn init_test(cx: &mut TestAppContext) { + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + }); + } + + #[gpui::test] + async fn test_save_file_output_and_effects(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + "/root", + json!({ + "dirty.txt": "on disk: dirty\n", + "clean.txt": "on disk: clean\n", + }), + ) + .await; + + let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await; + let tool = Arc::new(SaveFileTool::new(project.clone())); + + // Make dirty.txt dirty in-memory. + let dirty_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/dirty.txt", cx) + .expect("dirty.txt should exist in project") + }); + + let dirty_buffer = project + .update(cx, |project, cx| { + project.open_buffer(dirty_project_path, cx) + }) + .await + .unwrap(); + dirty_buffer.update(cx, |buffer, cx| { + buffer.edit([(0..buffer.len(), "in memory: dirty\n")], None, cx); + }); + assert!( + dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should be dirty before save" + ); + + // Ensure clean.txt is opened but remains clean. + let clean_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/clean.txt", cx) + .expect("clean.txt should exist in project") + }); + + let clean_buffer = project + .update(cx, |project, cx| { + project.open_buffer(clean_project_path, cx) + }) + .await + .unwrap(); + assert!( + !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "clean.txt buffer should start clean" + ); + + let output = cx + .update(|cx| { + tool.clone().run( + SaveFileToolInput { + paths: vec![ + PathBuf::from("root/dirty.txt"), + PathBuf::from("root/clean.txt"), + ], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + + // Output should mention saved + clean. + assert!( + output.contains("Saved 1 file(s)."), + "expected saved count line, got:\n{output}" + ); + assert!( + output.contains("1 clean."), + "expected clean count line, got:\n{output}" + ); + + // Effect: dirty buffer should now be clean and disk should have new content. + assert!( + !dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should not be dirty after save" + ); + + let disk_dirty = fs.load(path!("/root/dirty.txt").as_ref()).await.unwrap(); + assert_eq!( + disk_dirty, "in memory: dirty\n", + "dirty.txt disk content should be updated" + ); + + // Sanity: clean buffer should remain clean and disk unchanged. + let disk_clean = fs.load(path!("/root/clean.txt").as_ref()).await.unwrap(); + assert_eq!(disk_clean, "on disk: clean\n"); + + // Test empty paths case. + let output = cx + .update(|cx| { + tool.clone().run( + SaveFileToolInput { paths: vec![] }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert_eq!(output, "No paths provided."); + + // Test not-found path case. + let output = cx + .update(|cx| { + tool.clone().run( + SaveFileToolInput { + paths: vec![PathBuf::from("nonexistent/path.txt")], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert!( + output.contains("Not found (1):"), + "expected not-found header line, got:\n{output}" + ); + assert!( + output.contains("- nonexistent/path.txt"), + "expected not-found path bullet, got:\n{output}" + ); + } +} From 97f6cdac81ff83476286b18e879e1d1c7a2aad80 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Mon, 15 Dec 2025 15:22:29 -0700 Subject: [PATCH 013/266] Add an autofix workflow (#44922) One of the major annoyances with writing code with claude is that its poorly indented; instead of requiring manual intervention, let's just fix that in CI. Similar to https://autofix.ci, but as we already have a github app, we can do it without relying on a 3rd party. This PR doesn't trigger the workflow (we need a separate change in Zippy to do that) but will let me test it manually. Release Notes: - N/A --- .github/workflows/autofix_pr.yml | 53 +++++++++++++ tooling/xtask/src/tasks/workflows.rs | 2 + .../xtask/src/tasks/workflows/autofix_pr.rs | 77 +++++++++++++++++++ tooling/xtask/src/tasks/workflows/steps.rs | 12 ++- 4 files changed, 143 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/autofix_pr.yml create mode 100644 tooling/xtask/src/tasks/workflows/autofix_pr.rs diff --git a/.github/workflows/autofix_pr.yml b/.github/workflows/autofix_pr.yml new file mode 100644 index 0000000000000000000000000000000000000000..8c7786f6e1b91879a8b5a6f26f685570cd9cb2d3 --- /dev/null +++ b/.github/workflows/autofix_pr.yml @@ -0,0 +1,53 @@ +# Generated from xtask::workflows::autofix_pr +# Rebuild with `cargo xtask workflows`. +name: autofix_pr +run-name: 'autofix PR #${{ inputs.pr_number }}' +on: + workflow_dispatch: + inputs: + pr_number: + description: pr_number + required: true + type: string +jobs: + run_autofix: + runs-on: namespace-profile-2x4-ubuntu-2404 + steps: + - id: get-app-token + name: autofix_pr::run_autofix::authenticate_as_zippy + uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 + with: + app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} + private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }} + - name: steps::checkout_repo_with_token + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + with: + clean: false + token: ${{ steps.get-app-token.outputs.token }} + - name: autofix_pr::run_autofix::checkout_pr + run: gh pr checkout ${{ inputs.pr_number }} + shell: bash -euxo pipefail {0} + env: + GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} + - name: autofix_pr::run_autofix::run_cargo_fmt + run: cargo fmt --all + shell: bash -euxo pipefail {0} + - name: autofix_pr::run_autofix::run_clippy_fix + run: cargo clippy --workspace --release --all-targets --all-features --fix --allow-dirty --allow-staged + shell: bash -euxo pipefail {0} + - name: autofix_pr::run_autofix::commit_and_push + run: | + if git diff --quiet; then + echo "No changes to commit" + else + git add -A + git commit -m "Apply cargo fmt and clippy --fix" + git push + fi + shell: bash -euxo pipefail {0} + env: + GIT_COMMITTER_NAME: Zed Zippy + GIT_COMMITTER_EMAIL: hi@zed.dev + GIT_AUTHOR_NAME: Zed Zippy + GIT_AUTHOR_EMAIL: hi@zed.dev + GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} diff --git a/tooling/xtask/src/tasks/workflows.rs b/tooling/xtask/src/tasks/workflows.rs index 717517402d619e54d30a502fcfe26418910aac35..fe476355203a69c962081c36fe350460b9df6f6b 100644 --- a/tooling/xtask/src/tasks/workflows.rs +++ b/tooling/xtask/src/tasks/workflows.rs @@ -5,6 +5,7 @@ use std::fs; use std::path::{Path, PathBuf}; mod after_release; +mod autofix_pr; mod cherry_pick; mod compare_perf; mod danger; @@ -111,6 +112,7 @@ pub fn run_workflows(_: GenerateWorkflowArgs) -> Result<()> { WorkflowFile::zed(run_tests::run_tests), WorkflowFile::zed(release::release), WorkflowFile::zed(cherry_pick::cherry_pick), + WorkflowFile::zed(autofix_pr::autofix_pr), WorkflowFile::zed(compare_perf::compare_perf), WorkflowFile::zed(run_agent_evals::run_unit_evals), WorkflowFile::zed(run_agent_evals::run_cron_unit_evals), diff --git a/tooling/xtask/src/tasks/workflows/autofix_pr.rs b/tooling/xtask/src/tasks/workflows/autofix_pr.rs new file mode 100644 index 0000000000000000000000000000000000000000..7e00a8bcbdbd9cd367221d2d90413fb59428d560 --- /dev/null +++ b/tooling/xtask/src/tasks/workflows/autofix_pr.rs @@ -0,0 +1,77 @@ +use gh_workflow::*; + +use crate::tasks::workflows::{ + runners, + steps::{self, NamedJob, named}, + vars::{self, StepOutput, WorkflowInput}, +}; + +pub fn autofix_pr() -> Workflow { + let pr_number = WorkflowInput::string("pr_number", None); + let autofix = run_autofix(&pr_number); + named::workflow() + .run_name(format!("autofix PR #{pr_number}")) + .on(Event::default().workflow_dispatch( + WorkflowDispatch::default().add_input(pr_number.name, pr_number.input()), + )) + .add_job(autofix.name, autofix.job) +} + +fn run_autofix(pr_number: &WorkflowInput) -> NamedJob { + fn authenticate_as_zippy() -> (Step, StepOutput) { + let step = named::uses( + "actions", + "create-github-app-token", + "bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1", + ) + .add_with(("app-id", vars::ZED_ZIPPY_APP_ID)) + .add_with(("private-key", vars::ZED_ZIPPY_APP_PRIVATE_KEY)) + .id("get-app-token"); + let output = StepOutput::new(&step, "token"); + (step, output) + } + + fn checkout_pr(pr_number: &WorkflowInput, token: &StepOutput) -> Step { + named::bash(&format!("gh pr checkout {pr_number}")).add_env(("GITHUB_TOKEN", token)) + } + + fn run_cargo_fmt() -> Step { + named::bash("cargo fmt --all") + } + + fn run_clippy_fix() -> Step { + named::bash( + "cargo clippy --workspace --release --all-targets --all-features --fix --allow-dirty --allow-staged", + ) + } + + fn commit_and_push(token: &StepOutput) -> Step { + named::bash(indoc::indoc! {r#" + if git diff --quiet; then + echo "No changes to commit" + else + git add -A + git commit -m "Apply cargo fmt and clippy --fix" + git push + fi + "#}) + .add_env(("GIT_COMMITTER_NAME", "Zed Zippy")) + .add_env(("GIT_COMMITTER_EMAIL", "hi@zed.dev")) + .add_env(("GIT_AUTHOR_NAME", "Zed Zippy")) + .add_env(("GIT_AUTHOR_EMAIL", "hi@zed.dev")) + .add_env(("GITHUB_TOKEN", token)) + } + + let (authenticate, token) = authenticate_as_zippy(); + + named::job( + Job::default() + .runs_on(runners::LINUX_SMALL) + .add_step(authenticate) + .add_step(steps::checkout_repo_with_token(&token)) + .add_step(checkout_pr(pr_number, &token)) + .add_step(run_cargo_fmt()) + .add_step(run_clippy_fix()) + .add_step(commit_and_push(&token)), + ) +} diff --git a/tooling/xtask/src/tasks/workflows/steps.rs b/tooling/xtask/src/tasks/workflows/steps.rs index 722a5f0704542889703fdbb42c691d01bc50ace6..7d55df2db433d6e6eae96a5ae62a0c033689d904 100644 --- a/tooling/xtask/src/tasks/workflows/steps.rs +++ b/tooling/xtask/src/tasks/workflows/steps.rs @@ -1,6 +1,6 @@ use gh_workflow::*; -use crate::tasks::workflows::{runners::Platform, vars}; +use crate::tasks::workflows::{runners::Platform, vars, vars::StepOutput}; pub const BASH_SHELL: &str = "bash -euxo pipefail {0}"; // https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsshell @@ -17,6 +17,16 @@ pub fn checkout_repo() -> Step { .add_with(("clean", false)) } +pub fn checkout_repo_with_token(token: &StepOutput) -> Step { + named::uses( + "actions", + "checkout", + "11bd71901bbe5b1630ceea73d27597364c9af683", // v4 + ) + .add_with(("clean", false)) + .add_with(("token", token.to_string())) +} + pub fn setup_pnpm() -> Step { named::uses( "pnpm", From 4096bc55bea787b15c9281945aca5b87ce1acdc5 Mon Sep 17 00:00:00 2001 From: Vitaly Slobodin Date: Mon, 15 Dec 2025 23:48:54 +0100 Subject: [PATCH 014/266] languages: Add injections for string and tagged template literals for JS/TS(X) (#44180) Hi! This pull request adds language injections for string and tagged template literals for JS/TS(X). This is similar to what [this extension](https://marketplace.visualstudio.com/items?itemName=bierner.comment-tagged-templates) provides for VSCode. This PR is inspired by this tweet https://x.com/leaverou/status/1996306611208388953?s=46&t=foDQRPR8oIl1buTJ4kZoSQ I've added injections queries for the following languages: HTML, CSS, GraphQL and SQL. This works for: - String literals: `const cssString = /* css */'button { color: hotpink !important; }';` - Template literals: ```const cssString = /* css */`button { color: hotpink !important; }`;``` All injections support the format with whitespaces inside, i.e. `/* html */` and without them `/*html*/`. ## Screenshots |before|after| |---------|-----------| | CleanShot 2025-12-04 at 21 12 00@2x | CleanShot 2025-12-04 at 21 08 35@2x| Release Notes: - Added language injections for string and tagged template literals in JS/TS(X) --- .../languages/src/javascript/injections.scm | 43 +++++++++++++++++++ crates/languages/src/tsx/injections.scm | 43 +++++++++++++++++++ .../languages/src/typescript/injections.scm | 43 +++++++++++++++++++ 3 files changed, 129 insertions(+) diff --git a/crates/languages/src/javascript/injections.scm b/crates/languages/src/javascript/injections.scm index f79cd788d78964f61f611023d0645c95c88aaf17..244e025a6f5d62f1d3500fc35fc480b1baa2471e 100644 --- a/crates/languages/src/javascript/injections.scm +++ b/crates/languages/src/javascript/injections.scm @@ -83,3 +83,46 @@ arguments: (arguments (template_string (string_fragment) @injection.content (#set! injection.language "isograph"))) ) + +; Parse the contents of strings and tagged template +; literals with leading ECMAScript comments: +; '/* html */' or '/*html*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*html\\s*\\*\\/") + (#set! injection.language "html") +) + +; '/* sql */' or '/*sql*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*sql\\s*\\*\\/") + (#set! injection.language "sql") +) + +; '/* gql */' or '/*gql*/' +; '/* graphql */' or '/*graphql*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*(gql|graphql)\\s*\\*\\/") + (#set! injection.language "graphql") +) + +; '/* css */' or '/*css*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*(css)\\s*\\*\\/") + (#set! injection.language "css") +) diff --git a/crates/languages/src/tsx/injections.scm b/crates/languages/src/tsx/injections.scm index 3cca9e8e81c31d3565554595456fa62be89bc81f..2cf3ea69ca2fd95402eba6fadb85f3505c5562b7 100644 --- a/crates/languages/src/tsx/injections.scm +++ b/crates/languages/src/tsx/injections.scm @@ -83,3 +83,46 @@ arguments: (arguments (template_string (string_fragment) @injection.content (#set! injection.language "isograph"))) ) + +; Parse the contents of strings and tagged template +; literals with leading ECMAScript comments: +; '/* html */' or '/*html*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*html\\s*\\*\\/") + (#set! injection.language "html") +) + +; '/* sql */' or '/*sql*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*sql\\s*\\*\\/") + (#set! injection.language "sql") +) + +; '/* gql */' or '/*gql*/' +; '/* graphql */' or '/*graphql*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*(gql|graphql)\\s*\\*\\/") + (#set! injection.language "graphql") +) + +; '/* css */' or '/*css*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*(css)\\s*\\*\\/") + (#set! injection.language "css") +) diff --git a/crates/languages/src/typescript/injections.scm b/crates/languages/src/typescript/injections.scm index 5321e606c118a41df127c8aa37c7c2811dc8bd23..91880407900e7407e46982a54dbeaa3e30277bdd 100644 --- a/crates/languages/src/typescript/injections.scm +++ b/crates/languages/src/typescript/injections.scm @@ -124,3 +124,46 @@ ] ))) (#set! injection.language "css")) + +; Parse the contents of strings and tagged template +; literals with leading ECMAScript comments: +; '/* html */' or '/*html*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*html\\s*\\*\\/") + (#set! injection.language "html") +) + +; '/* sql */' or '/*sql*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*sql\\s*\\*\\/") + (#set! injection.language "sql") +) + +; '/* gql */' or '/*gql*/' +; '/* graphql */' or '/*graphql*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*(gql|graphql)\\s*\\*\\/") + (#set! injection.language "graphql") +) + +; '/* css */' or '/*css*/' +( + ((comment) @_ecma_comment [ + (string (string_fragment) @injection.content) + (template_string (string_fragment) @injection.content) + ]) + (#match? @_ecma_comment "^\\/\\*\\s*(css)\\s*\\*\\/") + (#set! injection.language "css") +) From b52f907a8edb0e4134b6b1bf125c54748fec001e Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Mon, 15 Dec 2025 23:59:04 +0100 Subject: [PATCH 015/266] extension_ci: Auto-assign version bumps to GitHub actor (#44929) Release Notes: - N/A --- .github/workflows/extension_bump.yml | 1 + tooling/xtask/src/tasks/workflows/extension_bump.rs | 5 +++-- .../src/tasks/workflows/{extensions/mod.rs => extensions.rs} | 0 3 files changed, 4 insertions(+), 2 deletions(-) rename tooling/xtask/src/tasks/workflows/{extensions/mod.rs => extensions.rs} (100%) diff --git a/.github/workflows/extension_bump.yml b/.github/workflows/extension_bump.yml index c7582378f1c9e87254e1a0b4e202d9f56b99877b..31676e5c914719a34f8b2e61193475ed107cd2db 100644 --- a/.github/workflows/extension_bump.yml +++ b/.github/workflows/extension_bump.yml @@ -113,6 +113,7 @@ jobs: delete-branch: true token: ${{ steps.generate-token.outputs.token }} sign-commits: true + assignees: ${{ github.actor }} timeout-minutes: 1 create_version_label: needs: diff --git a/tooling/xtask/src/tasks/workflows/extension_bump.rs b/tooling/xtask/src/tasks/workflows/extension_bump.rs index 34fcf8099031ec9d5562c76f45073a9936c285ff..8772011a2d1f48550095a916ab516cc98ac2d1f7 100644 --- a/tooling/xtask/src/tasks/workflows/extension_bump.rs +++ b/tooling/xtask/src/tasks/workflows/extension_bump.rs @@ -1,4 +1,4 @@ -use gh_workflow::*; +use gh_workflow::{ctx::Context, *}; use indoc::indoc; use crate::tasks::workflows::{ @@ -287,7 +287,8 @@ fn create_pull_request(new_version: StepOutput, generated_token: StepOutput) -> .add("base", "main") .add("delete-branch", true) .add("token", generated_token.to_string()) - .add("sign-commits", true), + .add("sign-commits", true) + .add("assignees", Context::github().actor().to_string()), ) } diff --git a/tooling/xtask/src/tasks/workflows/extensions/mod.rs b/tooling/xtask/src/tasks/workflows/extensions.rs similarity index 100% rename from tooling/xtask/src/tasks/workflows/extensions/mod.rs rename to tooling/xtask/src/tasks/workflows/extensions.rs From 0ead4668d2cbd1f0245cb0ffd1ef0de81644d50c Mon Sep 17 00:00:00 2001 From: Artem Molonosov Date: Mon, 15 Dec 2025 23:59:52 +0100 Subject: [PATCH 016/266] project_panel: Fix divider taking too much horizontal space (#44920) Closes: #44917 While setting up the project for contribution, I noticed that the divider in the welcome dialog was rendering incorrectly on the `main` branch compared to the latest release. **Current behaviour (`main` branch):** image **Expected behaviour (Release `0.216.1`):** image --- After some investigation, it looks like the issue was introduced in #44505, specifically in [these changes](https://github.com/zed-industries/zed/pull/44505/changes#diff-4ea61133da5775f0d5d06e67a8dccc84e671c3d04db5f738f6ebfab3a4df0b01R147-R158), which caused the divider to take the full width instead of being properly constrained. **PR result**: image Release Notes: - Fixes -or- divider rendering incorrectly --- crates/project_panel/src/project_panel.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index ea667ecbb479ca347914ee11ec789a14f29cf474..a645ae194b19e5770386ed2eb97de11f9350a866 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -6050,9 +6050,9 @@ impl Render for ProjectPanel { h_flex() .w_1_2() .gap_2() - .child(Divider::horizontal()) + .child(div().flex_1().child(Divider::horizontal())) .child(Label::new("or").size(LabelSize::XSmall).color(Color::Muted)) - .child(Divider::horizontal()), + .child(div().flex_1().child(Divider::horizontal())), ) .child( Button::new("clone_repo", "Clone Repository") From 870159e7e8e633db3ff83725ed0c13e99400dde2 Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Mon, 15 Dec 2025 18:40:39 -0500 Subject: [PATCH 017/266] git: Fix partially-staged paths not being accurately rendered (#44837) Updates #44089 - Restores the ability to have a partially staged/`Indeterminate` status for the git panel checkboxes - Removes the `optimistic_staging` logic, since its stated purpose is served by the `PendingOps` system in the `GitStore` (which may have bugs, but we should fix them in the git store rather than adding another layer) Release Notes: - Fixed partially-staged files not being represented accurately in the git panel. --------- Co-authored-by: Anthony Eid --- crates/git_ui/src/git_panel.rs | 315 +++++++++++++-------------------- 1 file changed, 123 insertions(+), 192 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 0cca777e07cf14d7f5e8537b2b8b8779cbc2ef64..d0618508ddbd153f4dcb1b77e974dc42ed2b0b32 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -319,9 +319,7 @@ impl TreeViewState { &mut self, section: Section, mut entries: Vec, - repo: &Repository, seen_directories: &mut HashSet, - optimistic_staging: &HashMap, ) -> Vec<(GitListEntry, bool)> { if entries.is_empty() { return Vec::new(); @@ -365,14 +363,7 @@ impl TreeViewState { } } - let (flattened, _) = self.flatten_tree( - &root, - section, - 0, - repo, - seen_directories, - optimistic_staging, - ); + let (flattened, _) = self.flatten_tree(&root, section, 0, seen_directories); flattened } @@ -381,9 +372,7 @@ impl TreeViewState { node: &TreeNode, section: Section, depth: usize, - repo: &Repository, seen_directories: &mut HashSet, - optimistic_staging: &HashMap, ) -> (Vec<(GitListEntry, bool)>, Vec) { let mut all_statuses = Vec::new(); let mut flattened = Vec::new(); @@ -393,26 +382,13 @@ impl TreeViewState { let Some(path) = terminal.path.clone().or_else(|| child.path.clone()) else { continue; }; - let (child_flattened, mut child_statuses) = self.flatten_tree( - terminal, - section, - depth + 1, - repo, - seen_directories, - optimistic_staging, - ); + let (child_flattened, mut child_statuses) = + self.flatten_tree(terminal, section, depth + 1, seen_directories); let key = TreeKey { section, path }; let expanded = *self.expanded_dirs.get(&key).unwrap_or(&true); self.expanded_dirs.entry(key.clone()).or_insert(true); seen_directories.insert(key.clone()); - let staged_count = child_statuses - .iter() - .filter(|entry| Self::is_entry_staged(entry, repo, optimistic_staging)) - .count(); - let staged_state = - GitPanel::toggle_state_for_counts(staged_count, child_statuses.len()); - self.directory_descendants .insert(key.clone(), child_statuses.clone()); @@ -421,7 +397,6 @@ impl TreeViewState { key, name, depth, - staged_state, expanded, }), true, @@ -465,23 +440,6 @@ impl TreeViewState { let name = parts.join("/"); (node, SharedString::from(name)) } - - fn is_entry_staged( - entry: &GitStatusEntry, - repo: &Repository, - optimistic_staging: &HashMap, - ) -> bool { - if let Some(optimistic) = optimistic_staging.get(&entry.repo_path) { - return *optimistic; - } - repo.pending_ops_for_path(&entry.repo_path) - .map(|ops| ops.staging() || ops.staged()) - .or_else(|| { - repo.status_for_path(&entry.repo_path) - .and_then(|status| status.status.staging().as_bool()) - }) - .unwrap_or(entry.staging.has_staged()) - } } #[derive(Debug, PartialEq, Eq, Clone)] @@ -501,7 +459,7 @@ struct GitTreeDirEntry { key: TreeKey, name: SharedString, depth: usize, - staged_state: ToggleState, + // staged_state: ToggleState, expanded: bool, } @@ -638,7 +596,6 @@ pub struct GitPanel { local_committer_task: Option>, bulk_staging: Option, stash_entries: GitStash, - optimistic_staging: HashMap, _settings_subscription: Subscription, } @@ -808,7 +765,6 @@ impl GitPanel { entry_count: 0, bulk_staging: None, stash_entries: Default::default(), - optimistic_staging: HashMap::default(), _settings_subscription, }; @@ -1555,7 +1511,7 @@ impl GitPanel { .detach(); } - fn is_entry_staged(&self, entry: &GitStatusEntry, repo: &Repository) -> bool { + fn stage_status_for_entry(entry: &GitStatusEntry, repo: &Repository) -> StageStatus { // Checking for current staged/unstaged file status is a chained operation: // 1. first, we check for any pending operation recorded in repository // 2. if there are no pending ops either running or finished, we then ask the repository @@ -1564,25 +1520,59 @@ impl GitPanel { // the checkbox's state (or flickering) which is undesirable. // 3. finally, if there is no info about this `entry` in the repo, we fall back to whatever status is encoded // in `entry` arg. - if let Some(optimistic) = self.optimistic_staging.get(&entry.repo_path) { - return *optimistic; - } repo.pending_ops_for_path(&entry.repo_path) - .map(|ops| ops.staging() || ops.staged()) + .map(|ops| { + if ops.staging() || ops.staged() { + StageStatus::Staged + } else { + StageStatus::Unstaged + } + }) .or_else(|| { repo.status_for_path(&entry.repo_path) - .and_then(|status| status.status.staging().as_bool()) + .map(|status| status.status.staging()) }) - .unwrap_or(entry.staging.has_staged()) + .unwrap_or(entry.staging) } - fn toggle_state_for_counts(staged_count: usize, total: usize) -> ToggleState { - if staged_count == 0 || total == 0 { - ToggleState::Unselected - } else if staged_count == total { - ToggleState::Selected + fn stage_status_for_directory( + &self, + entry: &GitTreeDirEntry, + repo: &Repository, + ) -> StageStatus { + let GitPanelViewMode::Tree(tree_state) = &self.view_mode else { + util::debug_panic!("We should never render a directory entry while in flat view mode"); + return StageStatus::Unstaged; + }; + + let Some(descendants) = tree_state.directory_descendants.get(&entry.key) else { + return StageStatus::Unstaged; + }; + + let mut fully_staged_count = 0usize; + let mut any_staged_or_partially_staged = false; + + for descendant in descendants { + match GitPanel::stage_status_for_entry(descendant, repo) { + StageStatus::Staged => { + fully_staged_count += 1; + any_staged_or_partially_staged = true; + } + StageStatus::PartiallyStaged => { + any_staged_or_partially_staged = true; + } + StageStatus::Unstaged => {} + } + } + + if descendants.is_empty() { + StageStatus::Unstaged + } else if fully_staged_count == descendants.len() { + StageStatus::Staged + } else if any_staged_or_partially_staged { + StageStatus::PartiallyStaged } else { - ToggleState::Indeterminate + StageStatus::Unstaged } } @@ -1611,31 +1601,37 @@ impl GitPanel { match entry { GitListEntry::Status(status_entry) => { let repo_paths = vec![status_entry.clone()]; - let stage = if self.is_entry_staged(status_entry, &repo) { - if let Some(op) = self.bulk_staging.clone() - && op.anchor == status_entry.repo_path - { - clear_anchor = Some(op.anchor); + let stage = match GitPanel::stage_status_for_entry(status_entry, &repo) { + StageStatus::Staged => { + if let Some(op) = self.bulk_staging.clone() + && op.anchor == status_entry.repo_path + { + clear_anchor = Some(op.anchor); + } + false + } + StageStatus::Unstaged | StageStatus::PartiallyStaged => { + set_anchor = Some(status_entry.repo_path.clone()); + true } - false - } else { - set_anchor = Some(status_entry.repo_path.clone()); - true }; (stage, repo_paths) } GitListEntry::TreeStatus(status_entry) => { let repo_paths = vec![status_entry.entry.clone()]; - let stage = if self.is_entry_staged(&status_entry.entry, &repo) { - if let Some(op) = self.bulk_staging.clone() - && op.anchor == status_entry.entry.repo_path - { - clear_anchor = Some(op.anchor); + let stage = match GitPanel::stage_status_for_entry(&status_entry.entry, &repo) { + StageStatus::Staged => { + if let Some(op) = self.bulk_staging.clone() + && op.anchor == status_entry.entry.repo_path + { + clear_anchor = Some(op.anchor); + } + false + } + StageStatus::Unstaged | StageStatus::PartiallyStaged => { + set_anchor = Some(status_entry.entry.repo_path.clone()); + true } - false - } else { - set_anchor = Some(status_entry.entry.repo_path.clone()); - true }; (stage, repo_paths) } @@ -1647,7 +1643,8 @@ impl GitPanel { .filter_map(|entry| entry.status_entry()) .filter(|status_entry| { section.contains(status_entry, &repo) - && status_entry.staging.as_bool() != Some(goal_staged_state) + && GitPanel::stage_status_for_entry(status_entry, &repo).as_bool() + != Some(goal_staged_state) }) .cloned() .collect::>(); @@ -1655,7 +1652,12 @@ impl GitPanel { (goal_staged_state, entries) } GitListEntry::Directory(entry) => { - let goal_staged_state = entry.staged_state != ToggleState::Selected; + let goal_staged_state = match self.stage_status_for_directory(entry, repo) { + StageStatus::Staged => StageStatus::Unstaged, + StageStatus::Unstaged | StageStatus::PartiallyStaged => StageStatus::Staged, + }; + let goal_stage = goal_staged_state == StageStatus::Staged; + let entries = self .view_mode .tree_state() @@ -1664,10 +1666,11 @@ impl GitPanel { .unwrap_or_default() .into_iter() .filter(|status_entry| { - self.is_entry_staged(status_entry, &repo) != goal_staged_state + GitPanel::stage_status_for_entry(status_entry, &repo) + != goal_staged_state }) .collect::>(); - (goal_staged_state, entries) + (goal_stage, entries) } } }; @@ -1682,10 +1685,6 @@ impl GitPanel { self.set_bulk_staging_anchor(anchor, cx); } - let repo = active_repository.read(cx); - self.apply_optimistic_stage(&repo_paths, stage, &repo); - cx.notify(); - self.change_file_stage(stage, repo_paths, cx); } @@ -1730,81 +1729,6 @@ impl GitPanel { .detach(); } - fn apply_optimistic_stage( - &mut self, - entries: &[GitStatusEntry], - stage: bool, - repo: &Repository, - ) { - // This “optimistic” pass keeps all checkboxes—files, folders, and section headers—visually in sync the moment you click, - // even though `change_file_stage` is still talking to the repository in the background. - // Before, the UI would wait for Git, causing checkbox flicker or stale parent states; - // Now, users see instant feedback and accurate parent/child tri-states while the async staging operation completes. - // - // Description: - // It records the desired state in `self.optimistic_staging` (a map from path → bool), - // walks the rendered entries, and swaps their `staging` flags based on that map. - // In tree view it also recomputes every directory’s tri-state checkbox using the updated child data, - // so parent folders flip between selected/indeterminate/empty in the same frame. - let new_stage = if stage { - StageStatus::Staged - } else { - StageStatus::Unstaged - }; - - self.optimistic_staging - .extend(entries.iter().map(|entry| (entry.repo_path.clone(), stage))); - - let staged_states: HashMap = self - .view_mode - .tree_state() - .map(|state| state.directory_descendants.iter()) - .into_iter() - .flatten() - .map(|(key, descendants)| { - let staged_count = descendants - .iter() - .filter(|entry| self.is_entry_staged(entry, repo)) - .count(); - ( - key.clone(), - Self::toggle_state_for_counts(staged_count, descendants.len()), - ) - }) - .collect(); - - for list_entry in &mut self.entries { - match list_entry { - GitListEntry::Status(status) => { - if self - .optimistic_staging - .get(&status.repo_path) - .is_some_and(|s| *s == stage) - { - status.staging = new_stage; - } - } - GitListEntry::TreeStatus(status) => { - if self - .optimistic_staging - .get(&status.entry.repo_path) - .is_some_and(|s| *s == stage) - { - status.entry.staging = new_stage; - } - } - GitListEntry::Directory(dir) => { - if let Some(state) = staged_states.get(&dir.key) { - dir.staged_state = *state; - } - } - _ => {} - } - } - - self.update_counts(repo); - } - pub fn total_staged_count(&self) -> usize { self.tracked_staged_count + self.new_staged_count + self.conflicted_staged_count } @@ -3394,13 +3318,9 @@ impl GitPanel { Some(&mut tree_state.logical_indices), ); - for (entry, is_visible) in tree_state.build_tree_entries( - section, - entries, - &repo, - &mut seen_directories, - &self.optimistic_staging, - ) { + for (entry, is_visible) in + tree_state.build_tree_entries(section, entries, &mut seen_directories) + { push_entry( self, entry, @@ -3440,13 +3360,6 @@ impl GitPanel { self.max_width_item_index = max_width_item_index; self.update_counts(repo); - let visible_paths: HashSet = self - .entries - .iter() - .filter_map(|entry| entry.status_entry().map(|e| e.repo_path.clone())) - .collect(); - self.optimistic_staging - .retain(|path, _| visible_paths.contains(path)); let bulk_staging_anchor_new_index = bulk_staging .as_ref() @@ -3456,7 +3369,9 @@ impl GitPanel { && let Some(index) = bulk_staging_anchor_new_index && let Some(entry) = self.entries.get(index) && let Some(entry) = entry.status_entry() - && self.is_entry_staged(entry, &repo) + && GitPanel::stage_status_for_entry(entry, &repo) + .as_bool() + .unwrap_or(false) { self.bulk_staging = bulk_staging; } @@ -3500,7 +3415,9 @@ impl GitPanel { for status_entry in self.entries.iter().filter_map(|entry| entry.status_entry()) { self.entry_count += 1; - let is_staging_or_staged = self.is_entry_staged(status_entry, repo); + let is_staging_or_staged = GitPanel::stage_status_for_entry(status_entry, repo) + .as_bool() + .unwrap_or(false); if repo.had_conflict_on_last_merge_head_change(&status_entry.repo_path) { self.conflicted_count += 1; @@ -4737,8 +4654,12 @@ impl GitPanel { .active_repository(cx) .expect("active repository must be set"); let repo = active_repo.read(cx); - let is_staging_or_staged = self.is_entry_staged(entry, &repo); - let mut is_staged: ToggleState = is_staging_or_staged.into(); + let stage_status = GitPanel::stage_status_for_entry(entry, &repo); + let mut is_staged: ToggleState = match stage_status { + StageStatus::Staged => ToggleState::Selected, + StageStatus::Unstaged => ToggleState::Unselected, + StageStatus::PartiallyStaged => ToggleState::Indeterminate, + }; if self.show_placeholders && !self.has_staged_changes() && !entry.status.is_created() { is_staged = ToggleState::Selected; } @@ -4895,12 +4816,9 @@ impl GitPanel { } }) .tooltip(move |_window, cx| { - // If is_staging_or_staged is None, this implies the file was partially staged, and so - // we allow the user to stage it in full by displaying `Stage` in the tooltip. - let action = if is_staging_or_staged { - "Unstage" - } else { - "Stage" + let action = match stage_status { + StageStatus::Staged => "Unstage", + StageStatus::Unstaged | StageStatus::PartiallyStaged => "Stage", }; let tooltip_name = action.to_string(); @@ -4960,7 +4878,21 @@ impl GitPanel { } else { IconName::Folder }; - let staged_state = entry.staged_state; + + let stage_status = if let Some(repo) = &self.active_repository { + self.stage_status_for_directory(entry, repo.read(cx)) + } else { + util::debug_panic!( + "Won't have entries to render without an active repository in Git Panel" + ); + StageStatus::PartiallyStaged + }; + + let toggle_state: ToggleState = match stage_status { + StageStatus::Staged => ToggleState::Selected, + StageStatus::Unstaged => ToggleState::Unselected, + StageStatus::PartiallyStaged => ToggleState::Indeterminate, + }; let name_row = h_flex() .items_center() @@ -5006,7 +4938,7 @@ impl GitPanel { .occlude() .cursor_pointer() .child( - Checkbox::new(checkbox_id, staged_state) + Checkbox::new(checkbox_id, toggle_state) .disabled(!has_write_access) .fill() .elevation(ElevationIndex::Surface) @@ -5029,10 +4961,9 @@ impl GitPanel { } }) .tooltip(move |_window, cx| { - let action = if staged_state.selected() { - "Unstage" - } else { - "Stage" + let action = match stage_status { + StageStatus::Staged => "Unstage", + StageStatus::Unstaged | StageStatus::PartiallyStaged => "Stage", }; Tooltip::simple(format!("{action} folder"), cx) }), From b8d0da97fa96025d4139ecfca8605cce72cca723 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Tue, 16 Dec 2025 00:46:09 +0100 Subject: [PATCH 018/266] collab: Add `copilot-swe-agent[bot]` to the `GET /contributor` endpoint (#44934) This PR adds the `copilot-swe-agent[bot]` user to the `GET /contributor` endpoint so that it passes the CLA check. Release Notes: - N/A --- crates/collab/src/api/contributors.rs | 40 +++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/crates/collab/src/api/contributors.rs b/crates/collab/src/api/contributors.rs index 549a9346b57c0a9801fe791826e9346e3f0350df..e09ac4f8b7355cf143b221308204742139308133 100644 --- a/crates/collab/src/api/contributors.rs +++ b/crates/collab/src/api/contributors.rs @@ -54,6 +54,16 @@ async fn check_is_contributor( ) -> Result> { let params = params.into_contributor_selector()?; + if CopilotSweAgentBot::is_copilot_bot(¶ms) { + return Ok(Json(CheckIsContributorResponse { + signed_at: Some( + CopilotSweAgentBot::created_at() + .and_utc() + .to_rfc3339_opts(SecondsFormat::Millis, true), + ), + })); + } + if Dependabot::is_dependabot(¶ms) { return Ok(Json(CheckIsContributorResponse { signed_at: Some( @@ -93,6 +103,36 @@ async fn check_is_contributor( })) } +/// The Copilot bot GitHub user (`copilot-swe-agent[bot]`). +/// +/// https://api.github.com/users/copilot-swe-agent[bot] +struct CopilotSweAgentBot; + +impl CopilotSweAgentBot { + const LOGIN: &'static str = "copilot-swe-agent[bot]"; + const USER_ID: i32 = 198982749; + + /// Returns the `created_at` timestamp for the Dependabot bot user. + fn created_at() -> &'static NaiveDateTime { + static CREATED_AT: OnceLock = OnceLock::new(); + CREATED_AT.get_or_init(|| { + chrono::DateTime::parse_from_rfc3339("2025-02-12T20:26:08Z") + .expect("failed to parse 'created_at' for 'copilot-swe-agent[bot]'") + .naive_utc() + }) + } + + /// Returns whether the given contributor selector corresponds to the Copilot bot user. + fn is_copilot_bot(contributor: &ContributorSelector) -> bool { + match contributor { + ContributorSelector::GitHubLogin { github_login } => github_login == Self::LOGIN, + ContributorSelector::GitHubUserId { github_user_id } => { + github_user_id == &Self::USER_ID + } + } + } +} + /// The Dependabot bot GitHub user (`dependabot[bot]`). /// /// https://api.github.com/users/dependabot[bot] From 7a4de734c6cccf6d60fd937141305b5fb1a9b55f Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Mon, 15 Dec 2025 18:50:18 -0500 Subject: [PATCH 019/266] git: Ensure no more than 4 blame processes run concurrently for each multibuffer (#44843) Previously we were only awaiting on up to 4 of the blame futures at a time, but we would still call `Project::blame_buffer` eagerly for every buffer in the multibuffer. Since that returns a `Task`, all the blame invocations were still launched concurrently. Release Notes: - N/A --- crates/editor/src/git/blame.rs | 164 ++++++++++++++++++--------------- 1 file changed, 91 insertions(+), 73 deletions(-) diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs index 67df69aadab43a45c2941703e10bb81af2b8dd78..031795ff2dbfceb96f950db18101b37fd3cdcf84 100644 --- a/crates/editor/src/git/blame.rs +++ b/crates/editor/src/git/blame.rs @@ -1,7 +1,7 @@ use crate::Editor; -use anyhow::Result; +use anyhow::{Context as _, Result}; use collections::HashMap; -use futures::StreamExt; + use git::{ GitHostingProviderRegistry, GitRemote, Oid, blame::{Blame, BlameEntry, ParsedCommitMessage}, @@ -494,84 +494,102 @@ impl GitBlame { self.changed_while_blurred = true; return; } - let blame = self.project.update(cx, |project, cx| { - let Some(multi_buffer) = self.multi_buffer.upgrade() else { - return Vec::new(); - }; - multi_buffer - .read(cx) - .all_buffer_ids() - .into_iter() - .filter_map(|id| { - let buffer = multi_buffer.read(cx).buffer(id)?; - let snapshot = buffer.read(cx).snapshot(); - let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe()); - - let blame_buffer = project.blame_buffer(&buffer, None, cx); - let remote_url = project - .git_store() - .read(cx) - .repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx) - .and_then(|(repo, _)| { - repo.read(cx) - .remote_upstream_url - .clone() - .or(repo.read(cx).remote_origin_url.clone()) - }); - Some( - async move { (id, snapshot, buffer_edits, blame_buffer.await, remote_url) }, - ) - }) - .collect::>() - }); - let provider_registry = GitHostingProviderRegistry::default_global(cx); + let buffers_to_blame = self + .multi_buffer + .update(cx, |multi_buffer, _| { + multi_buffer + .all_buffer_ids() + .into_iter() + .filter_map(|id| Some(multi_buffer.buffer(id)?.downgrade())) + .collect::>() + }) + .unwrap_or_default(); + let project = self.project.downgrade(); self.task = cx.spawn(async move |this, cx| { - let (result, errors) = cx - .background_spawn({ - async move { - let blame = futures::stream::iter(blame) - .buffered(4) - .collect::>() - .await; - let mut res = vec![]; - let mut errors = vec![]; - for (id, snapshot, buffer_edits, blame, remote_url) in blame { - match blame { - Ok(Some(Blame { entries, messages })) => { - let entries = build_blame_entry_sum_tree( - entries, - snapshot.max_point().row, - ); - let commit_details = parse_commit_messages( - messages, - remote_url, - provider_registry.clone(), - ) - .await; - - res.push(( + let mut all_results = Vec::new(); + let mut all_errors = Vec::new(); + + for buffers in buffers_to_blame.chunks(4) { + let blame = cx.update(|cx| { + buffers + .iter() + .map(|buffer| { + let buffer = buffer.upgrade().context("buffer was dropped")?; + let project = project.upgrade().context("project was dropped")?; + let id = buffer.read(cx).remote_id(); + let snapshot = buffer.read(cx).snapshot(); + let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe()); + let remote_url = project + .read(cx) + .git_store() + .read(cx) + .repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx) + .and_then(|(repo, _)| { + repo.read(cx) + .remote_upstream_url + .clone() + .or(repo.read(cx).remote_origin_url.clone()) + }); + let blame_buffer = project + .update(cx, |project, cx| project.blame_buffer(&buffer, None, cx)); + Ok(async move { + (id, snapshot, buffer_edits, blame_buffer.await, remote_url) + }) + }) + .collect::>>() + })??; + let provider_registry = + cx.update(|cx| GitHostingProviderRegistry::default_global(cx))?; + let (results, errors) = cx + .background_spawn({ + async move { + let blame = futures::future::join_all(blame).await; + let mut res = vec![]; + let mut errors = vec![]; + for (id, snapshot, buffer_edits, blame, remote_url) in blame { + match blame { + Ok(Some(Blame { entries, messages })) => { + let entries = build_blame_entry_sum_tree( + entries, + snapshot.max_point().row, + ); + let commit_details = parse_commit_messages( + messages, + remote_url, + provider_registry.clone(), + ) + .await; + + res.push(( + id, + snapshot, + buffer_edits, + Some(entries), + commit_details, + )); + } + Ok(None) => res.push(( id, snapshot, buffer_edits, - Some(entries), - commit_details, - )); - } - Ok(None) => { - res.push((id, snapshot, buffer_edits, None, Default::default())) + None, + Default::default(), + )), + Err(e) => errors.push(e), } - Err(e) => errors.push(e), } + (res, errors) } - (res, errors) - } - }) - .await; + }) + .await; + all_results.extend(results); + all_errors.extend(errors) + } this.update(cx, |this, cx| { this.buffers.clear(); - for (id, snapshot, buffer_edits, entries, commit_details) in result { + for (id, snapshot, buffer_edits, entries, commit_details) in all_results { let Some(entries) = entries else { continue; }; @@ -586,11 +604,11 @@ impl GitBlame { ); } cx.notify(); - if !errors.is_empty() { + if !all_errors.is_empty() { this.project.update(cx, |_, cx| { if this.user_triggered { - log::error!("failed to get git blame data: {errors:?}"); - let notification = errors + log::error!("failed to get git blame data: {all_errors:?}"); + let notification = all_errors .into_iter() .format_with(",", |e, f| f(&format_args!("{:#}", e))) .to_string(); @@ -601,7 +619,7 @@ impl GitBlame { } else { // If we weren't triggered by a user, we just log errors in the background, instead of sending // notifications. - log::debug!("failed to get git blame data: {errors:?}"); + log::debug!("failed to get git blame data: {all_errors:?}"); } }) } From f8561b4cb95165644f9736e0b107e267170105fd Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Mon, 15 Dec 2025 15:50:45 -0800 Subject: [PATCH 020/266] Anchor scroll offsets so that entire diff hunks at viewport top become visible (#44932) Fixes https://github.com/zed-industries/zed/issues/39258 Release Notes: - N/A --- crates/editor/src/editor_tests.rs | 34 +++++++++++++++++++++++++++++++ crates/editor/src/scroll.rs | 6 +++++- 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index a020b977c779a9b59a442170f7cc24f87ff54e2b..dfc8fd7f901bf1f45352511e3b7e69f7f4d4b367 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -22233,6 +22233,40 @@ async fn test_toggle_deletion_hunk_at_start_of_file( cx.assert_state_with_diff(hunk_expanded); } +#[gpui::test] +async fn test_expand_first_line_diff_hunk_keeps_deleted_lines_visible( + executor: BackgroundExecutor, + cx: &mut TestAppContext, +) { + init_test(cx, |_| {}); + let mut cx = EditorTestContext::new(cx).await; + + cx.set_state("ˇnew\nsecond\nthird\n"); + cx.set_head_text("old\nsecond\nthird\n"); + cx.update_editor(|editor, window, cx| { + editor.scroll(gpui::Point { x: 0., y: 0. }, None, window, cx); + }); + executor.run_until_parked(); + assert_eq!(cx.update_editor(|e, _, cx| e.scroll_position(cx)).y, 0.0); + + // Expanding a diff hunk at the first line inserts deleted lines above the first buffer line. + cx.update_editor(|editor, window, cx| { + let snapshot = editor.snapshot(window, cx); + let excerpt_id = editor.buffer.read(cx).excerpt_ids()[0]; + let hunks = editor + .diff_hunks_in_ranges(&[Anchor::min()..Anchor::max()], &snapshot.buffer_snapshot()) + .collect::>(); + assert_eq!(hunks.len(), 1); + let hunk_range = Anchor::range_in_buffer(excerpt_id, hunks[0].buffer_range.clone()); + editor.toggle_single_diff_hunk(hunk_range, cx) + }); + executor.run_until_parked(); + cx.assert_state_with_diff("- old\n+ ˇnew\n second\n third\n".to_string()); + + // Keep the editor scrolled to the top so the full hunk remains visible. + assert_eq!(cx.update_editor(|e, _, cx| e.scroll_position(cx)).y, 0.0); +} + #[gpui::test] async fn test_display_diff_hunks(cx: &mut TestAppContext) { init_test(cx, |_| {}); diff --git a/crates/editor/src/scroll.rs b/crates/editor/src/scroll.rs index a92735d18617057ddd10f049e5a22525827e1874..422be9a54e7cfcc40484e4093eeab6c94ce7d8ee 100644 --- a/crates/editor/src/scroll.rs +++ b/crates/editor/src/scroll.rs @@ -251,7 +251,11 @@ impl ScrollManager { Bias::Left, ) .to_point(map); - let top_anchor = map.buffer_snapshot().anchor_after(scroll_top_buffer_point); + // Anchor the scroll position to the *left* of the first visible buffer point. + // + // This prevents the viewport from shifting down when blocks (e.g. expanded diff hunk + // deletions) are inserted *above* the first buffer character in the file. + let top_anchor = map.buffer_snapshot().anchor_before(scroll_top_buffer_point); self.set_anchor( ScrollAnchor { From a60e0a178fb7976700dd9775e6465fcc564b33dc Mon Sep 17 00:00:00 2001 From: Johnny Klucinec <72411904+johnklucinec@users.noreply.github.com> Date: Mon, 15 Dec 2025 20:01:20 -0500 Subject: [PATCH 021/266] Improve keymap error formatting and add settings button icon (#42037) Closes https://github.com/zed-industries/zed/issues/41938 For some error messages relating to the keymap file, the font size was too large. This was due to the error message being a child `MarkdownString` instead of a `SharedString`. A `.text_xs()` method is being applied to this notification, but it appears not to affect the markdown text. I found that the H5 text size in markdown is the same size as other error messages, so I made each element (that had text) that size. There was also a special case for bullet points. I also added a gear icon to the settings button, so it was more in line with other app notifications. Error message (text too large): ![keymap-broke](https://github.com/user-attachments/assets/2c205a3a-ae28-419f-95c4-093340760d03) Expected behavior (notification with correct text sizing and icon): ![keymap-fixed](https://github.com/user-attachments/assets/f8a1396b-177f-4287-b390-c3804b70f1d2) Example behavior: ![settings](https://github.com/user-attachments/assets/09397954-781f-44be-88ad-08035fe66f0c) Release Notes: - Improved UI for keymap error messages. --------- Co-authored-by: Danilo Leal --- crates/settings/src/keymap_file.rs | 8 +++++--- crates/zed/src/zed.rs | 19 +++++++++++-------- 2 files changed, 16 insertions(+), 11 deletions(-) diff --git a/crates/settings/src/keymap_file.rs b/crates/settings/src/keymap_file.rs index 2ef1dfc5385592b9757eff5ec631af818ae1869c..146fc371b14cb5cba428d3a7beec11cc3008e7dd 100644 --- a/crates/settings/src/keymap_file.rs +++ b/crates/settings/src/keymap_file.rs @@ -303,19 +303,21 @@ impl KeymapFile { if errors.is_empty() { KeymapFileLoadResult::Success { key_bindings } } else { - let mut error_message = "Errors in user keymap file.\n".to_owned(); + let mut error_message = "Errors in user keymap file.".to_owned(); + for (context, section_errors) in errors { if context.is_empty() { - let _ = write!(error_message, "\n\nIn section without context predicate:"); + let _ = write!(error_message, "\nIn section without context predicate:"); } else { let _ = write!( error_message, - "\n\nIn section with {}:", + "\nIn section with {}:", MarkdownInlineCode(&format!("context = \"{}\"", context)) ); } let _ = write!(error_message, "{section_errors}"); } + KeymapFileLoadResult::SomeFailedToLoad { key_bindings, error_message: MarkdownString(error_message), diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index ed22d7ef510e367b71b2a1057513471a4e32306a..a51e38bfe48976c8bf12ae1d546f8a8421288af2 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -32,8 +32,8 @@ use git_ui::project_diff::ProjectDiffToolbar; use gpui::{ Action, App, AppContext as _, AsyncWindowContext, Context, DismissEvent, Element, Entity, Focusable, KeyBinding, ParentElement, PathPromptOptions, PromptLevel, ReadGlobal, SharedString, - Styled, Task, TitlebarOptions, UpdateGlobal, WeakEntity, Window, WindowKind, WindowOptions, - actions, image_cache, point, px, retain_all, + Task, TitlebarOptions, UpdateGlobal, WeakEntity, Window, WindowKind, WindowOptions, actions, + image_cache, point, px, retain_all, }; use image_viewer::ImageInfo; use language::Capability; @@ -1690,6 +1690,7 @@ fn show_keymap_file_json_error( cx.new(|cx| { MessageNotification::new(message.clone(), cx) .primary_message("Open Keymap File") + .primary_icon(IconName::Settings) .primary_on_click(|window, cx| { window.dispatch_action(zed_actions::OpenKeymapFile.boxed_clone(), cx); cx.emit(DismissEvent); @@ -1748,16 +1749,18 @@ fn show_markdown_app_notification( cx.new(move |cx| { MessageNotification::new_from_builder(cx, move |window, cx| { image_cache(retain_all("notification-cache")) - .text_xs() - .child(markdown_preview::markdown_renderer::render_parsed_markdown( - &parsed_markdown.clone(), - Some(workspace_handle.clone()), - window, - cx, + .child(div().text_ui(cx).child( + markdown_preview::markdown_renderer::render_parsed_markdown( + &parsed_markdown.clone(), + Some(workspace_handle.clone()), + window, + cx, + ), )) .into_any() }) .primary_message(primary_button_message) + .primary_icon(IconName::Settings) .primary_on_click_arc(primary_button_on_click) }) }) From 3b2ccaff6f05a2f6762d41dca48bc63f6cc47c25 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Mon, 15 Dec 2025 17:22:41 -0800 Subject: [PATCH 022/266] Make zed --wait work with directories (#44936) Fixes #23347 Release Notes: - Implemented the `zed --wait` flag so that it works when opening a directory. The command will block until the window is closed. --- crates/cli/src/main.rs | 2 + crates/zed/src/zed/open_listener.rs | 233 ++++++++++++++++++---------- 2 files changed, 151 insertions(+), 84 deletions(-) diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index 92c0ce2377b8c200b2367148226f3bd3b81f0008..e1a7a1481b56633364cb011f46cd55e616244f2c 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -61,6 +61,8 @@ Examples: )] struct Args { /// Wait for all of the given paths to be opened/closed before exiting. + /// + /// When opening a directory, waits until the created window is closed. #[arg(short, long)] wait: bool, /// Add files to the currently open workspace diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs index e398ad6df7cde55de529e94b62d4aac173741351..3bf6bffda6c7cbbb3a6b0d0c8661acc432b71335 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -10,6 +10,7 @@ use editor::Editor; use fs::Fs; use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender}; use futures::channel::{mpsc, oneshot}; +use futures::future; use futures::future::join_all; use futures::{FutureExt, SinkExt, StreamExt}; use git_ui::file_diff_view::FileDiffView; @@ -514,33 +515,27 @@ async fn open_local_workspace( app_state: &Arc, cx: &mut AsyncApp, ) -> bool { - let mut errored = false; - let paths_with_position = derive_paths_with_position(app_state.fs.as_ref(), workspace_paths).await; - // Handle reuse flag by finding existing window to replace - let replace_window = if reuse { - cx.update(|cx| workspace::local_workspace_windows(cx).into_iter().next()) - .ok() - .flatten() - } else { - None - }; - - // For reuse, force new workspace creation but with replace_window set - let effective_open_new_workspace = if reuse { - Some(true) + // If reuse flag is passed, open a new workspace in an existing window. + let (open_new_workspace, replace_window) = if reuse { + ( + Some(true), + cx.update(|cx| workspace::local_workspace_windows(cx).into_iter().next()) + .ok() + .flatten(), + ) } else { - open_new_workspace + (open_new_workspace, None) }; - match open_paths_with_positions( + let (workspace, items) = match open_paths_with_positions( &paths_with_position, &diff_paths, app_state.clone(), workspace::OpenOptions { - open_new_workspace: effective_open_new_workspace, + open_new_workspace, replace_window, prefer_focused_window: wait, env: env.cloned(), @@ -550,80 +545,95 @@ async fn open_local_workspace( ) .await { - Ok((workspace, items)) => { - let mut item_release_futures = Vec::new(); + Ok(result) => result, + Err(error) => { + responses + .send(CliResponse::Stderr { + message: format!("error opening {paths_with_position:?}: {error}"), + }) + .log_err(); + return true; + } + }; - for item in items { - match item { - Some(Ok(item)) => { - cx.update(|cx| { - let released = oneshot::channel(); - item.on_release( - cx, - Box::new(move |_| { - let _ = released.0.send(()); - }), - ) - .detach(); - item_release_futures.push(released.1); - }) - .log_err(); - } - Some(Err(err)) => { - responses - .send(CliResponse::Stderr { - message: err.to_string(), - }) - .log_err(); - errored = true; - } - None => {} - } + let mut errored = false; + let mut item_release_futures = Vec::new(); + let mut subscriptions = Vec::new(); + + // If --wait flag is used with no paths, or a directory, then wait until + // the entire workspace is closed. + if wait { + let mut wait_for_window_close = paths_with_position.is_empty() && diff_paths.is_empty(); + for path_with_position in &paths_with_position { + if app_state.fs.is_dir(&path_with_position.path).await { + wait_for_window_close = true; + break; } + } + + if wait_for_window_close { + let (release_tx, release_rx) = oneshot::channel(); + item_release_futures.push(release_rx); + subscriptions.push(workspace.update(cx, |_, _, cx| { + cx.on_release(move |_, _| { + let _ = release_tx.send(()); + }) + })); + } + } - if wait { - let background = cx.background_executor().clone(); - let wait = async move { - if paths_with_position.is_empty() && diff_paths.is_empty() { - let (done_tx, done_rx) = oneshot::channel(); - let _subscription = workspace.update(cx, |_, _, cx| { - cx.on_release(move |_, _| { - let _ = done_tx.send(()); - }) - }); - let _ = done_rx.await; - } else { - let _ = futures::future::try_join_all(item_release_futures).await; - }; + for item in items { + match item { + Some(Ok(item)) => { + if wait { + let (release_tx, release_rx) = oneshot::channel(); + item_release_futures.push(release_rx); + subscriptions.push(cx.update(|cx| { + item.on_release( + cx, + Box::new(move |_| { + release_tx.send(()).ok(); + }), + ) + })); } - .fuse(); - - futures::pin_mut!(wait); - - loop { - // Repeatedly check if CLI is still open to avoid wasting resources - // waiting for files or workspaces to close. - let mut timer = background.timer(Duration::from_secs(1)).fuse(); - futures::select_biased! { - _ = wait => break, - _ = timer => { - if responses.send(CliResponse::Ping).is_err() { - break; - } - } + } + Some(Err(err)) => { + responses + .send(CliResponse::Stderr { + message: err.to_string(), + }) + .log_err(); + errored = true; + } + None => {} + } + } + + if wait { + let wait = async move { + let _subscriptions = subscriptions; + let _ = future::try_join_all(item_release_futures).await; + } + .fuse(); + futures::pin_mut!(wait); + + let background = cx.background_executor().clone(); + loop { + // Repeatedly check if CLI is still open to avoid wasting resources + // waiting for files or workspaces to close. + let mut timer = background.timer(Duration::from_secs(1)).fuse(); + futures::select_biased! { + _ = wait => break, + _ = timer => { + if responses.send(CliResponse::Ping).is_err() { + break; } } } } - Err(error) => { - errored = true; - responses - .send(CliResponse::Stderr { - message: format!("error opening {paths_with_position:?}: {error}"), - }) - .log_err(); - } } + errored } @@ -653,12 +663,13 @@ mod tests { ipc::{self}, }; use editor::Editor; - use gpui::TestAppContext; + use futures::poll; + use gpui::{AppContext as _, TestAppContext}; use language::LineEnding; use remote::SshConnectionOptions; use rope::Rope; use serde_json::json; - use std::sync::Arc; + use std::{sync::Arc, task::Poll}; use util::path; use workspace::{AppState, Workspace}; @@ -754,6 +765,60 @@ mod tests { .unwrap(); } + #[gpui::test] + async fn test_wait_with_directory_waits_for_window_close(cx: &mut TestAppContext) { + let app_state = init_test(cx); + + app_state + .fs + .as_fake() + .insert_tree( + path!("/root"), + json!({ + "dir1": { + "file1.txt": "content1", + }, + }), + ) + .await; + + let (response_tx, _) = ipc::channel::().unwrap(); + let workspace_paths = vec![path!("/root/dir1").to_owned()]; + + let (done_tx, mut done_rx) = futures::channel::oneshot::channel(); + cx.spawn({ + let app_state = app_state.clone(); + move |mut cx| async move { + let errored = open_local_workspace( + workspace_paths, + vec![], + None, + false, + true, + &response_tx, + None, + &app_state, + &mut cx, + ) + .await; + let _ = done_tx.send(errored); + } + }) + .detach(); + + cx.background_executor.run_until_parked(); + assert_eq!(cx.windows().len(), 1); + assert!(matches!(poll!(&mut done_rx), Poll::Pending)); + + let window = cx.windows()[0]; + cx.update_window(window, |_, window, _| window.remove_window()) + .unwrap(); + cx.background_executor.run_until_parked(); + + let errored = done_rx.await.unwrap(); + assert!(!errored); + } + #[gpui::test] async fn test_open_workspace_with_nonexistent_files(cx: &mut TestAppContext) { let app_state = init_test(cx); From dfdad947e150668e7de19ce88173badf0ce27352 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Mon, 15 Dec 2025 18:03:02 -0800 Subject: [PATCH 023/266] settings_ui: Add Edit keybindings button (#44914) Closes #ISSUE Release Notes: - settings_ui: Added an "Open Keymap Editor" item under the Keymap section --- crates/keymap_editor/src/keymap_editor.rs | 95 +++++++++++++---------- crates/settings_ui/src/page_data.rs | 25 +++++- crates/settings_ui/src/settings_ui.rs | 82 +++++++++++++++++++ 3 files changed, 157 insertions(+), 45 deletions(-) diff --git a/crates/keymap_editor/src/keymap_editor.rs b/crates/keymap_editor/src/keymap_editor.rs index e81b1077c70d4eb3828715a6bcd28dfe564ab188..9e243d32151e3caeec2b8c51c7889d2ebe93f29b 100644 --- a/crates/keymap_editor/src/keymap_editor.rs +++ b/crates/keymap_editor/src/keymap_editor.rs @@ -81,50 +81,61 @@ pub fn init(cx: &mut App) { let keymap_event_channel = KeymapEventChannel::new(); cx.set_global(keymap_event_channel); - fn common(filter: Option, cx: &mut App) { - workspace::with_active_or_new_workspace(cx, move |workspace, window, cx| { - workspace - .with_local_workspace(window, cx, move |workspace, window, cx| { - let existing = workspace - .active_pane() - .read(cx) - .items() - .find_map(|item| item.downcast::()); - - let keymap_editor = if let Some(existing) = existing { - workspace.activate_item(&existing, true, true, window, cx); - existing - } else { - let keymap_editor = - cx.new(|cx| KeymapEditor::new(workspace.weak_handle(), window, cx)); - workspace.add_item_to_active_pane( - Box::new(keymap_editor.clone()), - None, - true, - window, - cx, - ); - keymap_editor - }; - - if let Some(filter) = filter { - keymap_editor.update(cx, |editor, cx| { - editor.filter_editor.update(cx, |editor, cx| { - editor.clear(window, cx); - editor.insert(&filter, window, cx); - }); - if !editor.has_binding_for(&filter) { - open_binding_modal_after_loading(cx) - } - }) - } - }) - .detach(); - }) + fn open_keymap_editor( + filter: Option, + workspace: &mut Workspace, + window: &mut Window, + cx: &mut Context, + ) { + workspace + .with_local_workspace(window, cx, |workspace, window, cx| { + let existing = workspace + .active_pane() + .read(cx) + .items() + .find_map(|item| item.downcast::()); + + let keymap_editor = if let Some(existing) = existing { + workspace.activate_item(&existing, true, true, window, cx); + existing + } else { + let keymap_editor = + cx.new(|cx| KeymapEditor::new(workspace.weak_handle(), window, cx)); + workspace.add_item_to_active_pane( + Box::new(keymap_editor.clone()), + None, + true, + window, + cx, + ); + keymap_editor + }; + + if let Some(filter) = filter { + keymap_editor.update(cx, |editor, cx| { + editor.filter_editor.update(cx, |editor, cx| { + editor.clear(window, cx); + editor.insert(&filter, window, cx); + }); + if !editor.has_binding_for(&filter) { + open_binding_modal_after_loading(cx) + } + }) + } + }) + .detach_and_log_err(cx); } - cx.on_action(|_: &OpenKeymap, cx| common(None, cx)) - .on_action(|action: &ChangeKeybinding, cx| common(Some(action.action.clone()), cx)); + cx.observe_new(|workspace: &mut Workspace, _window, _cx| { + workspace + .register_action(|workspace, _: &OpenKeymap, window, cx| { + open_keymap_editor(None, workspace, window, cx); + }) + .register_action(|workspace, action: &ChangeKeybinding, window, cx| { + open_keymap_editor(Some(action.action.clone()), workspace, window, cx); + }); + }) + .detach(); register_serializable_item::(cx); } diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs index 79fc1cc11158399265a184a289fd8d7a71ce8d69..007c41ad59b4e875770beecb089bd4e7fb2078b5 100644 --- a/crates/settings_ui/src/page_data.rs +++ b/crates/settings_ui/src/page_data.rs @@ -1,12 +1,12 @@ -use gpui::App; +use gpui::{Action as _, App}; use settings::{LanguageSettingsContent, SettingsContent}; use std::sync::Arc; use strum::IntoDiscriminant as _; use ui::{IntoElement, SharedString}; use crate::{ - DynamicItem, PROJECT, SettingField, SettingItem, SettingsFieldMetadata, SettingsPage, - SettingsPageItem, SubPageLink, USER, all_language_names, sub_page_stack, + ActionLink, DynamicItem, PROJECT, SettingField, SettingItem, SettingsFieldMetadata, + SettingsPage, SettingsPageItem, SubPageLink, USER, all_language_names, sub_page_stack, }; const DEFAULT_STRING: String = String::new(); @@ -1054,6 +1054,25 @@ pub(crate) fn settings_data(cx: &App) -> Vec { SettingsPage { title: "Keymap", items: vec![ + SettingsPageItem::SectionHeader("Keybindings"), + SettingsPageItem::ActionLink(ActionLink { + title: "Edit Keybindings".into(), + description: Some("Customize keybindings in the keymap editor.".into()), + button_text: "Open Keymap".into(), + on_click: Arc::new(|settings_window, window, cx| { + let Some(original_window) = settings_window.original_window else { + return; + }; + original_window + .update(cx, |_workspace, original_window, cx| { + original_window + .dispatch_action(zed_actions::OpenKeymap.boxed_clone(), cx); + original_window.activate_window(); + }) + .ok(); + window.remove_window(); + }), + }), SettingsPageItem::SectionHeader("Base Keymap"), SettingsPageItem::SettingItem(SettingItem { title: "Base Keymap", diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs index bfc60cc1ea21525effa5347431d90ee219064d24..40678f6cf8d1c6773ccf1168e065cb318ae9f14f 100644 --- a/crates/settings_ui/src/settings_ui.rs +++ b/crates/settings_ui/src/settings_ui.rs @@ -731,6 +731,7 @@ enum SettingsPageItem { SettingItem(SettingItem), SubPageLink(SubPageLink), DynamicItem(DynamicItem), + ActionLink(ActionLink), } impl std::fmt::Debug for SettingsPageItem { @@ -746,6 +747,9 @@ impl std::fmt::Debug for SettingsPageItem { SettingsPageItem::DynamicItem(dynamic_item) => { write!(f, "DynamicItem({})", dynamic_item.discriminant.title) } + SettingsPageItem::ActionLink(action_link) => { + write!(f, "ActionLink({})", action_link.title) + } } } } @@ -973,6 +977,55 @@ impl SettingsPageItem { return content.into_any_element(); } + SettingsPageItem::ActionLink(action_link) => v_flex() + .group("setting-item") + .px_8() + .child( + h_flex() + .id(action_link.title.clone()) + .w_full() + .min_w_0() + .justify_between() + .map(apply_padding) + .child( + v_flex() + .relative() + .w_full() + .max_w_1_2() + .child(Label::new(action_link.title.clone())) + .when_some( + action_link.description.as_ref(), + |this, description| { + this.child( + Label::new(description.clone()) + .size(LabelSize::Small) + .color(Color::Muted), + ) + }, + ), + ) + .child( + Button::new( + ("action-link".into(), action_link.title.clone()), + action_link.button_text.clone(), + ) + .icon(IconName::ArrowUpRight) + .tab_index(0_isize) + .icon_position(IconPosition::End) + .icon_color(Color::Muted) + .icon_size(IconSize::Small) + .style(ButtonStyle::OutlinedGhost) + .size(ButtonSize::Medium) + .on_click({ + let on_click = action_link.on_click.clone(); + cx.listener(move |this, _, window, cx| { + on_click(this, window, cx); + }) + }), + ), + ) + .when(!is_last, |this| this.child(Divider::horizontal())) + .into_any_element(), } } } @@ -1207,6 +1260,20 @@ impl PartialEq for SubPageLink { } } +#[derive(Clone)] +struct ActionLink { + title: SharedString, + description: Option, + button_text: SharedString, + on_click: Arc, +} + +impl PartialEq for ActionLink { + fn eq(&self, other: &Self) -> bool { + self.title == other.title + } +} + fn all_language_names(cx: &App) -> Vec { workspace::AppState::global(cx) .upgrade() @@ -1626,6 +1693,9 @@ impl SettingsWindow { any_found_since_last_header = true; } } + SettingsPageItem::ActionLink(_) => { + any_found_since_last_header = true; + } } } if let Some(last_header) = page_filter.get_mut(header_index) @@ -1864,6 +1934,18 @@ impl SettingsWindow { sub_page_link.title.as_ref(), ); } + SettingsPageItem::ActionLink(action_link) => { + documents.push(bm25::Document { + id: key_index, + contents: [page.title, header_str, action_link.title.as_ref()] + .join("\n"), + }); + push_candidates( + &mut fuzzy_match_candidates, + key_index, + action_link.title.as_ref(), + ); + } } push_candidates(&mut fuzzy_match_candidates, key_index, page.title); push_candidates(&mut fuzzy_match_candidates, key_index, header_str); From b17b0972048029b3a6a3f05bec4bfbc0bc8ae216 Mon Sep 17 00:00:00 2001 From: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> Date: Tue, 16 Dec 2025 03:03:16 +0100 Subject: [PATCH 024/266] terminal: Sanitize URLs with characters that cannot be last (#43559) Closes #43345 The list of characters comes from the linkify crate, which is already used for URL detection in the editor: https://github.com/robinst/linkify/blob/5239e12e26c633f42323e51ed81b0ff534528077/src/url.rs#L228 Release Notes: - Improved url links detection in terminals. --------- Signed-off-by: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> --- crates/terminal/src/terminal_hyperlinks.rs | 80 +++++++++++++--------- 1 file changed, 49 insertions(+), 31 deletions(-) diff --git a/crates/terminal/src/terminal_hyperlinks.rs b/crates/terminal/src/terminal_hyperlinks.rs index cff27c4567cca84b2310723bf73bfda8d58c166d..8ff33895251f707c8bc9a7894bd74b0bb323ae6c 100644 --- a/crates/terminal/src/terminal_hyperlinks.rs +++ b/crates/terminal/src/terminal_hyperlinks.rs @@ -160,8 +160,8 @@ fn sanitize_url_punctuation( let mut sanitized_url = url; let mut chars_trimmed = 0; - // First, handle parentheses balancing using single traversal - let (open_parens, close_parens) = + // Count parentheses in the URL + let (open_parens, mut close_parens) = sanitized_url .chars() .fold((0, 0), |(opens, closes), c| match c { @@ -170,33 +170,27 @@ fn sanitize_url_punctuation( _ => (opens, closes), }); - // Trim unbalanced closing parentheses - if close_parens > open_parens { - let mut remaining_close = close_parens; - while sanitized_url.ends_with(')') && remaining_close > open_parens { - sanitized_url.pop(); - chars_trimmed += 1; - remaining_close -= 1; - } - } + // Remove trailing characters that shouldn't be at the end of URLs + while let Some(last_char) = sanitized_url.chars().last() { + let should_remove = match last_char { + // These may be part of a URL but not at the end. It's not that the spec + // doesn't allow them, but they are frequently used in plain text as delimiters + // where they're not meant to be part of the URL. + '.' | ',' | ':' | ';' => true, + '(' => true, + ')' if close_parens > open_parens => { + close_parens -= 1; + + true + } + _ => false, + }; - // Handle trailing periods - if sanitized_url.ends_with('.') { - let trailing_periods = sanitized_url - .chars() - .rev() - .take_while(|&c| c == '.') - .count(); - - if trailing_periods > 1 { - sanitized_url.truncate(sanitized_url.len() - trailing_periods); - chars_trimmed += trailing_periods; - } else if trailing_periods == 1 - && let Some(second_last_char) = sanitized_url.chars().rev().nth(1) - && (second_last_char.is_alphanumeric() || second_last_char == '/') - { + if should_remove { sanitized_url.pop(); chars_trimmed += 1; + } else { + break; } } @@ -413,6 +407,8 @@ mod tests { ("https://www.google.com/)", "https://www.google.com/"), ("https://example.com/path)", "https://example.com/path"), ("https://test.com/))", "https://test.com/"), + ("https://test.com/(((", "https://test.com/"), + ("https://test.com/(test)(", "https://test.com/(test)"), // Cases that should NOT be sanitized (balanced parentheses) ( "https://en.wikipedia.org/wiki/Example_(disambiguation)", @@ -443,10 +439,10 @@ mod tests { } #[test] - fn test_url_periods_sanitization() { - // Test URLs with trailing periods (sentence punctuation) + fn test_url_punctuation_sanitization() { + // Test URLs with trailing punctuation (sentence/text punctuation) + // The sanitize_url_punctuation function removes ., ,, :, ;, from the end let test_cases = vec![ - // Cases that should be sanitized (trailing periods likely punctuation) ("https://example.com.", "https://example.com"), ( "https://github.com/zed-industries/zed.", @@ -466,13 +462,36 @@ mod tests { "https://en.wikipedia.org/wiki/C.E.O.", "https://en.wikipedia.org/wiki/C.E.O", ), - // Cases that should NOT be sanitized (periods are part of URL structure) + ("https://example.com,", "https://example.com"), + ("https://example.com/path,", "https://example.com/path"), + ("https://example.com,,", "https://example.com"), + ("https://example.com:", "https://example.com"), + ("https://example.com/path:", "https://example.com/path"), + ("https://example.com::", "https://example.com"), + ("https://example.com;", "https://example.com"), + ("https://example.com/path;", "https://example.com/path"), + ("https://example.com;;", "https://example.com"), + ("https://example.com.,", "https://example.com"), + ("https://example.com.:;", "https://example.com"), + ("https://example.com!.", "https://example.com!"), + ("https://example.com/).", "https://example.com/"), + ("https://example.com/);", "https://example.com/"), + ("https://example.com/;)", "https://example.com/"), ( "https://example.com/v1.0/api", "https://example.com/v1.0/api", ), ("https://192.168.1.1", "https://192.168.1.1"), ("https://sub.domain.com", "https://sub.domain.com"), + ( + "https://example.com?query=value", + "https://example.com?query=value", + ), + ("https://example.com?a=1&b=2", "https://example.com?a=1&b=2"), + ( + "https://example.com/path:8080", + "https://example.com/path:8080", + ), ]; for (input, expected) in test_cases { @@ -484,7 +503,6 @@ mod tests { let end_point = AlacPoint::new(Line(0), Column(input.len())); let dummy_match = Match::new(start_point, end_point); - // This test should initially fail since we haven't implemented period sanitization yet let (result, _) = sanitize_url_punctuation(input.to_string(), dummy_match, &term); assert_eq!(result, expected, "Failed for input: {}", input); } From c7d248329bd28fee61e5c5c6915bce72687c066b Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Mon, 15 Dec 2025 21:57:19 -0500 Subject: [PATCH 025/266] Include project rules in commit message generation (#44921) Closes #38027 Release Notes: - AI-generated commit messages now respect rules files (e.g. `AGENTS.md`) if present --------- Co-authored-by: Claude Haiku 4.5 --- Cargo.lock | 1 + crates/agent/src/agent.rs | 15 +----- crates/git_ui/Cargo.toml | 1 + crates/git_ui/src/git_panel.rs | 79 +++++++++++++++++++++++++++--- crates/prompt_store/src/prompts.rs | 12 +++++ 5 files changed, 89 insertions(+), 19 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 8c1ade1714c9dd7f609582cc8bdf5184678afcd9..b43be6986b89bcd121416ded247e5bd944628cca 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7077,6 +7077,7 @@ dependencies = [ "picker", "pretty_assertions", "project", + "prompt_store", "rand 0.9.2", "recent_projects", "remote", diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index 092f735bb7c3713e70ea137c2bab485315aa8849..715c8682ba9b1e6d21c6558271c00180691f59f0 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -33,7 +33,8 @@ use gpui::{ use language_model::{LanguageModel, LanguageModelProvider, LanguageModelRegistry}; use project::{Project, ProjectItem, ProjectPath, Worktree}; use prompt_store::{ - ProjectContext, PromptStore, RulesFileContext, UserRulesContext, WorktreeContext, + ProjectContext, PromptStore, RULES_FILE_NAMES, RulesFileContext, UserRulesContext, + WorktreeContext, }; use serde::{Deserialize, Serialize}; use settings::{LanguageModelSelection, update_settings_file}; @@ -51,18 +52,6 @@ pub struct ProjectSnapshot { pub timestamp: DateTime, } -const RULES_FILE_NAMES: [&str; 9] = [ - ".rules", - ".cursorrules", - ".windsurfrules", - ".clinerules", - ".github/copilot-instructions.md", - "CLAUDE.md", - "AGENT.md", - "AGENTS.md", - "GEMINI.md", -]; - pub struct RulesLoadingError { pub message: SharedString, } diff --git a/crates/git_ui/Cargo.toml b/crates/git_ui/Cargo.toml index 6747daa09d2801ad8c05c17fb04cb3ab235cdbff..c88244a036767be0ef862e74faa2113d54125443 100644 --- a/crates/git_ui/Cargo.toml +++ b/crates/git_ui/Cargo.toml @@ -43,6 +43,7 @@ notifications.workspace = true panel.workspace = true picker.workspace = true project.workspace = true +prompt_store.workspace = true recent_projects.workspace = true remote.workspace = true schemars.workspace = true diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index d0618508ddbd153f4dcb1b77e974dc42ed2b0b32..362423b79fed0e8f3428d6784dd6f15b47708247 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -57,6 +57,7 @@ use project::{ git_store::{GitStoreEvent, Repository, RepositoryEvent, RepositoryId, pending_op}, project_settings::{GitPathStyle, ProjectSettings}, }; +use prompt_store::RULES_FILE_NAMES; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore, StatusStyle}; use std::future::Future; @@ -71,7 +72,7 @@ use ui::{ prelude::*, }; use util::paths::PathStyle; -use util::{ResultExt, TryFutureExt, maybe}; +use util::{ResultExt, TryFutureExt, maybe, rel_path::RelPath}; use workspace::SERIALIZATION_THROTTLE_TIME; use workspace::{ Workspace, @@ -2325,6 +2326,56 @@ impl GitPanel { compressed } + async fn load_project_rules( + project: &Entity, + repo_work_dir: &Arc, + cx: &mut AsyncApp, + ) -> Option { + let rules_path = cx + .update(|cx| { + for worktree in project.read(cx).worktrees(cx) { + let worktree_abs_path = worktree.read(cx).abs_path(); + if !worktree_abs_path.starts_with(&repo_work_dir) { + continue; + } + + let worktree_snapshot = worktree.read(cx).snapshot(); + for rules_name in RULES_FILE_NAMES { + if let Ok(rel_path) = RelPath::unix(rules_name) { + if let Some(entry) = worktree_snapshot.entry_for_path(rel_path) { + if entry.is_file() { + return Some(ProjectPath { + worktree_id: worktree.read(cx).id(), + path: entry.path.clone(), + }); + } + } + } + } + } + None + }) + .ok()??; + + let buffer = project + .update(cx, |project, cx| project.open_buffer(rules_path, cx)) + .ok()? + .await + .ok()?; + + let content = buffer + .read_with(cx, |buffer, _| buffer.text()) + .ok()? + .trim() + .to_string(); + + if content.is_empty() { + None + } else { + Some(content) + } + } + /// Generates a commit message using an LLM. pub fn generate_commit_message(&mut self, cx: &mut Context) { if !self.can_commit() || !AgentSettings::get_global(cx).enabled(cx) { @@ -2352,8 +2403,10 @@ impl GitPanel { }); let temperature = AgentSettings::temperature_for_model(&model, cx); + let project = self.project.clone(); + let repo_work_dir = repo.read(cx).work_directory_abs_path.clone(); - self.generate_commit_message_task = Some(cx.spawn(async move |this, cx| { + self.generate_commit_message_task = Some(cx.spawn(async move |this, mut cx| { async move { let _defer = cx.on_drop(&this, |this, _cx| { this.generate_commit_message_task.take(); @@ -2386,19 +2439,33 @@ impl GitPanel { const MAX_DIFF_BYTES: usize = 20_000; diff_text = Self::compress_commit_diff(&diff_text, MAX_DIFF_BYTES); + let rules_content = Self::load_project_rules(&project, &repo_work_dir, &mut cx).await; + let subject = this.update(cx, |this, cx| { this.commit_editor.read(cx).text(cx).lines().next().map(ToOwned::to_owned).unwrap_or_default() })?; let text_empty = subject.trim().is_empty(); - let content = if text_empty { - format!("{PROMPT}\nHere are the changes in this commit:\n{diff_text}") + const PROMPT: &str = include_str!("commit_message_prompt.txt"); + + let rules_section = match &rules_content { + Some(rules) => format!( + "\n\nThe user has provided the following project rules that you should follow when writing the commit message:\n\ + \n{rules}\n\n" + ), + None => String::new(), + }; + + let subject_section = if text_empty { + String::new() } else { - format!("{PROMPT}\nHere is the user's subject line:\n{subject}\nHere are the changes in this commit:\n{diff_text}\n") + format!("\nHere is the user's subject line:\n{subject}") }; - const PROMPT: &str = include_str!("commit_message_prompt.txt"); + let content = format!( + "{PROMPT}{rules_section}{subject_section}\nHere are the changes in this commit:\n{diff_text}" + ); let request = LanguageModelRequest { thread_id: None, diff --git a/crates/prompt_store/src/prompts.rs b/crates/prompt_store/src/prompts.rs index 847e45742db17fe194d002c26a67380390b68f06..674d4869e9825fd700dde3db510fbf68c6b4d5cc 100644 --- a/crates/prompt_store/src/prompts.rs +++ b/crates/prompt_store/src/prompts.rs @@ -20,6 +20,18 @@ use util::{ use crate::UserPromptId; +pub const RULES_FILE_NAMES: &[&str] = &[ + ".rules", + ".cursorrules", + ".windsurfrules", + ".clinerules", + ".github/copilot-instructions.md", + "CLAUDE.md", + "AGENT.md", + "AGENTS.md", + "GEMINI.md", +]; + #[derive(Default, Debug, Clone, Serialize)] pub struct ProjectContext { pub worktrees: Vec, From 829b1b5661dbcf976489c3d8021acdb8f4ed6af9 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Mon, 15 Dec 2025 20:53:50 -0700 Subject: [PATCH 026/266] Fix link opening (#44910) - **Fix editor::OpenUrl on zed links** - **Fix cmd-clicking links too** Closes #44293 Closes #43833 Release Notes: - The `editor::OpenUrl` action now works for links to https://zed.dev - Clicking on a link to a Zed channel or channel-note within the editor no-longer redirects you via the web. --------- Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com> --- crates/client/src/client.rs | 58 +++++++++++++++++++++++------ crates/editor/src/editor.rs | 9 ++++- crates/zed/src/zed/open_listener.rs | 41 +++++++------------- 3 files changed, 68 insertions(+), 40 deletions(-) diff --git a/crates/client/src/client.rs b/crates/client/src/client.rs index 14311d6bbf52ecb6df8dcc4a2fbc9454836a4834..801c8c3de8d3f02e3d73809df2c651c6973f231a 100644 --- a/crates/client/src/client.rs +++ b/crates/client/src/client.rs @@ -1730,23 +1730,59 @@ impl ProtoClient for Client { /// prefix for the zed:// url scheme pub const ZED_URL_SCHEME: &str = "zed"; +/// A parsed Zed link that can be handled internally by the application. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ZedLink { + /// Join a channel: `zed.dev/channel/channel-name-123` or `zed://channel/channel-name-123` + Channel { channel_id: u64 }, + /// Open channel notes: `zed.dev/channel/channel-name-123/notes` or with heading `notes#heading` + ChannelNotes { + channel_id: u64, + heading: Option, + }, +} + /// Parses the given link into a Zed link. /// -/// Returns a [`Some`] containing the unprefixed link if the link is a Zed link. -/// Returns [`None`] otherwise. -pub fn parse_zed_link<'a>(link: &'a str, cx: &App) -> Option<&'a str> { +/// Returns a [`Some`] containing the parsed link if the link is a recognized Zed link +/// that should be handled internally by the application. +/// Returns [`None`] for links that should be opened in the browser. +pub fn parse_zed_link(link: &str, cx: &App) -> Option { let server_url = &ClientSettings::get_global(cx).server_url; - if let Some(stripped) = link + let path = link .strip_prefix(server_url) .and_then(|result| result.strip_prefix('/')) - { - return Some(stripped); + .or_else(|| { + link.strip_prefix(ZED_URL_SCHEME) + .and_then(|result| result.strip_prefix("://")) + })?; + + let mut parts = path.split('/'); + + if parts.next() != Some("channel") { + return None; } - if let Some(stripped) = link - .strip_prefix(ZED_URL_SCHEME) - .and_then(|result| result.strip_prefix("://")) - { - return Some(stripped); + + let slug = parts.next()?; + let id_str = slug.split('-').next_back()?; + let channel_id = id_str.parse::().ok()?; + + let Some(next) = parts.next() else { + return Some(ZedLink::Channel { channel_id }); + }; + + if let Some(heading) = next.strip_prefix("notes#") { + return Some(ZedLink::ChannelNotes { + channel_id, + heading: Some(heading.to_string()), + }); + } + + if next == "notes" { + return Some(ZedLink::ChannelNotes { + channel_id, + heading: None, + }); } None diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 797a2c9121d7742b4d3e6948c74eb61731b66856..7178f7e3e4f31aa9fefd3c080a82c5099a934311 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -17467,7 +17467,14 @@ impl Editor { // If there is one url or file, open it directly match first_url_or_file { Some(Either::Left(url)) => { - cx.update(|_, cx| cx.open_url(&url))?; + cx.update(|window, cx| { + if parse_zed_link(&url, cx).is_some() { + window + .dispatch_action(Box::new(zed_actions::OpenZedUrl { url }), cx); + } else { + cx.open_url(&url); + } + })?; Ok(Navigated::Yes) } Some(Either::Right(path)) => { diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs index 3bf6bffda6c7cbbb3a6b0d0c8661acc432b71335..6352c20e5c0dcd0bd25063ca3a7bbcae87e48e3f 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -3,7 +3,7 @@ use crate::restorable_workspace_locations; use anyhow::{Context as _, Result, anyhow}; use cli::{CliRequest, CliResponse, ipc::IpcSender}; use cli::{IpcHandshake, ipc}; -use client::parse_zed_link; +use client::{ZedLink, parse_zed_link}; use collections::HashMap; use db::kvp::KEY_VALUE_STORE; use editor::Editor; @@ -112,8 +112,18 @@ impl OpenRequest { }); } else if url.starts_with("ssh://") { this.parse_ssh_file_path(&url, cx)? - } else if let Some(request_path) = parse_zed_link(&url, cx) { - this.parse_request_path(request_path).log_err(); + } else if let Some(zed_link) = parse_zed_link(&url, cx) { + match zed_link { + ZedLink::Channel { channel_id } => { + this.join_channel = Some(channel_id); + } + ZedLink::ChannelNotes { + channel_id, + heading, + } => { + this.open_channel_notes.push((channel_id, heading)); + } + } } else { log::error!("unhandled url: {}", url); } @@ -157,31 +167,6 @@ impl OpenRequest { self.parse_file_path(url.path()); Ok(()) } - - fn parse_request_path(&mut self, request_path: &str) -> Result<()> { - let mut parts = request_path.split('/'); - if parts.next() == Some("channel") - && let Some(slug) = parts.next() - && let Some(id_str) = slug.split('-').next_back() - && let Ok(channel_id) = id_str.parse::() - { - let Some(next) = parts.next() else { - self.join_channel = Some(channel_id); - return Ok(()); - }; - - if let Some(heading) = next.strip_prefix("notes#") { - self.open_channel_notes - .push((channel_id, Some(heading.to_string()))); - return Ok(()); - } - if next == "notes" { - self.open_channel_notes.push((channel_id, None)); - return Ok(()); - } - } - anyhow::bail!("invalid zed url: {request_path}") - } } #[derive(Clone)] From ee2a4a9d37dee1b421f6e44251fc5af2283f44ec Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Mon, 15 Dec 2025 22:10:33 -0700 Subject: [PATCH 027/266] Clean up screenshare (#44945) Release Notes: - Fixed a bug where screen-share tabs would persist after the sender (or receiver) had left the call. --- crates/call/src/call_impl/room.rs | 12 ++++++++++++ crates/workspace/src/shared_screen.rs | 5 +++++ 2 files changed, 17 insertions(+) diff --git a/crates/call/src/call_impl/room.rs b/crates/call/src/call_impl/room.rs index fc15b4e4395ae7aa3100a165d942a6906cf1976d..ccc8c067c25a91aa44c01911be89c21f0ea9367c 100644 --- a/crates/call/src/call_impl/room.rs +++ b/crates/call/src/call_impl/room.rs @@ -305,6 +305,7 @@ impl Room { pub(crate) fn leave(&mut self, cx: &mut Context) -> Task> { cx.notify(); + self.emit_video_track_unsubscribed_events(cx); self.leave_internal(cx) } @@ -352,6 +353,14 @@ impl Room { self.maintain_connection.take(); } + fn emit_video_track_unsubscribed_events(&self, cx: &mut Context) { + for participant in self.remote_participants.values() { + for sid in participant.video_tracks.keys() { + cx.emit(Event::RemoteVideoTrackUnsubscribed { sid: sid.clone() }); + } + } + } + async fn maintain_connection( this: WeakEntity, client: Arc, @@ -882,6 +891,9 @@ impl Room { project_id: project.id, }); } + for sid in participant.video_tracks.keys() { + cx.emit(Event::RemoteVideoTrackUnsubscribed { sid: sid.clone() }); + } false } }); diff --git a/crates/workspace/src/shared_screen.rs b/crates/workspace/src/shared_screen.rs index 3c009f613ea52906649b73bb9fd657bab6906c3b..564560274699ab6685d481340c5efd4b6336ed56 100644 --- a/crates/workspace/src/shared_screen.rs +++ b/crates/workspace/src/shared_screen.rs @@ -42,6 +42,11 @@ impl SharedScreen { }) .detach(); + cx.observe_release(&room, |_, _, cx| { + cx.emit(Event::Close); + }) + .detach(); + let view = cx.new(|cx| RemoteVideoTrackView::new(track.clone(), window, cx)); cx.subscribe(&view, |_, _, ev, cx| match ev { call::RemoteVideoTrackViewEvent::Close => cx.emit(Event::Close), From 6016d0b8c6a22e586158d3b6f810b3cebb136118 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Mon, 15 Dec 2025 22:19:18 -0700 Subject: [PATCH 028/266] Improve autofix (#44930) Release Notes: - N/A --- .github/workflows/autofix_pr.yml | 38 +++++++++++++++++-- script/prettier | 10 ++++- .../xtask/src/tasks/workflows/autofix_pr.rs | 28 +++++++++++--- 3 files changed, 64 insertions(+), 12 deletions(-) diff --git a/.github/workflows/autofix_pr.yml b/.github/workflows/autofix_pr.yml index 8c7786f6e1b91879a8b5a6f26f685570cd9cb2d3..308849ccbeed0be7f9ab5c8f7e5846ed61a8724d 100644 --- a/.github/workflows/autofix_pr.yml +++ b/.github/workflows/autofix_pr.yml @@ -11,7 +11,7 @@ on: type: string jobs: run_autofix: - runs-on: namespace-profile-2x4-ubuntu-2404 + runs-on: namespace-profile-16x32-ubuntu-2204 steps: - id: get-app-token name: autofix_pr::run_autofix::authenticate_as_zippy @@ -29,6 +29,31 @@ jobs: shell: bash -euxo pipefail {0} env: GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} + - name: steps::setup_cargo_config + run: | + mkdir -p ./../.cargo + cp ./.cargo/ci-config.toml ./../.cargo/config.toml + shell: bash -euxo pipefail {0} + - name: steps::cache_rust_dependencies_namespace + uses: namespacelabs/nscloud-cache-action@v1 + with: + cache: rust + - name: steps::setup_linux + run: ./script/linux + shell: bash -euxo pipefail {0} + - name: steps::install_mold + run: ./script/install-mold + shell: bash -euxo pipefail {0} + - name: steps::download_wasi_sdk + run: ./script/download-wasi-sdk + shell: bash -euxo pipefail {0} + - name: steps::setup_pnpm + uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 + with: + version: '9' + - name: autofix_pr::run_autofix::run_prettier_fix + run: ./script/prettier --write + shell: bash -euxo pipefail {0} - name: autofix_pr::run_autofix::run_cargo_fmt run: cargo fmt --all shell: bash -euxo pipefail {0} @@ -41,13 +66,18 @@ jobs: echo "No changes to commit" else git add -A - git commit -m "Apply cargo fmt and clippy --fix" + git commit -m "Autofix" git push fi shell: bash -euxo pipefail {0} env: GIT_COMMITTER_NAME: Zed Zippy - GIT_COMMITTER_EMAIL: hi@zed.dev + GIT_COMMITTER_EMAIL: 234243425+zed-zippy[bot]@users.noreply.github.com GIT_AUTHOR_NAME: Zed Zippy - GIT_AUTHOR_EMAIL: hi@zed.dev + GIT_AUTHOR_EMAIL: 234243425+zed-zippy[bot]@users.noreply.github.com GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} + - name: steps::cleanup_cargo_config + if: always() + run: | + rm -rf ./../.cargo + shell: bash -euxo pipefail {0} diff --git a/script/prettier b/script/prettier index 5ad5d15cf0353b71a40821f3092ea0e7928abf9d..d7a9ba787fca2343cd705ff0d37e502a7aa9f77c 100755 --- a/script/prettier +++ b/script/prettier @@ -3,14 +3,20 @@ set -euxo pipefail PRETTIER_VERSION=3.5.0 -pnpm dlx "prettier@${PRETTIER_VERSION}" assets/settings/default.json --parser=jsonc --check || { +if [[ "${1:-}" == "--write" ]]; then + MODE="--write" +else + MODE="--check" +fi + +pnpm dlx "prettier@${PRETTIER_VERSION}" assets/settings/default.json --parser=jsonc $MODE || { echo "To fix, run from the root of the Zed repo:" echo " pnpm dlx prettier@${PRETTIER_VERSION} assets/settings/default.json --parser=jsonc --write" false } cd docs -pnpm dlx "prettier@${PRETTIER_VERSION}" . --check || { +pnpm dlx "prettier@${PRETTIER_VERSION}" . $MODE || { echo "To fix, run from the root of the Zed repo:" echo " cd docs && pnpm dlx prettier@${PRETTIER_VERSION} . --write && cd .." false diff --git a/tooling/xtask/src/tasks/workflows/autofix_pr.rs b/tooling/xtask/src/tasks/workflows/autofix_pr.rs index 7e00a8bcbdbd9cd367221d2d90413fb59428d560..835750e282dad39a3455fc0b5eb69bf82cc42201 100644 --- a/tooling/xtask/src/tasks/workflows/autofix_pr.rs +++ b/tooling/xtask/src/tasks/workflows/autofix_pr.rs @@ -2,7 +2,7 @@ use gh_workflow::*; use crate::tasks::workflows::{ runners, - steps::{self, NamedJob, named}, + steps::{self, FluentBuilder, NamedJob, named}, vars::{self, StepOutput, WorkflowInput}, }; @@ -45,20 +45,30 @@ fn run_autofix(pr_number: &WorkflowInput) -> NamedJob { ) } + fn run_prettier_fix() -> Step { + named::bash("./script/prettier --write") + } + fn commit_and_push(token: &StepOutput) -> Step { named::bash(indoc::indoc! {r#" if git diff --quiet; then echo "No changes to commit" else git add -A - git commit -m "Apply cargo fmt and clippy --fix" + git commit -m "Autofix" git push fi "#}) .add_env(("GIT_COMMITTER_NAME", "Zed Zippy")) - .add_env(("GIT_COMMITTER_EMAIL", "hi@zed.dev")) + .add_env(( + "GIT_COMMITTER_EMAIL", + "234243425+zed-zippy[bot]@users.noreply.github.com", + )) .add_env(("GIT_AUTHOR_NAME", "Zed Zippy")) - .add_env(("GIT_AUTHOR_EMAIL", "hi@zed.dev")) + .add_env(( + "GIT_AUTHOR_EMAIL", + "234243425+zed-zippy[bot]@users.noreply.github.com", + )) .add_env(("GITHUB_TOKEN", token)) } @@ -66,12 +76,18 @@ fn run_autofix(pr_number: &WorkflowInput) -> NamedJob { named::job( Job::default() - .runs_on(runners::LINUX_SMALL) + .runs_on(runners::LINUX_DEFAULT) .add_step(authenticate) .add_step(steps::checkout_repo_with_token(&token)) .add_step(checkout_pr(pr_number, &token)) + .add_step(steps::setup_cargo_config(runners::Platform::Linux)) + .add_step(steps::cache_rust_dependencies_namespace()) + .map(steps::install_linux_dependencies) + .add_step(steps::setup_pnpm()) + .add_step(run_prettier_fix()) .add_step(run_cargo_fmt()) .add_step(run_clippy_fix()) - .add_step(commit_and_push(&token)), + .add_step(commit_and_push(&token)) + .add_step(steps::cleanup_cargo_config(runners::Platform::Linux)), ) } From 8ef37e8577c5a3134bc26870caffe466277b27e5 Mon Sep 17 00:00:00 2001 From: Bertie690 <136088738+Bertie690@users.noreply.github.com> Date: Tue, 16 Dec 2025 00:50:15 -0500 Subject: [PATCH 029/266] Remove outdated `Cargo.toml` comment about `declare_interior_mutable_const` (#44950) Since the rule is no longer a `style` lint as of [mid-August](https://github.com/rust-lang/rust-clippy/pull/15454), the comment mentioning it not being one is outdated and should be removed. > [!NOTE] > I kept the severity at `error` for now to avoid rustling feathers. > If `warn` is preferred, feel free to change it yourself or ask me to do it - it's only 1 line of code, after all. Release Notes: - N/A --- Cargo.toml | 2 -- 1 file changed, 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f3a5fefc7168c5296d032ae89ec5817673d9c333..903d17fc3378519d3e632f63c1a1a0e08e6513cb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -857,8 +857,6 @@ unexpected_cfgs = { level = "allow" } dbg_macro = "deny" todo = "deny" -# This is not a style lint, see https://github.com/rust-lang/rust-clippy/pull/15454 -# Remove when the lint gets promoted to `suspicious`. declare_interior_mutable_const = "deny" redundant_clone = "deny" From a1dbfd0d777615cbe83b75dfd5237bb392b20631 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Tue, 16 Dec 2025 08:15:01 +0200 Subject: [PATCH 030/266] Fix the `file_finder::Toggle` binding (#44951) Closes https://github.com/zed-industries/zed/issues/44752 Closes https://github.com/zed-industries/zed/pull/44756 Release Notes: - Fixed "file_finder::Toggle" action sometimes not working in JetBrains keymap --- assets/keymaps/linux/jetbrains.json | 4 +++- assets/keymaps/macos/jetbrains.json | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/assets/keymaps/linux/jetbrains.json b/assets/keymaps/linux/jetbrains.json index 3a54c92bf33decd968ee8d711fb1a929534ded21..d3bf53a0d3694943252e0fccb2ac821cc6c2a6d3 100644 --- a/assets/keymaps/linux/jetbrains.json +++ b/assets/keymaps/linux/jetbrains.json @@ -70,7 +70,9 @@ "bindings": { "ctrl-f12": "outline::Toggle", "ctrl-r": ["buffer_search::Deploy", { "replace_enabled": true }], + "ctrl-e": "file_finder::Toggle", "ctrl-shift-n": "file_finder::Toggle", + "ctrl-alt-n": "file_finder::Toggle", "ctrl-g": "go_to_line::Toggle", "alt-enter": "editor::ToggleCodeActions", "ctrl-space": "editor::ShowCompletions", @@ -105,8 +107,8 @@ "ctrl-e": "file_finder::Toggle", "ctrl-k": "git_panel::ToggleFocus", // bug: This should also focus commit editor "ctrl-shift-n": "file_finder::Toggle", - "ctrl-n": "project_symbols::Toggle", "ctrl-alt-n": "file_finder::Toggle", + "ctrl-n": "project_symbols::Toggle", "ctrl-shift-a": "command_palette::Toggle", "shift shift": "command_palette::Toggle", "ctrl-alt-shift-n": "project_symbols::Toggle", diff --git a/assets/keymaps/macos/jetbrains.json b/assets/keymaps/macos/jetbrains.json index 1721a9d743a67abddbc55a4b505be497920d15aa..9946d8b124957349181db659259174d906d08d3a 100644 --- a/assets/keymaps/macos/jetbrains.json +++ b/assets/keymaps/macos/jetbrains.json @@ -68,8 +68,10 @@ "bindings": { "cmd-f12": "outline::Toggle", "cmd-r": ["buffer_search::Deploy", { "replace_enabled": true }], - "cmd-shift-o": "file_finder::Toggle", "cmd-l": "go_to_line::Toggle", + "cmd-e": "file_finder::Toggle", + "cmd-shift-o": "file_finder::Toggle", + "cmd-shift-n": "file_finder::Toggle", "alt-enter": "editor::ToggleCodeActions", "ctrl-space": "editor::ShowCompletions", "cmd-j": "editor::Hover", From f760233704f927ea778b14bdb8121c085bf8b654 Mon Sep 17 00:00:00 2001 From: Hourann Date: Tue, 16 Dec 2025 15:32:25 +0800 Subject: [PATCH 031/266] workspace: Fix context menu triggering format on save (#44073) Closes #43989 Release Notes: - Fixed editor context menu triggering format on save --- crates/workspace/src/item.rs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs index 42eb754c21347e7dced792f3e56cb9901bc70bd1..bb4b10fa63dc884b8cf0ab8eee8e3bc34880b2a5 100644 --- a/crates/workspace/src/item.rs +++ b/crates/workspace/src/item.rs @@ -883,8 +883,14 @@ impl ItemHandle for Entity { if let Some(item) = weak_item.upgrade() && item.workspace_settings(cx).autosave == AutosaveSetting::OnFocusChange { - Pane::autosave_item(&item, workspace.project.clone(), window, cx) - .detach_and_log_err(cx); + // Only trigger autosave if focus has truly left the item. + // If focus is still within the item's hierarchy (e.g., moved to a context menu), + // don't trigger autosave to avoid unwanted formatting and cursor jumps. + let focus_handle = item.item_focus_handle(cx); + if !focus_handle.contains_focused(window, cx) { + Pane::autosave_item(&item, workspace.project.clone(), window, cx) + .detach_and_log_err(cx); + } } }, ) From ebd5a50cce74b1e903a1403a3e5f38ddff93b0c4 Mon Sep 17 00:00:00 2001 From: Patrick Elsen Date: Tue, 16 Dec 2025 09:11:10 +0100 Subject: [PATCH 032/266] language_models: Add `auto_discover` setting for Ollama (#42207) First up: I'm sorry if this is a low quality PR, or if this feature isn't wanted. I implemented this because I'd like to have this behaviour. If you don't think that this is useful, feel free to close the PR without comment. :) My idea is this: I love to pull random models with Ollama to try them. At the same time, not all of them are useful for coding, or some won't work out of the box with the context_length set. So, I'd like to change Zed's behaviour to not show me all models Ollama has, but to limit it to the ones that I configure manually. What I did is add an `auto_discover` field to the settings. The idea is that you can write a config like this: ```json "language_models": { "ollama": { "api_url": "http://localhost:11434", "auto_discover": false, "available_models": [ { "name": "qwen3:4b", "display_name": "Qwen3 4B 32K", "max_tokens": 32768, "supports_tools": true, "supports_thinking": true, "supports_images": true } ] } } ``` The `auto_discover: false` means that Zed won't pick up or show the language models that Ollama knows about, and will only show me the one I manually configured in `available_models`. That way, I can pull random models with Ollama, but in Zed I can only see the ones that I know work (because I've configured them). The default for `auto_discover` (when it is not explicitly set) is `true`, meaning that the existing behaviour is preserved, and this is not a breaking change for configurations. Release Notes: - ollama: Added `auto_discover` setting to optionally limit visible models to only those manually configured in `available_models` --- crates/language_models/src/provider/ollama.rs | 8 ++++-- crates/language_models/src/settings.rs | 1 + .../src/settings_content/language_model.rs | 1 + docs/src/ai/llm-providers.md | 27 +++++++++++++++++++ 4 files changed, 35 insertions(+), 2 deletions(-) diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index c961001e65be662e0023b3199f68dfbf4989e604..6f3c49f8669885bfd02e5b11b81a091b1248227c 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -43,6 +43,7 @@ static API_KEY_ENV_VAR: LazyLock = env_var!(API_KEY_ENV_VAR_NAME); #[derive(Default, Debug, Clone, PartialEq)] pub struct OllamaSettings { pub api_url: String, + pub auto_discover: bool, pub available_models: Vec, } @@ -238,10 +239,13 @@ impl LanguageModelProvider for OllamaLanguageModelProvider { fn provided_models(&self, cx: &App) -> Vec> { let mut models: HashMap = HashMap::new(); + let settings = OllamaLanguageModelProvider::settings(cx); // Add models from the Ollama API - for model in self.state.read(cx).fetched_models.iter() { - models.insert(model.name.clone(), model.clone()); + if settings.auto_discover { + for model in self.state.read(cx).fetched_models.iter() { + models.insert(model.name.clone(), model.clone()); + } } // Override with available models from settings diff --git a/crates/language_models/src/settings.rs b/crates/language_models/src/settings.rs index 43a8e7334a744c84d6edfae3ffc97115eb8f51b2..62f0025c755e10ea1bdae605d9dcc752298bb5f1 100644 --- a/crates/language_models/src/settings.rs +++ b/crates/language_models/src/settings.rs @@ -78,6 +78,7 @@ impl settings::Settings for AllLanguageModelSettings { }, ollama: OllamaSettings { api_url: ollama.api_url.unwrap(), + auto_discover: ollama.auto_discover.unwrap_or(true), available_models: ollama.available_models.unwrap_or_default(), }, open_router: OpenRouterSettings { diff --git a/crates/settings/src/settings_content/language_model.rs b/crates/settings/src/settings_content/language_model.rs index 48f5a463a4b8d896885d9ba5b7d804d16ecb5b6b..b106f3d9925cb4afe058cff44649f998c8b73d8a 100644 --- a/crates/settings/src/settings_content/language_model.rs +++ b/crates/settings/src/settings_content/language_model.rs @@ -92,6 +92,7 @@ pub enum BedrockAuthMethodContent { #[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq, JsonSchema, MergeFrom)] pub struct OllamaSettingsContent { pub api_url: Option, + pub auto_discover: Option, pub available_models: Option>, } diff --git a/docs/src/ai/llm-providers.md b/docs/src/ai/llm-providers.md index f13ece5d3eb6aac3af38a0046abddc474649f503..ee495b1ba7e67a6cc15359453fd7d3ae41b17233 100644 --- a/docs/src/ai/llm-providers.md +++ b/docs/src/ai/llm-providers.md @@ -347,6 +347,33 @@ Download and install Ollama from [ollama.com/download](https://ollama.com/downlo 3. In the Agent Panel, select one of the Ollama models using the model dropdown. +#### Ollama Autodiscovery + +Zed will automatically discover models that Ollama has pulled. You can turn this off by setting +the `auto_discover` field in the Ollama settings. If you do this, you should manually specify which +models are available. + +```json [settings] +{ + "language_models": { + "ollama": { + "api_url": "http://localhost:11434", + "auto_discover": false, + "available_models": [ + { + "name": "qwen2.5-coder", + "display_name": "qwen 2.5 coder", + "max_tokens": 32768, + "supports_tools": true, + "supports_thinking": true, + "supports_images": true + } + ] + } + } +} +``` + #### Ollama Context Length {#ollama-context} Zed has pre-configured maximum context lengths (`max_tokens`) to match the capabilities of common models. From 65e90017914eb2ae41e86435bd203329cc9724c3 Mon Sep 17 00:00:00 2001 From: daomah <129229601+daomah@users.noreply.github.com> Date: Tue, 16 Dec 2025 03:13:48 -0500 Subject: [PATCH 033/266] docs: Add documentation for installing via winget (#44941) Simple documentation PR. Added information for installing on Windows via winget. Added links from the main README to relevant sections for both macOS and Windows Release Notes: - N/A --- README.md | 2 +- docs/src/installation.md | 6 ++++++ docs/src/windows.md | 8 ++++++++ 3 files changed, 15 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index d1e2a75beccc9b115bd3b2e09bcc812aebc98329..d3a5fd20526e5eae6826241dce2bb94e8533ecb3 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ Welcome to Zed, a high-performance, multiplayer code editor from the creators of ### Installation -On macOS, Linux, and Windows you can [download Zed directly](https://zed.dev/download) or [install Zed via your local package manager](https://zed.dev/docs/linux#installing-via-a-package-manager). +On macOS, Linux, and Windows you can [download Zed directly](https://zed.dev/download) or install Zed via your local package manager ([macOS](https://zed.dev/docs/installation#macos)/[Linux](https://zed.dev/docs/linux#installing-via-a-package-manager)/[Windows](https://zed.dev/docs/windows#package-managers)). Other platforms are not yet available: diff --git a/docs/src/installation.md b/docs/src/installation.md index 7802ef7776a78deefb196ab005297e1f54314ea6..7d2009e3a0266160ce4e13056287c36ef7660008 100644 --- a/docs/src/installation.md +++ b/docs/src/installation.md @@ -22,6 +22,12 @@ brew install --cask zed@preview Get the latest stable builds via [the download page](https://zed.dev/download). If you want to download our preview build, you can find it on its [releases page](https://zed.dev/releases/preview). After the first manual installation, Zed will periodically check for install updates. +Additionally, you can install Zed using winget: + +```sh +winget install -e --id ZedIndustries.Zed +``` + ### Linux For most Linux users, the easiest way to install Zed is through our installation script: diff --git a/docs/src/windows.md b/docs/src/windows.md index 34a553dd5b032915ed52651f7f02b737995b959b..b7b4b6b7bf153a2cae7cbf2b7168d502cfbdaeb0 100644 --- a/docs/src/windows.md +++ b/docs/src/windows.md @@ -6,6 +6,14 @@ Get the latest stable builds via [the download page](https://zed.dev/download). You can also build zed from source, see [these docs](https://zed.dev/docs/development/windows) for instructions. +### Package managers + +Additionally, you can install Zed using winget: + +```sh +winget install -e --id ZedIndustries.Zed +``` + ## Uninstall - Installed via installer: Use `Settings` → `Apps` → `Installed apps`, search for Zed, and click Uninstall. From 81d8fb930aca1f5e1f0a50d76a8644262538d085 Mon Sep 17 00:00:00 2001 From: Mayank Verma Date: Tue, 16 Dec 2025 13:56:29 +0530 Subject: [PATCH 034/266] tab_switcher: Fix missing preview on initial ctrl-shift-tab press (#44959) Closes #44852 Release Notes: - Fixed tab preview not showing up on initial ctrl-shift-tab press --- crates/tab_switcher/src/tab_switcher.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/tab_switcher/src/tab_switcher.rs b/crates/tab_switcher/src/tab_switcher.rs index 85186ad504eb098264aae64ba3c2354d20d011a4..85bb5fbba6ad49f556ecca9a4863972adb8666ce 100644 --- a/crates/tab_switcher/src/tab_switcher.rs +++ b/crates/tab_switcher/src/tab_switcher.rs @@ -529,7 +529,9 @@ impl TabSwitcherDelegate { } if self.select_last { - return self.matches.len() - 1; + let item_index = self.matches.len() - 1; + self.set_selected_index(item_index, window, cx); + return item_index; } // This only runs when initially opening the picker From 9d4d37a514881af95be3b39809243be2c4ab7a68 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Tue, 16 Dec 2025 09:50:27 +0100 Subject: [PATCH 035/266] Revert "editor: Refactor cursor_offset_on_selection field in favor of VimModeSettings" (#44960) Reverts zed-industries/zed#44889 Release Notes: - N/A --- crates/editor/src/editor.rs | 31 ++++++++++++++++++------------- crates/editor/src/element.rs | 27 +++++++++++---------------- crates/vim/src/vim.rs | 1 + 3 files changed, 30 insertions(+), 29 deletions(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 7178f7e3e4f31aa9fefd3c080a82c5099a934311..05625d2f4e4e66de5c9fe55f62a02eef5d874df9 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -202,7 +202,6 @@ use ui::{ IconSize, Indicator, Key, Tooltip, h_flex, prelude::*, scrollbars::ScrollbarAutoHide, }; use util::{RangeExt, ResultExt, TryFutureExt, maybe, post_inc}; -use vim_mode_setting::VimModeSetting; use workspace::{ CollaboratorId, Item as WorkspaceItem, ItemId, ItemNavHistory, OpenInTerminal, OpenTerminal, RestoreOnStartupBehavior, SERIALIZATION_THROTTLE_TIME, SplitDirection, TabBarSettings, Toast, @@ -1111,6 +1110,9 @@ pub struct Editor { pending_rename: Option, searchable: bool, cursor_shape: CursorShape, + /// Whether the cursor is offset one character to the left when something is + /// selected (needed for vim visual mode) + cursor_offset_on_selection: bool, current_line_highlight: Option, pub collapse_matches: bool, autoindent_mode: Option, @@ -2286,6 +2288,7 @@ impl Editor { cursor_shape: EditorSettings::get_global(cx) .cursor_shape .unwrap_or_default(), + cursor_offset_on_selection: false, current_line_highlight: None, autoindent_mode: Some(AutoindentMode::EachLine), collapse_matches: false, @@ -2472,7 +2475,10 @@ impl Editor { } } EditorEvent::Edited { .. } => { - if !editor.is_vim_mode_enabled(cx) { + let vim_mode = vim_mode_setting::VimModeSetting::try_get(cx) + .map(|vim_mode| vim_mode.0) + .unwrap_or(false); + if !vim_mode { let display_map = editor.display_snapshot(cx); let selections = editor.selections.all_adjusted_display(&display_map); let pop_state = editor @@ -3101,6 +3107,10 @@ impl Editor { self.cursor_shape } + pub fn set_cursor_offset_on_selection(&mut self, set_cursor_offset_on_selection: bool) { + self.cursor_offset_on_selection = set_cursor_offset_on_selection; + } + pub fn set_current_line_highlight( &mut self, current_line_highlight: Option, @@ -22644,7 +22654,10 @@ impl Editor { .and_then(|e| e.to_str()) .map(|a| a.to_string())); - let vim_mode_enabled = self.is_vim_mode_enabled(cx); + let vim_mode = vim_mode_setting::VimModeSetting::try_get(cx) + .map(|vim_mode| vim_mode.0) + .unwrap_or(false); + let edit_predictions_provider = all_language_settings(file, cx).edit_predictions.provider; let copilot_enabled = edit_predictions_provider == language::language_settings::EditPredictionProvider::Copilot; @@ -22662,7 +22675,7 @@ impl Editor { event_type, type = if auto_saved {"autosave"} else {"manual"}, file_extension, - vim_mode_enabled, + vim_mode, copilot_enabled, copilot_enabled_for_language, edit_predictions_provider, @@ -22672,7 +22685,7 @@ impl Editor { telemetry::event!( event_type, file_extension, - vim_mode_enabled, + vim_mode, copilot_enabled, copilot_enabled_for_language, edit_predictions_provider, @@ -23287,14 +23300,6 @@ impl Editor { show_underlines: self.diagnostics_enabled(), } } - - /// Returns the value of the `vim_mode` setting, defaulting `false` if the - /// setting is not set. - pub(crate) fn is_vim_mode_enabled(&self, cx: &App) -> bool { - VimModeSetting::try_get(cx) - .map(|vim_mode| vim_mode.0) - .unwrap_or(false) - } } fn edit_for_markdown_paste<'a>( diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index efb0459b15b7b7e19a485a81753d39d7dd20b5de..8de660275ba9b455aec610568c41347888654495 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -133,7 +133,7 @@ impl SelectionLayout { fn new( selection: Selection, line_mode: bool, - vim_mode_enabled: bool, + cursor_offset: bool, cursor_shape: CursorShape, map: &DisplaySnapshot, is_newest: bool, @@ -154,7 +154,7 @@ impl SelectionLayout { } // any vim visual mode (including line mode) - if vim_mode_enabled && !range.is_empty() && !selection.reversed { + if cursor_offset && !range.is_empty() && !selection.reversed { if head.column() > 0 { head = map.clip_point(DisplayPoint::new(head.row(), head.column() - 1), Bias::Left); } else if head.row().0 > 0 && head != map.max_point() { @@ -1463,7 +1463,7 @@ impl EditorElement { let layout = SelectionLayout::new( selection, editor.selections.line_mode(), - editor.is_vim_mode_enabled(cx), + editor.cursor_offset_on_selection, editor.cursor_shape, &snapshot.display_snapshot, is_newest, @@ -1510,7 +1510,7 @@ impl EditorElement { let drag_cursor_layout = SelectionLayout::new( drop_cursor.clone(), false, - editor.is_vim_mode_enabled(cx), + editor.cursor_offset_on_selection, CursorShape::Bar, &snapshot.display_snapshot, false, @@ -1574,7 +1574,7 @@ impl EditorElement { .push(SelectionLayout::new( selection.selection, selection.line_mode, - editor.is_vim_mode_enabled(cx), + editor.cursor_offset_on_selection, selection.cursor_shape, &snapshot.display_snapshot, false, @@ -1585,7 +1585,8 @@ impl EditorElement { selections.extend(remote_selections.into_values()); } else if !editor.is_focused(window) && editor.show_cursor_when_unfocused { - let player = editor.current_user_player_color(cx); + let cursor_offset_on_selection = editor.cursor_offset_on_selection; + let layouts = snapshot .buffer_snapshot() .selections_in_range(&(start_anchor..end_anchor), true) @@ -1593,7 +1594,7 @@ impl EditorElement { SelectionLayout::new( selection, line_mode, - editor.is_vim_mode_enabled(cx), + cursor_offset_on_selection, cursor_shape, &snapshot.display_snapshot, false, @@ -1602,7 +1603,7 @@ impl EditorElement { ) }) .collect::>(); - + let player = editor.current_user_player_color(cx); selections.push((player, layouts)); } }); @@ -3317,7 +3318,7 @@ impl EditorElement { SelectionLayout::new( newest, editor.selections.line_mode(), - editor.is_vim_mode_enabled(cx), + editor.cursor_offset_on_selection, editor.cursor_shape, &snapshot.display_snapshot, true, @@ -11548,7 +11549,6 @@ mod tests { use log::info; use std::num::NonZeroU32; use util::test::sample_text; - use vim_mode_setting::VimModeSetting; #[gpui::test] async fn test_soft_wrap_editor_width_auto_height_editor(cx: &mut TestAppContext) { @@ -11893,12 +11893,6 @@ mod tests { async fn test_vim_visual_selections(cx: &mut TestAppContext) { init_test(cx, |_| {}); - // Enable `vim_mode` setting so the logic that checks whether this is - // enabled can work as expected. - cx.update(|cx| { - VimModeSetting::override_global(VimModeSetting(true), cx); - }); - let window = cx.add_window(|window, cx| { let buffer = MultiBuffer::build_simple(&(sample_text(6, 6, 'a') + "\n"), cx); Editor::new(EditorMode::full(), buffer, None, window, cx) @@ -11909,6 +11903,7 @@ mod tests { window .update(cx, |editor, window, cx| { + editor.cursor_offset_on_selection = true; editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { s.select_ranges([ Point::new(0, 0)..Point::new(1, 0), diff --git a/crates/vim/src/vim.rs b/crates/vim/src/vim.rs index 9a9a1a001c32fcf8b22892ce5300d8d2aec3dd37..26fec968fb261fbb80a9f84211357623147ca0f4 100644 --- a/crates/vim/src/vim.rs +++ b/crates/vim/src/vim.rs @@ -1943,6 +1943,7 @@ impl Vim { editor.set_collapse_matches(collapse_matches); editor.set_input_enabled(vim.editor_input_enabled()); editor.set_autoindent(vim.should_autoindent()); + editor.set_cursor_offset_on_selection(vim.mode.is_visual()); editor .selections .set_line_mode(matches!(vim.mode, Mode::VisualLine)); From a176a8c47efd8312875585349ab4228fa72d7ea4 Mon Sep 17 00:00:00 2001 From: Xiaobo Liu Date: Tue, 16 Dec 2025 16:50:40 +0800 Subject: [PATCH 036/266] agent: Allow LanguageModelImage size to be optional (#44956) Release Notes: - Improved allow LanguageModelImage size to be optional Signed-off-by: Xiaobo Liu --- crates/agent/src/thread.rs | 3 +- crates/language_model/src/request.rs | 36 +++++++++++-------- .../language_models/src/provider/mistral.rs | 2 +- 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index b61c0ad0840475c3b5f6d4c0a7082a26d4d44a58..837bf454a2431c4a1efa81679adc6ed9ef355908 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2662,7 +2662,6 @@ impl From for acp::ContentBlock { fn convert_image(image_content: acp::ImageContent) -> LanguageModelImage { LanguageModelImage { source: image_content.data.into(), - // TODO: make this optional? - size: gpui::Size::new(0.into(), 0.into()), + size: None, } } diff --git a/crates/language_model/src/request.rs b/crates/language_model/src/request.rs index d97d87bdc95c443aeaf3f2b5578bf7f0c1ef322a..5e99cca4f9d6e61672c541cb90a3a1ca7da91203 100644 --- a/crates/language_model/src/request.rs +++ b/crates/language_model/src/request.rs @@ -19,7 +19,8 @@ use crate::{LanguageModelToolUse, LanguageModelToolUseId}; pub struct LanguageModelImage { /// A base64-encoded PNG image. pub source: SharedString, - pub size: Size, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub size: Option>, } impl LanguageModelImage { @@ -61,7 +62,7 @@ impl LanguageModelImage { } Some(Self { - size: size(DevicePixels(width?), DevicePixels(height?)), + size: Some(size(DevicePixels(width?), DevicePixels(height?))), source: SharedString::from(source.to_string()), }) } @@ -83,7 +84,7 @@ impl LanguageModelImage { pub fn empty() -> Self { Self { source: "".into(), - size: size(DevicePixels(0), DevicePixels(0)), + size: None, } } @@ -139,15 +140,18 @@ impl LanguageModelImage { let source = unsafe { String::from_utf8_unchecked(base64_image) }; Some(LanguageModelImage { - size: image_size, + size: Some(image_size), source: source.into(), }) }) } pub fn estimate_tokens(&self) -> usize { - let width = self.size.width.0.unsigned_abs() as usize; - let height = self.size.height.0.unsigned_abs() as usize; + let Some(size) = self.size.as_ref() else { + return 0; + }; + let width = size.width.0.unsigned_abs() as usize; + let height = size.height.0.unsigned_abs() as usize; // From: https://docs.anthropic.com/en/docs/build-with-claude/vision#calculate-image-costs // Note that are a lot of conditions on Anthropic's API, and OpenAI doesn't use this, @@ -463,8 +467,9 @@ mod tests { match result { LanguageModelToolResultContent::Image(image) => { assert_eq!(image.source.as_ref(), "base64encodedimagedata"); - assert_eq!(image.size.width.0, 100); - assert_eq!(image.size.height.0, 200); + let size = image.size.expect("size"); + assert_eq!(size.width.0, 100); + assert_eq!(size.height.0, 200); } _ => panic!("Expected Image variant"), } @@ -483,8 +488,9 @@ mod tests { match result { LanguageModelToolResultContent::Image(image) => { assert_eq!(image.source.as_ref(), "wrappedimagedata"); - assert_eq!(image.size.width.0, 50); - assert_eq!(image.size.height.0, 75); + let size = image.size.expect("size"); + assert_eq!(size.width.0, 50); + assert_eq!(size.height.0, 75); } _ => panic!("Expected Image variant"), } @@ -503,8 +509,9 @@ mod tests { match result { LanguageModelToolResultContent::Image(image) => { assert_eq!(image.source.as_ref(), "caseinsensitive"); - assert_eq!(image.size.width.0, 30); - assert_eq!(image.size.height.0, 40); + let size = image.size.expect("size"); + assert_eq!(size.width.0, 30); + assert_eq!(size.height.0, 40); } _ => panic!("Expected Image variant"), } @@ -541,8 +548,9 @@ mod tests { match result { LanguageModelToolResultContent::Image(image) => { assert_eq!(image.source.as_ref(), "directimage"); - assert_eq!(image.size.width.0, 200); - assert_eq!(image.size.height.0, 300); + let size = image.size.expect("size"); + assert_eq!(size.width.0, 200); + assert_eq!(size.height.0, 300); } _ => panic!("Expected Image variant"), } diff --git a/crates/language_models/src/provider/mistral.rs b/crates/language_models/src/provider/mistral.rs index 3e99f32be8224bb2b9973feccb0ce973b58eaaed..64f3999e3aa96b2611e265a6eaf5df8063332c2a 100644 --- a/crates/language_models/src/provider/mistral.rs +++ b/crates/language_models/src/provider/mistral.rs @@ -927,7 +927,7 @@ mod tests { MessageContent::Text("What's in this image?".into()), MessageContent::Image(LanguageModelImage { source: "base64data".into(), - size: Default::default(), + size: None, }), ], cache: false, From 9c32c29238d2f4b6006e61b979079482bf07f9dd Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Tue, 16 Dec 2025 01:53:08 -0700 Subject: [PATCH 037/266] Revert "Add save_file and restore_file_from_disk agent tools" (#44949) Reverts zed-industries/zed#44789 Need to fix a bug Release Notes: - N/A --- crates/agent/src/thread.rs | 5 +- crates/agent/src/tools.rs | 8 +- crates/agent/src/tools/edit_file_tool.rs | 23 +- .../src/tools/restore_file_from_disk_tool.rs | 352 ------------------ crates/agent/src/tools/save_file_tool.rs | 351 ----------------- 5 files changed, 7 insertions(+), 732 deletions(-) delete mode 100644 crates/agent/src/tools/restore_file_from_disk_tool.rs delete mode 100644 crates/agent/src/tools/save_file_tool.rs diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index 837bf454a2431c4a1efa81679adc6ed9ef355908..dbf29c68766cfe28d0bce1d82ed53536446326e2 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2,8 +2,7 @@ use crate::{ ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DbLanguageModel, DbThread, DeletePathTool, DiagnosticsTool, EditFileTool, FetchTool, FindPathTool, GrepTool, ListDirectoryTool, MovePathTool, NowTool, OpenTool, ProjectSnapshot, ReadFileTool, - RestoreFileFromDiskTool, SaveFileTool, SystemPromptTemplate, Template, Templates, TerminalTool, - ThinkingTool, WebSearchTool, + SystemPromptTemplate, Template, Templates, TerminalTool, ThinkingTool, WebSearchTool, }; use acp_thread::{MentionUri, UserMessageId}; use action_log::ActionLog; @@ -1003,8 +1002,6 @@ impl Thread { self.project.clone(), self.action_log.clone(), )); - self.add_tool(SaveFileTool::new(self.project.clone())); - self.add_tool(RestoreFileFromDiskTool::new(self.project.clone())); self.add_tool(TerminalTool::new(self.project.clone(), environment)); self.add_tool(ThinkingTool); self.add_tool(WebSearchTool); diff --git a/crates/agent/src/tools.rs b/crates/agent/src/tools.rs index 358903a32baa5ead9b073642015e6829501307a2..62a52998a705e11d1c9e69cbade7f427cc9cfc32 100644 --- a/crates/agent/src/tools.rs +++ b/crates/agent/src/tools.rs @@ -4,6 +4,7 @@ mod create_directory_tool; mod delete_path_tool; mod diagnostics_tool; mod edit_file_tool; + mod fetch_tool; mod find_path_tool; mod grep_tool; @@ -12,8 +13,6 @@ mod move_path_tool; mod now_tool; mod open_tool; mod read_file_tool; -mod restore_file_from_disk_tool; -mod save_file_tool; mod terminal_tool; mod thinking_tool; @@ -28,6 +27,7 @@ pub use create_directory_tool::*; pub use delete_path_tool::*; pub use diagnostics_tool::*; pub use edit_file_tool::*; + pub use fetch_tool::*; pub use find_path_tool::*; pub use grep_tool::*; @@ -36,8 +36,6 @@ pub use move_path_tool::*; pub use now_tool::*; pub use open_tool::*; pub use read_file_tool::*; -pub use restore_file_from_disk_tool::*; -pub use save_file_tool::*; pub use terminal_tool::*; pub use thinking_tool::*; @@ -94,8 +92,6 @@ tools! { NowTool, OpenTool, ReadFileTool, - RestoreFileFromDiskTool, - SaveFileTool, TerminalTool, ThinkingTool, WebSearchTool, diff --git a/crates/agent/src/tools/edit_file_tool.rs b/crates/agent/src/tools/edit_file_tool.rs index c08300e19541cad49033093f0d2bbe3a5b233683..0ab99426e2e9645adf3f837d21c28dc285ab6ea2 100644 --- a/crates/agent/src/tools/edit_file_tool.rs +++ b/crates/agent/src/tools/edit_file_tool.rs @@ -316,9 +316,9 @@ impl AgentTool for EditFileTool { // Check for unsaved changes first - these indicate modifications we don't know about if is_dirty { anyhow::bail!( - "This file has unsaved changes. Ask the user whether they want to keep or discard those changes. \ - If they want to keep them, ask for confirmation then use the save_file tool to save the file, then retry this edit. \ - If they want to discard them, ask for confirmation then use the restore_file_from_disk tool to restore the on-disk contents, then retry this edit." + "This file cannot be written to because it has unsaved changes. \ + Please end the current conversation immediately by telling the user you want to write to this file (mention its path explicitly) but you can't write to it because it has unsaved changes. \ + Ask the user to save that buffer's changes and to inform you when it's ok to proceed." ); } @@ -2202,24 +2202,9 @@ mod tests { assert!(result.is_err(), "Edit should fail when buffer is dirty"); let error_msg = result.unwrap_err().to_string(); assert!( - error_msg.contains("This file has unsaved changes."), + error_msg.contains("cannot be written to because it has unsaved changes"), "Error should mention unsaved changes, got: {}", error_msg ); - assert!( - error_msg.contains("keep or discard"), - "Error should ask whether to keep or discard changes, got: {}", - error_msg - ); - assert!( - error_msg.contains("save_file"), - "Error should reference save_file tool, got: {}", - error_msg - ); - assert!( - error_msg.contains("restore_file_from_disk"), - "Error should reference restore_file_from_disk tool, got: {}", - error_msg - ); } } diff --git a/crates/agent/src/tools/restore_file_from_disk_tool.rs b/crates/agent/src/tools/restore_file_from_disk_tool.rs deleted file mode 100644 index f5723f6ee3ee46144152dd3ed2939ab2cfaca9c0..0000000000000000000000000000000000000000 --- a/crates/agent/src/tools/restore_file_from_disk_tool.rs +++ /dev/null @@ -1,352 +0,0 @@ -use agent_client_protocol as acp; -use anyhow::Result; -use collections::FxHashSet; -use gpui::{App, Entity, SharedString, Task}; -use language::Buffer; -use project::Project; -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; -use std::path::PathBuf; -use std::sync::Arc; - -use crate::{AgentTool, ToolCallEventStream}; - -/// Discards unsaved changes in open buffers by reloading file contents from disk. -/// -/// Use this tool when: -/// - You attempted to edit files but they have unsaved changes the user does not want to keep. -/// - You want to reset files to the on-disk state before retrying an edit. -/// -/// Only use this tool after asking the user for permission, because it will discard unsaved changes. -#[derive(Debug, Serialize, Deserialize, JsonSchema)] -pub struct RestoreFileFromDiskToolInput { - /// The paths of the files to restore from disk. - pub paths: Vec, -} - -pub struct RestoreFileFromDiskTool { - project: Entity, -} - -impl RestoreFileFromDiskTool { - pub fn new(project: Entity) -> Self { - Self { project } - } -} - -impl AgentTool for RestoreFileFromDiskTool { - type Input = RestoreFileFromDiskToolInput; - type Output = String; - - fn name() -> &'static str { - "restore_file_from_disk" - } - - fn kind() -> acp::ToolKind { - acp::ToolKind::Other - } - - fn initial_title( - &self, - input: Result, - _cx: &mut App, - ) -> SharedString { - match input { - Ok(input) if input.paths.len() == 1 => "Restore file from disk".into(), - Ok(input) => format!("Restore {} files from disk", input.paths.len()).into(), - Err(_) => "Restore files from disk".into(), - } - } - - fn run( - self: Arc, - input: Self::Input, - _event_stream: ToolCallEventStream, - cx: &mut App, - ) -> Task> { - let project = self.project.clone(); - let input_paths = input.paths; - - cx.spawn(async move |cx| { - let mut buffers_to_reload: FxHashSet> = FxHashSet::default(); - - let mut restored_paths: Vec = Vec::new(); - let mut clean_paths: Vec = Vec::new(); - let mut not_found_paths: Vec = Vec::new(); - let mut open_errors: Vec<(PathBuf, String)> = Vec::new(); - let mut dirty_check_errors: Vec<(PathBuf, String)> = Vec::new(); - let mut reload_errors: Vec = Vec::new(); - - for path in input_paths { - let project_path = - project.read_with(cx, |project, cx| project.find_project_path(&path, cx)); - - let project_path = match project_path { - Ok(Some(project_path)) => project_path, - Ok(None) => { - not_found_paths.push(path); - continue; - } - Err(error) => { - open_errors.push((path, error.to_string())); - continue; - } - }; - - let open_buffer_task = - project.update(cx, |project, cx| project.open_buffer(project_path, cx)); - - let buffer = match open_buffer_task { - Ok(task) => match task.await { - Ok(buffer) => buffer, - Err(error) => { - open_errors.push((path, error.to_string())); - continue; - } - }, - Err(error) => { - open_errors.push((path, error.to_string())); - continue; - } - }; - - let is_dirty = match buffer.read_with(cx, |buffer, _| buffer.is_dirty()) { - Ok(is_dirty) => is_dirty, - Err(error) => { - dirty_check_errors.push((path, error.to_string())); - continue; - } - }; - - if is_dirty { - buffers_to_reload.insert(buffer); - restored_paths.push(path); - } else { - clean_paths.push(path); - } - } - - if !buffers_to_reload.is_empty() { - let reload_task = project.update(cx, |project, cx| { - project.reload_buffers(buffers_to_reload, true, cx) - }); - - match reload_task { - Ok(task) => { - if let Err(error) = task.await { - reload_errors.push(error.to_string()); - } - } - Err(error) => { - reload_errors.push(error.to_string()); - } - } - } - - let mut lines: Vec = Vec::new(); - - if !restored_paths.is_empty() { - lines.push(format!("Restored {} file(s).", restored_paths.len())); - } - if !clean_paths.is_empty() { - lines.push(format!("{} clean.", clean_paths.len())); - } - - if !not_found_paths.is_empty() { - lines.push(format!("Not found ({}):", not_found_paths.len())); - for path in ¬_found_paths { - lines.push(format!("- {}", path.display())); - } - } - if !open_errors.is_empty() { - lines.push(format!("Open failed ({}):", open_errors.len())); - for (path, error) in &open_errors { - lines.push(format!("- {}: {}", path.display(), error)); - } - } - if !dirty_check_errors.is_empty() { - lines.push(format!( - "Dirty check failed ({}):", - dirty_check_errors.len() - )); - for (path, error) in &dirty_check_errors { - lines.push(format!("- {}: {}", path.display(), error)); - } - } - if !reload_errors.is_empty() { - lines.push(format!("Reload failed ({}):", reload_errors.len())); - for error in &reload_errors { - lines.push(format!("- {}", error)); - } - } - - if lines.is_empty() { - Ok("No paths provided.".to_string()) - } else { - Ok(lines.join("\n")) - } - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use fs::Fs; - use gpui::TestAppContext; - use language::LineEnding; - use project::FakeFs; - use serde_json::json; - use settings::SettingsStore; - use util::path; - - fn init_test(cx: &mut TestAppContext) { - cx.update(|cx| { - let settings_store = SettingsStore::test(cx); - cx.set_global(settings_store); - }); - } - - #[gpui::test] - async fn test_restore_file_from_disk_output_and_effects(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree( - "/root", - json!({ - "dirty.txt": "on disk: dirty\n", - "clean.txt": "on disk: clean\n", - }), - ) - .await; - - let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await; - let tool = Arc::new(RestoreFileFromDiskTool::new(project.clone())); - - // Make dirty.txt dirty in-memory by saving different content into the buffer without saving to disk. - let dirty_project_path = project.read_with(cx, |project, cx| { - project - .find_project_path("root/dirty.txt", cx) - .expect("dirty.txt should exist in project") - }); - - let dirty_buffer = project - .update(cx, |project, cx| { - project.open_buffer(dirty_project_path, cx) - }) - .await - .unwrap(); - dirty_buffer.update(cx, |buffer, cx| { - buffer.edit([(0..buffer.len(), "in memory: dirty\n")], None, cx); - }); - assert!( - dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "dirty.txt buffer should be dirty before restore" - ); - - // Ensure clean.txt is opened but remains clean. - let clean_project_path = project.read_with(cx, |project, cx| { - project - .find_project_path("root/clean.txt", cx) - .expect("clean.txt should exist in project") - }); - - let clean_buffer = project - .update(cx, |project, cx| { - project.open_buffer(clean_project_path, cx) - }) - .await - .unwrap(); - assert!( - !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "clean.txt buffer should start clean" - ); - - let output = cx - .update(|cx| { - tool.clone().run( - RestoreFileFromDiskToolInput { - paths: vec![ - PathBuf::from("root/dirty.txt"), - PathBuf::from("root/clean.txt"), - ], - }, - ToolCallEventStream::test().0, - cx, - ) - }) - .await - .unwrap(); - - // Output should mention restored + clean. - assert!( - output.contains("Restored 1 file(s)."), - "expected restored count line, got:\n{output}" - ); - assert!( - output.contains("1 clean."), - "expected clean count line, got:\n{output}" - ); - - // Effect: dirty buffer should be restored back to disk content and become clean. - let dirty_text = dirty_buffer.read_with(cx, |buffer, _| buffer.text()); - assert_eq!( - dirty_text, "on disk: dirty\n", - "dirty.txt buffer should be restored to disk contents" - ); - assert!( - !dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "dirty.txt buffer should not be dirty after restore" - ); - - // Disk contents should be unchanged (restore-from-disk should not write). - let disk_dirty = fs.load(path!("/root/dirty.txt").as_ref()).await.unwrap(); - assert_eq!(disk_dirty, "on disk: dirty\n"); - - // Sanity: clean buffer should remain clean and unchanged. - let clean_text = clean_buffer.read_with(cx, |buffer, _| buffer.text()); - assert_eq!(clean_text, "on disk: clean\n"); - assert!( - !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "clean.txt buffer should remain clean" - ); - - // Test empty paths case. - let output = cx - .update(|cx| { - tool.clone().run( - RestoreFileFromDiskToolInput { paths: vec![] }, - ToolCallEventStream::test().0, - cx, - ) - }) - .await - .unwrap(); - assert_eq!(output, "No paths provided."); - - // Test not-found path case (path outside the project root). - let output = cx - .update(|cx| { - tool.clone().run( - RestoreFileFromDiskToolInput { - paths: vec![PathBuf::from("nonexistent/path.txt")], - }, - ToolCallEventStream::test().0, - cx, - ) - }) - .await - .unwrap(); - assert!( - output.contains("Not found (1):"), - "expected not-found header line, got:\n{output}" - ); - assert!( - output.contains("- nonexistent/path.txt"), - "expected not-found path bullet, got:\n{output}" - ); - - let _ = LineEnding::Unix; // keep import used if the buffer edit API changes - } -} diff --git a/crates/agent/src/tools/save_file_tool.rs b/crates/agent/src/tools/save_file_tool.rs deleted file mode 100644 index 429352200109c52303c9f6f94a28a49136af1a61..0000000000000000000000000000000000000000 --- a/crates/agent/src/tools/save_file_tool.rs +++ /dev/null @@ -1,351 +0,0 @@ -use agent_client_protocol as acp; -use anyhow::Result; -use collections::FxHashSet; -use gpui::{App, Entity, SharedString, Task}; -use language::Buffer; -use project::Project; -use schemars::JsonSchema; -use serde::{Deserialize, Serialize}; -use std::path::PathBuf; -use std::sync::Arc; - -use crate::{AgentTool, ToolCallEventStream}; - -/// Saves files that have unsaved changes. -/// -/// Use this tool when you need to edit files but they have unsaved changes that must be saved first. -/// Only use this tool after asking the user for permission to save their unsaved changes. -#[derive(Debug, Serialize, Deserialize, JsonSchema)] -pub struct SaveFileToolInput { - /// The paths of the files to save. - pub paths: Vec, -} - -pub struct SaveFileTool { - project: Entity, -} - -impl SaveFileTool { - pub fn new(project: Entity) -> Self { - Self { project } - } -} - -impl AgentTool for SaveFileTool { - type Input = SaveFileToolInput; - type Output = String; - - fn name() -> &'static str { - "save_file" - } - - fn kind() -> acp::ToolKind { - acp::ToolKind::Other - } - - fn initial_title( - &self, - input: Result, - _cx: &mut App, - ) -> SharedString { - match input { - Ok(input) if input.paths.len() == 1 => "Save file".into(), - Ok(input) => format!("Save {} files", input.paths.len()).into(), - Err(_) => "Save files".into(), - } - } - - fn run( - self: Arc, - input: Self::Input, - _event_stream: ToolCallEventStream, - cx: &mut App, - ) -> Task> { - let project = self.project.clone(); - let input_paths = input.paths; - - cx.spawn(async move |cx| { - let mut buffers_to_save: FxHashSet> = FxHashSet::default(); - - let mut saved_paths: Vec = Vec::new(); - let mut clean_paths: Vec = Vec::new(); - let mut not_found_paths: Vec = Vec::new(); - let mut open_errors: Vec<(PathBuf, String)> = Vec::new(); - let mut dirty_check_errors: Vec<(PathBuf, String)> = Vec::new(); - let mut save_errors: Vec<(String, String)> = Vec::new(); - - for path in input_paths { - let project_path = - project.read_with(cx, |project, cx| project.find_project_path(&path, cx)); - - let project_path = match project_path { - Ok(Some(project_path)) => project_path, - Ok(None) => { - not_found_paths.push(path); - continue; - } - Err(error) => { - open_errors.push((path, error.to_string())); - continue; - } - }; - - let open_buffer_task = - project.update(cx, |project, cx| project.open_buffer(project_path, cx)); - - let buffer = match open_buffer_task { - Ok(task) => match task.await { - Ok(buffer) => buffer, - Err(error) => { - open_errors.push((path, error.to_string())); - continue; - } - }, - Err(error) => { - open_errors.push((path, error.to_string())); - continue; - } - }; - - let is_dirty = match buffer.read_with(cx, |buffer, _| buffer.is_dirty()) { - Ok(is_dirty) => is_dirty, - Err(error) => { - dirty_check_errors.push((path, error.to_string())); - continue; - } - }; - - if is_dirty { - buffers_to_save.insert(buffer); - saved_paths.push(path); - } else { - clean_paths.push(path); - } - } - - // Save each buffer individually since there's no batch save API. - for buffer in buffers_to_save { - let path_for_buffer = match buffer.read_with(cx, |buffer, _| { - buffer - .file() - .map(|file| file.path().to_rel_path_buf()) - .map(|path| path.as_rel_path().as_unix_str().to_owned()) - }) { - Ok(path) => path.unwrap_or_else(|| "".to_string()), - Err(error) => { - save_errors.push(("".to_string(), error.to_string())); - continue; - } - }; - - let save_task = project.update(cx, |project, cx| project.save_buffer(buffer, cx)); - - match save_task { - Ok(task) => { - if let Err(error) = task.await { - save_errors.push((path_for_buffer, error.to_string())); - } - } - Err(error) => { - save_errors.push((path_for_buffer, error.to_string())); - } - } - } - - let mut lines: Vec = Vec::new(); - - if !saved_paths.is_empty() { - lines.push(format!("Saved {} file(s).", saved_paths.len())); - } - if !clean_paths.is_empty() { - lines.push(format!("{} clean.", clean_paths.len())); - } - - if !not_found_paths.is_empty() { - lines.push(format!("Not found ({}):", not_found_paths.len())); - for path in ¬_found_paths { - lines.push(format!("- {}", path.display())); - } - } - if !open_errors.is_empty() { - lines.push(format!("Open failed ({}):", open_errors.len())); - for (path, error) in &open_errors { - lines.push(format!("- {}: {}", path.display(), error)); - } - } - if !dirty_check_errors.is_empty() { - lines.push(format!( - "Dirty check failed ({}):", - dirty_check_errors.len() - )); - for (path, error) in &dirty_check_errors { - lines.push(format!("- {}: {}", path.display(), error)); - } - } - if !save_errors.is_empty() { - lines.push(format!("Save failed ({}):", save_errors.len())); - for (path, error) in &save_errors { - lines.push(format!("- {}: {}", path, error)); - } - } - - if lines.is_empty() { - Ok("No paths provided.".to_string()) - } else { - Ok(lines.join("\n")) - } - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use fs::Fs; - use gpui::TestAppContext; - use project::FakeFs; - use serde_json::json; - use settings::SettingsStore; - use util::path; - - fn init_test(cx: &mut TestAppContext) { - cx.update(|cx| { - let settings_store = SettingsStore::test(cx); - cx.set_global(settings_store); - }); - } - - #[gpui::test] - async fn test_save_file_output_and_effects(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree( - "/root", - json!({ - "dirty.txt": "on disk: dirty\n", - "clean.txt": "on disk: clean\n", - }), - ) - .await; - - let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await; - let tool = Arc::new(SaveFileTool::new(project.clone())); - - // Make dirty.txt dirty in-memory. - let dirty_project_path = project.read_with(cx, |project, cx| { - project - .find_project_path("root/dirty.txt", cx) - .expect("dirty.txt should exist in project") - }); - - let dirty_buffer = project - .update(cx, |project, cx| { - project.open_buffer(dirty_project_path, cx) - }) - .await - .unwrap(); - dirty_buffer.update(cx, |buffer, cx| { - buffer.edit([(0..buffer.len(), "in memory: dirty\n")], None, cx); - }); - assert!( - dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "dirty.txt buffer should be dirty before save" - ); - - // Ensure clean.txt is opened but remains clean. - let clean_project_path = project.read_with(cx, |project, cx| { - project - .find_project_path("root/clean.txt", cx) - .expect("clean.txt should exist in project") - }); - - let clean_buffer = project - .update(cx, |project, cx| { - project.open_buffer(clean_project_path, cx) - }) - .await - .unwrap(); - assert!( - !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "clean.txt buffer should start clean" - ); - - let output = cx - .update(|cx| { - tool.clone().run( - SaveFileToolInput { - paths: vec![ - PathBuf::from("root/dirty.txt"), - PathBuf::from("root/clean.txt"), - ], - }, - ToolCallEventStream::test().0, - cx, - ) - }) - .await - .unwrap(); - - // Output should mention saved + clean. - assert!( - output.contains("Saved 1 file(s)."), - "expected saved count line, got:\n{output}" - ); - assert!( - output.contains("1 clean."), - "expected clean count line, got:\n{output}" - ); - - // Effect: dirty buffer should now be clean and disk should have new content. - assert!( - !dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), - "dirty.txt buffer should not be dirty after save" - ); - - let disk_dirty = fs.load(path!("/root/dirty.txt").as_ref()).await.unwrap(); - assert_eq!( - disk_dirty, "in memory: dirty\n", - "dirty.txt disk content should be updated" - ); - - // Sanity: clean buffer should remain clean and disk unchanged. - let disk_clean = fs.load(path!("/root/clean.txt").as_ref()).await.unwrap(); - assert_eq!(disk_clean, "on disk: clean\n"); - - // Test empty paths case. - let output = cx - .update(|cx| { - tool.clone().run( - SaveFileToolInput { paths: vec![] }, - ToolCallEventStream::test().0, - cx, - ) - }) - .await - .unwrap(); - assert_eq!(output, "No paths provided."); - - // Test not-found path case. - let output = cx - .update(|cx| { - tool.clone().run( - SaveFileToolInput { - paths: vec![PathBuf::from("nonexistent/path.txt")], - }, - ToolCallEventStream::test().0, - cx, - ) - }) - .await - .unwrap(); - assert!( - output.contains("Not found (1):"), - "expected not-found header line, got:\n{output}" - ); - assert!( - output.contains("- nonexistent/path.txt"), - "expected not-found path bullet, got:\n{output}" - ); - } -} From 9ec147db6751ec60d0a80578f8ef01767fc0db69 Mon Sep 17 00:00:00 2001 From: Moritz Bitsch Date: Tue, 16 Dec 2025 09:48:20 +0000 Subject: [PATCH 038/266] Update Copilot sign-up URL based on verification domain (#44085) Use the url crate to extract the domain from the verification URI and construct the appropriate Copilot sign-up URL for GitHub or GitHub Enterprise. Release Notes: - Improved github enterprise (ghe) copilot sign in --- Cargo.lock | 1 + crates/copilot/Cargo.toml | 1 + crates/copilot/src/sign_in.rs | 44 ++++++++++++++++++++++++++++++++--- 3 files changed, 43 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b43be6986b89bcd121416ded247e5bd944628cca..4858c4ae01c7bdea2eaf46fba87707d3a2e0af24 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3672,6 +3672,7 @@ dependencies = [ "task", "theme", "ui", + "url", "util", "workspace", "zlog", diff --git a/crates/copilot/Cargo.toml b/crates/copilot/Cargo.toml index 459abda17573d66287e2c8ca0b995292acaf163b..3a1706a7a679fbc14eafbeac953d842cda9f65c8 100644 --- a/crates/copilot/Cargo.toml +++ b/crates/copilot/Cargo.toml @@ -52,6 +52,7 @@ ui.workspace = true util.workspace = true workspace.workspace = true itertools.workspace = true +url.workspace = true [target.'cfg(windows)'.dependencies] async-std = { version = "1.12.0", features = ["unstable"] } diff --git a/crates/copilot/src/sign_in.rs b/crates/copilot/src/sign_in.rs index 0bcb11e18be1994ea92703973ad1278c5d5aa4f8..20e31525a8fdb09fce04934d3445d51ba4226a2e 100644 --- a/crates/copilot/src/sign_in.rs +++ b/crates/copilot/src/sign_in.rs @@ -6,6 +6,7 @@ use gpui::{ Subscription, Window, WindowBounds, WindowOptions, div, point, }; use ui::{ButtonLike, CommonAnimationExt, ConfiguredApiCard, Vector, VectorName, prelude::*}; +use url::Url; use util::ResultExt as _; use workspace::{Toast, Workspace, notifications::NotificationId}; @@ -152,6 +153,7 @@ pub struct CopilotCodeVerification { focus_handle: FocusHandle, copilot: Entity, _subscription: Subscription, + sign_up_url: Option, } impl Focusable for CopilotCodeVerification { @@ -183,11 +185,22 @@ impl CopilotCodeVerification { .detach(); let status = copilot.read(cx).status(); + // Determine sign-up URL based on verification_uri domain if available + let sign_up_url = if let Status::SigningIn { + prompt: Some(ref prompt), + } = status + { + // Extract domain from verification_uri to construct sign-up URL + Self::get_sign_up_url_from_verification(&prompt.verification_uri) + } else { + None + }; Self { status, connect_clicked: false, focus_handle: cx.focus_handle(), copilot: copilot.clone(), + sign_up_url, _subscription: cx.observe(copilot, |this, copilot, cx| { let status = copilot.read(cx).status(); match status { @@ -201,10 +214,30 @@ impl CopilotCodeVerification { } pub fn set_status(&mut self, status: Status, cx: &mut Context) { + // Update sign-up URL if we have a new verification URI + if let Status::SigningIn { + prompt: Some(ref prompt), + } = status + { + self.sign_up_url = Self::get_sign_up_url_from_verification(&prompt.verification_uri); + } self.status = status; cx.notify(); } + fn get_sign_up_url_from_verification(verification_uri: &str) -> Option { + // Extract domain from verification URI using url crate + if let Ok(url) = Url::parse(verification_uri) + && let Some(host) = url.host_str() + && !host.contains("github.com") + { + // For GHE, construct URL from domain + Some(format!("https://{}/features/copilot", host)) + } else { + None + } + } + fn render_device_code(data: &PromptUserDeviceFlow, cx: &mut Context) -> impl IntoElement { let copied = cx .read_from_clipboard() @@ -302,7 +335,12 @@ impl CopilotCodeVerification { ) } - fn render_unauthorized_modal(cx: &mut Context) -> impl Element { + fn render_unauthorized_modal(&self, cx: &mut Context) -> impl Element { + let sign_up_url = self + .sign_up_url + .as_deref() + .unwrap_or(COPILOT_SIGN_UP_URL) + .to_owned(); let description = "Enable Copilot by connecting your existing license once you have subscribed or renewed your subscription."; v_flex() @@ -319,7 +357,7 @@ impl CopilotCodeVerification { .full_width() .style(ButtonStyle::Outlined) .size(ButtonSize::Medium) - .on_click(|_, _, cx| cx.open_url(COPILOT_SIGN_UP_URL)), + .on_click(move |_, _, cx| cx.open_url(&sign_up_url)), ) .child( Button::new("copilot-subscribe-cancel-button", "Cancel") @@ -374,7 +412,7 @@ impl Render for CopilotCodeVerification { } => Self::render_prompting_modal(self.connect_clicked, prompt, cx).into_any_element(), Status::Unauthorized => { self.connect_clicked = false; - Self::render_unauthorized_modal(cx).into_any_element() + self.render_unauthorized_modal(cx).into_any_element() } Status::Authorized => { self.connect_clicked = false; From 4109c9dde73ddd24069dc31758e9ca50fb613a89 Mon Sep 17 00:00:00 2001 From: Simon Pham Date: Tue, 16 Dec 2025 17:51:28 +0700 Subject: [PATCH 039/266] workspace: Display a launchpad page when in an empty window & add it as a `restore_on_startup` value (#44048) Hi, This PR fixes nothing. I just miss the option to open recent projects quickly upon opening Zed, so I made this. Hope I can see it soon in Preview channel. If there is any suggestion, just comment. I will take it seriously. Thank you! |ui|before|after| |-|-|-| |empty pane|Screenshot 2025-12-03 at 12 39 25|Screenshot 2025-12-03 at 12 34 03| |new window|Screenshot 2025-12-03 at 12 39 21|Screenshot 2025-12-04 at 10 43 17| --- Release Notes: - Added a new value to the `restore_on_startup` setting called `launchpad`. This value makes Zed open with a variant of the welcome screen ("the launchpad") upon startup. Additionally, this same page variant is now also what is displayed if you close all tabs in an existing window that doesn't contain any folders open. The launchpad page shows you up to 5 recent projects, making it easy to open something you were working recently. --------- Co-authored-by: Danilo Leal --- Cargo.lock | 2 +- assets/keymaps/default-linux.json | 5 + assets/keymaps/default-macos.json | 5 + assets/keymaps/default-windows.json | 5 + crates/editor/src/editor.rs | 9 +- crates/migrator/src/migrations.rs | 6 + .../src/migrations/m_2025_12_15/settings.rs | 52 ++ crates/migrator/src/migrator.rs | 8 + crates/onboarding/Cargo.toml | 1 - crates/onboarding/src/onboarding.rs | 22 +- crates/onboarding/src/welcome.rs | 443 -------------- .../src/settings_content/workspace.rs | 9 +- crates/title_bar/src/title_bar.rs | 2 +- crates/workspace/Cargo.toml | 1 + crates/workspace/src/pane.rs | 26 +- crates/workspace/src/welcome.rs | 568 ++++++++++++++++++ crates/workspace/src/workspace.rs | 1 + crates/zed/src/main.rs | 8 +- crates/zed/src/zed.rs | 1 + crates/zed_actions/src/lib.rs | 2 + docs/src/configuring-zed.md | 10 +- 21 files changed, 711 insertions(+), 475 deletions(-) create mode 100644 crates/migrator/src/migrations/m_2025_12_15/settings.rs delete mode 100644 crates/onboarding/src/welcome.rs create mode 100644 crates/workspace/src/welcome.rs diff --git a/Cargo.lock b/Cargo.lock index 4858c4ae01c7bdea2eaf46fba87707d3a2e0af24..72a65994b9eee32b3b2c84c846e2825ffd0ff723 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10843,7 +10843,6 @@ dependencies = [ "documented", "fs", "fuzzy", - "git", "gpui", "menu", "notifications", @@ -20096,6 +20095,7 @@ dependencies = [ "feature_flags", "fs", "futures 0.3.31", + "git", "gpui", "http_client", "itertools 0.14.0", diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index aac9dcf706856703800068e9e4b7ce9e94d73ecb..bb49582ce0e939a5c43c24862a4e50f9d82125d2 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -1263,6 +1263,11 @@ "ctrl-+": ["zed::IncreaseUiFontSize", { "persist": false }], "ctrl--": ["zed::DecreaseUiFontSize", { "persist": false }], "ctrl-0": ["zed::ResetUiFontSize", { "persist": false }], + "ctrl-1": ["welcome::OpenRecentProject", 0], + "ctrl-2": ["welcome::OpenRecentProject", 1], + "ctrl-3": ["welcome::OpenRecentProject", 2], + "ctrl-4": ["welcome::OpenRecentProject", 3], + "ctrl-5": ["welcome::OpenRecentProject", 4], }, }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 224f6755465d63df0802e3b3919dbdf2ba82246d..3c6ec6e0423e5ea254ddcd9690f92ac11e0fa73a 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -1366,6 +1366,11 @@ "cmd-+": ["zed::IncreaseUiFontSize", { "persist": false }], "cmd--": ["zed::DecreaseUiFontSize", { "persist": false }], "cmd-0": ["zed::ResetUiFontSize", { "persist": false }], + "cmd-1": ["welcome::OpenRecentProject", 0], + "cmd-2": ["welcome::OpenRecentProject", 1], + "cmd-3": ["welcome::OpenRecentProject", 2], + "cmd-4": ["welcome::OpenRecentProject", 3], + "cmd-5": ["welcome::OpenRecentProject", 4], }, }, { diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index 5626309ecb2e17fbbff53347da6059cd2db3be31..b15313fe75cc1265b5eb0c5560f26e4c148d4336 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -1295,6 +1295,11 @@ "ctrl-+": ["zed::IncreaseUiFontSize", { "persist": false }], "ctrl--": ["zed::DecreaseUiFontSize", { "persist": false }], "ctrl-0": ["zed::ResetUiFontSize", { "persist": false }], + "ctrl-1": ["welcome::OpenRecentProject", 0], + "ctrl-2": ["welcome::OpenRecentProject", 1], + "ctrl-3": ["welcome::OpenRecentProject", 2], + "ctrl-4": ["welcome::OpenRecentProject", 3], + "ctrl-5": ["welcome::OpenRecentProject", 4], }, }, { diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 05625d2f4e4e66de5c9fe55f62a02eef5d874df9..f4a83f900da68d90803b82c0aec1287fcaa71cd3 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -3427,7 +3427,8 @@ impl Editor { data.selections = inmemory_selections; }); - if WorkspaceSettings::get(None, cx).restore_on_startup != RestoreOnStartupBehavior::None + if WorkspaceSettings::get(None, cx).restore_on_startup + != RestoreOnStartupBehavior::EmptyTab && let Some(workspace_id) = self.workspace_serialization_id(cx) { let snapshot = self.buffer().read(cx).snapshot(cx); @@ -3467,7 +3468,8 @@ impl Editor { use text::ToPoint as _; if self.mode.is_minimap() - || WorkspaceSettings::get(None, cx).restore_on_startup == RestoreOnStartupBehavior::None + || WorkspaceSettings::get(None, cx).restore_on_startup + == RestoreOnStartupBehavior::EmptyTab { return; } @@ -23163,7 +23165,8 @@ impl Editor { ) { if self.buffer_kind(cx) == ItemBufferKind::Singleton && !self.mode.is_minimap() - && WorkspaceSettings::get(None, cx).restore_on_startup != RestoreOnStartupBehavior::None + && WorkspaceSettings::get(None, cx).restore_on_startup + != RestoreOnStartupBehavior::EmptyTab { let buffer_snapshot = OnceCell::new(); diff --git a/crates/migrator/src/migrations.rs b/crates/migrator/src/migrations.rs index a479379a674589c748e22fc18beb8ee7c85df652..f3fdb8f36c70d1bfde474f842a7bcbeff2668b50 100644 --- a/crates/migrator/src/migrations.rs +++ b/crates/migrator/src/migrations.rs @@ -165,3 +165,9 @@ pub(crate) mod m_2025_12_08 { pub(crate) use keymap::KEYMAP_PATTERNS; } + +pub(crate) mod m_2025_12_15 { + mod settings; + + pub(crate) use settings::SETTINGS_PATTERNS; +} diff --git a/crates/migrator/src/migrations/m_2025_12_15/settings.rs b/crates/migrator/src/migrations/m_2025_12_15/settings.rs new file mode 100644 index 0000000000000000000000000000000000000000..c875bdfdddffc62a58912bdc53bcf3e496e4eeab --- /dev/null +++ b/crates/migrator/src/migrations/m_2025_12_15/settings.rs @@ -0,0 +1,52 @@ +use std::ops::Range; +use tree_sitter::{Query, QueryMatch}; + +use crate::MigrationPatterns; +use crate::patterns::SETTINGS_NESTED_KEY_VALUE_PATTERN; + +pub const SETTINGS_PATTERNS: MigrationPatterns = &[( + SETTINGS_NESTED_KEY_VALUE_PATTERN, + rename_restore_on_startup_values, +)]; + +fn rename_restore_on_startup_values( + contents: &str, + mat: &QueryMatch, + query: &Query, +) -> Option<(Range, String)> { + if !is_restore_on_startup_setting(contents, mat, query) { + return None; + } + + let setting_value_ix = query.capture_index_for_name("setting_value")?; + let setting_value_range = mat + .nodes_for_capture_index(setting_value_ix) + .next()? + .byte_range(); + let setting_value = contents.get(setting_value_range.clone())?; + + // The value includes quotes, so we check for the quoted string + let new_value = match setting_value.trim() { + "\"none\"" => "\"empty_tab\"", + "\"welcome\"" => "\"launchpad\"", + _ => return None, + }; + + Some((setting_value_range, new_value.to_string())) +} + +fn is_restore_on_startup_setting(contents: &str, mat: &QueryMatch, query: &Query) -> bool { + // Check that the parent key is "workspace" (since restore_on_startup is under workspace settings) + // Actually, restore_on_startup can be at the root level too, so we need to handle both cases + // The SETTINGS_NESTED_KEY_VALUE_PATTERN captures parent_key and setting_name + + let setting_name_ix = match query.capture_index_for_name("setting_name") { + Some(ix) => ix, + None => return false, + }; + let setting_name_range = match mat.nodes_for_capture_index(setting_name_ix).next() { + Some(node) => node.byte_range(), + None => return false, + }; + contents.get(setting_name_range) == Some("restore_on_startup") +} diff --git a/crates/migrator/src/migrator.rs b/crates/migrator/src/migrator.rs index 23a24ae199cd076b76b3df2b0d68712f059fd32e..8329d635ce321c1b6280f06cdabe105879cc03a0 100644 --- a/crates/migrator/src/migrator.rs +++ b/crates/migrator/src/migrator.rs @@ -232,6 +232,10 @@ pub fn migrate_settings(text: &str) -> Result> { &SETTINGS_QUERY_2025_11_20, ), MigrationType::Json(migrations::m_2025_11_25::remove_context_server_source), + MigrationType::TreeSitter( + migrations::m_2025_12_15::SETTINGS_PATTERNS, + &SETTINGS_QUERY_2025_12_15, + ), ]; run_migrations(text, migrations) } @@ -366,6 +370,10 @@ define_query!( KEYMAP_QUERY_2025_12_08, migrations::m_2025_12_08::KEYMAP_PATTERNS ); +define_query!( + SETTINGS_QUERY_2025_12_15, + migrations::m_2025_12_15::SETTINGS_PATTERNS +); // custom query static EDIT_PREDICTION_SETTINGS_MIGRATION_QUERY: LazyLock = LazyLock::new(|| { diff --git a/crates/onboarding/Cargo.toml b/crates/onboarding/Cargo.toml index 2ff3467c4804f7c0a50488a2c4a1e283ea571292..e5e5b5cac93aa4021f8933bd38f8711d53b89902 100644 --- a/crates/onboarding/Cargo.toml +++ b/crates/onboarding/Cargo.toml @@ -22,7 +22,6 @@ db.workspace = true documented.workspace = true fs.workspace = true fuzzy.workspace = true -git.workspace = true gpui.workspace = true menu.workspace = true notifications.workspace = true diff --git a/crates/onboarding/src/onboarding.rs b/crates/onboarding/src/onboarding.rs index 94581e142339cde9d4f1f01a3fb361ae810c1efa..66402f33d31c6e9ce5894c56872c8d92d2c4c36c 100644 --- a/crates/onboarding/src/onboarding.rs +++ b/crates/onboarding/src/onboarding.rs @@ -1,5 +1,4 @@ -pub use crate::welcome::ShowWelcome; -use crate::{multibuffer_hint::MultibufferHint, welcome::WelcomePage}; +use crate::multibuffer_hint::MultibufferHint; use client::{Client, UserStore, zed_urls}; use db::kvp::KEY_VALUE_STORE; use fs::Fs; @@ -17,6 +16,8 @@ use ui::{ Divider, KeyBinding, ParentElement as _, StatefulInteractiveElement, Vector, VectorName, WithScrollbar as _, prelude::*, rems_from_px, }; +pub use workspace::welcome::ShowWelcome; +use workspace::welcome::WelcomePage; use workspace::{ AppState, Workspace, WorkspaceId, dock::DockPosition, @@ -24,12 +25,12 @@ use workspace::{ notifications::NotifyResultExt as _, open_new, register_serializable_item, with_active_or_new_workspace, }; +use zed_actions::OpenOnboarding; mod base_keymap_picker; mod basics_page; pub mod multibuffer_hint; mod theme_preview; -mod welcome; /// Imports settings from Visual Studio Code. #[derive(Copy, Clone, Debug, Default, PartialEq, Deserialize, JsonSchema, Action)] @@ -52,14 +53,6 @@ pub struct ImportCursorSettings { pub const FIRST_OPEN: &str = "first_open"; pub const DOCS_URL: &str = "https://zed.dev/docs/"; -actions!( - zed, - [ - /// Opens the onboarding view. - OpenOnboarding - ] -); - actions!( onboarding, [ @@ -121,7 +114,8 @@ pub fn init(cx: &mut App) { if let Some(existing) = existing { workspace.activate_item(&existing, true, true, window, cx); } else { - let settings_page = WelcomePage::new(window, cx); + let settings_page = cx + .new(|cx| WelcomePage::new(workspace.weak_handle(), false, window, cx)); workspace.add_item_to_active_pane( Box::new(settings_page), None, @@ -427,7 +421,9 @@ fn go_to_welcome_page(cx: &mut App) { if let Some(idx) = idx { pane.activate_item(idx, true, true, window, cx); } else { - let item = Box::new(WelcomePage::new(window, cx)); + let item = Box::new( + cx.new(|cx| WelcomePage::new(workspace.weak_handle(), false, window, cx)), + ); pane.add_item(item, true, true, Some(onboarding_idx), window, cx); } diff --git a/crates/onboarding/src/welcome.rs b/crates/onboarding/src/welcome.rs deleted file mode 100644 index b2711cd52d61a51711bd8ec90581b981d7bcf784..0000000000000000000000000000000000000000 --- a/crates/onboarding/src/welcome.rs +++ /dev/null @@ -1,443 +0,0 @@ -use gpui::{ - Action, App, Context, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, - ParentElement, Render, Styled, Task, Window, actions, -}; -use menu::{SelectNext, SelectPrevious}; -use ui::{ButtonLike, Divider, DividerColor, KeyBinding, Vector, VectorName, prelude::*}; -use workspace::{ - NewFile, Open, - item::{Item, ItemEvent}, - with_active_or_new_workspace, -}; -use zed_actions::{Extensions, OpenSettings, agent, command_palette}; - -use crate::{Onboarding, OpenOnboarding}; - -actions!( - zed, - [ - /// Show the Zed welcome screen - ShowWelcome - ] -); - -const CONTENT: (Section<4>, Section<3>) = ( - Section { - title: "Get Started", - entries: [ - SectionEntry { - icon: IconName::Plus, - title: "New File", - action: &NewFile, - }, - SectionEntry { - icon: IconName::FolderOpen, - title: "Open Project", - action: &Open, - }, - SectionEntry { - icon: IconName::CloudDownload, - title: "Clone Repository", - action: &git::Clone, - }, - SectionEntry { - icon: IconName::ListCollapse, - title: "Open Command Palette", - action: &command_palette::Toggle, - }, - ], - }, - Section { - title: "Configure", - entries: [ - SectionEntry { - icon: IconName::Settings, - title: "Open Settings", - action: &OpenSettings, - }, - SectionEntry { - icon: IconName::ZedAssistant, - title: "View AI Settings", - action: &agent::OpenSettings, - }, - SectionEntry { - icon: IconName::Blocks, - title: "Explore Extensions", - action: &Extensions { - category_filter: None, - id: None, - }, - }, - ], - }, -); - -struct Section { - title: &'static str, - entries: [SectionEntry; COLS], -} - -impl Section { - fn render(self, index_offset: usize, focus: &FocusHandle, cx: &mut App) -> impl IntoElement { - v_flex() - .min_w_full() - .child( - h_flex() - .px_1() - .mb_2() - .gap_2() - .child( - Label::new(self.title.to_ascii_uppercase()) - .buffer_font(cx) - .color(Color::Muted) - .size(LabelSize::XSmall), - ) - .child(Divider::horizontal().color(DividerColor::BorderVariant)), - ) - .children( - self.entries - .iter() - .enumerate() - .map(|(index, entry)| entry.render(index_offset + index, focus, cx)), - ) - } -} - -struct SectionEntry { - icon: IconName, - title: &'static str, - action: &'static dyn Action, -} - -impl SectionEntry { - fn render(&self, button_index: usize, focus: &FocusHandle, cx: &App) -> impl IntoElement { - ButtonLike::new(("onboarding-button-id", button_index)) - .tab_index(button_index as isize) - .full_width() - .size(ButtonSize::Medium) - .child( - h_flex() - .w_full() - .justify_between() - .child( - h_flex() - .gap_2() - .child( - Icon::new(self.icon) - .color(Color::Muted) - .size(IconSize::XSmall), - ) - .child(Label::new(self.title)), - ) - .child( - KeyBinding::for_action_in(self.action, focus, cx).size(rems_from_px(12.)), - ), - ) - .on_click(|_, window, cx| window.dispatch_action(self.action.boxed_clone(), cx)) - } -} - -pub struct WelcomePage { - focus_handle: FocusHandle, -} - -impl WelcomePage { - fn select_next(&mut self, _: &SelectNext, window: &mut Window, cx: &mut Context) { - window.focus_next(); - cx.notify(); - } - - fn select_previous(&mut self, _: &SelectPrevious, window: &mut Window, cx: &mut Context) { - window.focus_prev(); - cx.notify(); - } -} - -impl Render for WelcomePage { - fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { - let (first_section, second_section) = CONTENT; - let first_section_entries = first_section.entries.len(); - let last_index = first_section_entries + second_section.entries.len(); - - h_flex() - .size_full() - .justify_center() - .overflow_hidden() - .bg(cx.theme().colors().editor_background) - .key_context("Welcome") - .track_focus(&self.focus_handle(cx)) - .on_action(cx.listener(Self::select_previous)) - .on_action(cx.listener(Self::select_next)) - .child( - h_flex() - .px_12() - .py_40() - .size_full() - .relative() - .max_w(px(1100.)) - .child( - div() - .size_full() - .max_w_128() - .mx_auto() - .child( - h_flex() - .w_full() - .justify_center() - .gap_4() - .child(Vector::square(VectorName::ZedLogo, rems(2.))) - .child( - div().child(Headline::new("Welcome to Zed")).child( - Label::new("The editor for what's next") - .size(LabelSize::Small) - .color(Color::Muted) - .italic(), - ), - ), - ) - .child( - v_flex() - .mt_10() - .gap_6() - .child(first_section.render( - Default::default(), - &self.focus_handle, - cx, - )) - .child(second_section.render( - first_section_entries, - &self.focus_handle, - cx, - )) - .child( - h_flex() - .w_full() - .pt_4() - .justify_center() - // We call this a hack - .rounded_b_xs() - .border_t_1() - .border_color(cx.theme().colors().border.opacity(0.6)) - .border_dashed() - .child( - Button::new("welcome-exit", "Return to Setup") - .tab_index(last_index as isize) - .full_width() - .label_size(LabelSize::XSmall) - .on_click(|_, window, cx| { - window.dispatch_action( - OpenOnboarding.boxed_clone(), - cx, - ); - - with_active_or_new_workspace(cx, |workspace, window, cx| { - let Some((welcome_id, welcome_idx)) = workspace - .active_pane() - .read(cx) - .items() - .enumerate() - .find_map(|(idx, item)| { - let _ = item.downcast::()?; - Some((item.item_id(), idx)) - }) - else { - return; - }; - - workspace.active_pane().update(cx, |pane, cx| { - // Get the index here to get around the borrow checker - let idx = pane.items().enumerate().find_map( - |(idx, item)| { - let _ = - item.downcast::()?; - Some(idx) - }, - ); - - if let Some(idx) = idx { - pane.activate_item( - idx, true, true, window, cx, - ); - } else { - let item = - Box::new(Onboarding::new(workspace, cx)); - pane.add_item( - item, - true, - true, - Some(welcome_idx), - window, - cx, - ); - } - - pane.remove_item( - welcome_id, - false, - false, - window, - cx, - ); - }); - }); - }), - ), - ), - ), - ), - ) - } -} - -impl WelcomePage { - pub fn new(window: &mut Window, cx: &mut App) -> Entity { - cx.new(|cx| { - let focus_handle = cx.focus_handle(); - cx.on_focus(&focus_handle, window, |_, _, cx| cx.notify()) - .detach(); - - WelcomePage { focus_handle } - }) - } -} - -impl EventEmitter for WelcomePage {} - -impl Focusable for WelcomePage { - fn focus_handle(&self, _: &App) -> gpui::FocusHandle { - self.focus_handle.clone() - } -} - -impl Item for WelcomePage { - type Event = ItemEvent; - - fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString { - "Welcome".into() - } - - fn telemetry_event_text(&self) -> Option<&'static str> { - Some("New Welcome Page Opened") - } - - fn show_toolbar(&self) -> bool { - false - } - - fn to_item_events(event: &Self::Event, mut f: impl FnMut(workspace::item::ItemEvent)) { - f(*event) - } -} - -impl workspace::SerializableItem for WelcomePage { - fn serialized_item_kind() -> &'static str { - "WelcomePage" - } - - fn cleanup( - workspace_id: workspace::WorkspaceId, - alive_items: Vec, - _window: &mut Window, - cx: &mut App, - ) -> Task> { - workspace::delete_unloaded_items( - alive_items, - workspace_id, - "welcome_pages", - &persistence::WELCOME_PAGES, - cx, - ) - } - - fn deserialize( - _project: Entity, - _workspace: gpui::WeakEntity, - workspace_id: workspace::WorkspaceId, - item_id: workspace::ItemId, - window: &mut Window, - cx: &mut App, - ) -> Task>> { - if persistence::WELCOME_PAGES - .get_welcome_page(item_id, workspace_id) - .ok() - .is_some_and(|is_open| is_open) - { - window.spawn(cx, async move |cx| cx.update(WelcomePage::new)) - } else { - Task::ready(Err(anyhow::anyhow!("No welcome page to deserialize"))) - } - } - - fn serialize( - &mut self, - workspace: &mut workspace::Workspace, - item_id: workspace::ItemId, - _closing: bool, - _window: &mut Window, - cx: &mut Context, - ) -> Option>> { - let workspace_id = workspace.database_id()?; - Some(cx.background_spawn(async move { - persistence::WELCOME_PAGES - .save_welcome_page(item_id, workspace_id, true) - .await - })) - } - - fn should_serialize(&self, event: &Self::Event) -> bool { - event == &ItemEvent::UpdateTab - } -} - -mod persistence { - use db::{ - query, - sqlez::{domain::Domain, thread_safe_connection::ThreadSafeConnection}, - sqlez_macros::sql, - }; - use workspace::WorkspaceDb; - - pub struct WelcomePagesDb(ThreadSafeConnection); - - impl Domain for WelcomePagesDb { - const NAME: &str = stringify!(WelcomePagesDb); - - const MIGRATIONS: &[&str] = (&[sql!( - CREATE TABLE welcome_pages ( - workspace_id INTEGER, - item_id INTEGER UNIQUE, - is_open INTEGER DEFAULT FALSE, - - PRIMARY KEY(workspace_id, item_id), - FOREIGN KEY(workspace_id) REFERENCES workspaces(workspace_id) - ON DELETE CASCADE - ) STRICT; - )]); - } - - db::static_connection!(WELCOME_PAGES, WelcomePagesDb, [WorkspaceDb]); - - impl WelcomePagesDb { - query! { - pub async fn save_welcome_page( - item_id: workspace::ItemId, - workspace_id: workspace::WorkspaceId, - is_open: bool - ) -> Result<()> { - INSERT OR REPLACE INTO welcome_pages(item_id, workspace_id, is_open) - VALUES (?, ?, ?) - } - } - - query! { - pub fn get_welcome_page( - item_id: workspace::ItemId, - workspace_id: workspace::WorkspaceId - ) -> Result { - SELECT is_open - FROM welcome_pages - WHERE item_id = ? AND workspace_id = ? - } - } - } -} diff --git a/crates/settings/src/settings_content/workspace.rs b/crates/settings/src/settings_content/workspace.rs index b809a8fa85a9b27da3f3af5242e99b280466a4bb..832f6ec409c8594c55beab1fd6f327c1215f8bdc 100644 --- a/crates/settings/src/settings_content/workspace.rs +++ b/crates/settings/src/settings_content/workspace.rs @@ -42,7 +42,7 @@ pub struct WorkspaceSettingsContent { /// Default: off pub autosave: Option, /// Controls previous session restoration in freshly launched Zed instance. - /// Values: none, last_workspace, last_session + /// Values: empty_tab, last_workspace, last_session, launchpad /// Default: last_session pub restore_on_startup: Option, /// Whether to attempt to restore previous file's state when opening it again. @@ -382,13 +382,16 @@ impl CloseWindowWhenNoItems { )] #[serde(rename_all = "snake_case")] pub enum RestoreOnStartupBehavior { - /// Always start with an empty editor - None, + /// Always start with an empty editor tab + #[serde(alias = "none")] + EmptyTab, /// Restore the workspace that was closed last. LastWorkspace, /// Restore all workspaces that were open when quitting Zed. #[default] LastSession, + /// Show the launchpad with recent projects (no tabs). + Launchpad, } #[with_fallible_options] diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index 5bd47d02691c9a5c7fec968b5ea6e97265b956b2..4d7397a0bc82142245b86c11ffdf441a6b781ad8 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -479,7 +479,7 @@ impl TitleBar { let name = if let Some(name) = name { util::truncate_and_trailoff(&name, MAX_PROJECT_NAME_LENGTH) } else { - "Open recent project".to_string() + "Open Recent Project".to_string() }; Button::new("project_name_trigger", name) diff --git a/crates/workspace/Cargo.toml b/crates/workspace/Cargo.toml index acf95df37f5d20da65b6e9fa4460ba09b2ea81e3..c2554c63c4f6a1b9836a8ccc24ce4e567fefe601 100644 --- a/crates/workspace/Cargo.toml +++ b/crates/workspace/Cargo.toml @@ -38,6 +38,7 @@ db.workspace = true feature_flags.workspace = true fs.workspace = true futures.workspace = true +git.workspace = true gpui.workspace = true http_client.workspace = true itertools.workspace = true diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index 338a858f3c774deb1cc0750c56afd678f4eadf4a..036723c13755ff2a7b2b10e9684d822f239a8e0b 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -47,10 +47,9 @@ use std::{ }; use theme::ThemeSettings; use ui::{ - ButtonSize, Color, ContextMenu, ContextMenuEntry, ContextMenuItem, DecoratedIcon, IconButton, - IconButtonShape, IconDecoration, IconDecorationKind, IconName, IconSize, Indicator, Label, - PopoverMenu, PopoverMenuHandle, Tab, TabBar, TabPosition, Tooltip, prelude::*, - right_click_menu, + ContextMenu, ContextMenuEntry, ContextMenuItem, DecoratedIcon, IconButtonShape, IconDecoration, + IconDecorationKind, Indicator, PopoverMenu, PopoverMenuHandle, Tab, TabBar, TabPosition, + Tooltip, prelude::*, right_click_menu, }; use util::{ResultExt, debug_panic, maybe, paths::PathStyle, truncate_and_remove_front}; @@ -398,6 +397,7 @@ pub struct Pane { diagnostic_summary_update: Task<()>, /// If a certain project item wants to get recreated with specific data, it can persist its data before the recreation here. pub project_item_restoration_data: HashMap>, + welcome_page: Option>, pub in_center_group: bool, pub is_upper_left: bool, @@ -546,6 +546,7 @@ impl Pane { zoom_out_on_close: true, diagnostic_summary_update: Task::ready(()), project_item_restoration_data: HashMap::default(), + welcome_page: None, in_center_group: false, is_upper_left: false, is_upper_right: false, @@ -635,6 +636,10 @@ impl Pane { self.last_focus_handle_by_item .insert(active_item.item_id(), focused.downgrade()); } + } else if let Some(welcome_page) = self.welcome_page.as_ref() { + if self.focus_handle.is_focused(window) { + welcome_page.read(cx).focus_handle(cx).focus(window); + } } } @@ -4061,10 +4066,15 @@ impl Render for Pane { if has_worktrees { placeholder } else { - placeholder.child( - Label::new("Open a file or project to get started.") - .color(Color::Muted), - ) + if self.welcome_page.is_none() { + let workspace = self.workspace.clone(); + self.welcome_page = Some(cx.new(|cx| { + crate::welcome::WelcomePage::new( + workspace, true, window, cx, + ) + })); + } + placeholder.child(self.welcome_page.clone().unwrap()) } } }) diff --git a/crates/workspace/src/welcome.rs b/crates/workspace/src/welcome.rs new file mode 100644 index 0000000000000000000000000000000000000000..93ff1ea266ff9f40b64064ea03d9bd1b91161300 --- /dev/null +++ b/crates/workspace/src/welcome.rs @@ -0,0 +1,568 @@ +use crate::{ + NewFile, Open, PathList, SerializedWorkspaceLocation, WORKSPACE_DB, Workspace, WorkspaceId, + item::{Item, ItemEvent}, +}; +use git::Clone as GitClone; +use gpui::WeakEntity; +use gpui::{ + Action, App, Context, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, + ParentElement, Render, Styled, Task, Window, actions, +}; +use menu::{SelectNext, SelectPrevious}; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use ui::{ButtonLike, Divider, DividerColor, KeyBinding, Vector, VectorName, prelude::*}; +use util::ResultExt; +use zed_actions::{Extensions, OpenOnboarding, OpenSettings, agent, command_palette}; + +#[derive(PartialEq, Clone, Debug, Deserialize, Serialize, JsonSchema, Action)] +#[action(namespace = welcome)] +#[serde(transparent)] +pub struct OpenRecentProject { + pub index: usize, +} + +actions!( + zed, + [ + /// Show the Zed welcome screen + ShowWelcome + ] +); + +#[derive(IntoElement)] +struct SectionHeader { + title: SharedString, +} + +impl SectionHeader { + fn new(title: impl Into) -> Self { + Self { + title: title.into(), + } + } +} + +impl RenderOnce for SectionHeader { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + h_flex() + .px_1() + .mb_2() + .gap_2() + .child( + Label::new(self.title.to_ascii_uppercase()) + .buffer_font(cx) + .color(Color::Muted) + .size(LabelSize::XSmall), + ) + .child(Divider::horizontal().color(DividerColor::BorderVariant)) + } +} + +#[derive(IntoElement)] +struct SectionButton { + label: SharedString, + icon: IconName, + action: Box, + tab_index: usize, + focus_handle: FocusHandle, +} + +impl SectionButton { + fn new( + label: impl Into, + icon: IconName, + action: &dyn Action, + tab_index: usize, + focus_handle: FocusHandle, + ) -> Self { + Self { + label: label.into(), + icon, + action: action.boxed_clone(), + tab_index, + focus_handle, + } + } +} + +impl RenderOnce for SectionButton { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + let id = format!("onb-button-{}", self.label); + let action_ref: &dyn Action = &*self.action; + + ButtonLike::new(id) + .tab_index(self.tab_index as isize) + .full_width() + .size(ButtonSize::Medium) + .child( + h_flex() + .w_full() + .justify_between() + .child( + h_flex() + .gap_2() + .child( + Icon::new(self.icon) + .color(Color::Muted) + .size(IconSize::Small), + ) + .child(Label::new(self.label)), + ) + .child( + KeyBinding::for_action_in(action_ref, &self.focus_handle, cx) + .size(rems_from_px(12.)), + ), + ) + .on_click(move |_, window, cx| window.dispatch_action(self.action.boxed_clone(), cx)) + } +} + +struct SectionEntry { + icon: IconName, + title: &'static str, + action: &'static dyn Action, +} + +impl SectionEntry { + fn render(&self, button_index: usize, focus: &FocusHandle, _cx: &App) -> impl IntoElement { + SectionButton::new( + self.title, + self.icon, + self.action, + button_index, + focus.clone(), + ) + } +} + +const CONTENT: (Section<4>, Section<3>) = ( + Section { + title: "Get Started", + entries: [ + SectionEntry { + icon: IconName::Plus, + title: "New File", + action: &NewFile, + }, + SectionEntry { + icon: IconName::FolderOpen, + title: "Open Project", + action: &Open, + }, + SectionEntry { + icon: IconName::CloudDownload, + title: "Clone Repository", + action: &GitClone, + }, + SectionEntry { + icon: IconName::ListCollapse, + title: "Open Command Palette", + action: &command_palette::Toggle, + }, + ], + }, + Section { + title: "Configure", + entries: [ + SectionEntry { + icon: IconName::Settings, + title: "Open Settings", + action: &OpenSettings, + }, + SectionEntry { + icon: IconName::ZedAssistant, + title: "View AI Settings", + action: &agent::OpenSettings, + }, + SectionEntry { + icon: IconName::Blocks, + title: "Explore Extensions", + action: &Extensions { + category_filter: None, + id: None, + }, + }, + ], + }, +); + +struct Section { + title: &'static str, + entries: [SectionEntry; COLS], +} + +impl Section { + fn render(self, index_offset: usize, focus: &FocusHandle, cx: &App) -> impl IntoElement { + v_flex() + .min_w_full() + .child(SectionHeader::new(self.title)) + .children( + self.entries + .iter() + .enumerate() + .map(|(index, entry)| entry.render(index_offset + index, focus, cx)), + ) + } +} + +pub struct WelcomePage { + workspace: WeakEntity, + focus_handle: FocusHandle, + fallback_to_recent_projects: bool, + recent_workspaces: Option>, +} + +impl WelcomePage { + pub fn new( + workspace: WeakEntity, + fallback_to_recent_projects: bool, + window: &mut Window, + cx: &mut Context, + ) -> Self { + let focus_handle = cx.focus_handle(); + cx.on_focus(&focus_handle, window, |_, _, cx| cx.notify()) + .detach(); + + if fallback_to_recent_projects { + cx.spawn_in(window, async move |this: WeakEntity, cx| { + let workspaces = WORKSPACE_DB + .recent_workspaces_on_disk() + .await + .log_err() + .unwrap_or_default(); + + this.update(cx, |this, cx| { + this.recent_workspaces = Some(workspaces); + cx.notify(); + }) + .ok(); + }) + .detach(); + } + + WelcomePage { + workspace, + focus_handle, + fallback_to_recent_projects, + recent_workspaces: None, + } + } + + fn select_next(&mut self, _: &SelectNext, window: &mut Window, cx: &mut Context) { + window.focus_next(); + cx.notify(); + } + + fn select_previous(&mut self, _: &SelectPrevious, window: &mut Window, cx: &mut Context) { + window.focus_prev(); + cx.notify(); + } + + fn open_recent_project( + &mut self, + action: &OpenRecentProject, + window: &mut Window, + cx: &mut Context, + ) { + if let Some(recent_workspaces) = &self.recent_workspaces { + if let Some((_workspace_id, location, paths)) = recent_workspaces.get(action.index) { + let paths = paths.clone(); + let location = location.clone(); + let is_local = matches!(location, SerializedWorkspaceLocation::Local); + let workspace = self.workspace.clone(); + + if is_local { + let paths = paths.paths().to_vec(); + cx.spawn_in(window, async move |_, cx| { + let _ = workspace.update_in(cx, |workspace, window, cx| { + workspace + .open_workspace_for_paths(true, paths, window, cx) + .detach(); + }); + }) + .detach(); + } else { + use zed_actions::OpenRecent; + window.dispatch_action(OpenRecent::default().boxed_clone(), cx); + } + } + } + } + + fn render_recent_project_section( + &self, + recent_projects: Vec, + ) -> impl IntoElement { + v_flex() + .w_full() + .child(SectionHeader::new("Recent Projects")) + .children(recent_projects) + } + + fn render_recent_project( + &self, + index: usize, + location: &SerializedWorkspaceLocation, + paths: &PathList, + ) -> impl IntoElement { + let (icon, title) = match location { + SerializedWorkspaceLocation::Local => { + let path = paths.paths().first().map(|p| p.as_path()); + let name = path + .and_then(|p| p.file_name()) + .map(|n| n.to_string_lossy().to_string()) + .unwrap_or_else(|| "Untitled".to_string()); + (IconName::Folder, name) + } + SerializedWorkspaceLocation::Remote(_) => { + (IconName::Server, "Remote Project".to_string()) + } + }; + + SectionButton::new( + title, + icon, + &OpenRecentProject { index }, + 10, + self.focus_handle.clone(), + ) + } +} + +impl Render for WelcomePage { + fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { + let (first_section, second_section) = CONTENT; + let first_section_entries = first_section.entries.len(); + let last_index = first_section_entries + second_section.entries.len(); + + let recent_projects = self + .recent_workspaces + .as_ref() + .into_iter() + .flatten() + .take(5) + .enumerate() + .map(|(index, (_, loc, paths))| self.render_recent_project(index, loc, paths)) + .collect::>(); + + let second_section = if self.fallback_to_recent_projects && !recent_projects.is_empty() { + self.render_recent_project_section(recent_projects) + .into_any_element() + } else { + second_section + .render(first_section_entries, &self.focus_handle, cx) + .into_any_element() + }; + + let welcome_label = if self.fallback_to_recent_projects { + "Welcome back to Zed" + } else { + "Welcome to Zed" + }; + + h_flex() + .key_context("Welcome") + .track_focus(&self.focus_handle(cx)) + .on_action(cx.listener(Self::select_previous)) + .on_action(cx.listener(Self::select_next)) + .on_action(cx.listener(Self::open_recent_project)) + .size_full() + .justify_center() + .overflow_hidden() + .bg(cx.theme().colors().editor_background) + .child( + h_flex() + .relative() + .size_full() + .px_12() + .py_40() + .max_w(px(1100.)) + .child( + v_flex() + .size_full() + .max_w_128() + .mx_auto() + .gap_6() + .overflow_x_hidden() + .child( + h_flex() + .w_full() + .justify_center() + .mb_4() + .gap_4() + .child(Vector::square(VectorName::ZedLogo, rems_from_px(45.))) + .child( + v_flex().child(Headline::new(welcome_label)).child( + Label::new("The editor for what's next") + .size(LabelSize::Small) + .color(Color::Muted) + .italic(), + ), + ), + ) + .child(first_section.render(Default::default(), &self.focus_handle, cx)) + .child(second_section) + .when(!self.fallback_to_recent_projects, |this| { + this.child( + v_flex().gap_1().child(Divider::horizontal()).child( + Button::new("welcome-exit", "Return to Onboarding") + .tab_index(last_index as isize) + .full_width() + .label_size(LabelSize::XSmall) + .on_click(|_, window, cx| { + window.dispatch_action( + OpenOnboarding.boxed_clone(), + cx, + ); + }), + ), + ) + }), + ), + ) + } +} + +impl EventEmitter for WelcomePage {} + +impl Focusable for WelcomePage { + fn focus_handle(&self, _: &App) -> gpui::FocusHandle { + self.focus_handle.clone() + } +} + +impl Item for WelcomePage { + type Event = ItemEvent; + + fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString { + "Welcome".into() + } + + fn telemetry_event_text(&self) -> Option<&'static str> { + Some("New Welcome Page Opened") + } + + fn show_toolbar(&self) -> bool { + false + } + + fn to_item_events(event: &Self::Event, mut f: impl FnMut(crate::item::ItemEvent)) { + f(*event) + } +} + +impl crate::SerializableItem for WelcomePage { + fn serialized_item_kind() -> &'static str { + "WelcomePage" + } + + fn cleanup( + workspace_id: crate::WorkspaceId, + alive_items: Vec, + _window: &mut Window, + cx: &mut App, + ) -> Task> { + crate::delete_unloaded_items( + alive_items, + workspace_id, + "welcome_pages", + &persistence::WELCOME_PAGES, + cx, + ) + } + + fn deserialize( + _project: Entity, + workspace: gpui::WeakEntity, + workspace_id: crate::WorkspaceId, + item_id: crate::ItemId, + window: &mut Window, + cx: &mut App, + ) -> Task>> { + if persistence::WELCOME_PAGES + .get_welcome_page(item_id, workspace_id) + .ok() + .is_some_and(|is_open| is_open) + { + Task::ready(Ok( + cx.new(|cx| WelcomePage::new(workspace, false, window, cx)) + )) + } else { + Task::ready(Err(anyhow::anyhow!("No welcome page to deserialize"))) + } + } + + fn serialize( + &mut self, + workspace: &mut Workspace, + item_id: crate::ItemId, + _closing: bool, + _window: &mut Window, + cx: &mut Context, + ) -> Option>> { + let workspace_id = workspace.database_id()?; + Some(cx.background_spawn(async move { + persistence::WELCOME_PAGES + .save_welcome_page(item_id, workspace_id, true) + .await + })) + } + + fn should_serialize(&self, event: &Self::Event) -> bool { + event == &ItemEvent::UpdateTab + } +} + +mod persistence { + use crate::WorkspaceDb; + use db::{ + query, + sqlez::{domain::Domain, thread_safe_connection::ThreadSafeConnection}, + sqlez_macros::sql, + }; + + pub struct WelcomePagesDb(ThreadSafeConnection); + + impl Domain for WelcomePagesDb { + const NAME: &str = stringify!(WelcomePagesDb); + + const MIGRATIONS: &[&str] = (&[sql!( + CREATE TABLE welcome_pages ( + workspace_id INTEGER, + item_id INTEGER UNIQUE, + is_open INTEGER DEFAULT FALSE, + + PRIMARY KEY(workspace_id, item_id), + FOREIGN KEY(workspace_id) REFERENCES workspaces(workspace_id) + ON DELETE CASCADE + ) STRICT; + )]); + } + + db::static_connection!(WELCOME_PAGES, WelcomePagesDb, [WorkspaceDb]); + + impl WelcomePagesDb { + query! { + pub async fn save_welcome_page( + item_id: crate::ItemId, + workspace_id: crate::WorkspaceId, + is_open: bool + ) -> Result<()> { + INSERT OR REPLACE INTO welcome_pages(item_id, workspace_id, is_open) + VALUES (?, ?, ?) + } + } + + query! { + pub fn get_welcome_page( + item_id: crate::ItemId, + workspace_id: crate::WorkspaceId + ) -> Result { + SELECT is_open + FROM welcome_pages + WHERE item_id = ? AND workspace_id = ? + } + } + } +} diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 7dfa5d634c73ee639be1e24373ca86b548180547..41304fd77f1eff8d890ff21a3051e57ce3ab295e 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -16,6 +16,7 @@ mod theme_preview; mod toast_layer; mod toolbar; pub mod utility_pane; +pub mod welcome; mod workspace_settings; pub use crate::notifications::NotificationFrame; diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 6d94a15a666c6659f522d4b61962c932347b6304..674cc5f659f7a0d5d97eb7700505eb0ec4c5e5bc 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -1157,7 +1157,13 @@ async fn restore_or_create_workspace(app_state: Arc, cx: &mut AsyncApp app_state, cx, |workspace, window, cx| { - Editor::new_file(workspace, &Default::default(), window, cx) + let restore_on_startup = WorkspaceSettings::get_global(cx).restore_on_startup; + match restore_on_startup { + workspace::RestoreOnStartupBehavior::Launchpad => {} + _ => { + Editor::new_file(workspace, &Default::default(), window, cx); + } + } }, ) })? diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index a51e38bfe48976c8bf12ae1d546f8a8421288af2..c1d98936aa2ad20e6eef7f18bfed2d2c0615395a 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -4801,6 +4801,7 @@ mod tests { "keymap_editor", "keystroke_input", "language_selector", + "welcome", "line_ending_selector", "lsp_tool", "markdown", diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs index f69baa03b002fdcac5207f977a23cfc924283e2d..458ca10ecdf8915eef3ee69c6334b1a14cc0c219 100644 --- a/crates/zed_actions/src/lib.rs +++ b/crates/zed_actions/src/lib.rs @@ -70,6 +70,8 @@ actions!( OpenTelemetryLog, /// Opens the performance profiler. OpenPerformanceProfiler, + /// Opens the onboarding view. + OpenOnboarding, ] ); diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md index 76c0b528fa106ae087297d3c9191ee70620116ba..549dbe6fbb47b03a372ee3ddac87b72dbc4d9c2e 100644 --- a/docs/src/configuring-zed.md +++ b/docs/src/configuring-zed.md @@ -3142,7 +3142,15 @@ List of strings containing any combination of: ```json [settings] { - "restore_on_startup": "none" + "restore_on_startup": "empty_tab" +} +``` + +4. Always start with the welcome launchpad: + +```json [settings] +{ + "restore_on_startup": "launchpad" } ``` From 33b71aea6488b285c98643e7bee9a90ea1067ded Mon Sep 17 00:00:00 2001 From: Mayank Verma Date: Tue, 16 Dec 2025 16:46:27 +0530 Subject: [PATCH 040/266] workspace: Use markdown to render LSP notification content (#44215) Closes #43657 Release Notes: - Improved LSP notification messages by adding markdown rendering with clickable URLs, inline code, etc.
Before After
screenshot-notification-before screenshot-notification-after
--------- Co-authored-by: Danilo Leal --- Cargo.lock | 1 + crates/workspace/Cargo.toml | 1 + crates/workspace/src/notifications.rs | 77 ++++++++++++++++++++++----- 3 files changed, 67 insertions(+), 12 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 72a65994b9eee32b3b2c84c846e2825ffd0ff723..6d5d68fa9293a391ecfa1308c1c347a7cd48cb8b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20101,6 +20101,7 @@ dependencies = [ "itertools 0.14.0", "language", "log", + "markdown", "menu", "node_runtime", "parking_lot", diff --git a/crates/workspace/Cargo.toml b/crates/workspace/Cargo.toml index c2554c63c4f6a1b9836a8ccc24ce4e567fefe601..956d63580404da351d34af3b5cf5fd531d5a0011 100644 --- a/crates/workspace/Cargo.toml +++ b/crates/workspace/Cargo.toml @@ -45,6 +45,7 @@ itertools.workspace = true language.workspace = true log.workspace = true menu.workspace = true +markdown.workspace = true node_runtime.workspace = true parking_lot.workspace = true postage.workspace = true diff --git a/crates/workspace/src/notifications.rs b/crates/workspace/src/notifications.rs index 6d37ea4d2a50637ae7c2e0287ae8f371e3b47aba..3b126d329e7fafefa4043661c5039f1e17b09b54 100644 --- a/crates/workspace/src/notifications.rs +++ b/crates/workspace/src/notifications.rs @@ -3,9 +3,12 @@ use anyhow::Context as _; use gpui::{ AnyView, App, AppContext as _, AsyncWindowContext, ClickEvent, ClipboardItem, Context, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, PromptLevel, Render, ScrollHandle, - Task, svg, + Task, TextStyleRefinement, UnderlineStyle, svg, }; +use markdown::{Markdown, MarkdownElement, MarkdownStyle}; use parking_lot::Mutex; +use settings::Settings; +use theme::ThemeSettings; use std::ops::Deref; use std::sync::{Arc, LazyLock}; @@ -216,6 +219,7 @@ pub struct LanguageServerPrompt { focus_handle: FocusHandle, request: Option, scroll_handle: ScrollHandle, + markdown: Entity, } impl Focusable for LanguageServerPrompt { @@ -228,10 +232,13 @@ impl Notification for LanguageServerPrompt {} impl LanguageServerPrompt { pub fn new(request: project::LanguageServerPromptRequest, cx: &mut App) -> Self { + let markdown = cx.new(|cx| Markdown::new(request.message.clone().into(), None, None, cx)); + Self { focus_handle: cx.focus_handle(), request: Some(request), scroll_handle: ScrollHandle::new(), + markdown, } } @@ -262,7 +269,7 @@ impl Render for LanguageServerPrompt { }; let (icon, color) = match request.level { - PromptLevel::Info => (IconName::Info, Color::Accent), + PromptLevel::Info => (IconName::Info, Color::Muted), PromptLevel::Warning => (IconName::Warning, Color::Warning), PromptLevel::Critical => (IconName::XCircle, Color::Error), }; @@ -291,16 +298,15 @@ impl Render for LanguageServerPrompt { .child( h_flex() .justify_between() - .items_start() .child( h_flex() .gap_2() - .child(Icon::new(icon).color(color)) + .child(Icon::new(icon).color(color).size(IconSize::Small)) .child(Label::new(request.lsp_name.clone())), ) .child( h_flex() - .gap_2() + .gap_1() .child( IconButton::new("copy", IconName::Copy) .on_click({ @@ -317,15 +323,17 @@ impl Render for LanguageServerPrompt { IconButton::new(close_id, close_icon) .tooltip(move |_window, cx| { if suppress { - Tooltip::for_action( - "Suppress.\nClose with click.", - &SuppressNotification, + Tooltip::with_meta( + "Suppress", + Some(&SuppressNotification), + "Click to close", cx, ) } else { - Tooltip::for_action( - "Close.\nSuppress with shift-click.", - &menu::Cancel, + Tooltip::with_meta( + "Close", + Some(&menu::Cancel), + "Suppress with shift-click", cx, ) } @@ -342,7 +350,16 @@ impl Render for LanguageServerPrompt { ), ), ) - .child(Label::new(request.message.to_string()).size(LabelSize::Small)) + .child( + MarkdownElement::new(self.markdown.clone(), markdown_style(window, cx)) + .text_size(TextSize::Small.rems(cx)) + .code_block_renderer(markdown::CodeBlockRenderer::Default { + copy_button: false, + copy_button_on_hover: false, + border: false, + }) + .on_url_click(|link, _, cx| cx.open_url(&link)), + ) .children(request.actions.iter().enumerate().map(|(ix, action)| { let this_handle = cx.entity(); Button::new(ix, action.title.clone()) @@ -369,6 +386,42 @@ fn workspace_error_notification_id() -> NotificationId { NotificationId::unique::() } +fn markdown_style(window: &Window, cx: &App) -> MarkdownStyle { + let settings = ThemeSettings::get_global(cx); + let ui_font_family = settings.ui_font.family.clone(); + let ui_font_fallbacks = settings.ui_font.fallbacks.clone(); + let buffer_font_family = settings.buffer_font.family.clone(); + let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone(); + + let mut base_text_style = window.text_style(); + base_text_style.refine(&TextStyleRefinement { + font_family: Some(ui_font_family), + font_fallbacks: ui_font_fallbacks, + color: Some(cx.theme().colors().text), + ..Default::default() + }); + + MarkdownStyle { + base_text_style, + selection_background_color: cx.theme().colors().element_selection_background, + inline_code: TextStyleRefinement { + background_color: Some(cx.theme().colors().editor_background.opacity(0.5)), + font_family: Some(buffer_font_family), + font_fallbacks: buffer_font_fallbacks, + ..Default::default() + }, + link: TextStyleRefinement { + underline: Some(UnderlineStyle { + thickness: px(1.), + color: Some(cx.theme().colors().text_accent), + wavy: false, + }), + ..Default::default() + }, + ..Default::default() + } +} + #[derive(Debug, Clone)] pub struct ErrorMessagePrompt { message: SharedString, From c3b08609094a4442d7b7a85a4de89553e4f16c3e Mon Sep 17 00:00:00 2001 From: Michael Benfield Date: Tue, 16 Dec 2025 03:25:59 -0800 Subject: [PATCH 041/266] Remove CopyAsMarkdown (#44933) Copying rendered markdown doesn't reliably do anything sensible. If we copy text from the middle of a bold section, no formatting is copied. If we copy text at the end, the trailing bold delimiters are copied, resulting in gibberish markdown. Thus even fixing the associated issue (so that leading delimeters are reliably copied) won't consistently produce good results. Also, as the user messages in the agent panel don't render markdown anyway, it seems the most likely use case for copying markdown is inapplicable. Closes #42958 Release Notes: - N/A --- assets/keymaps/default-linux.json | 6 +++--- assets/keymaps/default-macos.json | 2 +- assets/keymaps/default-windows.json | 2 +- crates/markdown/src/markdown.rs | 18 ------------------ 4 files changed, 5 insertions(+), 23 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index bb49582ce0e939a5c43c24862a4e50f9d82125d2..38ef7d092d534163ead569c522227b089f84af99 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -262,9 +262,9 @@ { "context": "AgentPanel > Markdown", "bindings": { - "copy": "markdown::CopyAsMarkdown", - "ctrl-insert": "markdown::CopyAsMarkdown", - "ctrl-c": "markdown::CopyAsMarkdown", + "copy": "markdown::Copy", + "ctrl-insert": "markdown::Copy", + "ctrl-c": "markdown::Copy", }, }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 3c6ec6e0423e5ea254ddcd9690f92ac11e0fa73a..8a0e3dfdcddbd448e6a6b9bf66f3731153208120 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -303,7 +303,7 @@ "context": "AgentPanel > Markdown", "use_key_equivalents": true, "bindings": { - "cmd-c": "markdown::CopyAsMarkdown", + "cmd-c": "markdown::Copy", }, }, { diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index b15313fe75cc1265b5eb0c5560f26e4c148d4336..e344ea356fb171fb07474f498056df73c73d8307 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -265,7 +265,7 @@ "context": "AgentPanel > Markdown", "use_key_equivalents": true, "bindings": { - "ctrl-c": "markdown::CopyAsMarkdown", + "ctrl-c": "markdown::Copy", }, }, { diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index 6f4ebe4a91f2cee344c1d82ff70722406251434d..270192107c13e8ddfc5eba1b3e6e8e298b93125a 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -149,8 +149,6 @@ actions!( [ /// Copies the selected text to the clipboard. Copy, - /// Copies the selected text as markdown to the clipboard. - CopyAsMarkdown ] ); @@ -295,14 +293,6 @@ impl Markdown { cx.write_to_clipboard(ClipboardItem::new_string(text)); } - fn copy_as_markdown(&self, _: &mut Window, cx: &mut Context) { - if self.selection.end <= self.selection.start { - return; - } - let text = self.source[self.selection.start..self.selection.end].to_string(); - cx.write_to_clipboard(ClipboardItem::new_string(text)); - } - fn parse(&mut self, cx: &mut Context) { if self.source.is_empty() { return; @@ -1360,14 +1350,6 @@ impl Element for MarkdownElement { } } }); - window.on_action(std::any::TypeId::of::(), { - let entity = self.markdown.clone(); - move |_, phase, window, cx| { - if phase == DispatchPhase::Bubble { - entity.update(cx, move |this, cx| this.copy_as_markdown(window, cx)) - } - } - }); self.paint_mouse_listeners(hitbox, &rendered_markdown.text, window, cx); rendered_markdown.element.paint(window, cx); From 2178ad6b9146b30cd2915b1c4d886640e0671164 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Tue, 16 Dec 2025 13:33:22 +0200 Subject: [PATCH 042/266] Remove unneccessary snapshot storing in the buffer chunks (#44972) Release Notes: - N/A Co-authored-by: Lukas Wirth --- crates/language/src/buffer.rs | 6 +- crates/language/src/buffer/row_chunk.rs | 62 +++++++++---------- crates/project/src/lsp_store.rs | 21 +++++-- .../project/src/lsp_store/inlay_hint_cache.rs | 11 +--- 4 files changed, 50 insertions(+), 50 deletions(-) diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 22fcbf5ee85c0f42de8097526df4a5fdc383ac35..59795c375ab9b663339dbbebccc60062058c6ef9 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -4317,14 +4317,12 @@ impl BufferSnapshot { for chunk in self .tree_sitter_data .chunks - .applicable_chunks(&[self.anchor_before(range.start)..self.anchor_after(range.end)]) + .applicable_chunks(&[range.to_point(self)]) { if known_chunks.is_some_and(|chunks| chunks.contains(&chunk.row_range())) { continue; } - let Some(chunk_range) = self.tree_sitter_data.chunks.chunk_range(chunk) else { - continue; - }; + let chunk_range = chunk.anchor_range(); let chunk_range = chunk_range.to_offset(&self); if let Some(cached_brackets) = diff --git a/crates/language/src/buffer/row_chunk.rs b/crates/language/src/buffer/row_chunk.rs index e4ef5227e690a9912257ea00edc2b5f722326ae3..0f3c0b5afb1cc1a2d60a2a568fe00403733ef5c6 100644 --- a/crates/language/src/buffer/row_chunk.rs +++ b/crates/language/src/buffer/row_chunk.rs @@ -3,7 +3,6 @@ use std::{ops::Range, sync::Arc}; -use clock::Global; use text::{Anchor, OffsetRangeExt as _, Point}; use util::RangeExt; @@ -19,14 +18,13 @@ use crate::BufferRow; /// #[derive(Clone)] pub struct RowChunks { - snapshot: text::BufferSnapshot, chunks: Arc<[RowChunk]>, + version: clock::Global, } impl std::fmt::Debug for RowChunks { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("RowChunks") - .field("version", self.snapshot.version()) .field("chunks", &self.chunks) .finish() } @@ -38,34 +36,45 @@ impl RowChunks { let last_row = buffer_point_range.end.row; let chunks = (buffer_point_range.start.row..=last_row) .step_by(max_rows_per_chunk as usize) + .collect::>(); + let last_chunk_id = chunks.len() - 1; + let chunks = chunks + .into_iter() .enumerate() - .map(|(id, chunk_start)| RowChunk { - id, - start: chunk_start, - end_exclusive: (chunk_start + max_rows_per_chunk).min(last_row), + .map(|(id, chunk_start)| { + let start = Point::new(chunk_start, 0); + let end_exclusive = (chunk_start + max_rows_per_chunk).min(last_row); + let end = if id == last_chunk_id { + Point::new(end_exclusive, snapshot.line_len(end_exclusive)) + } else { + Point::new(end_exclusive, 0) + }; + RowChunk { + id, + start: chunk_start, + end_exclusive, + start_anchor: snapshot.anchor_before(start), + end_anchor: snapshot.anchor_after(end), + } }) .collect::>(); Self { - snapshot, chunks: Arc::from(chunks), + version: snapshot.version().clone(), } } - pub fn version(&self) -> &Global { - self.snapshot.version() + pub fn version(&self) -> &clock::Global { + &self.version } pub fn len(&self) -> usize { self.chunks.len() } - pub fn applicable_chunks( - &self, - ranges: &[Range], - ) -> impl Iterator { + pub fn applicable_chunks(&self, ranges: &[Range]) -> impl Iterator { let row_ranges = ranges .iter() - .map(|range| range.to_point(&self.snapshot)) // Be lenient and yield multiple chunks if they "touch" the exclusive part of the range. // This will result in LSP hints [re-]queried for more ranges, but also more hints already visible when scrolling around. .map(|point_range| point_range.start.row..point_range.end.row + 1) @@ -81,23 +90,6 @@ impl RowChunks { .copied() } - pub fn chunk_range(&self, chunk: RowChunk) -> Option> { - if !self.chunks.contains(&chunk) { - return None; - } - - let start = Point::new(chunk.start, 0); - let end = if self.chunks.last() == Some(&chunk) { - Point::new( - chunk.end_exclusive, - self.snapshot.line_len(chunk.end_exclusive), - ) - } else { - Point::new(chunk.end_exclusive, 0) - }; - Some(self.snapshot.anchor_before(start)..self.snapshot.anchor_after(end)) - } - pub fn previous_chunk(&self, chunk: RowChunk) -> Option { if chunk.id == 0 { None @@ -112,10 +104,16 @@ pub struct RowChunk { pub id: usize, pub start: BufferRow, pub end_exclusive: BufferRow, + pub start_anchor: Anchor, + pub end_anchor: Anchor, } impl RowChunk { pub fn row_range(&self) -> Range { self.start..self.end_exclusive } + + pub fn anchor_range(&self) -> Range { + self.start_anchor..self.end_anchor + } } diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index a8c639fe5930bf8c71d8bca5f2455364826c3514..b107be8b9ff32ef078d92700b46210a3c35c2845 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -6849,9 +6849,15 @@ impl LspStore { ranges: &[Range], cx: &mut Context, ) -> Vec> { + let buffer_snapshot = buffer.read(cx).snapshot(); + let ranges = ranges + .iter() + .map(|range| range.to_point(&buffer_snapshot)) + .collect::>(); + self.latest_lsp_data(buffer, cx) .inlay_hints - .applicable_chunks(ranges) + .applicable_chunks(ranges.as_slice()) .map(|chunk| chunk.row_range()) .collect() } @@ -6898,6 +6904,12 @@ impl LspStore { .map(|(_, known_chunks)| known_chunks) .unwrap_or_default(); + let buffer_snapshot = buffer.read(cx).snapshot(); + let ranges = ranges + .iter() + .map(|range| range.to_point(&buffer_snapshot)) + .collect::>(); + let mut hint_fetch_tasks = Vec::new(); let mut cached_inlay_hints = None; let mut ranges_to_query = None; @@ -6922,9 +6934,7 @@ impl LspStore { .cloned(), ) { (None, None) => { - let Some(chunk_range) = existing_inlay_hints.chunk_range(row_chunk) else { - continue; - }; + let chunk_range = row_chunk.anchor_range(); ranges_to_query .get_or_insert_with(Vec::new) .push((row_chunk, chunk_range)); @@ -12726,10 +12736,11 @@ impl LspStore { .update(cx, |buffer, _| buffer.wait_for_version(version))? .await?; lsp_store.update(cx, |lsp_store, cx| { + let buffer_snapshot = buffer.read(cx).snapshot(); let lsp_data = lsp_store.latest_lsp_data(&buffer, cx); let chunks_queried_for = lsp_data .inlay_hints - .applicable_chunks(&[range]) + .applicable_chunks(&[range.to_point(&buffer_snapshot)]) .collect::>(); match chunks_queried_for.as_slice() { &[chunk] => { diff --git a/crates/project/src/lsp_store/inlay_hint_cache.rs b/crates/project/src/lsp_store/inlay_hint_cache.rs index 804552b52cee9f31799e12f3c42e0614291eeab9..0cd9698e74bbfa4c53ad58569ebf59db99b5decd 100644 --- a/crates/project/src/lsp_store/inlay_hint_cache.rs +++ b/crates/project/src/lsp_store/inlay_hint_cache.rs @@ -8,7 +8,7 @@ use language::{ row_chunk::{RowChunk, RowChunks}, }; use lsp::LanguageServerId; -use text::Anchor; +use text::Point; use crate::{InlayHint, InlayId}; @@ -90,10 +90,7 @@ impl BufferInlayHints { } } - pub fn applicable_chunks( - &self, - ranges: &[Range], - ) -> impl Iterator { + pub fn applicable_chunks(&self, ranges: &[Range]) -> impl Iterator { self.chunks.applicable_chunks(ranges) } @@ -226,8 +223,4 @@ impl BufferInlayHints { } } } - - pub fn chunk_range(&self, chunk: RowChunk) -> Option> { - self.chunks.chunk_range(chunk) - } } From ba24ac7aae456dc3862fcd569a5041388d05f96c Mon Sep 17 00:00:00 2001 From: Luca <45566784+LuggaPugga@users.noreply.github.com> Date: Tue, 16 Dec 2025 12:35:45 +0100 Subject: [PATCH 043/266] fix: updated cursor linux keymap to use new AcceptNextWordEditPrediction (#44971) ### Problem PR #44411 replaced the `editor::AcceptPartialEditPrediction` action with `editor::AcceptNextLineEditPrediction` and `editor::AcceptNextWordEditPrediction`. However, the Linux cursor keymap wasn't updated to reflect this change, causing a panic on startup for Linux users. ### Solution Updated the Linux keymap configuration to reference the new actions Release Notes: - N/A --- assets/keymaps/linux/cursor.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/assets/keymaps/linux/cursor.json b/assets/keymaps/linux/cursor.json index 53f38234bb47a0f7c4412bf767e3eedf0465ba2a..58a7309cf902a3f69f949830cace2200f41fb0fe 100644 --- a/assets/keymaps/linux/cursor.json +++ b/assets/keymaps/linux/cursor.json @@ -70,7 +70,8 @@ "context": "Editor && mode == full && edit_prediction", "use_key_equivalents": true, "bindings": { - "ctrl-right": "editor::AcceptPartialEditPrediction", + "ctrl-right": "editor::AcceptNextWordEditPrediction", + "ctrl-down": "editor::AcceptNextLineEditPrediction", }, }, { From f358b9531a3311b449c3fde41a04f7bfc0c574f2 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Tue, 16 Dec 2025 17:09:11 +0530 Subject: [PATCH 044/266] gpui: Add grid repeat min content API (#44973) Required for https://github.com/zed-industries/zed/pull/44712 We started using `grid` for Markdown tables instead of flex. This resulted in tables having a width of 0 inside popovers, since popovers are laid out using `AvailableSpace::MinContent`. One way to fix this is to lay out popovers using `MaxContent` instead. But that would affect all Markdown rendered in popovers and could change how popovers look, or regress things. The other option is to fix it where the problem actually is: `repeat(count, vec![minmax(length(0.0), fr(1.0))])`. Since the minimum width here is `0`, laying things out with `MinContent` causes the Markdown table to shrink completely. What we want instead is for the minimum width to be the min-content size, but only for Markdown rendered inside popovers. This PR does exactly that, without interfering with the `grid_cols` API, which intentionally follows a TailwindCSS-like convention. See https://github.com/zed-industries/zed/pull/44368 for context. Release Notes: - N/A --- crates/gpui/src/style.rs | 5 +++++ crates/gpui/src/styled.rs | 7 +++++++ crates/gpui/src/taffy.rs | 15 ++++++++++++++- 3 files changed, 26 insertions(+), 1 deletion(-) diff --git a/crates/gpui/src/style.rs b/crates/gpui/src/style.rs index 446c3ad2a325681a39689577a261ed1ffdde6d5b..4d6e6f490d81d967692a3e9d8316af75a7a4d306 100644 --- a/crates/gpui/src/style.rs +++ b/crates/gpui/src/style.rs @@ -265,6 +265,10 @@ pub struct Style { /// Equivalent to the Tailwind `grid-cols-` pub grid_cols: Option, + /// The grid columns with min-content minimum sizing. + /// Unlike grid_cols, it won't shrink to width 0 in AvailableSpace::MinContent constraints. + pub grid_cols_min_content: Option, + /// The row span of this element /// Equivalent to the Tailwind `grid-rows-` pub grid_rows: Option, @@ -772,6 +776,7 @@ impl Default for Style { opacity: None, grid_rows: None, grid_cols: None, + grid_cols_min_content: None, grid_location: None, #[cfg(debug_assertions)] diff --git a/crates/gpui/src/styled.rs b/crates/gpui/src/styled.rs index e01649be481e27f89643db2ffb3a9ccd294b9b73..e8088a84d7fc141d0a320988c6399afe2b93ce07 100644 --- a/crates/gpui/src/styled.rs +++ b/crates/gpui/src/styled.rs @@ -637,6 +637,13 @@ pub trait Styled: Sized { self } + /// Sets the grid columns with min-content minimum sizing. + /// Unlike grid_cols, it won't shrink to width 0 in AvailableSpace::MinContent constraints. + fn grid_cols_min_content(mut self, cols: u16) -> Self { + self.style().grid_cols_min_content = Some(cols); + self + } + /// Sets the grid rows of this element. fn grid_rows(mut self, rows: u16) -> Self { self.style().grid_rows = Some(rows); diff --git a/crates/gpui/src/taffy.rs b/crates/gpui/src/taffy.rs index 11cb0872861321c3c06c3f8a5bf79fdd30eb2275..99a50b87c8aa9f40a7694f1c2084b10f6d0a9315 100644 --- a/crates/gpui/src/taffy.rs +++ b/crates/gpui/src/taffy.rs @@ -8,6 +8,7 @@ use std::{fmt::Debug, ops::Range}; use taffy::{ TaffyTree, TraversePartialTree as _, geometry::{Point as TaffyPoint, Rect as TaffyRect, Size as TaffySize}, + prelude::min_content, style::AvailableSpace as TaffyAvailableSpace, tree::NodeId, }; @@ -314,6 +315,14 @@ impl ToTaffy for Style { .unwrap_or_default() } + fn to_grid_repeat_min_content( + unit: &Option, + ) -> Vec> { + // grid-template-columns: repeat(, minmax(min-content, 1fr)); + unit.map(|count| vec![repeat(count, vec![minmax(min_content(), fr(1.0))])]) + .unwrap_or_default() + } + taffy::style::Style { display: self.display.into(), overflow: self.overflow.into(), @@ -338,7 +347,11 @@ impl ToTaffy for Style { flex_grow: self.flex_grow, flex_shrink: self.flex_shrink, grid_template_rows: to_grid_repeat(&self.grid_rows), - grid_template_columns: to_grid_repeat(&self.grid_cols), + grid_template_columns: if self.grid_cols_min_content.is_some() { + to_grid_repeat_min_content(&self.grid_cols_min_content) + } else { + to_grid_repeat(&self.grid_cols) + }, grid_row: self .grid_location .as_ref() From 30deb22ab7f0ae7d8c2df879176789cfaa948b44 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 09:04:07 -0300 Subject: [PATCH 045/266] agent_ui: Add the ability to delete a profile through the UI (#44977) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit It was only possible to delete profiles through the `settings.json`, but now you can do it through the UI: Screenshot 2025-12-16 at 8  42@2x Release Notes: - agent: Added the ability to delete a profile through the "Manage Profiles" modal. --- .../manage_profiles_modal.rs | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+) diff --git a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs index 2f17349c3d1da1cf68a3ab513ccad434a115087b..ed00b2b5c716fdf27abc1c9d7c5850b36fce830f 100644 --- a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs +++ b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs @@ -8,6 +8,7 @@ use editor::Editor; use fs::Fs; use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, prelude::*}; use language_model::{LanguageModel, LanguageModelRegistry}; +use settings::SettingsStore; use settings::{ LanguageModelProviderSetting, LanguageModelSelection, Settings as _, update_settings_file, }; @@ -94,6 +95,7 @@ pub struct ViewProfileMode { configure_default_model: NavigableEntry, configure_tools: NavigableEntry, configure_mcps: NavigableEntry, + delete_profile: NavigableEntry, cancel_item: NavigableEntry, } @@ -109,6 +111,7 @@ pub struct ManageProfilesModal { active_model: Option>, focus_handle: FocusHandle, mode: Mode, + _settings_subscription: Subscription, } impl ManageProfilesModal { @@ -148,12 +151,23 @@ impl ManageProfilesModal { ) -> Self { let focus_handle = cx.focus_handle(); + // Keep this modal in sync with settings changes (including profile deletion). + let settings_subscription = + cx.observe_global_in::(window, |this, window, cx| { + if matches!(this.mode, Mode::ChooseProfile(_)) { + this.mode = Mode::choose_profile(window, cx); + this.focus_handle(cx).focus(window); + cx.notify(); + } + }); + Self { fs, active_model, context_server_registry, focus_handle, mode: Mode::choose_profile(window, cx), + _settings_subscription: settings_subscription, } } @@ -192,6 +206,7 @@ impl ManageProfilesModal { configure_default_model: NavigableEntry::focusable(cx), configure_tools: NavigableEntry::focusable(cx), configure_mcps: NavigableEntry::focusable(cx), + delete_profile: NavigableEntry::focusable(cx), cancel_item: NavigableEntry::focusable(cx), }); self.focus_handle(cx).focus(window); @@ -369,6 +384,42 @@ impl ManageProfilesModal { } } + fn delete_profile( + &mut self, + profile_id: AgentProfileId, + window: &mut Window, + cx: &mut Context, + ) { + if builtin_profiles::is_builtin(&profile_id) { + self.view_profile(profile_id, window, cx); + return; + } + + let fs = self.fs.clone(); + + update_settings_file(fs, cx, move |settings, _cx| { + let Some(agent_settings) = settings.agent.as_mut() else { + return; + }; + + let Some(profiles) = agent_settings.profiles.as_mut() else { + return; + }; + + profiles.shift_remove(profile_id.0.as_ref()); + + if agent_settings + .default_profile + .as_deref() + .is_some_and(|default_profile| default_profile == profile_id.0.as_ref()) + { + agent_settings.default_profile = Some(AgentProfileId::default().0); + } + }); + + self.choose_profile(window, cx); + } + fn cancel(&mut self, window: &mut Window, cx: &mut Context) { match &self.mode { Mode::ChooseProfile { .. } => { @@ -756,6 +807,40 @@ impl ManageProfilesModal { }), ), ) + .child( + div() + .id("delete-profile") + .track_focus(&mode.delete_profile.focus_handle) + .on_action({ + let profile_id = mode.profile_id.clone(); + cx.listener(move |this, _: &menu::Confirm, window, cx| { + this.delete_profile(profile_id.clone(), window, cx); + }) + }) + .child( + ListItem::new("delete-profile") + .toggle_state( + mode.delete_profile + .focus_handle + .contains_focused(window, cx), + ) + .inset(true) + .spacing(ListItemSpacing::Sparse) + .start_slot( + Icon::new(IconName::Trash) + .size(IconSize::Small) + .color(Color::Error), + ) + .child(Label::new("Delete Profile").color(Color::Error)) + .disabled(builtin_profiles::is_builtin(&mode.profile_id)) + .on_click({ + let profile_id = mode.profile_id.clone(); + cx.listener(move |this, _, window, cx| { + this.delete_profile(profile_id.clone(), window, cx); + }) + }), + ), + ) .child(ListSeparator) .child( div() @@ -805,6 +890,7 @@ impl ManageProfilesModal { .entry(mode.configure_default_model) .entry(mode.configure_tools) .entry(mode.configure_mcps) + .entry(mode.delete_profile) .entry(mode.cancel_item) } } From 4e482288cb42fc998e6af18b87d643940c5fa3bf Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 09:15:08 -0300 Subject: [PATCH 046/266] agent_ui: Add keybinding to cycle through profiles (#44979) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Similar to the mode selector in external agents, it will now be possible to use `shift-tab` to cycle through profiles. Screenshot 2025-12-16 at 9  04@2x Release Notes: - Added the ability to use `shift-tab` to cycle through profiles for the built-in Zed agent. --- crates/agent_ui/src/acp/thread_view.rs | 6 ++- crates/agent_ui/src/profile_selector.rs | 56 +++++++++++++++++++++---- 2 files changed, 52 insertions(+), 10 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 6cd2ec2fa3442bbf4961dffb0c4538ac9615d982..bc449c3c3a0238a5989c52abec029a708bf9f0ba 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -4208,7 +4208,11 @@ impl AcpThreadView { } })) .on_action(cx.listener(|this, _: &CycleModeSelector, window, cx| { - if let Some(mode_selector) = this.mode_selector() { + if let Some(profile_selector) = this.profile_selector.as_ref() { + profile_selector.update(cx, |profile_selector, cx| { + profile_selector.cycle_profile(cx); + }); + } else if let Some(mode_selector) = this.mode_selector() { mode_selector.update(cx, |mode_selector, cx| { mode_selector.cycle_mode(window, cx); }); diff --git a/crates/agent_ui/src/profile_selector.rs b/crates/agent_ui/src/profile_selector.rs index 0182be0912d3b8a8a046371ce725e7d21a0ddb58..ac08070fcefa92854b51bc8a66d4d388d08e087d 100644 --- a/crates/agent_ui/src/profile_selector.rs +++ b/crates/agent_ui/src/profile_selector.rs @@ -1,4 +1,4 @@ -use crate::{ManageProfiles, ToggleProfileSelector}; +use crate::{CycleModeSelector, ManageProfiles, ToggleProfileSelector}; use agent_settings::{ AgentProfile, AgentProfileId, AgentSettings, AvailableProfiles, builtin_profiles, }; @@ -70,6 +70,29 @@ impl ProfileSelector { self.picker_handle.clone() } + pub fn cycle_profile(&mut self, cx: &mut Context) { + if !self.provider.profiles_supported(cx) { + return; + } + + let profiles = AgentProfile::available_profiles(cx); + if profiles.is_empty() { + return; + } + + let current_profile_id = self.provider.profile_id(cx); + let current_index = profiles + .keys() + .position(|id| id == ¤t_profile_id) + .unwrap_or(0); + + let next_index = (current_index + 1) % profiles.len(); + + if let Some((next_profile_id, _)) = profiles.get_index(next_index) { + self.provider.set_profile(next_profile_id.clone(), cx); + } + } + fn ensure_picker( &mut self, window: &mut Window, @@ -163,14 +186,29 @@ impl Render for ProfileSelector { PickerPopoverMenu::new( picker, trigger_button, - move |_window, cx| { - Tooltip::for_action_in( - "Toggle Profile Menu", - &ToggleProfileSelector, - &focus_handle, - cx, - ) - }, + Tooltip::element({ + move |_window, cx| { + let container = || h_flex().gap_1().justify_between(); + v_flex() + .gap_1() + .child( + container() + .pb_1() + .border_b_1() + .border_color(cx.theme().colors().border_variant) + .child(Label::new("Cycle Through Profiles")) + .child(KeyBinding::for_action_in( + &CycleModeSelector, + &focus_handle, + cx, + )), + ) + .child(container().child(Label::new("Toggle Profile Menu")).child( + KeyBinding::for_action_in(&ToggleProfileSelector, &focus_handle, cx), + )) + .into_any() + } + }), gpui::Corner::BottomRight, cx, ) From 5152fd898ef941d607abf07317dbf9edc27e998c Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Tue, 16 Dec 2025 13:35:47 +0100 Subject: [PATCH 047/266] agent_ui: Add scroll to most recent user prompt button (#44961) Release Notes: - Added a button to the agent thread view that scrolls to the most recent prompt --- crates/agent_ui/src/acp/thread_view.rs | 103 ++++++++++++++++++++++++- 1 file changed, 102 insertions(+), 1 deletion(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index bc449c3c3a0238a5989c52abec029a708bf9f0ba..f5e5b6c3b261d5c82bf8d3fc3fc13d482e69ca7d 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -693,7 +693,7 @@ impl AcpThreadView { this.new_server_version_available = Some(new_version.into()); cx.notify(); }) - .log_err(); + .ok(); } } }) @@ -4863,6 +4863,32 @@ impl AcpThreadView { cx.notify(); } + fn scroll_to_most_recent_user_prompt(&mut self, cx: &mut Context) { + let Some(thread) = self.thread() else { + return; + }; + + let entries = thread.read(cx).entries(); + if entries.is_empty() { + return; + } + + // Find the most recent user message and scroll it to the top of the viewport. + // (Fallback: if no user message exists, scroll to the bottom.) + if let Some(ix) = entries + .iter() + .rposition(|entry| matches!(entry, AgentThreadEntry::UserMessage(_))) + { + self.list_state.scroll_to(ListOffset { + item_ix: ix, + offset_in_item: px(0.0), + }); + cx.notify(); + } else { + self.scroll_to_bottom(cx); + } + } + pub fn scroll_to_bottom(&mut self, cx: &mut Context) { if let Some(thread) = self.thread() { let entry_count = thread.read(cx).entries().len(); @@ -5081,6 +5107,16 @@ impl AcpThreadView { } })); + let scroll_to_recent_user_prompt = + IconButton::new("scroll_to_recent_user_prompt", IconName::ForwardArrow) + .shape(ui::IconButtonShape::Square) + .icon_size(IconSize::Small) + .icon_color(Color::Ignored) + .tooltip(Tooltip::text("Scroll To Most Recent User Prompt")) + .on_click(cx.listener(move |this, _, _, cx| { + this.scroll_to_most_recent_user_prompt(cx); + })); + let scroll_to_top = IconButton::new("scroll_to_top", IconName::ArrowUp) .shape(ui::IconButtonShape::Square) .icon_size(IconSize::Small) @@ -5157,6 +5193,7 @@ impl AcpThreadView { container .child(open_as_markdown) + .child(scroll_to_recent_user_prompt) .child(scroll_to_top) .into_any_element() } @@ -6789,6 +6826,70 @@ pub(crate) mod tests { }); } + #[gpui::test] + async fn test_scroll_to_most_recent_user_prompt(cx: &mut TestAppContext) { + init_test(cx); + + let connection = StubAgentConnection::new(); + + // Each user prompt will result in a user message entry plus an agent message entry. + connection.set_next_prompt_updates(vec![acp::SessionUpdate::AgentMessageChunk( + acp::ContentChunk::new("Response 1".into()), + )]); + + let (thread_view, cx) = + setup_thread_view(StubAgentServer::new(connection.clone()), cx).await; + + let thread = thread_view + .read_with(cx, |view, _| view.thread().cloned()) + .unwrap(); + + thread + .update(cx, |thread, cx| thread.send_raw("Prompt 1", cx)) + .await + .unwrap(); + cx.run_until_parked(); + + connection.set_next_prompt_updates(vec![acp::SessionUpdate::AgentMessageChunk( + acp::ContentChunk::new("Response 2".into()), + )]); + + thread + .update(cx, |thread, cx| thread.send_raw("Prompt 2", cx)) + .await + .unwrap(); + cx.run_until_parked(); + + // Move somewhere else first so we're not trivially already on the last user prompt. + thread_view.update(cx, |view, cx| { + view.scroll_to_top(cx); + }); + cx.run_until_parked(); + + thread_view.update(cx, |view, cx| { + view.scroll_to_most_recent_user_prompt(cx); + let scroll_top = view.list_state.logical_scroll_top(); + // Entries layout is: [User1, Assistant1, User2, Assistant2] + assert_eq!(scroll_top.item_ix, 2); + }); + } + + #[gpui::test] + async fn test_scroll_to_most_recent_user_prompt_falls_back_to_bottom_without_user_messages( + cx: &mut TestAppContext, + ) { + init_test(cx); + + let (thread_view, cx) = setup_thread_view(StubAgentServer::default_response(), cx).await; + + // With no entries, scrolling should be a no-op and must not panic. + thread_view.update(cx, |view, cx| { + view.scroll_to_most_recent_user_prompt(cx); + let scroll_top = view.list_state.logical_scroll_top(); + assert_eq!(scroll_top.item_ix, 0); + }); + } + #[gpui::test] async fn test_message_editing_cancel(cx: &mut TestAppContext) { init_test(cx); From 68295ba3713b00ddebaa8de81f166085d4fe5fc6 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Tue, 16 Dec 2025 18:11:06 +0530 Subject: [PATCH 048/266] markdown: Fix Markdown table not rendering in hover popover (#44712) Closes #44306 This PR makes two changes: - Uses the new `grid_cols_min_content` API. See more here: https://github.com/zed-industries/zed/pull/44973. - Changes Markdown table rendering to use a single grid instead of creating a new grid per row, so column widths stay consistent across rows. Release Notes: - Fixed an issue where Markdown tables wouldn't render in the hover popover. --- crates/editor/src/hover_popover.rs | 2 ++ crates/markdown/src/markdown.rs | 56 ++++++++++++++++++------------ 2 files changed, 35 insertions(+), 23 deletions(-) diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs index 7c3e41e8c2edf721fbcae729069eecb640e2246c..64415005ec61b1ce942e4fbedaabc70919f5e61d 100644 --- a/crates/editor/src/hover_popover.rs +++ b/crates/editor/src/hover_popover.rs @@ -656,6 +656,7 @@ pub fn hover_markdown_style(window: &Window, cx: &App) -> MarkdownStyle { .text_base() .mt(rems(1.)) .mb_0(), + table_columns_min_size: true, ..Default::default() } } @@ -709,6 +710,7 @@ pub fn diagnostics_markdown_style(window: &Window, cx: &App) -> MarkdownStyle { .font_weight(FontWeight::BOLD) .text_base() .mb_0(), + table_columns_min_size: true, ..Default::default() } } diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index 270192107c13e8ddfc5eba1b3e6e8e298b93125a..50de82fb5f24bd0328123ada86d80d073b675801 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -70,6 +70,7 @@ pub struct MarkdownStyle { pub heading_level_styles: Option, pub height_is_multiple_of_line_height: bool, pub prevent_mouse_interaction: bool, + pub table_columns_min_size: bool, } impl Default for MarkdownStyle { @@ -91,6 +92,7 @@ impl Default for MarkdownStyle { heading_level_styles: None, height_is_multiple_of_line_height: false, prevent_mouse_interaction: false, + table_columns_min_size: false, } } } @@ -1062,11 +1064,21 @@ impl Element for MarkdownElement { MarkdownTag::MetadataBlock(_) => {} MarkdownTag::Table(alignments) => { builder.table_alignments = alignments.clone(); + builder.table_row_index = 0; + builder.in_table_head = false; + let column_count = alignments.len(); builder.push_div( div() .id(("table", range.start)) - .min_w_0() + .grid() + .grid_cols(column_count as u16) + .when(self.style.table_columns_min_size, |this| { + this.grid_cols_min_content(column_count as u16) + }) + .when(!self.style.table_columns_min_size, |this| { + this.grid_cols(column_count as u16) + }) .size_full() .mb_2() .border_1() @@ -1078,38 +1090,30 @@ impl Element for MarkdownElement { ); } MarkdownTag::TableHead => { - let column_count = builder.table_alignments.len(); - - builder.push_div( - div() - .grid() - .grid_cols(column_count as u16) - .bg(cx.theme().colors().title_bar_background), - range, - markdown_end, - ); + builder.in_table_head = true; builder.push_text_style(TextStyleRefinement { font_weight: Some(FontWeight::SEMIBOLD), ..Default::default() }); } - MarkdownTag::TableRow => { - let column_count = builder.table_alignments.len(); - - builder.push_div( - div().grid().grid_cols(column_count as u16), - range, - markdown_end, - ); - } + MarkdownTag::TableRow => {} MarkdownTag::TableCell => { + let is_header = builder.in_table_head; + let row_index = builder.table_row_index; + builder.push_div( div() .min_w_0() .border(px(0.5)) .border_color(cx.theme().colors().border) .px_1() - .py_0p5(), + .py_0p5() + .when(is_header, |this| { + this.bg(cx.theme().colors().title_bar_background) + }) + .when(!is_header && row_index % 2 == 1, |this| { + this.bg(cx.theme().colors().panel_background) + }), range, markdown_end, ); @@ -1224,13 +1228,15 @@ impl Element for MarkdownElement { MarkdownTagEnd::Table => { builder.pop_div(); builder.table_alignments.clear(); + builder.in_table_head = false; + builder.table_row_index = 0; } MarkdownTagEnd::TableHead => { - builder.pop_div(); builder.pop_text_style(); + builder.in_table_head = false; } MarkdownTagEnd::TableRow => { - builder.pop_div(); + builder.table_row_index += 1; } MarkdownTagEnd::TableCell => { builder.pop_div(); @@ -1500,6 +1506,8 @@ struct MarkdownElementBuilder { code_block_stack: Vec>>, list_stack: Vec, table_alignments: Vec, + in_table_head: bool, + table_row_index: usize, syntax_theme: Arc, } @@ -1536,6 +1544,8 @@ impl MarkdownElementBuilder { code_block_stack: Vec::new(), list_stack: Vec::new(), table_alignments: Vec::new(), + in_table_head: false, + table_row_index: 0, syntax_theme, } } From 90d7ccfd5d0db23b04e4cf48d1f049b211654f12 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 09:46:08 -0300 Subject: [PATCH 049/266] agent_ui: Search models only by name (#44984) We were previously matching the search on both model name and provider ID. In most cases, this would yield an okay result, but if you search for "Opus", for example, you'd see the Sonnet models in the search result, which was very confusing. This was because we were matching to both provider ID and model name. "Sonnet" and "Opus" share the same provider ID, so they both contain "Anthropic" as a prefix. Then, "Opus" contains the letter P, as well as Anthropic, thus the match. Now, we're only matching by model name, which I think most of the time will yield more accurate results. Release Notes: - agent: Improved the model search quality in the model picker. --- crates/agent_ui/src/acp/model_selector.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs index f9710ad9b3aac29546dbe66a518a198d9b113385..959e0e72f38feadb39da38b7bbc3eed58dcd775e 100644 --- a/crates/agent_ui/src/acp/model_selector.rs +++ b/crates/agent_ui/src/acp/model_selector.rs @@ -403,9 +403,7 @@ async fn fuzzy_search( let candidates = model_list .iter() .enumerate() - .map(|(ix, model)| { - StringMatchCandidate::new(ix, &format!("{}/{}", model.id, model.name)) - }) + .map(|(ix, model)| StringMatchCandidate::new(ix, model.name.as_ref())) .collect::>(); let mut matches = match_strings( &candidates, From 775548e93c2fe1f56351acc92ae95b379b5cc4d6 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 09:55:26 -0300 Subject: [PATCH 050/266] ui: Fix Divider component growing unnecessarily (#44986) I had previously added `flex_none` to the Divider and that caused it to grow beyond the container's width in some cases (project panel, agent panel's restore to check point button, etc.). Release Notes: - N/A --- crates/project_panel/src/project_panel.rs | 4 ++-- crates/ui/src/components/divider.rs | 2 -- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index a645ae194b19e5770386ed2eb97de11f9350a866..ea667ecbb479ca347914ee11ec789a14f29cf474 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -6050,9 +6050,9 @@ impl Render for ProjectPanel { h_flex() .w_1_2() .gap_2() - .child(div().flex_1().child(Divider::horizontal())) + .child(Divider::horizontal()) .child(Label::new("or").size(LabelSize::XSmall).color(Color::Muted)) - .child(div().flex_1().child(Divider::horizontal())), + .child(Divider::horizontal()), ) .child( Button::new("clone_repo", "Clone Repository") diff --git a/crates/ui/src/components/divider.rs b/crates/ui/src/components/divider.rs index cc7ad19875d2817d98076812bb7b9ea101341107..5ad2187cfae36f3cc45cbecb42f115f0742abed4 100644 --- a/crates/ui/src/components/divider.rs +++ b/crates/ui/src/components/divider.rs @@ -146,13 +146,11 @@ impl RenderOnce for Divider { let base = match self.direction { DividerDirection::Horizontal => div() .min_w_0() - .flex_none() .h_px() .w_full() .when(self.inset, |this| this.mx_1p5()), DividerDirection::Vertical => div() .min_w_0() - .flex_none() .w_px() .h_full() .when(self.inset, |this| this.my_1p5()), From 37bd27b2a8b2f26e70c3a279bad1fbb70d0e3f47 Mon Sep 17 00:00:00 2001 From: lif <1835304752@qq.com> Date: Tue, 16 Dec 2025 21:05:31 +0800 Subject: [PATCH 051/266] diagnostics: Respect toolbar breadcrumbs setting in diagnostics panel (#44974) ## Summary The diagnostics panel was ignoring the user's `toolbar.breadcrumbs` setting and always showing breadcrumbs. This makes both `BufferDiagnosticsEditor` and `ProjectDiagnosticsEditor` check the `EditorSettings` to determine whether to display breadcrumbs. ## Changes - `buffer_diagnostics.rs`: Updated `breadcrumb_location` to check `EditorSettings::get_global(cx).toolbar.breadcrumbs` - `diagnostics.rs`: Updated `breadcrumb_location` to check `EditorSettings::get_global(cx).toolbar.breadcrumbs` This follows the same pattern used by the regular `Editor` in `items.rs`. ## Test plan 1. Set `toolbar.breadcrumbs` to `false` in settings.json 2. Open a file with diagnostics 3. Run `diagnostics: deploy current file` 4. Verify that breadcrumbs are hidden in the diagnostics panel Fixes #43020 --- crates/diagnostics/src/buffer_diagnostics.rs | 10 +++++++--- crates/diagnostics/src/diagnostics.rs | 10 +++++++--- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/crates/diagnostics/src/buffer_diagnostics.rs b/crates/diagnostics/src/buffer_diagnostics.rs index 0fd8783dd514f8da3c53d41dcb6f8e9004ae501c..ca28f2805adca78846a66e7b1f4d9f3fc57bb557 100644 --- a/crates/diagnostics/src/buffer_diagnostics.rs +++ b/crates/diagnostics/src/buffer_diagnostics.rs @@ -6,7 +6,7 @@ use crate::{ use anyhow::Result; use collections::HashMap; use editor::{ - Editor, EditorEvent, ExcerptRange, MultiBuffer, PathKey, + Editor, EditorEvent, EditorSettings, ExcerptRange, MultiBuffer, PathKey, display_map::{BlockPlacement, BlockProperties, BlockStyle, CustomBlockId}, multibuffer_context_lines, }; @@ -701,8 +701,12 @@ impl Item for BufferDiagnosticsEditor { }); } - fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation { - ToolbarItemLocation::PrimaryLeft + fn breadcrumb_location(&self, cx: &App) -> ToolbarItemLocation { + if EditorSettings::get_global(cx).toolbar.breadcrumbs { + ToolbarItemLocation::PrimaryLeft + } else { + ToolbarItemLocation::Hidden + } } fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option> { diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs index 76edf4f9b438aca1c47393c9c14c6321d0013eb8..0999bebdb6aa9ca744e3a5121670a1b7357411a9 100644 --- a/crates/diagnostics/src/diagnostics.rs +++ b/crates/diagnostics/src/diagnostics.rs @@ -12,7 +12,7 @@ use buffer_diagnostics::BufferDiagnosticsEditor; use collections::{BTreeSet, HashMap, HashSet}; use diagnostic_renderer::DiagnosticBlock; use editor::{ - Editor, EditorEvent, ExcerptRange, MultiBuffer, PathKey, + Editor, EditorEvent, EditorSettings, ExcerptRange, MultiBuffer, PathKey, display_map::{BlockPlacement, BlockProperties, BlockStyle, CustomBlockId}, multibuffer_context_lines, }; @@ -894,8 +894,12 @@ impl Item for ProjectDiagnosticsEditor { Some(Box::new(self.editor.clone())) } - fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation { - ToolbarItemLocation::PrimaryLeft + fn breadcrumb_location(&self, cx: &App) -> ToolbarItemLocation { + if EditorSettings::get_global(cx).toolbar.breadcrumbs { + ToolbarItemLocation::PrimaryLeft + } else { + ToolbarItemLocation::Hidden + } } fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option> { From 0362e301f72c4bcec766e8d309c2c2cdc3ba32eb Mon Sep 17 00:00:00 2001 From: Daiki Takagi <90747075+Suzushiro-radish@users.noreply.github.com> Date: Tue, 16 Dec 2025 22:43:23 +0900 Subject: [PATCH 052/266] acp_thread: Decode file:// mention paths so non-ASCII names render correctly (#44983) ## Summary This fixes a minor bug I found #44981 - Fix percent-encoded filenames appearing in agent mentions after message submission. - Decode file:// paths in MentionUri::parse using the existing urlencoding crate (already used elsewhere in the codebase). - Add tests for non-ASCII file URIs. ## Screenshots image --- Cargo.lock | 1 + crates/acp_thread/Cargo.toml | 1 + crates/acp_thread/src/mention.rs | 19 ++++++++++++++++++- 3 files changed, 20 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index 6d5d68fa9293a391ecfa1308c1c347a7cd48cb8b..5b35991dfde30b4b976ae96a552862876a245486 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -37,6 +37,7 @@ dependencies = [ "terminal", "ui", "url", + "urlencoding", "util", "uuid", "watch", diff --git a/crates/acp_thread/Cargo.toml b/crates/acp_thread/Cargo.toml index 8ef6f1a52c8b207658d59a1e6b877964df9e42ce..70f2e4d259f1611fb42ebc0b064d278c8b3b9c4d 100644 --- a/crates/acp_thread/Cargo.toml +++ b/crates/acp_thread/Cargo.toml @@ -46,6 +46,7 @@ url.workspace = true util.workspace = true uuid.workspace = true watch.workspace = true +urlencoding.workspace = true [dev-dependencies] env_logger.workspace = true diff --git a/crates/acp_thread/src/mention.rs b/crates/acp_thread/src/mention.rs index c1b7032cfaa904764055bb79a3cac7e7ac74b0c1..3e2e53fb7fbdf581b45566bd747cfcbfc1c0a004 100644 --- a/crates/acp_thread/src/mention.rs +++ b/crates/acp_thread/src/mention.rs @@ -4,12 +4,14 @@ use file_icons::FileIcons; use prompt_store::{PromptId, UserPromptId}; use serde::{Deserialize, Serialize}; use std::{ + borrow::Cow, fmt, ops::RangeInclusive, path::{Path, PathBuf}, }; use ui::{App, IconName, SharedString}; use url::Url; +use urlencoding::decode; use util::paths::PathStyle; #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)] @@ -74,11 +76,13 @@ impl MentionUri { let path = url.path(); match url.scheme() { "file" => { - let path = if path_style.is_windows() { + let normalized = if path_style.is_windows() { path.trim_start_matches("/") } else { path }; + let decoded = decode(normalized).unwrap_or(Cow::Borrowed(normalized)); + let path = decoded.as_ref(); if let Some(fragment) = url.fragment() { let line_range = parse_line_range(fragment)?; @@ -406,6 +410,19 @@ mod tests { assert_eq!(parsed.to_uri().to_string(), selection_uri); } + #[test] + fn test_parse_file_uri_with_non_ascii() { + let file_uri = uri!("file:///path/to/%E6%97%A5%E6%9C%AC%E8%AA%9E.txt"); + let parsed = MentionUri::parse(file_uri, PathStyle::local()).unwrap(); + match &parsed { + MentionUri::File { abs_path } => { + assert_eq!(abs_path, Path::new(path!("/path/to/日本語.txt"))); + } + _ => panic!("Expected File variant"), + } + assert_eq!(parsed.to_uri().to_string(), file_uri); + } + #[test] fn test_parse_untitled_selection_uri() { let selection_uri = uri!("zed:///agent/untitled-buffer#L1:10"); From 5f451c89e07edffa443fcc8293f4055213ce0fcf Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Tue, 16 Dec 2025 19:18:52 +0530 Subject: [PATCH 053/266] markdown: Fix double borders in Markdown and Markdown Preview tables (#44991) Improves upon https://github.com/zed-industries/zed/pull/42674 Before: image image After: image image Release Notes: - Fixed an issue where Markdown tables would sometimes show double borders. --- crates/markdown/src/markdown.rs | 82 ++++++++++++++----- .../markdown_preview/src/markdown_renderer.rs | 12 ++- 2 files changed, 69 insertions(+), 25 deletions(-) diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index 50de82fb5f24bd0328123ada86d80d073b675801..536d9fd6a2439e9b23b9f99d20a4aff425eda956 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -1063,9 +1063,7 @@ impl Element for MarkdownElement { } MarkdownTag::MetadataBlock(_) => {} MarkdownTag::Table(alignments) => { - builder.table_alignments = alignments.clone(); - builder.table_row_index = 0; - builder.in_table_head = false; + builder.table.start(alignments.clone()); let column_count = alignments.len(); builder.push_div( @@ -1081,7 +1079,7 @@ impl Element for MarkdownElement { }) .size_full() .mb_2() - .border_1() + .border(px(1.5)) .border_color(cx.theme().colors().border) .rounded_sm() .overflow_hidden(), @@ -1090,21 +1088,24 @@ impl Element for MarkdownElement { ); } MarkdownTag::TableHead => { - builder.in_table_head = true; + builder.table.start_head(); builder.push_text_style(TextStyleRefinement { font_weight: Some(FontWeight::SEMIBOLD), ..Default::default() }); } - MarkdownTag::TableRow => {} + MarkdownTag::TableRow => { + builder.table.start_row(); + } MarkdownTag::TableCell => { - let is_header = builder.in_table_head; - let row_index = builder.table_row_index; + let is_header = builder.table.in_head; + let row_index = builder.table.row_index; + let col_index = builder.table.col_index; builder.push_div( div() - .min_w_0() - .border(px(0.5)) + .when(col_index > 0, |this| this.border_l_1()) + .when(row_index > 0, |this| this.border_t_1()) .border_color(cx.theme().colors().border) .px_1() .py_0p5() @@ -1227,19 +1228,18 @@ impl Element for MarkdownElement { } MarkdownTagEnd::Table => { builder.pop_div(); - builder.table_alignments.clear(); - builder.in_table_head = false; - builder.table_row_index = 0; + builder.table.end(); } MarkdownTagEnd::TableHead => { builder.pop_text_style(); - builder.in_table_head = false; + builder.table.end_head(); } MarkdownTagEnd::TableRow => { - builder.table_row_index += 1; + builder.table.end_row(); } MarkdownTagEnd::TableCell => { builder.pop_div(); + builder.table.end_cell(); } _ => log::debug!("unsupported markdown tag end: {:?}", tag), }, @@ -1494,6 +1494,50 @@ impl ParentElement for AnyDiv { } } +#[derive(Default)] +struct TableState { + alignments: Vec, + in_head: bool, + row_index: usize, + col_index: usize, +} + +impl TableState { + fn start(&mut self, alignments: Vec) { + self.alignments = alignments; + self.in_head = false; + self.row_index = 0; + self.col_index = 0; + } + + fn end(&mut self) { + self.alignments.clear(); + self.in_head = false; + self.row_index = 0; + self.col_index = 0; + } + + fn start_head(&mut self) { + self.in_head = true; + } + + fn end_head(&mut self) { + self.in_head = false; + } + + fn start_row(&mut self) { + self.col_index = 0; + } + + fn end_row(&mut self) { + self.row_index += 1; + } + + fn end_cell(&mut self) { + self.col_index += 1; + } +} + struct MarkdownElementBuilder { div_stack: Vec, rendered_lines: Vec, @@ -1505,9 +1549,7 @@ struct MarkdownElementBuilder { text_style_stack: Vec, code_block_stack: Vec>>, list_stack: Vec, - table_alignments: Vec, - in_table_head: bool, - table_row_index: usize, + table: TableState, syntax_theme: Arc, } @@ -1543,9 +1585,7 @@ impl MarkdownElementBuilder { text_style_stack: Vec::new(), code_block_stack: Vec::new(), list_stack: Vec::new(), - table_alignments: Vec::new(), - in_table_head: false, - table_row_index: 0, + table: TableState::default(), syntax_theme, } } diff --git a/crates/markdown_preview/src/markdown_renderer.rs b/crates/markdown_preview/src/markdown_renderer.rs index 336f1cacfd2e3d7c25e19aeaf328b1c10db10b30..d4c810245c0fcf874160957cff1b029c4c4c1702 100644 --- a/crates/markdown_preview/src/markdown_renderer.rs +++ b/crates/markdown_preview/src/markdown_renderer.rs @@ -9,7 +9,7 @@ use gpui::{ AbsoluteLength, AnyElement, App, AppContext as _, ClipboardItem, Context, Div, Element, ElementId, Entity, HighlightStyle, Hsla, ImageSource, InteractiveText, IntoElement, Keystroke, Modifiers, ParentElement, Render, Resource, SharedString, Styled, StyledText, TextStyle, - WeakEntity, Window, div, img, rems, + WeakEntity, Window, div, img, px, rems, }; use settings::Settings; use std::{ @@ -521,7 +521,8 @@ fn render_markdown_table(parsed: &ParsedMarkdownTable, cx: &mut RenderContext) - .children(render_markdown_text(&cell.children, cx)) .px_2() .py_1() - .border_1() + .when(col_idx > 0, |this| this.border_l_1()) + .when(row_idx > 0, |this| this.border_t_1()) .border_color(cx.border_color) .when(cell.is_header, |this| { this.bg(cx.title_bar_background_color) @@ -551,7 +552,8 @@ fn render_markdown_table(parsed: &ParsedMarkdownTable, cx: &mut RenderContext) - } let empty_cell = div() - .border_1() + .when(col_idx > 0, |this| this.border_l_1()) + .when(row_idx > 0, |this| this.border_t_1()) .border_color(cx.border_color) .when(row_idx % 2 == 1, |this| this.bg(cx.panel_background_color)); @@ -568,8 +570,10 @@ fn render_markdown_table(parsed: &ParsedMarkdownTable, cx: &mut RenderContext) - div() .grid() .grid_cols(max_column_count as u16) - .border_1() + .border(px(1.5)) .border_color(cx.border_color) + .rounded_sm() + .overflow_hidden() .children(cells), ) .into_any() From 37e4f7e9b54e1cc830ec45d7fb4d019edf9f47cd Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 10:50:52 -0300 Subject: [PATCH 054/266] agent_ui: Remove custom "unavailable editing" tooltip (#44992) Now that we can use `Tooltip::element`, we don't need a separate file/component just for this. Release Notes: - N/A --- crates/agent_ui/src/acp/thread_view.rs | 26 ++++++++++++----- crates/agent_ui/src/ui.rs | 4 +-- .../src/ui/unavailable_editing_tooltip.rs | 29 ------------------- 3 files changed, 20 insertions(+), 39 deletions(-) delete mode 100644 crates/agent_ui/src/ui/unavailable_editing_tooltip.rs diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index f5e5b6c3b261d5c82bf8d3fc3fc13d482e69ca7d..aa02e22635c1585003fbfc540b50687ae0930ecd 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -63,10 +63,7 @@ use crate::acp::message_editor::{MessageEditor, MessageEditorEvent}; use crate::agent_diff::AgentDiff; use crate::profile_selector::{ProfileProvider, ProfileSelector}; -use crate::ui::{ - AgentNotification, AgentNotificationEvent, BurnModeTooltip, UnavailableEditingTooltip, - UsageCallout, -}; +use crate::ui::{AgentNotification, AgentNotificationEvent, BurnModeTooltip, UsageCallout}; use crate::{ AgentDiffPane, AgentPanel, AllowAlways, AllowOnce, ContinueThread, ContinueWithBurnMode, CycleModeSelector, ExpandMessageEditor, Follow, KeepAll, NewThread, OpenAgentDiff, OpenHistory, @@ -2091,10 +2088,23 @@ impl AcpThreadView { .icon_size(IconSize::Small) .icon_color(Color::Muted) .style(ButtonStyle::Transparent) - .tooltip(move |_window, cx| { - cx.new(|_| UnavailableEditingTooltip::new(agent_name.clone())) - .into() - }) + .tooltip(Tooltip::element({ + move |_, _| { + v_flex() + .gap_1() + .child(Label::new("Unavailable Editing")).child( + div().max_w_64().child( + Label::new(format!( + "Editing previous messages is not available for {} yet.", + agent_name.clone() + )) + .size(LabelSize::Small) + .color(Color::Muted), + ), + ) + .into_any_element() + } + })) ) ) } diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs index e604df416e2725a6f1b7bff8eed883a8cc36e184..6c3d8bc1427092b0d0380cf286da1706337932fe 100644 --- a/crates/agent_ui/src/ui.rs +++ b/crates/agent_ui/src/ui.rs @@ -5,7 +5,7 @@ mod claude_code_onboarding_modal; mod end_trial_upsell; mod hold_for_default; mod onboarding_modal; -mod unavailable_editing_tooltip; + mod usage_callout; pub use acp_onboarding_modal::*; @@ -15,5 +15,5 @@ pub use claude_code_onboarding_modal::*; pub use end_trial_upsell::*; pub use hold_for_default::*; pub use onboarding_modal::*; -pub use unavailable_editing_tooltip::*; + pub use usage_callout::*; diff --git a/crates/agent_ui/src/ui/unavailable_editing_tooltip.rs b/crates/agent_ui/src/ui/unavailable_editing_tooltip.rs deleted file mode 100644 index 2993fb89a989619ecfe3d79b06d82a2a6f71fc31..0000000000000000000000000000000000000000 --- a/crates/agent_ui/src/ui/unavailable_editing_tooltip.rs +++ /dev/null @@ -1,29 +0,0 @@ -use gpui::{Context, IntoElement, Render, Window}; -use ui::{prelude::*, tooltip_container}; - -pub struct UnavailableEditingTooltip { - agent_name: SharedString, -} - -impl UnavailableEditingTooltip { - pub fn new(agent_name: SharedString) -> Self { - Self { agent_name } - } -} - -impl Render for UnavailableEditingTooltip { - fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { - tooltip_container(cx, |this, _| { - this.child(Label::new("Unavailable Editing")).child( - div().max_w_64().child( - Label::new(format!( - "Editing previous messages is not available for {} yet.", - self.agent_name - )) - .size(LabelSize::Small) - .color(Color::Muted), - ), - ) - }) - } -} From 5f054e8d9c227e206e7dd3379c81911aa8e652c2 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 11:34:20 -0300 Subject: [PATCH 055/266] agent_ui: Create components for the model selector (#44993) This PR introduces a few components for the model selector pickers. Given we're still maintaining two flavors of it due to one of them being wired through ACP and the other through the language model registry, having one source of truth for the UI should help with maintenance moving forward, considering that despite the internal differences, they look and behave the same from the standpoint of the UI. Release Notes: - N/A --- crates/agent_ui/src/acp/model_selector.rs | 86 ++-------- .../agent_ui/src/language_model_selector.rs | 85 ++-------- crates/agent_ui/src/ui.rs | 4 +- .../src/ui/model_selector_components.rs | 147 ++++++++++++++++++ 4 files changed, 176 insertions(+), 146 deletions(-) create mode 100644 crates/agent_ui/src/ui/model_selector_components.rs diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs index 959e0e72f38feadb39da38b7bbc3eed58dcd775e..658b88e0c2a4f0b4203c5f1191c0a49cb4ad6fd5 100644 --- a/crates/agent_ui/src/acp/model_selector.rs +++ b/crates/agent_ui/src/acp/model_selector.rs @@ -12,14 +12,11 @@ use gpui::{ }; use ordered_float::OrderedFloat; use picker::{Picker, PickerDelegate}; -use ui::{ - DocumentationAside, DocumentationEdge, DocumentationSide, IntoElement, KeyBinding, ListItem, - ListItemSpacing, prelude::*, -}; +use ui::{DocumentationAside, DocumentationEdge, DocumentationSide, prelude::*}; use util::ResultExt; use zed_actions::agent::OpenSettings; -use crate::ui::HoldForDefault; +use crate::ui::{HoldForDefault, ModelSelectorFooter, ModelSelectorHeader, ModelSelectorListItem}; pub type AcpModelSelector = Picker; @@ -236,39 +233,19 @@ impl PickerDelegate for AcpModelPickerDelegate { fn render_match( &self, ix: usize, - selected: bool, + is_focused: bool, _: &mut Window, cx: &mut Context>, ) -> Option { match self.filtered_entries.get(ix)? { - AcpModelPickerEntry::Separator(title) => Some( - div() - .px_2() - .pb_1() - .when(ix > 1, |this| { - this.mt_1() - .pt_2() - .border_t_1() - .border_color(cx.theme().colors().border_variant) - }) - .child( - Label::new(title) - .size(LabelSize::XSmall) - .color(Color::Muted), - ) - .into_any_element(), - ), + AcpModelPickerEntry::Separator(title) => { + Some(ModelSelectorHeader::new(title, ix > 1).into_any_element()) + } AcpModelPickerEntry::Model(model_info) => { let is_selected = Some(model_info) == self.selected_model.as_ref(); let default_model = self.agent_server.default_model(cx); let is_default = default_model.as_ref() == Some(&model_info.id); - let model_icon_color = if is_selected { - Color::Accent - } else { - Color::Muted - }; - Some( div() .id(("model-picker-menu-child", ix)) @@ -284,30 +261,10 @@ impl PickerDelegate for AcpModelPickerDelegate { })) }) .child( - ListItem::new(ix) - .inset(true) - .spacing(ListItemSpacing::Sparse) - .toggle_state(selected) - .child( - h_flex() - .w_full() - .gap_1p5() - .when_some(model_info.icon, |this, icon| { - this.child( - Icon::new(icon) - .color(model_icon_color) - .size(IconSize::Small) - ) - }) - .child(Label::new(model_info.name.clone()).truncate()), - ) - .end_slot(div().pr_3().when(is_selected, |this| { - this.child( - Icon::new(IconName::Check) - .color(Color::Accent) - .size(IconSize::Small), - ) - })), + ModelSelectorListItem::new(ix, model_info.name.clone()) + .is_focused(is_focused) + .is_selected(is_selected) + .when_some(model_info.icon, |this, icon| this.icon(icon)), ) .into_any_element() ) @@ -343,7 +300,7 @@ impl PickerDelegate for AcpModelPickerDelegate { fn render_footer( &self, _window: &mut Window, - cx: &mut Context>, + _cx: &mut Context>, ) -> Option { let focus_handle = self.focus_handle.clone(); @@ -351,26 +308,7 @@ impl PickerDelegate for AcpModelPickerDelegate { return None; } - Some( - h_flex() - .w_full() - .p_1p5() - .border_t_1() - .border_color(cx.theme().colors().border_variant) - .child( - Button::new("configure", "Configure") - .full_width() - .style(ButtonStyle::Outlined) - .key_binding( - KeyBinding::for_action_in(&OpenSettings, &focus_handle, cx) - .map(|kb| kb.size(rems_from_px(12.))), - ) - .on_click(|_, window, cx| { - window.dispatch_action(OpenSettings.boxed_clone(), cx); - }), - ) - .into_any(), - ) + Some(ModelSelectorFooter::new(OpenSettings.boxed_clone(), focus_handle).into_any_element()) } } diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs index 5b5a4513c6dca32e985c966e07ad84e84fc9a872..7e1c35eba45bf9a79d42b59374c8cdb2aa0cac21 100644 --- a/crates/agent_ui/src/language_model_selector.rs +++ b/crates/agent_ui/src/language_model_selector.rs @@ -11,9 +11,11 @@ use language_model::{ }; use ordered_float::OrderedFloat; use picker::{Picker, PickerDelegate}; -use ui::{KeyBinding, ListItem, ListItemSpacing, prelude::*}; +use ui::prelude::*; use zed_actions::agent::OpenSettings; +use crate::ui::{ModelSelectorFooter, ModelSelectorHeader, ModelSelectorListItem}; + type OnModelChanged = Arc, &mut App) + 'static>; type GetActiveModel = Arc Option + 'static>; @@ -459,28 +461,14 @@ impl PickerDelegate for LanguageModelPickerDelegate { fn render_match( &self, ix: usize, - selected: bool, + is_focused: bool, _: &mut Window, cx: &mut Context>, ) -> Option { match self.filtered_entries.get(ix)? { - LanguageModelPickerEntry::Separator(title) => Some( - div() - .px_2() - .pb_1() - .when(ix > 1, |this| { - this.mt_1() - .pt_2() - .border_t_1() - .border_color(cx.theme().colors().border_variant) - }) - .child( - Label::new(title) - .size(LabelSize::XSmall) - .color(Color::Muted), - ) - .into_any_element(), - ), + LanguageModelPickerEntry::Separator(title) => { + Some(ModelSelectorHeader::new(title, ix > 1).into_any_element()) + } LanguageModelPickerEntry::Model(model_info) => { let active_model = (self.get_active_model)(cx); let active_provider_id = active_model.as_ref().map(|m| m.provider.id()); @@ -489,35 +477,11 @@ impl PickerDelegate for LanguageModelPickerDelegate { let is_selected = Some(model_info.model.provider_id()) == active_provider_id && Some(model_info.model.id()) == active_model_id; - let model_icon_color = if is_selected { - Color::Accent - } else { - Color::Muted - }; - Some( - ListItem::new(ix) - .inset(true) - .spacing(ListItemSpacing::Sparse) - .toggle_state(selected) - .child( - h_flex() - .w_full() - .gap_1p5() - .child( - Icon::new(model_info.icon) - .color(model_icon_color) - .size(IconSize::Small), - ) - .child(Label::new(model_info.model.name().0).truncate()), - ) - .end_slot(div().pr_3().when(is_selected, |this| { - this.child( - Icon::new(IconName::Check) - .color(Color::Accent) - .size(IconSize::Small), - ) - })) + ModelSelectorListItem::new(ix, model_info.model.name().0) + .is_focused(is_focused) + .is_selected(is_selected) + .icon(model_info.icon) .into_any_element(), ) } @@ -527,34 +491,15 @@ impl PickerDelegate for LanguageModelPickerDelegate { fn render_footer( &self, _window: &mut Window, - cx: &mut Context>, + _cx: &mut Context>, ) -> Option { - let focus_handle = self.focus_handle.clone(); - if !self.popover_styles { return None; } - Some( - h_flex() - .w_full() - .p_1p5() - .border_t_1() - .border_color(cx.theme().colors().border_variant) - .child( - Button::new("configure", "Configure") - .full_width() - .style(ButtonStyle::Outlined) - .key_binding( - KeyBinding::for_action_in(&OpenSettings, &focus_handle, cx) - .map(|kb| kb.size(rems_from_px(12.))), - ) - .on_click(|_, window, cx| { - window.dispatch_action(OpenSettings.boxed_clone(), cx); - }), - ) - .into_any(), - ) + let focus_handle = self.focus_handle.clone(); + + Some(ModelSelectorFooter::new(OpenSettings.boxed_clone(), focus_handle).into_any_element()) } } diff --git a/crates/agent_ui/src/ui.rs b/crates/agent_ui/src/ui.rs index 6c3d8bc1427092b0d0380cf286da1706337932fe..b484fdb6c6c480f1cffe78eea7a51f635d3906a1 100644 --- a/crates/agent_ui/src/ui.rs +++ b/crates/agent_ui/src/ui.rs @@ -4,8 +4,8 @@ mod burn_mode_tooltip; mod claude_code_onboarding_modal; mod end_trial_upsell; mod hold_for_default; +mod model_selector_components; mod onboarding_modal; - mod usage_callout; pub use acp_onboarding_modal::*; @@ -14,6 +14,6 @@ pub use burn_mode_tooltip::*; pub use claude_code_onboarding_modal::*; pub use end_trial_upsell::*; pub use hold_for_default::*; +pub use model_selector_components::*; pub use onboarding_modal::*; - pub use usage_callout::*; diff --git a/crates/agent_ui/src/ui/model_selector_components.rs b/crates/agent_ui/src/ui/model_selector_components.rs new file mode 100644 index 0000000000000000000000000000000000000000..3218daef7c9aadae5cd45b2fc65807d8a32254bd --- /dev/null +++ b/crates/agent_ui/src/ui/model_selector_components.rs @@ -0,0 +1,147 @@ +use gpui::{Action, FocusHandle, prelude::*}; +use ui::{KeyBinding, ListItem, ListItemSpacing, prelude::*}; + +#[derive(IntoElement)] +pub struct ModelSelectorHeader { + title: SharedString, + has_border: bool, +} + +impl ModelSelectorHeader { + pub fn new(title: impl Into, has_border: bool) -> Self { + Self { + title: title.into(), + has_border, + } + } +} + +impl RenderOnce for ModelSelectorHeader { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + div() + .px_2() + .pb_1() + .when(self.has_border, |this| { + this.mt_1() + .pt_2() + .border_t_1() + .border_color(cx.theme().colors().border_variant) + }) + .child( + Label::new(self.title) + .size(LabelSize::XSmall) + .color(Color::Muted), + ) + } +} + +#[derive(IntoElement)] +pub struct ModelSelectorListItem { + index: usize, + title: SharedString, + icon: Option, + is_selected: bool, + is_focused: bool, +} + +impl ModelSelectorListItem { + pub fn new(index: usize, title: impl Into) -> Self { + Self { + index, + title: title.into(), + icon: None, + is_selected: false, + is_focused: false, + } + } + + pub fn icon(mut self, icon: IconName) -> Self { + self.icon = Some(icon); + self + } + + pub fn is_selected(mut self, is_selected: bool) -> Self { + self.is_selected = is_selected; + self + } + + pub fn is_focused(mut self, is_focused: bool) -> Self { + self.is_focused = is_focused; + self + } +} + +impl RenderOnce for ModelSelectorListItem { + fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement { + let model_icon_color = if self.is_selected { + Color::Accent + } else { + Color::Muted + }; + + ListItem::new(self.index) + .inset(true) + .spacing(ListItemSpacing::Sparse) + .toggle_state(self.is_focused) + .child( + h_flex() + .w_full() + .gap_1p5() + .when_some(self.icon, |this, icon| { + this.child( + Icon::new(icon) + .color(model_icon_color) + .size(IconSize::Small), + ) + }) + .child(Label::new(self.title).truncate()), + ) + .end_slot(div().pr_2().when(self.is_selected, |this| { + this.child( + Icon::new(IconName::Check) + .color(Color::Accent) + .size(IconSize::Small), + ) + })) + } +} + +#[derive(IntoElement)] +pub struct ModelSelectorFooter { + action: Box, + focus_handle: FocusHandle, +} + +impl ModelSelectorFooter { + pub fn new(action: Box, focus_handle: FocusHandle) -> Self { + Self { + action, + focus_handle, + } + } +} + +impl RenderOnce for ModelSelectorFooter { + fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { + let action = self.action; + let focus_handle = self.focus_handle; + + h_flex() + .w_full() + .p_1p5() + .border_t_1() + .border_color(cx.theme().colors().border_variant) + .child( + Button::new("configure", "Configure") + .full_width() + .style(ButtonStyle::Outlined) + .key_binding( + KeyBinding::for_action_in(action.as_ref(), &focus_handle, cx) + .map(|kb| kb.size(rems_from_px(12.))), + ) + .on_click(move |_, window, cx| { + window.dispatch_action(action.boxed_clone(), cx); + }), + ) + } +} From 81519ae9233924007d37171db96f8bc99eeb00d2 Mon Sep 17 00:00:00 2001 From: Finn Evers Date: Tue, 16 Dec 2025 15:44:30 +0100 Subject: [PATCH 056/266] collab: Add `copilot` name alias to the `GET /contributor` endpoint (#44958) Although the copilot bot integration is referred to by `copilot-swe-agent[bot]` (https://api.github.com/users/copilot-swe-agent[bot]), GitHub parses the copilot identity as @\copilot in some cases, e.g. https://github.com/zed-industries/zed/pull/44915#issuecomment-3657567754. This causes the CLA check to still fail despite Copilot being added to the CLA endpoint (and https://api.github.com/users/copilot returning a 404 for that very name..). This PR fixes this by also considering the name alias of Copilot for the `contributor` endpoint. Release Notes: - N/A --- crates/collab/src/api/contributors.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/collab/src/api/contributors.rs b/crates/collab/src/api/contributors.rs index e09ac4f8b7355cf143b221308204742139308133..ce318b15295ebe5c777597a6d3c6106e57af8e05 100644 --- a/crates/collab/src/api/contributors.rs +++ b/crates/collab/src/api/contributors.rs @@ -111,6 +111,9 @@ struct CopilotSweAgentBot; impl CopilotSweAgentBot { const LOGIN: &'static str = "copilot-swe-agent[bot]"; const USER_ID: i32 = 198982749; + /// The alias of the GitHub copilot user. Although https://api.github.com/users/copilot + /// yields a 404, GitHub still refers to the copilot bot user as @Copilot in some cases. + const NAME_ALIAS: &'static str = "copilot"; /// Returns the `created_at` timestamp for the Dependabot bot user. fn created_at() -> &'static NaiveDateTime { @@ -125,7 +128,9 @@ impl CopilotSweAgentBot { /// Returns whether the given contributor selector corresponds to the Copilot bot user. fn is_copilot_bot(contributor: &ContributorSelector) -> bool { match contributor { - ContributorSelector::GitHubLogin { github_login } => github_login == Self::LOGIN, + ContributorSelector::GitHubLogin { github_login } => { + github_login == Self::LOGIN || github_login == Self::NAME_ALIAS + } ContributorSelector::GitHubUserId { github_user_id } => { github_user_id == &Self::USER_ID } From da0960bab680d8a626e91124edcd3667cabbe23d Mon Sep 17 00:00:00 2001 From: Nereuxofficial <37740907+Nereuxofficial@users.noreply.github.com> Date: Tue, 16 Dec 2025 15:51:33 +0100 Subject: [PATCH 057/266] languages: Correctly calculate ranges in `label_for_completion` (#44925) Closes #44825 Release Notes: - Fixed a case where an incorrect match could be generated in label_for_completion --------- Co-authored-by: Kirill Bulatov --- crates/language/src/language.rs | 5 +++- crates/languages/src/rust.rs | 48 ++++++++++++++++++++++++++++++--- 2 files changed, 49 insertions(+), 4 deletions(-) diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs index a17c93f11a8705bf477d2eceb4f7bec9315cf6d1..b0805c4ddd9d1203a1f1a3071e8640fd016c1fb1 100644 --- a/crates/language/src/language.rs +++ b/crates/language/src/language.rs @@ -2425,7 +2425,10 @@ impl CodeLabel { "invalid filter range" ); runs.iter().for_each(|(range, _)| { - assert!(text.get(range.clone()).is_some(), "invalid run range"); + assert!( + text.get(range.clone()).is_some(), + "invalid run range with inputs. Requested range {range:?} in text '{text}'", + ); }); Self { runs, diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs index ee64954196f58fe03f53a9e83fbbbea3f636449a..c10f76b079bf093e71b5444934196940e7b26d6c 100644 --- a/crates/languages/src/rust.rs +++ b/crates/languages/src/rust.rs @@ -375,16 +375,20 @@ impl LspAdapter for RustLspAdapter { let start_pos = range.start as usize; let end_pos = range.end as usize; - label.push_str(&snippet.text[text_pos..end_pos]); - text_pos = end_pos; + label.push_str(&snippet.text[text_pos..start_pos]); if start_pos == end_pos { let caret_start = label.len(); label.push('…'); runs.push((caret_start..label.len(), HighlightId::TABSTOP_INSERT_ID)); } else { - runs.push((start_pos..end_pos, HighlightId::TABSTOP_REPLACE_ID)); + let label_start = label.len(); + label.push_str(&snippet.text[start_pos..end_pos]); + let label_end = label.len(); + runs.push((label_start..label_end, HighlightId::TABSTOP_REPLACE_ID)); } + + text_pos = end_pos; } label.push_str(&snippet.text[text_pos..]); @@ -1592,6 +1596,44 @@ mod tests { ], )) ); + + // Test for correct range calculation with mixed empty and non-empty tabstops.(See https://github.com/zed-industries/zed/issues/44825) + let res = adapter + .label_for_completion( + &lsp::CompletionItem { + kind: Some(lsp::CompletionItemKind::STRUCT), + label: "Particles".to_string(), + insert_text_format: Some(lsp::InsertTextFormat::SNIPPET), + text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { + range: lsp::Range::default(), + new_text: "Particles { pos_x: $1, pos_y: $2, vel_x: $3, vel_y: $4, acc_x: ${5:()}, acc_y: ${6:()}, mass: $7 }$0".to_string(), + })), + ..Default::default() + }, + &language, + ) + .await + .unwrap(); + + assert_eq!( + res, + CodeLabel::new( + "Particles { pos_x: …, pos_y: …, vel_x: …, vel_y: …, acc_x: (), acc_y: (), mass: … }".to_string(), + 0..9, + vec![ + (19..22, HighlightId::TABSTOP_INSERT_ID), + (31..34, HighlightId::TABSTOP_INSERT_ID), + (43..46, HighlightId::TABSTOP_INSERT_ID), + (55..58, HighlightId::TABSTOP_INSERT_ID), + (67..69, HighlightId::TABSTOP_REPLACE_ID), + (78..80, HighlightId::TABSTOP_REPLACE_ID), + (88..91, HighlightId::TABSTOP_INSERT_ID), + (0..9, highlight_type), + (60..65, highlight_field), + (71..76, highlight_field), + ], + ) + ); } #[gpui::test] From 1104ac7f7c61a33d5a32161c19cecd5aefbad5e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yara=20=F0=9F=8F=B3=EF=B8=8F=E2=80=8D=E2=9A=A7=EF=B8=8F?= Date: Tue, 16 Dec 2025 16:07:33 +0100 Subject: [PATCH 058/266] Revert windows implementation of "Multiple priority scheduler (#44701)" (#44990) This reverts the windows part of commit 636d11ebec8e74f0f0c173e858597fb57ccfa0b9. Release Notes: - N/A --- crates/gpui/src/executor.rs | 10 ++ crates/gpui/src/gpui.rs | 4 +- .../gpui/src/platform/windows/dispatcher.rs | 91 ++++++++----------- crates/gpui/src/platform/windows/events.rs | 3 +- crates/gpui/src/platform/windows/platform.rs | 24 +++-- crates/gpui/src/platform/windows/window.rs | 4 +- 6 files changed, 65 insertions(+), 71 deletions(-) diff --git a/crates/gpui/src/executor.rs b/crates/gpui/src/executor.rs index a219a20e92819f7d510ff9e93bce493f7ca723c9..6c2ecb341ff2fe446efd7823c107fd32a557feb5 100644 --- a/crates/gpui/src/executor.rs +++ b/crates/gpui/src/executor.rs @@ -290,9 +290,19 @@ impl BackgroundExecutor { &self, future: AnyFuture, label: Option, + #[cfg_attr( + target_os = "windows", + expect( + unused_variables, + reason = "Multi priority scheduler is broken on windows" + ) + )] priority: Priority, ) -> Task { let dispatcher = self.dispatcher.clone(); + #[cfg(target_os = "windows")] + let priority = Priority::Medium; // multi-prio scheduler is broken on windows + let (runnable, task) = if let Priority::Realtime(realtime) = priority { let location = core::panic::Location::caller(); let (mut tx, rx) = flume::bounded::>(1); diff --git a/crates/gpui/src/gpui.rs b/crates/gpui/src/gpui.rs index e5c726f58e117b76e2dbb2976089d5788baa848e..76a61e286d3fe6c1acae8e4e628d4c9130f1305f 100644 --- a/crates/gpui/src/gpui.rs +++ b/crates/gpui/src/gpui.rs @@ -31,7 +31,7 @@ mod path_builder; mod platform; pub mod prelude; mod profiler; -#[cfg(any(target_os = "windows", target_os = "linux"))] +#[cfg(target_os = "linux")] mod queue; mod scene; mod shared_string; @@ -91,7 +91,7 @@ pub use keymap::*; pub use path_builder::*; pub use platform::*; pub use profiler::*; -#[cfg(any(target_os = "windows", target_os = "linux"))] +#[cfg(target_os = "linux")] pub(crate) use queue::{PriorityQueueReceiver, PriorityQueueSender}; pub use refineable::*; pub use scene::*; diff --git a/crates/gpui/src/platform/windows/dispatcher.rs b/crates/gpui/src/platform/windows/dispatcher.rs index 0720d414c9b44dec4a3bab5b50fd7dde47991989..14486ccee9843ef9c0792d62f22fa825f0db43ee 100644 --- a/crates/gpui/src/platform/windows/dispatcher.rs +++ b/crates/gpui/src/platform/windows/dispatcher.rs @@ -4,31 +4,24 @@ use std::{ time::{Duration, Instant}, }; -use anyhow::Context; +use flume::Sender; use util::ResultExt; use windows::{ - System::Threading::{ - ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler, WorkItemPriority, - }, + System::Threading::{ThreadPool, ThreadPoolTimer, TimerElapsedHandler, WorkItemHandler}, Win32::{ Foundation::{LPARAM, WPARAM}, - System::Threading::{ - GetCurrentThread, HIGH_PRIORITY_CLASS, SetPriorityClass, SetThreadPriority, - THREAD_PRIORITY_HIGHEST, THREAD_PRIORITY_TIME_CRITICAL, - }, UI::WindowsAndMessaging::PostMessageW, }, }; use crate::{ - GLOBAL_THREAD_TIMINGS, HWND, PlatformDispatcher, Priority, PriorityQueueSender, - RealtimePriority, RunnableVariant, SafeHwnd, THREAD_TIMINGS, TaskLabel, TaskTiming, - ThreadTaskTimings, WM_GPUI_TASK_DISPATCHED_ON_MAIN_THREAD, profiler, + GLOBAL_THREAD_TIMINGS, HWND, PlatformDispatcher, RunnableVariant, SafeHwnd, THREAD_TIMINGS, + TaskLabel, TaskTiming, ThreadTaskTimings, WM_GPUI_TASK_DISPATCHED_ON_MAIN_THREAD, }; pub(crate) struct WindowsDispatcher { pub(crate) wake_posted: AtomicBool, - main_sender: PriorityQueueSender, + main_sender: Sender, main_thread_id: ThreadId, pub(crate) platform_window_handle: SafeHwnd, validation_number: usize, @@ -36,7 +29,7 @@ pub(crate) struct WindowsDispatcher { impl WindowsDispatcher { pub(crate) fn new( - main_sender: PriorityQueueSender, + main_sender: Sender, platform_window_handle: HWND, validation_number: usize, ) -> Self { @@ -52,7 +45,7 @@ impl WindowsDispatcher { } } - fn dispatch_on_threadpool(&self, priority: WorkItemPriority, runnable: RunnableVariant) { + fn dispatch_on_threadpool(&self, runnable: RunnableVariant) { let handler = { let mut task_wrapper = Some(runnable); WorkItemHandler::new(move |_| { @@ -60,8 +53,7 @@ impl WindowsDispatcher { Ok(()) }) }; - - ThreadPool::RunWithPriorityAsync(&handler, priority).log_err(); + ThreadPool::RunAsync(&handler).log_err(); } fn dispatch_on_threadpool_after(&self, runnable: RunnableVariant, duration: Duration) { @@ -87,7 +79,7 @@ impl WindowsDispatcher { start, end: None, }; - profiler::add_task_timing(timing); + Self::add_task_timing(timing); runnable.run(); @@ -99,7 +91,7 @@ impl WindowsDispatcher { start, end: None, }; - profiler::add_task_timing(timing); + Self::add_task_timing(timing); runnable.run(); @@ -110,7 +102,23 @@ impl WindowsDispatcher { let end = Instant::now(); timing.end = Some(end); - profiler::add_task_timing(timing); + Self::add_task_timing(timing); + } + + pub(crate) fn add_task_timing(timing: TaskTiming) { + THREAD_TIMINGS.with(|timings| { + let mut timings = timings.lock(); + let timings = &mut timings.timings; + + if let Some(last_timing) = timings.iter_mut().rev().next() { + if last_timing.location == timing.location { + last_timing.end = timing.end; + return; + } + } + + timings.push_back(timing); + }); } } @@ -138,22 +146,20 @@ impl PlatformDispatcher for WindowsDispatcher { current().id() == self.main_thread_id } - fn dispatch(&self, runnable: RunnableVariant, label: Option, priority: Priority) { - let priority = match priority { - Priority::Realtime(_) => unreachable!(), - Priority::High => WorkItemPriority::High, - Priority::Medium => WorkItemPriority::Normal, - Priority::Low => WorkItemPriority::Low, - }; - self.dispatch_on_threadpool(priority, runnable); - + fn dispatch( + &self, + runnable: RunnableVariant, + label: Option, + _priority: gpui::Priority, + ) { + self.dispatch_on_threadpool(runnable); if let Some(label) = label { log::debug!("TaskLabel: {label:?}"); } } - fn dispatch_on_main_thread(&self, runnable: RunnableVariant, priority: Priority) { - match self.main_sender.send(priority, runnable) { + fn dispatch_on_main_thread(&self, runnable: RunnableVariant, _priority: gpui::Priority) { + match self.main_sender.send(runnable) { Ok(_) => { if !self.wake_posted.swap(true, Ordering::AcqRel) { unsafe { @@ -185,27 +191,8 @@ impl PlatformDispatcher for WindowsDispatcher { self.dispatch_on_threadpool_after(runnable, duration); } - fn spawn_realtime(&self, priority: RealtimePriority, f: Box) { - std::thread::spawn(move || { - // SAFETY: always safe to call - let thread_handle = unsafe { GetCurrentThread() }; - - let thread_priority = match priority { - RealtimePriority::Audio => THREAD_PRIORITY_TIME_CRITICAL, - RealtimePriority::Other => THREAD_PRIORITY_HIGHEST, - }; - - // SAFETY: thread_handle is a valid handle to a thread - unsafe { SetPriorityClass(thread_handle, HIGH_PRIORITY_CLASS) } - .context("thread priority class") - .log_err(); - - // SAFETY: thread_handle is a valid handle to a thread - unsafe { SetThreadPriority(thread_handle, thread_priority) } - .context("thread priority") - .log_err(); - - f(); - }); + fn spawn_realtime(&self, _priority: crate::RealtimePriority, _f: Box) { + // disabled on windows for now. + unimplemented!(); } } diff --git a/crates/gpui/src/platform/windows/events.rs b/crates/gpui/src/platform/windows/events.rs index f648f45cf4bf632ae07784de8bdc1503f88d6177..e6fa6006eb95ec45f1634cb72ef63e2f622455a7 100644 --- a/crates/gpui/src/platform/windows/events.rs +++ b/crates/gpui/src/platform/windows/events.rs @@ -243,8 +243,7 @@ impl WindowsWindowInner { fn handle_timer_msg(&self, handle: HWND, wparam: WPARAM) -> Option { if wparam.0 == SIZE_MOVE_LOOP_TIMER_ID { - let mut runnables = self.main_receiver.clone().try_iter(); - while let Some(Ok(runnable)) = runnables.next() { + for runnable in self.main_receiver.drain() { WindowsDispatcher::execute_runnable(runnable); } self.handle_paint_msg(handle) diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs index fa847bca6b404538a9f75b757bf53a2e4e2a1418..af0cb89ecc94da70cc42c8d4c397aeb2a811d6fb 100644 --- a/crates/gpui/src/platform/windows/platform.rs +++ b/crates/gpui/src/platform/windows/platform.rs @@ -51,7 +51,7 @@ struct WindowsPlatformInner { raw_window_handles: std::sync::Weak>>, // The below members will never change throughout the entire lifecycle of the app. validation_number: usize, - main_receiver: PriorityQueueReceiver, + main_receiver: flume::Receiver, dispatcher: Arc, } @@ -98,7 +98,7 @@ impl WindowsPlatform { OleInitialize(None).context("unable to initialize Windows OLE")?; } let directx_devices = DirectXDevices::new().context("Creating DirectX devices")?; - let (main_sender, main_receiver) = PriorityQueueReceiver::new(); + let (main_sender, main_receiver) = flume::unbounded::(); let validation_number = if usize::BITS == 64 { rand::random::() as usize } else { @@ -857,24 +857,22 @@ impl WindowsPlatformInner { } break 'tasks; } - let mut main_receiver = self.main_receiver.clone(); - match main_receiver.try_pop() { - Ok(Some(runnable)) => WindowsDispatcher::execute_runnable(runnable), - _ => break 'timeout_loop, + match self.main_receiver.try_recv() { + Err(_) => break 'timeout_loop, + Ok(runnable) => WindowsDispatcher::execute_runnable(runnable), } } // Someone could enqueue a Runnable here. The flag is still true, so they will not PostMessage. // We need to check for those Runnables after we clear the flag. self.dispatcher.wake_posted.store(false, Ordering::Release); - let mut main_receiver = self.main_receiver.clone(); - match main_receiver.try_pop() { - Ok(Some(runnable)) => { + match self.main_receiver.try_recv() { + Err(_) => break 'tasks, + Ok(runnable) => { self.dispatcher.wake_posted.store(true, Ordering::Release); WindowsDispatcher::execute_runnable(runnable); } - _ => break 'tasks, } } @@ -936,7 +934,7 @@ pub(crate) struct WindowCreationInfo { pub(crate) windows_version: WindowsVersion, pub(crate) drop_target_helper: IDropTargetHelper, pub(crate) validation_number: usize, - pub(crate) main_receiver: PriorityQueueReceiver, + pub(crate) main_receiver: flume::Receiver, pub(crate) platform_window_handle: HWND, pub(crate) disable_direct_composition: bool, pub(crate) directx_devices: DirectXDevices, @@ -949,8 +947,8 @@ struct PlatformWindowCreateContext { inner: Option>>, raw_window_handles: std::sync::Weak>>, validation_number: usize, - main_sender: Option>, - main_receiver: Option>, + main_sender: Option>, + main_receiver: Option>, directx_devices: Option, dispatcher: Option>, } diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs index 0cfa812b288406c5b4afcea37949eed3918f5c91..7ef92b4150e69424b68e9417dda377aa7f2e9cc0 100644 --- a/crates/gpui/src/platform/windows/window.rs +++ b/crates/gpui/src/platform/windows/window.rs @@ -81,7 +81,7 @@ pub(crate) struct WindowsWindowInner { pub(crate) executor: ForegroundExecutor, pub(crate) windows_version: WindowsVersion, pub(crate) validation_number: usize, - pub(crate) main_receiver: PriorityQueueReceiver, + pub(crate) main_receiver: flume::Receiver, pub(crate) platform_window_handle: HWND, } @@ -362,7 +362,7 @@ struct WindowCreateContext { windows_version: WindowsVersion, drop_target_helper: IDropTargetHelper, validation_number: usize, - main_receiver: PriorityQueueReceiver, + main_receiver: flume::Receiver, platform_window_handle: HWND, appearance: WindowAppearance, disable_direct_composition: bool, From 73b37e9774399780fb49901a4a2d0b025db4a2a8 Mon Sep 17 00:00:00 2001 From: Dave Waggoner Date: Tue, 16 Dec 2025 07:08:28 -0800 Subject: [PATCH 059/266] terminal: Improve scroll performance (#44714) Related to: - #44510 - #44407 Previously we were searching for hyperlinks on every scroll, even if Cmd was not held. With this PR, - We only search for hyperlinks on scroll if Cmd is held - We now clear `last_hovered_word` in all cases where Cmd is not held - Renamed `word_from_position` -> `schedule_find_hyperlink` - Simplified logic in `schedule_find_hyperlink` Performance measurements The test scrolls up and down 20,000x in a loop. However, since this PR is just removing a code path that was very dependent on the length of the line in terminal, it's not super meaningful as a comparison. The test uses a line length of "long line ".repeat(1000), and in main the performance is directly proportional to the line length, so for benchmarking it in main it only scrolls up and down 20x. I think all that is really useful to say is that currently scrolling is slow, and proportional to the line length, and with this PR it is buttery-smooth and unaffected by line length. I've included a few data points below anyway. At least the test can help catch future regressions. | Branch | Command | Scrolls | Iter/sec | Mean [ms] | SD [ms] | Iterations | Importance (weight) | |:---|:---|---:|---:|---:|---:|---:|---:| | main | tests::perf::scroll_long_line_benchmark | 40 | 16.85 | 712.00 | 2.80 | 12 | average (50) | | this PR | tests::perf::scroll_long_line_benchmark | 40 | 116.22 | 413.60 | 0.50 | 48 | average (50) | | this PR | tests::perf::scroll_long_line_benchmark | 40,000 | 9.19 | 1306.40 | 7.00 | 12 | average (50) | | only overhead | tests::perf::scroll_long_line_benchmark | 0 | 114.29 | 420.90 | 2.00 | 48 | average (50) | Release Notes: - terminal: Improved scroll performance --- crates/terminal/src/terminal.rs | 152 ++++++++++++++++++++++++++------ 1 file changed, 127 insertions(+), 25 deletions(-) diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs index 601fa75044a648e7c40e84b32aabda8096856119..c7ac75af0c810c55d470b1de8175c11c65855b58 100644 --- a/crates/terminal/src/terminal.rs +++ b/crates/terminal/src/terminal.rs @@ -892,6 +892,8 @@ impl TaskStatus { } } +const FIND_HYPERLINK_THROTTLE_PX: Pixels = px(5.0); + impl Terminal { fn process_event(&mut self, event: AlacTermEvent, cx: &mut Context) { match event { @@ -1718,38 +1720,40 @@ impl Terminal { { self.write_to_pty(bytes); } - } else if e.modifiers.secondary() { - self.word_from_position(e.position); + } else { + self.schedule_find_hyperlink(e.modifiers, e.position); } cx.notify(); } - fn word_from_position(&mut self, position: Point) { - if self.selection_phase == SelectionPhase::Selecting { + fn schedule_find_hyperlink(&mut self, modifiers: Modifiers, position: Point) { + if self.selection_phase == SelectionPhase::Selecting + || !modifiers.secondary() + || !self.last_content.terminal_bounds.bounds.contains(&position) + { self.last_content.last_hovered_word = None; - } else if self.last_content.terminal_bounds.bounds.contains(&position) { - // Throttle hyperlink searches to avoid excessive processing - let now = Instant::now(); - let should_search = if let Some(last_pos) = self.last_hyperlink_search_position { + return; + } + + // Throttle hyperlink searches to avoid excessive processing + let now = Instant::now(); + if self + .last_hyperlink_search_position + .map_or(true, |last_pos| { // Only search if mouse moved significantly or enough time passed - let distance_moved = - ((position.x - last_pos.x).abs() + (position.y - last_pos.y).abs()) > px(5.0); + let distance_moved = ((position.x - last_pos.x).abs() + + (position.y - last_pos.y).abs()) + > FIND_HYPERLINK_THROTTLE_PX; let time_elapsed = now.duration_since(self.last_mouse_move_time).as_millis() > 100; distance_moved || time_elapsed - } else { - true - }; - - if should_search { - self.last_mouse_move_time = now; - self.last_hyperlink_search_position = Some(position); - self.events.push_back(InternalEvent::FindHyperlink( - position - self.last_content.terminal_bounds.bounds.origin, - false, - )); - } - } else { - self.last_content.last_hovered_word = None; + }) + { + self.last_mouse_move_time = now; + self.last_hyperlink_search_position = Some(position); + self.events.push_back(InternalEvent::FindHyperlink( + position - self.last_content.terminal_bounds.bounds.origin, + false, + )); } } @@ -1941,7 +1945,7 @@ impl Terminal { } fn refresh_hovered_word(&mut self, window: &Window) { - self.word_from_position(window.mouse_position()); + self.schedule_find_hyperlink(window.modifiers(), window.mouse_position()); } fn determine_scroll_lines( @@ -2858,4 +2862,102 @@ mod tests { text ); } + + mod perf { + use super::super::*; + use gpui::{ + Entity, Point, ScrollDelta, ScrollWheelEvent, TestAppContext, VisualContext, + VisualTestContext, point, + }; + use util::default; + use util_macros::perf; + + async fn init_scroll_perf_test( + cx: &mut TestAppContext, + ) -> (Entity, &mut VisualTestContext) { + cx.update(|cx| { + let settings_store = settings::SettingsStore::test(cx); + cx.set_global(settings_store); + }); + + cx.executor().allow_parking(); + + let window = cx.add_empty_window(); + let builder = window + .update(|window, cx| { + let settings = TerminalSettings::get_global(cx); + let test_path_hyperlink_timeout_ms = 100; + TerminalBuilder::new( + None, + None, + task::Shell::System, + HashMap::default(), + CursorShape::default(), + AlternateScroll::On, + None, + settings.path_hyperlink_regexes.clone(), + test_path_hyperlink_timeout_ms, + false, + window.window_handle().window_id().as_u64(), + None, + cx, + vec![], + ) + }) + .await + .unwrap(); + let terminal = window.new(|cx| builder.subscribe(cx)); + + terminal.update(window, |term, cx| { + term.write_output("long line ".repeat(1000).as_bytes(), cx); + }); + + (terminal, window) + } + + #[perf] + #[gpui::test] + async fn scroll_long_line_benchmark(cx: &mut TestAppContext) { + let (terminal, window) = init_scroll_perf_test(cx).await; + let wobble = point(FIND_HYPERLINK_THROTTLE_PX, px(0.0)); + let mut scroll_by = |lines: i32| { + window.update_window_entity(&terminal, |terminal, window, cx| { + let bounds = terminal.last_content.terminal_bounds.bounds; + let center = bounds.origin + bounds.center(); + let position = center + wobble * lines as f32; + + terminal.mouse_move( + &MouseMoveEvent { + position, + ..default() + }, + cx, + ); + + terminal.scroll_wheel( + &ScrollWheelEvent { + position, + delta: ScrollDelta::Lines(Point::new(0.0, lines as f32)), + ..default() + }, + 1.0, + ); + + assert!( + terminal + .events + .iter() + .any(|event| matches!(event, InternalEvent::Scroll(_))), + "Should have Scroll event when scrolling within terminal bounds" + ); + terminal.sync(window, cx); + }); + }; + + for _ in 0..20000 { + scroll_by(1); + scroll_by(-1); + } + } + } } From 7ba6f39e8284cb7b3522f137b0d724ad59740ddd Mon Sep 17 00:00:00 2001 From: Andre Roelofs Date: Tue, 16 Dec 2025 16:36:45 +0100 Subject: [PATCH 060/266] Fix macros on x11 sometimes resulting in incorrect input (#44234) Closes #40678 The python file below simulates the macros at various timings and can be run by running: 1. `sudo python3 -m pip install evdev --break-system-packages` 2. `sudo python3 zed_shift_brace_replayer.py` Checked timings for hold=0.1, =0.01 and =0.001 with the latter two no longer causing incorrect inputs. [zed_shift_brace_replayer.py](https://github.com/user-attachments/files/23560570/zed_shift_brace_replayer.py) Release Notes: - linux: fixed a race condition where the macros containing modifier + key would sometimes be processed without the modifier --- crates/gpui/src/platform/linux/x11/client.rs | 29 +++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs index 60400dada57775a295fdb36c7f1ddd9dd8b83a67..5e9089b09809a7ec1b8b257427b0a670adc0f123 100644 --- a/crates/gpui/src/platform/linux/x11/client.rs +++ b/crates/gpui/src/platform/linux/x11/client.rs @@ -29,7 +29,7 @@ use x11rb::{ protocol::xkb::ConnectionExt as _, protocol::xproto::{ AtomEnum, ChangeWindowAttributesAux, ClientMessageData, ClientMessageEvent, - ConnectionExt as _, EventMask, Visibility, + ConnectionExt as _, EventMask, ModMask, Visibility, }, protocol::{Event, randr, render, xinput, xkb, xproto}, resource_manager::Database, @@ -1018,6 +1018,12 @@ impl X11Client { let modifiers = modifiers_from_state(event.state); state.modifiers = modifiers; state.pre_key_char_down.take(); + + // Macros containing modifiers might result in + // the modifiers missing from the event. + // We therefore update the mask from the global state. + update_xkb_mask_from_event_state(&mut state.xkb, event.state); + let keystroke = { let code = event.detail.into(); let mut keystroke = crate::Keystroke::from_xkb(&state.xkb, modifiers, code); @@ -1083,6 +1089,11 @@ impl X11Client { let modifiers = modifiers_from_state(event.state); state.modifiers = modifiers; + // Macros containing modifiers might result in + // the modifiers missing from the event. + // We therefore update the mask from the global state. + update_xkb_mask_from_event_state(&mut state.xkb, event.state); + let keystroke = { let code = event.detail.into(); let keystroke = crate::Keystroke::from_xkb(&state.xkb, modifiers, code); @@ -2516,3 +2527,19 @@ fn get_dpi_factor((width_px, height_px): (u32, u32), (width_mm, height_mm): (u64 fn valid_scale_factor(scale_factor: f32) -> bool { scale_factor.is_sign_positive() && scale_factor.is_normal() } + +#[inline] +fn update_xkb_mask_from_event_state(xkb: &mut xkbc::State, event_state: xproto::KeyButMask) { + let depressed_mods = event_state.remove((ModMask::LOCK | ModMask::M2).bits()); + let latched_mods = xkb.serialize_mods(xkbc::STATE_MODS_LATCHED); + let locked_mods = xkb.serialize_mods(xkbc::STATE_MODS_LOCKED); + let locked_layout = xkb.serialize_layout(xkbc::STATE_LAYOUT_LOCKED); + xkb.update_mask( + depressed_mods.into(), + latched_mods, + locked_mods, + 0, + 0, + locked_layout, + ); +} From 4573a59777a905204c50e8f746bf9319febce9b1 Mon Sep 17 00:00:00 2001 From: Xiaobo Liu Date: Tue, 16 Dec 2025 23:37:03 +0800 Subject: [PATCH 061/266] git_ui: Fix double slash in commit URLs (#44996) Release Notes: - Fixed double slash in commit URLs The github_url variable was generating URLs with an extra slash like "https://github.com//user/repo/commit/xxxx" due to manual string formatting of the base_url() result. Fixed by replacing manual URL construction with the proper build_commit_permalink() method that uses Url::join() for correct path handling, consistent with how other Git hosting providers construct URLs. Signed-off-by: Xiaobo Liu --- crates/git_ui/src/commit_view.rs | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/crates/git_ui/src/commit_view.rs b/crates/git_ui/src/commit_view.rs index 8cb9d82826086371950d2c51fd06381dd013251f..0f5420fec4169f8e3d945dd8bd0987ebbaba8d19 100644 --- a/crates/git_ui/src/commit_view.rs +++ b/crates/git_ui/src/commit_view.rs @@ -3,7 +3,10 @@ use buffer_diff::{BufferDiff, BufferDiffSnapshot}; use editor::display_map::{BlockPlacement, BlockProperties, BlockStyle}; use editor::{Editor, EditorEvent, ExcerptRange, MultiBuffer, multibuffer_context_lines}; use git::repository::{CommitDetails, CommitDiff, RepoPath}; -use git::{GitHostingProviderRegistry, GitRemote, parse_git_remote_url}; +use git::{ + BuildCommitPermalinkParams, GitHostingProviderRegistry, GitRemote, ParsedGitRemote, + parse_git_remote_url, +}; use gpui::{ AnyElement, App, AppContext as _, AsyncApp, AsyncWindowContext, Context, Element, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement, ParentElement, @@ -393,13 +396,15 @@ impl CommitView { let remote_info = self.remote.as_ref().map(|remote| { let provider = remote.host.name(); - let url = format!( - "{}/{}/{}/commit/{}", - remote.host.base_url(), - remote.owner, - remote.repo, - commit.sha - ); + let parsed_remote = ParsedGitRemote { + owner: remote.owner.as_ref().into(), + repo: remote.repo.as_ref().into(), + }; + let params = BuildCommitPermalinkParams { sha: &commit.sha }; + let url = remote + .host + .build_commit_permalink(&parsed_remote, params) + .to_string(); (provider, url) }); From 935a7cc310db486b1e08483f24f26e7935e53679 Mon Sep 17 00:00:00 2001 From: Nihal Kumar <121309701+nihalxkumar@users.noreply.github.com> Date: Tue, 16 Dec 2025 21:16:14 +0530 Subject: [PATCH 062/266] terminal: Add ctrl+click link detection with mouse movement (#42526) Closes #41994 This PR introduces Element-bounded drag tolerance for Ctrl/Cmd+click in terminal. Previously, Ctrl/Cmd+click on terminal links required pixel-perfect accuracy. Any mouse movement during the click would cancel the navigation, making it frustrating to click on links, especially on high-DPI displays or with sensitive mice. Users can now click anywhere within a clickable element (file path, URL, hyperlink), drag the cursor anywhere within that same element's boundaries and release to trigger navigation Implementation: - Stores detected element metadata (`text` and `grid_range`) on Ctrl/Cmd+mouse-down - Tracks cursor position during drag, preserving click state while within element bounds - Verifies element match on mouse-up before triggering navigation - Uses existing `find_from_grid_point()` for element detection Before: [before.webm](https://github.com/user-attachments/assets/ee80de66-998e-4d8e-94d0-f5e65eb06d22) After: [after.webm](https://github.com/user-attachments/assets/7c9ddd9e-cfc1-4c79-b62c-78e9d909e6f4) Release Notes: - terminal: Fixed an issue where `ctrl|cmd+click` on links was very sensitive to mouse movement. Clicking links now tolerates mouse movement within the same clickable element, making link navigation more reliable --------- Co-authored-by: Ben Kunkle --- crates/terminal/src/terminal.rs | 287 +++++++++++++++++++++++++++----- 1 file changed, 249 insertions(+), 38 deletions(-) diff --git a/crates/terminal/src/terminal.rs b/crates/terminal/src/terminal.rs index c7ac75af0c810c55d470b1de8175c11c65855b58..e64780e2945363e71b357b79aee57024484d417c 100644 --- a/crates/terminal/src/terminal.rs +++ b/crates/terminal/src/terminal.rs @@ -155,8 +155,8 @@ enum InternalEvent { ScrollToAlacPoint(AlacPoint), SetSelection(Option<(Selection, AlacPoint)>), UpdateSelection(Point), - // Adjusted mouse position, should open FindHyperlink(Point, bool), + ProcessHyperlink((String, bool, Match), bool), // Whether keep selection when copy Copy(Option), // Vi mode events @@ -380,6 +380,7 @@ impl TerminalBuilder { is_remote_terminal: false, last_mouse_move_time: Instant::now(), last_hyperlink_search_position: None, + mouse_down_hyperlink: None, #[cfg(windows)] shell_program: None, activation_script: Vec::new(), @@ -610,6 +611,7 @@ impl TerminalBuilder { is_remote_terminal, last_mouse_move_time: Instant::now(), last_hyperlink_search_position: None, + mouse_down_hyperlink: None, #[cfg(windows)] shell_program, activation_script: activation_script.clone(), @@ -840,6 +842,7 @@ pub struct Terminal { is_remote_terminal: bool, last_mouse_move_time: Instant, last_hyperlink_search_position: Option>, + mouse_down_hyperlink: Option<(String, bool, Match)>, #[cfg(windows)] shell_program: Option, template: CopyTemplate, @@ -1152,7 +1155,6 @@ impl Terminal { } InternalEvent::FindHyperlink(position, open) => { trace!("Finding hyperlink at position: position={position:?}, open={open:?}"); - let prev_hovered_word = self.last_content.last_hovered_word.take(); let point = grid_point( *position, @@ -1166,47 +1168,53 @@ impl Terminal { point, &mut self.hyperlink_regex_searches, ) { - Some((maybe_url_or_path, is_url, url_match)) => { - let target = if is_url { - // Treat "file://" URLs like file paths to ensure - // that line numbers at the end of the path are - // handled correctly. - // file://{path} should be urldecoded, returning a urldecoded {path} - if let Some(path) = maybe_url_or_path.strip_prefix("file://") { - let decoded_path = urlencoding::decode(path) - .map(|decoded| decoded.into_owned()) - .unwrap_or(path.to_owned()); - - MaybeNavigationTarget::PathLike(PathLikeTarget { - maybe_path: decoded_path, - terminal_dir: self.working_directory(), - }) - } else { - MaybeNavigationTarget::Url(maybe_url_or_path.clone()) - } - } else { - MaybeNavigationTarget::PathLike(PathLikeTarget { - maybe_path: maybe_url_or_path.clone(), - terminal_dir: self.working_directory(), - }) - }; - if *open { - cx.emit(Event::Open(target)); - } else { - self.update_selected_word( - prev_hovered_word, - url_match, - maybe_url_or_path, - target, - cx, - ); - } + Some(hyperlink) => { + self.process_hyperlink(hyperlink, *open, cx); } None => { cx.emit(Event::NewNavigationTarget(None)); } } } + InternalEvent::ProcessHyperlink(hyperlink, open) => { + self.process_hyperlink(hyperlink.clone(), *open, cx); + } + } + } + + fn process_hyperlink( + &mut self, + hyperlink: (String, bool, Match), + open: bool, + cx: &mut Context, + ) { + let (maybe_url_or_path, is_url, url_match) = hyperlink; + let prev_hovered_word = self.last_content.last_hovered_word.take(); + + let target = if is_url { + if let Some(path) = maybe_url_or_path.strip_prefix("file://") { + let decoded_path = urlencoding::decode(path) + .map(|decoded| decoded.into_owned()) + .unwrap_or(path.to_owned()); + + MaybeNavigationTarget::PathLike(PathLikeTarget { + maybe_path: decoded_path, + terminal_dir: self.working_directory(), + }) + } else { + MaybeNavigationTarget::Url(maybe_url_or_path.clone()) + } + } else { + MaybeNavigationTarget::PathLike(PathLikeTarget { + maybe_path: maybe_url_or_path.clone(), + terminal_dir: self.working_directory(), + }) + }; + + if open { + cx.emit(Event::Open(target)); + } else { + self.update_selected_word(prev_hovered_word, url_match, maybe_url_or_path, target, cx); } } @@ -1777,6 +1785,20 @@ impl Terminal { ) { let position = e.position - self.last_content.terminal_bounds.bounds.origin; if !self.mouse_mode(e.modifiers.shift) { + if let Some((.., hyperlink_range)) = &self.mouse_down_hyperlink { + let point = grid_point( + position, + self.last_content.terminal_bounds, + self.last_content.display_offset, + ); + + if !hyperlink_range.contains(&point) { + self.mouse_down_hyperlink = None; + } else { + return; + } + } + self.selection_phase = SelectionPhase::Selecting; // Alacritty has the same ordering, of first updating the selection // then scrolling 15ms later @@ -1823,6 +1845,23 @@ impl Terminal { self.last_content.display_offset, ); + if e.button == MouseButton::Left + && e.modifiers.secondary() + && !self.mouse_mode(e.modifiers.shift) + { + let term_lock = self.term.lock(); + self.mouse_down_hyperlink = terminal_hyperlinks::find_from_grid_point( + &term_lock, + point, + &mut self.hyperlink_regex_searches, + ); + drop(term_lock); + + if self.mouse_down_hyperlink.is_some() { + return; + } + } + if self.mouse_mode(e.modifiers.shift) { if let Some(bytes) = mouse_button_report(point, e.button, e.modifiers, true, self.last_content.mode) @@ -1893,6 +1932,31 @@ impl Terminal { self.copy(Some(true)); } + if let Some(mouse_down_hyperlink) = self.mouse_down_hyperlink.take() { + let point = grid_point( + position, + self.last_content.terminal_bounds, + self.last_content.display_offset, + ); + + if let Some(mouse_up_hyperlink) = { + let term_lock = self.term.lock(); + terminal_hyperlinks::find_from_grid_point( + &term_lock, + point, + &mut self.hyperlink_regex_searches, + ) + } { + if mouse_down_hyperlink == mouse_up_hyperlink { + self.events + .push_back(InternalEvent::ProcessHyperlink(mouse_up_hyperlink, true)); + self.selection_phase = SelectionPhase::Ended; + self.last_mouse = None; + return; + } + } + } + //Hyperlinks if self.selection_phase == SelectionPhase::Ended { let mouse_cell_index = @@ -2409,10 +2473,91 @@ mod tests { term::cell::Cell, }; use collections::HashMap; - use gpui::{Pixels, Point, TestAppContext, bounds, point, size, smol_timeout}; + use gpui::{ + Entity, Modifiers, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, + Point, TestAppContext, bounds, point, size, smol_timeout, + }; use rand::{Rng, distr, rngs::ThreadRng}; use task::ShellBuilder; + fn init_ctrl_click_hyperlink_test(cx: &mut TestAppContext, output: &[u8]) -> Entity { + cx.update(|cx| { + let settings_store = settings::SettingsStore::test(cx); + cx.set_global(settings_store); + }); + + let terminal = cx.new(|cx| { + TerminalBuilder::new_display_only(CursorShape::default(), AlternateScroll::On, None, 0) + .unwrap() + .subscribe(cx) + }); + + terminal.update(cx, |terminal, cx| { + terminal.write_output(output, cx); + }); + + cx.run_until_parked(); + + terminal.update(cx, |terminal, _cx| { + let term_lock = terminal.term.lock(); + terminal.last_content = Terminal::make_content(&term_lock, &terminal.last_content); + drop(term_lock); + + let terminal_bounds = TerminalBounds::new( + px(20.0), + px(10.0), + bounds(point(px(0.0), px(0.0)), size(px(400.0), px(400.0))), + ); + terminal.last_content.terminal_bounds = terminal_bounds; + terminal.events.clear(); + }); + + terminal + } + + fn ctrl_mouse_down_at( + terminal: &mut Terminal, + position: Point, + cx: &mut Context, + ) { + let mouse_down = MouseDownEvent { + button: MouseButton::Left, + position, + modifiers: Modifiers::secondary_key(), + click_count: 1, + first_mouse: true, + }; + terminal.mouse_down(&mouse_down, cx); + } + + fn ctrl_mouse_move_to( + terminal: &mut Terminal, + position: Point, + cx: &mut Context, + ) { + let terminal_bounds = terminal.last_content.terminal_bounds.bounds; + let drag_event = MouseMoveEvent { + position, + pressed_button: Some(MouseButton::Left), + modifiers: Modifiers::secondary_key(), + }; + terminal.mouse_drag(&drag_event, terminal_bounds, cx); + } + + fn ctrl_mouse_up_at( + terminal: &mut Terminal, + position: Point, + cx: &mut Context, + ) { + let mouse_up = MouseUpEvent { + button: MouseButton::Left, + position, + modifiers: Modifiers::secondary_key(), + click_count: 1, + }; + terminal.mouse_up(&mouse_up, cx); + } + #[gpui::test] async fn test_basic_terminal(cx: &mut TestAppContext) { cx.executor().allow_parking(); @@ -2863,6 +3008,72 @@ mod tests { ); } + #[gpui::test] + async fn test_hyperlink_ctrl_click_same_position(cx: &mut TestAppContext) { + let terminal = init_ctrl_click_hyperlink_test(cx, b"Visit https://zed.dev/ for more\r\n"); + + terminal.update(cx, |terminal, cx| { + let click_position = point(px(80.0), px(10.0)); + ctrl_mouse_down_at(terminal, click_position, cx); + ctrl_mouse_up_at(terminal, click_position, cx); + + assert!( + terminal + .events + .iter() + .any(|event| matches!(event, InternalEvent::ProcessHyperlink(_, true))), + "Should have ProcessHyperlink event when ctrl+clicking on same hyperlink position" + ); + }); + } + + #[gpui::test] + async fn test_hyperlink_ctrl_click_drag_outside_bounds(cx: &mut TestAppContext) { + let terminal = init_ctrl_click_hyperlink_test( + cx, + b"Visit https://zed.dev/ for more\r\nThis is another line\r\n", + ); + + terminal.update(cx, |terminal, cx| { + let down_position = point(px(80.0), px(10.0)); + let up_position = point(px(10.0), px(50.0)); + + ctrl_mouse_down_at(terminal, down_position, cx); + ctrl_mouse_move_to(terminal, up_position, cx); + ctrl_mouse_up_at(terminal, up_position, cx); + + assert!( + !terminal + .events + .iter() + .any(|event| matches!(event, InternalEvent::ProcessHyperlink(_, _))), + "Should NOT have ProcessHyperlink event when dragging outside the hyperlink" + ); + }); + } + + #[gpui::test] + async fn test_hyperlink_ctrl_click_drag_within_bounds(cx: &mut TestAppContext) { + let terminal = init_ctrl_click_hyperlink_test(cx, b"Visit https://zed.dev/ for more\r\n"); + + terminal.update(cx, |terminal, cx| { + let down_position = point(px(70.0), px(10.0)); + let up_position = point(px(130.0), px(10.0)); + + ctrl_mouse_down_at(terminal, down_position, cx); + ctrl_mouse_move_to(terminal, up_position, cx); + ctrl_mouse_up_at(terminal, up_position, cx); + + assert!( + terminal + .events + .iter() + .any(|event| matches!(event, InternalEvent::ProcessHyperlink(_, true))), + "Should have ProcessHyperlink event when dragging within hyperlink bounds" + ); + }); + } + mod perf { use super::super::*; use gpui::{ From 005a85e57b14aed31e7a55dca9efe2b28f158d36 Mon Sep 17 00:00:00 2001 From: Dan Greco Date: Tue, 16 Dec 2025 10:48:14 -0500 Subject: [PATCH 063/266] Add project settings schema to schema_generator CLI (#44321) Release Notes: - Added project settings schema to the schema_generator CLI. This allows for exporting the project settings schema as JSON for use in other tools. --- Cargo.lock | 1 + crates/schema_generator/Cargo.toml | 1 + crates/schema_generator/src/main.rs | 6 ++++++ 3 files changed, 8 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index 5b35991dfde30b4b976ae96a552862876a245486..b9a9dee415d76123cf3c9c86686f94e704b5a4db 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -14249,6 +14249,7 @@ dependencies = [ "schemars", "serde", "serde_json", + "settings", "theme", ] diff --git a/crates/schema_generator/Cargo.toml b/crates/schema_generator/Cargo.toml index 865f76f4af917606af5d61d173950493fdde07c7..b92298a3b41d62b861c19a1f22ceaee0d63828b5 100644 --- a/crates/schema_generator/Cargo.toml +++ b/crates/schema_generator/Cargo.toml @@ -15,4 +15,5 @@ env_logger.workspace = true schemars = { workspace = true, features = ["indexmap2"] } serde.workspace = true serde_json.workspace = true +settings.workspace = true theme.workspace = true diff --git a/crates/schema_generator/src/main.rs b/crates/schema_generator/src/main.rs index a7e406a1a9c0426ac8294c05bd475931c3e62fb4..a77060c54d1361dc96204238a282f8e75946a37b 100644 --- a/crates/schema_generator/src/main.rs +++ b/crates/schema_generator/src/main.rs @@ -1,6 +1,7 @@ use anyhow::Result; use clap::{Parser, ValueEnum}; use schemars::schema_for; +use settings::ProjectSettingsContent; use theme::{IconThemeFamilyContent, ThemeFamilyContent}; #[derive(Parser, Debug)] @@ -14,6 +15,7 @@ pub struct Args { pub enum SchemaType { Theme, IconTheme, + Project, } fn main() -> Result<()> { @@ -30,6 +32,10 @@ fn main() -> Result<()> { let schema = schema_for!(IconThemeFamilyContent); println!("{}", serde_json::to_string_pretty(&schema)?); } + SchemaType::Project => { + let schema = schema_for!(ProjectSettingsContent); + println!("{}", serde_json::to_string_pretty(&schema)?); + } } Ok(()) From 914b0117fb5a23469af85e567d5723eca6b53635 Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Tue, 16 Dec 2025 16:59:26 +0100 Subject: [PATCH 064/266] Optimize editor rendering when clipped by parent containers (#44995) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #44997 ## Summary Optimizes editor rendering when an editor is partially clipped by a parent container (e.g., a `List`). The editor now only lays out and renders lines that are actually visible within the viewport, rather than all lines in the document. ## Problem When an `AutoHeight` editor with thousands of lines is placed inside a scrollable `List` (such as in the Agent Panel thread view), the editor would lay out **all** lines during prepaint, even though only a small portion was visible. Profiling showed that ~50% of frame time was spent in `EditorElement::prepaint` → `LineWithInvisibles::from_chunks`, processing thousands of invisible lines. ## Solution Calculate the intersection of the editor's bounds with the current content mask (which represents the visible viewport after all parent clipping). Use this to determine: 1. `clipped_top_in_lines` - how many lines are clipped above the viewport 2. `visible_height_in_lines` - how many lines are actually visible Then adjust `start_row` and `end_row` to only include visible lines. The parent container handles positioning, so `scroll_position` remains unchanged for paint calculations. ## Example For a 3000-line editor where only 50 lines are visible: - **Before**: Lay out and render 3000 lines - **After**: Lay out and render ~50 lines ## Testing Verified the following scenarios work correctly: - Editor fully visible (no clipping) - Editor clipped from top - Editor clipped from bottom - Editor completely outside viewport (renders nothing) - Fractional line clipping at boundaries - Scrollable editors with internal scroll state inside a clipped container Release Notes: - Improved agent panel performance when rendering large diffs. --- crates/editor/src/element.rs | 17 +++++++++++++++-- crates/editor/src/test.rs | 8 +++----- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 8de660275ba9b455aec610568c41347888654495..95047569c31c2e306b0f984832b568f052e4179a 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -9164,6 +9164,15 @@ impl Element for EditorElement { let height_in_lines = f64::from(bounds.size.height / line_height); let max_row = snapshot.max_point().row().as_f64(); + // Calculate how much of the editor is clipped by parent containers (e.g., List). + // This allows us to only render lines that are actually visible, which is + // critical for performance when large AutoHeight editors are inside Lists. + let visible_bounds = window.content_mask().bounds; + let clipped_top = (visible_bounds.origin.y - bounds.origin.y).max(px(0.)); + let clipped_top_in_lines = f64::from(clipped_top / line_height); + let visible_height_in_lines = + f64::from(visible_bounds.size.height / line_height); + // The max scroll position for the top of the window let max_scroll_top = if matches!( snapshot.mode, @@ -9220,10 +9229,14 @@ impl Element for EditorElement { let mut scroll_position = snapshot.scroll_position(); // The scroll position is a fractional point, the whole number of which represents // the top of the window in terms of display rows. - let start_row = DisplayRow(scroll_position.y as u32); + // We add clipped_top_in_lines to skip rows that are clipped by parent containers, + // but we don't modify scroll_position itself since the parent handles positioning. + let start_row = + DisplayRow((scroll_position.y + clipped_top_in_lines).floor() as u32); let max_row = snapshot.max_point().row(); let end_row = cmp::min( - (scroll_position.y + height_in_lines).ceil() as u32, + (scroll_position.y + clipped_top_in_lines + visible_height_in_lines).ceil() + as u32, max_row.next_row().0, ); let end_row = DisplayRow(end_row); diff --git a/crates/editor/src/test.rs b/crates/editor/src/test.rs index 5a0652bdd199a638f92234b1d50232071db18e07..1cc619385446502db6a3a0dceb6e70fa4b4e8416 100644 --- a/crates/editor/src/test.rs +++ b/crates/editor/src/test.rs @@ -176,11 +176,9 @@ pub fn block_content_for_tests( } pub fn editor_content_with_blocks(editor: &Entity, cx: &mut VisualTestContext) -> String { - cx.draw( - gpui::Point::default(), - size(px(3000.0), px(3000.0)), - |_, _| editor.clone(), - ); + let draw_size = size(px(3000.0), px(3000.0)); + cx.simulate_resize(draw_size); + cx.draw(gpui::Point::default(), draw_size, |_, _| editor.clone()); let (snapshot, mut lines, blocks) = editor.update_in(cx, |editor, window, cx| { let snapshot = editor.snapshot(window, cx); let text = editor.display_text(cx); From 8b9fa1581c038abf64bd2a4d39f1a1f367c07595 Mon Sep 17 00:00:00 2001 From: Lena <241371603+zelenenka@users.noreply.github.com> Date: Tue, 16 Dec 2025 17:01:28 +0100 Subject: [PATCH 065/266] Update contribution ideas and guidelines (#45001) Release Notes: - N/A --- CONTRIBUTING.md | 37 +++++++++++++++++++++++-------------- 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 9cbac4af2b57f0350fa9f5665e110e0d6e7f6341..f7aceadce18788ae2b8bb9d0fe4b5f16225e70d2 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -15,15 +15,17 @@ with the community to improve the product in ways we haven't thought of (or had In particular we love PRs that are: -- Fixes to existing bugs and issues. -- Small enhancements to existing features, particularly to make them work for more people. +- Fixing or extending the docs. +- Fixing bugs. +- Small enhancements to existing features to make them work for more people (making things work on more platforms/modes/whatever). - Small extra features, like keybindings or actions you miss from other editors or extensions. -- Work towards shipping larger features on our roadmap. +- Part of a Community Program like [Let's Git Together](https://github.com/zed-industries/zed/issues/41541). If you're looking for concrete ideas: -- Our [top-ranking issues](https://github.com/zed-industries/zed/issues/5393) based on votes by the community. -- Our [public roadmap](https://zed.dev/roadmap) contains a rough outline of our near-term priorities for Zed. +- [Curated board of issues](https://github.com/orgs/zed-industries/projects/69) suitable for everyone from first-time contributors to seasoned community champions. +- [Triaged bugs with confirmed steps to reproduce](https://github.com/zed-industries/zed/issues?q=is%3Aissue%20state%3Aopen%20type%3ABug%20label%3Astate%3Areproducible). +- [Area labels](https://github.com/zed-industries/zed/labels?q=area%3A*) to browse bugs in a specific part of the product you care about (after clicking on an area label, add type:Bug to the search). ## Sending changes @@ -37,9 +39,17 @@ like, sorry). Although we will take a look, we tend to only merge about half the PRs that are submitted. If you'd like your PR to have the best chance of being merged: -- Include a clear description of what you're solving, and why it's important to you. -- Include tests. -- If it changes the UI, attach screenshots or screen recordings. +- Make sure the change is **desired**: we're always happy to accept bugfixes, + but features should be confirmed with us first if you aim to avoid wasted + effort. If there isn't already a GitHub issue for your feature with staff + confirmation that we want it, start with a GitHub discussion rather than a PR. +- Include a clear description of **what you're solving**, and why it's important. +- Include **tests**. +- If it changes the UI, attach **screenshots** or screen recordings. +- Make the PR about **one thing only**, e.g. if it's a bugfix, don't add two + features and a refactoring on top of that. +- Keep AI assistance under your judgement and responsibility: it's unlikely + we'll merge a vibe-coded PR that the author doesn't understand. The internal advice for reviewers is as follows: @@ -50,10 +60,9 @@ The internal advice for reviewers is as follows: If you need more feedback from us: the best way is to be responsive to Github comments, or to offer up time to pair with us. -If you are making a larger change, or need advice on how to finish the change -you're making, please open the PR early. We would love to help you get -things right, and it's often easier to see how to solve a problem before the -diff gets too big. +If you need help deciding how to fix a bug, or finish implementing a feature +that we've agreed we want, please open a PR early so we can discuss how to make +the change with code in hand. ## Things we will (probably) not merge @@ -61,11 +70,11 @@ Although there are few hard and fast rules, typically we don't merge: - Anything that can be provided by an extension. For example a new language, or theme. For adding themes or support for a new language to Zed, check out our [docs on developing extensions](https://zed.dev/docs/extensions/developing-extensions). - New file icons. Zed's default icon theme consists of icons that are hand-designed to fit together in a cohesive manner, please don't submit PRs with off-the-shelf SVGs. +- Features where (in our subjective opinion) the extra complexity isn't worth it for the number of people who will benefit. - Giant refactorings. - Non-trivial changes with no tests. - Stylistic code changes that do not alter any app logic. Reducing allocations, removing `.unwrap()`s, fixing typos is great; making code "more readable" — maybe not so much. -- Features where (in our subjective opinion) the extra complexity isn't worth it for the number of people who will benefit. -- Anything that seems completely AI generated. +- Anything that seems AI-generated without understanding the output. ## Bird's-eye view of Zed From 420254cff1498bc141f89edca345b3603d535984 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Tue, 16 Dec 2025 09:18:51 -0700 Subject: [PATCH 066/266] Re-add save_file and restore_file_from_disk agent tools (#45005) This re-introduces the `save_file` and `restore_file_from_disk` agent tools that were reverted in #44949. I pushed that original PR without trying it just to get the build off my machine, but I had missed a step: the tools weren't added to the default profile settings in `default.json`, so they were never enabled even though the code was present. ## Changes - Add `save_file` and `restore_file_from_disk` to the "write" profile in `default.json` - Add `Thread::has_tool()` method to check tool availability at runtime - Make `edit_file_tool`'s dirty buffer error message conditional on whether `save_file`/`restore_file_from_disk` tools are available (so the agent gets appropriate guidance based on what tools it actually has) - Update test to match new conditional error message behavior Release Notes: - Added `save_file` and `restore_file_from_disk` agent tools to handle dirty buffers when editing files --- assets/settings/default.json | 2 + crates/agent/src/thread.rs | 11 +- crates/agent/src/tools.rs | 8 +- crates/agent/src/tools/edit_file_tool.rs | 47 ++- .../src/tools/restore_file_from_disk_tool.rs | 352 ++++++++++++++++++ crates/agent/src/tools/save_file_tool.rs | 351 +++++++++++++++++ 6 files changed, 760 insertions(+), 11 deletions(-) create mode 100644 crates/agent/src/tools/restore_file_from_disk_tool.rs create mode 100644 crates/agent/src/tools/save_file_tool.rs diff --git a/assets/settings/default.json b/assets/settings/default.json index 146915dd1a242e2a8b70ba1010bb5fbe09dbbbbc..0ef3bb70c71bb96828bc1b1c2594376b15bada90 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -972,6 +972,8 @@ "now": true, "find_path": true, "read_file": true, + "restore_file_from_disk": true, + "save_file": true, "open": true, "grep": true, "terminal": true, diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index dbf29c68766cfe28d0bce1d82ed53536446326e2..bed3db853a3106ca4df9676d799b4a2bfa0106a0 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -2,7 +2,8 @@ use crate::{ ContextServerRegistry, CopyPathTool, CreateDirectoryTool, DbLanguageModel, DbThread, DeletePathTool, DiagnosticsTool, EditFileTool, FetchTool, FindPathTool, GrepTool, ListDirectoryTool, MovePathTool, NowTool, OpenTool, ProjectSnapshot, ReadFileTool, - SystemPromptTemplate, Template, Templates, TerminalTool, ThinkingTool, WebSearchTool, + RestoreFileFromDiskTool, SaveFileTool, SystemPromptTemplate, Template, Templates, TerminalTool, + ThinkingTool, WebSearchTool, }; use acp_thread::{MentionUri, UserMessageId}; use action_log::ActionLog; @@ -1002,6 +1003,8 @@ impl Thread { self.project.clone(), self.action_log.clone(), )); + self.add_tool(SaveFileTool::new(self.project.clone())); + self.add_tool(RestoreFileFromDiskTool::new(self.project.clone())); self.add_tool(TerminalTool::new(self.project.clone(), environment)); self.add_tool(ThinkingTool); self.add_tool(WebSearchTool); @@ -1966,6 +1969,12 @@ impl Thread { self.running_turn.as_ref()?.tools.get(name).cloned() } + pub fn has_tool(&self, name: &str) -> bool { + self.running_turn + .as_ref() + .is_some_and(|turn| turn.tools.contains_key(name)) + } + fn build_request_messages( &self, available_tools: Vec, diff --git a/crates/agent/src/tools.rs b/crates/agent/src/tools.rs index 62a52998a705e11d1c9e69cbade7f427cc9cfc32..358903a32baa5ead9b073642015e6829501307a2 100644 --- a/crates/agent/src/tools.rs +++ b/crates/agent/src/tools.rs @@ -4,7 +4,6 @@ mod create_directory_tool; mod delete_path_tool; mod diagnostics_tool; mod edit_file_tool; - mod fetch_tool; mod find_path_tool; mod grep_tool; @@ -13,6 +12,8 @@ mod move_path_tool; mod now_tool; mod open_tool; mod read_file_tool; +mod restore_file_from_disk_tool; +mod save_file_tool; mod terminal_tool; mod thinking_tool; @@ -27,7 +28,6 @@ pub use create_directory_tool::*; pub use delete_path_tool::*; pub use diagnostics_tool::*; pub use edit_file_tool::*; - pub use fetch_tool::*; pub use find_path_tool::*; pub use grep_tool::*; @@ -36,6 +36,8 @@ pub use move_path_tool::*; pub use now_tool::*; pub use open_tool::*; pub use read_file_tool::*; +pub use restore_file_from_disk_tool::*; +pub use save_file_tool::*; pub use terminal_tool::*; pub use thinking_tool::*; @@ -92,6 +94,8 @@ tools! { NowTool, OpenTool, ReadFileTool, + RestoreFileFromDiskTool, + SaveFileTool, TerminalTool, ThinkingTool, WebSearchTool, diff --git a/crates/agent/src/tools/edit_file_tool.rs b/crates/agent/src/tools/edit_file_tool.rs index 0ab99426e2e9645adf3f837d21c28dc285ab6ea2..3acb7f5951f3ca4b682dcabc62a0d54c35ab08d6 100644 --- a/crates/agent/src/tools/edit_file_tool.rs +++ b/crates/agent/src/tools/edit_file_tool.rs @@ -306,20 +306,39 @@ impl AgentTool for EditFileTool { // Check if the file has been modified since the agent last read it if let Some(abs_path) = abs_path.as_ref() { - let (last_read_mtime, current_mtime, is_dirty) = self.thread.update(cx, |thread, cx| { + let (last_read_mtime, current_mtime, is_dirty, has_save_tool, has_restore_tool) = self.thread.update(cx, |thread, cx| { let last_read = thread.file_read_times.get(abs_path).copied(); let current = buffer.read(cx).file().and_then(|file| file.disk_state().mtime()); let dirty = buffer.read(cx).is_dirty(); - (last_read, current, dirty) + let has_save = thread.has_tool("save_file"); + let has_restore = thread.has_tool("restore_file_from_disk"); + (last_read, current, dirty, has_save, has_restore) })?; // Check for unsaved changes first - these indicate modifications we don't know about if is_dirty { - anyhow::bail!( - "This file cannot be written to because it has unsaved changes. \ - Please end the current conversation immediately by telling the user you want to write to this file (mention its path explicitly) but you can't write to it because it has unsaved changes. \ - Ask the user to save that buffer's changes and to inform you when it's ok to proceed." - ); + let message = match (has_save_tool, has_restore_tool) { + (true, true) => { + "This file has unsaved changes. Ask the user whether they want to keep or discard those changes. \ + If they want to keep them, ask for confirmation then use the save_file tool to save the file, then retry this edit. \ + If they want to discard them, ask for confirmation then use the restore_file_from_disk tool to restore the on-disk contents, then retry this edit." + } + (true, false) => { + "This file has unsaved changes. Ask the user whether they want to keep or discard those changes. \ + If they want to keep them, ask for confirmation then use the save_file tool to save the file, then retry this edit. \ + If they want to discard them, ask the user to manually revert the file, then inform you when it's ok to proceed." + } + (false, true) => { + "This file has unsaved changes. Ask the user whether they want to keep or discard those changes. \ + If they want to keep them, ask the user to manually save the file, then inform you when it's ok to proceed. \ + If they want to discard them, ask for confirmation then use the restore_file_from_disk tool to restore the on-disk contents, then retry this edit." + } + (false, false) => { + "This file has unsaved changes. Ask the user whether they want to keep or discard those changes, \ + then ask them to save or revert the file manually and inform you when it's ok to proceed." + } + }; + anyhow::bail!("{}", message); } // Check if the file was modified on disk since we last read it @@ -2202,9 +2221,21 @@ mod tests { assert!(result.is_err(), "Edit should fail when buffer is dirty"); let error_msg = result.unwrap_err().to_string(); assert!( - error_msg.contains("cannot be written to because it has unsaved changes"), + error_msg.contains("This file has unsaved changes."), "Error should mention unsaved changes, got: {}", error_msg ); + assert!( + error_msg.contains("keep or discard"), + "Error should ask whether to keep or discard changes, got: {}", + error_msg + ); + // Since save_file and restore_file_from_disk tools aren't added to the thread, + // the error message should ask the user to manually save or revert + assert!( + error_msg.contains("save or revert the file manually"), + "Error should ask user to manually save or revert when tools aren't available, got: {}", + error_msg + ); } } diff --git a/crates/agent/src/tools/restore_file_from_disk_tool.rs b/crates/agent/src/tools/restore_file_from_disk_tool.rs new file mode 100644 index 0000000000000000000000000000000000000000..f5723f6ee3ee46144152dd3ed2939ab2cfaca9c0 --- /dev/null +++ b/crates/agent/src/tools/restore_file_from_disk_tool.rs @@ -0,0 +1,352 @@ +use agent_client_protocol as acp; +use anyhow::Result; +use collections::FxHashSet; +use gpui::{App, Entity, SharedString, Task}; +use language::Buffer; +use project::Project; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use std::sync::Arc; + +use crate::{AgentTool, ToolCallEventStream}; + +/// Discards unsaved changes in open buffers by reloading file contents from disk. +/// +/// Use this tool when: +/// - You attempted to edit files but they have unsaved changes the user does not want to keep. +/// - You want to reset files to the on-disk state before retrying an edit. +/// +/// Only use this tool after asking the user for permission, because it will discard unsaved changes. +#[derive(Debug, Serialize, Deserialize, JsonSchema)] +pub struct RestoreFileFromDiskToolInput { + /// The paths of the files to restore from disk. + pub paths: Vec, +} + +pub struct RestoreFileFromDiskTool { + project: Entity, +} + +impl RestoreFileFromDiskTool { + pub fn new(project: Entity) -> Self { + Self { project } + } +} + +impl AgentTool for RestoreFileFromDiskTool { + type Input = RestoreFileFromDiskToolInput; + type Output = String; + + fn name() -> &'static str { + "restore_file_from_disk" + } + + fn kind() -> acp::ToolKind { + acp::ToolKind::Other + } + + fn initial_title( + &self, + input: Result, + _cx: &mut App, + ) -> SharedString { + match input { + Ok(input) if input.paths.len() == 1 => "Restore file from disk".into(), + Ok(input) => format!("Restore {} files from disk", input.paths.len()).into(), + Err(_) => "Restore files from disk".into(), + } + } + + fn run( + self: Arc, + input: Self::Input, + _event_stream: ToolCallEventStream, + cx: &mut App, + ) -> Task> { + let project = self.project.clone(); + let input_paths = input.paths; + + cx.spawn(async move |cx| { + let mut buffers_to_reload: FxHashSet> = FxHashSet::default(); + + let mut restored_paths: Vec = Vec::new(); + let mut clean_paths: Vec = Vec::new(); + let mut not_found_paths: Vec = Vec::new(); + let mut open_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut dirty_check_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut reload_errors: Vec = Vec::new(); + + for path in input_paths { + let project_path = + project.read_with(cx, |project, cx| project.find_project_path(&path, cx)); + + let project_path = match project_path { + Ok(Some(project_path)) => project_path, + Ok(None) => { + not_found_paths.push(path); + continue; + } + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let open_buffer_task = + project.update(cx, |project, cx| project.open_buffer(project_path, cx)); + + let buffer = match open_buffer_task { + Ok(task) => match task.await { + Ok(buffer) => buffer, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let is_dirty = match buffer.read_with(cx, |buffer, _| buffer.is_dirty()) { + Ok(is_dirty) => is_dirty, + Err(error) => { + dirty_check_errors.push((path, error.to_string())); + continue; + } + }; + + if is_dirty { + buffers_to_reload.insert(buffer); + restored_paths.push(path); + } else { + clean_paths.push(path); + } + } + + if !buffers_to_reload.is_empty() { + let reload_task = project.update(cx, |project, cx| { + project.reload_buffers(buffers_to_reload, true, cx) + }); + + match reload_task { + Ok(task) => { + if let Err(error) = task.await { + reload_errors.push(error.to_string()); + } + } + Err(error) => { + reload_errors.push(error.to_string()); + } + } + } + + let mut lines: Vec = Vec::new(); + + if !restored_paths.is_empty() { + lines.push(format!("Restored {} file(s).", restored_paths.len())); + } + if !clean_paths.is_empty() { + lines.push(format!("{} clean.", clean_paths.len())); + } + + if !not_found_paths.is_empty() { + lines.push(format!("Not found ({}):", not_found_paths.len())); + for path in ¬_found_paths { + lines.push(format!("- {}", path.display())); + } + } + if !open_errors.is_empty() { + lines.push(format!("Open failed ({}):", open_errors.len())); + for (path, error) in &open_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !dirty_check_errors.is_empty() { + lines.push(format!( + "Dirty check failed ({}):", + dirty_check_errors.len() + )); + for (path, error) in &dirty_check_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !reload_errors.is_empty() { + lines.push(format!("Reload failed ({}):", reload_errors.len())); + for error in &reload_errors { + lines.push(format!("- {}", error)); + } + } + + if lines.is_empty() { + Ok("No paths provided.".to_string()) + } else { + Ok(lines.join("\n")) + } + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use fs::Fs; + use gpui::TestAppContext; + use language::LineEnding; + use project::FakeFs; + use serde_json::json; + use settings::SettingsStore; + use util::path; + + fn init_test(cx: &mut TestAppContext) { + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + }); + } + + #[gpui::test] + async fn test_restore_file_from_disk_output_and_effects(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + "/root", + json!({ + "dirty.txt": "on disk: dirty\n", + "clean.txt": "on disk: clean\n", + }), + ) + .await; + + let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await; + let tool = Arc::new(RestoreFileFromDiskTool::new(project.clone())); + + // Make dirty.txt dirty in-memory by saving different content into the buffer without saving to disk. + let dirty_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/dirty.txt", cx) + .expect("dirty.txt should exist in project") + }); + + let dirty_buffer = project + .update(cx, |project, cx| { + project.open_buffer(dirty_project_path, cx) + }) + .await + .unwrap(); + dirty_buffer.update(cx, |buffer, cx| { + buffer.edit([(0..buffer.len(), "in memory: dirty\n")], None, cx); + }); + assert!( + dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should be dirty before restore" + ); + + // Ensure clean.txt is opened but remains clean. + let clean_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/clean.txt", cx) + .expect("clean.txt should exist in project") + }); + + let clean_buffer = project + .update(cx, |project, cx| { + project.open_buffer(clean_project_path, cx) + }) + .await + .unwrap(); + assert!( + !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "clean.txt buffer should start clean" + ); + + let output = cx + .update(|cx| { + tool.clone().run( + RestoreFileFromDiskToolInput { + paths: vec![ + PathBuf::from("root/dirty.txt"), + PathBuf::from("root/clean.txt"), + ], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + + // Output should mention restored + clean. + assert!( + output.contains("Restored 1 file(s)."), + "expected restored count line, got:\n{output}" + ); + assert!( + output.contains("1 clean."), + "expected clean count line, got:\n{output}" + ); + + // Effect: dirty buffer should be restored back to disk content and become clean. + let dirty_text = dirty_buffer.read_with(cx, |buffer, _| buffer.text()); + assert_eq!( + dirty_text, "on disk: dirty\n", + "dirty.txt buffer should be restored to disk contents" + ); + assert!( + !dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should not be dirty after restore" + ); + + // Disk contents should be unchanged (restore-from-disk should not write). + let disk_dirty = fs.load(path!("/root/dirty.txt").as_ref()).await.unwrap(); + assert_eq!(disk_dirty, "on disk: dirty\n"); + + // Sanity: clean buffer should remain clean and unchanged. + let clean_text = clean_buffer.read_with(cx, |buffer, _| buffer.text()); + assert_eq!(clean_text, "on disk: clean\n"); + assert!( + !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "clean.txt buffer should remain clean" + ); + + // Test empty paths case. + let output = cx + .update(|cx| { + tool.clone().run( + RestoreFileFromDiskToolInput { paths: vec![] }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert_eq!(output, "No paths provided."); + + // Test not-found path case (path outside the project root). + let output = cx + .update(|cx| { + tool.clone().run( + RestoreFileFromDiskToolInput { + paths: vec![PathBuf::from("nonexistent/path.txt")], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert!( + output.contains("Not found (1):"), + "expected not-found header line, got:\n{output}" + ); + assert!( + output.contains("- nonexistent/path.txt"), + "expected not-found path bullet, got:\n{output}" + ); + + let _ = LineEnding::Unix; // keep import used if the buffer edit API changes + } +} diff --git a/crates/agent/src/tools/save_file_tool.rs b/crates/agent/src/tools/save_file_tool.rs new file mode 100644 index 0000000000000000000000000000000000000000..429352200109c52303c9f6f94a28a49136af1a61 --- /dev/null +++ b/crates/agent/src/tools/save_file_tool.rs @@ -0,0 +1,351 @@ +use agent_client_protocol as acp; +use anyhow::Result; +use collections::FxHashSet; +use gpui::{App, Entity, SharedString, Task}; +use language::Buffer; +use project::Project; +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use std::sync::Arc; + +use crate::{AgentTool, ToolCallEventStream}; + +/// Saves files that have unsaved changes. +/// +/// Use this tool when you need to edit files but they have unsaved changes that must be saved first. +/// Only use this tool after asking the user for permission to save their unsaved changes. +#[derive(Debug, Serialize, Deserialize, JsonSchema)] +pub struct SaveFileToolInput { + /// The paths of the files to save. + pub paths: Vec, +} + +pub struct SaveFileTool { + project: Entity, +} + +impl SaveFileTool { + pub fn new(project: Entity) -> Self { + Self { project } + } +} + +impl AgentTool for SaveFileTool { + type Input = SaveFileToolInput; + type Output = String; + + fn name() -> &'static str { + "save_file" + } + + fn kind() -> acp::ToolKind { + acp::ToolKind::Other + } + + fn initial_title( + &self, + input: Result, + _cx: &mut App, + ) -> SharedString { + match input { + Ok(input) if input.paths.len() == 1 => "Save file".into(), + Ok(input) => format!("Save {} files", input.paths.len()).into(), + Err(_) => "Save files".into(), + } + } + + fn run( + self: Arc, + input: Self::Input, + _event_stream: ToolCallEventStream, + cx: &mut App, + ) -> Task> { + let project = self.project.clone(); + let input_paths = input.paths; + + cx.spawn(async move |cx| { + let mut buffers_to_save: FxHashSet> = FxHashSet::default(); + + let mut saved_paths: Vec = Vec::new(); + let mut clean_paths: Vec = Vec::new(); + let mut not_found_paths: Vec = Vec::new(); + let mut open_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut dirty_check_errors: Vec<(PathBuf, String)> = Vec::new(); + let mut save_errors: Vec<(String, String)> = Vec::new(); + + for path in input_paths { + let project_path = + project.read_with(cx, |project, cx| project.find_project_path(&path, cx)); + + let project_path = match project_path { + Ok(Some(project_path)) => project_path, + Ok(None) => { + not_found_paths.push(path); + continue; + } + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let open_buffer_task = + project.update(cx, |project, cx| project.open_buffer(project_path, cx)); + + let buffer = match open_buffer_task { + Ok(task) => match task.await { + Ok(buffer) => buffer, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }, + Err(error) => { + open_errors.push((path, error.to_string())); + continue; + } + }; + + let is_dirty = match buffer.read_with(cx, |buffer, _| buffer.is_dirty()) { + Ok(is_dirty) => is_dirty, + Err(error) => { + dirty_check_errors.push((path, error.to_string())); + continue; + } + }; + + if is_dirty { + buffers_to_save.insert(buffer); + saved_paths.push(path); + } else { + clean_paths.push(path); + } + } + + // Save each buffer individually since there's no batch save API. + for buffer in buffers_to_save { + let path_for_buffer = match buffer.read_with(cx, |buffer, _| { + buffer + .file() + .map(|file| file.path().to_rel_path_buf()) + .map(|path| path.as_rel_path().as_unix_str().to_owned()) + }) { + Ok(path) => path.unwrap_or_else(|| "".to_string()), + Err(error) => { + save_errors.push(("".to_string(), error.to_string())); + continue; + } + }; + + let save_task = project.update(cx, |project, cx| project.save_buffer(buffer, cx)); + + match save_task { + Ok(task) => { + if let Err(error) = task.await { + save_errors.push((path_for_buffer, error.to_string())); + } + } + Err(error) => { + save_errors.push((path_for_buffer, error.to_string())); + } + } + } + + let mut lines: Vec = Vec::new(); + + if !saved_paths.is_empty() { + lines.push(format!("Saved {} file(s).", saved_paths.len())); + } + if !clean_paths.is_empty() { + lines.push(format!("{} clean.", clean_paths.len())); + } + + if !not_found_paths.is_empty() { + lines.push(format!("Not found ({}):", not_found_paths.len())); + for path in ¬_found_paths { + lines.push(format!("- {}", path.display())); + } + } + if !open_errors.is_empty() { + lines.push(format!("Open failed ({}):", open_errors.len())); + for (path, error) in &open_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !dirty_check_errors.is_empty() { + lines.push(format!( + "Dirty check failed ({}):", + dirty_check_errors.len() + )); + for (path, error) in &dirty_check_errors { + lines.push(format!("- {}: {}", path.display(), error)); + } + } + if !save_errors.is_empty() { + lines.push(format!("Save failed ({}):", save_errors.len())); + for (path, error) in &save_errors { + lines.push(format!("- {}: {}", path, error)); + } + } + + if lines.is_empty() { + Ok("No paths provided.".to_string()) + } else { + Ok(lines.join("\n")) + } + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use fs::Fs; + use gpui::TestAppContext; + use project::FakeFs; + use serde_json::json; + use settings::SettingsStore; + use util::path; + + fn init_test(cx: &mut TestAppContext) { + cx.update(|cx| { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + }); + } + + #[gpui::test] + async fn test_save_file_output_and_effects(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + "/root", + json!({ + "dirty.txt": "on disk: dirty\n", + "clean.txt": "on disk: clean\n", + }), + ) + .await; + + let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await; + let tool = Arc::new(SaveFileTool::new(project.clone())); + + // Make dirty.txt dirty in-memory. + let dirty_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/dirty.txt", cx) + .expect("dirty.txt should exist in project") + }); + + let dirty_buffer = project + .update(cx, |project, cx| { + project.open_buffer(dirty_project_path, cx) + }) + .await + .unwrap(); + dirty_buffer.update(cx, |buffer, cx| { + buffer.edit([(0..buffer.len(), "in memory: dirty\n")], None, cx); + }); + assert!( + dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should be dirty before save" + ); + + // Ensure clean.txt is opened but remains clean. + let clean_project_path = project.read_with(cx, |project, cx| { + project + .find_project_path("root/clean.txt", cx) + .expect("clean.txt should exist in project") + }); + + let clean_buffer = project + .update(cx, |project, cx| { + project.open_buffer(clean_project_path, cx) + }) + .await + .unwrap(); + assert!( + !clean_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "clean.txt buffer should start clean" + ); + + let output = cx + .update(|cx| { + tool.clone().run( + SaveFileToolInput { + paths: vec![ + PathBuf::from("root/dirty.txt"), + PathBuf::from("root/clean.txt"), + ], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + + // Output should mention saved + clean. + assert!( + output.contains("Saved 1 file(s)."), + "expected saved count line, got:\n{output}" + ); + assert!( + output.contains("1 clean."), + "expected clean count line, got:\n{output}" + ); + + // Effect: dirty buffer should now be clean and disk should have new content. + assert!( + !dirty_buffer.read_with(cx, |buffer, _| buffer.is_dirty()), + "dirty.txt buffer should not be dirty after save" + ); + + let disk_dirty = fs.load(path!("/root/dirty.txt").as_ref()).await.unwrap(); + assert_eq!( + disk_dirty, "in memory: dirty\n", + "dirty.txt disk content should be updated" + ); + + // Sanity: clean buffer should remain clean and disk unchanged. + let disk_clean = fs.load(path!("/root/clean.txt").as_ref()).await.unwrap(); + assert_eq!(disk_clean, "on disk: clean\n"); + + // Test empty paths case. + let output = cx + .update(|cx| { + tool.clone().run( + SaveFileToolInput { paths: vec![] }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert_eq!(output, "No paths provided."); + + // Test not-found path case. + let output = cx + .update(|cx| { + tool.clone().run( + SaveFileToolInput { + paths: vec![PathBuf::from("nonexistent/path.txt")], + }, + ToolCallEventStream::test().0, + cx, + ) + }) + .await + .unwrap(); + assert!( + output.contains("Not found (1):"), + "expected not-found header line, got:\n{output}" + ); + assert!( + output.contains("- nonexistent/path.txt"), + "expected not-found path bullet, got:\n{output}" + ); + } +} From 0466db66cde85d79c8b3ec4bbe418bc68130f5c2 Mon Sep 17 00:00:00 2001 From: Jakub Konka Date: Tue, 16 Dec 2025 17:41:27 +0100 Subject: [PATCH 067/266] helix: Map Zed's specific diff and git-related to goto mode (#45006) Until now, Helix-mode users would have to rely on Vim's `d *` behaviour which cannot be reliably replicated with Helix's default delete behaviour and so I believe that remapping this functionality to Helix's goto mode is a better fit. Release Notes: - Added custom mappings for Zed specific diff and git-related actions to Helix's goto mode: * `g o` - toggle selected diff hunks * `g O` - toggle staged * `g R` - restore change * `g u` - stage and goto next diff hunk * `g U` - unstage and goto next diff hunk --- assets/keymaps/vim.json | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json index 0097480e2775a1048452b2a5e8ec826525da3f2e..6e5d3423872a7dd83234b28e67c5082b36bd858f 100644 --- a/assets/keymaps/vim.json +++ b/assets/keymaps/vim.json @@ -502,6 +502,11 @@ "g p": "pane::ActivatePreviousItem", "shift-h": "pane::ActivatePreviousItem", // not a helix default "g .": "vim::HelixGotoLastModification", + "g o": "editor::ToggleSelectedDiffHunks", // Zed specific + "g shift-o": "git::ToggleStaged", // Zed specific + "g shift-r": "git::Restore", // Zed specific + "g u": "git::StageAndNext", // Zed specific + "g shift-u": "git::UnstageAndNext", // Zed specific // Window mode "space w v": "pane::SplitDown", From bcebe76e536c980a03ce618343a76a511f543881 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Tue, 16 Dec 2025 12:14:57 -0500 Subject: [PATCH 068/266] Bump Zed to v0.219 (#45009) 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 b9a9dee415d76123cf3c9c86686f94e704b5a4db..f8ff534719080a144ee0541d7b63f8b631017452 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -20507,7 +20507,7 @@ dependencies = [ [[package]] name = "zed" -version = "0.218.0" +version = "0.219.0" dependencies = [ "acp_tools", "activity_indicator", diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index 141de1139fb571020377ef9b115ed8204bad100b..955540843489ac21d79042854eb6fcebf5f64318 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.218.0" +version = "0.219.0" publish.workspace = true license = "GPL-3.0-or-later" authors = ["Zed Team "] From 3f11cbd62c203857f83252f7e2aa1b073a4b73fb Mon Sep 17 00:00:00 2001 From: Remco Smits Date: Tue, 16 Dec 2025 18:51:58 +0100 Subject: [PATCH 069/266] git_ui: Add support for collapsing/expanding entries with your keyboard (#45002) This PR adds support for collapsing/expanding Git entries with your keyboard like you can inside the project panel and variable list. I noticed there is a bug that selecting the next entry when you are on the directory level will select a non-visible entry. Will fix that in another PR, as it is not related to this feature implementation. **Result**: https://github.com/user-attachments/assets/912cc146-1e1c-485f-9b60-5ddc0a124696 Release Notes: - Git panel: Add support for collapsing/expanding entries with your keyboard. --- assets/keymaps/default-linux.json | 2 ++ assets/keymaps/default-macos.json | 2 ++ assets/keymaps/default-windows.json | 2 ++ crates/git_ui/src/git_panel.rs | 48 +++++++++++++++++++++++++++++ 4 files changed, 54 insertions(+) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 38ef7d092d534163ead569c522227b089f84af99..185a2249a7a7f3cd33213a736d38df2f8565b885 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -900,6 +900,8 @@ { "context": "GitPanel && ChangesList", "bindings": { + "left": "git_panel::CollapseSelectedEntry", + "right": "git_panel::ExpandSelectedEntry", "up": "menu::SelectPrevious", "down": "menu::SelectNext", "enter": "menu::Confirm", diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 8a0e3dfdcddbd448e6a6b9bf66f3731153208120..c711615041931a064680c5afce32c4ec06c749b3 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -975,6 +975,8 @@ "context": "GitPanel && ChangesList", "use_key_equivalents": true, "bindings": { + "left": "git_panel::CollapseSelectedEntry", + "right": "git_panel::ExpandSelectedEntry", "up": "menu::SelectPrevious", "down": "menu::SelectNext", "cmd-up": "menu::SelectFirst", diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index e344ea356fb171fb07474f498056df73c73d8307..1498f1deb98b6258bd92ac2dd0dbf1199c7db64f 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -904,6 +904,8 @@ "context": "GitPanel && ChangesList", "use_key_equivalents": true, "bindings": { + "left": "git_panel::CollapseSelectedEntry", + "right": "git_panel::ExpandSelectedEntry", "up": "menu::SelectPrevious", "down": "menu::SelectNext", "enter": "menu::Confirm", diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 362423b79fed0e8f3428d6784dd6f15b47708247..9bdcb0858a4547b3312ed5d48c85a6e8a7015d8d 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -98,6 +98,10 @@ actions!( ToggleSortByPath, /// Toggles showing entries in tree vs flat view. ToggleTreeView, + /// Expands the selected entry to show its children. + ExpandSelectedEntry, + /// Collapses the selected entry to hide its children. + CollapseSelectedEntry, ] ); @@ -896,6 +900,48 @@ impl GitPanel { .position(|entry| entry.status_entry().is_some()) } + fn expand_selected_entry( + &mut self, + _: &ExpandSelectedEntry, + window: &mut Window, + cx: &mut Context, + ) { + let Some(entry) = self.get_selected_entry().cloned() else { + return; + }; + + if let GitListEntry::Directory(dir_entry) = entry { + if dir_entry.expanded { + self.select_next(&SelectNext, window, cx); + } else { + self.toggle_directory(&dir_entry.key, window, cx); + } + } else { + self.select_next(&SelectNext, window, cx); + } + } + + fn collapse_selected_entry( + &mut self, + _: &CollapseSelectedEntry, + window: &mut Window, + cx: &mut Context, + ) { + let Some(entry) = self.get_selected_entry().cloned() else { + return; + }; + + if let GitListEntry::Directory(dir_entry) = entry { + if dir_entry.expanded { + self.toggle_directory(&dir_entry.key, window, cx); + } else { + self.select_previous(&SelectPrevious, window, cx); + } + } else { + self.select_previous(&SelectPrevious, window, cx); + } + } + fn select_first(&mut self, _: &SelectFirst, _window: &mut Window, cx: &mut Context) { if let Some(first_entry) = self.first_status_entry_index() { self.selected_entry = Some(first_entry); @@ -5264,6 +5310,8 @@ impl Render for GitPanel { .on_action(cx.listener(Self::stash_all)) .on_action(cx.listener(Self::stash_pop)) }) + .on_action(cx.listener(Self::collapse_selected_entry)) + .on_action(cx.listener(Self::expand_selected_entry)) .on_action(cx.listener(Self::select_first)) .on_action(cx.listener(Self::select_next)) .on_action(cx.listener(Self::select_previous)) From c1317baebebf955c589ef19d8c209b2ef526f75f Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Tue, 16 Dec 2025 10:58:10 -0700 Subject: [PATCH 070/266] Revert "Optimize editor rendering when clipped by parent containers" (#45011) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 914b0117fb5a23469af85e567d5723eca6b53635 (#44995). The optimization introduced a regression that causes the main thread to hang for **100+ seconds** in certain scenarios, requiring a force quit to recover. ## Analysis from spindump When a large `AutoHeight` editor is displayed inside a `List` (e.g., Agent Panel thread view), the clipping calculation can produce invalid row ranges: 1. `visible_bounds` from `window.content_mask().bounds` represents the window's content mask, not the intersection with the editor 2. When the editor is partially scrolled out of view, `clipped_top_in_lines` becomes extremely large 3. This causes `start_row` to be computed as an astronomically high value 4. `blocks_in_range(start_row..end_row)` then spends excessive time in `Cursor::search_forward` iterating through the block tree The spindump showed **~46% of samples** (459/1001 over 10+ seconds) stuck in `BlockSnapshot::blocks_in_range()`, specifically in cursor iteration. ### Heaviest stack trace ``` EditorElement::prepaint └─ blocks_in_range + 236 └─ Cursor::search_forward (459 samples) ``` ## Symptoms - Main thread unresponsive for 33-113 seconds before sampling even began - UI completely frozen - High CPU usage on main thread (10+ seconds of CPU time in the sample) - Force quit required to recover ## Path forward The original optimization goal (reducing line layout work for clipped editors) is valid, but the implementation needs to: 1. Correctly calculate the **intersection** of editor bounds with the visible viewport 2. Ensure row calculations stay within valid ranges (clamped to `max_row`) 3. Handle edge cases where the editor is completely outside the visible bounds Release Notes: - Fixed a hang that could occur when viewing large diffs in the Agent Panel --- crates/editor/src/element.rs | 17 ++--------------- crates/editor/src/test.rs | 8 +++++--- 2 files changed, 7 insertions(+), 18 deletions(-) diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 95047569c31c2e306b0f984832b568f052e4179a..8de660275ba9b455aec610568c41347888654495 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -9164,15 +9164,6 @@ impl Element for EditorElement { let height_in_lines = f64::from(bounds.size.height / line_height); let max_row = snapshot.max_point().row().as_f64(); - // Calculate how much of the editor is clipped by parent containers (e.g., List). - // This allows us to only render lines that are actually visible, which is - // critical for performance when large AutoHeight editors are inside Lists. - let visible_bounds = window.content_mask().bounds; - let clipped_top = (visible_bounds.origin.y - bounds.origin.y).max(px(0.)); - let clipped_top_in_lines = f64::from(clipped_top / line_height); - let visible_height_in_lines = - f64::from(visible_bounds.size.height / line_height); - // The max scroll position for the top of the window let max_scroll_top = if matches!( snapshot.mode, @@ -9229,14 +9220,10 @@ impl Element for EditorElement { let mut scroll_position = snapshot.scroll_position(); // The scroll position is a fractional point, the whole number of which represents // the top of the window in terms of display rows. - // We add clipped_top_in_lines to skip rows that are clipped by parent containers, - // but we don't modify scroll_position itself since the parent handles positioning. - let start_row = - DisplayRow((scroll_position.y + clipped_top_in_lines).floor() as u32); + let start_row = DisplayRow(scroll_position.y as u32); let max_row = snapshot.max_point().row(); let end_row = cmp::min( - (scroll_position.y + clipped_top_in_lines + visible_height_in_lines).ceil() - as u32, + (scroll_position.y + height_in_lines).ceil() as u32, max_row.next_row().0, ); let end_row = DisplayRow(end_row); diff --git a/crates/editor/src/test.rs b/crates/editor/src/test.rs index 1cc619385446502db6a3a0dceb6e70fa4b4e8416..5a0652bdd199a638f92234b1d50232071db18e07 100644 --- a/crates/editor/src/test.rs +++ b/crates/editor/src/test.rs @@ -176,9 +176,11 @@ pub fn block_content_for_tests( } pub fn editor_content_with_blocks(editor: &Entity, cx: &mut VisualTestContext) -> String { - let draw_size = size(px(3000.0), px(3000.0)); - cx.simulate_resize(draw_size); - cx.draw(gpui::Point::default(), draw_size, |_, _| editor.clone()); + cx.draw( + gpui::Point::default(), + size(px(3000.0), px(3000.0)), + |_, _| editor.clone(), + ); let (snapshot, mut lines, blocks) = editor.update_in(cx, |editor, window, cx| { let snapshot = editor.snapshot(window, cx); let text = editor.display_text(cx); From d07818b20fa9fbc24c906d0c81ffbe89cd4cd471 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Tue, 16 Dec 2025 19:02:13 +0100 Subject: [PATCH 071/266] git: Allow customising commit message prompt from rules library (#45004) Closes #26823 Release Notes: - Added support for customising the prompt used for generating commit message in the rules library --------- Co-authored-by: Danilo Leal --- crates/agent/src/agent.rs | 5 +- crates/agent_ui/src/completion_provider.rs | 13 +- crates/git_ui/src/git_panel.rs | 22 +- crates/prompt_store/src/prompt_store.rs | 53 ++- crates/rules_library/src/rules_library.rs | 394 +++++++++++---------- 5 files changed, 285 insertions(+), 202 deletions(-) diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index 715c8682ba9b1e6d21c6558271c00180691f59f0..f29b9f405c121b54fd9a4a250e977c593ffc3d4b 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -414,10 +414,7 @@ impl NativeAgent { .into_iter() .flat_map(|(contents, prompt_metadata)| match contents { Ok(contents) => Some(UserRulesContext { - uuid: match prompt_metadata.id { - prompt_store::PromptId::User { uuid } => uuid, - prompt_store::PromptId::EditWorkflow => return None, - }, + uuid: prompt_metadata.id.user_id()?, title: prompt_metadata.title.map(|title| title.to_string()), contents, }), diff --git a/crates/agent_ui/src/completion_provider.rs b/crates/agent_ui/src/completion_provider.rs index a2b6e0510e25c12cfbfb98d3e72cb0d2c830887a..206a2b3282b5471e8d5e8d18788519c3853dca55 100644 --- a/crates/agent_ui/src/completion_provider.rs +++ b/crates/agent_ui/src/completion_provider.rs @@ -20,7 +20,7 @@ use project::{ Completion, CompletionDisplayOptions, CompletionIntent, CompletionResponse, PathMatchCandidateSet, Project, ProjectPath, Symbol, WorktreeId, }; -use prompt_store::{PromptId, PromptStore, UserPromptId}; +use prompt_store::{PromptStore, UserPromptId}; use rope::Point; use text::{Anchor, ToPoint as _}; use ui::prelude::*; @@ -1585,13 +1585,10 @@ pub(crate) fn search_rules( if metadata.default { None } else { - match metadata.id { - PromptId::EditWorkflow => None, - PromptId::User { uuid } => Some(RulesContextEntry { - prompt_id: uuid, - title: metadata.title?, - }), - } + Some(RulesContextEntry { + prompt_id: metadata.id.user_id()?, + title: metadata.title?, + }) } }) .collect::>() diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 9bdcb0858a4547b3312ed5d48c85a6e8a7015d8d..d7be4dfe723e9cbe312420e920e4b4e90f080585 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -57,7 +57,7 @@ use project::{ git_store::{GitStoreEvent, Repository, RepositoryEvent, RepositoryId, pending_op}, project_settings::{GitPathStyle, ProjectSettings}, }; -use prompt_store::RULES_FILE_NAMES; +use prompt_store::{PromptId, PromptStore, RULES_FILE_NAMES}; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore, StatusStyle}; use std::future::Future; @@ -2422,6 +2422,20 @@ impl GitPanel { } } + async fn load_commit_message_prompt(cx: &mut AsyncApp) -> String { + const DEFAULT_PROMPT: &str = include_str!("commit_message_prompt.txt"); + + let load = async { + let store = cx.update(|cx| PromptStore::global(cx)).ok()?.await.ok()?; + store + .update(cx, |s, cx| s.load(PromptId::CommitMessage, cx)) + .ok()? + .await + .ok() + }; + load.await.unwrap_or_else(|| DEFAULT_PROMPT.to_string()) + } + /// Generates a commit message using an LLM. pub fn generate_commit_message(&mut self, cx: &mut Context) { if !self.can_commit() || !AgentSettings::get_global(cx).enabled(cx) { @@ -2487,14 +2501,14 @@ impl GitPanel { let rules_content = Self::load_project_rules(&project, &repo_work_dir, &mut cx).await; + let prompt = Self::load_commit_message_prompt(&mut cx).await; + let subject = this.update(cx, |this, cx| { this.commit_editor.read(cx).text(cx).lines().next().map(ToOwned::to_owned).unwrap_or_default() })?; let text_empty = subject.trim().is_empty(); - const PROMPT: &str = include_str!("commit_message_prompt.txt"); - let rules_section = match &rules_content { Some(rules) => format!( "\n\nThe user has provided the following project rules that you should follow when writing the commit message:\n\ @@ -2510,7 +2524,7 @@ impl GitPanel { }; let content = format!( - "{PROMPT}{rules_section}{subject_section}\nHere are the changes in this commit:\n{diff_text}" + "{prompt}{rules_section}{subject_section}\nHere are the changes in this commit:\n{diff_text}" ); let request = LanguageModelRequest { diff --git a/crates/prompt_store/src/prompt_store.rs b/crates/prompt_store/src/prompt_store.rs index fb087ce34d6d67fe4ea11a33f554307ed558c18a..b69051b067c95674d8d09be76c5b4c607fd03f67 100644 --- a/crates/prompt_store/src/prompt_store.rs +++ b/crates/prompt_store/src/prompt_store.rs @@ -56,6 +56,7 @@ pub struct PromptMetadata { pub enum PromptId { User { uuid: UserPromptId }, EditWorkflow, + CommitMessage, } impl PromptId { @@ -63,8 +64,32 @@ impl PromptId { UserPromptId::new().into() } + pub fn user_id(&self) -> Option { + match self { + Self::User { uuid } => Some(*uuid), + _ => None, + } + } + pub fn is_built_in(&self) -> bool { - !matches!(self, PromptId::User { .. }) + match self { + Self::User { .. } => false, + Self::EditWorkflow | Self::CommitMessage => true, + } + } + + pub fn can_edit(&self) -> bool { + match self { + Self::User { .. } | Self::CommitMessage => true, + Self::EditWorkflow => false, + } + } + + pub fn default_content(&self) -> Option<&'static str> { + match self { + Self::User { .. } | Self::EditWorkflow => None, + Self::CommitMessage => Some(include_str!("../../git_ui/src/commit_message_prompt.txt")), + } } } @@ -95,6 +120,7 @@ impl std::fmt::Display for PromptId { match self { PromptId::User { uuid } => write!(f, "{}", uuid.0), PromptId::EditWorkflow => write!(f, "Edit workflow"), + PromptId::CommitMessage => write!(f, "Commit message"), } } } @@ -181,6 +207,25 @@ impl PromptStore { metadata.delete(&mut txn, &PromptId::EditWorkflow).ok(); bodies.delete(&mut txn, &PromptId::EditWorkflow).ok(); + // Insert default commit message prompt if not present + if metadata.get(&txn, &PromptId::CommitMessage)?.is_none() { + metadata.put( + &mut txn, + &PromptId::CommitMessage, + &PromptMetadata { + id: PromptId::CommitMessage, + title: Some("Git Commit Message".into()), + default: false, + saved_at: Utc::now(), + }, + )?; + } + if bodies.get(&txn, &PromptId::CommitMessage)?.is_none() { + let commit_message_prompt = + include_str!("../../git_ui/src/commit_message_prompt.txt"); + bodies.put(&mut txn, &PromptId::CommitMessage, commit_message_prompt)?; + } + txn.commit()?; Self::upgrade_dbs(&db_env, metadata, bodies).log_err(); @@ -387,8 +432,8 @@ impl PromptStore { body: Rope, cx: &Context, ) -> Task> { - if id.is_built_in() { - return Task::ready(Err(anyhow!("built-in prompts cannot be saved"))); + if !id.can_edit() { + return Task::ready(Err(anyhow!("this prompt cannot be edited"))); } let prompt_metadata = PromptMetadata { @@ -430,7 +475,7 @@ impl PromptStore { ) -> Task> { let mut cache = self.metadata_cache.write(); - if id.is_built_in() { + if !id.can_edit() { title = cache .metadata_by_id .get(&id) diff --git a/crates/rules_library/src/rules_library.rs b/crates/rules_library/src/rules_library.rs index 09b7e0b539cde7371b97ef092fbd8f904b241c13..00cf939f7af45f7701cd9d3599a103ece4a6f393 100644 --- a/crates/rules_library/src/rules_library.rs +++ b/crates/rules_library/src/rules_library.rs @@ -21,9 +21,7 @@ use std::sync::atomic::AtomicBool; use std::time::Duration; use theme::ThemeSettings; use title_bar::platform_title_bar::PlatformTitleBar; -use ui::{ - Divider, KeyBinding, ListItem, ListItemSpacing, ListSubHeader, Render, Tooltip, prelude::*, -}; +use ui::{Divider, KeyBinding, ListItem, ListItemSpacing, ListSubHeader, Tooltip, prelude::*}; use util::{ResultExt, TryFutureExt}; use workspace::{Workspace, WorkspaceSettings, client_side_decorations}; use zed_actions::assistant::InlineAssist; @@ -44,15 +42,12 @@ actions!( /// Duplicates the selected rule. DuplicateRule, /// Toggles whether the selected rule is a default rule. - ToggleDefaultRule + ToggleDefaultRule, + /// Restores a built-in rule to its default content. + RestoreDefaultContent ] ); -const BUILT_IN_TOOLTIP_TEXT: &str = concat!( - "This rule supports special functionality.\n", - "It's read-only, but you can remove it from your default rules." -); - pub trait InlineAssistDelegate { fn assist( &self, @@ -270,23 +265,35 @@ impl PickerDelegate for RulePickerDelegate { .background_spawn(async move { let matches = search.await; - let (default_rules, non_default_rules): (Vec<_>, Vec<_>) = - matches.iter().partition(|rule| rule.default); + let (built_in_rules, user_rules): (Vec<_>, Vec<_>) = + matches.into_iter().partition(|rule| rule.id.is_built_in()); + let (default_rules, other_rules): (Vec<_>, Vec<_>) = + user_rules.into_iter().partition(|rule| rule.default); let mut filtered_entries = Vec::new(); + if !built_in_rules.is_empty() { + filtered_entries.push(RulePickerEntry::Header("Built-in Rules".into())); + + for rule in built_in_rules { + filtered_entries.push(RulePickerEntry::Rule(rule)); + } + + filtered_entries.push(RulePickerEntry::Separator); + } + if !default_rules.is_empty() { filtered_entries.push(RulePickerEntry::Header("Default Rules".into())); for rule in default_rules { - filtered_entries.push(RulePickerEntry::Rule(rule.clone())); + filtered_entries.push(RulePickerEntry::Rule(rule)); } filtered_entries.push(RulePickerEntry::Separator); } - for rule in non_default_rules { - filtered_entries.push(RulePickerEntry::Rule(rule.clone())); + for rule in other_rules { + filtered_entries.push(RulePickerEntry::Rule(rule)); } let selected_index = prev_prompt_id @@ -341,21 +348,27 @@ impl PickerDelegate for RulePickerDelegate { cx: &mut Context>, ) -> Option { match self.filtered_entries.get(ix)? { - RulePickerEntry::Header(title) => Some( - ListSubHeader::new(title.clone()) - .end_slot( - IconButton::new("info", IconName::Info) - .style(ButtonStyle::Transparent) - .icon_size(IconSize::Small) - .icon_color(Color::Muted) - .tooltip(Tooltip::text( - "Default Rules are attached by default with every new thread.", - )) - .into_any_element(), - ) - .inset(true) - .into_any_element(), - ), + RulePickerEntry::Header(title) => { + let tooltip_text = if title.as_ref() == "Built-in Rules" { + "Built-in rules are those included out of the box with Zed." + } else { + "Default Rules are attached by default with every new thread." + }; + + Some( + ListSubHeader::new(title.clone()) + .end_slot( + IconButton::new("info", IconName::Info) + .style(ButtonStyle::Transparent) + .icon_size(IconSize::Small) + .icon_color(Color::Muted) + .tooltip(Tooltip::text(tooltip_text)) + .into_any_element(), + ) + .inset(true) + .into_any_element(), + ) + } RulePickerEntry::Separator => Some( h_flex() .py_1() @@ -376,7 +389,7 @@ impl PickerDelegate for RulePickerDelegate { .truncate() .mr_10(), ) - .end_slot::(default.then(|| { + .end_slot::((default && !prompt_id.is_built_in()).then(|| { IconButton::new("toggle-default-rule", IconName::Paperclip) .toggle_state(true) .icon_color(Color::Accent) @@ -386,62 +399,52 @@ impl PickerDelegate for RulePickerDelegate { cx.emit(RulePickerEvent::ToggledDefault { prompt_id }) })) })) - .end_hover_slot( - h_flex() - .child(if prompt_id.is_built_in() { - div() - .id("built-in-rule") - .child(Icon::new(IconName::FileLock).color(Color::Muted)) - .tooltip(move |_window, cx| { - Tooltip::with_meta( - "Built-in rule", - None, - BUILT_IN_TOOLTIP_TEXT, - cx, - ) - }) - .into_any() - } else { - IconButton::new("delete-rule", IconName::Trash) - .icon_color(Color::Muted) - .icon_size(IconSize::Small) - .tooltip(Tooltip::text("Delete Rule")) - .on_click(cx.listener(move |_, _, _, cx| { - cx.emit(RulePickerEvent::Deleted { prompt_id }) - })) - .into_any_element() - }) - .child( - IconButton::new("toggle-default-rule", IconName::Plus) - .selected_icon(IconName::Dash) - .toggle_state(default) - .icon_size(IconSize::Small) - .icon_color(if default { - Color::Accent - } else { - Color::Muted - }) - .map(|this| { - if default { - this.tooltip(Tooltip::text( - "Remove from Default Rules", - )) + .when(!prompt_id.is_built_in(), |this| { + this.end_hover_slot( + h_flex() + .child( + IconButton::new("delete-rule", IconName::Trash) + .icon_color(Color::Muted) + .icon_size(IconSize::Small) + .tooltip(Tooltip::text("Delete Rule")) + .on_click(cx.listener(move |_, _, _, cx| { + cx.emit(RulePickerEvent::Deleted { prompt_id }) + })), + ) + .child( + IconButton::new("toggle-default-rule", IconName::Plus) + .selected_icon(IconName::Dash) + .toggle_state(default) + .icon_size(IconSize::Small) + .icon_color(if default { + Color::Accent } else { - this.tooltip(move |_window, cx| { - Tooltip::with_meta( - "Add to Default Rules", - None, - "Always included in every thread.", - cx, - ) + Color::Muted + }) + .map(|this| { + if default { + this.tooltip(Tooltip::text( + "Remove from Default Rules", + )) + } else { + this.tooltip(move |_window, cx| { + Tooltip::with_meta( + "Add to Default Rules", + None, + "Always included in every thread.", + cx, + ) + }) + } + }) + .on_click(cx.listener(move |_, _, _, cx| { + cx.emit(RulePickerEvent::ToggledDefault { + prompt_id, }) - } - }) - .on_click(cx.listener(move |_, _, _, cx| { - cx.emit(RulePickerEvent::ToggledDefault { prompt_id }) - })), - ), - ) + })), + ), + ) + }) .into_any_element(), ) } @@ -573,7 +576,7 @@ impl RulesLibrary { pub fn save_rule(&mut self, prompt_id: PromptId, window: &mut Window, cx: &mut Context) { const SAVE_THROTTLE: Duration = Duration::from_millis(500); - if prompt_id.is_built_in() { + if !prompt_id.can_edit() { return; } @@ -661,6 +664,33 @@ impl RulesLibrary { } } + pub fn restore_default_content_for_active_rule( + &mut self, + window: &mut Window, + cx: &mut Context, + ) { + if let Some(active_rule_id) = self.active_rule_id { + self.restore_default_content(active_rule_id, window, cx); + } + } + + pub fn restore_default_content( + &mut self, + prompt_id: PromptId, + window: &mut Window, + cx: &mut Context, + ) { + let Some(default_content) = prompt_id.default_content() else { + return; + }; + + if let Some(rule_editor) = self.rule_editors.get(&prompt_id) { + rule_editor.body_editor.update(cx, |editor, cx| { + editor.set_text(default_content, window, cx); + }); + } + } + pub fn toggle_default_for_rule( &mut self, prompt_id: PromptId, @@ -721,7 +751,7 @@ impl RulesLibrary { }); let mut editor = Editor::for_buffer(buffer, None, window, cx); - if prompt_id.is_built_in() { + if !prompt_id.can_edit() { editor.set_read_only(true); editor.set_show_edit_predictions(Some(false), window, cx); } @@ -1148,30 +1178,38 @@ impl RulesLibrary { fn render_active_rule_editor( &self, editor: &Entity, + read_only: bool, cx: &mut Context, ) -> impl IntoElement { let settings = ThemeSettings::get_global(cx); + let text_color = if read_only { + cx.theme().colors().text_muted + } else { + cx.theme().colors().text + }; div() .w_full() - .on_action(cx.listener(Self::move_down_from_title)) .pl_1() .border_1() .border_color(transparent_black()) .rounded_sm() - .group_hover("active-editor-header", |this| { - this.border_color(cx.theme().colors().border_variant) + .when(!read_only, |this| { + this.group_hover("active-editor-header", |this| { + this.border_color(cx.theme().colors().border_variant) + }) }) + .on_action(cx.listener(Self::move_down_from_title)) .child(EditorElement::new( &editor, EditorStyle { background: cx.theme().system().transparent, local_player: cx.theme().players().local(), text: TextStyle { - color: cx.theme().colors().editor_foreground, + color: text_color, font_family: settings.ui_font.family.clone(), font_features: settings.ui_font.features.clone(), - font_size: HeadlineSize::Large.rems().into(), + font_size: HeadlineSize::Medium.rems().into(), font_weight: settings.ui_font.weight, line_height: relative(settings.buffer_line_height.value()), ..Default::default() @@ -1186,6 +1224,68 @@ impl RulesLibrary { )) } + fn render_duplicate_rule_button(&self) -> impl IntoElement { + IconButton::new("duplicate-rule", IconName::BookCopy) + .tooltip(move |_window, cx| Tooltip::for_action("Duplicate Rule", &DuplicateRule, cx)) + .on_click(|_, window, cx| { + window.dispatch_action(Box::new(DuplicateRule), cx); + }) + } + + fn render_built_in_rule_controls(&self) -> impl IntoElement { + h_flex() + .gap_1() + .child(self.render_duplicate_rule_button()) + .child( + IconButton::new("restore-default", IconName::RotateCcw) + .tooltip(move |_window, cx| { + Tooltip::for_action( + "Restore to Default Content", + &RestoreDefaultContent, + cx, + ) + }) + .on_click(|_, window, cx| { + window.dispatch_action(Box::new(RestoreDefaultContent), cx); + }), + ) + } + + fn render_regular_rule_controls(&self, default: bool) -> impl IntoElement { + h_flex() + .gap_1() + .child( + IconButton::new("toggle-default-rule", IconName::Paperclip) + .toggle_state(default) + .when(default, |this| this.icon_color(Color::Accent)) + .map(|this| { + if default { + this.tooltip(Tooltip::text("Remove from Default Rules")) + } else { + this.tooltip(move |_window, cx| { + Tooltip::with_meta( + "Add to Default Rules", + None, + "Always included in every thread.", + cx, + ) + }) + } + }) + .on_click(|_, window, cx| { + window.dispatch_action(Box::new(ToggleDefaultRule), cx); + }), + ) + .child(self.render_duplicate_rule_button()) + .child( + IconButton::new("delete-rule", IconName::Trash) + .tooltip(move |_window, cx| Tooltip::for_action("Delete Rule", &DeleteRule, cx)) + .on_click(|_, window, cx| { + window.dispatch_action(Box::new(DeleteRule), cx); + }), + ) + } + fn render_active_rule(&mut self, cx: &mut Context) -> gpui::Stateful
{ div() .id("rule-editor") @@ -1198,9 +1298,9 @@ impl RulesLibrary { let rule_metadata = self.store.read(cx).metadata(prompt_id)?; let rule_editor = &self.rule_editors[&prompt_id]; let focus_handle = rule_editor.body_editor.focus_handle(cx); - let model = LanguageModelRegistry::read_global(cx) - .default_model() - .map(|default| default.model); + let registry = LanguageModelRegistry::read_global(cx); + let model = registry.default_model().map(|default| default.model); + let built_in = prompt_id.is_built_in(); Some( v_flex() @@ -1214,14 +1314,15 @@ impl RulesLibrary { .child( h_flex() .group("active-editor-header") - .pt_2() - .pl_1p5() - .pr_2p5() + .h_12() + .px_2() .gap_2() .justify_between() - .child( - self.render_active_rule_editor(&rule_editor.title_editor, cx), - ) + .child(self.render_active_rule_editor( + &rule_editor.title_editor, + built_in, + cx, + )) .child( h_flex() .h_full() @@ -1258,89 +1359,15 @@ impl RulesLibrary { .color(Color::Muted), ) })) - .child(if prompt_id.is_built_in() { - div() - .id("built-in-rule") - .child( - Icon::new(IconName::FileLock) - .color(Color::Muted), - ) - .tooltip(move |_window, cx| { - Tooltip::with_meta( - "Built-in rule", - None, - BUILT_IN_TOOLTIP_TEXT, - cx, - ) - }) - .into_any() - } else { - IconButton::new("delete-rule", IconName::Trash) - .tooltip(move |_window, cx| { - Tooltip::for_action( - "Delete Rule", - &DeleteRule, - cx, - ) - }) - .on_click(|_, window, cx| { - window - .dispatch_action(Box::new(DeleteRule), cx); - }) - .into_any_element() - }) - .child( - IconButton::new("duplicate-rule", IconName::BookCopy) - .tooltip(move |_window, cx| { - Tooltip::for_action( - "Duplicate Rule", - &DuplicateRule, - cx, - ) - }) - .on_click(|_, window, cx| { - window.dispatch_action( - Box::new(DuplicateRule), - cx, - ); - }), - ) - .child( - IconButton::new( - "toggle-default-rule", - IconName::Paperclip, - ) - .toggle_state(rule_metadata.default) - .icon_color(if rule_metadata.default { - Color::Accent + .map(|this| { + if built_in { + this.child(self.render_built_in_rule_controls()) } else { - Color::Muted - }) - .map(|this| { - if rule_metadata.default { - this.tooltip(Tooltip::text( - "Remove from Default Rules", - )) - } else { - this.tooltip(move |_window, cx| { - Tooltip::with_meta( - "Add to Default Rules", - None, - "Always included in every thread.", - cx, - ) - }) - } - }) - .on_click( - |_, window, cx| { - window.dispatch_action( - Box::new(ToggleDefaultRule), - cx, - ); - }, - ), - ), + this.child(self.render_regular_rule_controls( + rule_metadata.default, + )) + } + }), ), ) .child( @@ -1385,6 +1412,9 @@ impl Render for RulesLibrary { .on_action(cx.listener(|this, &ToggleDefaultRule, window, cx| { this.toggle_default_for_active_rule(window, cx) })) + .on_action(cx.listener(|this, &RestoreDefaultContent, window, cx| { + this.restore_default_content_for_active_rule(window, cx) + })) .size_full() .overflow_hidden() .font(ui_font) From 4896f477e2353fa5f6eaf01642533e7f7bd56384 Mon Sep 17 00:00:00 2001 From: max <144637754+mdliss@users.noreply.github.com> Date: Tue, 16 Dec 2025 12:03:34 -0600 Subject: [PATCH 072/266] Add MCP prompt support to agent threads (#43523) Fixes #43165 ## Problem MCP prompts were only available in text threads, not agent threads. Users with MCP servers that expose prompts couldn't use them in the main agent panel. ## Solution Added MCP prompt support to agent threads by: - Creating `ContextServerPromptRegistry` to track MCP prompts from context servers - Subscribing to context server events to reload prompts when MCP servers start/stop - Converting MCP prompts to available commands that appear in the slash command menu - Integrating prompt expansion into the agent message flow ## Testing Tested with a custom MCP server exposing `explain-code` and `write-tests` prompts. Prompts now appear in the `/` slash command menu in agent threads. Release Notes: - Added MCP prompt support to agent threads. Prompts from MCP servers now appear in the slash command menu when typing `/` in agent threads. --------- Co-authored-by: Agus Zubiaga --- crates/acp_thread/src/acp_thread.rs | 41 ++- crates/agent/src/agent.rs | 327 +++++++++++++++++- crates/agent/src/thread.rs | 60 +++- .../src/tools/context_server_registry.rs | 160 ++++++++- crates/agent_ui/src/acp/thread_view.rs | 78 ++++- crates/context_server/src/types.rs | 2 +- 6 files changed, 627 insertions(+), 41 deletions(-) diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index 53294a963d9d230c9b06372c26591ede0434ab28..2ec6347fd4aa088d7ae2cc8f5a7b6cef37d3b202 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -43,6 +43,7 @@ pub struct UserMessage { pub content: ContentBlock, pub chunks: Vec, pub checkpoint: Option, + pub indented: bool, } #[derive(Debug)] @@ -73,6 +74,7 @@ impl UserMessage { #[derive(Debug, PartialEq)] pub struct AssistantMessage { pub chunks: Vec, + pub indented: bool, } impl AssistantMessage { @@ -123,6 +125,14 @@ pub enum AgentThreadEntry { } impl AgentThreadEntry { + pub fn is_indented(&self) -> bool { + match self { + Self::UserMessage(message) => message.indented, + Self::AssistantMessage(message) => message.indented, + Self::ToolCall(_) => false, + } + } + pub fn to_markdown(&self, cx: &App) -> String { match self { Self::UserMessage(message) => message.to_markdown(cx), @@ -1184,6 +1194,16 @@ impl AcpThread { message_id: Option, chunk: acp::ContentBlock, cx: &mut Context, + ) { + self.push_user_content_block_with_indent(message_id, chunk, false, cx) + } + + pub fn push_user_content_block_with_indent( + &mut self, + message_id: Option, + chunk: acp::ContentBlock, + indented: bool, + cx: &mut Context, ) { let language_registry = self.project.read(cx).languages().clone(); let path_style = self.project.read(cx).path_style(cx); @@ -1194,8 +1214,10 @@ impl AcpThread { id, content, chunks, + indented: existing_indented, .. }) = last_entry + && *existing_indented == indented { *id = message_id.or(id.take()); content.append(chunk.clone(), &language_registry, path_style, cx); @@ -1210,6 +1232,7 @@ impl AcpThread { content, chunks: vec![chunk], checkpoint: None, + indented, }), cx, ); @@ -1221,12 +1244,26 @@ impl AcpThread { chunk: acp::ContentBlock, is_thought: bool, cx: &mut Context, + ) { + self.push_assistant_content_block_with_indent(chunk, is_thought, false, cx) + } + + pub fn push_assistant_content_block_with_indent( + &mut self, + chunk: acp::ContentBlock, + is_thought: bool, + indented: bool, + cx: &mut Context, ) { let language_registry = self.project.read(cx).languages().clone(); let path_style = self.project.read(cx).path_style(cx); let entries_len = self.entries.len(); if let Some(last_entry) = self.entries.last_mut() - && let AgentThreadEntry::AssistantMessage(AssistantMessage { chunks }) = last_entry + && let AgentThreadEntry::AssistantMessage(AssistantMessage { + chunks, + indented: existing_indented, + }) = last_entry + && *existing_indented == indented { let idx = entries_len - 1; cx.emit(AcpThreadEvent::EntryUpdated(idx)); @@ -1255,6 +1292,7 @@ impl AcpThread { self.push_entry( AgentThreadEntry::AssistantMessage(AssistantMessage { chunks: vec![chunk], + indented, }), cx, ); @@ -1704,6 +1742,7 @@ impl AcpThread { content: block, chunks: message, checkpoint: None, + indented: false, }), cx, ); diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index f29b9f405c121b54fd9a4a250e977c593ffc3d4b..693d3abd4497c057a75b4f01c07bd51f311f1fdb 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -5,12 +5,12 @@ mod legacy_thread; mod native_agent_server; pub mod outline; mod templates; -mod thread; -mod tools; - #[cfg(test)] mod tests; +mod thread; +mod tools; +use context_server::ContextServerId; pub use db::*; pub use history_store::*; pub use native_agent_server::NativeAgentServer; @@ -18,11 +18,11 @@ pub use templates::*; pub use thread::*; pub use tools::*; -use acp_thread::{AcpThread, AgentModelSelector}; +use acp_thread::{AcpThread, AgentModelSelector, UserMessageId}; use agent_client_protocol as acp; use anyhow::{Context as _, Result, anyhow}; use chrono::{DateTime, Utc}; -use collections::{HashSet, IndexMap}; +use collections::{HashMap, HashSet, IndexMap}; use fs::Fs; use futures::channel::{mpsc, oneshot}; use futures::future::Shared; @@ -39,7 +39,6 @@ use prompt_store::{ use serde::{Deserialize, Serialize}; use settings::{LanguageModelSelection, update_settings_file}; use std::any::Any; -use std::collections::HashMap; use std::path::{Path, PathBuf}; use std::rc::Rc; use std::sync::Arc; @@ -252,12 +251,24 @@ impl NativeAgent { .await; cx.new(|cx| { + let context_server_store = project.read(cx).context_server_store(); + let context_server_registry = + cx.new(|cx| ContextServerRegistry::new(context_server_store.clone(), cx)); + let mut subscriptions = vec![ cx.subscribe(&project, Self::handle_project_event), cx.subscribe( &LanguageModelRegistry::global(cx), Self::handle_models_updated_event, ), + cx.subscribe( + &context_server_store, + Self::handle_context_server_store_updated, + ), + cx.subscribe( + &context_server_registry, + Self::handle_context_server_registry_event, + ), ]; if let Some(prompt_store) = prompt_store.as_ref() { subscriptions.push(cx.subscribe(prompt_store, Self::handle_prompts_updated_event)) @@ -266,16 +277,14 @@ impl NativeAgent { let (project_context_needs_refresh_tx, project_context_needs_refresh_rx) = watch::channel(()); Self { - sessions: HashMap::new(), + sessions: HashMap::default(), history, project_context: cx.new(|_| project_context), project_context_needs_refresh: project_context_needs_refresh_tx, _maintain_project_context: cx.spawn(async move |this, cx| { Self::maintain_project_context(this, project_context_needs_refresh_rx, cx).await }), - context_server_registry: cx.new(|cx| { - ContextServerRegistry::new(project.read(cx).context_server_store(), cx) - }), + context_server_registry, templates, models: LanguageModels::new(cx), project, @@ -344,6 +353,9 @@ impl NativeAgent { pending_save: Task::ready(()), }, ); + + self.update_available_commands(cx); + acp_thread } @@ -608,6 +620,99 @@ impl NativeAgent { } } + fn handle_context_server_store_updated( + &mut self, + _store: Entity, + _event: &project::context_server_store::Event, + cx: &mut Context, + ) { + self.update_available_commands(cx); + } + + fn handle_context_server_registry_event( + &mut self, + _registry: Entity, + event: &ContextServerRegistryEvent, + cx: &mut Context, + ) { + match event { + ContextServerRegistryEvent::ToolsChanged => {} + ContextServerRegistryEvent::PromptsChanged => { + self.update_available_commands(cx); + } + } + } + + fn update_available_commands(&self, cx: &mut Context) { + let available_commands = self.build_available_commands(cx); + for session in self.sessions.values() { + if let Some(acp_thread) = session.acp_thread.upgrade() { + acp_thread.update(cx, |thread, cx| { + thread + .handle_session_update( + acp::SessionUpdate::AvailableCommandsUpdate( + acp::AvailableCommandsUpdate::new(available_commands.clone()), + ), + cx, + ) + .log_err(); + }); + } + } + } + + fn build_available_commands(&self, cx: &App) -> Vec { + let registry = self.context_server_registry.read(cx); + + let mut prompt_name_counts: HashMap<&str, usize> = HashMap::default(); + for context_server_prompt in registry.prompts() { + *prompt_name_counts + .entry(context_server_prompt.prompt.name.as_str()) + .or_insert(0) += 1; + } + + registry + .prompts() + .flat_map(|context_server_prompt| { + let prompt = &context_server_prompt.prompt; + + let should_prefix = prompt_name_counts + .get(prompt.name.as_str()) + .copied() + .unwrap_or(0) + > 1; + + let name = if should_prefix { + format!("{}.{}", context_server_prompt.server_id, prompt.name) + } else { + prompt.name.clone() + }; + + let mut command = acp::AvailableCommand::new( + name, + prompt.description.clone().unwrap_or_default(), + ); + + match prompt.arguments.as_deref() { + Some([arg]) => { + let hint = format!("<{}>", arg.name); + + command = command.input(acp::AvailableCommandInput::Unstructured( + acp::UnstructuredCommandInput::new(hint), + )); + } + Some([]) | None => {} + Some(_) => { + // skip >1 argument commands since we don't support them yet + return None; + } + } + + Some(command) + }) + .collect() + } + pub fn load_thread( &mut self, id: acp::SessionId, @@ -706,6 +811,102 @@ impl NativeAgent { history.update(cx, |history, cx| history.reload(cx)).ok(); }); } + + fn send_mcp_prompt( + &self, + message_id: UserMessageId, + session_id: agent_client_protocol::SessionId, + prompt_name: String, + server_id: ContextServerId, + arguments: HashMap, + original_content: Vec, + cx: &mut Context, + ) -> Task> { + let server_store = self.context_server_registry.read(cx).server_store().clone(); + let path_style = self.project.read(cx).path_style(cx); + + cx.spawn(async move |this, cx| { + let prompt = + crate::get_prompt(&server_store, &server_id, &prompt_name, arguments, cx).await?; + + let (acp_thread, thread) = this.update(cx, |this, _cx| { + let session = this + .sessions + .get(&session_id) + .context("Failed to get session")?; + anyhow::Ok((session.acp_thread.clone(), session.thread.clone())) + })??; + + let mut last_is_user = true; + + thread.update(cx, |thread, cx| { + thread.push_acp_user_block( + message_id, + original_content.into_iter().skip(1), + path_style, + cx, + ); + })?; + + for message in prompt.messages { + let context_server::types::PromptMessage { role, content } = message; + let block = mcp_message_content_to_acp_content_block(content); + + match role { + context_server::types::Role::User => { + let id = acp_thread::UserMessageId::new(); + + acp_thread.update(cx, |acp_thread, cx| { + acp_thread.push_user_content_block_with_indent( + Some(id.clone()), + block.clone(), + true, + cx, + ); + anyhow::Ok(()) + })??; + + thread.update(cx, |thread, cx| { + thread.push_acp_user_block(id, [block], path_style, cx); + anyhow::Ok(()) + })??; + } + context_server::types::Role::Assistant => { + acp_thread.update(cx, |acp_thread, cx| { + acp_thread.push_assistant_content_block_with_indent( + block.clone(), + false, + true, + cx, + ); + anyhow::Ok(()) + })??; + + thread.update(cx, |thread, cx| { + thread.push_acp_agent_block(block, cx); + anyhow::Ok(()) + })??; + } + } + + last_is_user = role == context_server::types::Role::User; + } + + let response_stream = thread.update(cx, |thread, cx| { + if last_is_user { + thread.send_existing(cx) + } else { + // Resume if MCP prompt did not end with a user message + thread.resume(cx) + } + })??; + + cx.update(|cx| { + NativeAgentConnection::handle_thread_events(response_stream, acp_thread, cx) + })? + .await + }) + } } /// Wrapper struct that implements the AgentConnection trait @@ -840,6 +1041,39 @@ impl NativeAgentConnection { } } +struct Command<'a> { + prompt_name: &'a str, + arg_value: &'a str, + explicit_server_id: Option<&'a str>, +} + +impl<'a> Command<'a> { + fn parse(prompt: &'a [acp::ContentBlock]) -> Option { + let acp::ContentBlock::Text(text_content) = prompt.first()? else { + return None; + }; + let text = text_content.text.trim(); + let command = text.strip_prefix('/')?; + let (command, arg_value) = command + .split_once(char::is_whitespace) + .unwrap_or((command, "")); + + if let Some((server_id, prompt_name)) = command.split_once('.') { + Some(Self { + prompt_name, + arg_value, + explicit_server_id: Some(server_id), + }) + } else { + Some(Self { + prompt_name: command, + arg_value, + explicit_server_id: None, + }) + } + } +} + struct NativeAgentModelSelector { session_id: acp::SessionId, connection: NativeAgentConnection, @@ -1005,6 +1239,47 @@ impl acp_thread::AgentConnection for NativeAgentConnection { let session_id = params.session_id.clone(); log::info!("Received prompt request for session: {}", session_id); log::debug!("Prompt blocks count: {}", params.prompt.len()); + + if let Some(parsed_command) = Command::parse(¶ms.prompt) { + let registry = self.0.read(cx).context_server_registry.read(cx); + + let explicit_server_id = parsed_command + .explicit_server_id + .map(|server_id| ContextServerId(server_id.into())); + + if let Some(prompt) = + registry.find_prompt(explicit_server_id.as_ref(), parsed_command.prompt_name) + { + let arguments = if !parsed_command.arg_value.is_empty() + && let Some(arg_name) = prompt + .prompt + .arguments + .as_ref() + .and_then(|args| args.first()) + .map(|arg| arg.name.clone()) + { + HashMap::from_iter([(arg_name, parsed_command.arg_value.to_string())]) + } else { + Default::default() + }; + + let prompt_name = prompt.prompt.name.clone(); + let server_id = prompt.server_id.clone(); + + return self.0.update(cx, |agent, cx| { + agent.send_mcp_prompt( + id, + session_id.clone(), + prompt_name, + server_id, + arguments, + params.prompt, + cx, + ) + }); + }; + }; + let path_style = self.0.read(cx).project.read(cx).path_style(cx); self.run_turn(session_id, cx, move |thread, cx| { @@ -1601,3 +1876,35 @@ mod internal_tests { }); } } + +fn mcp_message_content_to_acp_content_block( + content: context_server::types::MessageContent, +) -> acp::ContentBlock { + match content { + context_server::types::MessageContent::Text { + text, + annotations: _, + } => text.into(), + context_server::types::MessageContent::Image { + data, + mime_type, + annotations: _, + } => acp::ContentBlock::Image(acp::ImageContent::new(data, mime_type)), + context_server::types::MessageContent::Audio { + data, + mime_type, + annotations: _, + } => acp::ContentBlock::Audio(acp::AudioContent::new(data, mime_type)), + context_server::types::MessageContent::Resource { + resource, + annotations: _, + } => { + let mut link = + acp::ResourceLink::new(resource.uri.to_string(), resource.uri.to_string()); + if let Some(mime_type) = resource.mime_type { + link = link.mime_type(mime_type); + } + acp::ContentBlock::ResourceLink(link) + } + } +} diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index bed3db853a3106ca4df9676d799b4a2bfa0106a0..bb22470b9e7db934f949a13b86fd13f9dc58beed 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -108,7 +108,13 @@ impl Message { pub fn to_request(&self) -> Vec { match self { - Message::User(message) => vec![message.to_request()], + Message::User(message) => { + if message.content.is_empty() { + vec![] + } else { + vec![message.to_request()] + } + } Message::Agent(message) => message.to_request(), Message::Resume => vec![LanguageModelRequestMessage { role: Role::User, @@ -1141,20 +1147,64 @@ impl Thread { where T: Into, { + let content = content.into_iter().map(Into::into).collect::>(); + log::debug!("Thread::send content: {:?}", content); + + self.messages + .push(Message::User(UserMessage { id, content })); + cx.notify(); + + self.send_existing(cx) + } + + pub fn send_existing( + &mut self, + cx: &mut Context, + ) -> Result>> { let model = self.model().context("No language model configured")?; log::info!("Thread::send called with model: {}", model.name().0); self.advance_prompt_id(); - let content = content.into_iter().map(Into::into).collect::>(); - log::debug!("Thread::send content: {:?}", content); + log::debug!("Total messages in thread: {}", self.messages.len()); + self.run_turn(cx) + } + pub fn push_acp_user_block( + &mut self, + id: UserMessageId, + blocks: impl IntoIterator, + path_style: PathStyle, + cx: &mut Context, + ) { + let content = blocks + .into_iter() + .map(|block| UserMessageContent::from_content_block(block, path_style)) + .collect::>(); self.messages .push(Message::User(UserMessage { id, content })); cx.notify(); + } - log::debug!("Total messages in thread: {}", self.messages.len()); - self.run_turn(cx) + pub fn push_acp_agent_block(&mut self, block: acp::ContentBlock, cx: &mut Context) { + let text = match block { + acp::ContentBlock::Text(text_content) => text_content.text, + acp::ContentBlock::Image(_) => "[image]".to_string(), + acp::ContentBlock::Audio(_) => "[audio]".to_string(), + acp::ContentBlock::ResourceLink(resource_link) => resource_link.uri, + acp::ContentBlock::Resource(resource) => match resource.resource { + acp::EmbeddedResourceResource::TextResourceContents(resource) => resource.uri, + acp::EmbeddedResourceResource::BlobResourceContents(resource) => resource.uri, + _ => "[resource]".to_string(), + }, + _ => "[unknown]".to_string(), + }; + + self.messages.push(Message::Agent(AgentMessage { + content: vec![AgentMessageContent::Text(text)], + ..Default::default() + })); + cx.notify(); } #[cfg(feature = "eval")] diff --git a/crates/agent/src/tools/context_server_registry.rs b/crates/agent/src/tools/context_server_registry.rs index 03a0ef84e73d4cbca83d61077d568ec58cd7ae2b..735a47ae9fb99decbf97beb74a590f13f8f74878 100644 --- a/crates/agent/src/tools/context_server_registry.rs +++ b/crates/agent/src/tools/context_server_registry.rs @@ -3,11 +3,23 @@ use agent_client_protocol::ToolKind; use anyhow::{Result, anyhow, bail}; use collections::{BTreeMap, HashMap}; use context_server::ContextServerId; -use gpui::{App, Context, Entity, SharedString, Task}; +use gpui::{App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task}; use project::context_server_store::{ContextServerStatus, ContextServerStore}; use std::sync::Arc; use util::ResultExt; +pub struct ContextServerPrompt { + pub server_id: ContextServerId, + pub prompt: context_server::types::Prompt, +} + +pub enum ContextServerRegistryEvent { + ToolsChanged, + PromptsChanged, +} + +impl EventEmitter for ContextServerRegistry {} + pub struct ContextServerRegistry { server_store: Entity, registered_servers: HashMap, @@ -16,7 +28,20 @@ pub struct ContextServerRegistry { struct RegisteredContextServer { tools: BTreeMap>, + prompts: BTreeMap, load_tools: Task>, + load_prompts: Task>, +} + +impl RegisteredContextServer { + fn new() -> Self { + Self { + tools: BTreeMap::default(), + prompts: BTreeMap::default(), + load_tools: Task::ready(Ok(())), + load_prompts: Task::ready(Ok(())), + } + } } impl ContextServerRegistry { @@ -28,6 +53,7 @@ impl ContextServerRegistry { }; for server in server_store.read(cx).running_servers() { this.reload_tools_for_server(server.id(), cx); + this.reload_prompts_for_server(server.id(), cx); } this } @@ -56,6 +82,41 @@ impl ContextServerRegistry { .map(|(id, server)| (id, &server.tools)) } + pub fn prompts(&self) -> impl Iterator { + self.registered_servers + .values() + .flat_map(|server| server.prompts.values()) + } + + pub fn find_prompt( + &self, + server_id: Option<&ContextServerId>, + name: &str, + ) -> Option<&ContextServerPrompt> { + if let Some(server_id) = server_id { + self.registered_servers + .get(server_id) + .and_then(|server| server.prompts.get(name)) + } else { + self.registered_servers + .values() + .find_map(|server| server.prompts.get(name)) + } + } + + pub fn server_store(&self) -> &Entity { + &self.server_store + } + + fn get_or_register_server( + &mut self, + server_id: &ContextServerId, + ) -> &mut RegisteredContextServer { + self.registered_servers + .entry(server_id.clone()) + .or_insert_with(RegisteredContextServer::new) + } + fn reload_tools_for_server(&mut self, server_id: ContextServerId, cx: &mut Context) { let Some(server) = self.server_store.read(cx).get_running_server(&server_id) else { return; @@ -67,13 +128,7 @@ impl ContextServerRegistry { return; } - let registered_server = - self.registered_servers - .entry(server_id.clone()) - .or_insert(RegisteredContextServer { - tools: BTreeMap::default(), - load_tools: Task::ready(Ok(())), - }); + let registered_server = self.get_or_register_server(&server_id); registered_server.load_tools = cx.spawn(async move |this, cx| { let response = client .request::(()) @@ -94,6 +149,49 @@ impl ContextServerRegistry { )); registered_server.tools.insert(tool.name(), tool); } + cx.emit(ContextServerRegistryEvent::ToolsChanged); + cx.notify(); + } + }) + }); + } + + fn reload_prompts_for_server(&mut self, server_id: ContextServerId, cx: &mut Context) { + let Some(server) = self.server_store.read(cx).get_running_server(&server_id) else { + return; + }; + let Some(client) = server.client() else { + return; + }; + if !client.capable(context_server::protocol::ServerCapability::Prompts) { + return; + } + + let registered_server = self.get_or_register_server(&server_id); + + registered_server.load_prompts = cx.spawn(async move |this, cx| { + let response = client + .request::(()) + .await; + + this.update(cx, |this, cx| { + let Some(registered_server) = this.registered_servers.get_mut(&server_id) else { + return; + }; + + registered_server.prompts.clear(); + if let Some(response) = response.log_err() { + for prompt in response.prompts { + let name: SharedString = prompt.name.clone().into(); + registered_server.prompts.insert( + name, + ContextServerPrompt { + server_id: server_id.clone(), + prompt, + }, + ); + } + cx.emit(ContextServerRegistryEvent::PromptsChanged); cx.notify(); } }) @@ -112,9 +210,17 @@ impl ContextServerRegistry { ContextServerStatus::Starting => {} ContextServerStatus::Running => { self.reload_tools_for_server(server_id.clone(), cx); + self.reload_prompts_for_server(server_id.clone(), cx); } ContextServerStatus::Stopped | ContextServerStatus::Error(_) => { - self.registered_servers.remove(server_id); + if let Some(registered_server) = self.registered_servers.remove(server_id) { + if !registered_server.tools.is_empty() { + cx.emit(ContextServerRegistryEvent::ToolsChanged); + } + if !registered_server.prompts.is_empty() { + cx.emit(ContextServerRegistryEvent::PromptsChanged); + } + } cx.notify(); } } @@ -251,3 +357,39 @@ impl AnyAgentTool for ContextServerTool { Ok(()) } } + +pub fn get_prompt( + server_store: &Entity, + server_id: &ContextServerId, + prompt_name: &str, + arguments: HashMap, + cx: &mut AsyncApp, +) -> Task> { + let server = match cx.update(|cx| server_store.read(cx).get_running_server(server_id)) { + Ok(server) => server, + Err(error) => return Task::ready(Err(error)), + }; + let Some(server) = server else { + return Task::ready(Err(anyhow::anyhow!("Context server not found"))); + }; + + let Some(protocol) = server.client() else { + return Task::ready(Err(anyhow::anyhow!("Context server not initialized"))); + }; + + let prompt_name = prompt_name.to_string(); + + cx.background_spawn(async move { + let response = protocol + .request::( + context_server::types::PromptsGetParams { + name: prompt_name, + arguments: (!arguments.is_empty()).then(|| arguments), + meta: None, + }, + ) + .await?; + + Ok(response) + }) +} diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index aa02e22635c1585003fbfc540b50687ae0930ecd..cabdaf920c9597e85176f11f4f3a466c4ab96fe8 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1315,7 +1315,7 @@ impl AcpThreadView { })?; anyhow::Ok(()) }) - .detach(); + .detach_and_log_err(cx); } fn open_edited_buffer( @@ -1940,6 +1940,16 @@ impl AcpThreadView { window: &mut Window, cx: &Context, ) -> AnyElement { + let is_indented = entry.is_indented(); + let is_first_indented = is_indented + && self.thread().is_some_and(|thread| { + thread + .read(cx) + .entries() + .get(entry_ix.saturating_sub(1)) + .is_none_or(|entry| !entry.is_indented()) + }); + let primary = match &entry { AgentThreadEntry::UserMessage(message) => { let Some(editor) = self @@ -1972,7 +1982,9 @@ impl AcpThreadView { v_flex() .id(("user_message", entry_ix)) .map(|this| { - if entry_ix == 0 && !has_checkpoint_button && rules_item.is_none() { + if is_first_indented { + this.pt_0p5() + } else if entry_ix == 0 && !has_checkpoint_button && rules_item.is_none() { this.pt(rems_from_px(18.)) } else if rules_item.is_some() { this.pt_3() @@ -2018,6 +2030,9 @@ impl AcpThreadView { .shadow_md() .bg(cx.theme().colors().editor_background) .border_1() + .when(is_indented, |this| { + this.py_2().px_2().shadow_sm() + }) .when(editing && !editor_focus, |this| this.border_dashed()) .border_color(cx.theme().colors().border) .map(|this|{ @@ -2112,7 +2127,10 @@ impl AcpThreadView { ) .into_any() } - AgentThreadEntry::AssistantMessage(AssistantMessage { chunks }) => { + AgentThreadEntry::AssistantMessage(AssistantMessage { + chunks, + indented: _, + }) => { let is_last = entry_ix + 1 == total_entries; let style = default_markdown_style(false, false, window, cx); @@ -2146,6 +2164,7 @@ impl AcpThreadView { v_flex() .px_5() .py_1p5() + .when(is_first_indented, |this| this.pt_0p5()) .when(is_last, |this| this.pb_4()) .w_full() .text_ui(cx) @@ -2155,19 +2174,48 @@ impl AcpThreadView { AgentThreadEntry::ToolCall(tool_call) => { let has_terminals = tool_call.terminals().next().is_some(); - div().w_full().map(|this| { - if has_terminals { - this.children(tool_call.terminals().map(|terminal| { - self.render_terminal_tool_call( - entry_ix, terminal, tool_call, window, cx, - ) - })) - } else { - this.child(self.render_tool_call(entry_ix, tool_call, window, cx)) - } - }) + div() + .w_full() + .map(|this| { + if has_terminals { + this.children(tool_call.terminals().map(|terminal| { + self.render_terminal_tool_call( + entry_ix, terminal, tool_call, window, cx, + ) + })) + } else { + this.child(self.render_tool_call(entry_ix, tool_call, window, cx)) + } + }) + .into_any() } - .into_any(), + }; + + let primary = if is_indented { + let line_top = if is_first_indented { + rems_from_px(-12.0) + } else { + rems_from_px(0.0) + }; + + div() + .relative() + .w_full() + .pl(rems_from_px(20.0)) + .bg(cx.theme().colors().panel_background.opacity(0.2)) + .child( + div() + .absolute() + .left(rems_from_px(18.0)) + .top(line_top) + .bottom_0() + .w_px() + .bg(cx.theme().colors().border.opacity(0.6)), + ) + .child(primary) + .into_any_element() + } else { + primary }; let needs_confirmation = if let AgentThreadEntry::ToolCall(tool_call) = entry { diff --git a/crates/context_server/src/types.rs b/crates/context_server/src/types.rs index 03aca4f3caf7995091bbc8e049494b324674a9d3..81a427a289347ad50bf6a11674c4c5867073a274 100644 --- a/crates/context_server/src/types.rs +++ b/crates/context_server/src/types.rs @@ -330,7 +330,7 @@ pub struct PromptMessage { pub content: MessageContent, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)] #[serde(rename_all = "lowercase")] pub enum Role { User, From 93d79f3862ea56b5c445b534285f843ce6868ea2 Mon Sep 17 00:00:00 2001 From: Mayank Verma Date: Tue, 16 Dec 2025 23:39:09 +0530 Subject: [PATCH 073/266] git: Add support for repository excludes file (#42082) Closes #4824 Release Notes: - Added support for Git repository excludes file `.git/info/exclude` --------- Co-authored-by: Cole Miller Co-authored-by: Cole Miller --- crates/editor/src/editor_tests.rs | 47 +++++-- crates/editor/src/test/editor_test_context.rs | 6 + crates/git/src/git.rs | 1 + crates/worktree/src/ignore.rs | 37 +++++- crates/worktree/src/worktree.rs | 121 +++++++++++++++++- crates/worktree/src/worktree_tests.rs | 90 ++++++++++++- 6 files changed, 280 insertions(+), 22 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index dfc8fd7f901bf1f45352511e3b7e69f7f4d4b367..0fc91832dcaab8ed709739c74be01e51bb491e83 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -25578,6 +25578,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_python(cx: &mut TestApp ˇ log('for else') "}); cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): ˇfor item in items: @@ -25597,6 +25598,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_python(cx: &mut TestApp // test relative indent is preserved when tab // for `if`, `elif`, `else`, `while`, `with` and `for` cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): ˇfor item in items: @@ -25630,6 +25632,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_python(cx: &mut TestApp ˇ return 0 "}); cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): ˇtry: @@ -25646,6 +25649,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_python(cx: &mut TestApp // test relative indent is preserved when tab // for `try`, `except`, `else`, `finally`, `match` and `def` cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): ˇtry: @@ -25679,6 +25683,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("else:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): if i == 2: @@ -25696,6 +25701,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("except:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25715,6 +25721,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("else:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25738,6 +25745,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("finally:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25762,6 +25770,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("else:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25787,6 +25796,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("finally:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25812,6 +25822,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("except:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25835,6 +25846,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("except:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): try: @@ -25856,6 +25868,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("else:", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def main(): for i in range(10): @@ -25872,6 +25885,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("a", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" def f() -> list[str]: aˇ @@ -25885,6 +25899,7 @@ async fn test_outdent_after_input_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input(":", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" match 1: case:ˇ @@ -25908,6 +25923,7 @@ async fn test_indent_on_newline_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" # COMMENT: ˇ @@ -25920,7 +25936,7 @@ async fn test_indent_on_newline_for_python(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" { ˇ @@ -25980,6 +25996,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_bash(cx: &mut TestAppCo ˇ} "}); cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" function main() { ˇfor item in $items; do @@ -25997,6 +26014,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_bash(cx: &mut TestAppCo "}); // test relative indent is preserved when tab cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" function main() { ˇfor item in $items; do @@ -26031,6 +26049,7 @@ async fn test_tab_in_leading_whitespace_auto_indents_for_bash(cx: &mut TestAppCo ˇ} "}); cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" function handle() { ˇcase \"$1\" in @@ -26073,6 +26092,7 @@ async fn test_indent_after_input_for_bash(cx: &mut TestAppContext) { ˇ} "}); cx.update_editor(|e, window, cx| e.handle_input("#", window, cx)); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" function main() { #ˇ for item in $items; do @@ -26107,6 +26127,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("else", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then echo \"foo bar\" @@ -26122,6 +26143,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("elif", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then echo \"foo bar\" @@ -26139,6 +26161,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("fi", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then echo \"foo bar\" @@ -26156,6 +26179,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("done", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" while read line; do echo \"$line\" @@ -26171,6 +26195,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("done", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" for file in *.txt; do cat \"$file\" @@ -26191,6 +26216,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("esac", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" case \"$1\" in start) @@ -26213,6 +26239,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("*)", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" case \"$1\" in start) @@ -26232,6 +26259,7 @@ async fn test_outdent_after_input_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.handle_input("fi", window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then echo \"outer if\" @@ -26258,6 +26286,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" # COMMENT: ˇ @@ -26271,7 +26300,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then @@ -26286,7 +26315,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then else @@ -26301,7 +26330,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" if [ \"$1\" = \"test\" ]; then elif @@ -26315,7 +26344,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" for file in *.txt; do ˇ @@ -26329,7 +26358,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" case \"$1\" in start) @@ -26346,7 +26375,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" case \"$1\" in start) @@ -26362,7 +26391,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" function test() { ˇ @@ -26376,7 +26405,7 @@ async fn test_indent_on_newline_for_bash(cx: &mut TestAppContext) { cx.update_editor(|editor, window, cx| { editor.newline(&Newline, window, cx); }); - cx.run_until_parked(); + cx.wait_for_autoindent_applied().await; cx.assert_editor_state(indoc! {" echo \"test\"; ˇ diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs index 511629c59d8f61f1c53f5deaa406f113b9dfc3d9..bcfaeea3a7330539b2f2790e7dbe9a4969c76981 100644 --- a/crates/editor/src/test/editor_test_context.rs +++ b/crates/editor/src/test/editor_test_context.rs @@ -305,6 +305,12 @@ impl EditorTestContext { snapshot.anchor_before(ranges[0].start)..snapshot.anchor_after(ranges[0].end) } + pub async fn wait_for_autoindent_applied(&mut self) { + if let Some(fut) = self.update_buffer(|buffer, _| buffer.wait_for_autoindent_applied()) { + fut.await.ok(); + } + } + pub fn set_head_text(&mut self, diff_base: &str) { self.cx.run_until_parked(); let fs = diff --git a/crates/git/src/git.rs b/crates/git/src/git.rs index 8b8f88ef65b86ea9157e1c3217fa01bb0d6355cb..805d8d181ab7a434b565d38bdb2f802a8a3cda1a 100644 --- a/crates/git/src/git.rs +++ b/crates/git/src/git.rs @@ -23,6 +23,7 @@ pub const FSMONITOR_DAEMON: &str = "fsmonitor--daemon"; pub const LFS_DIR: &str = "lfs"; pub const COMMIT_MESSAGE: &str = "COMMIT_EDITMSG"; pub const INDEX_LOCK: &str = "index.lock"; +pub const REPO_EXCLUDE: &str = "info/exclude"; actions!( git, diff --git a/crates/worktree/src/ignore.rs b/crates/worktree/src/ignore.rs index 17c362e2d7f78384fe3b9b444353d302c4dac4c5..87487c36df6dc4eca3da43eaab95f83847ba5d1f 100644 --- a/crates/worktree/src/ignore.rs +++ b/crates/worktree/src/ignore.rs @@ -13,6 +13,10 @@ pub enum IgnoreStackEntry { Global { ignore: Arc, }, + RepoExclude { + ignore: Arc, + parent: Arc, + }, Some { abs_base_path: Arc, ignore: Arc, @@ -21,6 +25,12 @@ pub enum IgnoreStackEntry { All, } +#[derive(Debug)] +pub enum IgnoreKind { + Gitignore(Arc), + RepoExclude, +} + impl IgnoreStack { pub fn none() -> Self { Self { @@ -43,13 +53,19 @@ impl IgnoreStack { } } - pub fn append(self, abs_base_path: Arc, ignore: Arc) -> Self { + pub fn append(self, kind: IgnoreKind, ignore: Arc) -> Self { let top = match self.top.as_ref() { IgnoreStackEntry::All => self.top.clone(), - _ => Arc::new(IgnoreStackEntry::Some { - abs_base_path, - ignore, - parent: self.top.clone(), + _ => Arc::new(match kind { + IgnoreKind::Gitignore(abs_base_path) => IgnoreStackEntry::Some { + abs_base_path, + ignore, + parent: self.top.clone(), + }, + IgnoreKind::RepoExclude => IgnoreStackEntry::RepoExclude { + ignore, + parent: self.top.clone(), + }, }), }; Self { @@ -84,6 +100,17 @@ impl IgnoreStack { ignore::Match::Whitelist(_) => false, } } + IgnoreStackEntry::RepoExclude { ignore, parent } => { + match ignore.matched(abs_path, is_dir) { + ignore::Match::None => IgnoreStack { + repo_root: self.repo_root.clone(), + top: parent.clone(), + } + .is_abs_path_ignored(abs_path, is_dir), + ignore::Match::Ignore(_) => true, + ignore::Match::Whitelist(_) => false, + } + } IgnoreStackEntry::Some { abs_base_path, ignore, diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs index e1ce31c038de9136109c3c8566e5e497dfa4f239..6ec19493840da0b9de3eb55ac483488339ec5e8d 100644 --- a/crates/worktree/src/worktree.rs +++ b/crates/worktree/src/worktree.rs @@ -19,7 +19,8 @@ use futures::{ }; use fuzzy::CharBag; use git::{ - COMMIT_MESSAGE, DOT_GIT, FSMONITOR_DAEMON, GITIGNORE, INDEX_LOCK, LFS_DIR, status::GitSummary, + COMMIT_MESSAGE, DOT_GIT, FSMONITOR_DAEMON, GITIGNORE, INDEX_LOCK, LFS_DIR, REPO_EXCLUDE, + status::GitSummary, }; use gpui::{ App, AppContext as _, AsyncApp, BackgroundExecutor, Context, Entity, EventEmitter, Priority, @@ -71,6 +72,8 @@ use util::{ }; pub use worktree_settings::WorktreeSettings; +use crate::ignore::IgnoreKind; + pub const FS_WATCH_LATENCY: Duration = Duration::from_millis(100); /// A set of local or remote files that are being opened as part of a project. @@ -233,6 +236,9 @@ impl Default for WorkDirectory { pub struct LocalSnapshot { snapshot: Snapshot, global_gitignore: Option>, + /// Exclude files for all git repositories in the worktree, indexed by their absolute path. + /// The boolean indicates whether the gitignore needs to be updated. + repo_exclude_by_work_dir_abs_path: HashMap, (Arc, bool)>, /// All of the gitignore files in the worktree, indexed by their absolute path. /// The boolean indicates whether the gitignore needs to be updated. ignores_by_parent_abs_path: HashMap, (Arc, bool)>, @@ -393,6 +399,7 @@ impl Worktree { let mut snapshot = LocalSnapshot { ignores_by_parent_abs_path: Default::default(), global_gitignore: Default::default(), + repo_exclude_by_work_dir_abs_path: Default::default(), git_repositories: Default::default(), snapshot: Snapshot::new( cx.entity_id().as_u64(), @@ -2565,13 +2572,21 @@ impl LocalSnapshot { } else { IgnoreStack::none() }; + + if let Some((repo_exclude, _)) = repo_root + .as_ref() + .and_then(|abs_path| self.repo_exclude_by_work_dir_abs_path.get(abs_path)) + { + ignore_stack = ignore_stack.append(IgnoreKind::RepoExclude, repo_exclude.clone()); + } ignore_stack.repo_root = repo_root; for (parent_abs_path, ignore) in new_ignores.into_iter().rev() { if ignore_stack.is_abs_path_ignored(parent_abs_path, true) { ignore_stack = IgnoreStack::all(); break; } else if let Some(ignore) = ignore { - ignore_stack = ignore_stack.append(parent_abs_path.into(), ignore); + ignore_stack = + ignore_stack.append(IgnoreKind::Gitignore(parent_abs_path.into()), ignore); } } @@ -3646,13 +3661,23 @@ impl BackgroundScanner { let root_abs_path = self.state.lock().await.snapshot.abs_path.clone(); let repo = if self.scanning_enabled { - let (ignores, repo) = discover_ancestor_git_repo(self.fs.clone(), &root_abs_path).await; + let (ignores, exclude, repo) = + discover_ancestor_git_repo(self.fs.clone(), &root_abs_path).await; self.state .lock() .await .snapshot .ignores_by_parent_abs_path .extend(ignores); + if let Some(exclude) = exclude { + self.state + .lock() + .await + .snapshot + .repo_exclude_by_work_dir_abs_path + .insert(root_abs_path.as_path().into(), (exclude, false)); + } + repo } else { None @@ -3914,6 +3939,7 @@ impl BackgroundScanner { let mut relative_paths = Vec::with_capacity(abs_paths.len()); let mut dot_git_abs_paths = Vec::new(); + let mut work_dirs_needing_exclude_update = Vec::new(); abs_paths.sort_unstable(); abs_paths.dedup_by(|a, b| a.starts_with(b)); { @@ -3987,6 +4013,18 @@ impl BackgroundScanner { continue; }; + let absolute_path = abs_path.to_path_buf(); + if absolute_path.ends_with(Path::new(DOT_GIT).join(REPO_EXCLUDE)) { + if let Some(repository) = snapshot + .git_repositories + .values() + .find(|repo| repo.common_dir_abs_path.join(REPO_EXCLUDE) == absolute_path) + { + work_dirs_needing_exclude_update + .push(repository.work_directory_abs_path.clone()); + } + } + if abs_path.file_name() == Some(OsStr::new(GITIGNORE)) { for (_, repo) in snapshot .git_repositories @@ -4032,6 +4070,19 @@ impl BackgroundScanner { return; } + if !work_dirs_needing_exclude_update.is_empty() { + let mut state = self.state.lock().await; + for work_dir_abs_path in work_dirs_needing_exclude_update { + if let Some((_, needs_update)) = state + .snapshot + .repo_exclude_by_work_dir_abs_path + .get_mut(&work_dir_abs_path) + { + *needs_update = true; + } + } + } + self.state.lock().await.snapshot.scan_id += 1; let (scan_job_tx, scan_job_rx) = channel::unbounded(); @@ -4299,7 +4350,8 @@ impl BackgroundScanner { match build_gitignore(&child_abs_path, self.fs.as_ref()).await { Ok(ignore) => { let ignore = Arc::new(ignore); - ignore_stack = ignore_stack.append(job.abs_path.clone(), ignore.clone()); + ignore_stack = ignore_stack + .append(IgnoreKind::Gitignore(job.abs_path.clone()), ignore.clone()); new_ignore = Some(ignore); } Err(error) => { @@ -4561,11 +4613,24 @@ impl BackgroundScanner { .await; if path.is_empty() - && let Some((ignores, repo)) = new_ancestor_repo.take() + && let Some((ignores, exclude, repo)) = new_ancestor_repo.take() { log::trace!("updating ancestor git repository"); state.snapshot.ignores_by_parent_abs_path.extend(ignores); if let Some((ancestor_dot_git, work_directory)) = repo { + if let Some(exclude) = exclude { + let work_directory_abs_path = self + .state + .lock() + .await + .snapshot + .work_directory_abs_path(&work_directory); + + state + .snapshot + .repo_exclude_by_work_dir_abs_path + .insert(work_directory_abs_path.into(), (exclude, false)); + } state .insert_git_repository_for_path( work_directory, @@ -4663,6 +4728,36 @@ impl BackgroundScanner { { let snapshot = &mut self.state.lock().await.snapshot; let abs_path = snapshot.abs_path.clone(); + + snapshot.repo_exclude_by_work_dir_abs_path.retain( + |work_dir_abs_path, (exclude, needs_update)| { + if *needs_update { + *needs_update = false; + ignores_to_update.push(work_dir_abs_path.clone()); + + if let Some((_, repository)) = snapshot + .git_repositories + .iter() + .find(|(_, repo)| &repo.work_directory_abs_path == work_dir_abs_path) + { + let exclude_abs_path = + repository.common_dir_abs_path.join(REPO_EXCLUDE); + if let Ok(current_exclude) = self + .executor + .block(build_gitignore(&exclude_abs_path, self.fs.as_ref())) + { + *exclude = Arc::new(current_exclude); + } + } + } + + snapshot + .git_repositories + .iter() + .any(|(_, repo)| &repo.work_directory_abs_path == work_dir_abs_path) + }, + ); + snapshot .ignores_by_parent_abs_path .retain(|parent_abs_path, (_, needs_update)| { @@ -4717,7 +4812,8 @@ impl BackgroundScanner { let mut ignore_stack = job.ignore_stack; if let Some((ignore, _)) = snapshot.ignores_by_parent_abs_path.get(&job.abs_path) { - ignore_stack = ignore_stack.append(job.abs_path.clone(), ignore.clone()); + ignore_stack = + ignore_stack.append(IgnoreKind::Gitignore(job.abs_path.clone()), ignore.clone()); } let mut entries_by_id_edits = Vec::new(); @@ -4892,6 +4988,9 @@ impl BackgroundScanner { let preserve = ids_to_preserve.contains(work_directory_id); if !preserve { affected_repo_roots.push(entry.dot_git_abs_path.parent().unwrap().into()); + snapshot + .repo_exclude_by_work_dir_abs_path + .remove(&entry.work_directory_abs_path); } preserve }); @@ -4931,8 +5030,10 @@ async fn discover_ancestor_git_repo( root_abs_path: &SanitizedPath, ) -> ( HashMap, (Arc, bool)>, + Option>, Option<(PathBuf, WorkDirectory)>, ) { + let mut exclude = None; let mut ignores = HashMap::default(); for (index, ancestor) in root_abs_path.as_path().ancestors().enumerate() { if index != 0 { @@ -4968,6 +5069,7 @@ async fn discover_ancestor_git_repo( // also mark where in the git repo the root folder is located. return ( ignores, + exclude, Some(( ancestor_dot_git, WorkDirectory::AboveProject { @@ -4979,12 +5081,17 @@ async fn discover_ancestor_git_repo( }; } + let repo_exclude_abs_path = ancestor_dot_git.join(REPO_EXCLUDE); + if let Ok(repo_exclude) = build_gitignore(&repo_exclude_abs_path, fs.as_ref()).await { + exclude = Some(Arc::new(repo_exclude)); + } + // Reached root of git repository. break; } } - (ignores, None) + (ignores, exclude, None) } fn build_diff( diff --git a/crates/worktree/src/worktree_tests.rs b/crates/worktree/src/worktree_tests.rs index e58e99ea68ebde51a6c12abfd859296b3cd883c4..12f2863aab6c4b4376157f3499fa332051a4822f 100644 --- a/crates/worktree/src/worktree_tests.rs +++ b/crates/worktree/src/worktree_tests.rs @@ -1,7 +1,7 @@ use crate::{Entry, EntryKind, Event, PathChange, Worktree, WorktreeModelHandle}; use anyhow::Result; use fs::{FakeFs, Fs, RealFs, RemoveOptions}; -use git::GITIGNORE; +use git::{DOT_GIT, GITIGNORE, REPO_EXCLUDE}; use gpui::{AppContext as _, BackgroundExecutor, BorrowAppContext, Context, Task, TestAppContext}; use parking_lot::Mutex; use postage::stream::Stream; @@ -2412,6 +2412,94 @@ async fn test_global_gitignore(executor: BackgroundExecutor, cx: &mut TestAppCon }); } +#[gpui::test] +async fn test_repo_exclude(executor: BackgroundExecutor, cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(executor); + let project_dir = Path::new(path!("/project")); + fs.insert_tree( + project_dir, + json!({ + ".git": { + "info": { + "exclude": ".env.*" + } + }, + ".env.example": "secret=xxxx", + ".env.local": "secret=1234", + ".gitignore": "!.env.example", + "README.md": "# Repo Exclude", + "src": { + "main.rs": "fn main() {}", + }, + }), + ) + .await; + + let worktree = Worktree::local( + project_dir, + true, + fs.clone(), + Default::default(), + true, + &mut cx.to_async(), + ) + .await + .unwrap(); + worktree + .update(cx, |worktree, _| { + worktree.as_local().unwrap().scan_complete() + }) + .await; + cx.run_until_parked(); + + // .gitignore overrides .git/info/exclude + worktree.update(cx, |worktree, _cx| { + let expected_excluded_paths = []; + let expected_ignored_paths = [".env.local"]; + let expected_tracked_paths = [".env.example", "README.md", "src/main.rs"]; + let expected_included_paths = []; + + check_worktree_entries( + worktree, + &expected_excluded_paths, + &expected_ignored_paths, + &expected_tracked_paths, + &expected_included_paths, + ); + }); + + // Ignore statuses are updated when .git/info/exclude file changes + fs.write( + &project_dir.join(DOT_GIT).join(REPO_EXCLUDE), + ".env.example".as_bytes(), + ) + .await + .unwrap(); + worktree + .update(cx, |worktree, _| { + worktree.as_local().unwrap().scan_complete() + }) + .await; + cx.run_until_parked(); + + worktree.update(cx, |worktree, _cx| { + let expected_excluded_paths = []; + let expected_ignored_paths = []; + let expected_tracked_paths = [".env.example", ".env.local", "README.md", "src/main.rs"]; + let expected_included_paths = []; + + check_worktree_entries( + worktree, + &expected_excluded_paths, + &expected_ignored_paths, + &expected_tracked_paths, + &expected_included_paths, + ); + }); +} + #[track_caller] fn check_worktree_entries( tree: &Worktree, From f21cec7cb1d961a0956b97046001117da3bc17f2 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Tue, 16 Dec 2025 20:34:00 +0200 Subject: [PATCH 074/266] Introduce worktree trust mechanism (#44887) Closes https://github.com/zed-industries/zed/issues/12589 Forces Zed to require user permissions before running any basic potentially dangerous actions: parsing and synchronizing `.zed/settings.json`, downloading and spawning any language and MCP servers (includes `prettier` and `copilot` instances) and all `NodeRuntime` interactions. There are more we can add later, among the ideas: DAP downloads on debugger start, Python virtual environment, etc. By default, Zed starts in restricted mode and shows a `! Restricted Mode` in the title bar, no aforementioned actions are executed. Clicking it or calling `workspace::ToggleWorktreeSecurity` command will bring a modal to trust worktrees or dismiss the modal: 1 Agent Panel shows a message too: 2 This works on local, SSH and WSL remote projects, trusted worktrees are persisted between Zed restarts. There's a way to clear all persisted trust with `workspace::ClearTrustedWorktrees`, this will restart Zed. This mechanism can be turned off with settings: ```jsonc "session": { "trust_all_worktrees": true } ``` in this mode, all worktrees will be trusted by default, allowing all actions, but no auto trust will be persisted: hence, when the setting is changed back, auto trusted worktrees will require another trust confirmation. This settings switch was added to the onboarding view also. Release Notes: - Introduced worktree trust mechanism, can be turned off with `"session": { "trust_all_worktrees": true }` --------- Co-authored-by: Matt Miller Co-authored-by: Danilo Leal Co-authored-by: John D. Swanson --- Cargo.lock | 1 + assets/keymaps/default-linux.json | 1 + assets/keymaps/default-macos.json | 1 + assets/keymaps/default-windows.json | 1 + assets/settings/default.json | 6 + crates/agent_ui/src/agent_panel.rs | 245 ++- crates/agent_ui/src/agent_ui.rs | 10 + .../remote_editing_collaboration_tests.rs | 286 ++- crates/collab/src/tests/test_server.rs | 3 + crates/edit_prediction_cli/src/headless.rs | 5 +- .../edit_prediction_cli/src/load_project.rs | 1 + crates/editor/src/editor_tests.rs | 169 +- crates/eval/src/eval.rs | 2 +- crates/eval/src/instance.rs | 1 + crates/git_ui/src/worktree_picker.rs | 1 + crates/inspector_ui/src/inspector.rs | 1 + crates/node_runtime/src/node_runtime.rs | 9 + crates/onboarding/src/basics_page.rs | 48 +- crates/project/Cargo.toml | 2 + crates/project/src/context_server_store.rs | 19 + crates/project/src/lsp_store.rs | 85 +- crates/project/src/persistence.rs | 411 ++++ crates/project/src/project.rs | 127 +- crates/project/src/project_settings.rs | 168 +- crates/project/src/trusted_worktrees.rs | 1933 +++++++++++++++++ crates/project_benchmarks/src/main.rs | 3 +- crates/proto/proto/worktree.proto | 19 + crates/proto/proto/zed.proto | 5 +- crates/proto/src/proto.rs | 10 +- .../recent_projects/src/remote_connections.rs | 21 +- crates/recent_projects/src/remote_servers.rs | 1 + crates/remote_server/Cargo.toml | 2 +- crates/remote_server/src/headless_project.rs | 62 + .../remote_server/src/remote_editing_tests.rs | 3 +- crates/remote_server/src/unix.rs | 7 + .../settings/src/settings_content/project.rs | 6 + crates/settings_ui/src/page_data.rs | 22 + crates/title_bar/src/title_bar.rs | 62 +- .../components/notification/alert_modal.rs | 231 +- crates/workspace/src/modal_layer.rs | 17 +- crates/workspace/src/security_modal.rs | 373 ++++ crates/workspace/src/workspace.rs | 83 +- crates/zed/src/main.rs | 14 +- docs/src/SUMMARY.md | 5 +- docs/src/ai/privacy-and-security.md | 4 +- docs/src/configuring-zed.md | 41 + docs/src/worktree-trust.md | 66 + 47 files changed, 4415 insertions(+), 178 deletions(-) create mode 100644 crates/project/src/persistence.rs create mode 100644 crates/project/src/trusted_worktrees.rs create mode 100644 crates/workspace/src/security_modal.rs create mode 100644 docs/src/worktree-trust.md diff --git a/Cargo.lock b/Cargo.lock index f8ff534719080a144ee0541d7b63f8b631017452..b89c0803c7ed9a1b90fc3e8fc55eab10cee7b905 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12421,6 +12421,7 @@ dependencies = [ "context_server", "dap", "dap_adapters", + "db", "extension", "fancy-regex", "fs", diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 185a2249a7a7f3cd33213a736d38df2f8565b885..5a37614180d46b4a79b97f9a23665cbf5372cc0a 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -45,6 +45,7 @@ "ctrl-alt-z": "edit_prediction::RatePredictions", "ctrl-alt-shift-i": "edit_prediction::ToggleMenu", "ctrl-alt-l": "lsp_tool::ToggleMenu", + "ctrl-alt-shift-s": "workspace::ToggleWorktreeSecurity", }, }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index c711615041931a064680c5afce32c4ec06c749b3..8c8094495e16a9f26adaa380f584abe5e3bc2947 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -51,6 +51,7 @@ "ctrl-cmd-i": "edit_prediction::ToggleMenu", "ctrl-cmd-l": "lsp_tool::ToggleMenu", "ctrl-cmd-c": "editor::DisplayCursorNames", + "ctrl-cmd-s": "workspace::ToggleWorktreeSecurity", }, }, { diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index 1498f1deb98b6258bd92ac2dd0dbf1199c7db64f..74320ae637080da92108f195eabca537e3a71406 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -43,6 +43,7 @@ "ctrl-shift-i": "edit_prediction::ToggleMenu", "shift-alt-l": "lsp_tool::ToggleMenu", "ctrl-shift-alt-c": "editor::DisplayCursorNames", + "ctrl-shift-alt-s": "workspace::ToggleWorktreeSecurity", }, }, { diff --git a/assets/settings/default.json b/assets/settings/default.json index 0ef3bb70c71bb96828bc1b1c2594376b15bada90..a0e499934428b4bafcbe12b97b2e8fc4747a5f31 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -2062,6 +2062,12 @@ // // Default: true "restore_unsaved_buffers": true, + // Whether or not to skip worktree trust checks. + // When trusted, project settings are synchronized automatically, + // language and MCP servers are downloaded and started automatically. + // + // Default: false + "trust_all_worktrees": false, }, // Zed's Prettier integration settings. // Allows to enable/disable formatting with Prettier diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 97c7aecb8e34563db0adfa6bdbeda31140fd6cdd..ff8cf8db969e9ef2d1d86b306c0f38fb66a67fde 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -2,10 +2,12 @@ use std::{ops::Range, path::Path, rc::Rc, sync::Arc, time::Duration}; use acp_thread::AcpThread; use agent::{ContextServerRegistry, DbThreadMetadata, HistoryEntry, HistoryStore}; +use agent_servers::AgentServer; use db::kvp::{Dismissable, KEY_VALUE_STORE}; use project::{ ExternalAgentServerName, agent_server_store::{CLAUDE_CODE_NAME, CODEX_NAME, GEMINI_NAME}, + trusted_worktrees::{RemoteHostLocation, TrustedWorktrees, wait_for_workspace_trust}, }; use serde::{Deserialize, Serialize}; use settings::{ @@ -262,6 +264,17 @@ impl AgentType { Self::Custom { .. } => Some(IconName::Sparkle), } } + + fn is_mcp(&self) -> bool { + match self { + Self::NativeAgent => false, + Self::TextThread => false, + Self::Custom { .. } => false, + Self::Gemini => true, + Self::ClaudeCode => true, + Self::Codex => true, + } + } } impl From for AgentType { @@ -287,7 +300,7 @@ impl ActiveView { } } - pub fn native_agent( + fn native_agent( fs: Arc, prompt_store: Option>, history_store: Entity, @@ -442,6 +455,9 @@ pub struct AgentPanel { pending_serialization: Option>>, onboarding: Entity, selected_agent: AgentType, + new_agent_thread_task: Task<()>, + show_trust_workspace_message: bool, + _worktree_trust_subscription: Option, } impl AgentPanel { @@ -665,6 +681,48 @@ impl AgentPanel { None }; + let mut show_trust_workspace_message = false; + let worktree_trust_subscription = + TrustedWorktrees::try_get_global(cx).and_then(|trusted_worktrees| { + let has_global_trust = trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust_workspace( + project + .read(cx) + .remote_connection_options(cx) + .map(RemoteHostLocation::from), + cx, + ) + }); + if has_global_trust { + None + } else { + show_trust_workspace_message = true; + let project = project.clone(); + Some(cx.subscribe( + &trusted_worktrees, + move |agent_panel, trusted_worktrees, _, cx| { + let new_show_trust_workspace_message = + !trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust_workspace( + project + .read(cx) + .remote_connection_options(cx) + .map(RemoteHostLocation::from), + cx, + ) + }); + if new_show_trust_workspace_message + != agent_panel.show_trust_workspace_message + { + agent_panel.show_trust_workspace_message = + new_show_trust_workspace_message; + cx.notify(); + }; + }, + )) + } + }); + let mut panel = Self { active_view, workspace, @@ -687,11 +745,14 @@ impl AgentPanel { height: None, zoomed: false, pending_serialization: None, + new_agent_thread_task: Task::ready(()), onboarding, acp_history, history_store, selected_agent: AgentType::default(), loading: false, + show_trust_workspace_message, + _worktree_trust_subscription: worktree_trust_subscription, }; // Initial sync of agent servers from extensions @@ -884,37 +945,63 @@ impl AgentPanel { } }; - let server = ext_agent.server(fs, history); - - this.update_in(cx, |this, window, cx| { - let selected_agent = ext_agent.into(); - if this.selected_agent != selected_agent { - this.selected_agent = selected_agent; - this.serialize(cx); + if ext_agent.is_mcp() { + let wait_task = this.update(cx, |agent_panel, cx| { + agent_panel.project.update(cx, |project, cx| { + wait_for_workspace_trust( + project.remote_connection_options(cx), + "context servers", + cx, + ) + }) + })?; + if let Some(wait_task) = wait_task { + this.update_in(cx, |agent_panel, window, cx| { + agent_panel.show_trust_workspace_message = true; + cx.notify(); + agent_panel.new_agent_thread_task = + cx.spawn_in(window, async move |agent_panel, cx| { + wait_task.await; + let server = ext_agent.server(fs, history); + agent_panel + .update_in(cx, |agent_panel, window, cx| { + agent_panel.show_trust_workspace_message = false; + cx.notify(); + agent_panel._external_thread( + server, + resume_thread, + summarize_thread, + workspace, + project, + loading, + ext_agent, + window, + cx, + ); + }) + .ok(); + }); + })?; + return Ok(()); } + } - let thread_view = cx.new(|cx| { - crate::acp::AcpThreadView::new( - server, - resume_thread, - summarize_thread, - workspace.clone(), - project, - this.history_store.clone(), - this.prompt_store.clone(), - !loading, - window, - cx, - ) - }); - - this.set_active_view( - ActiveView::ExternalAgentThread { thread_view }, - !loading, + let server = ext_agent.server(fs, history); + this.update_in(cx, |agent_panel, window, cx| { + agent_panel._external_thread( + server, + resume_thread, + summarize_thread, + workspace, + project, + loading, + ext_agent, window, cx, ); - }) + })?; + + anyhow::Ok(()) }) .detach_and_log_err(cx); } @@ -1423,6 +1510,36 @@ impl AgentPanel { window: &mut Window, cx: &mut Context, ) { + let wait_task = if agent.is_mcp() { + self.project.update(cx, |project, cx| { + wait_for_workspace_trust( + project.remote_connection_options(cx), + "context servers", + cx, + ) + }) + } else { + None + }; + if let Some(wait_task) = wait_task { + self.show_trust_workspace_message = true; + cx.notify(); + self.new_agent_thread_task = cx.spawn_in(window, async move |agent_panel, cx| { + wait_task.await; + agent_panel + .update_in(cx, |agent_panel, window, cx| { + agent_panel.show_trust_workspace_message = false; + cx.notify(); + agent_panel._new_agent_thread(agent, window, cx); + }) + .ok(); + }); + } else { + self._new_agent_thread(agent, window, cx); + } + } + + fn _new_agent_thread(&mut self, agent: AgentType, window: &mut Window, cx: &mut Context) { match agent { AgentType::TextThread => { window.dispatch_action(NewTextThread.boxed_clone(), cx); @@ -1477,6 +1594,47 @@ impl AgentPanel { cx, ); } + + fn _external_thread( + &mut self, + server: Rc, + resume_thread: Option, + summarize_thread: Option, + workspace: WeakEntity, + project: Entity, + loading: bool, + ext_agent: ExternalAgent, + window: &mut Window, + cx: &mut Context, + ) { + let selected_agent = AgentType::from(ext_agent); + if self.selected_agent != selected_agent { + self.selected_agent = selected_agent; + self.serialize(cx); + } + + let thread_view = cx.new(|cx| { + crate::acp::AcpThreadView::new( + server, + resume_thread, + summarize_thread, + workspace.clone(), + project, + self.history_store.clone(), + self.prompt_store.clone(), + !loading, + window, + cx, + ) + }); + + self.set_active_view( + ActiveView::ExternalAgentThread { thread_view }, + !loading, + window, + cx, + ); + } } impl Focusable for AgentPanel { @@ -2557,6 +2715,38 @@ impl AgentPanel { } } + fn render_workspace_trust_message(&self, cx: &Context) -> Option { + if !self.show_trust_workspace_message { + return None; + } + + let description = "To protect your system, third-party code—like MCP servers—won't run until you mark this workspace as safe."; + + Some( + Callout::new() + .icon(IconName::Warning) + .severity(Severity::Warning) + .border_position(ui::BorderPosition::Bottom) + .title("You're in Restricted Mode") + .description(description) + .actions_slot( + Button::new("open-trust-modal", "Configure Project Trust") + .label_size(LabelSize::Small) + .style(ButtonStyle::Outlined) + .on_click({ + cx.listener(move |this, _, window, cx| { + this.workspace + .update(cx, |workspace, cx| { + workspace + .show_worktree_trust_security_modal(true, window, cx) + }) + .log_err(); + }) + }), + ), + ) + } + fn key_context(&self) -> KeyContext { let mut key_context = KeyContext::new_with_defaults(); key_context.add("AgentPanel"); @@ -2609,6 +2799,7 @@ impl Render for AgentPanel { } })) .child(self.render_toolbar(window, cx)) + .children(self.render_workspace_trust_message(cx)) .children(self.render_onboarding(window, cx)) .map(|parent| match &self.active_view { ActiveView::ExternalAgentThread { thread_view, .. } => parent diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index 3a0cc74bef611175b82884bd87e521c5a968d54a..4f759d6a9c7687d2cdf29752c489db2fcb1ffe68 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -171,6 +171,16 @@ impl ExternalAgent { Self::Custom { name } => Rc::new(agent_servers::CustomAgentServer::new(name.clone())), } } + + pub fn is_mcp(&self) -> bool { + match self { + Self::Gemini => true, + Self::ClaudeCode => true, + Self::Codex => true, + Self::NativeAgent => false, + Self::Custom { .. } => false, + } + } } /// Opens the profile management interface for configuring agent tools and settings. diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs index 04403de9fa0883e9d738f3d96b9b2acdf1d66967..a66d7a1856c195a41a495123b468dc2b6ac8a1ca 100644 --- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs +++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs @@ -4,6 +4,7 @@ use collections::{HashMap, HashSet}; use dap::{Capabilities, adapters::DebugTaskDefinition, transport::RequestHandling}; use debugger_ui::debugger_panel::DebugPanel; +use editor::{Editor, EditorMode, MultiBuffer}; use extension::ExtensionHostProxy; use fs::{FakeFs, Fs as _, RemoveOptions}; use futures::StreamExt as _; @@ -12,22 +13,30 @@ use http_client::BlockedHttpClient; use language::{ FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageRegistry, language_settings::{Formatter, FormatterList, language_settings}, - tree_sitter_typescript, + rust_lang, tree_sitter_typescript, }; use node_runtime::NodeRuntime; use project::{ ProjectPath, debugger::session::ThreadId, lsp_store::{FormatTrigger, LspFormatTarget}, + trusted_worktrees::{PathTrust, TrustedWorktrees}, }; use remote::RemoteClient; use remote_server::{HeadlessAppState, HeadlessProject}; use rpc::proto; use serde_json::json; -use settings::{LanguageServerFormatterSpecifier, PrettierSettingsContent, SettingsStore}; +use settings::{ + InlayHintSettingsContent, LanguageServerFormatterSpecifier, PrettierSettingsContent, + SettingsStore, +}; use std::{ path::Path, - sync::{Arc, atomic::AtomicUsize}, + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, + time::Duration, }; use task::TcpArgumentsTemplate; use util::{path, rel_path::rel_path}; @@ -90,13 +99,14 @@ async fn test_sharing_an_ssh_remote_project( languages, extension_host_proxy: Arc::new(ExtensionHostProxy::new()), }, + false, cx, ) }); let client_ssh = RemoteClient::fake_client(opts, cx_a).await; let (project_a, worktree_id) = client_a - .build_ssh_project(path!("/code/project1"), client_ssh, cx_a) + .build_ssh_project(path!("/code/project1"), client_ssh, false, cx_a) .await; // While the SSH worktree is being scanned, user A shares the remote project. @@ -250,13 +260,14 @@ async fn test_ssh_collaboration_git_branches( languages, extension_host_proxy: Arc::new(ExtensionHostProxy::new()), }, + false, cx, ) }); let client_ssh = RemoteClient::fake_client(opts, cx_a).await; let (project_a, _) = client_a - .build_ssh_project("/project", client_ssh, cx_a) + .build_ssh_project("/project", client_ssh, false, cx_a) .await; // While the SSH worktree is being scanned, user A shares the remote project. @@ -454,13 +465,14 @@ async fn test_ssh_collaboration_formatting_with_prettier( languages, extension_host_proxy: Arc::new(ExtensionHostProxy::new()), }, + false, cx, ) }); let client_ssh = RemoteClient::fake_client(opts, cx_a).await; let (project_a, worktree_id) = client_a - .build_ssh_project(path!("/project"), client_ssh, cx_a) + .build_ssh_project(path!("/project"), client_ssh, false, cx_a) .await; // While the SSH worktree is being scanned, user A shares the remote project. @@ -615,6 +627,7 @@ async fn test_remote_server_debugger( languages, extension_host_proxy: Arc::new(ExtensionHostProxy::new()), }, + false, cx, ) }); @@ -627,7 +640,7 @@ async fn test_remote_server_debugger( command_palette_hooks::init(cx); }); let (project_a, _) = client_a - .build_ssh_project(path!("/code"), client_ssh.clone(), cx_a) + .build_ssh_project(path!("/code"), client_ssh.clone(), false, cx_a) .await; let (workspace, cx_a) = client_a.build_workspace(&project_a, cx_a); @@ -723,6 +736,7 @@ async fn test_slow_adapter_startup_retries( languages, extension_host_proxy: Arc::new(ExtensionHostProxy::new()), }, + false, cx, ) }); @@ -735,7 +749,7 @@ async fn test_slow_adapter_startup_retries( command_palette_hooks::init(cx); }); let (project_a, _) = client_a - .build_ssh_project(path!("/code"), client_ssh.clone(), cx_a) + .build_ssh_project(path!("/code"), client_ssh.clone(), false, cx_a) .await; let (workspace, cx_a) = client_a.build_workspace(&project_a, cx_a); @@ -838,3 +852,259 @@ async fn test_slow_adapter_startup_retries( shutdown_session.await.unwrap(); } + +#[gpui::test] +async fn test_ssh_remote_worktree_trust(cx_a: &mut TestAppContext, server_cx: &mut TestAppContext) { + use project::trusted_worktrees::RemoteHostLocation; + + cx_a.update(|cx| { + release_channel::init(semver::Version::new(0, 0, 0), cx); + }); + server_cx.update(|cx| { + release_channel::init(semver::Version::new(0, 0, 0), cx); + }); + + let mut server = TestServer::start(cx_a.executor().clone()).await; + let client_a = server.create_client(cx_a, "user_a").await; + + let server_name = "override-rust-analyzer"; + let lsp_inlay_hint_request_count = Arc::new(AtomicUsize::new(0)); + + let (opts, server_ssh) = RemoteClient::fake_server(cx_a, server_cx); + let remote_fs = FakeFs::new(server_cx.executor()); + remote_fs + .insert_tree( + path!("/projects"), + json!({ + "project_a": { + ".zed": { + "settings.json": r#"{"languages":{"Rust":{"language_servers":["override-rust-analyzer"]}}}"# + }, + "main.rs": "fn main() {}" + }, + "project_b": { "lib.rs": "pub fn lib() {}" } + }), + ) + .await; + + server_cx.update(HeadlessProject::init); + let remote_http_client = Arc::new(BlockedHttpClient); + let node = NodeRuntime::unavailable(); + let languages = Arc::new(LanguageRegistry::new(server_cx.executor())); + languages.add(rust_lang()); + + let capabilities = lsp::ServerCapabilities { + inlay_hint_provider: Some(lsp::OneOf::Left(true)), + ..lsp::ServerCapabilities::default() + }; + let mut fake_language_servers = languages.register_fake_lsp( + "Rust", + FakeLspAdapter { + name: server_name, + capabilities: capabilities.clone(), + initializer: Some(Box::new({ + let lsp_inlay_hint_request_count = lsp_inlay_hint_request_count.clone(); + move |fake_server| { + let lsp_inlay_hint_request_count = lsp_inlay_hint_request_count.clone(); + fake_server.set_request_handler::( + move |_params, _| { + lsp_inlay_hint_request_count.fetch_add(1, Ordering::Release); + async move { + Ok(Some(vec![lsp::InlayHint { + position: lsp::Position::new(0, 0), + label: lsp::InlayHintLabel::String("hint".to_string()), + kind: None, + text_edits: None, + tooltip: None, + padding_left: None, + padding_right: None, + data: None, + }])) + } + }, + ); + } + })), + ..FakeLspAdapter::default() + }, + ); + + let _headless_project = server_cx.new(|cx| { + HeadlessProject::new( + HeadlessAppState { + session: server_ssh, + fs: remote_fs.clone(), + http_client: remote_http_client, + node_runtime: node, + languages, + extension_host_proxy: Arc::new(ExtensionHostProxy::new()), + }, + true, + cx, + ) + }); + + let client_ssh = RemoteClient::fake_client(opts, cx_a).await; + let (project_a, worktree_id_a) = client_a + .build_ssh_project(path!("/projects/project_a"), client_ssh.clone(), true, cx_a) + .await; + + cx_a.update(|cx| { + release_channel::init(semver::Version::new(0, 0, 0), cx); + + SettingsStore::update_global(cx, |store, cx| { + store.update_user_settings(cx, |settings| { + let language_settings = &mut settings.project.all_languages.defaults; + language_settings.inlay_hints = Some(InlayHintSettingsContent { + enabled: Some(true), + ..InlayHintSettingsContent::default() + }) + }); + }); + }); + + project_a + .update(cx_a, |project, cx| { + project.languages().add(rust_lang()); + project.languages().register_fake_lsp_adapter( + "Rust", + FakeLspAdapter { + name: server_name, + capabilities, + ..FakeLspAdapter::default() + }, + ); + project.find_or_create_worktree(path!("/projects/project_b"), true, cx) + }) + .await + .unwrap(); + + cx_a.run_until_parked(); + + let worktree_ids = project_a.read_with(cx_a, |project, cx| { + project + .worktrees(cx) + .map(|wt| wt.read(cx).id()) + .collect::>() + }); + assert_eq!(worktree_ids.len(), 2); + + let remote_host = project_a.read_with(cx_a, |project, cx| { + project + .remote_connection_options(cx) + .map(RemoteHostLocation::from) + }); + + let trusted_worktrees = + cx_a.update(|cx| TrustedWorktrees::try_get_global(cx).expect("trust global should exist")); + + let can_trust_a = + trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_b = + trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[1], cx)); + assert!(!can_trust_a, "project_a should be restricted initially"); + assert!(!can_trust_b, "project_b should be restricted initially"); + + let worktree_store = project_a.read_with(cx_a, |project, _| project.worktree_store()); + let has_restricted = trusted_worktrees.read_with(cx_a, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!(has_restricted, "should have restricted worktrees"); + + let buffer_before_approval = project_a + .update(cx_a, |project, cx| { + project.open_buffer((worktree_id_a, rel_path("main.rs")), cx) + }) + .await + .unwrap(); + + let (editor, cx_a) = cx_a.add_window_view(|window, cx| { + Editor::new( + EditorMode::full(), + cx.new(|cx| MultiBuffer::singleton(buffer_before_approval.clone(), cx)), + Some(project_a.clone()), + window, + cx, + ) + }); + cx_a.run_until_parked(); + let fake_language_server = fake_language_servers.next(); + + cx_a.read(|cx| { + let file = buffer_before_approval.read(cx).file(); + assert_eq!( + language_settings(Some("Rust".into()), file, cx).language_servers, + ["...".to_string()], + "remote .zed/settings.json must not sync before trust approval" + ) + }); + + editor.update_in(cx_a, |editor, window, cx| { + editor.handle_input("1", window, cx); + }); + cx_a.run_until_parked(); + cx_a.executor().advance_clock(Duration::from_secs(1)); + assert_eq!( + lsp_inlay_hint_request_count.load(Ordering::Acquire), + 0, + "inlay hints must not be queried before trust approval" + ); + + trusted_worktrees.update(cx_a, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_ids[0])]), + remote_host.clone(), + cx, + ); + }); + cx_a.run_until_parked(); + + cx_a.read(|cx| { + let file = buffer_before_approval.read(cx).file(); + assert_eq!( + language_settings(Some("Rust".into()), file, cx).language_servers, + ["override-rust-analyzer".to_string()], + "remote .zed/settings.json should sync after trust approval" + ) + }); + let _fake_language_server = fake_language_server.await.unwrap(); + editor.update_in(cx_a, |editor, window, cx| { + editor.handle_input("1", window, cx); + }); + cx_a.run_until_parked(); + cx_a.executor().advance_clock(Duration::from_secs(1)); + assert!( + lsp_inlay_hint_request_count.load(Ordering::Acquire) > 0, + "inlay hints should be queried after trust approval" + ); + + let can_trust_a = + trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_b = + trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[1], cx)); + assert!(can_trust_a, "project_a should be trusted after trust()"); + assert!(!can_trust_b, "project_b should still be restricted"); + + trusted_worktrees.update(cx_a, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_ids[1])]), + remote_host.clone(), + cx, + ); + }); + + let can_trust_a = + trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_b = + trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[1], cx)); + assert!(can_trust_a, "project_a should remain trusted"); + assert!(can_trust_b, "project_b should now be trusted"); + + let has_restricted_after = trusted_worktrees.read_with(cx_a, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!( + !has_restricted_after, + "should have no restricted worktrees after trusting both" + ); +} diff --git a/crates/collab/src/tests/test_server.rs b/crates/collab/src/tests/test_server.rs index 959d54cf0864ccddf7273cca0276d18d4f59308b..3abbd1a014b556db02e70b42c239729100f17eb8 100644 --- a/crates/collab/src/tests/test_server.rs +++ b/crates/collab/src/tests/test_server.rs @@ -761,6 +761,7 @@ impl TestClient { &self, root_path: impl AsRef, ssh: Entity, + init_worktree_trust: bool, cx: &mut TestAppContext, ) -> (Entity, WorktreeId) { let project = cx.update(|cx| { @@ -771,6 +772,7 @@ impl TestClient { self.app_state.user_store.clone(), self.app_state.languages.clone(), self.app_state.fs.clone(), + init_worktree_trust, cx, ) }); @@ -839,6 +841,7 @@ impl TestClient { self.app_state.languages.clone(), self.app_state.fs.clone(), None, + false, cx, ) }) diff --git a/crates/edit_prediction_cli/src/headless.rs b/crates/edit_prediction_cli/src/headless.rs index 2deb96fdbf19a94c5649d87a7bf2f5fea0b601c2..489e78d364d0fdbb08b93eab89fd5f91f345f68e 100644 --- a/crates/edit_prediction_cli/src/headless.rs +++ b/crates/edit_prediction_cli/src/headless.rs @@ -8,8 +8,7 @@ use gpui_tokio::Tokio; use language::LanguageRegistry; use language_extension::LspAccess; use node_runtime::{NodeBinaryOptions, NodeRuntime}; -use project::Project; -use project::project_settings::ProjectSettings; +use project::{Project, project_settings::ProjectSettings}; use release_channel::{AppCommitSha, AppVersion}; use reqwest_client::ReqwestClient; use settings::{Settings, SettingsStore}; @@ -115,7 +114,7 @@ pub fn init(cx: &mut App) -> EpAppState { tx.send(Some(options)).log_err(); }) .detach(); - let node_runtime = NodeRuntime::new(client.http_client(), None, rx); + let node_runtime = NodeRuntime::new(client.http_client(), None, rx, None); let extension_host_proxy = ExtensionHostProxy::global(cx); diff --git a/crates/edit_prediction_cli/src/load_project.rs b/crates/edit_prediction_cli/src/load_project.rs index 38f114d726d3626fac89982b7f3a98c55e92ac07..70daf00b79486fd917556cffaa26b1fd01ed4d28 100644 --- a/crates/edit_prediction_cli/src/load_project.rs +++ b/crates/edit_prediction_cli/src/load_project.rs @@ -179,6 +179,7 @@ async fn setup_project( app_state.languages.clone(), app_state.fs.clone(), None, + false, cx, ) })?; diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 0fc91832dcaab8ed709739c74be01e51bb491e83..f379b2b4e014ae7f51b5d8ffd842112dba54279b 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -41,14 +41,16 @@ use multi_buffer::{ use parking_lot::Mutex; use pretty_assertions::{assert_eq, assert_ne}; use project::{ - FakeFs, + FakeFs, Project, debugger::breakpoint_store::{BreakpointState, SourceBreakpoint}, project_settings::LspSettings, + trusted_worktrees::{PathTrust, TrustedWorktrees}, }; use serde_json::{self, json}; use settings::{ AllLanguageSettingsContent, EditorSettingsContent, IndentGuideBackgroundColoring, - IndentGuideColoring, ProjectSettingsContent, SearchSettingsContent, + IndentGuideColoring, InlayHintSettingsContent, ProjectSettingsContent, SearchSettingsContent, + SettingsStore, }; use std::{cell::RefCell, future::Future, rc::Rc, sync::atomic::AtomicBool, time::Instant}; use std::{ @@ -29364,3 +29366,166 @@ async fn test_find_references_single_case(cx: &mut TestAppContext) { cx.assert_editor_state(after); } + +#[gpui::test] +async fn test_local_worktree_trust(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + + cx.update(|cx| { + SettingsStore::update_global(cx, |store, cx| { + store.update_user_settings(cx, |settings| { + settings.project.all_languages.defaults.inlay_hints = + Some(InlayHintSettingsContent { + enabled: Some(true), + ..InlayHintSettingsContent::default() + }); + }); + }); + }); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/project"), + json!({ + ".zed": { + "settings.json": r#"{"languages":{"Rust":{"language_servers":["override-rust-analyzer"]}}}"# + }, + "main.rs": "fn main() {}" + }), + ) + .await; + + let lsp_inlay_hint_request_count = Arc::new(AtomicUsize::new(0)); + let server_name = "override-rust-analyzer"; + let project = Project::test_with_worktree_trust(fs, [path!("/project").as_ref()], cx).await; + + let language_registry = project.read_with(cx, |project, _| project.languages().clone()); + language_registry.add(rust_lang()); + + let capabilities = lsp::ServerCapabilities { + inlay_hint_provider: Some(lsp::OneOf::Left(true)), + ..lsp::ServerCapabilities::default() + }; + let mut fake_language_servers = language_registry.register_fake_lsp( + "Rust", + FakeLspAdapter { + name: server_name, + capabilities, + initializer: Some(Box::new({ + let lsp_inlay_hint_request_count = lsp_inlay_hint_request_count.clone(); + move |fake_server| { + let lsp_inlay_hint_request_count = lsp_inlay_hint_request_count.clone(); + fake_server.set_request_handler::( + move |_params, _| { + lsp_inlay_hint_request_count.fetch_add(1, atomic::Ordering::Release); + async move { + Ok(Some(vec![lsp::InlayHint { + position: lsp::Position::new(0, 0), + label: lsp::InlayHintLabel::String("hint".to_string()), + kind: None, + text_edits: None, + tooltip: None, + padding_left: None, + padding_right: None, + data: None, + }])) + } + }, + ); + } + })), + ..FakeLspAdapter::default() + }, + ); + + cx.run_until_parked(); + + let worktree_id = project.read_with(cx, |project, cx| { + project + .worktrees(cx) + .next() + .map(|wt| wt.read(cx).id()) + .expect("should have a worktree") + }); + + let trusted_worktrees = + cx.update(|cx| TrustedWorktrees::try_get_global(cx).expect("trust global should exist")); + + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust, "worktree should be restricted initially"); + + let buffer_before_approval = project + .update(cx, |project, cx| { + project.open_buffer((worktree_id, rel_path("main.rs")), cx) + }) + .await + .unwrap(); + + let (editor, cx) = cx.add_window_view(|window, cx| { + Editor::new( + EditorMode::full(), + cx.new(|cx| MultiBuffer::singleton(buffer_before_approval.clone(), cx)), + Some(project.clone()), + window, + cx, + ) + }); + cx.run_until_parked(); + let fake_language_server = fake_language_servers.next(); + + cx.read(|cx| { + let file = buffer_before_approval.read(cx).file(); + assert_eq!( + language::language_settings::language_settings(Some("Rust".into()), file, cx) + .language_servers, + ["...".to_string()], + "local .zed/settings.json must not apply before trust approval" + ) + }); + + editor.update_in(cx, |editor, window, cx| { + editor.handle_input("1", window, cx); + }); + cx.run_until_parked(); + cx.executor() + .advance_clock(std::time::Duration::from_secs(1)); + assert_eq!( + lsp_inlay_hint_request_count.load(atomic::Ordering::Acquire), + 0, + "inlay hints must not be queried before trust approval" + ); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + std::collections::HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + cx.run_until_parked(); + + cx.read(|cx| { + let file = buffer_before_approval.read(cx).file(); + assert_eq!( + language::language_settings::language_settings(Some("Rust".into()), file, cx) + .language_servers, + ["override-rust-analyzer".to_string()], + "local .zed/settings.json should apply after trust approval" + ) + }); + let _fake_language_server = fake_language_server.await.unwrap(); + editor.update_in(cx, |editor, window, cx| { + editor.handle_input("1", window, cx); + }); + cx.run_until_parked(); + cx.executor() + .advance_clock(std::time::Duration::from_secs(1)); + assert!( + lsp_inlay_hint_request_count.load(atomic::Ordering::Acquire) > 0, + "inlay hints should be queried after trust approval" + ); + + let can_trust_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(can_trust_after, "worktree should be trusted after trust()"); +} diff --git a/crates/eval/src/eval.rs b/crates/eval/src/eval.rs index 80633696b7d5e655bb7db3627568b881642cf62c..3a2891922c80b95c85f0daed25603bea14b41842 100644 --- a/crates/eval/src/eval.rs +++ b/crates/eval/src/eval.rs @@ -422,7 +422,7 @@ pub fn init(cx: &mut App) -> Arc { tx.send(Some(options)).log_err(); }) .detach(); - let node_runtime = NodeRuntime::new(client.http_client(), None, rx); + let node_runtime = NodeRuntime::new(client.http_client(), None, rx, None); let extension_host_proxy = ExtensionHostProxy::global(cx); debug_adapter_extension::init(extension_host_proxy.clone(), cx); diff --git a/crates/eval/src/instance.rs b/crates/eval/src/instance.rs index 4c71a5a82b3946a9cc6e22ced378ebaabeec5256..8c9da3eefab61e4fa5897f9d76123c3fe1d5fa8b 100644 --- a/crates/eval/src/instance.rs +++ b/crates/eval/src/instance.rs @@ -202,6 +202,7 @@ impl ExampleInstance { app_state.languages.clone(), app_state.fs.clone(), None, + false, cx, ); diff --git a/crates/git_ui/src/worktree_picker.rs b/crates/git_ui/src/worktree_picker.rs index f6b3e47dec386d906e55e555600a93059d0766d0..875ae55eefae19e24aa26fe75f80d70f8316c82b 100644 --- a/crates/git_ui/src/worktree_picker.rs +++ b/crates/git_ui/src/worktree_picker.rs @@ -421,6 +421,7 @@ async fn open_remote_worktree( app_state.user_store.clone(), app_state.languages.clone(), app_state.fs.clone(), + true, cx, ) })?; diff --git a/crates/inspector_ui/src/inspector.rs b/crates/inspector_ui/src/inspector.rs index 7f7985df9b98ee286c79e18a665802b1f73fbc1e..a82d27b6d015bef97b50983e05f3e2096a1ef8c7 100644 --- a/crates/inspector_ui/src/inspector.rs +++ b/crates/inspector_ui/src/inspector.rs @@ -33,6 +33,7 @@ pub fn init(app_state: Arc, cx: &mut App) { app_state.languages.clone(), app_state.fs.clone(), None, + false, cx, ); diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs index 1eb6714500446dbfd2967ed4aa2f514a5f427aba..322117cd717cac5c604ba215a2a1c7e0f7d87f06 100644 --- a/crates/node_runtime/src/node_runtime.rs +++ b/crates/node_runtime/src/node_runtime.rs @@ -9,6 +9,8 @@ use serde::Deserialize; use smol::io::BufReader; use smol::{fs, lock::Mutex}; use std::fmt::Display; +use std::future::Future; +use std::pin::Pin; use std::{ env::{self, consts}, ffi::OsString, @@ -46,6 +48,7 @@ struct NodeRuntimeState { last_options: Option, options: watch::Receiver>, shell_env_loaded: Shared>, + trust_task: Option + Send>>>, } impl NodeRuntime { @@ -53,9 +56,11 @@ impl NodeRuntime { http: Arc, shell_env_loaded: Option>, options: watch::Receiver>, + trust_task: Option + Send>>>, ) -> Self { NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState { http, + trust_task, instance: None, last_options: None, options, @@ -70,11 +75,15 @@ impl NodeRuntime { last_options: None, options: watch::channel(Some(NodeBinaryOptions::default())).1, shell_env_loaded: oneshot::channel().1.shared(), + trust_task: None, }))) } async fn instance(&self) -> Box { let mut state = self.0.lock().await; + if let Some(trust_task) = state.trust_task.take() { + trust_task.await; + } let options = loop { if let Some(options) = state.options.borrow().as_ref() { diff --git a/crates/onboarding/src/basics_page.rs b/crates/onboarding/src/basics_page.rs index ab5d578f7de731aff6be355b4d7ddb2c6cf95d57..b5a2f5de365b581b95cb60269918068345474880 100644 --- a/crates/onboarding/src/basics_page.rs +++ b/crates/onboarding/src/basics_page.rs @@ -3,6 +3,7 @@ use std::sync::Arc; use client::TelemetrySettings; use fs::Fs; use gpui::{Action, App, IntoElement}; +use project::project_settings::ProjectSettings; use settings::{BaseKeymap, Settings, update_settings_file}; use theme::{ Appearance, SystemAppearance, ThemeAppearanceMode, ThemeName, ThemeRegistry, ThemeSelection, @@ -10,8 +11,8 @@ use theme::{ }; use ui::{ Divider, ParentElement as _, StatefulInteractiveElement, SwitchField, TintColor, - ToggleButtonGroup, ToggleButtonGroupSize, ToggleButtonSimple, ToggleButtonWithIcon, prelude::*, - rems_from_px, + ToggleButtonGroup, ToggleButtonGroupSize, ToggleButtonSimple, ToggleButtonWithIcon, Tooltip, + prelude::*, rems_from_px, }; use vim_mode_setting::VimModeSetting; @@ -409,6 +410,48 @@ fn render_vim_mode_switch(tab_index: &mut isize, cx: &mut App) -> impl IntoEleme }) } +fn render_worktree_auto_trust_switch(tab_index: &mut isize, cx: &mut App) -> impl IntoElement { + let toggle_state = if ProjectSettings::get_global(cx).session.trust_all_worktrees { + ui::ToggleState::Selected + } else { + ui::ToggleState::Unselected + }; + + let tooltip_description = "Zed can only allow services like language servers, project settings, and MCP servers to run after you mark a new project as trusted."; + + SwitchField::new( + "onboarding-auto-trust-worktrees", + Some("Trust All Projects By Default"), + Some("Automatically mark all new projects as trusted to unlock all Zed's features".into()), + toggle_state, + { + let fs = ::global(cx); + move |&selection, _, cx| { + let trust = match selection { + ToggleState::Selected => true, + ToggleState::Unselected => false, + ToggleState::Indeterminate => { + return; + } + }; + update_settings_file(fs.clone(), cx, move |setting, _| { + setting.session.get_or_insert_default().trust_all_worktrees = Some(trust); + }); + + telemetry::event!( + "Welcome Page Worktree Auto Trust Toggled", + options = if trust { "on" } else { "off" } + ); + } + }, + ) + .tab_index({ + *tab_index += 1; + *tab_index - 1 + }) + .tooltip(Tooltip::text(tooltip_description)) +} + fn render_setting_import_button( tab_index: isize, label: SharedString, @@ -481,6 +524,7 @@ pub(crate) fn render_basics_page(cx: &mut App) -> impl IntoElement { .child(render_base_keymap_section(&mut tab_index, cx)) .child(render_import_settings_section(&mut tab_index, cx)) .child(render_vim_mode_switch(&mut tab_index, cx)) + .child(render_worktree_auto_trust_switch(&mut tab_index, cx)) .child(Divider::horizontal().color(ui::DividerColor::BorderVariant)) .child(render_telemetry_section(&mut tab_index, cx)) } diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml index 9e2789fc109b8217f0f1033cc6d4832105c0ad48..b589af2d50c77b68da6d94334904505f104b37e8 100644 --- a/crates/project/Cargo.toml +++ b/crates/project/Cargo.toml @@ -40,6 +40,7 @@ clock.workspace = true collections.workspace = true context_server.workspace = true dap.workspace = true +db.workspace = true extension.workspace = true fancy-regex.workspace = true fs.workspace = true @@ -96,6 +97,7 @@ tracing.workspace = true [dev-dependencies] client = { workspace = true, features = ["test-support"] } +db = { workspace = true, features = ["test-support"] } collections = { workspace = true, features = ["test-support"] } context_server = { workspace = true, features = ["test-support"] } buffer_diff = { workspace = true, features = ["test-support"] } diff --git a/crates/project/src/context_server_store.rs b/crates/project/src/context_server_store.rs index 7ba46a46872ba57c758baccf9f67b0039818ee75..7d060db887b1b5d07dd4d6de9ca85297adfd0c6f 100644 --- a/crates/project/src/context_server_store.rs +++ b/crates/project/src/context_server_store.rs @@ -15,6 +15,7 @@ use util::{ResultExt as _, rel_path::RelPath}; use crate::{ Project, project_settings::{ContextServerSettings, ProjectSettings}, + trusted_worktrees::wait_for_workspace_trust, worktree_store::WorktreeStore, }; @@ -332,6 +333,15 @@ impl ContextServerStore { pub fn start_server(&mut self, server: Arc, cx: &mut Context) { cx.spawn(async move |this, cx| { + let wait_task = this.update(cx, |context_server_store, cx| { + context_server_store.project.update(cx, |project, cx| { + let remote_host = project.remote_connection_options(cx); + wait_for_workspace_trust(remote_host, "context servers", cx) + }) + })??; + if let Some(wait_task) = wait_task { + wait_task.await; + } let this = this.upgrade().context("Context server store dropped")?; let settings = this .update(cx, |this, _| { @@ -572,6 +582,15 @@ impl ContextServerStore { } async fn maintain_servers(this: WeakEntity, cx: &mut AsyncApp) -> Result<()> { + let wait_task = this.update(cx, |context_server_store, cx| { + context_server_store.project.update(cx, |project, cx| { + let remote_host = project.remote_connection_options(cx); + wait_for_workspace_trust(remote_host, "context servers", cx) + }) + })??; + if let Some(wait_task) = wait_task { + wait_task.await; + } let (mut configured_servers, registry, worktree_store) = this.update(cx, |this, _| { ( this.context_server_settings.clone(), diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index b107be8b9ff32ef078d92700b46210a3c35c2845..2ea3dbf70fcb4359f3f5985cc6cd3bb4db7df009 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -38,6 +38,7 @@ use crate::{ prettier_store::{self, PrettierStore, PrettierStoreEvent}, project_settings::{LspSettings, ProjectSettings}, toolchain_store::{LocalToolchainStore, ToolchainStoreEvent}, + trusted_worktrees::{PathTrust, TrustedWorktrees, TrustedWorktreesEvent}, worktree_store::{WorktreeStore, WorktreeStoreEvent}, yarn::YarnPathStore, }; @@ -54,8 +55,8 @@ use futures::{ }; use globset::{Glob, GlobBuilder, GlobMatcher, GlobSet, GlobSetBuilder}; use gpui::{ - App, AppContext, AsyncApp, Context, Entity, EventEmitter, PromptLevel, SharedString, Task, - WeakEntity, + App, AppContext, AsyncApp, Context, Entity, EventEmitter, PromptLevel, SharedString, + Subscription, Task, WeakEntity, }; use http_client::HttpClient; use itertools::Itertools as _; @@ -96,13 +97,14 @@ use serde::Serialize; use serde_json::Value; use settings::{Settings, SettingsLocation, SettingsStore}; use sha2::{Digest, Sha256}; -use smol::channel::Sender; +use smol::channel::{Receiver, Sender}; use snippet::Snippet; use std::{ any::TypeId, borrow::Cow, cell::RefCell, cmp::{Ordering, Reverse}, + collections::hash_map, convert::TryInto, ffi::OsStr, future::ready, @@ -296,6 +298,7 @@ pub struct LocalLspStore { LanguageServerId, HashMap, HashMap>>, >, + restricted_worktrees_tasks: HashMap)>, } impl LocalLspStore { @@ -367,7 +370,8 @@ impl LocalLspStore { ) -> LanguageServerId { let worktree = worktree_handle.read(cx); - let root_path = worktree.abs_path(); + let worktree_id = worktree.id(); + let worktree_abs_path = worktree.abs_path(); let toolchain = key.toolchain.clone(); let override_options = settings.initialization_options.clone(); @@ -375,19 +379,49 @@ impl LocalLspStore { let server_id = self.languages.next_language_server_id(); log::trace!( - "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}", + "attempting to start language server {:?}, path: {worktree_abs_path:?}, id: {server_id}", adapter.name.0 ); + let untrusted_worktree_task = + TrustedWorktrees::try_get_global(cx).and_then(|trusted_worktrees| { + let can_trust = trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust(worktree_id, cx) + }); + if can_trust { + self.restricted_worktrees_tasks.remove(&worktree_id); + None + } else { + match self.restricted_worktrees_tasks.entry(worktree_id) { + hash_map::Entry::Occupied(o) => Some(o.get().1.clone()), + hash_map::Entry::Vacant(v) => { + let (tx, rx) = smol::channel::bounded::<()>(1); + let subscription = cx.subscribe(&trusted_worktrees, move |_, e, _| { + if let TrustedWorktreesEvent::Trusted(_, trusted_paths) = e { + if trusted_paths.contains(&PathTrust::Worktree(worktree_id)) { + tx.send_blocking(()).ok(); + } + } + }); + v.insert((subscription, rx.clone())); + Some(rx) + } + } + } + }); + let update_binary_status = untrusted_worktree_task.is_none(); + let binary = self.get_language_server_binary( + worktree_abs_path.clone(), adapter.clone(), settings, toolchain.clone(), delegate.clone(), true, + untrusted_worktree_task, cx, ); - let pending_workspace_folders: Arc>> = Default::default(); + let pending_workspace_folders = Arc::>>::default(); let pending_server = cx.spawn({ let adapter = adapter.clone(); @@ -420,7 +454,7 @@ impl LocalLspStore { server_id, server_name, binary, - &root_path, + &worktree_abs_path, code_action_kinds, Some(pending_workspace_folders), cx, @@ -556,8 +590,10 @@ impl LocalLspStore { pending_workspace_folders, }; - self.languages - .update_lsp_binary_status(adapter.name(), BinaryStatus::Starting); + if update_binary_status { + self.languages + .update_lsp_binary_status(adapter.name(), BinaryStatus::Starting); + } self.language_servers.insert(server_id, state); self.language_server_ids @@ -571,19 +607,34 @@ impl LocalLspStore { fn get_language_server_binary( &self, + worktree_abs_path: Arc, adapter: Arc, settings: Arc, toolchain: Option, delegate: Arc, allow_binary_download: bool, + untrusted_worktree_task: Option>, cx: &mut App, ) -> Task> { if let Some(settings) = &settings.binary && let Some(path) = settings.path.as_ref().map(PathBuf::from) { let settings = settings.clone(); - + let languages = self.languages.clone(); return cx.background_spawn(async move { + if let Some(untrusted_worktree_task) = untrusted_worktree_task { + log::info!( + "Waiting for worktree {worktree_abs_path:?} to be trusted, before starting language server {}", + adapter.name(), + ); + untrusted_worktree_task.recv().await.ok(); + log::info!( + "Worktree {worktree_abs_path:?} is trusted, starting language server {}", + adapter.name(), + ); + languages + .update_lsp_binary_status(adapter.name(), BinaryStatus::Starting); + } let mut env = delegate.shell_env().await; env.extend(settings.env.unwrap_or_default()); @@ -614,6 +665,18 @@ impl LocalLspStore { }; cx.spawn(async move |cx| { + if let Some(untrusted_worktree_task) = untrusted_worktree_task { + log::info!( + "Waiting for worktree {worktree_abs_path:?} to be trusted, before starting language server {}", + adapter.name(), + ); + untrusted_worktree_task.recv().await.ok(); + log::info!( + "Worktree {worktree_abs_path:?} is trusted, starting language server {}", + adapter.name(), + ); + } + let (existing_binary, maybe_download_binary) = adapter .clone() .get_language_server_command(delegate.clone(), toolchain, lsp_binary_options, cx) @@ -3258,6 +3321,7 @@ impl LocalLspStore { id_to_remove: WorktreeId, cx: &mut Context, ) -> Vec { + self.restricted_worktrees_tasks.remove(&id_to_remove); self.diagnostics.remove(&id_to_remove); self.prettier_store.update(cx, |prettier_store, cx| { prettier_store.remove_worktree(id_to_remove, cx); @@ -3974,6 +4038,7 @@ impl LspStore { buffers_opened_in_servers: HashMap::default(), buffer_pull_diagnostics_result_ids: HashMap::default(), workspace_pull_diagnostics_result_ids: HashMap::default(), + restricted_worktrees_tasks: HashMap::default(), watched_manifest_filenames: ManifestProvidersStore::global(cx) .manifest_file_names(), }), diff --git a/crates/project/src/persistence.rs b/crates/project/src/persistence.rs new file mode 100644 index 0000000000000000000000000000000000000000..be844c58384aa001fdbffa5fbac5dc513e98c535 --- /dev/null +++ b/crates/project/src/persistence.rs @@ -0,0 +1,411 @@ +use collections::{HashMap, HashSet}; +use gpui::{App, Entity, SharedString}; +use std::path::PathBuf; + +use db::{ + query, + sqlez::{domain::Domain, thread_safe_connection::ThreadSafeConnection}, + sqlez_macros::sql, +}; + +use crate::{ + trusted_worktrees::{PathTrust, RemoteHostLocation, find_worktree_in_store}, + worktree_store::WorktreeStore, +}; + +// https://www.sqlite.org/limits.html +// > <..> the maximum value of a host parameter number is SQLITE_MAX_VARIABLE_NUMBER, +// > which defaults to <..> 32766 for SQLite versions after 3.32.0. +#[allow(unused)] +const MAX_QUERY_PLACEHOLDERS: usize = 32000; + +#[allow(unused)] +pub struct ProjectDb(ThreadSafeConnection); + +impl Domain for ProjectDb { + const NAME: &str = stringify!(ProjectDb); + + const MIGRATIONS: &[&str] = &[sql!( + CREATE TABLE IF NOT EXISTS trusted_worktrees ( + trust_id INTEGER PRIMARY KEY AUTOINCREMENT, + absolute_path TEXT, + user_name TEXT, + host_name TEXT + ) STRICT; + )]; +} + +db::static_connection!(PROJECT_DB, ProjectDb, []); + +impl ProjectDb { + pub(crate) async fn save_trusted_worktrees( + &self, + trusted_worktrees: HashMap, HashSet>, + trusted_workspaces: HashSet>, + ) -> anyhow::Result<()> { + use anyhow::Context as _; + use db::sqlez::statement::Statement; + use itertools::Itertools as _; + + PROJECT_DB + .clear_trusted_worktrees() + .await + .context("clearing previous trust state")?; + + let trusted_worktrees = trusted_worktrees + .into_iter() + .flat_map(|(host, abs_paths)| { + abs_paths + .into_iter() + .map(move |abs_path| (Some(abs_path), host.clone())) + }) + .chain(trusted_workspaces.into_iter().map(|host| (None, host))) + .collect::>(); + let mut first_worktree; + let mut last_worktree = 0_usize; + for (count, placeholders) in std::iter::once("(?, ?, ?)") + .cycle() + .take(trusted_worktrees.len()) + .chunks(MAX_QUERY_PLACEHOLDERS / 3) + .into_iter() + .map(|chunk| { + let mut count = 0; + let placeholders = chunk + .inspect(|_| { + count += 1; + }) + .join(", "); + (count, placeholders) + }) + .collect::>() + { + first_worktree = last_worktree; + last_worktree = last_worktree + count; + let query = format!( + r#"INSERT INTO trusted_worktrees(absolute_path, user_name, host_name) +VALUES {placeholders};"# + ); + + let trusted_worktrees = trusted_worktrees[first_worktree..last_worktree].to_vec(); + self.write(move |conn| { + let mut statement = Statement::prepare(conn, query)?; + let mut next_index = 1; + for (abs_path, host) in trusted_worktrees { + let abs_path = abs_path.as_ref().map(|abs_path| abs_path.to_string_lossy()); + next_index = statement.bind( + &abs_path.as_ref().map(|abs_path| abs_path.as_ref()), + next_index, + )?; + next_index = statement.bind( + &host + .as_ref() + .and_then(|host| Some(host.user_name.as_ref()?.as_str())), + next_index, + )?; + next_index = statement.bind( + &host.as_ref().map(|host| host.host_identifier.as_str()), + next_index, + )?; + } + statement.exec() + }) + .await + .context("inserting new trusted state")?; + } + Ok(()) + } + + pub(crate) fn fetch_trusted_worktrees( + &self, + worktree_store: Option>, + host: Option, + cx: &App, + ) -> anyhow::Result, HashSet>> { + let trusted_worktrees = PROJECT_DB.trusted_worktrees()?; + Ok(trusted_worktrees + .into_iter() + .map(|(abs_path, user_name, host_name)| { + let db_host = match (user_name, host_name) { + (_, None) => None, + (None, Some(host_name)) => Some(RemoteHostLocation { + user_name: None, + host_identifier: SharedString::new(host_name), + }), + (Some(user_name), Some(host_name)) => Some(RemoteHostLocation { + user_name: Some(SharedString::new(user_name)), + host_identifier: SharedString::new(host_name), + }), + }; + + match abs_path { + Some(abs_path) => { + if db_host != host { + (db_host, PathTrust::AbsPath(abs_path)) + } else if let Some(worktree_store) = &worktree_store { + find_worktree_in_store(worktree_store.read(cx), &abs_path, cx) + .map(PathTrust::Worktree) + .map(|trusted_worktree| (host.clone(), trusted_worktree)) + .unwrap_or_else(|| (db_host.clone(), PathTrust::AbsPath(abs_path))) + } else { + (db_host, PathTrust::AbsPath(abs_path)) + } + } + None => (db_host, PathTrust::Workspace), + } + }) + .fold(HashMap::default(), |mut acc, (remote_host, path_trust)| { + acc.entry(remote_host) + .or_insert_with(HashSet::default) + .insert(path_trust); + acc + })) + } + + query! { + fn trusted_worktrees() -> Result, Option, Option)>> { + SELECT absolute_path, user_name, host_name + FROM trusted_worktrees + } + } + + query! { + pub async fn clear_trusted_worktrees() -> Result<()> { + DELETE FROM trusted_worktrees + } + } +} + +#[cfg(test)] +mod tests { + use std::path::PathBuf; + + use collections::{HashMap, HashSet}; + use gpui::{SharedString, TestAppContext}; + use serde_json::json; + use settings::SettingsStore; + use smol::lock::Mutex; + use util::path; + + use crate::{ + FakeFs, Project, + persistence::PROJECT_DB, + trusted_worktrees::{PathTrust, RemoteHostLocation}, + }; + + static TEST_LOCK: Mutex<()> = Mutex::new(()); + + #[gpui::test] + async fn test_save_and_fetch_trusted_worktrees(cx: &mut TestAppContext) { + cx.executor().allow_parking(); + let _guard = TEST_LOCK.lock().await; + PROJECT_DB.clear_trusted_worktrees().await.unwrap(); + cx.update(|cx| { + if cx.try_global::().is_none() { + let settings = SettingsStore::test(cx); + cx.set_global(settings); + } + }); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/"), + json!({ + "project_a": { "main.rs": "" }, + "project_b": { "lib.rs": "" } + }), + ) + .await; + + let project = Project::test( + fs, + [path!("/project_a").as_ref(), path!("/project_b").as_ref()], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); + + let mut trusted_paths: HashMap, HashSet> = + HashMap::default(); + trusted_paths.insert( + None, + HashSet::from_iter([ + PathBuf::from(path!("/project_a")), + PathBuf::from(path!("/project_b")), + ]), + ); + + PROJECT_DB + .save_trusted_worktrees(trusted_paths, HashSet::default()) + .await + .unwrap(); + + let fetched = cx.update(|cx| { + PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) + }); + let fetched = fetched.unwrap(); + + let local_trust = fetched.get(&None).expect("should have local host entry"); + assert_eq!(local_trust.len(), 2); + assert!( + local_trust + .iter() + .all(|p| matches!(p, PathTrust::Worktree(_))) + ); + + let fetched_no_store = cx + .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) + .unwrap(); + let local_trust_no_store = fetched_no_store + .get(&None) + .expect("should have local host entry"); + assert_eq!(local_trust_no_store.len(), 2); + assert!( + local_trust_no_store + .iter() + .all(|p| matches!(p, PathTrust::AbsPath(_))) + ); + } + + #[gpui::test] + async fn test_save_and_fetch_workspace_trust(cx: &mut TestAppContext) { + cx.executor().allow_parking(); + let _guard = TEST_LOCK.lock().await; + PROJECT_DB.clear_trusted_worktrees().await.unwrap(); + cx.update(|cx| { + if cx.try_global::().is_none() { + let settings = SettingsStore::test(cx); + cx.set_global(settings); + } + }); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); + + let trusted_workspaces = HashSet::from_iter([None]); + PROJECT_DB + .save_trusted_worktrees(HashMap::default(), trusted_workspaces) + .await + .unwrap(); + + let fetched = cx.update(|cx| { + PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) + }); + let fetched = fetched.unwrap(); + + let local_trust = fetched.get(&None).expect("should have local host entry"); + assert!(local_trust.contains(&PathTrust::Workspace)); + + let fetched_no_store = cx + .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) + .unwrap(); + let local_trust_no_store = fetched_no_store + .get(&None) + .expect("should have local host entry"); + assert!(local_trust_no_store.contains(&PathTrust::Workspace)); + } + + #[gpui::test] + async fn test_save_and_fetch_remote_host_trust(cx: &mut TestAppContext) { + cx.executor().allow_parking(); + let _guard = TEST_LOCK.lock().await; + PROJECT_DB.clear_trusted_worktrees().await.unwrap(); + cx.update(|cx| { + if cx.try_global::().is_none() { + let settings = SettingsStore::test(cx); + cx.set_global(settings); + } + }); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); + + let remote_host = Some(RemoteHostLocation { + user_name: Some(SharedString::from("testuser")), + host_identifier: SharedString::from("remote.example.com"), + }); + + let mut trusted_paths: HashMap, HashSet> = + HashMap::default(); + trusted_paths.insert( + remote_host.clone(), + HashSet::from_iter([PathBuf::from("/home/testuser/project")]), + ); + + PROJECT_DB + .save_trusted_worktrees(trusted_paths, HashSet::default()) + .await + .unwrap(); + + let fetched = cx.update(|cx| { + PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) + }); + let fetched = fetched.unwrap(); + + let remote_trust = fetched + .get(&remote_host) + .expect("should have remote host entry"); + assert_eq!(remote_trust.len(), 1); + assert!(remote_trust + .iter() + .any(|p| matches!(p, PathTrust::AbsPath(path) if path == &PathBuf::from("/home/testuser/project")))); + + let fetched_no_store = cx + .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) + .unwrap(); + let remote_trust_no_store = fetched_no_store + .get(&remote_host) + .expect("should have remote host entry"); + assert_eq!(remote_trust_no_store.len(), 1); + assert!(remote_trust_no_store + .iter() + .any(|p| matches!(p, PathTrust::AbsPath(path) if path == &PathBuf::from("/home/testuser/project")))); + } + + #[gpui::test] + async fn test_clear_trusted_worktrees(cx: &mut TestAppContext) { + cx.executor().allow_parking(); + let _guard = TEST_LOCK.lock().await; + PROJECT_DB.clear_trusted_worktrees().await.unwrap(); + cx.update(|cx| { + if cx.try_global::().is_none() { + let settings = SettingsStore::test(cx); + cx.set_global(settings); + } + }); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); + + let trusted_workspaces = HashSet::from_iter([None]); + PROJECT_DB + .save_trusted_worktrees(HashMap::default(), trusted_workspaces) + .await + .unwrap(); + + PROJECT_DB.clear_trusted_worktrees().await.unwrap(); + + let fetched = cx.update(|cx| { + PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) + }); + let fetched = fetched.unwrap(); + + assert!(fetched.is_empty(), "should be empty after clear"); + + let fetched_no_store = cx + .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) + .unwrap(); + assert!(fetched_no_store.is_empty(), "should be empty after clear"); + } +} diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 7e7c1ecb67d2f463cb5b728cbb2a7f1ea2b072e0..79d37f0e99f35f5c059a98017f5036e95e18bf01 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -10,6 +10,7 @@ pub mod image_store; pub mod lsp_command; pub mod lsp_store; mod manifest_tree; +mod persistence; pub mod prettier_store; mod project_search; pub mod project_settings; @@ -19,6 +20,7 @@ pub mod task_store; pub mod telemetry_snapshot; pub mod terminals; pub mod toolchain_store; +pub mod trusted_worktrees; pub mod worktree_store; #[cfg(test)] @@ -39,6 +41,7 @@ use crate::{ git_store::GitStore, lsp_store::{SymbolLocation, log_store::LogKind}, project_search::SearchResultsHandle, + trusted_worktrees::{PathTrust, RemoteHostLocation, TrustedWorktrees}, }; pub use agent_server_store::{AgentServerStore, AgentServersUpdated, ExternalAgentServerName}; pub use git_store::{ @@ -1069,6 +1072,7 @@ impl Project { languages: Arc, fs: Arc, env: Option>, + init_worktree_trust: bool, cx: &mut App, ) -> Entity { cx.new(|cx: &mut Context| { @@ -1077,6 +1081,15 @@ impl Project { .detach(); let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx); let worktree_store = cx.new(|_| WorktreeStore::local(false, fs.clone())); + if init_worktree_trust { + trusted_worktrees::track_worktree_trust( + worktree_store.clone(), + None, + None, + None, + cx, + ); + } cx.subscribe(&worktree_store, Self::on_worktree_store_event) .detach(); @@ -1250,6 +1263,7 @@ impl Project { user_store: Entity, languages: Arc, fs: Arc, + init_worktree_trust: bool, cx: &mut App, ) -> Entity { cx.new(|cx: &mut Context| { @@ -1258,8 +1272,14 @@ impl Project { .detach(); let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx); - let (remote_proto, path_style) = - remote.read_with(cx, |remote, _| (remote.proto_client(), remote.path_style())); + let (remote_proto, path_style, connection_options) = + remote.read_with(cx, |remote, _| { + ( + remote.proto_client(), + remote.path_style(), + remote.connection_options(), + ) + }); let worktree_store = cx.new(|_| { WorktreeStore::remote( false, @@ -1268,8 +1288,23 @@ impl Project { path_style, ) }); + cx.subscribe(&worktree_store, Self::on_worktree_store_event) .detach(); + if init_worktree_trust { + match &connection_options { + RemoteConnectionOptions::Wsl(..) | RemoteConnectionOptions::Ssh(..) => { + trusted_worktrees::track_worktree_trust( + worktree_store.clone(), + Some(RemoteHostLocation::from(connection_options)), + None, + Some((remote_proto.clone(), REMOTE_SERVER_PROJECT_ID)), + cx, + ); + } + RemoteConnectionOptions::Docker(..) => {} + } + } let weak_self = cx.weak_entity(); let context_server_store = @@ -1450,6 +1485,9 @@ impl Project { remote_proto.add_entity_request_handler(Self::handle_language_server_prompt_request); remote_proto.add_entity_message_handler(Self::handle_hide_toast); remote_proto.add_entity_request_handler(Self::handle_update_buffer_from_remote_server); + remote_proto.add_entity_request_handler(Self::handle_trust_worktrees); + remote_proto.add_entity_request_handler(Self::handle_restrict_worktrees); + BufferStore::init(&remote_proto); LspStore::init(&remote_proto); SettingsObserver::init(&remote_proto); @@ -1810,6 +1848,7 @@ impl Project { Arc::new(languages), fs, None, + false, cx, ) }) @@ -1834,6 +1873,25 @@ impl Project { fs: Arc, root_paths: impl IntoIterator, cx: &mut gpui::TestAppContext, + ) -> Entity { + Self::test_project(fs, root_paths, false, cx).await + } + + #[cfg(any(test, feature = "test-support"))] + pub async fn test_with_worktree_trust( + fs: Arc, + root_paths: impl IntoIterator, + cx: &mut gpui::TestAppContext, + ) -> Entity { + Self::test_project(fs, root_paths, true, cx).await + } + + #[cfg(any(test, feature = "test-support"))] + async fn test_project( + fs: Arc, + root_paths: impl IntoIterator, + init_worktree_trust: bool, + cx: &mut gpui::TestAppContext, ) -> Entity { use clock::FakeSystemClock; @@ -1850,6 +1908,7 @@ impl Project { Arc::new(languages), fs, None, + init_worktree_trust, cx, ) }); @@ -4757,9 +4816,14 @@ impl Project { envelope: TypedEnvelope, mut cx: AsyncApp, ) -> Result<()> { - this.update(&mut cx, |this, cx| { + this.update(&mut cx, |project, cx| { let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id); - if let Some(worktree) = this.worktree_for_id(worktree_id, cx) { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust(worktree_id, cx) + }); + } + if let Some(worktree) = project.worktree_for_id(worktree_id, cx) { worktree.update(cx, |worktree, _| { let worktree = worktree.as_remote_mut().unwrap(); worktree.update_from_remote(envelope.payload); @@ -4786,6 +4850,61 @@ impl Project { BufferStore::handle_update_buffer(buffer_store, envelope, cx).await } + async fn handle_trust_worktrees( + this: Entity, + envelope: TypedEnvelope, + mut cx: AsyncApp, + ) -> Result { + let trusted_worktrees = cx + .update(|cx| TrustedWorktrees::try_get_global(cx))? + .context("missing trusted worktrees")?; + trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| { + let remote_host = this + .read(cx) + .remote_connection_options(cx) + .map(RemoteHostLocation::from); + trusted_worktrees.trust( + envelope + .payload + .trusted_paths + .into_iter() + .filter_map(|proto_path| PathTrust::from_proto(proto_path)) + .collect(), + remote_host, + cx, + ); + })?; + Ok(proto::Ack {}) + } + + async fn handle_restrict_worktrees( + this: Entity, + envelope: TypedEnvelope, + mut cx: AsyncApp, + ) -> Result { + let trusted_worktrees = cx + .update(|cx| TrustedWorktrees::try_get_global(cx))? + .context("missing trusted worktrees")?; + trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| { + let mut restricted_paths = envelope + .payload + .worktree_ids + .into_iter() + .map(WorktreeId::from_proto) + .map(PathTrust::Worktree) + .collect::>(); + if envelope.payload.restrict_workspace { + restricted_paths.insert(PathTrust::Workspace); + } + let remote_host = this + .read(cx) + .remote_connection_options(cx) + .map(RemoteHostLocation::from); + trusted_worktrees.restrict(restricted_paths, remote_host, cx); + })?; + Ok(proto::Ack {}) + } + async fn handle_update_buffer( this: Entity, envelope: TypedEnvelope, diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs index 8494eac5b33e7e1f231f9c62010c49aec345229f..6d95411681d5d350271e7071b752f27d0807f60d 100644 --- a/crates/project/src/project_settings.rs +++ b/crates/project/src/project_settings.rs @@ -23,13 +23,14 @@ use settings::{ DapSettingsContent, InvalidSettingsError, LocalSettingsKind, RegisterSetting, Settings, SettingsLocation, SettingsStore, parse_json_with_comments, watch_config_file, }; -use std::{path::PathBuf, sync::Arc, time::Duration}; +use std::{cell::OnceCell, collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration}; use task::{DebugTaskFile, TaskTemplates, VsCodeDebugTaskFile, VsCodeTaskFile}; use util::{ResultExt, rel_path::RelPath, serde::default_true}; use worktree::{PathChange, UpdatedEntriesSet, Worktree, WorktreeId}; use crate::{ task_store::{TaskSettingsLocation, TaskStore}, + trusted_worktrees::{PathTrust, TrustedWorktrees, TrustedWorktreesEvent}, worktree_store::{WorktreeStore, WorktreeStoreEvent}, }; @@ -83,6 +84,12 @@ pub struct SessionSettings { /// /// Default: true pub restore_unsaved_buffers: bool, + /// Whether or not to skip worktree trust checks. + /// When trusted, project settings are synchronized automatically, + /// language and MCP servers are downloaded and started automatically. + /// + /// Default: false + pub trust_all_worktrees: bool, } #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)] @@ -570,6 +577,7 @@ impl Settings for ProjectSettings { load_direnv: project.load_direnv.clone().unwrap(), session: SessionSettings { restore_unsaved_buffers: content.session.unwrap().restore_unsaved_buffers.unwrap(), + trust_all_worktrees: content.session.unwrap().trust_all_worktrees.unwrap(), }, } } @@ -595,6 +603,9 @@ pub struct SettingsObserver { worktree_store: Entity, project_id: u64, task_store: Entity, + pending_local_settings: + HashMap), Option>>, + _trusted_worktrees_watcher: Option, _user_settings_watcher: Option, _global_task_config_watcher: Task<()>, _global_debug_config_watcher: Task<()>, @@ -620,11 +631,61 @@ impl SettingsObserver { cx.subscribe(&worktree_store, Self::on_worktree_store_event) .detach(); + let _trusted_worktrees_watcher = + TrustedWorktrees::try_get_global(cx).map(|trusted_worktrees| { + cx.subscribe( + &trusted_worktrees, + move |settings_observer, _, e, cx| match e { + TrustedWorktreesEvent::Trusted(_, trusted_paths) => { + for trusted_path in trusted_paths { + if let Some(pending_local_settings) = settings_observer + .pending_local_settings + .remove(trusted_path) + { + for ((worktree_id, directory_path), settings_contents) in + pending_local_settings + { + apply_local_settings( + worktree_id, + &directory_path, + LocalSettingsKind::Settings, + &settings_contents, + cx, + ); + if let Some(downstream_client) = + &settings_observer.downstream_client + { + downstream_client + .send(proto::UpdateWorktreeSettings { + project_id: settings_observer.project_id, + worktree_id: worktree_id.to_proto(), + path: directory_path.to_proto(), + content: settings_contents, + kind: Some( + local_settings_kind_to_proto( + LocalSettingsKind::Settings, + ) + .into(), + ), + }) + .log_err(); + } + } + } + } + } + TrustedWorktreesEvent::Restricted(..) => {} + }, + ) + }); + Self { worktree_store, task_store, mode: SettingsObserverMode::Local(fs.clone()), downstream_client: None, + _trusted_worktrees_watcher, + pending_local_settings: HashMap::default(), _user_settings_watcher: None, project_id: REMOTE_SERVER_PROJECT_ID, _global_task_config_watcher: Self::subscribe_to_global_task_file_changes( @@ -677,6 +738,8 @@ impl SettingsObserver { mode: SettingsObserverMode::Remote, downstream_client: None, project_id: REMOTE_SERVER_PROJECT_ID, + _trusted_worktrees_watcher: None, + pending_local_settings: HashMap::default(), _user_settings_watcher: user_settings_watcher, _global_task_config_watcher: Self::subscribe_to_global_task_file_changes( fs.clone(), @@ -975,36 +1038,32 @@ impl SettingsObserver { let worktree_id = worktree.read(cx).id(); let remote_worktree_id = worktree.read(cx).id(); let task_store = self.task_store.clone(); - + let can_trust_worktree = OnceCell::new(); for (directory, kind, file_content) in settings_contents { + let mut applied = true; match kind { - LocalSettingsKind::Settings | LocalSettingsKind::Editorconfig => cx - .update_global::(|store, cx| { - let result = store.set_local_settings( - worktree_id, - directory.clone(), - kind, - file_content.as_deref(), - cx, - ); - - match result { - Err(InvalidSettingsError::LocalSettings { path, message }) => { - log::error!("Failed to set local settings in {path:?}: {message}"); - cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err( - InvalidSettingsError::LocalSettings { path, message }, - ))); - } - Err(e) => { - log::error!("Failed to set local settings: {e}"); - } - Ok(()) => { - cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(directory - .as_std_path() - .join(local_settings_file_relative_path().as_std_path())))); - } + LocalSettingsKind::Settings => { + if *can_trust_worktree.get_or_init(|| { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust(worktree_id, cx) + }) + } else { + true } - }), + }) { + apply_local_settings(worktree_id, &directory, kind, &file_content, cx) + } else { + applied = false; + self.pending_local_settings + .entry(PathTrust::Worktree(worktree_id)) + .or_default() + .insert((worktree_id, directory.clone()), file_content.clone()); + } + } + LocalSettingsKind::Editorconfig => { + apply_local_settings(worktree_id, &directory, kind, &file_content, cx) + } LocalSettingsKind::Tasks => { let result = task_store.update(cx, |task_store, cx| { task_store.update_user_tasks( @@ -1067,16 +1126,18 @@ impl SettingsObserver { } }; - if let Some(downstream_client) = &self.downstream_client { - downstream_client - .send(proto::UpdateWorktreeSettings { - project_id: self.project_id, - worktree_id: remote_worktree_id.to_proto(), - path: directory.to_proto(), - content: file_content.clone(), - kind: Some(local_settings_kind_to_proto(kind).into()), - }) - .log_err(); + if applied { + if let Some(downstream_client) = &self.downstream_client { + downstream_client + .send(proto::UpdateWorktreeSettings { + project_id: self.project_id, + worktree_id: remote_worktree_id.to_proto(), + path: directory.to_proto(), + content: file_content.clone(), + kind: Some(local_settings_kind_to_proto(kind).into()), + }) + .log_err(); + } } } } @@ -1193,6 +1254,37 @@ impl SettingsObserver { } } +fn apply_local_settings( + worktree_id: WorktreeId, + directory: &Arc, + kind: LocalSettingsKind, + file_content: &Option, + cx: &mut Context<'_, SettingsObserver>, +) { + cx.update_global::(|store, cx| { + let result = store.set_local_settings( + worktree_id, + directory.clone(), + kind, + file_content.as_deref(), + cx, + ); + + match result { + Err(InvalidSettingsError::LocalSettings { path, message }) => { + log::error!("Failed to set local settings in {path:?}: {message}"); + cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Err( + InvalidSettingsError::LocalSettings { path, message }, + ))); + } + Err(e) => log::error!("Failed to set local settings: {e}"), + Ok(()) => cx.emit(SettingsObserverEvent::LocalSettingsUpdated(Ok(directory + .as_std_path() + .join(local_settings_file_relative_path().as_std_path())))), + } + }) +} + pub fn local_settings_kind_from_proto(kind: proto::LocalSettingsKind) -> LocalSettingsKind { match kind { proto::LocalSettingsKind::Settings => LocalSettingsKind::Settings, diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rs new file mode 100644 index 0000000000000000000000000000000000000000..733e8d48294b863f8bf35cdb1ea458acd59dcadb --- /dev/null +++ b/crates/project/src/trusted_worktrees.rs @@ -0,0 +1,1933 @@ +//! A module, responsible for managing the trust logic in Zed. +//! +//! It deals with multiple hosts, distinguished by [`RemoteHostLocation`]. +//! Each [`crate::Project`] and `HeadlessProject` should call [`init_global`], if wants to establish the trust mechanism. +//! This will set up a [`gpui::Global`] with [`TrustedWorktrees`] entity that will persist, restore and allow querying for worktree trust. +//! It's also possible to subscribe on [`TrustedWorktreesEvent`] events of this entity to track trust changes dynamically. +//! +//! The implementation can synchronize trust information with the remote hosts: currently, WSL and SSH. +//! Docker and Collab remotes do not employ trust mechanism, as manage that themselves. +//! +//! Unless `trust_all_worktrees` auto trust is enabled, does not trust anything that was not persisted before. +//! When dealing with "restricted" and other related concepts in the API, it means all explicitly restricted, after any of the [`TrustedWorktreesStore::can_trust`] and [`TrustedWorktreesStore::can_trust_global`] calls. +//! +//! +//! +//! +//! Path rust hierarchy. +//! +//! Zed has multiple layers of trust, based on the requests and [`PathTrust`] enum variants. +//! From the least to the most trusted level: +//! +//! * "single file worktree" +//! +//! After opening an empty Zed it's possible to open just a file, same as after opening a directory in Zed it's possible to open a file outside of this directory. +//! Usual scenario for both cases is opening Zed's settings.json file via `zed: open settings file` command: that starts a language server for a new file open, which originates from a newly created, single file worktree. +//! +//! Spawning a language server is potentially dangerous, and Zed needs to restrict that by default. +//! Each single file worktree requires a separate trust permission, unless a more global level is trusted. +//! +//! * "workspace" +//! +//! Even an empty Zed instance with no files or directories open is potentially dangerous: opening an Assistant Panel and creating new external agent thread might require installing and running MCP servers. +//! +//! Disabling the entire panel is possible with ai-related settings. +//! Yet when it's enabled, it's still reasonably safe to use remote AI agents and control their permissions in the Assistant Panel. +//! +//! Unlike that, MCP servers are similar to language servers and may require fetching, installing and running packages or binaries. +//! Given that those servers are not tied to any particular worktree, this level of trust is required to operate any MCP server. +//! +//! Workspace level of trust assumes all single file worktrees are trusted too, for the same host: if we allow global MCP server-related functionality, we can already allow spawning language servers for single file worktrees as well. +//! +//! * "directory worktree" +//! +//! If a directory is open in Zed, it's a full worktree which may spawn multiple language servers associated with it. +//! Each such worktree requires a separate trust permission, so each separate directory worktree has to be trusted separately, unless a more global level is trusted. +//! +//! When a directory worktree is trusted and language servers are allowed to be downloaded and started, hence we also allow workspace level of trust (hence, "single file worktree" level of trust also). +//! +//! * "path override" +//! +//! To ease trusting multiple directory worktrees at once, it's possible to trust a parent directory of a certain directory worktree opened in Zed. +//! Trusting a directory means trusting all its subdirectories as well, including all current and potential directory worktrees. +//! +//! If we trust multiple projects to install and spawn various language server processes, we can also allow workspace trust requests for MCP servers installation and spawning. + +use collections::{HashMap, HashSet}; +use gpui::{ + App, AppContext as _, Context, Entity, EventEmitter, Global, SharedString, Task, WeakEntity, +}; +use remote::RemoteConnectionOptions; +use rpc::{AnyProtoClient, proto}; +use settings::{Settings as _, WorktreeId}; +use std::{ + path::{Path, PathBuf}, + sync::Arc, +}; +use util::debug_panic; + +use crate::{project_settings::ProjectSettings, worktree_store::WorktreeStore}; + +#[cfg(not(any(test, feature = "test-support")))] +use crate::persistence::PROJECT_DB; +#[cfg(not(any(test, feature = "test-support")))] +use util::ResultExt as _; + +pub fn init( + downstream_client: Option<(AnyProtoClient, u64)>, + upstream_client: Option<(AnyProtoClient, u64)>, + cx: &mut App, +) { + if TrustedWorktrees::try_get_global(cx).is_none() { + let trusted_worktrees = cx.new(|cx| { + TrustedWorktreesStore::new(None, None, downstream_client, upstream_client, cx) + }); + cx.set_global(TrustedWorktrees(trusted_worktrees)) + } +} + +/// An initialization call to set up trust global for a particular project (remote or local). +pub fn track_worktree_trust( + worktree_store: Entity, + remote_host: Option, + downstream_client: Option<(AnyProtoClient, u64)>, + upstream_client: Option<(AnyProtoClient, u64)>, + cx: &mut App, +) { + match TrustedWorktrees::try_get_global(cx) { + Some(trusted_worktrees) => { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + let sync_upstream = trusted_worktrees.upstream_client.as_ref().map(|(_, id)| id) + != upstream_client.as_ref().map(|(_, id)| id); + trusted_worktrees.downstream_client = downstream_client; + trusted_worktrees.upstream_client = upstream_client; + trusted_worktrees.add_worktree_store(worktree_store, remote_host, cx); + + if sync_upstream { + if let Some((upstream_client, upstream_project_id)) = + &trusted_worktrees.upstream_client + { + let trusted_paths = trusted_worktrees + .trusted_paths + .iter() + .flat_map(|(_, paths)| { + paths.iter().map(|trusted_path| trusted_path.to_proto()) + }) + .collect::>(); + if !trusted_paths.is_empty() { + upstream_client + .send(proto::TrustWorktrees { + project_id: *upstream_project_id, + trusted_paths, + }) + .ok(); + } + } + } + }); + } + None => { + let trusted_worktrees = cx.new(|cx| { + TrustedWorktreesStore::new( + Some(worktree_store.clone()), + remote_host, + downstream_client, + upstream_client, + cx, + ) + }); + cx.set_global(TrustedWorktrees(trusted_worktrees)) + } + } +} + +/// Waits until at least [`PathTrust::Workspace`] level of trust is granted for the host the [`TrustedWorktrees`] was initialized with. +pub fn wait_for_default_workspace_trust( + what_waits: &'static str, + cx: &mut App, +) -> Option> { + let trusted_worktrees = TrustedWorktrees::try_get_global(cx)?; + wait_for_workspace_trust( + trusted_worktrees.read(cx).remote_host.clone(), + what_waits, + cx, + ) +} + +/// Waits until at least [`PathTrust::Workspace`] level of trust is granted for a particular host. +pub fn wait_for_workspace_trust( + remote_host: Option>, + what_waits: &'static str, + cx: &mut App, +) -> Option> { + let trusted_worktrees = TrustedWorktrees::try_get_global(cx)?; + let remote_host = remote_host.map(|host| host.into()); + + let remote_host = if trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust_workspace(remote_host.clone(), cx) + }) { + None + } else { + Some(remote_host) + }?; + + Some(cx.spawn(async move |cx| { + log::info!("Waiting for workspace to be trusted before starting {what_waits}"); + let (tx, restricted_worktrees_task) = smol::channel::bounded::<()>(1); + let Ok(_subscription) = cx.update(|cx| { + cx.subscribe(&trusted_worktrees, move |_, e, _| { + if let TrustedWorktreesEvent::Trusted(trusted_host, trusted_paths) = e { + if trusted_host == &remote_host && trusted_paths.contains(&PathTrust::Workspace) + { + log::info!("Workspace is trusted for {what_waits}"); + tx.send_blocking(()).ok(); + } + } + }) + }) else { + return; + }; + + restricted_worktrees_task.recv().await.ok(); + })) +} + +/// A collection of worktree trust metadata, can be accessed globally (if initialized) and subscribed to. +pub struct TrustedWorktrees(Entity); + +impl Global for TrustedWorktrees {} + +impl TrustedWorktrees { + pub fn try_get_global(cx: &App) -> Option> { + cx.try_global::().map(|this| this.0.clone()) + } +} + +/// A collection of worktrees that are considered trusted and not trusted. +/// This can be used when checking for this criteria before enabling certain features. +/// +/// Emits an event each time the worktree was checked and found not trusted, +/// or a certain worktree had been trusted. +pub struct TrustedWorktreesStore { + downstream_client: Option<(AnyProtoClient, u64)>, + upstream_client: Option<(AnyProtoClient, u64)>, + worktree_stores: HashMap, Option>, + trusted_paths: HashMap, HashSet>, + #[cfg(not(any(test, feature = "test-support")))] + serialization_task: Task<()>, + restricted: HashSet, + remote_host: Option, + restricted_workspaces: HashSet>, +} + +/// An identifier of a host to split the trust questions by. +/// Each trusted data change and event is done for a particular host. +/// A host may contain more than one worktree or even project open concurrently. +#[derive(Debug, PartialEq, Eq, Clone, Hash)] +pub struct RemoteHostLocation { + pub user_name: Option, + pub host_identifier: SharedString, +} + +impl From for RemoteHostLocation { + fn from(options: RemoteConnectionOptions) -> Self { + let (user_name, host_name) = match options { + RemoteConnectionOptions::Ssh(ssh) => ( + ssh.username.map(SharedString::new), + SharedString::new(ssh.host), + ), + RemoteConnectionOptions::Wsl(wsl) => ( + wsl.user.map(SharedString::new), + SharedString::new(wsl.distro_name), + ), + RemoteConnectionOptions::Docker(docker_connection_options) => ( + Some(SharedString::new(docker_connection_options.name)), + SharedString::new(docker_connection_options.container_id), + ), + }; + RemoteHostLocation { + user_name, + host_identifier: host_name, + } + } +} + +/// A unit of trust consideration inside a particular host: +/// either a familiar worktree, or a path that may influence other worktrees' trust. +/// See module-level documentation on the trust model. +#[derive(Debug, PartialEq, Eq, Clone, Hash)] +pub enum PathTrust { + /// General, no worktrees or files open case. + /// E.g. MCP servers can be spawned from a blank Zed instance, but will do `npm i` and other potentially malicious actions. + Workspace, + /// A worktree that is familiar to this workspace. + /// Either a single file or a directory worktree. + Worktree(WorktreeId), + /// A path that may be another worktree yet not loaded into any workspace (hence, without any `WorktreeId`), + /// or a parent path coming out of the security modal. + AbsPath(PathBuf), +} + +impl PathTrust { + fn to_proto(&self) -> proto::PathTrust { + match self { + Self::Workspace => proto::PathTrust { + content: Some(proto::path_trust::Content::Workspace(0)), + }, + Self::Worktree(worktree_id) => proto::PathTrust { + content: Some(proto::path_trust::Content::WorktreeId( + worktree_id.to_proto(), + )), + }, + Self::AbsPath(path_buf) => proto::PathTrust { + content: Some(proto::path_trust::Content::AbsPath( + path_buf.to_string_lossy().to_string(), + )), + }, + } + } + + pub fn from_proto(proto: proto::PathTrust) -> Option { + Some(match proto.content? { + proto::path_trust::Content::WorktreeId(id) => { + Self::Worktree(WorktreeId::from_proto(id)) + } + proto::path_trust::Content::AbsPath(path) => Self::AbsPath(PathBuf::from(path)), + proto::path_trust::Content::Workspace(_) => Self::Workspace, + }) + } +} + +/// A change of trust on a certain host. +#[derive(Debug)] +pub enum TrustedWorktreesEvent { + Trusted(Option, HashSet), + Restricted(Option, HashSet), +} + +impl EventEmitter for TrustedWorktreesStore {} + +impl TrustedWorktreesStore { + fn new( + worktree_store: Option>, + remote_host: Option, + downstream_client: Option<(AnyProtoClient, u64)>, + upstream_client: Option<(AnyProtoClient, u64)>, + cx: &App, + ) -> Self { + #[cfg(any(test, feature = "test-support"))] + let _ = cx; + + #[cfg(not(any(test, feature = "test-support")))] + let trusted_paths = if downstream_client.is_none() { + match PROJECT_DB.fetch_trusted_worktrees( + worktree_store.clone(), + remote_host.clone(), + cx, + ) { + Ok(trusted_paths) => trusted_paths, + Err(e) => { + log::error!("Failed to do initial trusted worktrees fetch: {e:#}"); + HashMap::default() + } + } + } else { + HashMap::default() + }; + #[cfg(any(test, feature = "test-support"))] + let trusted_paths = HashMap::, HashSet>::default(); + + if let Some((upstream_client, upstream_project_id)) = &upstream_client { + let trusted_paths = trusted_paths + .iter() + .flat_map(|(_, paths)| paths.iter().map(|trusted_path| trusted_path.to_proto())) + .collect::>(); + if !trusted_paths.is_empty() { + upstream_client + .send(proto::TrustWorktrees { + project_id: *upstream_project_id, + trusted_paths, + }) + .ok(); + } + } + + let worktree_stores = match worktree_store { + Some(worktree_store) => { + HashMap::from_iter([(worktree_store.downgrade(), remote_host.clone())]) + } + None => HashMap::default(), + }; + + Self { + trusted_paths, + downstream_client, + upstream_client, + remote_host, + restricted_workspaces: HashSet::default(), + restricted: HashSet::default(), + #[cfg(not(any(test, feature = "test-support")))] + serialization_task: Task::ready(()), + worktree_stores, + } + } + + /// Whether a particular worktree store has associated worktrees that are restricted, or an associated host is restricted. + pub fn has_restricted_worktrees( + &self, + worktree_store: &Entity, + cx: &App, + ) -> bool { + let Some(remote_host) = self.worktree_stores.get(&worktree_store.downgrade()) else { + return false; + }; + self.restricted_workspaces.contains(remote_host) + || self.restricted.iter().any(|restricted_worktree| { + worktree_store + .read(cx) + .worktree_for_id(*restricted_worktree, cx) + .is_some() + }) + } + + /// Adds certain entities on this host to the trusted list. + /// This will emit [`TrustedWorktreesEvent::Trusted`] event for all passed entries + /// and the ones that got auto trusted based on trust hierarchy (see module-level docs). + pub fn trust( + &mut self, + mut trusted_paths: HashSet, + remote_host: Option, + cx: &mut Context, + ) { + let mut new_workspace_trusted = false; + let mut new_trusted_single_file_worktrees = HashSet::default(); + let mut new_trusted_other_worktrees = HashSet::default(); + let mut new_trusted_abs_paths = HashSet::default(); + for trusted_path in trusted_paths.iter().chain( + self.trusted_paths + .remove(&remote_host) + .iter() + .flat_map(|current_trusted| current_trusted.iter()), + ) { + match trusted_path { + PathTrust::Workspace => new_workspace_trusted = true, + PathTrust::Worktree(worktree_id) => { + self.restricted.remove(worktree_id); + if let Some((abs_path, is_file, host)) = + self.find_worktree_data(*worktree_id, cx) + { + if host == remote_host { + if is_file { + new_trusted_single_file_worktrees.insert(*worktree_id); + } else { + new_trusted_other_worktrees.insert((abs_path, *worktree_id)); + new_workspace_trusted = true; + } + } + } + } + PathTrust::AbsPath(path) => { + new_workspace_trusted = true; + debug_assert!( + path.is_absolute(), + "Cannot trust non-absolute path {path:?}" + ); + new_trusted_abs_paths.insert(path.clone()); + } + } + } + + if new_workspace_trusted { + new_trusted_single_file_worktrees.clear(); + self.restricted_workspaces.remove(&remote_host); + trusted_paths.insert(PathTrust::Workspace); + } + new_trusted_other_worktrees.retain(|(worktree_abs_path, _)| { + new_trusted_abs_paths + .iter() + .all(|new_trusted_path| !worktree_abs_path.starts_with(new_trusted_path)) + }); + if !new_trusted_other_worktrees.is_empty() { + new_trusted_single_file_worktrees.clear(); + } + self.restricted = std::mem::take(&mut self.restricted) + .into_iter() + .filter(|restricted_worktree| { + let Some((restricted_worktree_path, is_file, restricted_host)) = + self.find_worktree_data(*restricted_worktree, cx) + else { + return false; + }; + if restricted_host != remote_host { + return true; + } + let retain = (!is_file + || (!new_workspace_trusted && new_trusted_other_worktrees.is_empty())) + && new_trusted_abs_paths.iter().all(|new_trusted_path| { + !restricted_worktree_path.starts_with(new_trusted_path) + }); + if !retain { + trusted_paths.insert(PathTrust::Worktree(*restricted_worktree)); + } + retain + }) + .collect(); + + { + let trusted_paths = self.trusted_paths.entry(remote_host.clone()).or_default(); + trusted_paths.extend(new_trusted_abs_paths.into_iter().map(PathTrust::AbsPath)); + trusted_paths.extend( + new_trusted_other_worktrees + .into_iter() + .map(|(_, worktree_id)| PathTrust::Worktree(worktree_id)), + ); + trusted_paths.extend( + new_trusted_single_file_worktrees + .into_iter() + .map(PathTrust::Worktree), + ); + if trusted_paths.is_empty() && new_workspace_trusted { + trusted_paths.insert(PathTrust::Workspace); + } + } + + cx.emit(TrustedWorktreesEvent::Trusted( + remote_host, + trusted_paths.clone(), + )); + + #[cfg(not(any(test, feature = "test-support")))] + if self.downstream_client.is_none() { + let mut new_trusted_workspaces = HashSet::default(); + let new_trusted_worktrees = self + .trusted_paths + .clone() + .into_iter() + .map(|(host, paths)| { + let abs_paths = paths + .into_iter() + .flat_map(|path| match path { + PathTrust::Worktree(worktree_id) => self + .find_worktree_data(worktree_id, cx) + .map(|(abs_path, ..)| abs_path.to_path_buf()), + PathTrust::AbsPath(abs_path) => Some(abs_path), + PathTrust::Workspace => { + new_trusted_workspaces.insert(host.clone()); + None + } + }) + .collect(); + (host, abs_paths) + }) + .collect(); + // Do not persist auto trusted worktrees + if !ProjectSettings::get_global(cx).session.trust_all_worktrees { + self.serialization_task = cx.background_spawn(async move { + PROJECT_DB + .save_trusted_worktrees(new_trusted_worktrees, new_trusted_workspaces) + .await + .log_err(); + }); + } + } + + if let Some((upstream_client, upstream_project_id)) = &self.upstream_client { + let trusted_paths = trusted_paths + .iter() + .map(|trusted_path| trusted_path.to_proto()) + .collect::>(); + if !trusted_paths.is_empty() { + upstream_client + .send(proto::TrustWorktrees { + project_id: *upstream_project_id, + trusted_paths, + }) + .ok(); + } + } + } + + /// Restricts certain entities on this host. + /// This will emit [`TrustedWorktreesEvent::Restricted`] event for all passed entries. + pub fn restrict( + &mut self, + restricted_paths: HashSet, + remote_host: Option, + cx: &mut Context, + ) { + for restricted_path in restricted_paths { + match restricted_path { + PathTrust::Workspace => { + self.restricted_workspaces.insert(remote_host.clone()); + cx.emit(TrustedWorktreesEvent::Restricted( + remote_host.clone(), + HashSet::from_iter([PathTrust::Workspace]), + )); + } + PathTrust::Worktree(worktree_id) => { + self.restricted.insert(worktree_id); + cx.emit(TrustedWorktreesEvent::Restricted( + remote_host.clone(), + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + )); + } + PathTrust::AbsPath(..) => debug_panic!("Unexpected: cannot restrict an abs path"), + } + } + } + + /// Erases all trust information. + /// Requires Zed's restart to take proper effect. + pub fn clear_trusted_paths(&mut self, cx: &App) -> Task<()> { + if self.downstream_client.is_none() { + self.trusted_paths.clear(); + + #[cfg(not(any(test, feature = "test-support")))] + { + let (tx, rx) = smol::channel::bounded(1); + self.serialization_task = cx.background_spawn(async move { + PROJECT_DB.clear_trusted_worktrees().await.log_err(); + tx.send(()).await.ok(); + }); + + return cx.background_spawn(async move { + rx.recv().await.ok(); + }); + } + + #[cfg(any(test, feature = "test-support"))] + { + let _ = cx; + Task::ready(()) + } + } else { + Task::ready(()) + } + } + + /// Checks whether a certain worktree is trusted (or on a larger trust level). + /// If not, emits [`TrustedWorktreesEvent::Restricted`] event if for the first time and not trusted, or no corresponding worktree store was found. + /// + /// No events or data adjustment happens when `trust_all_worktrees` auto trust is enabled. + pub fn can_trust(&mut self, worktree_id: WorktreeId, cx: &mut Context) -> bool { + if ProjectSettings::get_global(cx).session.trust_all_worktrees { + return true; + } + if self.restricted.contains(&worktree_id) { + return false; + } + + let Some((worktree_path, is_file, remote_host)) = self.find_worktree_data(worktree_id, cx) + else { + return false; + }; + + if self + .trusted_paths + .get(&remote_host) + .is_some_and(|trusted_paths| trusted_paths.contains(&PathTrust::Worktree(worktree_id))) + { + return true; + } + + // See module documentation for details on trust level. + if is_file && self.trusted_paths.contains_key(&remote_host) { + return true; + } + + let parent_path_trusted = + self.trusted_paths + .get(&remote_host) + .is_some_and(|trusted_paths| { + trusted_paths.iter().any(|trusted_path| { + let PathTrust::AbsPath(trusted_path) = trusted_path else { + return false; + }; + worktree_path.starts_with(trusted_path) + }) + }); + if parent_path_trusted { + return true; + } + + self.restricted.insert(worktree_id); + cx.emit(TrustedWorktreesEvent::Restricted( + remote_host, + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + )); + if let Some((downstream_client, downstream_project_id)) = &self.downstream_client { + downstream_client + .send(proto::RestrictWorktrees { + project_id: *downstream_project_id, + restrict_workspace: false, + worktree_ids: vec![worktree_id.to_proto()], + }) + .ok(); + } + if let Some((upstream_client, upstream_project_id)) = &self.upstream_client { + upstream_client + .send(proto::RestrictWorktrees { + project_id: *upstream_project_id, + restrict_workspace: false, + worktree_ids: vec![worktree_id.to_proto()], + }) + .ok(); + } + false + } + + /// Checks whether a certain worktree is trusted globally (or on a larger trust level). + /// If not, emits [`TrustedWorktreesEvent::Restricted`] event if checked for the first time and not trusted. + /// + /// No events or data adjustment happens when `trust_all_worktrees` auto trust is enabled. + pub fn can_trust_workspace( + &mut self, + remote_host: Option, + cx: &mut Context, + ) -> bool { + if ProjectSettings::get_global(cx).session.trust_all_worktrees { + return true; + } + if self.restricted_workspaces.contains(&remote_host) { + return false; + } + if self.trusted_paths.contains_key(&remote_host) { + return true; + } + + self.restricted_workspaces.insert(remote_host.clone()); + cx.emit(TrustedWorktreesEvent::Restricted( + remote_host.clone(), + HashSet::from_iter([PathTrust::Workspace]), + )); + + if remote_host == self.remote_host { + if let Some((downstream_client, downstream_project_id)) = &self.downstream_client { + downstream_client + .send(proto::RestrictWorktrees { + project_id: *downstream_project_id, + restrict_workspace: true, + worktree_ids: Vec::new(), + }) + .ok(); + } + if let Some((upstream_client, upstream_project_id)) = &self.upstream_client { + upstream_client + .send(proto::RestrictWorktrees { + project_id: *upstream_project_id, + restrict_workspace: true, + worktree_ids: Vec::new(), + }) + .ok(); + } + } + false + } + + /// Lists all explicitly restricted worktrees (via [`TrustedWorktreesStore::can_trust`] and [`TrustedWorktreesStore::can_trust_workspace`] method calls) for a particular worktree store on a particular host. + pub fn restricted_worktrees( + &self, + worktree_store: &WorktreeStore, + remote_host: Option, + cx: &App, + ) -> HashSet)>> { + let mut single_file_paths = HashSet::default(); + let other_paths = self + .restricted + .iter() + .filter_map(|&restricted_worktree_id| { + let worktree = worktree_store.worktree_for_id(restricted_worktree_id, cx)?; + let worktree = worktree.read(cx); + let abs_path = worktree.abs_path(); + if worktree.is_single_file() { + single_file_paths.insert(Some((restricted_worktree_id, abs_path))); + None + } else { + Some((restricted_worktree_id, abs_path)) + } + }) + .map(Some) + .collect::>(); + + if !other_paths.is_empty() { + return other_paths; + } else if self.restricted_workspaces.contains(&remote_host) { + return HashSet::from_iter([None]); + } else { + single_file_paths + } + } + + /// Switches the "trust nothing" mode to "automatically trust everything". + /// This does not influence already persisted data, but stops adding new worktrees there. + pub fn auto_trust_all(&mut self, cx: &mut Context) { + for (remote_host, mut worktrees) in std::mem::take(&mut self.restricted) + .into_iter() + .flat_map(|restricted_worktree| { + let (_, _, host) = self.find_worktree_data(restricted_worktree, cx)?; + Some((restricted_worktree, host)) + }) + .fold(HashMap::default(), |mut acc, (worktree_id, remote_host)| { + acc.entry(remote_host) + .or_insert_with(HashSet::default) + .insert(PathTrust::Worktree(worktree_id)); + acc + }) + { + if self.restricted_workspaces.remove(&remote_host) { + worktrees.insert(PathTrust::Workspace); + } + self.trust(worktrees, remote_host, cx); + } + + for remote_host in std::mem::take(&mut self.restricted_workspaces) { + self.trust(HashSet::from_iter([PathTrust::Workspace]), remote_host, cx); + } + } + + fn find_worktree_data( + &mut self, + worktree_id: WorktreeId, + cx: &mut Context, + ) -> Option<(Arc, bool, Option)> { + let mut worktree_data = None; + self.worktree_stores.retain( + |worktree_store, remote_host| match worktree_store.upgrade() { + Some(worktree_store) => { + if worktree_data.is_none() { + if let Some(worktree) = + worktree_store.read(cx).worktree_for_id(worktree_id, cx) + { + worktree_data = Some(( + worktree.read(cx).abs_path(), + worktree.read(cx).is_single_file(), + remote_host.clone(), + )); + } + } + true + } + None => false, + }, + ); + worktree_data + } + + fn add_worktree_store( + &mut self, + worktree_store: Entity, + remote_host: Option, + cx: &mut Context, + ) { + self.worktree_stores + .insert(worktree_store.downgrade(), remote_host.clone()); + + if let Some(trusted_paths) = self.trusted_paths.remove(&remote_host) { + self.trusted_paths.insert( + remote_host.clone(), + trusted_paths + .into_iter() + .map(|path_trust| match path_trust { + PathTrust::AbsPath(abs_path) => { + find_worktree_in_store(worktree_store.read(cx), &abs_path, cx) + .map(PathTrust::Worktree) + .unwrap_or_else(|| PathTrust::AbsPath(abs_path)) + } + other => other, + }) + .collect(), + ); + } + } +} + +pub(crate) fn find_worktree_in_store( + worktree_store: &WorktreeStore, + abs_path: &Path, + cx: &App, +) -> Option { + let (worktree, path_in_worktree) = worktree_store.find_worktree(&abs_path, cx)?; + if path_in_worktree.is_empty() { + Some(worktree.read(cx).id()) + } else { + None + } +} + +#[cfg(test)] +mod tests { + use std::{cell::RefCell, path::PathBuf, rc::Rc}; + + use collections::HashSet; + use gpui::TestAppContext; + use serde_json::json; + use settings::SettingsStore; + use util::path; + + use crate::{FakeFs, Project}; + + use super::*; + + fn init_test(cx: &mut TestAppContext) { + cx.update(|cx| { + if cx.try_global::().is_none() { + let settings_store = SettingsStore::test(cx); + cx.set_global(settings_store); + } + if cx.try_global::().is_some() { + cx.remove_global::(); + } + }); + } + + fn init_trust_global( + worktree_store: Entity, + cx: &mut TestAppContext, + ) -> Entity { + cx.update(|cx| { + track_worktree_trust(worktree_store, None, None, None, cx); + TrustedWorktrees::try_get_global(cx).expect("global should be set") + }) + } + + #[gpui::test] + async fn test_single_worktree_trust(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_id = worktree_store.read_with(cx, |store, cx| { + store.worktrees().next().unwrap().read(cx).id() + }); + + let trusted_worktrees = init_trust_global(worktree_store.clone(), cx); + + let events: Rc>> = Rc::default(); + cx.update({ + let events = events.clone(); + |cx| { + cx.subscribe(&trusted_worktrees, move |_, event, _| { + events.borrow_mut().push(match event { + TrustedWorktreesEvent::Trusted(host, paths) => { + TrustedWorktreesEvent::Trusted(host.clone(), paths.clone()) + } + TrustedWorktreesEvent::Restricted(host, paths) => { + TrustedWorktreesEvent::Restricted(host.clone(), paths.clone()) + } + }); + }) + } + }) + .detach(); + + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust, "worktree should be restricted by default"); + + { + let events = events.borrow(); + assert_eq!(events.len(), 1); + match &events[0] { + TrustedWorktreesEvent::Restricted(host, paths) => { + assert!(host.is_none()); + assert!(paths.contains(&PathTrust::Worktree(worktree_id))); + } + _ => panic!("expected Restricted event"), + } + } + + let has_restricted = trusted_worktrees.read_with(cx, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!(has_restricted, "should have restricted worktrees"); + + let restricted = worktree_store.read_with(cx, |ws, cx| { + trusted_worktrees + .read(cx) + .restricted_worktrees(ws, None, cx) + }); + assert!( + restricted + .iter() + .any(|r| r.as_ref().map(|(id, _)| *id) == Some(worktree_id)) + ); + + events.borrow_mut().clear(); + + let can_trust_again = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust_again, "worktree should still be restricted"); + assert!( + events.borrow().is_empty(), + "no duplicate Restricted event on repeated can_trust" + ); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + + { + let events = events.borrow(); + assert_eq!(events.len(), 1); + match &events[0] { + TrustedWorktreesEvent::Trusted(host, paths) => { + assert!(host.is_none()); + assert!(paths.contains(&PathTrust::Worktree(worktree_id))); + } + _ => panic!("expected Trusted event"), + } + } + + let can_trust_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(can_trust_after, "worktree should be trusted after trust()"); + + let has_restricted_after = trusted_worktrees.read_with(cx, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!( + !has_restricted_after, + "should have no restricted worktrees after trust" + ); + + let restricted_after = worktree_store.read_with(cx, |ws, cx| { + trusted_worktrees + .read(cx) + .restricted_worktrees(ws, None, cx) + }); + assert!( + restricted_after.is_empty(), + "restricted set should be empty" + ); + } + + #[gpui::test] + async fn test_workspace_trust_no_worktrees(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({})).await; + + let project = Project::test(fs, Vec::<&Path>::new(), cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let events: Rc>> = Rc::default(); + cx.update({ + let events = events.clone(); + |cx| { + cx.subscribe(&trusted_worktrees, move |_, event, _| { + events.borrow_mut().push(match event { + TrustedWorktreesEvent::Trusted(host, paths) => { + TrustedWorktreesEvent::Trusted(host.clone(), paths.clone()) + } + TrustedWorktreesEvent::Restricted(host, paths) => { + TrustedWorktreesEvent::Restricted(host.clone(), paths.clone()) + } + }); + }) + } + }) + .detach(); + + let can_trust_workspace = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + !can_trust_workspace, + "workspace should be restricted by default" + ); + + { + let events = events.borrow(); + assert_eq!(events.len(), 1); + match &events[0] { + TrustedWorktreesEvent::Restricted(host, paths) => { + assert!(host.is_none()); + assert!(paths.contains(&PathTrust::Workspace)); + } + _ => panic!("expected Restricted event"), + } + } + + events.borrow_mut().clear(); + + let can_trust_workspace_again = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + !can_trust_workspace_again, + "workspace should still be restricted" + ); + assert!( + events.borrow().is_empty(), + "no duplicate Restricted event on repeated can_trust_workspace" + ); + + trusted_worktrees.update(cx, |store, cx| { + store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); + }); + + { + let events = events.borrow(); + assert_eq!(events.len(), 1); + match &events[0] { + TrustedWorktreesEvent::Trusted(host, paths) => { + assert!(host.is_none()); + assert!(paths.contains(&PathTrust::Workspace)); + } + _ => panic!("expected Trusted event"), + } + } + + let can_trust_workspace_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + can_trust_workspace_after, + "workspace should be trusted after trust()" + ); + } + + #[gpui::test] + async fn test_single_file_worktree_trust(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "foo.rs": "fn foo() {}" })) + .await; + + let project = Project::test(fs, [path!("/root/foo.rs").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_id = worktree_store.read_with(cx, |store, cx| { + let worktree = store.worktrees().next().unwrap(); + let worktree = worktree.read(cx); + assert!(worktree.is_single_file(), "expected single-file worktree"); + worktree.id() + }); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let events: Rc>> = Rc::default(); + cx.update({ + let events = events.clone(); + |cx| { + cx.subscribe(&trusted_worktrees, move |_, event, _| { + events.borrow_mut().push(match event { + TrustedWorktreesEvent::Trusted(host, paths) => { + TrustedWorktreesEvent::Trusted(host.clone(), paths.clone()) + } + TrustedWorktreesEvent::Restricted(host, paths) => { + TrustedWorktreesEvent::Restricted(host.clone(), paths.clone()) + } + }); + }) + } + }) + .detach(); + + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + !can_trust, + "single-file worktree should be restricted by default" + ); + + { + let events = events.borrow(); + assert_eq!(events.len(), 1); + match &events[0] { + TrustedWorktreesEvent::Restricted(host, paths) => { + assert!(host.is_none()); + assert!(paths.contains(&PathTrust::Worktree(worktree_id))); + } + _ => panic!("expected Restricted event"), + } + } + + events.borrow_mut().clear(); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + + { + let events = events.borrow(); + assert_eq!(events.len(), 1); + match &events[0] { + TrustedWorktreesEvent::Trusted(host, paths) => { + assert!(host.is_none()); + assert!(paths.contains(&PathTrust::Worktree(worktree_id))); + } + _ => panic!("expected Trusted event"), + } + } + + let can_trust_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + can_trust_after, + "single-file worktree should be trusted after trust()" + ); + } + + #[gpui::test] + async fn test_workspace_trust_unlocks_single_file_worktree(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "foo.rs": "fn foo() {}" })) + .await; + + let project = Project::test(fs, [path!("/root/foo.rs").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_id = worktree_store.read_with(cx, |store, cx| { + let worktree = store.worktrees().next().unwrap(); + let worktree = worktree.read(cx); + assert!(worktree.is_single_file(), "expected single-file worktree"); + worktree.id() + }); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let can_trust_workspace = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + !can_trust_workspace, + "workspace should be restricted by default" + ); + + let can_trust_file = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + !can_trust_file, + "single-file worktree should be restricted by default" + ); + + trusted_worktrees.update(cx, |store, cx| { + store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); + }); + + let can_trust_workspace_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + can_trust_workspace_after, + "workspace should be trusted after trust(Workspace)" + ); + + let can_trust_file_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + can_trust_file_after, + "single-file worktree should be trusted after workspace trust" + ); + } + + #[gpui::test] + async fn test_multiple_single_file_worktrees_trust_one(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/root"), + json!({ + "a.rs": "fn a() {}", + "b.rs": "fn b() {}", + "c.rs": "fn c() {}" + }), + ) + .await; + + let project = Project::test( + fs, + [ + path!("/root/a.rs").as_ref(), + path!("/root/b.rs").as_ref(), + path!("/root/c.rs").as_ref(), + ], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_ids: Vec<_> = worktree_store.read_with(cx, |store, cx| { + store + .worktrees() + .map(|worktree| { + let worktree = worktree.read(cx); + assert!(worktree.is_single_file()); + worktree.id() + }) + .collect() + }); + assert_eq!(worktree_ids.len(), 3); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + for &worktree_id in &worktree_ids { + let can_trust = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + !can_trust, + "worktree {worktree_id:?} should be restricted initially" + ); + } + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_ids[1])]), + None, + cx, + ); + }); + + let can_trust_0 = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_1 = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[1], cx)); + let can_trust_2 = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[2], cx)); + + assert!(!can_trust_0, "worktree 0 should still be restricted"); + assert!(can_trust_1, "worktree 1 should be trusted"); + assert!(!can_trust_2, "worktree 2 should still be restricted"); + } + + #[gpui::test] + async fn test_two_directory_worktrees_separate_trust(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/projects"), + json!({ + "project_a": { "main.rs": "fn main() {}" }, + "project_b": { "lib.rs": "pub fn lib() {}" } + }), + ) + .await; + + let project = Project::test( + fs, + [ + path!("/projects/project_a").as_ref(), + path!("/projects/project_b").as_ref(), + ], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_ids: Vec<_> = worktree_store.read_with(cx, |store, cx| { + store + .worktrees() + .map(|worktree| { + let worktree = worktree.read(cx); + assert!(!worktree.is_single_file()); + worktree.id() + }) + .collect() + }); + assert_eq!(worktree_ids.len(), 2); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let can_trust_a = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_b = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[1], cx)); + assert!(!can_trust_a, "project_a should be restricted initially"); + assert!(!can_trust_b, "project_b should be restricted initially"); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_ids[0])]), + None, + cx, + ); + }); + + let can_trust_a = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_b = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[1], cx)); + assert!(can_trust_a, "project_a should be trusted after trust()"); + assert!(!can_trust_b, "project_b should still be restricted"); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_ids[1])]), + None, + cx, + ); + }); + + let can_trust_a = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[0], cx)); + let can_trust_b = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_ids[1], cx)); + assert!(can_trust_a, "project_a should remain trusted"); + assert!(can_trust_b, "project_b should now be trusted"); + } + + #[gpui::test] + async fn test_directory_worktree_trust_enables_workspace(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_id = worktree_store.read_with(cx, |store, cx| { + let worktree = store.worktrees().next().unwrap(); + assert!(!worktree.read(cx).is_single_file()); + worktree.read(cx).id() + }); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let can_trust_workspace = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + !can_trust_workspace, + "workspace should be restricted initially" + ); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + + let can_trust_workspace_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + can_trust_workspace_after, + "workspace should be trusted after trusting directory worktree" + ); + } + + #[gpui::test] + async fn test_directory_worktree_trust_enables_single_file(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/"), + json!({ + "project": { "main.rs": "fn main() {}" }, + "standalone.rs": "fn standalone() {}" + }), + ) + .await; + + let project = Project::test( + fs, + [path!("/project").as_ref(), path!("/standalone.rs").as_ref()], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let (dir_worktree_id, file_worktree_id) = worktree_store.read_with(cx, |store, cx| { + let worktrees: Vec<_> = store.worktrees().collect(); + assert_eq!(worktrees.len(), 2); + let (dir_worktree, file_worktree) = if worktrees[0].read(cx).is_single_file() { + (&worktrees[1], &worktrees[0]) + } else { + (&worktrees[0], &worktrees[1]) + }; + assert!(!dir_worktree.read(cx).is_single_file()); + assert!(file_worktree.read(cx).is_single_file()); + (dir_worktree.read(cx).id(), file_worktree.read(cx).id()) + }); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let can_trust_file = + trusted_worktrees.update(cx, |store, cx| store.can_trust(file_worktree_id, cx)); + assert!( + !can_trust_file, + "single-file worktree should be restricted initially" + ); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(dir_worktree_id)]), + None, + cx, + ); + }); + + let can_trust_dir = + trusted_worktrees.update(cx, |store, cx| store.can_trust(dir_worktree_id, cx)); + let can_trust_file_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust(file_worktree_id, cx)); + assert!(can_trust_dir, "directory worktree should be trusted"); + assert!( + can_trust_file_after, + "single-file worktree should be trusted after directory worktree trust" + ); + } + + #[gpui::test] + async fn test_abs_path_trust_covers_multiple_worktrees(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/workspace"), + json!({ + "project_a": { "main.rs": "fn main() {}" }, + "project_b": { "lib.rs": "pub fn lib() {}" } + }), + ) + .await; + + let project = Project::test( + fs, + [ + path!("/workspace/project_a").as_ref(), + path!("/workspace/project_b").as_ref(), + ], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_ids: Vec<_> = worktree_store.read_with(cx, |store, cx| { + store + .worktrees() + .map(|worktree| worktree.read(cx).id()) + .collect() + }); + assert_eq!(worktree_ids.len(), 2); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + for &worktree_id in &worktree_ids { + let can_trust = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust, "worktree should be restricted initially"); + } + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::AbsPath(PathBuf::from(path!("/workspace")))]), + None, + cx, + ); + }); + + for &worktree_id in &worktree_ids { + let can_trust = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + can_trust, + "worktree should be trusted after parent path trust" + ); + } + } + + #[gpui::test] + async fn test_auto_trust_all(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/"), + json!({ + "project_a": { "main.rs": "fn main() {}" }, + "project_b": { "lib.rs": "pub fn lib() {}" }, + "single.rs": "fn single() {}" + }), + ) + .await; + + let project = Project::test( + fs, + [ + path!("/project_a").as_ref(), + path!("/project_b").as_ref(), + path!("/single.rs").as_ref(), + ], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_ids: Vec<_> = worktree_store.read_with(cx, |store, cx| { + store + .worktrees() + .map(|worktree| worktree.read(cx).id()) + .collect() + }); + assert_eq!(worktree_ids.len(), 3); + + let trusted_worktrees = init_trust_global(worktree_store.clone(), cx); + + let events: Rc>> = Rc::default(); + cx.update({ + let events = events.clone(); + |cx| { + cx.subscribe(&trusted_worktrees, move |_, event, _| { + events.borrow_mut().push(match event { + TrustedWorktreesEvent::Trusted(host, paths) => { + TrustedWorktreesEvent::Trusted(host.clone(), paths.clone()) + } + TrustedWorktreesEvent::Restricted(host, paths) => { + TrustedWorktreesEvent::Restricted(host.clone(), paths.clone()) + } + }); + }) + } + }) + .detach(); + + for &worktree_id in &worktree_ids { + let can_trust = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust, "worktree should be restricted initially"); + } + let can_trust_workspace = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + !can_trust_workspace, + "workspace should be restricted initially" + ); + + let has_restricted = trusted_worktrees.read_with(cx, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!(has_restricted, "should have restricted worktrees"); + + events.borrow_mut().clear(); + + trusted_worktrees.update(cx, |store, cx| { + store.auto_trust_all(cx); + }); + + for &worktree_id in &worktree_ids { + let can_trust = + trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!( + can_trust, + "worktree {worktree_id:?} should be trusted after auto_trust_all" + ); + } + + let can_trust_workspace = + trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); + assert!( + can_trust_workspace, + "workspace should be trusted after auto_trust_all" + ); + + let has_restricted_after = trusted_worktrees.read_with(cx, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!( + !has_restricted_after, + "should have no restricted worktrees after auto_trust_all" + ); + + let trusted_event_count = events + .borrow() + .iter() + .filter(|e| matches!(e, TrustedWorktreesEvent::Trusted(..))) + .count(); + assert!( + trusted_event_count > 0, + "should have emitted Trusted events" + ); + } + + #[gpui::test] + async fn test_wait_for_global_trust_already_trusted(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + trusted_worktrees.update(cx, |store, cx| { + store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); + }); + + let task = cx.update(|cx| wait_for_workspace_trust(None::, "test", cx)); + assert!(task.is_none(), "should return None when already trusted"); + } + + #[gpui::test] + async fn test_wait_for_workspace_trust_resolves_on_trust(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let task = cx.update(|cx| wait_for_workspace_trust(None::, "test", cx)); + assert!( + task.is_some(), + "should return Some(Task) when not yet trusted" + ); + + let task = task.unwrap(); + + cx.executor().run_until_parked(); + + trusted_worktrees.update(cx, |store, cx| { + store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); + }); + + cx.executor().run_until_parked(); + task.await; + } + + #[gpui::test] + async fn test_wait_for_default_workspace_trust_resolves_on_directory_worktree_trust( + cx: &mut TestAppContext, + ) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_id = worktree_store.read_with(cx, |store, cx| { + let worktree = store.worktrees().next().unwrap(); + assert!(!worktree.read(cx).is_single_file()); + worktree.read(cx).id() + }); + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let task = cx.update(|cx| wait_for_default_workspace_trust("test", cx)); + assert!( + task.is_some(), + "should return Some(Task) when not yet trusted" + ); + + let task = task.unwrap(); + + cx.executor().run_until_parked(); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + + cx.executor().run_until_parked(); + task.await; + } + + #[gpui::test] + async fn test_trust_restrict_trust_cycle(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) + .await; + + let project = Project::test(fs, [path!("/root").as_ref()], cx).await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_id = worktree_store.read_with(cx, |store, cx| { + store.worktrees().next().unwrap().read(cx).id() + }); + + let trusted_worktrees = init_trust_global(worktree_store.clone(), cx); + + let events: Rc>> = Rc::default(); + cx.update({ + let events = events.clone(); + |cx| { + cx.subscribe(&trusted_worktrees, move |_, event, _| { + events.borrow_mut().push(match event { + TrustedWorktreesEvent::Trusted(host, paths) => { + TrustedWorktreesEvent::Trusted(host.clone(), paths.clone()) + } + TrustedWorktreesEvent::Restricted(host, paths) => { + TrustedWorktreesEvent::Restricted(host.clone(), paths.clone()) + } + }); + }) + } + }) + .detach(); + + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust, "should be restricted initially"); + assert_eq!(events.borrow().len(), 1); + events.borrow_mut().clear(); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(can_trust, "should be trusted after trust()"); + assert_eq!(events.borrow().len(), 1); + assert!(matches!( + &events.borrow()[0], + TrustedWorktreesEvent::Trusted(..) + )); + events.borrow_mut().clear(); + + trusted_worktrees.update(cx, |store, cx| { + store.restrict( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(!can_trust, "should be restricted after restrict()"); + assert_eq!(events.borrow().len(), 1); + assert!(matches!( + &events.borrow()[0], + TrustedWorktreesEvent::Restricted(..) + )); + + let has_restricted = trusted_worktrees.read_with(cx, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!(has_restricted); + events.borrow_mut().clear(); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(worktree_id)]), + None, + cx, + ); + }); + let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); + assert!(can_trust, "should be trusted again after second trust()"); + assert_eq!(events.borrow().len(), 1); + assert!(matches!( + &events.borrow()[0], + TrustedWorktreesEvent::Trusted(..) + )); + + let has_restricted = trusted_worktrees.read_with(cx, |store, cx| { + store.has_restricted_worktrees(&worktree_store, cx) + }); + assert!(!has_restricted); + } + + #[gpui::test] + async fn test_multi_host_trust_isolation(cx: &mut TestAppContext) { + init_test(cx); + + let fs = FakeFs::new(cx.executor()); + fs.insert_tree( + path!("/"), + json!({ + "local_project": { "main.rs": "fn main() {}" }, + "remote_project": { "lib.rs": "pub fn lib() {}" } + }), + ) + .await; + + let project = Project::test( + fs, + [ + path!("/local_project").as_ref(), + path!("/remote_project").as_ref(), + ], + cx, + ) + .await; + let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); + let worktree_ids: Vec<_> = worktree_store.read_with(cx, |store, cx| { + store + .worktrees() + .map(|worktree| worktree.read(cx).id()) + .collect() + }); + assert_eq!(worktree_ids.len(), 2); + let local_worktree = worktree_ids[0]; + let _remote_worktree = worktree_ids[1]; + + let trusted_worktrees = init_trust_global(worktree_store, cx); + + let host_a: Option = None; + let host_b = Some(RemoteHostLocation { + user_name: Some("user".into()), + host_identifier: "remote-host".into(), + }); + + let can_trust_local = + trusted_worktrees.update(cx, |store, cx| store.can_trust(local_worktree, cx)); + assert!(!can_trust_local, "local worktree restricted on host_a"); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Workspace]), + host_b.clone(), + cx, + ); + }); + + let can_trust_workspace_a = trusted_worktrees.update(cx, |store, cx| { + store.can_trust_workspace(host_a.clone(), cx) + }); + assert!( + !can_trust_workspace_a, + "host_a workspace should still be restricted" + ); + + let can_trust_workspace_b = trusted_worktrees.update(cx, |store, cx| { + store.can_trust_workspace(host_b.clone(), cx) + }); + assert!(can_trust_workspace_b, "host_b workspace should be trusted"); + + trusted_worktrees.update(cx, |store, cx| { + store.trust( + HashSet::from_iter([PathTrust::Worktree(local_worktree)]), + host_a.clone(), + cx, + ); + }); + + let can_trust_local_after = + trusted_worktrees.update(cx, |store, cx| store.can_trust(local_worktree, cx)); + assert!( + can_trust_local_after, + "local worktree should be trusted on host_a" + ); + + let can_trust_workspace_a_after = trusted_worktrees.update(cx, |store, cx| { + store.can_trust_workspace(host_a.clone(), cx) + }); + assert!( + can_trust_workspace_a_after, + "host_a workspace should be trusted after directory trust" + ); + } +} diff --git a/crates/project_benchmarks/src/main.rs b/crates/project_benchmarks/src/main.rs index 738d0d0f2240f566f77f98a07df4a9ac587e10b4..03c25bc464af06793e351f27588b023ec8eb3eb9 100644 --- a/crates/project_benchmarks/src/main.rs +++ b/crates/project_benchmarks/src/main.rs @@ -62,7 +62,7 @@ fn main() -> Result<(), anyhow::Error> { let client = Client::production(cx); let http_client = FakeHttpClient::with_200_response(); let (_, rx) = watch::channel(None); - let node = NodeRuntime::new(http_client, None, rx); + let node = NodeRuntime::new(http_client, None, rx, None); let user_store = cx.new(|cx| UserStore::new(client.clone(), cx)); let registry = Arc::new(LanguageRegistry::new(cx.background_executor().clone())); let fs = Arc::new(RealFs::new(None, cx.background_executor().clone())); @@ -73,6 +73,7 @@ fn main() -> Result<(), anyhow::Error> { registry, fs, Some(Default::default()), + false, cx, ); diff --git a/crates/proto/proto/worktree.proto b/crates/proto/proto/worktree.proto index 9ab9e95438d220834351308ea83ffe9a18dec999..315aeb311e1e4284970dffa17bee4b0142373e92 100644 --- a/crates/proto/proto/worktree.proto +++ b/crates/proto/proto/worktree.proto @@ -158,3 +158,22 @@ message UpdateUserSettings { uint64 project_id = 1; string contents = 2; } + +message TrustWorktrees { + uint64 project_id = 1; + repeated PathTrust trusted_paths = 2; +} + +message PathTrust { + oneof content { + uint64 workspace = 1; + uint64 worktree_id = 2; + string abs_path = 3; + } +} + +message RestrictWorktrees { + uint64 project_id = 1; + bool restrict_workspace = 2; + repeated uint64 worktree_ids = 3; +} diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.proto index 8e26a26a43ff8af5c1b676f5dc7f8fe49e67e19f..b781a06155698505eaeb0a1d19eaaba3e7d3c08d 100644 --- a/crates/proto/proto/zed.proto +++ b/crates/proto/proto/zed.proto @@ -448,7 +448,10 @@ message Envelope { ExternalExtensionAgentsUpdated external_extension_agents_updated = 401; GitCreateRemote git_create_remote = 402; - GitRemoveRemote git_remove_remote = 403;// current max + GitRemoveRemote git_remove_remote = 403; + + TrustWorktrees trust_worktrees = 404; + RestrictWorktrees restrict_worktrees = 405; // current max } reserved 87 to 88, 396; diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs index 455f94704663dcd96e37487b1a4243850634c18e..840118b0c9d17e3c1889b8138ae70a639930f28e 100644 --- a/crates/proto/src/proto.rs +++ b/crates/proto/src/proto.rs @@ -310,6 +310,8 @@ messages!( (GitCreateBranch, Background), (GitChangeBranch, Background), (GitRenameBranch, Background), + (TrustWorktrees, Background), + (RestrictWorktrees, Background), (CheckForPushedCommits, Background), (CheckForPushedCommitsResponse, Background), (GitDiff, Background), @@ -529,7 +531,9 @@ request_messages!( (GetAgentServerCommand, AgentServerCommand), (RemoteStarted, Ack), (GitGetWorktrees, GitWorktreesResponse), - (GitCreateWorktree, Ack) + (GitCreateWorktree, Ack), + (TrustWorktrees, Ack), + (RestrictWorktrees, Ack), ); lsp_messages!( @@ -702,7 +706,9 @@ entity_messages!( ExternalAgentLoadingStatusUpdated, NewExternalAgentVersionAvailable, GitGetWorktrees, - GitCreateWorktree + GitCreateWorktree, + TrustWorktrees, + RestrictWorktrees, ); entity_messages!( diff --git a/crates/recent_projects/src/remote_connections.rs b/crates/recent_projects/src/remote_connections.rs index c0a655d19e513c838275d3e4f3beadaabcc8fef6..be40df4d1c80c3a1dda7c3f8fdfa370bc231bbfb 100644 --- a/crates/recent_projects/src/remote_connections.rs +++ b/crates/recent_projects/src/remote_connections.rs @@ -16,6 +16,7 @@ use gpui::{ use language::{CursorShape, Point}; use markdown::{Markdown, MarkdownElement, MarkdownStyle}; +use project::trusted_worktrees; use release_channel::ReleaseChannel; use remote::{ ConnectionIdentifier, DockerConnectionOptions, RemoteClient, RemoteConnection, @@ -646,6 +647,7 @@ pub async fn open_remote_project( app_state.languages.clone(), app_state.fs.clone(), None, + false, cx, ); cx.new(|cx| { @@ -788,11 +790,20 @@ pub async fn open_remote_project( continue; } - if created_new_window { - window - .update(cx, |_, window, _| window.remove_window()) - .ok(); - } + window + .update(cx, |workspace, window, cx| { + if created_new_window { + window.remove_window(); + } + trusted_worktrees::track_worktree_trust( + workspace.project().read(cx).worktree_store(), + None, + None, + None, + cx, + ); + }) + .ok(); } Ok(items) => { diff --git a/crates/recent_projects/src/remote_servers.rs b/crates/recent_projects/src/remote_servers.rs index c960a2b1a9af9e11730240c24483a673b77e0fb5..84cc216805897d81ee8d7cbba3b0f6d8a66cbdf9 100644 --- a/crates/recent_projects/src/remote_servers.rs +++ b/crates/recent_projects/src/remote_servers.rs @@ -1000,6 +1000,7 @@ impl RemoteServerProjects { app_state.user_store.clone(), app_state.languages.clone(), app_state.fs.clone(), + true, cx, ), ) diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.toml index 114dc777c1d518fc2bcbc6aaff5a4b9aa7b68a1d..ce4af656a60267cde5453f27cad129109ff660f1 100644 --- a/crates/remote_server/Cargo.toml +++ b/crates/remote_server/Cargo.toml @@ -26,6 +26,7 @@ anyhow.workspace = true askpass.workspace = true clap.workspace = true client.workspace = true +collections.workspace = true dap_adapters.workspace = true debug_adapter_extension.workspace = true env_logger.workspace = true @@ -81,7 +82,6 @@ action_log.workspace = true agent = { workspace = true, features = ["test-support"] } client = { workspace = true, features = ["test-support"] } clock = { workspace = true, features = ["test-support"] } -collections.workspace = true dap = { workspace = true, features = ["test-support"] } editor = { workspace = true, features = ["test-support"] } workspace = { workspace = true, features = ["test-support"] } diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs index 361e74579cc157e6e40a968a29ef4e6eed026335..89d26d35c77e076e1e618669acb5e54dc8afdcca 100644 --- a/crates/remote_server/src/headless_project.rs +++ b/crates/remote_server/src/headless_project.rs @@ -1,4 +1,5 @@ use anyhow::{Context as _, Result, anyhow}; +use collections::HashSet; use language::File; use lsp::LanguageServerId; @@ -21,6 +22,7 @@ use project::{ project_settings::SettingsObserver, search::SearchQuery, task_store::TaskStore, + trusted_worktrees::{PathTrust, RemoteHostLocation, TrustedWorktrees}, worktree_store::WorktreeStore, }; use rpc::{ @@ -86,6 +88,7 @@ impl HeadlessProject { languages, extension_host_proxy: proxy, }: HeadlessAppState, + init_worktree_trust: bool, cx: &mut Context, ) -> Self { debug_adapter_extension::init(proxy.clone(), cx); @@ -97,6 +100,16 @@ impl HeadlessProject { store }); + if init_worktree_trust { + project::trusted_worktrees::track_worktree_trust( + worktree_store.clone(), + None::, + Some((session.clone(), REMOTE_SERVER_PROJECT_ID)), + None, + cx, + ); + } + let environment = cx.new(|cx| ProjectEnvironment::new(None, worktree_store.downgrade(), None, true, cx)); let manifest_tree = ManifestTree::new(worktree_store.clone(), cx); @@ -264,6 +277,8 @@ impl HeadlessProject { session.add_entity_request_handler(Self::handle_get_directory_environment); session.add_entity_message_handler(Self::handle_toggle_lsp_logs); session.add_entity_request_handler(Self::handle_open_image_by_path); + session.add_entity_request_handler(Self::handle_trust_worktrees); + session.add_entity_request_handler(Self::handle_restrict_worktrees); session.add_entity_request_handler(BufferStore::handle_update_buffer); session.add_entity_message_handler(BufferStore::handle_close_buffer); @@ -595,6 +610,53 @@ impl HeadlessProject { }) } + pub async fn handle_trust_worktrees( + _: Entity, + envelope: TypedEnvelope, + mut cx: AsyncApp, + ) -> Result { + let trusted_worktrees = cx + .update(|cx| TrustedWorktrees::try_get_global(cx))? + .context("missing trusted worktrees")?; + trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| { + trusted_worktrees.trust( + envelope + .payload + .trusted_paths + .into_iter() + .filter_map(PathTrust::from_proto) + .collect(), + None, + cx, + ); + })?; + Ok(proto::Ack {}) + } + + pub async fn handle_restrict_worktrees( + _: Entity, + envelope: TypedEnvelope, + mut cx: AsyncApp, + ) -> Result { + let trusted_worktrees = cx + .update(|cx| TrustedWorktrees::try_get_global(cx))? + .context("missing trusted worktrees")?; + trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| { + let mut restricted_paths = envelope + .payload + .worktree_ids + .into_iter() + .map(WorktreeId::from_proto) + .map(PathTrust::Worktree) + .collect::>(); + if envelope.payload.restrict_workspace { + restricted_paths.insert(PathTrust::Workspace); + } + trusted_worktrees.restrict(restricted_paths, None, cx); + })?; + Ok(proto::Ack {}) + } + pub async fn handle_open_new_buffer( this: Entity, _message: TypedEnvelope, diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs index a91d1d055d582eb2f2de4883314ad5984238103a..a7a870b0513694abe8b126fd0badea05534749ea 100644 --- a/crates/remote_server/src/remote_editing_tests.rs +++ b/crates/remote_server/src/remote_editing_tests.rs @@ -1933,6 +1933,7 @@ pub async fn init_test( languages, extension_host_proxy: proxy, }, + false, cx, ) }); @@ -1977,5 +1978,5 @@ fn build_project(ssh: Entity, cx: &mut TestAppContext) -> Entity

>); let node_runtime = NodeRuntime::new( http_client.clone(), Some(shell_env_loaded_rx), node_settings_rx, + trust_task, ); let mut languages = LanguageRegistry::new(cx.background_executor().clone()); @@ -468,6 +474,7 @@ pub fn execute_run( languages, extension_host_proxy, }, + true, cx, ) }); diff --git a/crates/settings/src/settings_content/project.rs b/crates/settings/src/settings_content/project.rs index 5cd708694d0cfd3699fdc822509d0209f9a96fd1..a5e15153832c425134e129cba1984b3b5886aa56 100644 --- a/crates/settings/src/settings_content/project.rs +++ b/crates/settings/src/settings_content/project.rs @@ -187,6 +187,12 @@ pub struct SessionSettingsContent { /// /// Default: true pub restore_unsaved_buffers: Option, + /// Whether or not to skip worktree trust checks. + /// When trusted, project settings are synchronized automatically, + /// language and MCP servers are downloaded and started automatically. + /// + /// Default: false + pub trust_all_worktrees: Option, } #[derive(Deserialize, Serialize, Clone, PartialEq, Eq, JsonSchema, MergeFrom, Debug)] diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs index 007c41ad59b4e875770beecb089bd4e7fb2078b5..1d0603de3184ad9da874b428a94af37d8966e6a2 100644 --- a/crates/settings_ui/src/page_data.rs +++ b/crates/settings_ui/src/page_data.rs @@ -138,6 +138,28 @@ pub(crate) fn settings_data(cx: &App) -> Vec { metadata: None, files: USER, }), + SettingsPageItem::SectionHeader("Security"), + SettingsPageItem::SettingItem(SettingItem { + title: "Trust All Projects By Default", + description: "When opening Zed, avoid Restricted Mode by auto-trusting all projects, enabling use of all features without having to give permission to each new project.", + field: Box::new(SettingField { + json_path: Some("session.trust_all_projects"), + pick: |settings_content| { + settings_content + .session + .as_ref() + .and_then(|session| session.trust_all_worktrees.as_ref()) + }, + write: |settings_content, value| { + settings_content + .session + .get_or_insert_default() + .trust_all_worktrees = value; + }, + }), + metadata: None, + files: USER, + }), SettingsPageItem::SectionHeader("Workspace Restoration"), SettingsPageItem::SettingItem(SettingItem { title: "Restore Unsaved Buffers", diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index 4d7397a0bc82142245b86c11ffdf441a6b781ad8..608fea7383176460cb4b7519824cd2dc118dbb69 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -30,18 +30,20 @@ use gpui::{ Subscription, WeakEntity, Window, actions, div, }; use onboarding_banner::OnboardingBanner; -use project::{Project, WorktreeSettings, git_store::GitStoreEvent}; +use project::{ + Project, WorktreeSettings, git_store::GitStoreEvent, trusted_worktrees::TrustedWorktrees, +}; use remote::RemoteConnectionOptions; use settings::{Settings, SettingsLocation}; use std::sync::Arc; use theme::ActiveTheme; use title_bar_settings::TitleBarSettings; use ui::{ - Avatar, Button, ButtonLike, ButtonStyle, Chip, ContextMenu, Icon, IconName, IconSize, - IconWithIndicator, Indicator, PopoverMenu, PopoverMenuHandle, Tooltip, h_flex, prelude::*, + Avatar, ButtonLike, Chip, ContextMenu, IconWithIndicator, Indicator, PopoverMenu, + PopoverMenuHandle, TintColor, Tooltip, prelude::*, }; use util::{ResultExt, rel_path::RelPath}; -use workspace::{Workspace, notifications::NotifyResultExt}; +use workspace::{ToggleWorktreeSecurity, Workspace, notifications::NotifyResultExt}; use zed_actions::{OpenRecent, OpenRemote}; pub use onboarding_banner::restore_banner; @@ -163,6 +165,7 @@ impl Render for TitleBar { title_bar .when(title_bar_settings.show_project_items, |title_bar| { title_bar + .children(self.render_restricted_mode(cx)) .children(self.render_project_host(cx)) .child(self.render_project_name(cx)) }) @@ -291,7 +294,12 @@ impl TitleBar { _ => {} }), ); - subscriptions.push(cx.observe(&user_store, |_, _, cx| cx.notify())); + subscriptions.push(cx.observe(&user_store, |_a, _, cx| cx.notify())); + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + subscriptions.push(cx.subscribe(&trusted_worktrees, |_, _, _, cx| { + cx.notify(); + })); + } let banner = cx.new(|cx| { OnboardingBanner::new( @@ -317,7 +325,7 @@ impl TitleBar { client, _subscriptions: subscriptions, banner, - screen_share_popover_handle: Default::default(), + screen_share_popover_handle: PopoverMenuHandle::default(), } } @@ -427,6 +435,48 @@ impl TitleBar { ) } + pub fn render_restricted_mode(&self, cx: &mut Context) -> Option { + let has_restricted_worktrees = TrustedWorktrees::try_get_global(cx) + .map(|trusted_worktrees| { + trusted_worktrees + .read(cx) + .has_restricted_worktrees(&self.project.read(cx).worktree_store(), cx) + }) + .unwrap_or(false); + if !has_restricted_worktrees { + return None; + } + + Some( + Button::new("restricted_mode_trigger", "Restricted Mode") + .style(ButtonStyle::Tinted(TintColor::Warning)) + .label_size(LabelSize::Small) + .color(Color::Warning) + .icon(IconName::Warning) + .icon_color(Color::Warning) + .icon_size(IconSize::Small) + .icon_position(IconPosition::Start) + .tooltip(|_, cx| { + Tooltip::with_meta( + "You're in Restricted Mode", + Some(&ToggleWorktreeSecurity), + "Mark this project as trusted and unlock all features", + cx, + ) + }) + .on_click({ + cx.listener(move |this, _, window, cx| { + this.workspace + .update(cx, |workspace, cx| { + workspace.show_worktree_trust_security_modal(true, window, cx) + }) + .log_err(); + }) + }) + .into_any_element(), + ) + } + pub fn render_project_host(&self, cx: &mut Context) -> Option { if self.project.read(cx).is_via_remote_server() { return self.render_remote_project_connection(cx); diff --git a/crates/ui/src/components/notification/alert_modal.rs b/crates/ui/src/components/notification/alert_modal.rs index 9990dc1ce5f13e6834a009c4b8d7c14b594ccf36..52a084c847887a4dea7fd8b9a3fbad8390f68863 100644 --- a/crates/ui/src/components/notification/alert_modal.rs +++ b/crates/ui/src/components/notification/alert_modal.rs @@ -1,73 +1,161 @@ use crate::component_prelude::*; use crate::prelude::*; +use crate::{Checkbox, ListBulletItem, ToggleState}; +use gpui::Action; +use gpui::FocusHandle; use gpui::IntoElement; +use gpui::Stateful; use smallvec::{SmallVec, smallvec}; +use theme::ActiveTheme; + +type ActionHandler = Box) -> Stateful

>; #[derive(IntoElement, RegisterComponent)] pub struct AlertModal { id: ElementId, + header: Option, children: SmallVec<[AnyElement; 2]>, - title: SharedString, - primary_action: SharedString, - dismiss_label: SharedString, + footer: Option, + title: Option, + primary_action: Option, + dismiss_label: Option, + width: Option, + key_context: Option, + action_handlers: Vec, + focus_handle: Option, } impl AlertModal { - pub fn new(id: impl Into, title: impl Into) -> Self { + pub fn new(id: impl Into) -> Self { Self { id: id.into(), + header: None, children: smallvec![], - title: title.into(), - primary_action: "Ok".into(), - dismiss_label: "Cancel".into(), + footer: None, + title: None, + primary_action: None, + dismiss_label: None, + width: None, + key_context: None, + action_handlers: Vec::new(), + focus_handle: None, } } + pub fn title(mut self, title: impl Into) -> Self { + self.title = Some(title.into()); + self + } + + pub fn header(mut self, header: impl IntoElement) -> Self { + self.header = Some(header.into_any_element()); + self + } + + pub fn footer(mut self, footer: impl IntoElement) -> Self { + self.footer = Some(footer.into_any_element()); + self + } + pub fn primary_action(mut self, primary_action: impl Into) -> Self { - self.primary_action = primary_action.into(); + self.primary_action = Some(primary_action.into()); self } pub fn dismiss_label(mut self, dismiss_label: impl Into) -> Self { - self.dismiss_label = dismiss_label.into(); + self.dismiss_label = Some(dismiss_label.into()); + self + } + + pub fn width(mut self, width: impl Into) -> Self { + self.width = Some(width.into()); + self + } + + pub fn key_context(mut self, key_context: impl Into) -> Self { + self.key_context = Some(key_context.into()); + self + } + + pub fn on_action( + mut self, + listener: impl Fn(&A, &mut Window, &mut App) + 'static, + ) -> Self { + self.action_handlers + .push(Box::new(move |div| div.on_action(listener))); + self + } + + pub fn track_focus(mut self, focus_handle: &gpui::FocusHandle) -> Self { + self.focus_handle = Some(focus_handle.clone()); self } } impl RenderOnce for AlertModal { fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement { - v_flex() + let width = self.width.unwrap_or_else(|| px(440.).into()); + let has_default_footer = self.primary_action.is_some() || self.dismiss_label.is_some(); + + let mut modal = v_flex() + .when_some(self.key_context, |this, key_context| { + this.key_context(key_context.as_str()) + }) + .when_some(self.focus_handle, |this, focus_handle| { + this.track_focus(&focus_handle) + }) .id(self.id) .elevation_3(cx) - .w(px(440.)) - .p_5() - .child( + .w(width) + .bg(cx.theme().colors().elevated_surface_background) + .overflow_hidden(); + + for handler in self.action_handlers { + modal = handler(modal); + } + + if let Some(header) = self.header { + modal = modal.child(header); + } else if let Some(title) = self.title { + modal = modal.child( + v_flex() + .pt_3() + .pr_3() + .pl_3() + .pb_1() + .child(Headline::new(title).size(HeadlineSize::Small)), + ); + } + + if !self.children.is_empty() { + modal = modal.child( v_flex() + .p_3() .text_ui(cx) .text_color(Color::Muted.color(cx)) .gap_1() - .child(Headline::new(self.title).size(HeadlineSize::Small)) .children(self.children), - ) - .child( + ); + } + + if let Some(footer) = self.footer { + modal = modal.child(footer); + } else if has_default_footer { + let primary_action = self.primary_action.unwrap_or_else(|| "Ok".into()); + let dismiss_label = self.dismiss_label.unwrap_or_else(|| "Cancel".into()); + + modal = modal.child( h_flex() - .h(rems(1.75)) + .p_3() .items_center() - .child(div().flex_1()) - .child( - h_flex() - .items_center() - .gap_1() - .child( - Button::new(self.dismiss_label.clone(), self.dismiss_label.clone()) - .color(Color::Muted), - ) - .child(Button::new( - self.primary_action.clone(), - self.primary_action, - )), - ), - ) + .justify_end() + .gap_1() + .child(Button::new(dismiss_label.clone(), dismiss_label).color(Color::Muted)) + .child(Button::new(primary_action.clone(), primary_action)), + ); + } + + modal } } @@ -90,24 +178,75 @@ impl Component for AlertModal { Some("A modal dialog that presents an alert message with primary and dismiss actions.") } - fn preview(_window: &mut Window, _cx: &mut App) -> Option { + fn preview(_window: &mut Window, cx: &mut App) -> Option { Some( v_flex() .gap_6() .p_4() - .children(vec![example_group( - vec![ - single_example( - "Basic Alert", - AlertModal::new("simple-modal", "Do you want to leave the current call?") - .child("The current window will be closed, and connections to any shared projects will be terminated." - ) - .primary_action("Leave Call") - .into_any_element(), - ) - ], - )]) - .into_any_element() + .children(vec![ + example_group(vec![single_example( + "Basic Alert", + AlertModal::new("simple-modal") + .title("Do you want to leave the current call?") + .child( + "The current window will be closed, and connections to any shared projects will be terminated." + ) + .primary_action("Leave Call") + .dismiss_label("Cancel") + .into_any_element(), + )]), + example_group(vec![single_example( + "Custom Header", + AlertModal::new("custom-header-modal") + .header( + v_flex() + .p_3() + .bg(cx.theme().colors().background) + .gap_1() + .child( + h_flex() + .gap_1() + .child(Icon::new(IconName::Warning).color(Color::Warning)) + .child(Headline::new("Unrecognized Workspace").size(HeadlineSize::Small)) + ) + .child( + h_flex() + .pl(IconSize::default().rems() + rems(0.5)) + .child(Label::new("~/projects/my-project").color(Color::Muted)) + ) + ) + .child( + "Untrusted workspaces are opened in Restricted Mode to protect your system. +Review .zed/settings.json for any extensions or commands configured by this project.", + ) + .child( + v_flex() + .mt_1() + .child(Label::new("Restricted mode prevents:").color(Color::Muted)) + .child(ListBulletItem::new("Project settings from being applied")) + .child(ListBulletItem::new("Language servers from running")) + .child(ListBulletItem::new("MCP integrations from installing")) + ) + .footer( + h_flex() + .p_3() + .justify_between() + .child( + Checkbox::new("trust-parent", ToggleState::Unselected) + .label("Trust all projects in parent directory") + ) + .child( + h_flex() + .gap_1() + .child(Button::new("restricted", "Stay in Restricted Mode").color(Color::Muted)) + .child(Button::new("trust", "Trust and Continue").style(ButtonStyle::Filled)) + ) + ) + .width(rems(40.)) + .into_any_element(), + )]), + ]) + .into_any_element(), ) } } diff --git a/crates/workspace/src/modal_layer.rs b/crates/workspace/src/modal_layer.rs index bcd7db3a82aec46405927e118af86cf4a0d4912b..d6f10f703100d89bef5babd4baa590df5fa0c8fd 100644 --- a/crates/workspace/src/modal_layer.rs +++ b/crates/workspace/src/modal_layer.rs @@ -171,28 +171,19 @@ impl Render for ModalLayer { }; div() - .occlude() .absolute() .size_full() - .top_0() - .left_0() - .when(active_modal.modal.fade_out_background(cx), |el| { + .inset_0() + .occlude() + .when(active_modal.modal.fade_out_background(cx), |this| { let mut background = cx.theme().colors().elevated_surface_background; background.fade_out(0.2); - el.bg(background) + this.bg(background) }) - .on_mouse_down( - MouseButton::Left, - cx.listener(|this, _, window, cx| { - this.hide_modal(window, cx); - }), - ) .child( v_flex() .h(px(0.0)) .top_20() - .flex() - .flex_col() .items_center() .track_focus(&active_modal.focus_handle) .child( diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs new file mode 100644 index 0000000000000000000000000000000000000000..f2a94ad81661a2572f35d1d746b04b31fa24f00c --- /dev/null +++ b/crates/workspace/src/security_modal.rs @@ -0,0 +1,373 @@ +//! A UI interface for managing the [`TrustedWorktrees`] data. + +use std::{ + borrow::Cow, + path::{Path, PathBuf}, + sync::Arc, +}; + +use collections::{HashMap, HashSet}; +use gpui::{DismissEvent, EventEmitter, FocusHandle, Focusable, WeakEntity}; + +use project::{ + WorktreeId, + trusted_worktrees::{PathTrust, RemoteHostLocation, TrustedWorktrees}, + worktree_store::WorktreeStore, +}; +use smallvec::SmallVec; +use theme::ActiveTheme; +use ui::{ + AlertModal, Checkbox, FluentBuilder, KeyBinding, ListBulletItem, ToggleState, prelude::*, +}; + +use crate::{DismissDecision, ModalView, ToggleWorktreeSecurity}; + +pub struct SecurityModal { + restricted_paths: HashMap, RestrictedPath>, + home_dir: Option, + trust_parents: bool, + worktree_store: WeakEntity, + remote_host: Option, + focus_handle: FocusHandle, + trusted: Option, +} + +#[derive(Debug, PartialEq, Eq)] +struct RestrictedPath { + abs_path: Option>, + is_file: bool, + host: Option, +} + +impl Focusable for SecurityModal { + fn focus_handle(&self, _: &ui::App) -> FocusHandle { + self.focus_handle.clone() + } +} + +impl EventEmitter for SecurityModal {} + +impl ModalView for SecurityModal { + fn fade_out_background(&self) -> bool { + true + } + + fn on_before_dismiss(&mut self, _: &mut Window, _: &mut Context) -> DismissDecision { + match self.trusted { + Some(false) => telemetry::event!("Open in Restricted", source = "Worktree Trust Modal"), + Some(true) => telemetry::event!("Trust and Continue", source = "Worktree Trust Modal"), + None => telemetry::event!("Dismissed", source = "Worktree Trust Modal"), + } + DismissDecision::Dismiss(true) + } +} + +impl Render for SecurityModal { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + if self.restricted_paths.is_empty() { + self.dismiss(cx); + return v_flex().into_any_element(); + } + + let header_label = if self.restricted_paths.len() == 1 { + "Unrecognized Project" + } else { + "Unrecognized Projects" + }; + + let trust_label = self.build_trust_label(); + + AlertModal::new("security-modal") + .width(rems(40.)) + .key_context("SecurityModal") + .track_focus(&self.focus_handle(cx)) + .on_action(cx.listener(|this, _: &menu::Confirm, _window, cx| { + this.trust_and_dismiss(cx); + })) + .on_action(cx.listener(|security_modal, _: &ToggleWorktreeSecurity, _window, cx| { + security_modal.trusted = Some(false); + security_modal.dismiss(cx); + })) + .header( + v_flex() + .p_3() + .gap_1() + .rounded_t_md() + .bg(cx.theme().colors().editor_background.opacity(0.5)) + .border_b_1() + .border_color(cx.theme().colors().border_variant) + .child( + h_flex() + .gap_2() + .child(Icon::new(IconName::Warning).color(Color::Warning)) + .child(Label::new(header_label)), + ) + .children(self.restricted_paths.values().map(|restricted_path| { + let abs_path = restricted_path.abs_path.as_ref().and_then(|abs_path| { + if restricted_path.is_file { + abs_path.parent() + } else { + Some(abs_path.as_ref()) + } + }); + + let label = match abs_path { + Some(abs_path) => match &restricted_path.host { + Some(remote_host) => match &remote_host.user_name { + Some(user_name) => format!( + "{} ({}@{})", + self.shorten_path(abs_path).display(), + user_name, + remote_host.host_identifier + ), + None => format!( + "{} ({})", + self.shorten_path(abs_path).display(), + remote_host.host_identifier + ), + }, + None => self.shorten_path(abs_path).display().to_string(), + }, + None => match &restricted_path.host { + Some(remote_host) => match &remote_host.user_name { + Some(user_name) => format!( + "Empty project ({}@{})", + user_name, remote_host.host_identifier + ), + None => { + format!("Empty project ({})", remote_host.host_identifier) + } + }, + None => "Empty project".to_string(), + }, + }; + h_flex() + .pl(IconSize::default().rems() + rems(0.5)) + .child(Label::new(label).color(Color::Muted)) + })), + ) + .child( + v_flex() + .gap_2() + .child( + v_flex() + .child( + Label::new( + "Untrusted projects are opened in Restricted Mode to protect your system.", + ) + .color(Color::Muted), + ) + .child( + Label::new( + "Review .zed/settings.json for any extensions or commands configured by this project.", + ) + .color(Color::Muted), + ), + ) + .child( + v_flex() + .child(Label::new("Restricted Mode prevents:").color(Color::Muted)) + .child(ListBulletItem::new("Project settings from being applied")) + .child(ListBulletItem::new("Language servers from running")) + .child(ListBulletItem::new("MCP Server integrations from installing")), + ) + .map(|this| match trust_label { + Some(trust_label) => this.child( + Checkbox::new("trust-parents", ToggleState::from(self.trust_parents)) + .label(trust_label) + .on_click(cx.listener( + |security_modal, state: &ToggleState, _, cx| { + security_modal.trust_parents = state.selected(); + cx.notify(); + cx.stop_propagation(); + }, + )), + ), + None => this, + }), + ) + .footer( + h_flex() + .px_3() + .pb_3() + .gap_1() + .justify_end() + .child( + Button::new("rm", "Stay in Restricted Mode") + .key_binding( + KeyBinding::for_action( + &ToggleWorktreeSecurity, + cx, + ) + .map(|kb| kb.size(rems_from_px(12.))), + ) + .on_click(cx.listener(move |security_modal, _, _, cx| { + security_modal.trusted = Some(false); + security_modal.dismiss(cx); + cx.stop_propagation(); + })), + ) + .child( + Button::new("tc", "Trust and Continue") + .style(ButtonStyle::Filled) + .layer(ui::ElevationIndex::ModalSurface) + .key_binding( + KeyBinding::for_action(&menu::Confirm, cx) + .map(|kb| kb.size(rems_from_px(12.))), + ) + .on_click(cx.listener(move |security_modal, _, _, cx| { + security_modal.trust_and_dismiss(cx); + cx.stop_propagation(); + })), + ), + ) + .into_any_element() + } +} + +impl SecurityModal { + pub fn new( + worktree_store: WeakEntity, + remote_host: Option>, + cx: &mut Context, + ) -> Self { + let mut this = Self { + worktree_store, + remote_host: remote_host.map(|host| host.into()), + restricted_paths: HashMap::default(), + focus_handle: cx.focus_handle(), + trust_parents: false, + home_dir: std::env::home_dir(), + trusted: None, + }; + this.refresh_restricted_paths(cx); + + this + } + + fn build_trust_label(&self) -> Option> { + let mut has_restricted_files = false; + let available_parents = self + .restricted_paths + .values() + .filter(|restricted_path| { + has_restricted_files |= restricted_path.is_file; + !restricted_path.is_file + }) + .filter_map(|restricted_path| restricted_path.abs_path.as_ref()?.parent()) + .collect::>(); + match available_parents.len() { + 0 => { + if has_restricted_files { + Some(Cow::Borrowed("Trust all single files")) + } else { + None + } + } + 1 => Some(Cow::Owned(format!( + "Trust all projects in the {:?} folder", + self.shorten_path(available_parents[0]) + ))), + _ => Some(Cow::Borrowed("Trust all projects in the parent folders")), + } + } + + fn shorten_path<'a>(&self, path: &'a Path) -> Cow<'a, Path> { + match &self.home_dir { + Some(home_dir) => path + .strip_prefix(home_dir) + .map(|stripped| Path::new("~").join(stripped)) + .map(Cow::Owned) + .unwrap_or(Cow::Borrowed(path)), + None => Cow::Borrowed(path), + } + } + + fn trust_and_dismiss(&mut self, cx: &mut Context) { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + let mut paths_to_trust = self + .restricted_paths + .keys() + .map(|worktree_id| match worktree_id { + Some(worktree_id) => PathTrust::Worktree(*worktree_id), + None => PathTrust::Workspace, + }) + .collect::>(); + if self.trust_parents { + paths_to_trust.extend(self.restricted_paths.values().filter_map( + |restricted_paths| { + if restricted_paths.is_file { + Some(PathTrust::Workspace) + } else { + let parent_abs_path = + restricted_paths.abs_path.as_ref()?.parent()?.to_owned(); + Some(PathTrust::AbsPath(parent_abs_path)) + } + }, + )); + } + trusted_worktrees.trust(paths_to_trust, self.remote_host.clone(), cx); + }); + } + + self.trusted = Some(true); + self.dismiss(cx); + } + + pub fn dismiss(&mut self, cx: &mut Context) { + cx.emit(DismissEvent); + } + + pub fn refresh_restricted_paths(&mut self, cx: &mut Context) { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + if let Some(worktree_store) = self.worktree_store.upgrade() { + let mut new_restricted_worktrees = trusted_worktrees + .read(cx) + .restricted_worktrees(worktree_store.read(cx), self.remote_host.clone(), cx) + .into_iter() + .filter_map(|restricted_path| { + let restricted_path = match restricted_path { + Some((worktree_id, abs_path)) => { + let worktree = + worktree_store.read(cx).worktree_for_id(worktree_id, cx)?; + ( + Some(worktree_id), + RestrictedPath { + abs_path: Some(abs_path), + is_file: worktree.read(cx).is_single_file(), + host: self.remote_host.clone(), + }, + ) + } + None => ( + None, + RestrictedPath { + abs_path: None, + is_file: false, + host: self.remote_host.clone(), + }, + ), + }; + Some(restricted_path) + }) + .collect::>(); + // Do not clutter the UI: + // * trusting regular local worktrees assumes the workspace is trusted either, on the same host. + // * trusting a workspace trusts all single-file worktrees on the same host. + if new_restricted_worktrees.len() > 1 { + new_restricted_worktrees.remove(&None); + } + + if self.restricted_paths != new_restricted_worktrees { + self.trust_parents = false; + self.restricted_paths = new_restricted_worktrees; + cx.notify(); + } + } + } else if !self.restricted_paths.is_empty() { + self.restricted_paths.clear(); + cx.notify(); + } + } +} diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 41304fd77f1eff8d890ff21a3051e57ce3ab295e..34593f5bc8f6af3b9cbac87e8fbff50d3f954a95 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -9,6 +9,7 @@ pub mod pane_group; mod path_list; mod persistence; pub mod searchable; +mod security_modal; pub mod shared_screen; mod status_bar; pub mod tasks; @@ -77,7 +78,9 @@ use project::{ DirectoryLister, Project, ProjectEntryId, ProjectPath, ResolvedPath, Worktree, WorktreeId, WorktreeSettings, debugger::{breakpoint_store::BreakpointStoreEvent, session::ThreadStatus}, + project_settings::ProjectSettings, toolchain_store::ToolchainStoreEvent, + trusted_worktrees::TrustedWorktrees, }; use remote::{ RemoteClientDelegate, RemoteConnection, RemoteConnectionOptions, @@ -86,7 +89,9 @@ use remote::{ use schemars::JsonSchema; use serde::Deserialize; use session::AppSession; -use settings::{CenteredPaddingSettings, Settings, SettingsLocation, update_settings_file}; +use settings::{ + CenteredPaddingSettings, Settings, SettingsLocation, SettingsStore, update_settings_file, +}; use shared_screen::SharedScreen; use sqlez::{ bindable::{Bind, Column, StaticColumnCount}, @@ -137,6 +142,7 @@ use crate::{ SerializedAxis, model::{DockData, DockStructure, SerializedItem, SerializedPane, SerializedPaneGroup}, }, + security_modal::SecurityModal, utility_pane::{DraggedUtilityPane, UtilityPaneFrame, UtilityPaneSlot, UtilityPaneState}, }; @@ -277,6 +283,12 @@ actions!( ZoomIn, /// Zooms out of the active pane. ZoomOut, + /// If any worktrees are in restricted mode, shows a modal with possible actions. + /// If the modal is shown already, closes it without trusting any worktree. + ToggleWorktreeSecurity, + /// Clears all trusted worktrees, placing them in restricted mode on next open. + /// Requires restart to take effect on already opened projects. + ClearTrustedWorktrees, /// Stops following a collaborator. Unfollow, /// Restores the banner. @@ -1217,6 +1229,17 @@ impl Workspace { window: &mut Window, cx: &mut Context, ) -> Self { + cx.observe_global::(|_, cx| { + if ProjectSettings::get_global(cx).session.trust_all_worktrees { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.auto_trust_all(cx); + }) + } + } + }) + .detach(); + cx.subscribe_in(&project, window, move |this, _, event, window, cx| { match event { project::Event::RemoteIdChanged(_) => { @@ -1474,7 +1497,7 @@ impl Workspace { }), ]; - cx.defer_in(window, |this, window, cx| { + cx.defer_in(window, move |this, window, cx| { this.update_window_title(window, cx); this.show_initial_notifications(cx); }); @@ -1559,6 +1582,7 @@ impl Workspace { app_state.languages.clone(), app_state.fs.clone(), env, + true, cx, ); @@ -5938,6 +5962,25 @@ impl Workspace { } }, )) + .on_action(cx.listener( + |workspace: &mut Workspace, _: &ToggleWorktreeSecurity, window, cx| { + workspace.show_worktree_trust_security_modal(true, window, cx); + }, + )) + .on_action( + cx.listener(|_: &mut Workspace, _: &ClearTrustedWorktrees, _, cx| { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + let clear_task = trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.clear_trusted_paths(cx) + }); + cx.spawn(async move |_, cx| { + clear_task.await; + cx.update(|cx| reload(cx)).ok(); + }) + .detach(); + } + }), + ) .on_action(cx.listener( |workspace: &mut Workspace, _: &ReopenClosedItem, window, cx| { workspace.reopen_closed_item(window, cx).detach(); @@ -6418,6 +6461,41 @@ impl Workspace { file.project.all_languages.defaults.show_edit_predictions = Some(!show_edit_predictions) }); } + + pub fn show_worktree_trust_security_modal( + &mut self, + toggle: bool, + window: &mut Window, + cx: &mut Context, + ) { + if let Some(security_modal) = self.active_modal::(cx) { + if toggle { + security_modal.update(cx, |security_modal, cx| { + security_modal.dismiss(cx); + }) + } else { + security_modal.update(cx, |security_modal, cx| { + security_modal.refresh_restricted_paths(cx); + }); + } + } else { + let has_restricted_worktrees = TrustedWorktrees::try_get_global(cx) + .map(|trusted_worktrees| { + trusted_worktrees + .read(cx) + .has_restricted_worktrees(&self.project().read(cx).worktree_store(), cx) + }) + .unwrap_or(false); + if has_restricted_worktrees { + let project = self.project().read(cx); + let remote_host = project.remote_connection_options(cx); + let worktree_store = project.worktree_store().downgrade(); + self.toggle_modal(window, cx, |_, cx| { + SecurityModal::new(worktree_store, remote_host, cx) + }); + } + } + } } fn leader_border_for_pane( @@ -7968,6 +8046,7 @@ pub fn open_remote_project_with_new_connection( app_state.user_store.clone(), app_state.languages.clone(), app_state.fs.clone(), + true, cx, ) })?; diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 674cc5f659f7a0d5d97eb7700505eb0ec4c5e5bc..353baba02cca9b0060a647f438fa8be4e81e9142 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -27,7 +27,7 @@ use reqwest_client::ReqwestClient; use assets::Assets; use node_runtime::{NodeBinaryOptions, NodeRuntime}; use parking_lot::Mutex; -use project::project_settings::ProjectSettings; +use project::{project_settings::ProjectSettings, trusted_worktrees}; use recent_projects::{SshSettings, open_remote_project}; use release_channel::{AppCommitSha, AppVersion, ReleaseChannel}; use session::{AppSession, Session}; @@ -36,6 +36,7 @@ use std::{ env, io::{self, IsTerminal}, path::{Path, PathBuf}, + pin::Pin, process, sync::{Arc, OnceLock}, time::Instant, @@ -406,6 +407,7 @@ pub fn main() { }); app.run(move |cx| { + trusted_worktrees::init(None, None, cx); menu::init(); zed_actions::init(); @@ -474,7 +476,15 @@ pub fn main() { tx.send(Some(options)).log_err(); }) .detach(); - let node_runtime = NodeRuntime::new(client.http_client(), Some(shell_env_loaded_rx), rx); + + let trust_task = trusted_worktrees::wait_for_default_workspace_trust("Node runtime", cx) + .map(|trust_task| Box::pin(trust_task) as Pin>); + let node_runtime = NodeRuntime::new( + client.http_client(), + Some(shell_env_loaded_rx), + rx, + trust_task, + ); debug_adapter_extension::init(extension_host_proxy.clone(), cx); languages::init(languages.clone(), fs.clone(), node_runtime.clone(), cx); diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index 9d1f6f61d446b67256c00bf6322aed73af922c5e..6514bd6455d85fe390bebce10096fc4edc5a9f0a 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -23,6 +23,9 @@ - [Visual Customization](./visual-customization.md) - [Vim Mode](./vim.md) - [Helix Mode](./helix.md) +- [Privacy and Security](./ai/privacy-and-security.md) + - [Worktree Trust](./worktree-trust.md) + - [AI Improvement](./ai/ai-improvement.md) @@ -69,8 +72,6 @@ - [Models](./ai/models.md) - [Plans and Usage](./ai/plans-and-usage.md) - [Billing](./ai/billing.md) -- [Privacy and Security](./ai/privacy-and-security.md) - - [AI Improvement](./ai/ai-improvement.md) # Extensions diff --git a/docs/src/ai/privacy-and-security.md b/docs/src/ai/privacy-and-security.md index 6921567b9165e863cd4303752a669e641e6fcdca..d72cc8c476a83f60d8342962fcdd410e541e7356 100644 --- a/docs/src/ai/privacy-and-security.md +++ b/docs/src/ai/privacy-and-security.md @@ -2,7 +2,7 @@ ## Philosophy -Zed aims to collect on the minimum data necessary to serve and improve our product. +Zed aims to collect only the minimum data necessary to serve and improve our product. We believe in opt-in data sharing as the default in building AI products, rather than opt-out, like most of our competitors. Privacy Mode is not a setting to be toggled, it's a default stance. @@ -12,6 +12,8 @@ It is entirely possible to use Zed, including Zed's AI capabilities, without sha ## Documentation +- [Worktree trust](../worktree-trust.md): How Zed opens files and directories in restricted mode. + - [Telemetry](../telemetry.md): How Zed collects general telemetry data. - [AI Improvement](./ai-improvement.md): Zed's opt-in-only approach to data collection for AI improvement, whether our Agentic offering or Edit Predictions. diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md index 549dbe6fbb47b03a372ee3ddac87b72dbc4d9c2e..8a638d9f7857e1a55aaa5589a77110a7b803bbfe 100644 --- a/docs/src/configuring-zed.md +++ b/docs/src/configuring-zed.md @@ -1451,6 +1451,47 @@ or `boolean` values +### Session + +- Description: Controls Zed lifecycle-related behavior. +- Setting: `session` +- Default: + +```json +{ + "session": { + "restore_unsaved_buffers": true, + "trust_all_worktrees": false + } +} +``` + +**Options** + +1. Whether or not to restore unsaved buffers on restart: + +```json [settings] +{ + "session": { + "restore_unsaved_buffers": true + } +} +``` + +If this is true, user won't be prompted whether to save/discard dirty files when closing the application. + +2. Whether or not to skip worktree and workspace trust checks: + +```json [settings] +{ + "session": { + "trust_all_worktrees": false + } +} +``` + +When trusted, project settings are synchronized automatically, language and MCP servers are downloaded and started automatically. + ### Drag And Drop Selection - Description: Whether to allow drag and drop text selection in buffer. `delay` is the milliseconds that must elapse before drag and drop is allowed. Otherwise, a new text selection is created. diff --git a/docs/src/worktree-trust.md b/docs/src/worktree-trust.md new file mode 100644 index 0000000000000000000000000000000000000000..158851117bfdc4d00746594d74e1e6dae0bb84dc --- /dev/null +++ b/docs/src/worktree-trust.md @@ -0,0 +1,66 @@ +# Zed and trusted worktrees + +A worktree in Zed is either a directory or a single file that Zed opens as a standalone "project". +Zed opens a worktree every time `zed some/path` is invoked, on drag and dropping a file or directory into Zed, on opening user settings.json, etc. + +Every worktree opened may contain a `.zed/settings.json` file with extra configuration options that may require installing and spawning language servers or MCP servers. +Note that the Zed workspace itself may also perform user-configured MCP server installation and spawning, even if no worktrees are open. + +In order to provide users the opportunity to make their own choices according to their unique threat model and risk tolerance, the workspace and all worktrees will be started in Restricted mode, which prevents download and execution of any related items. Until configured to trust the workspace and/or worktrees, Zed will not perform any untrusted actions and will wait for user confirmation. This gives users a chance to review and understand any pre-configured settings, MCP servers, or language servers associated with a project. + +If a worktree is not trusted, Zed will indicate this with an exclamation mark icon in the title bar and a message in the Agent panel. Clicking this icon or using `workspace::ToggleWorktreeSecurity` action will bring up the security modal that allows the user to trust the worktree. + +Trusting any worktree will persist this information between restarts. It's possible to clear all trusted worktrees with `workspace::ClearTrustedWorktrees` command. +This command will restart Zed, to ensure no untrusted settings, language servers or MCP servers persist. + +This feature works locally and on SSH and WSL remote hosts. Zed tracks trust information per host in these cases. + +## What is restricted + +Restricted Mode prevents: + +- Project settings (`.zed/settings.json`) from being parsed and applied +- Language servers from being installed and spawned +- MCP servers from being installed and spawned + +## Configuring broad worktree trust + +By default, Zed won't trust any new worktrees and users will be required to trust each new worktree. Though not recommended, users may elect to trust all worktrees and the current workspace for a given session by configuring the following setting: + +```json [settings] +"session": { + "trust_all_worktrees": true +} +``` + +Note that auto trusted worktrees are not persisted between restarts, only manually trusted worktrees are. This ensures that new trust decisions must be made if a users elects to disable the `trust_all_worktrees` setting. + +## Trust hierarchy + +These are mostly internal details and may change in the future, but are helpful to understand how multiple different trust requests can be approved at once. +Zed has multiple layers of trust, based on the requests, from the least to most trusted level: + +- "single file worktree" + +After opening an empty Zed it's possible to open just a file, same as after opening a directory in Zed it's possible to open a file outside of this directory. +A typical scenario where a directory might be open and a single file is subsequently opened is opening Zed's settings.json file via `zed: open settings file` command: that starts a language server for a new file open, which originates from a newly created, single file worktree. + +Spawning a language server presents a risk should the language server experience a supply-chain attack; therefore, Zed restricts that by default. Each single file worktree requires a separate trust grant, unless the directory containing it is trusted or all worktrees are trusted. + +- "workspace" + +Even an empty Zed workspace with no files or directories open presents a risk if new MCP servers are locally configured by the user without review. For instance, opening an Assistant Panel and creating a new external agent thread might require installing and running new user-configured [Model Context Protocol servers](./ai/mcp.md). By default, zed will restrict a new MCP server until the user elects to trust the local workspace. Users may also disable the entire Agent panel if preferred; see [AI Configuration](./ai/configuration.md) for more details. + +Workspace trust, permitted by trusting Zed with no worktrees open, allows locally configured resources to be downloaded and executed. Workspace trust is per host and also trusts all single file worktrees from the same host in order to permit all local user-configured MCP and language servers to start. + +- "directory worktree" + +If a directory is open in Zed, it's a full worktree which may spawn multiple language servers associated with it or spawn MCP servers if contained in a project settings file.Therefore, each directory worktree requires a separate trust grant unless a parent directory worktree trust is granted (see below). + +When a directory worktree is trusted, language and MCP servers are permitted to be downloaded and started, hence we also enable workspace trust for the host in question automatically when this occurs. + +- "parent directory worktree" + +To permit trust decisions for multiple directory worktrees at once, it's possible to trust all subdirectories of a given parent directory worktree opened in Zed by checking the appropriate checkbox. This will grant trust to all its subdirectories, including all current and potential directory worktrees. + +This also automatically enables workspace trust to permit the newly trusted resources to download and start. From be1f824a35f414effa888a3959371a289cb84876 Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Tue, 16 Dec 2025 11:38:46 -0700 Subject: [PATCH 075/266] Fix agent notification getting stuck when thread view is dropped (#44939) Closes #32951 ## Summary When an agent notification was shown and the `AcpThreadView` was dropped (e.g., by closing the project window or navigating to a new thread), the notification would become orphaned and undismissable because the subscriptions handling dismiss events were dropped along with the thread view. ## Fix Added an `on_release` callback that closes all notification windows when the thread view is dropped. This ensures notifications are always cleaned up properly. ## Testing Added `test_notification_closed_when_thread_view_dropped` to verify notifications are closed when the thread view is dropped. Release Notes: - Fixed agent notification getting stuck and becoming undismissable when the project window is closed or when navigating to a new thread --- crates/agent_ui/src/acp/thread_view.rs | 66 +++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 2 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index cabdaf920c9597e85176f11f4f3a466c4ab96fe8..90134ebfb458a37f01ed99fe7345238c763e5418 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -389,6 +389,17 @@ impl AcpThreadView { ), ]; + cx.on_release(|this, cx| { + for window in this.notifications.drain(..) { + window + .update(cx, |_, window, _| { + window.remove_window(); + }) + .ok(); + } + }) + .detach(); + let show_codex_windows_warning = cfg!(windows) && project.read(cx).is_local() && agent.clone().downcast::().is_some(); @@ -5042,8 +5053,8 @@ impl AcpThreadView { }); if let Some(screen_window) = cx - .open_window(options, |_, cx| { - cx.new(|_| { + .open_window(options, |_window, cx| { + cx.new(|_cx| { AgentNotification::new(title.clone(), caption.clone(), icon, project_name) }) }) @@ -6469,6 +6480,57 @@ pub(crate) mod tests { ); } + #[gpui::test] + async fn test_notification_closed_when_thread_view_dropped(cx: &mut TestAppContext) { + init_test(cx); + + let (thread_view, cx) = setup_thread_view(StubAgentServer::default_response(), cx).await; + + let weak_view = thread_view.downgrade(); + + let message_editor = cx.read(|cx| thread_view.read(cx).message_editor.clone()); + message_editor.update_in(cx, |editor, window, cx| { + editor.set_text("Hello", window, cx); + }); + + cx.deactivate_window(); + + thread_view.update_in(cx, |thread_view, window, cx| { + thread_view.send(window, cx); + }); + + cx.run_until_parked(); + + // Verify notification is shown + assert!( + cx.windows() + .iter() + .any(|window| window.downcast::().is_some()), + "Expected notification to be shown" + ); + + // Drop the thread view (simulating navigation to a new thread) + drop(thread_view); + drop(message_editor); + // Trigger an update to flush effects, which will call release_dropped_entities + cx.update(|_window, _cx| {}); + cx.run_until_parked(); + + // Verify the entity was actually released + assert!( + !weak_view.is_upgradable(), + "Thread view entity should be released after dropping" + ); + + // The notification should be automatically closed via on_release + assert!( + !cx.windows() + .iter() + .any(|window| window.downcast::().is_some()), + "Notification should be closed when thread view is dropped" + ); + } + async fn setup_thread_view( agent: impl AgentServer + 'static, cx: &mut TestAppContext, From bd5569b338234c66d4fd850e0c3d0f0446ba1371 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Tue, 16 Dec 2025 20:41:38 +0200 Subject: [PATCH 076/266] Bump tree-sitter to the latest (#44963) Release Notes: - N/A Co-authored-by: Lukas Wirth --- Cargo.lock | 294 +++++++++++------- Cargo.toml | 6 +- crates/editor/src/jsx_tag_auto_close.rs | 2 +- crates/extension_host/src/wasm_host.rs | 10 +- crates/extension_host/src/wasm_host/wit.rs | 2 +- .../src/wasm_host/wit/since_v0_8_0.rs | 4 +- .../src/syntax_map/syntax_map_tests.rs | 4 +- crates/vim/src/object.rs | 2 +- 8 files changed, 200 insertions(+), 124 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b89c0803c7ed9a1b90fc3e8fc55eab10cee7b905..2d0cb8235d547c5486ffd89e3d54fd8d46a54f0c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -111,6 +111,15 @@ dependencies = [ "workspace", ] +[[package]] +name = "addr2line" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" +dependencies = [ + "gimli 0.31.1", +] + [[package]] name = "addr2line" version = "0.25.1" @@ -1997,7 +2006,7 @@ version = "0.3.76" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" dependencies = [ - "addr2line", + "addr2line 0.25.1", "cfg-if", "libc", "miniz_oxide", @@ -2656,9 +2665,9 @@ dependencies = [ [[package]] name = "cap-fs-ext" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e41cc18551193fe8fa6f15c1e3c799bc5ec9e2cfbfaa8ed46f37013e3e6c173c" +checksum = "d5528f85b1e134ae811704e41ef80930f56e795923f866813255bc342cc20654" dependencies = [ "cap-primitives", "cap-std", @@ -2668,9 +2677,9 @@ dependencies = [ [[package]] name = "cap-net-ext" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f83833816c66c986e913b22ac887cec216ea09301802054316fc5301809702c" +checksum = "20a158160765c6a7d0d8c072a53d772e4cb243f38b04bfcf6b4939cfbe7482e7" dependencies = [ "cap-primitives", "cap-std", @@ -2680,9 +2689,9 @@ dependencies = [ [[package]] name = "cap-primitives" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a1e394ed14f39f8bc26f59d4c0c010dbe7f0a1b9bafff451b1f98b67c8af62a" +checksum = "b6cf3aea8a5081171859ef57bc1606b1df6999df4f1110f8eef68b30098d1d3a" dependencies = [ "ambient-authority", "fs-set-times", @@ -2698,9 +2707,9 @@ dependencies = [ [[package]] name = "cap-rand" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0acb89ccf798a28683f00089d0630dfaceec087234eae0d308c05ddeaa941b40" +checksum = "d8144c22e24bbcf26ade86cb6501a0916c46b7e4787abdb0045a467eb1645a1d" dependencies = [ "ambient-authority", "rand 0.8.5", @@ -2708,9 +2717,9 @@ dependencies = [ [[package]] name = "cap-std" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07c0355ca583dd58f176c3c12489d684163861ede3c9efa6fd8bba314c984189" +checksum = "b6dc3090992a735d23219de5c204927163d922f42f575a0189b005c62d37549a" dependencies = [ "cap-primitives", "io-extras", @@ -2720,9 +2729,9 @@ dependencies = [ [[package]] name = "cap-time-ext" -version = "3.4.4" +version = "3.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "491af520b8770085daa0466978c75db90368c71896523f2464214e38359b1a5b" +checksum = "def102506ce40c11710a9b16e614af0cde8e76ae51b1f48c04b8d79f4b671a80" dependencies = [ "ambient-authority", "cap-primitives", @@ -3924,20 +3933,38 @@ dependencies = [ "libc", ] +[[package]] +name = "cranelift-assembler-x64" +version = "0.120.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5023e06632d8f351c2891793ccccfe4aef957954904392434038745fb6f1f68" +dependencies = [ + "cranelift-assembler-x64-meta", +] + +[[package]] +name = "cranelift-assembler-x64-meta" +version = "0.120.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1c4012b4c8c1f6eb05c0a0a540e3e1ee992631af51aa2bbb3e712903ce4fd65" +dependencies = [ + "cranelift-srcgen", +] + [[package]] name = "cranelift-bforest" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e15d04a0ce86cb36ead88ad68cf693ffd6cda47052b9e0ac114bc47fd9cd23c4" +checksum = "4d6d883b4942ef3a7104096b8bc6f2d1a41393f159ac8de12aed27b25d67f895" dependencies = [ "cranelift-entity", ] [[package]] name = "cranelift-bitset" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7c6e3969a7ce267259ce244b7867c5d3bc9e65b0a87e81039588dfdeaede9f34" +checksum = "db7b2ee9eec6ca8a716d900d5264d678fb2c290c58c46c8da7f94ee268175d17" dependencies = [ "serde", "serde_derive", @@ -3945,11 +3972,12 @@ dependencies = [ [[package]] name = "cranelift-codegen" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c22032c4cb42558371cf516bb47f26cdad1819d3475c133e93c49f50ebf304e" +checksum = "aeda0892577afdce1ac2e9a983a55f8c5b87a59334e1f79d8f735a2d7ba4f4b4" dependencies = [ "bumpalo", + "cranelift-assembler-x64", "cranelift-bforest", "cranelift-bitset", "cranelift-codegen-meta", @@ -3958,9 +3986,10 @@ dependencies = [ "cranelift-entity", "cranelift-isle", "gimli 0.31.1", - "hashbrown 0.14.5", + "hashbrown 0.15.5", "log", "postcard", + "pulley-interpreter", "regalloc2", "rustc-hash 2.1.1", "serde", @@ -3972,33 +4001,36 @@ dependencies = [ [[package]] name = "cranelift-codegen-meta" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c904bc71c61b27fc57827f4a1379f29de64fe95653b620a3db77d59655eee0b8" +checksum = "e461480d87f920c2787422463313326f67664e68108c14788ba1676f5edfcd15" dependencies = [ + "cranelift-assembler-x64-meta", "cranelift-codegen-shared", + "cranelift-srcgen", + "pulley-interpreter", ] [[package]] name = "cranelift-codegen-shared" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40180f5497572f644ce88c255480981ae2ec1d7bb4d8e0c0136a13b87a2f2ceb" +checksum = "976584d09f200c6c84c4b9ff7af64fc9ad0cb64dffa5780991edd3fe143a30a1" [[package]] name = "cranelift-control" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d132c6d0bd8a489563472afc171759da0707804a65ece7ceb15a8c6d7dd5ef" +checksum = "46d43d70f4e17c545aa88dbf4c84d4200755d27c6e3272ebe4de65802fa6a955" dependencies = [ "arbitrary", ] [[package]] name = "cranelift-entity" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b2d0d9618275474fbf679dd018ac6e009acbd6ae6850f6a67be33fb3b00b323" +checksum = "d75418674520cb400c8772bfd6e11a62736c78fc1b6e418195696841d1bf91f1" dependencies = [ "cranelift-bitset", "serde", @@ -4007,9 +4039,9 @@ dependencies = [ [[package]] name = "cranelift-frontend" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fac41e16729107393174b0c9e3730fb072866100e1e64e80a1a963b2e484d57" +checksum = "3c8b1a91c86687a344f3c52dd6dfb6e50db0dfa7f2e9c7711b060b3623e1fdeb" dependencies = [ "cranelift-codegen", "log", @@ -4019,21 +4051,27 @@ dependencies = [ [[package]] name = "cranelift-isle" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ca20d576e5070044d0a72a9effc2deacf4d6aa650403189d8ea50126483944d" +checksum = "711baa4e3432d4129295b39ec2b4040cc1b558874ba0a37d08e832e857db7285" [[package]] name = "cranelift-native" -version = "0.116.1" +version = "0.120.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8dee82f3f1f2c4cba9177f1cc5e350fe98764379bcd29340caa7b01f85076c7" +checksum = "41c83e8666e3bcc5ffeaf6f01f356f0e1f9dcd69ce5511a1efd7ca5722001a3f" dependencies = [ "cranelift-codegen", "libc", "target-lexicon 0.13.3", ] +[[package]] +name = "cranelift-srcgen" +version = "0.120.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02e3f4d783a55c64266d17dc67d2708852235732a100fc40dd9f1051adc64d7b" + [[package]] name = "crash-context" version = "0.6.3" @@ -12795,13 +12833,12 @@ checksum = "bd348ff538bc9caeda7ee8cad2d1d48236a1f443c1fa3913c6a02fe0043b1dd3" [[package]] name = "pulley-interpreter" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62d95f8575df49a2708398182f49a888cf9dc30210fb1fd2df87c889edcee75d" +checksum = "986beaef947a51d17b42b0ea18ceaa88450d35b6994737065ed505c39172db71" dependencies = [ "cranelift-bitset", "log", - "sptr", "wasmtime-math", ] @@ -13300,9 +13337,9 @@ dependencies = [ [[package]] name = "regalloc2" -version = "0.11.2" +version = "0.12.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc06e6b318142614e4a48bc725abbf08ff166694835c43c9dae5a9009704639a" +checksum = "5216b1837de2149f8bc8e6d5f88a9326b63b8c836ed58ce4a0a29ec736a59734" dependencies = [ "allocator-api2", "bumpalo", @@ -17311,9 +17348,9 @@ dependencies = [ [[package]] name = "tree-sitter" -version = "0.25.10" +version = "0.26.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78f873475d258561b06f1c595d93308a7ed124d9977cb26b148c2084a4a3cc87" +checksum = "974d205cc395652cfa8b37daa053fe56eebd429acf8dc055503fee648dae981e" dependencies = [ "cc", "regex", @@ -18400,6 +18437,16 @@ dependencies = [ "wasmparser 0.227.1", ] +[[package]] +name = "wasm-encoder" +version = "0.229.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38ba1d491ecacb085a2552025c10a675a6fddcbd03b1fc9b36c536010ce265d2" +dependencies = [ + "leb128fmt", + "wasmparser 0.229.0", +] + [[package]] name = "wasm-metadata" version = "0.201.0" @@ -18484,23 +18531,37 @@ dependencies = [ "semver", ] +[[package]] +name = "wasmparser" +version = "0.229.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc3b1f053f5d41aa55640a1fa9b6d1b8a9e4418d118ce308d20e24ff3575a8c" +dependencies = [ + "bitflags 2.9.4", + "hashbrown 0.15.5", + "indexmap", + "semver", + "serde", +] + [[package]] name = "wasmprinter" -version = "0.221.3" +version = "0.229.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7343c42a97f2926c7819ff81b64012092ae954c5d83ddd30c9fcdefd97d0b283" +checksum = "d25dac01892684a99b8fbfaf670eb6b56edea8a096438c75392daeb83156ae2e" dependencies = [ "anyhow", "termcolor", - "wasmparser 0.221.3", + "wasmparser 0.229.0", ] [[package]] name = "wasmtime" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11976a250672556d1c4c04c6d5d7656ac9192ac9edc42a4587d6c21460010e69" +checksum = "57373e1d8699662fb791270ac5dfac9da5c14f618ecf940cdb29dc3ad9472a3c" dependencies = [ + "addr2line 0.24.2", "anyhow", "async-trait", "bitflags 2.9.4", @@ -18508,7 +18569,7 @@ dependencies = [ "cc", "cfg-if", "encoding_rs", - "hashbrown 0.14.5", + "hashbrown 0.15.5", "indexmap", "libc", "log", @@ -18516,12 +18577,11 @@ dependencies = [ "memfd", "object 0.36.7", "once_cell", - "paste", "postcard", "psm", "pulley-interpreter", "rayon", - "rustix 0.38.44", + "rustix 1.1.2", "semver", "serde", "serde_derive", @@ -18529,7 +18589,7 @@ dependencies = [ "sptr", "target-lexicon 0.13.3", "trait-variant", - "wasmparser 0.221.3", + "wasmparser 0.229.0", "wasmtime-asm-macros", "wasmtime-component-macro", "wasmtime-component-util", @@ -18546,18 +18606,18 @@ dependencies = [ [[package]] name = "wasmtime-asm-macros" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f178b0d125201fbe9f75beaf849bd3e511891f9e45ba216a5b620802ccf64f2" +checksum = "bd0fc91372865167a695dc98d0d6771799a388a7541d3f34e939d0539d6583de" dependencies = [ "cfg-if", ] [[package]] name = "wasmtime-c-api-impl" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea30cef3608f2de5797c7bbb94c1ba4f3676d9a7f81ae86ced1b512e2766ed0c" +checksum = "46db556f1dccdd88e0672bd407162ab0036b72e5eccb0f4398d8251cba32dba1" dependencies = [ "anyhow", "log", @@ -18568,9 +18628,9 @@ dependencies = [ [[package]] name = "wasmtime-c-api-macros" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "022a79ebe1124d5d384d82463d7e61c6b4dd857d81f15cb8078974eeb86db65b" +checksum = "315cc6bc8cdc66f296accb26d7625ae64c1c7b6da6f189e8a72ce6594bf7bd36" dependencies = [ "proc-macro2", "quote", @@ -18578,9 +18638,9 @@ dependencies = [ [[package]] name = "wasmtime-component-macro" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d74de6592ed945d0a602f71243982a304d5d02f1e501b638addf57f42d57dfaf" +checksum = "25c9c7526675ff9a9794b115023c4af5128e3eb21389bfc3dc1fd344d549258f" dependencies = [ "anyhow", "proc-macro2", @@ -18588,20 +18648,20 @@ dependencies = [ "syn 2.0.106", "wasmtime-component-util", "wasmtime-wit-bindgen", - "wit-parser 0.221.3", + "wit-parser 0.229.0", ] [[package]] name = "wasmtime-component-util" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "707dc7b3c112ab5a366b30cfe2fb5b2f8e6a0f682f16df96a5ec582bfe6f056e" +checksum = "cc42ec8b078875804908d797cb4950fec781d9add9684c9026487fd8eb3f6291" [[package]] name = "wasmtime-cranelift" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "366be722674d4bf153290fbcbc4d7d16895cc82fb3e869f8d550ff768f9e9e87" +checksum = "b2bd72f0a6a0ffcc6a184ec86ac35c174e48ea0e97bbae277c8f15f8bf77a566" dependencies = [ "anyhow", "cfg-if", @@ -18611,22 +18671,23 @@ dependencies = [ "cranelift-frontend", "cranelift-native", "gimli 0.31.1", - "itertools 0.12.1", + "itertools 0.14.0", "log", "object 0.36.7", + "pulley-interpreter", "smallvec", "target-lexicon 0.13.3", - "thiserror 1.0.69", - "wasmparser 0.221.3", + "thiserror 2.0.17", + "wasmparser 0.229.0", "wasmtime-environ", "wasmtime-versioned-export-macros", ] [[package]] name = "wasmtime-environ" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cdadc1af7097347aa276a4f008929810f726b5b46946971c660b6d421e9994ad" +checksum = "e6187bb108a23eb25d2a92aa65d6c89fb5ed53433a319038a2558567f3011ff2" dependencies = [ "anyhow", "cpp_demangle", @@ -18643,22 +18704,22 @@ dependencies = [ "serde_derive", "smallvec", "target-lexicon 0.13.3", - "wasm-encoder 0.221.3", - "wasmparser 0.221.3", + "wasm-encoder 0.229.0", + "wasmparser 0.229.0", "wasmprinter", "wasmtime-component-util", ] [[package]] name = "wasmtime-fiber" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ccba90d4119f081bca91190485650730a617be1fff5228f8c4757ce133d21117" +checksum = "dc8965d2128c012329f390e24b8b2758dd93d01bf67e1a1a0dd3d8fd72f56873" dependencies = [ "anyhow", "cc", "cfg-if", - "rustix 0.38.44", + "rustix 1.1.2", "wasmtime-asm-macros", "wasmtime-versioned-export-macros", "windows-sys 0.59.0", @@ -18666,9 +18727,9 @@ dependencies = [ [[package]] name = "wasmtime-jit-icache-coherence" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec5e8552e01692e6c2e5293171704fed8abdec79d1a6995a0870ab190e5747d1" +checksum = "7af0e940cb062a45c0b3f01a926f77da5947149e99beb4e3dd9846d5b8f11619" dependencies = [ "anyhow", "cfg-if", @@ -18678,24 +18739,24 @@ dependencies = [ [[package]] name = "wasmtime-math" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29210ec2aa25e00f4d54605cedaf080f39ec01a872c5bd520ad04c67af1dde17" +checksum = "acfca360e719dda9a27e26944f2754ff2fd5bad88e21919c42c5a5f38ddd93cb" dependencies = [ "libm", ] [[package]] name = "wasmtime-slab" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcb5821a96fa04ac14bc7b158bb3d5cd7729a053db5a74dad396cd513a5e5ccf" +checksum = "48e240559cada55c4b24af979d5f6c95e0029f5772f32027ec3c62b258aaff65" [[package]] name = "wasmtime-versioned-export-macros" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "86ff86db216dc0240462de40c8290887a613dddf9685508eb39479037ba97b5b" +checksum = "d0963c1438357a3d8c0efe152b4ef5259846c1cf8b864340270744fe5b3bae5e" dependencies = [ "proc-macro2", "quote", @@ -18704,9 +18765,9 @@ dependencies = [ [[package]] name = "wasmtime-wasi" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d1be69bfcab1bdac74daa7a1f9695ab992b9c8e21b9b061e7d66434097e0ca4" +checksum = "4ae951b72c7c6749a1c15dcdfb6d940a2614c932b4a54f474636e78e2c744b4c" dependencies = [ "anyhow", "async-trait", @@ -18721,30 +18782,43 @@ dependencies = [ "futures 0.3.31", "io-extras", "io-lifetimes", - "rustix 0.38.44", + "rustix 1.1.2", "system-interface", - "thiserror 1.0.69", + "thiserror 2.0.17", "tokio", "tracing", - "trait-variant", "url", "wasmtime", + "wasmtime-wasi-io", "wiggle", "windows-sys 0.59.0", ] +[[package]] +name = "wasmtime-wasi-io" +version = "33.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a835790dcecc3d7051ec67da52ba9e04af25e1bc204275b9391e3f0042b10797" +dependencies = [ + "anyhow", + "async-trait", + "bytes 1.10.1", + "futures 0.3.31", + "wasmtime", +] + [[package]] name = "wasmtime-winch" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdbabfb8f20502d5e1d81092b9ead3682ae59988487aafcd7567387b7a43cf8f" +checksum = "cbc3b117d03d6eeabfa005a880c5c22c06503bb8820f3aa2e30f0e8d87b6752f" dependencies = [ "anyhow", "cranelift-codegen", "gimli 0.31.1", "object 0.36.7", "target-lexicon 0.13.3", - "wasmparser 0.221.3", + "wasmparser 0.229.0", "wasmtime-cranelift", "wasmtime-environ", "winch-codegen", @@ -18752,14 +18826,14 @@ dependencies = [ [[package]] name = "wasmtime-wit-bindgen" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8358319c2dd1e4db79e3c1c5d3a5af84956615343f9f89f4e4996a36816e06e6" +checksum = "1382f4f09390eab0d75d4994d0c3b0f6279f86a571807ec67a8253c87cf6a145" dependencies = [ "anyhow", "heck 0.5.0", "indexmap", - "wit-parser 0.221.3", + "wit-parser 0.229.0", ] [[package]] @@ -19053,14 +19127,14 @@ dependencies = [ [[package]] name = "wiggle" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b9af35bc9629c52c261465320a9a07959164928b4241980ba1cf923b9e6751d" +checksum = "649c1aca13ef9e9dccf2d5efbbebf12025bc5521c3fb7754355ef60f5eb810be" dependencies = [ "anyhow", "async-trait", "bitflags 2.9.4", - "thiserror 1.0.69", + "thiserror 2.0.17", "tracing", "wasmtime", "wiggle-macro", @@ -19068,24 +19142,23 @@ dependencies = [ [[package]] name = "wiggle-generate" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2cf267dd05673912c8138f4b54acabe6bd53407d9d1536f0fadb6520dd16e101" +checksum = "164870fc34214ee42bd81b8ce9e7c179800fa1a7d4046d17a84e7f7bf422c8ad" dependencies = [ "anyhow", "heck 0.5.0", "proc-macro2", "quote", - "shellexpand 2.1.2", "syn 2.0.106", "witx", ] [[package]] name = "wiggle-macro" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08c5c473d4198e6c2d377f3809f713ff0c110cab88a0805ae099a82119ee250c" +checksum = "d873bb5b59ca703b5e41562e96a4796d1af61bf4cf80bf8a7abda755a380ec1c" dependencies = [ "proc-macro2", "quote", @@ -19126,18 +19199,19 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] name = "winch-codegen" -version = "29.0.1" +version = "33.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f849ef2c5f46cb0a20af4b4487aaa239846e52e2c03f13fa3c784684552859c" +checksum = "7914c296fbcef59d1b89a15e82384d34dc9669bc09763f2ef068a28dd3a64ebf" dependencies = [ "anyhow", + "cranelift-assembler-x64", "cranelift-codegen", "gimli 0.31.1", "regalloc2", "smallvec", "target-lexicon 0.13.3", - "thiserror 1.0.69", - "wasmparser 0.221.3", + "thiserror 2.0.17", + "wasmparser 0.229.0", "wasmtime-cranelift", "wasmtime-environ", ] @@ -20035,9 +20109,9 @@ dependencies = [ [[package]] name = "wit-parser" -version = "0.221.3" +version = "0.227.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "896112579ed56b4a538b07a3d16e562d101ff6265c46b515ce0c701eef16b2ac" +checksum = "ddf445ed5157046e4baf56f9138c124a0824d4d1657e7204d71886ad8ce2fc11" dependencies = [ "anyhow", "id-arena", @@ -20048,14 +20122,14 @@ dependencies = [ "serde_derive", "serde_json", "unicode-xid", - "wasmparser 0.221.3", + "wasmparser 0.227.1", ] [[package]] name = "wit-parser" -version = "0.227.1" +version = "0.229.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ddf445ed5157046e4baf56f9138c124a0824d4d1657e7204d71886ad8ce2fc11" +checksum = "459c6ba62bf511d6b5f2a845a2a736822e38059c1cfa0b644b467bbbfae4efa6" dependencies = [ "anyhow", "id-arena", @@ -20066,7 +20140,7 @@ dependencies = [ "serde_derive", "serde_json", "unicode-xid", - "wasmparser 0.227.1", + "wasmparser 0.229.0", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 903d17fc3378519d3e632f63c1a1a0e08e6513cb..f46ffa2583c022be8704e95684ddce65b19d3fab 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -663,7 +663,7 @@ tokio-socks = { version = "0.5.2", default-features = false, features = ["future toml = "0.8" toml_edit = { version = "0.22", default-features = false, features = ["display", "parse", "serde"] } tower-http = "0.4.4" -tree-sitter = { version = "0.25.10", features = ["wasm"] } +tree-sitter = { version = "0.26", features = ["wasm"] } tree-sitter-bash = "0.25.1" tree-sitter-c = "0.23" tree-sitter-cpp = { git = "https://github.com/tree-sitter/tree-sitter-cpp", rev = "5cb9b693cfd7bfacab1d9ff4acac1a4150700609" } @@ -697,7 +697,7 @@ uuid = { version = "1.1.2", features = ["v4", "v5", "v7", "serde"] } walkdir = "2.5" wasm-encoder = "0.221" wasmparser = "0.221" -wasmtime = { version = "29", default-features = false, features = [ +wasmtime = { version = "33", default-features = false, features = [ "async", "demangle", "runtime", @@ -706,7 +706,7 @@ wasmtime = { version = "29", default-features = false, features = [ "incremental-cache", "parallel-compilation", ] } -wasmtime-wasi = "29" +wasmtime-wasi = "33" wax = "0.6" which = "6.0.0" windows-core = "0.61" diff --git a/crates/editor/src/jsx_tag_auto_close.rs b/crates/editor/src/jsx_tag_auto_close.rs index e22fde313df4b99b7b650775ad7e7397e3c4f813..1d808c968d579569fb595a5a1a0ddaa4dbc718b3 100644 --- a/crates/editor/src/jsx_tag_auto_close.rs +++ b/crates/editor/src/jsx_tag_auto_close.rs @@ -19,7 +19,7 @@ pub struct JsxTagCompletionState { /// that corresponds to the tag name /// Note that this is not configurable, i.e. we assume the first /// named child of a tag node is the tag name -const TS_NODE_TAG_NAME_CHILD_INDEX: usize = 0; +const TS_NODE_TAG_NAME_CHILD_INDEX: u32 = 0; /// Maximum number of parent elements to walk back when checking if an open tag /// is already closed. diff --git a/crates/extension_host/src/wasm_host.rs b/crates/extension_host/src/wasm_host.rs index cecaf2039bc6dc049ece1177700a14eead3d86bc..a6e5768f16243ce6c6a4d250002e29d5db06a071 100644 --- a/crates/extension_host/src/wasm_host.rs +++ b/crates/extension_host/src/wasm_host.rs @@ -45,7 +45,7 @@ use wasmtime::{ CacheStore, Engine, Store, component::{Component, ResourceTable}, }; -use wasmtime_wasi::{self as wasi, WasiView}; +use wasmtime_wasi::p2::{self as wasi, IoView as _}; use wit::Extension; pub struct WasmHost { @@ -685,8 +685,8 @@ impl WasmHost { .await .context("failed to create extension work dir")?; - let file_perms = wasi::FilePerms::all(); - let dir_perms = wasi::DirPerms::all(); + let file_perms = wasmtime_wasi::FilePerms::all(); + let dir_perms = wasmtime_wasi::DirPerms::all(); let path = SanitizedPath::new(&extension_work_dir).to_string(); #[cfg(target_os = "windows")] let path = path.replace('\\', "/"); @@ -856,11 +856,13 @@ impl WasmState { } } -impl wasi::WasiView for WasmState { +impl wasi::IoView for WasmState { fn table(&mut self) -> &mut ResourceTable { &mut self.table } +} +impl wasi::WasiView for WasmState { fn ctx(&mut self) -> &mut wasi::WasiCtx { &mut self.ctx } diff --git a/crates/extension_host/src/wasm_host/wit.rs b/crates/extension_host/src/wasm_host/wit.rs index 5058c63365021a00dc9abf9fc05e9085757e161e..e080915b4fe1f18325843961db36e2fbc16bd418 100644 --- a/crates/extension_host/src/wasm_host/wit.rs +++ b/crates/extension_host/src/wasm_host/wit.rs @@ -45,7 +45,7 @@ pub fn new_linker( f: impl Fn(&mut Linker, fn(&mut WasmState) -> &mut WasmState) -> Result<()>, ) -> Linker { let mut linker = Linker::new(&wasm_engine(executor)); - wasmtime_wasi::add_to_linker_async(&mut linker).unwrap(); + wasmtime_wasi::p2::add_to_linker_async(&mut linker).unwrap(); f(&mut linker, wasi_view).unwrap(); linker } diff --git a/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs b/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs index a2776f9f3b5b055d00787fb59c9bbca582352b1f..b2e0a1a4fbbf302a41cd509c27df9f52dc9a788d 100644 --- a/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs +++ b/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs @@ -1,7 +1,7 @@ use crate::wasm_host::wit::since_v0_6_0::{ dap::{ - AttachRequest, BuildTaskDefinition, BuildTaskDefinitionTemplatePayload, LaunchRequest, - StartDebuggingRequestArguments, TcpArguments, TcpArgumentsTemplate, + BuildTaskDefinition, BuildTaskDefinitionTemplatePayload, StartDebuggingRequestArguments, + TcpArguments, TcpArgumentsTemplate, }, slash_command::SlashCommandOutputSection, }; diff --git a/crates/language/src/syntax_map/syntax_map_tests.rs b/crates/language/src/syntax_map/syntax_map_tests.rs index 1eb63772760719a381d16795ecde0c4a3293c789..2a9f7f172388f99543ac979938a3e8fec9db541a 100644 --- a/crates/language/src/syntax_map/syntax_map_tests.rs +++ b/crates/language/src/syntax_map/syntax_map_tests.rs @@ -1133,8 +1133,8 @@ fn check_interpolation( check_node_edits( depth, range, - old_node.child(i).unwrap(), - new_node.child(i).unwrap(), + old_node.child(i as u32).unwrap(), + new_node.child(i as u32).unwrap(), old_buffer, new_buffer, edits, diff --git a/crates/vim/src/object.rs b/crates/vim/src/object.rs index f11386d02d6846343645b6c7514603f16396163c..98c14855a3e20623c87d6204c1c4233f20008cbb 100644 --- a/crates/vim/src/object.rs +++ b/crates/vim/src/object.rs @@ -911,7 +911,7 @@ pub fn surrounding_html_tag( while let Some(cur_node) = last_child_node { if cur_node.child_count() >= 2 { let first_child = cur_node.child(0); - let last_child = cur_node.child(cur_node.child_count() - 1); + let last_child = cur_node.child(cur_node.child_count() as u32 - 1); if let (Some(first_child), Some(last_child)) = (first_child, last_child) { let open_tag = open_tag(buffer.chars_for_range(first_child.byte_range())); let close_tag = close_tag(buffer.chars_for_range(last_child.byte_range())); From 7098952a1ca2291d113a18b08477ee8a5aa663d9 Mon Sep 17 00:00:00 2001 From: Katie Geer Date: Tue, 16 Dec 2025 10:47:24 -0800 Subject: [PATCH 077/266] docs: Migrate from Intellij (#44928) Adding migration guide for Intellij as well as a doc of rules for agents to help write future docs Release Notes: - N/A... --- docs/.rules | 157 +++++++++++++++ docs/src/SUMMARY.md | 3 +- docs/src/migrate/intellij.md | 357 +++++++++++++++++++++++++++++++++++ 3 files changed, 516 insertions(+), 1 deletion(-) create mode 100644 docs/.rules create mode 100644 docs/src/migrate/intellij.md diff --git a/docs/.rules b/docs/.rules new file mode 100644 index 0000000000000000000000000000000000000000..17c0e97450ce50f6846c865d58289257f2008f5c --- /dev/null +++ b/docs/.rules @@ -0,0 +1,157 @@ +# Zed Documentation Guidelines + +## Voice and Tone + +### Core Principles + +- **Practical over promotional**: Focus on what users can do, not on selling Zed. Avoid marketing language like "powerful," "revolutionary," or "best-in-class." +- **Honest about limitations**: When Zed lacks a feature or doesn't match another tool's depth, say so directly. Pair limitations with workarounds or alternative workflows. +- **Direct and concise**: Use short sentences. Get to the point. Developers are scanning, not reading novels. +- **Second person**: Address the reader as "you." Avoid "the user" or "one." +- **Present tense**: "Zed opens the file" not "Zed will open the file." + +### What to Avoid + +- Superlatives without substance ("incredibly fast," "seamlessly integrated") +- Hedging language ("simply," "just," "easily")—if something is simple, the instructions will show it +- Apologetic tone for missing features—state the limitation and move on +- Comparisons that disparage other tools—be factual, not competitive +- Meta-commentary about honesty ("the honest take is...", "to be frank...", "honestly...")—let honesty show through frank assessments, not announcements + +## Content Structure + +### Page Organization + +1. **Start with the goal**: Open with what the reader will accomplish, not background +2. **Front-load the action**: Put the most common task first, edge cases later +3. **Use headers liberally**: Readers scan; headers help them find what they need +4. **End with "what's next"**: Link to related docs or logical next steps + +### Section Patterns + +For how-to content: +1. Brief context (1-2 sentences max) +2. Steps or instructions +3. Example (code block or screenshot reference) +4. Tips or gotchas (if any) + +For reference content: +1. What it is (definition) +2. How to access/configure it +3. Options/parameters table +4. Examples + +## Formatting Conventions + +### Keybindings + +- Use backticks for key combinations: `Cmd+Shift+P` +- Show both macOS and Linux/Windows when they differ: `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +- Use `+` to join simultaneous keys, space for sequences: `Cmd+K Cmd+C` + +### Code and Settings + +- Inline code for setting names, file paths, commands: `format_on_save`, `.zed/settings.json`, `zed .` +- Code blocks for JSON config, multi-line commands, or file contents +- Always show complete, working examples—not fragments + +### Terminal Commands + +Use `sh` code blocks for terminal commands, not plain backticks: + +```sh +brew install zed-editor/zed/zed +``` + +Not: +``` +brew install zed-editor/zed/zed +``` + +For single inline commands in prose, backticks are fine: `zed .` + +### Tables + +Use tables for: +- Keybinding comparisons between editors +- Settings mappings (e.g., VS Code → Zed) +- Feature comparisons with clear columns + +Format: +``` +| Action | Shortcut | Notes | +| --- | --- | --- | +| Open File | `Cmd+O` | Works from any context | +``` + +### Tips and Notes + +Use blockquote format with bold label: +``` +> **Tip:** Practical advice that helps bridge gaps or saves time. +``` + +Reserve tips for genuinely useful information, not padding. + +## Writing Guidelines + +### Settings Documentation + +- **Settings Editor first**: Show how to find and change settings in the UI before showing JSON +- **JSON as secondary**: Present JSON examples as "Or add this to your settings.json" for users who prefer direct editing +- **Complete examples**: Include the full JSON structure, not just the value + +### Migration Guides + +- **Jobs to be done**: Frame around tasks ("How do I search files?") not features ("File Search Feature") +- **Acknowledge the source**: Respect that users have muscle memory and preferences from their previous editor +- **Keybindings tables**: Essential for migration docs—show what maps, what's different, what's missing +- **Trade-offs section**: Be explicit about what the user gains and loses in the switch + +### Feature Documentation + +- **Start with the default**: Document the out-of-box experience first +- **Configuration options**: Group related settings together +- **Cross-link generously**: Link to related features, settings reference, and relevant guides + +## Terminology + +| Use | Instead of | +| --- | --- | +| folder | directory (in user-facing text) | +| project | workspace (Zed doesn't have workspaces) | +| Settings Editor | settings UI, preferences | +| command palette | command bar, action search | +| language server | LSP (spell out first use, then LSP is fine) | +| panel | tool window, sidebar (be specific: "Project Panel," "Terminal Panel") | + +## Examples + +### Good: Direct and actionable +``` +To format on save, open the Settings Editor (`Cmd+,`) and search for `format_on_save`. Set it to `on`. + +Or add this to your settings.json: +{ + "format_on_save": "on" +} +``` + +### Bad: Wordy and promotional +``` +Zed provides a powerful and seamless formatting experience. Simply navigate to the settings and you'll find the format_on_save option which enables Zed's incredible auto-formatting capabilities. +``` + +### Good: Honest about limitations +``` +Zed doesn't index your project like IntelliJ does. You open a folder and start working immediately—no waiting. The trade-off: cross-project analysis relies on language servers, which may not go as deep. + +**How to adapt:** +- Use `Cmd+Shift+F` for project-wide text search +- Use `Cmd+O` for symbol search (powered by your language server) +``` + +### Bad: Defensive or dismissive +``` +While some users might miss indexing, Zed's approach is actually better because it's faster. +``` diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index 6514bd6455d85fe390bebce10096fc4edc5a9f0a..d6dd7a0aef9737fb095e87705e813f87fd0ed683 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -87,9 +87,10 @@ - [Agent Server Extensions](./extensions/agent-servers.md) - [MCP Server Extensions](./extensions/mcp-extensions.md) -# Migrate +# Coming From... - [VS Code](./migrate/vs-code.md) +- [IntelliJ IDEA](./migrate/intellij.md) # Language Support diff --git a/docs/src/migrate/intellij.md b/docs/src/migrate/intellij.md new file mode 100644 index 0000000000000000000000000000000000000000..d931fde4f1c2cd98db6b154d7009feff6fcb6a5b --- /dev/null +++ b/docs/src/migrate/intellij.md @@ -0,0 +1,357 @@ +# How to Migrate from IntelliJ IDEA to Zed + +This guide covers how to set up Zed if you're coming from IntelliJ IDEA, including keybindings, settings, and the differences you should expect. + +## Install Zed + +Zed is available on macOS, Windows, and Linux. + +For macOS, you can download it from zed.dev/download, or install via Homebrew: + +```sh +brew install --cask zed +``` + +For Windows, download the installer from zed.dev/download, or install via winget: + +```sh +winget install Zed.Zed +``` + +For most Linux users, the easiest way to install Zed is through our installation script: + +```sh +curl -f https://zed.dev/install.sh | sh +``` + +After installation, you can launch Zed from your Applications folder (macOS), Start menu (Windows), or directly from the terminal using: +`zed .` +This opens the current directory in Zed. + +## Set Up the JetBrains Keymap + +If you're coming from IntelliJ, the fastest way to feel at home is to use the JetBrains keymap. During onboarding, you can select it as your base keymap. If you missed that step, you can change it anytime: + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Search for `base_keymap` +3. Select `JetBrains` + +Or add this directly to your `settings.json`: + +```json +{ + "base_keymap": "JetBrains" +} +``` + +This maps familiar shortcuts like `Shift Shift` for Search Everywhere, `Cmd+O` for Go to Class, and `Cmd+Shift+A` for Find Action. + +## Set Up Editor Preferences + +You can configure settings manually in the Settings Editor. + +To edit your settings: + +1. `Cmd+,` to open the Settings Editor. +2. Run `zed: open settings` in the Command Palette. + +Settings IntelliJ users typically configure first: + +| Zed Setting | What it does | +| ----------------------- | ------------------------------------------------------------------------------- | +| `format_on_save` | Auto-format when saving. Set to `"on"` to enable. | +| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` | +| `preferred_line_length` | Column width for wrapping and rulers. Default is 80. | +| `inlay_hints` | Show parameter names and type hints inline, like IntelliJ's hints. | +| `relative_line_numbers` | Useful if you're coming from IdeaVim. | + +Zed also supports per-project settings. Create a `.zed/settings.json` file in your project root to override global settings for that project, similar to how you might use `.idea` folders in IntelliJ. + +> **Tip:** If you're joining an existing project, check `format_on_save` before making your first commit. Otherwise you might accidentally reformat an entire file when you only meant to change one line. + +## Open or Create a Project + +After setup, press `Cmd+Shift+O` (with JetBrains keymap) to open a folder. This becomes your workspace in Zed. Unlike IntelliJ, there's no project configuration wizard, no `.iml` files, and no SDK setup required. + +To start a new project, create a directory using your terminal or file manager, then open it in Zed. The editor will treat that folder as the root of your project. + +You can also launch Zed from the terminal inside any folder with: +`zed .` + +Once inside a project: + +- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like IntelliJ's "Recent Files") +- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like IntelliJ's "Search Everywhere") +- Use `Cmd+O` to search for symbols (like IntelliJ's "Go to Class") + +Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like IntelliJ's Project tool window). + +## Differences in Keybindings + +If you chose the JetBrains keymap during onboarding, most of your shortcuts should already feel familiar. Here's a quick reference for how Zed compares to IntelliJ. + +### Common Shared Keybindings (Zed with JetBrains keymap ↔ IntelliJ) + +| Action | Shortcut | +| ----------------------------- | ----------------------- | +| Search Everywhere | `Shift Shift` | +| Find Action / Command Palette | `Cmd + Shift + A` | +| Go to File | `Cmd + Shift + O` | +| Go to Symbol / Class | `Cmd + O` | +| Recent Files | `Cmd + E` | +| Go to Definition | `Cmd + B` | +| Find Usages | `Alt + F7` | +| Rename Symbol | `Shift + F6` | +| Reformat Code | `Cmd + Alt + L` | +| Toggle Project Panel | `Cmd + 1` | +| Toggle Terminal | `Alt + F12` | +| Duplicate Line | `Cmd + D` | +| Delete Line | `Cmd + Backspace` | +| Move Line Up/Down | `Shift + Alt + Up/Down` | +| Expand/Shrink Selection | `Alt + Up/Down` | +| Comment Line | `Cmd + /` | +| Go Back / Forward | `Cmd + [` / `Cmd + ]` | +| Toggle Breakpoint | `Ctrl + F8` | + +### Different Keybindings (IntelliJ → Zed) + +| Action | IntelliJ | Zed (JetBrains keymap) | +| ---------------------- | ----------- | ------------------------ | +| File Structure | `Cmd + F12` | `Cmd + F12` (outline) | +| Navigate to Next Error | `F2` | `F2` | +| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) | +| Debug | `Ctrl + D` | `Alt + Shift + F9` | +| Stop | `Cmd + F2` | `Ctrl + F2` | + +### Unique to Zed + +| Action | Shortcut | Notes | +| ----------------- | -------------------------- | ------------------------------ | +| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications | +| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction | + +### How to Customize Keybindings + +- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`) +- Run `Zed: Open Keymap Editor` + +This opens a list of all available bindings. You can override individual shortcuts or remove conflicts. + +Zed also supports key sequences (multi-key shortcuts). + +## Differences in User Interfaces + +### No Indexing + +If you've used IntelliJ on large projects, you know the wait: "Indexing..." can take anywhere from 30 seconds to 15 minutes depending on project size. IntelliJ builds a comprehensive index of your entire codebase to power its code intelligence, and it re-indexes when dependencies change or after builds. + +Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size. + +The trade-off is real: IntelliJ's index powers features like finding all usages across your entire codebase, understanding class hierarchies, and detecting dead code. Zed delegates this work to language servers, which may not analyze as deeply or as broadly. + +**How to adapt:** + +- For project-wide symbol search, use `Cmd+O` / Go to Symbol (relies on your language server) +- For finding files by name, use `Cmd+Shift+O` / Go to File +- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases +- If you need deep static analysis for JVM code, consider running IntelliJ's inspections as a separate step or using standalone tools like Checkstyle, PMD, or SpotBugs + +### LSP vs. Native Language Intelligence + +IntelliJ has its own language analysis engine built from scratch for each supported language. For Java, Kotlin, and other JVM languages, this engine understands your code deeply: it resolves types, tracks data flow, knows about framework annotations, and offers dozens of specialized refactorings. + +Zed uses the Language Server Protocol (LSP) for code intelligence. Each language has its own server: `jdtls` for Java, `rust-analyzer` for Rust, and so on. + +For some languages, the LSP experience is excellent. TypeScript, Rust, and Go have mature language servers that provide fast, accurate completions, diagnostics, and refactorings. For JVM languages, the gap might be more noticeable. The Eclipse-based Java language server is capable, but it won't match IntelliJ's depth for things like: + +- Spring and Jakarta EE annotation processing +- Complex refactorings (extract interface, pull members up, change signature with all callers) +- Framework-aware inspections +- Automatic import optimization with custom ordering rules + +**How to adapt:** + +- Use `Alt+Enter` for available code actions—the list will vary by language server +- For Java, ensure `jdtls` is properly configured with your JDK path in settings + +### No Project Model + +IntelliJ manages projects through `.idea` folders containing XML configuration files, `.iml` module definitions, SDK assignments, and run configurations. This model enables IntelliJ to understand multi-module projects, manage dependencies automatically, and persist complex run/debug setups. + +Zed has no project model. A project is a folder. There's no wizard, no SDK selection screen, no module configuration. + +This means: + +- Build commands are manual. Zed doesn't detect Maven or Gradle projects. +- Run configurations don't exist. You define tasks or use the terminal. +- SDK management is external. Your language server uses whatever JDK is on your PATH. +- There are no module boundaries. Zed sees folders, not project structure. + +**How to adapt:** + +- Create a `.zed/settings.json` in your project root for project-specific settings +- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`): + +```json +[ + { + "label": "build", + "command": "./gradlew build" + }, + { + "label": "run", + "command": "./gradlew bootRun" + }, + { + "label": "test current file", + "command": "./gradlew test --tests $ZED_STEM" + } +] +``` + +- Use `Ctrl+Alt+R` to run tasks quickly +- Lean on your terminal (`Alt+F12`) for anything tasks don't cover +- For multi-module projects, you can open each module as a separate Zed window, or open the root and navigate via file finder + +### No Framework Integration + +IntelliJ's value for enterprise Java development comes largely from its framework integration. Spring beans are understood and navigable. JPA entities get special treatment. Endpoints are indexed and searchable. Jakarta EE annotations modify how the IDE analyzes your code. + +Zed has none of this. The language server sees Java code as Java code, so it doesn't understand that `@Autowired` means something special or that this class is a REST controller. + +Similarly for other ecosystems: no Rails integration, no Django awareness, no Angular/React-specific tooling beyond what the TypeScript language server provides. + +**How to adapt:** + +- Use grep and file search liberally. `Cmd+Shift+F` with a regex can find endpoint definitions, bean names, or annotation usages. +- Rely on your language server's "find references" (`Alt+F7`) for navigation—it works, just without framework context +- For Spring Boot, keep the Actuator endpoints or a separate tool for understanding bean wiring +- Consider using framework-specific CLI tools (Spring CLI, Rails generators) from Zed's terminal + +> **Tip:** For database work, pick up a dedicated tool like DataGrip, DBeaver, or TablePlus. Many developers who switch to Zed keep DataGrip around specifically for SQL—it integrates well with your existing JetBrains license. + +If your daily work depends heavily on framework-aware navigation and refactoring, you'll feel the gap. Zed works best when you're comfortable navigating code through search rather than specialized tooling, or when your language has strong LSP support that covers most of what you need. + +### Tool Windows vs. Docks + +IntelliJ organizes auxiliary views into numbered tool windows (Project = 1, Git = 9, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks": + +| IntelliJ Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) | +| -------------------- | -------------- | --------------------------- | +| Project (1) | Project Panel | `Cmd + 1` | +| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` | +| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` | +| Structure (7) | Outline Panel | `Cmd + 7` | +| Problems (6) | Diagnostics | `Cmd + 6` | +| Debug (5) | Debug Panel | `Cmd + 5` | + +Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings. + +> **Tip:** IntelliJ has an "Override IDE shortcuts" setting that lets terminal shortcuts like `Ctrl+Left/Right` work normally. In Zed, terminal keybindings are separate—check your keymap if familiar shortcuts aren't working in the terminal panel. + +### Debugging + +Both IntelliJ and Zed offer integrated debugging, but the experience differs: + +- Zed's debugger uses the Debug Adapter Protocol (DAP), supporting multiple languages +- Set breakpoints with `Ctrl+F8` +- Start debugging with `Alt+Shift+F9` +- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out) +- Continue execution with `F9` + +The Debug Panel (`Cmd+5`) shows variables, call stack, and breakpoints—similar to IntelliJ's Debug tool window. + +### Extensions vs. Plugins + +IntelliJ has a massive plugin ecosystem covering everything from language support to database tools to deployment integrations. + +Zed's extension ecosystem is smaller and more focused: + +- Language support and syntax highlighting +- Themes +- Slash commands for AI +- Context servers + +Several features that require plugins in other editors are built into Zed: + +- Real-time collaboration with voice chat +- AI coding assistance +- Built-in terminal +- Task runner +- LSP-based code intelligence + +You won't find one-to-one replacements for every IntelliJ plugin, especially for framework-specific tools, database clients, or application server integrations. For those workflows, you may need to use external tools alongside Zed. + +## Collaboration in Zed vs. IntelliJ + +IntelliJ offers Code With Me as a separate plugin for collaboration. Zed has collaboration built into the core experience. + +- Open the Collab Panel in the left dock +- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join +- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly + +Once connected, you'll see each other's cursors, selections, and edits in real time. Voice chat is included. There's no need for separate tools or third-party logins. + +## Using AI in Zed + +If you're used to AI assistants in IntelliJ (like GitHub Copilot or JetBrains AI), Zed offers similar capabilities with more flexibility. + +### Configuring GitHub Copilot + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Navigate to **AI → Edit Predictions** +3. Click **Configure** next to "Configure Providers" +4. Under **GitHub Copilot**, click **Sign in to GitHub** + +Once signed in, just start typing. Zed will offer suggestions inline for you to accept. + +### Additional AI Options + +To use other AI models in Zed, you have several options: + +- Use Zed's hosted models, with higher rate limits. Requires [authentication](https://zed.dev/docs/accounts.html) and subscription to [Zed Pro](https://zed.dev/docs/ai/subscription.html). +- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed +- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html) + +## Advanced Config and Productivity Tweaks + +Zed exposes advanced settings for power users who want to fine-tune their environment. + +Here are a few useful tweaks: + +**Format on Save:** + +```json +"format_on_save": "on" +``` + +**Enable direnv support:** + +```json +"load_direnv": "shell_hook" +``` + +**Configure language servers**: For Java development, you may want to configure the Java language server in your settings: + +```json +{ + "lsp": { + "jdtls": { + "settings": { + "java_home": "/path/to/jdk" + } + } + } +} +``` + +## Next Steps + +Now that you're set up, here are some resources to help you get the most out of Zed: + +- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior +- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap +- [Tasks](../tasks.md) — Set up build and run commands for your projects +- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion +- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time +- [Languages](../languages.md) — Language-specific setup guides, including Java and Kotlin From e4029c13c9b4b8153296a81b1550f10b78f3e0ed Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Tue, 16 Dec 2025 19:55:34 +0100 Subject: [PATCH 078/266] prompt_store: Remove unused PromptId::EditWorkflow (#45018) Release Notes: - N/A --- crates/prompt_store/src/prompt_store.rs | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/crates/prompt_store/src/prompt_store.rs b/crates/prompt_store/src/prompt_store.rs index b69051b067c95674d8d09be76c5b4c607fd03f67..6417a7ad214c84258d4cc18eddc0b1c1d785ca18 100644 --- a/crates/prompt_store/src/prompt_store.rs +++ b/crates/prompt_store/src/prompt_store.rs @@ -55,7 +55,6 @@ pub struct PromptMetadata { #[serde(tag = "kind")] pub enum PromptId { User { uuid: UserPromptId }, - EditWorkflow, CommitMessage, } @@ -74,20 +73,19 @@ impl PromptId { pub fn is_built_in(&self) -> bool { match self { Self::User { .. } => false, - Self::EditWorkflow | Self::CommitMessage => true, + Self::CommitMessage => true, } } pub fn can_edit(&self) -> bool { match self { Self::User { .. } | Self::CommitMessage => true, - Self::EditWorkflow => false, } } pub fn default_content(&self) -> Option<&'static str> { match self { - Self::User { .. } | Self::EditWorkflow => None, + Self::User { .. } => None, Self::CommitMessage => Some(include_str!("../../git_ui/src/commit_message_prompt.txt")), } } @@ -119,7 +117,6 @@ impl std::fmt::Display for PromptId { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { PromptId::User { uuid } => write!(f, "{}", uuid.0), - PromptId::EditWorkflow => write!(f, "Edit workflow"), PromptId::CommitMessage => write!(f, "Commit message"), } } @@ -202,11 +199,6 @@ impl PromptStore { let metadata = db_env.create_database(&mut txn, Some("metadata.v2"))?; let bodies = db_env.create_database(&mut txn, Some("bodies.v2"))?; - // Remove edit workflow prompt, as we decided to opt into it using - // a slash command instead. - metadata.delete(&mut txn, &PromptId::EditWorkflow).ok(); - bodies.delete(&mut txn, &PromptId::EditWorkflow).ok(); - // Insert default commit message prompt if not present if metadata.get(&txn, &PromptId::CommitMessage)?.is_none() { metadata.put( From 91a976bf7b016f94ca400250bf116d6a25c1180a Mon Sep 17 00:00:00 2001 From: Josh Robson Chase Date: Tue, 16 Dec 2025 14:00:46 -0500 Subject: [PATCH 079/266] nix: Pin `cargo-about` to 0.8.2 (#44901) `cargo-about` got pinned to 0.8.2 in https://github.com/zed-industries/zed/pull/44012, but this isn't exactly "easy" to accomplish in nix. The version of nixpkgs in the flake inputs uses the proper version, but if you override the nixpkgs input or use the provided overlay, you might end up trying to build with a bad version of `cargo-about`. Since nixpkgs is versioned as a whole, your options are (in rough order of desirability): 1. Hope that nixpkgs simply includes multiple versions of the same package (common for things with stable major versions/breaking changes) 1. Use either `override` or `overrideAttrs` to provide different version/source attributes 1. Depend on multiple versions of nixpkgs to get the specific versions of the packages you want 1. Vendor the whole package build from a specific point in its history Option 1 is out - there's only one version of cargo-about in nixpkgs. Option 2 doesn't seem to work due to the way that `buildRustPackage` wraps the base `mkDerivation` which provides the `override` extension functions. There *might* be a way to make this work, but I haven't dug into the `buildRustPackage` internals enough to say for sure. Edit: I apparently can't read and the problems with this option were already solved for `cargo-bundle`, so this is the final approach! Option 3 always just feels a bit icky and opaque to me. Leaving Option 4. I usually find this approach to be "fine" for small package definitions that aren't actually much bigger than the overridden attributes would have be with the Option 2 approach. ~~Since the `cargo-about` definition is nice and small, this is the approach I chose.~~ ~~Since this has the potential to require a build of `cargo-about`, I'm only actually invoking its build if the provided version is wrong - more or less the same thing that's happening in the `generate-licenses` script, but nix-y.~~ Edit: Shouldn't ever cause a rebuild since there's only one 0.8.2 input source/vendored deps, so anything that was already using it will already be cached. I'm also updating nixpkgs to the latest unstable which currently has `cargo-about 0.8.4` to prove that this works. Unrelatedly, I also ran `nix fmt` as a drive-by change. `nix/build.nix` was a bit out of spec. Release Notes: - N/A --- flake.lock | 8 +-- nix/build.nix | 169 ++++++++++++++++++++++++++++---------------------- 2 files changed, 100 insertions(+), 77 deletions(-) diff --git a/flake.lock b/flake.lock index 3074b947ef51c387b5d20aba85478636f48de557..520dcb3f7469319dbf755bfd70103cb5de1b2c48 100644 --- a/flake.lock +++ b/flake.lock @@ -32,11 +32,11 @@ }, "nixpkgs": { "locked": { - "lastModified": 315532800, - "narHash": "sha256-5CwQ80ucRHiqVbMEEbTFnjz70/axSJ0aliyzSaFSkmY=", - "rev": "f6b44b2401525650256b977063dbcf830f762369", + "lastModified": 1765772535, + "narHash": "sha256-I715zWsdVZ+CipmLtoCAeNG0etQywiWRE5PaWntnaYk=", + "rev": "09b8fda8959d761445f12b55f380d90375a1d6bb", "type": "tarball", - "url": "https://releases.nixos.org/nixpkgs/nixpkgs-25.11pre891648.f6b44b240152/nixexprs.tar.xz" + "url": "https://releases.nixos.org/nixpkgs/nixpkgs-26.05pre911985.09b8fda8959d/nixexprs.tar.xz" }, "original": { "type": "tarball", diff --git a/nix/build.nix b/nix/build.nix index 484049a421f8de839fc157a45795637a12bd23b4..16b03e9a53bd2118c9b5bf45cf8fb7720ee5022b 100644 --- a/nix/build.nix +++ b/nix/build.nix @@ -83,70 +83,94 @@ let cargoLock = ../Cargo.lock; - nativeBuildInputs = - [ - cmake - copyDesktopItems - curl - perl - pkg-config - protobuf - cargo-about - rustPlatform.bindgenHook - ] - ++ lib.optionals stdenv'.hostPlatform.isLinux [ makeWrapper ] - ++ lib.optionals stdenv'.hostPlatform.isDarwin [ - (cargo-bundle.overrideAttrs ( - new: old: { - version = "0.6.1-zed"; - src = fetchFromGitHub { - owner = "zed-industries"; - repo = "cargo-bundle"; - rev = "2be2669972dff3ddd4daf89a2cb29d2d06cad7c7"; - hash = "sha256-cSvW0ND148AGdIGWg/ku0yIacVgW+9f1Nsi+kAQxVrI="; - }; - cargoHash = "sha256-urn+A3yuw2uAO4HGmvQnKvWtHqvG9KHxNCCWTiytE4k="; - - # NOTE: can drop once upstream uses `finalAttrs` here: - # https://github.com/NixOS/nixpkgs/blob/10214747f5e6e7cb5b9bdf9e018a3c7b3032f5af/pkgs/build-support/rust/build-rust-package/default.nix#L104 - # - # See (for context): https://github.com/NixOS/nixpkgs/pull/382550 - cargoDeps = rustPlatform.fetchCargoVendor { - inherit (new) src; - hash = new.cargoHash; - patches = new.cargoPatches or []; - name = new.cargoDepsName or new.finalPackage.name; - }; - } - )) - ]; - - buildInputs = - [ - curl - fontconfig - freetype - # TODO: need staticlib of this for linking the musl remote server. - # should make it a separate derivation/flake output - # see https://crane.dev/examples/cross-musl.html - libgit2 - openssl - sqlite - zlib - zstd - ] - ++ lib.optionals stdenv'.hostPlatform.isLinux [ - alsa-lib - libxkbcommon - wayland - gpu-lib - xorg.libX11 - xorg.libxcb - ] - ++ lib.optionals stdenv'.hostPlatform.isDarwin [ - apple-sdk_15 - (darwinMinVersionHook "10.15") - ]; + nativeBuildInputs = [ + cmake + copyDesktopItems + curl + perl + pkg-config + protobuf + # Pin cargo-about to 0.8.2. Newer versions don't work with the current license identifiers + # See https://github.com/zed-industries/zed/pull/44012 + (cargo-about.overrideAttrs ( + new: old: rec { + version = "0.8.2"; + + src = fetchFromGitHub { + owner = "EmbarkStudios"; + repo = "cargo-about"; + tag = version; + sha256 = "sha256-cNKZpDlfqEXeOE5lmu79AcKOawkPpk4PQCsBzNtIEbs="; + }; + + cargoHash = "sha256-NnocSs6UkuF/mCM3lIdFk+r51Iz2bHuYzMT/gEbT/nk="; + + # NOTE: can drop once upstream uses `finalAttrs` here: + # https://github.com/NixOS/nixpkgs/blob/10214747f5e6e7cb5b9bdf9e018a3c7b3032f5af/pkgs/build-support/rust/build-rust-package/default.nix#L104 + # + # See (for context): https://github.com/NixOS/nixpkgs/pull/382550 + cargoDeps = rustPlatform.fetchCargoVendor { + inherit (new) src; + hash = new.cargoHash; + patches = new.cargoPatches or [ ]; + name = new.cargoDepsName or new.finalPackage.name; + }; + } + )) + rustPlatform.bindgenHook + ] + ++ lib.optionals stdenv'.hostPlatform.isLinux [ makeWrapper ] + ++ lib.optionals stdenv'.hostPlatform.isDarwin [ + (cargo-bundle.overrideAttrs ( + new: old: { + version = "0.6.1-zed"; + src = fetchFromGitHub { + owner = "zed-industries"; + repo = "cargo-bundle"; + rev = "2be2669972dff3ddd4daf89a2cb29d2d06cad7c7"; + hash = "sha256-cSvW0ND148AGdIGWg/ku0yIacVgW+9f1Nsi+kAQxVrI="; + }; + cargoHash = "sha256-urn+A3yuw2uAO4HGmvQnKvWtHqvG9KHxNCCWTiytE4k="; + + # NOTE: can drop once upstream uses `finalAttrs` here: + # https://github.com/NixOS/nixpkgs/blob/10214747f5e6e7cb5b9bdf9e018a3c7b3032f5af/pkgs/build-support/rust/build-rust-package/default.nix#L104 + # + # See (for context): https://github.com/NixOS/nixpkgs/pull/382550 + cargoDeps = rustPlatform.fetchCargoVendor { + inherit (new) src; + hash = new.cargoHash; + patches = new.cargoPatches or [ ]; + name = new.cargoDepsName or new.finalPackage.name; + }; + } + )) + ]; + + buildInputs = [ + curl + fontconfig + freetype + # TODO: need staticlib of this for linking the musl remote server. + # should make it a separate derivation/flake output + # see https://crane.dev/examples/cross-musl.html + libgit2 + openssl + sqlite + zlib + zstd + ] + ++ lib.optionals stdenv'.hostPlatform.isLinux [ + alsa-lib + libxkbcommon + wayland + gpu-lib + xorg.libX11 + xorg.libxcb + ] + ++ lib.optionals stdenv'.hostPlatform.isDarwin [ + apple-sdk_15 + (darwinMinVersionHook "10.15") + ]; cargoExtraArgs = "-p zed -p cli --locked --features=gpui/runtime_shaders"; @@ -177,7 +201,7 @@ let ZED_UPDATE_EXPLANATION = "Zed has been installed using Nix. Auto-updates have thus been disabled."; RELEASE_VERSION = version; LK_CUSTOM_WEBRTC = livekit-libwebrtc; - PROTOC="${protobuf}/bin/protoc"; + PROTOC = "${protobuf}/bin/protoc"; CARGO_PROFILE = profile; # need to handle some profiles specially https://github.com/rust-lang/cargo/issues/11053 @@ -217,14 +241,13 @@ let # `webrtc-sys` expects a staticlib; nixpkgs' `livekit-webrtc` has been patched to # produce a `dylib`... patching `webrtc-sys`'s build script is the easier option # TODO: send livekit sdk a PR to make this configurable - postPatch = - '' - substituteInPlace webrtc-sys/build.rs --replace-fail \ - "cargo:rustc-link-lib=static=webrtc" "cargo:rustc-link-lib=dylib=webrtc" - '' - + lib.optionalString withGLES '' - cat ${glesConfig} >> .cargo/config/config.toml - ''; + postPatch = '' + substituteInPlace webrtc-sys/build.rs --replace-fail \ + "cargo:rustc-link-lib=static=webrtc" "cargo:rustc-link-lib=dylib=webrtc" + '' + + lib.optionalString withGLES '' + cat ${glesConfig} >> .cargo/config/config.toml + ''; in crates: drv: if hasWebRtcSys crates then From 0c91f061c360468da86bd1cb88768ceae6f71308 Mon Sep 17 00:00:00 2001 From: "Oleksii (Alexey) Orlenko" Date: Tue, 16 Dec 2025 20:22:30 +0100 Subject: [PATCH 080/266] agent_ui: Implement favorite models selection (#44297) This PR solves my main pain point with Zed agent: I have a long list of available models from different providers, and I switch between a few of them depending on the context and the project. In particular, I use the same models from different providers depending on whether I'm working on a personal project or at my day job. Since I only care about a few models (none of which are in "recommended") that are scattered all over the list, switching between them is bothersome, even using search. This change adds a new option in `settings.json` (`agent.favorite_models`) and the UI to manipulate it directly from the list of available models. When any models are marked as favorites, they appear in a dedicated section at the very top of the list. Each model has a small icon button that appears on hover and allows to toggle whether it's marked as favorite. I implemented this on the UI level (i.e. there's no first-party knowledge about favorite models in the agent itself; in theory it could return favorite models as a group but it would make it harder to implement bespoke UI for the favorite models section and it also wouldn't work for text threads which don't use the ACP infrastructure). The feature is only enabled for the native agent but disabled for external agents because we can't easily map their model IDs to settings and there could be weird collisions between them. https://github.com/user-attachments/assets/cf23afe4-3883-45cb-9906-f55de3ea2a97 Closes https://github.com/zed-industries/zed/issues/31507 Release Notes: - Added the ability to mark language models as favorites and pin them to the top of the list. This feature is available in the native Zed agent (including text threads and the inline assistant), but not in external agents via ACP. --------- Co-authored-by: Danilo Leal Co-authored-by: Bennet Bo Fenner --- Cargo.lock | 1 + crates/acp_thread/src/connection.rs | 10 + crates/agent/src/agent.rs | 4 + crates/agent_settings/Cargo.toml | 1 + crates/agent_settings/src/agent_settings.rs | 12 +- crates/agent_ui/src/acp/model_selector.rs | 282 ++++++++++++++++-- .../manage_profiles_modal.rs | 45 ++- crates/agent_ui/src/agent_model_selector.rs | 37 ++- crates/agent_ui/src/agent_ui.rs | 2 + crates/agent_ui/src/favorite_models.rs | 57 ++++ .../agent_ui/src/language_model_selector.rs | 216 ++++++++++++-- crates/agent_ui/src/text_thread_editor.rs | 36 ++- .../src/ui/model_selector_components.rs | 35 ++- crates/settings/src/settings_content/agent.rs | 13 + 14 files changed, 653 insertions(+), 98 deletions(-) create mode 100644 crates/agent_ui/src/favorite_models.rs diff --git a/Cargo.lock b/Cargo.lock index 2d0cb8235d547c5486ffd89e3d54fd8d46a54f0c..6908a8ed5185ea71cc51a34d63990decaaf082d9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -301,6 +301,7 @@ dependencies = [ name = "agent_settings" version = "0.1.0" dependencies = [ + "agent-client-protocol", "anyhow", "cloud_llm_client", "collections", diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs index 3c8c56b2c02cd775be030cb4c4b05a9c75f0d10f..a670ba601159ec323ad2c88695c30bf4aeae4118 100644 --- a/crates/acp_thread/src/connection.rs +++ b/crates/acp_thread/src/connection.rs @@ -202,6 +202,12 @@ pub trait AgentModelSelector: 'static { fn should_render_footer(&self) -> bool { false } + + /// Whether this selector supports the favorites feature. + /// Only the native agent uses the model ID format that maps to settings. + fn supports_favorites(&self) -> bool { + false + } } #[derive(Debug, Clone, PartialEq, Eq)] @@ -239,6 +245,10 @@ impl AgentModelList { AgentModelList::Grouped(groups) => groups.is_empty(), } } + + pub fn is_flat(&self) -> bool { + matches!(self, AgentModelList::Flat(_)) + } } #[cfg(feature = "test-support")] diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index 693d3abd4497c057a75b4f01c07bd51f311f1fdb..5e16f74682ef95a4e990ed5a124a0d6031acfb0e 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -1164,6 +1164,10 @@ impl acp_thread::AgentModelSelector for NativeAgentModelSelector { fn should_render_footer(&self) -> bool { true } + + fn supports_favorites(&self) -> bool { + true + } } impl acp_thread::AgentConnection for NativeAgentConnection { diff --git a/crates/agent_settings/Cargo.toml b/crates/agent_settings/Cargo.toml index 8ddcac24fe054d1226f2bbac49498fd35d6ed1c3..0d7163549f0a4b172773c9ac95dcbc84b7212667 100644 --- a/crates/agent_settings/Cargo.toml +++ b/crates/agent_settings/Cargo.toml @@ -12,6 +12,7 @@ workspace = true path = "src/agent_settings.rs" [dependencies] +agent-client-protocol.workspace = true anyhow.workspace = true cloud_llm_client.workspace = true collections.workspace = true diff --git a/crates/agent_settings/src/agent_settings.rs b/crates/agent_settings/src/agent_settings.rs index 25ca5c78d6b76145a1b1b5d19ac86246ff419d1d..b513ec1a70b6f7ab02382dfa312ea2d4d6a47234 100644 --- a/crates/agent_settings/src/agent_settings.rs +++ b/crates/agent_settings/src/agent_settings.rs @@ -2,7 +2,8 @@ mod agent_profile; use std::sync::Arc; -use collections::IndexMap; +use agent_client_protocol::ModelId; +use collections::{HashSet, IndexMap}; use gpui::{App, Pixels, px}; use language_model::LanguageModel; use project::DisableAiSettings; @@ -33,6 +34,7 @@ pub struct AgentSettings { pub commit_message_model: Option, pub thread_summary_model: Option, pub inline_alternatives: Vec, + pub favorite_models: Vec, pub default_profile: AgentProfileId, pub default_view: DefaultAgentView, pub profiles: IndexMap, @@ -96,6 +98,13 @@ impl AgentSettings { pub fn set_message_editor_max_lines(&self) -> usize { self.message_editor_min_lines * 2 } + + pub fn favorite_model_ids(&self) -> HashSet { + self.favorite_models + .iter() + .map(|sel| ModelId::new(format!("{}/{}", sel.provider.0, sel.model))) + .collect() + } } #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Default)] @@ -164,6 +173,7 @@ impl Settings for AgentSettings { commit_message_model: agent.commit_message_model, thread_summary_model: agent.thread_summary_model, inline_alternatives: agent.inline_alternatives.unwrap_or_default(), + favorite_models: agent.favorite_models, default_profile: AgentProfileId(agent.default_profile.unwrap()), default_view: agent.default_view.unwrap(), profiles: agent diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs index 658b88e0c2a4f0b4203c5f1191c0a49cb4ad6fd5..f885ff12e598168abdf7727dc03e4814e5de3b49 100644 --- a/crates/agent_ui/src/acp/model_selector.rs +++ b/crates/agent_ui/src/acp/model_selector.rs @@ -1,18 +1,22 @@ use std::{cmp::Reverse, rc::Rc, sync::Arc}; use acp_thread::{AgentModelInfo, AgentModelList, AgentModelSelector}; +use agent_client_protocol::ModelId; use agent_servers::AgentServer; +use agent_settings::AgentSettings; use anyhow::Result; -use collections::IndexMap; +use collections::{HashSet, IndexMap}; use fs::Fs; use futures::FutureExt; use fuzzy::{StringMatchCandidate, match_strings}; use gpui::{ Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, FocusHandle, Task, WeakEntity, }; +use itertools::Itertools; use ordered_float::OrderedFloat; use picker::{Picker, PickerDelegate}; -use ui::{DocumentationAside, DocumentationEdge, DocumentationSide, prelude::*}; +use settings::Settings; +use ui::{DocumentationAside, DocumentationEdge, DocumentationSide, IntoElement, prelude::*}; use util::ResultExt; use zed_actions::agent::OpenSettings; @@ -38,7 +42,7 @@ pub fn acp_model_selector( enum AcpModelPickerEntry { Separator(SharedString), - Model(AgentModelInfo), + Model(AgentModelInfo, bool), } pub struct AcpModelPickerDelegate { @@ -140,7 +144,7 @@ impl PickerDelegate for AcpModelPickerDelegate { _cx: &mut Context>, ) -> bool { match self.filtered_entries.get(ix) { - Some(AcpModelPickerEntry::Model(_)) => true, + Some(AcpModelPickerEntry::Model(_, _)) => true, Some(AcpModelPickerEntry::Separator(_)) | None => false, } } @@ -155,6 +159,12 @@ impl PickerDelegate for AcpModelPickerDelegate { window: &mut Window, cx: &mut Context>, ) -> Task<()> { + let favorites = if self.selector.supports_favorites() { + Arc::new(AgentSettings::get_global(cx).favorite_model_ids()) + } else { + Default::default() + }; + cx.spawn_in(window, async move |this, cx| { let filtered_models = match this .read_with(cx, |this, cx| { @@ -171,7 +181,7 @@ impl PickerDelegate for AcpModelPickerDelegate { this.update_in(cx, |this, window, cx| { this.delegate.filtered_entries = - info_list_to_picker_entries(filtered_models).collect(); + info_list_to_picker_entries(filtered_models, favorites); // Finds the currently selected model in the list let new_index = this .delegate @@ -179,7 +189,7 @@ impl PickerDelegate for AcpModelPickerDelegate { .as_ref() .and_then(|selected| { this.delegate.filtered_entries.iter().position(|entry| { - if let AcpModelPickerEntry::Model(model_info) = entry { + if let AcpModelPickerEntry::Model(model_info, _) = entry { model_info.id == selected.id } else { false @@ -195,7 +205,7 @@ impl PickerDelegate for AcpModelPickerDelegate { } fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context>) { - if let Some(AcpModelPickerEntry::Model(model_info)) = + if let Some(AcpModelPickerEntry::Model(model_info, _)) = self.filtered_entries.get(self.selected_index) { if window.modifiers().secondary() { @@ -233,7 +243,7 @@ impl PickerDelegate for AcpModelPickerDelegate { fn render_match( &self, ix: usize, - is_focused: bool, + selected: bool, _: &mut Window, cx: &mut Context>, ) -> Option { @@ -241,32 +251,53 @@ impl PickerDelegate for AcpModelPickerDelegate { AcpModelPickerEntry::Separator(title) => { Some(ModelSelectorHeader::new(title, ix > 1).into_any_element()) } - AcpModelPickerEntry::Model(model_info) => { + AcpModelPickerEntry::Model(model_info, is_favorite) => { let is_selected = Some(model_info) == self.selected_model.as_ref(); let default_model = self.agent_server.default_model(cx); let is_default = default_model.as_ref() == Some(&model_info.id); + let supports_favorites = self.selector.supports_favorites(); + + let is_favorite = *is_favorite; + let handle_action_click = { + let model_id = model_info.id.clone(); + let fs = self.fs.clone(); + + move |cx: &App| { + crate::favorite_models::toggle_model_id_in_settings( + model_id.clone(), + !is_favorite, + fs.clone(), + cx, + ); + } + }; + Some( div() .id(("model-picker-menu-child", ix)) .when_some(model_info.description.clone(), |this, description| { - this - .on_hover(cx.listener(move |menu, hovered, _, cx| { - if *hovered { - menu.delegate.selected_description = Some((ix, description.clone(), is_default)); - } else if matches!(menu.delegate.selected_description, Some((id, _, _)) if id == ix) { - menu.delegate.selected_description = None; - } - cx.notify(); - })) + this.on_hover(cx.listener(move |menu, hovered, _, cx| { + if *hovered { + menu.delegate.selected_description = + Some((ix, description.clone(), is_default)); + } else if matches!(menu.delegate.selected_description, Some((id, _, _)) if id == ix) { + menu.delegate.selected_description = None; + } + cx.notify(); + })) }) .child( ModelSelectorListItem::new(ix, model_info.name.clone()) - .is_focused(is_focused) + .when_some(model_info.icon, |this, icon| this.icon(icon)) .is_selected(is_selected) - .when_some(model_info.icon, |this, icon| this.icon(icon)), + .is_focused(selected) + .when(supports_favorites, |this| { + this.is_favorite(is_favorite) + .on_toggle_favorite(handle_action_click) + }), ) - .into_any_element() + .into_any_element(), ) } } @@ -314,18 +345,51 @@ impl PickerDelegate for AcpModelPickerDelegate { fn info_list_to_picker_entries( model_list: AgentModelList, -) -> impl Iterator { + favorites: Arc>, +) -> Vec { + let mut entries = Vec::new(); + + let all_models: Vec<_> = match &model_list { + AgentModelList::Flat(list) => list.iter().collect(), + AgentModelList::Grouped(index_map) => index_map.values().flatten().collect(), + }; + + let favorite_models: Vec<_> = all_models + .iter() + .filter(|m| favorites.contains(&m.id)) + .unique_by(|m| &m.id) + .collect(); + + let has_favorites = !favorite_models.is_empty(); + if has_favorites { + entries.push(AcpModelPickerEntry::Separator("Favorite".into())); + for model in favorite_models { + entries.push(AcpModelPickerEntry::Model((*model).clone(), true)); + } + } + match model_list { AgentModelList::Flat(list) => { - itertools::Either::Left(list.into_iter().map(AcpModelPickerEntry::Model)) + if has_favorites { + entries.push(AcpModelPickerEntry::Separator("All".into())); + } + for model in list { + let is_favorite = favorites.contains(&model.id); + entries.push(AcpModelPickerEntry::Model(model, is_favorite)); + } } AgentModelList::Grouped(index_map) => { - itertools::Either::Right(index_map.into_iter().flat_map(|(group_name, models)| { - std::iter::once(AcpModelPickerEntry::Separator(group_name.0)) - .chain(models.into_iter().map(AcpModelPickerEntry::Model)) - })) + for (group_name, models) in index_map { + entries.push(AcpModelPickerEntry::Separator(group_name.0)); + for model in models { + let is_favorite = favorites.contains(&model.id); + entries.push(AcpModelPickerEntry::Model(model, is_favorite)); + } + } } } + + entries } async fn fuzzy_search( @@ -447,6 +511,170 @@ mod tests { } } + fn create_favorites(models: Vec<&str>) -> Arc> { + Arc::new( + models + .into_iter() + .map(|m| ModelId::new(m.to_string())) + .collect(), + ) + } + + fn get_entry_model_ids(entries: &[AcpModelPickerEntry]) -> Vec<&str> { + entries + .iter() + .filter_map(|entry| match entry { + AcpModelPickerEntry::Model(info, _) => Some(info.id.0.as_ref()), + _ => None, + }) + .collect() + } + + fn get_entry_labels(entries: &[AcpModelPickerEntry]) -> Vec<&str> { + entries + .iter() + .map(|entry| match entry { + AcpModelPickerEntry::Model(info, _) => info.id.0.as_ref(), + AcpModelPickerEntry::Separator(s) => &s, + }) + .collect() + } + + #[gpui::test] + fn test_favorites_section_appears_when_favorites_exist(_cx: &mut TestAppContext) { + let models = create_model_list(vec![ + ("zed", vec!["zed/claude", "zed/gemini"]), + ("openai", vec!["openai/gpt-5"]), + ]); + let favorites = create_favorites(vec!["zed/gemini"]); + + let entries = info_list_to_picker_entries(models, favorites); + + assert!(matches!( + entries.first(), + Some(AcpModelPickerEntry::Separator(s)) if s == "Favorite" + )); + + let model_ids = get_entry_model_ids(&entries); + assert_eq!(model_ids[0], "zed/gemini"); + } + + #[gpui::test] + fn test_no_favorites_section_when_no_favorites(_cx: &mut TestAppContext) { + let models = create_model_list(vec![("zed", vec!["zed/claude", "zed/gemini"])]); + let favorites = create_favorites(vec![]); + + let entries = info_list_to_picker_entries(models, favorites); + + assert!(matches!( + entries.first(), + Some(AcpModelPickerEntry::Separator(s)) if s == "zed" + )); + } + + #[gpui::test] + fn test_models_have_correct_actions(_cx: &mut TestAppContext) { + let models = create_model_list(vec![ + ("zed", vec!["zed/claude", "zed/gemini"]), + ("openai", vec!["openai/gpt-5"]), + ]); + let favorites = create_favorites(vec!["zed/claude"]); + + let entries = info_list_to_picker_entries(models, favorites); + + for entry in &entries { + if let AcpModelPickerEntry::Model(info, is_favorite) = entry { + if info.id.0.as_ref() == "zed/claude" { + assert!(is_favorite, "zed/claude should be a favorite"); + } else { + assert!(!is_favorite, "{} should not be a favorite", info.id.0); + } + } + } + } + + #[gpui::test] + fn test_favorites_appear_in_both_sections(_cx: &mut TestAppContext) { + let models = create_model_list(vec![ + ("zed", vec!["zed/claude", "zed/gemini"]), + ("openai", vec!["openai/gpt-5", "openai/gpt-4"]), + ]); + let favorites = create_favorites(vec!["zed/gemini", "openai/gpt-5"]); + + let entries = info_list_to_picker_entries(models, favorites); + let model_ids = get_entry_model_ids(&entries); + + assert_eq!(model_ids[0], "zed/gemini"); + assert_eq!(model_ids[1], "openai/gpt-5"); + + assert!(model_ids[2..].contains(&"zed/gemini")); + assert!(model_ids[2..].contains(&"openai/gpt-5")); + } + + #[gpui::test] + fn test_favorites_are_not_duplicated_when_repeated_in_other_sections(_cx: &mut TestAppContext) { + let models = create_model_list(vec![ + ("Recommended", vec!["zed/claude", "anthropic/claude"]), + ("Zed", vec!["zed/claude", "zed/gpt-5"]), + ("Antropic", vec!["anthropic/claude"]), + ("OpenAI", vec!["openai/gpt-5"]), + ]); + + let favorites = create_favorites(vec!["zed/claude"]); + + let entries = info_list_to_picker_entries(models, favorites); + let labels = get_entry_labels(&entries); + + assert_eq!( + labels, + vec![ + "Favorite", + "zed/claude", + "Recommended", + "zed/claude", + "anthropic/claude", + "Zed", + "zed/claude", + "zed/gpt-5", + "Antropic", + "anthropic/claude", + "OpenAI", + "openai/gpt-5" + ] + ); + } + + #[gpui::test] + fn test_flat_model_list_with_favorites(_cx: &mut TestAppContext) { + let models = AgentModelList::Flat(vec![ + acp_thread::AgentModelInfo { + id: acp::ModelId::new("zed/claude".to_string()), + name: "Claude".into(), + description: None, + icon: None, + }, + acp_thread::AgentModelInfo { + id: acp::ModelId::new("zed/gemini".to_string()), + name: "Gemini".into(), + description: None, + icon: None, + }, + ]); + let favorites = create_favorites(vec!["zed/gemini"]); + + let entries = info_list_to_picker_entries(models, favorites); + + assert!(matches!( + entries.first(), + Some(AcpModelPickerEntry::Separator(s)) if s == "Favorite" + )); + + assert!(entries.iter().any(|e| matches!( + e, + AcpModelPickerEntry::Separator(s) if s == "All" + ))); + } + #[gpui::test] async fn test_fuzzy_match(cx: &mut TestAppContext) { let models = create_model_list(vec![ diff --git a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs index ed00b2b5c716fdf27abc1c9d7c5850b36fce830f..127852fd50e81cf56ae37a7af430f88ae2accf99 100644 --- a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs +++ b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs @@ -222,7 +222,6 @@ impl ManageProfilesModal { let profile_id_for_closure = profile_id.clone(); let model_picker = cx.new(|cx| { - let fs = fs.clone(); let profile_id = profile_id_for_closure.clone(); language_model_selector( @@ -250,22 +249,36 @@ impl ManageProfilesModal { }) } }, - move |model, cx| { - let provider = model.provider_id().0.to_string(); - let model_id = model.id().0.to_string(); - let profile_id = profile_id.clone(); - - update_settings_file(fs.clone(), cx, move |settings, _cx| { - let agent_settings = settings.agent.get_or_insert_default(); - if let Some(profiles) = agent_settings.profiles.as_mut() { - if let Some(profile) = profiles.get_mut(profile_id.0.as_ref()) { - profile.default_model = Some(LanguageModelSelection { - provider: LanguageModelProviderSetting(provider.clone()), - model: model_id.clone(), - }); + { + let fs = fs.clone(); + move |model, cx| { + let provider = model.provider_id().0.to_string(); + let model_id = model.id().0.to_string(); + let profile_id = profile_id.clone(); + + update_settings_file(fs.clone(), cx, move |settings, _cx| { + let agent_settings = settings.agent.get_or_insert_default(); + if let Some(profiles) = agent_settings.profiles.as_mut() { + if let Some(profile) = profiles.get_mut(profile_id.0.as_ref()) { + profile.default_model = Some(LanguageModelSelection { + provider: LanguageModelProviderSetting(provider.clone()), + model: model_id.clone(), + }); + } } - } - }); + }); + } + }, + { + let fs = fs.clone(); + move |model, should_be_favorite, cx| { + crate::favorite_models::toggle_in_settings( + model, + should_be_favorite, + fs.clone(), + cx, + ); + } }, false, // Do not use popover styles for the model picker self.focus_handle.clone(), diff --git a/crates/agent_ui/src/agent_model_selector.rs b/crates/agent_ui/src/agent_model_selector.rs index 9c2634143099d2097b5c6492f81c56aa51f12491..ac57ed575d9d1b6de2c53d3e0e4a91b4bd16ab1a 100644 --- a/crates/agent_ui/src/agent_model_selector.rs +++ b/crates/agent_ui/src/agent_model_selector.rs @@ -29,26 +29,39 @@ impl AgentModelSelector { Self { selector: cx.new(move |cx| { - let fs = fs.clone(); language_model_selector( { let model_context = model_usage_context.clone(); move |cx| model_context.configured_model(cx) }, - move |model, cx| { - let provider = model.provider_id().0.to_string(); - let model_id = model.id().0.to_string(); - match &model_usage_context { - ModelUsageContext::InlineAssistant => { - update_settings_file(fs.clone(), cx, move |settings, _cx| { - settings - .agent - .get_or_insert_default() - .set_inline_assistant_model(provider.clone(), model_id); - }); + { + let fs = fs.clone(); + move |model, cx| { + let provider = model.provider_id().0.to_string(); + let model_id = model.id().0.to_string(); + match &model_usage_context { + ModelUsageContext::InlineAssistant => { + update_settings_file(fs.clone(), cx, move |settings, _cx| { + settings + .agent + .get_or_insert_default() + .set_inline_assistant_model(provider.clone(), model_id); + }); + } } } }, + { + let fs = fs.clone(); + move |model, should_be_favorite, cx| { + crate::favorite_models::toggle_in_settings( + model, + should_be_favorite, + fs.clone(), + cx, + ); + } + }, true, // Use popover styles for picker focus_handle_clone, window, diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index 4f759d6a9c7687d2cdf29752c489db2fcb1ffe68..1622d17f5852d825b9c8d69996fad7c89bb89dce 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -7,6 +7,7 @@ mod buffer_codegen; mod completion_provider; mod context; mod context_server_configuration; +mod favorite_models; mod inline_assistant; mod inline_prompt_editor; mod language_model_selector; @@ -467,6 +468,7 @@ mod tests { commit_message_model: None, thread_summary_model: None, inline_alternatives: vec![], + favorite_models: vec![], default_profile: AgentProfileId::default(), default_view: DefaultAgentView::Thread, profiles: Default::default(), diff --git a/crates/agent_ui/src/favorite_models.rs b/crates/agent_ui/src/favorite_models.rs new file mode 100644 index 0000000000000000000000000000000000000000..d8d4db976fc9916973eedd9174925fba75a06b2b --- /dev/null +++ b/crates/agent_ui/src/favorite_models.rs @@ -0,0 +1,57 @@ +use std::sync::Arc; + +use agent_client_protocol::ModelId; +use fs::Fs; +use language_model::LanguageModel; +use settings::{LanguageModelSelection, update_settings_file}; +use ui::App; + +fn language_model_to_selection(model: &Arc) -> LanguageModelSelection { + LanguageModelSelection { + provider: model.provider_id().to_string().into(), + model: model.id().0.to_string(), + } +} + +fn model_id_to_selection(model_id: &ModelId) -> LanguageModelSelection { + let id = model_id.0.as_ref(); + let (provider, model) = id.split_once('/').unwrap_or(("", id)); + LanguageModelSelection { + provider: provider.to_owned().into(), + model: model.to_owned(), + } +} + +pub fn toggle_in_settings( + model: Arc, + should_be_favorite: bool, + fs: Arc, + cx: &App, +) { + let selection = language_model_to_selection(&model); + update_settings_file(fs, cx, move |settings, _| { + let agent = settings.agent.get_or_insert_default(); + if should_be_favorite { + agent.add_favorite_model(selection.clone()); + } else { + agent.remove_favorite_model(&selection); + } + }); +} + +pub fn toggle_model_id_in_settings( + model_id: ModelId, + should_be_favorite: bool, + fs: Arc, + cx: &App, +) { + let selection = model_id_to_selection(&model_id); + update_settings_file(fs, cx, move |settings, _| { + let agent = settings.agent.get_or_insert_default(); + if should_be_favorite { + agent.add_favorite_model(selection.clone()); + } else { + agent.remove_favorite_model(&selection); + } + }); +} diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs index 7e1c35eba45bf9a79d42b59374c8cdb2aa0cac21..7bb42fb330dcccb4b5401217d0181d3d616fe66f 100644 --- a/crates/agent_ui/src/language_model_selector.rs +++ b/crates/agent_ui/src/language_model_selector.rs @@ -1,16 +1,18 @@ use std::{cmp::Reverse, sync::Arc}; -use collections::IndexMap; +use agent_settings::AgentSettings; +use collections::{HashMap, HashSet, IndexMap}; use fuzzy::{StringMatch, StringMatchCandidate, match_strings}; use gpui::{ Action, AnyElement, App, BackgroundExecutor, DismissEvent, FocusHandle, Subscription, Task, }; use language_model::{ - AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelProviderId, - LanguageModelRegistry, + AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelId, LanguageModelProvider, + LanguageModelProviderId, LanguageModelRegistry, }; use ordered_float::OrderedFloat; use picker::{Picker, PickerDelegate}; +use settings::Settings; use ui::prelude::*; use zed_actions::agent::OpenSettings; @@ -18,12 +20,14 @@ use crate::ui::{ModelSelectorFooter, ModelSelectorHeader, ModelSelectorListItem} type OnModelChanged = Arc, &mut App) + 'static>; type GetActiveModel = Arc Option + 'static>; +type OnToggleFavorite = Arc, bool, &App) + 'static>; pub type LanguageModelSelector = Picker; pub fn language_model_selector( get_active_model: impl Fn(&App) -> Option + 'static, on_model_changed: impl Fn(Arc, &mut App) + 'static, + on_toggle_favorite: impl Fn(Arc, bool, &App) + 'static, popover_styles: bool, focus_handle: FocusHandle, window: &mut Window, @@ -32,6 +36,7 @@ pub fn language_model_selector( let delegate = LanguageModelPickerDelegate::new( get_active_model, on_model_changed, + on_toggle_favorite, popover_styles, focus_handle, window, @@ -49,7 +54,17 @@ pub fn language_model_selector( } fn all_models(cx: &App) -> GroupedModels { - let providers = LanguageModelRegistry::global(cx).read(cx).providers(); + let lm_registry = LanguageModelRegistry::global(cx).read(cx); + let providers = lm_registry.providers(); + + let mut favorites_index = FavoritesIndex::default(); + + for sel in &AgentSettings::get_global(cx).favorite_models { + favorites_index + .entry(sel.provider.0.clone().into()) + .or_default() + .insert(sel.model.clone().into()); + } let recommended = providers .iter() @@ -57,10 +72,7 @@ fn all_models(cx: &App) -> GroupedModels { provider .recommended_models(cx) .into_iter() - .map(|model| ModelInfo { - model, - icon: provider.icon(), - }) + .map(|model| ModelInfo::new(&**provider, model, &favorites_index)) }) .collect(); @@ -70,25 +82,44 @@ fn all_models(cx: &App) -> GroupedModels { provider .provided_models(cx) .into_iter() - .map(|model| ModelInfo { - model, - icon: provider.icon(), - }) + .map(|model| ModelInfo::new(&**provider, model, &favorites_index)) }) .collect(); GroupedModels::new(all, recommended) } +type FavoritesIndex = HashMap>; + #[derive(Clone)] struct ModelInfo { model: Arc, icon: IconName, + is_favorite: bool, +} + +impl ModelInfo { + fn new( + provider: &dyn LanguageModelProvider, + model: Arc, + favorites_index: &FavoritesIndex, + ) -> Self { + let is_favorite = favorites_index + .get(&provider.id()) + .map_or(false, |set| set.contains(&model.id())); + + Self { + model, + icon: provider.icon(), + is_favorite, + } + } } pub struct LanguageModelPickerDelegate { on_model_changed: OnModelChanged, get_active_model: GetActiveModel, + on_toggle_favorite: OnToggleFavorite, all_models: Arc, filtered_entries: Vec, selected_index: usize, @@ -102,6 +133,7 @@ impl LanguageModelPickerDelegate { fn new( get_active_model: impl Fn(&App) -> Option + 'static, on_model_changed: impl Fn(Arc, &mut App) + 'static, + on_toggle_favorite: impl Fn(Arc, bool, &App) + 'static, popover_styles: bool, focus_handle: FocusHandle, window: &mut Window, @@ -117,6 +149,7 @@ impl LanguageModelPickerDelegate { selected_index: Self::get_active_model_index(&entries, get_active_model(cx)), filtered_entries: entries, get_active_model: Arc::new(get_active_model), + on_toggle_favorite: Arc::new(on_toggle_favorite), _authenticate_all_providers_task: Self::authenticate_all_providers(cx), _subscriptions: vec![cx.subscribe_in( &LanguageModelRegistry::global(cx), @@ -219,12 +252,19 @@ impl LanguageModelPickerDelegate { } struct GroupedModels { + favorites: Vec, recommended: Vec, all: IndexMap>, } impl GroupedModels { pub fn new(all: Vec, recommended: Vec) -> Self { + let favorites = all + .iter() + .filter(|info| info.is_favorite) + .cloned() + .collect(); + let mut all_by_provider: IndexMap<_, Vec> = IndexMap::default(); for model in all { let provider = model.model.provider_id(); @@ -236,6 +276,7 @@ impl GroupedModels { } Self { + favorites, recommended, all: all_by_provider, } @@ -244,13 +285,18 @@ impl GroupedModels { fn entries(&self) -> Vec { let mut entries = Vec::new(); + if !self.favorites.is_empty() { + entries.push(LanguageModelPickerEntry::Separator("Favorite".into())); + for info in &self.favorites { + entries.push(LanguageModelPickerEntry::Model(info.clone())); + } + } + if !self.recommended.is_empty() { entries.push(LanguageModelPickerEntry::Separator("Recommended".into())); - entries.extend( - self.recommended - .iter() - .map(|info| LanguageModelPickerEntry::Model(info.clone())), - ); + for info in &self.recommended { + entries.push(LanguageModelPickerEntry::Model(info.clone())); + } } for models in self.all.values() { @@ -260,12 +306,11 @@ impl GroupedModels { entries.push(LanguageModelPickerEntry::Separator( models[0].model.provider_name().0, )); - entries.extend( - models - .iter() - .map(|info| LanguageModelPickerEntry::Model(info.clone())), - ); + for info in models { + entries.push(LanguageModelPickerEntry::Model(info.clone())); + } } + entries } } @@ -461,7 +506,7 @@ impl PickerDelegate for LanguageModelPickerDelegate { fn render_match( &self, ix: usize, - is_focused: bool, + selected: bool, _: &mut Window, cx: &mut Context>, ) -> Option { @@ -477,11 +522,20 @@ impl PickerDelegate for LanguageModelPickerDelegate { let is_selected = Some(model_info.model.provider_id()) == active_provider_id && Some(model_info.model.id()) == active_model_id; + let is_favorite = model_info.is_favorite; + let handle_action_click = { + let model = model_info.model.clone(); + let on_toggle_favorite = self.on_toggle_favorite.clone(); + move |cx: &App| on_toggle_favorite(model.clone(), !is_favorite, cx) + }; + Some( ModelSelectorListItem::new(ix, model_info.model.name().0) - .is_focused(is_focused) - .is_selected(is_selected) .icon(model_info.icon) + .is_selected(is_selected) + .is_focused(selected) + .is_favorite(is_favorite) + .on_toggle_favorite(handle_action_click) .into_any_element(), ) } @@ -493,12 +547,12 @@ impl PickerDelegate for LanguageModelPickerDelegate { _window: &mut Window, _cx: &mut Context>, ) -> Option { + let focus_handle = self.focus_handle.clone(); + if !self.popover_styles { return None; } - let focus_handle = self.focus_handle.clone(); - Some(ModelSelectorFooter::new(OpenSettings.boxed_clone(), focus_handle).into_any_element()) } } @@ -598,11 +652,24 @@ mod tests { } fn create_models(model_specs: Vec<(&str, &str)>) -> Vec { + create_models_with_favorites(model_specs, vec![]) + } + + fn create_models_with_favorites( + model_specs: Vec<(&str, &str)>, + favorites: Vec<(&str, &str)>, + ) -> Vec { model_specs .into_iter() - .map(|(provider, name)| ModelInfo { - model: Arc::new(TestLanguageModel::new(name, provider)), - icon: IconName::Ai, + .map(|(provider, name)| { + let is_favorite = favorites + .iter() + .any(|(fav_provider, fav_name)| *fav_provider == provider && *fav_name == name); + ModelInfo { + model: Arc::new(TestLanguageModel::new(name, provider)), + icon: IconName::Ai, + is_favorite, + } }) .collect() } @@ -740,4 +807,93 @@ mod tests { vec!["zed/claude", "zed/gemini", "copilot/claude"], ); } + + #[gpui::test] + fn test_favorites_section_appears_when_favorites_exist(_cx: &mut TestAppContext) { + let recommended_models = create_models(vec![("zed", "claude")]); + let all_models = create_models_with_favorites( + vec![("zed", "claude"), ("zed", "gemini"), ("openai", "gpt-4")], + vec![("zed", "gemini")], + ); + + let grouped_models = GroupedModels::new(all_models, recommended_models); + let entries = grouped_models.entries(); + + assert!(matches!( + entries.first(), + Some(LanguageModelPickerEntry::Separator(s)) if s == "Favorite" + )); + + assert_models_eq(grouped_models.favorites, vec!["zed/gemini"]); + } + + #[gpui::test] + fn test_no_favorites_section_when_no_favorites(_cx: &mut TestAppContext) { + let recommended_models = create_models(vec![("zed", "claude")]); + let all_models = create_models(vec![("zed", "claude"), ("zed", "gemini")]); + + let grouped_models = GroupedModels::new(all_models, recommended_models); + let entries = grouped_models.entries(); + + assert!(matches!( + entries.first(), + Some(LanguageModelPickerEntry::Separator(s)) if s == "Recommended" + )); + + assert!(grouped_models.favorites.is_empty()); + } + + #[gpui::test] + fn test_models_have_correct_actions(_cx: &mut TestAppContext) { + let recommended_models = + create_models_with_favorites(vec![("zed", "claude")], vec![("zed", "claude")]); + let all_models = create_models_with_favorites( + vec![("zed", "claude"), ("zed", "gemini"), ("openai", "gpt-4")], + vec![("zed", "claude")], + ); + + let grouped_models = GroupedModels::new(all_models, recommended_models); + let entries = grouped_models.entries(); + + for entry in &entries { + if let LanguageModelPickerEntry::Model(info) = entry { + if info.model.telemetry_id() == "zed/claude" { + assert!(info.is_favorite, "zed/claude should be a favorite"); + } else { + assert!( + !info.is_favorite, + "{} should not be a favorite", + info.model.telemetry_id() + ); + } + } + } + } + + #[gpui::test] + fn test_favorites_appear_in_other_sections(_cx: &mut TestAppContext) { + let favorites = vec![("zed", "gemini"), ("openai", "gpt-4")]; + + let recommended_models = + create_models_with_favorites(vec![("zed", "claude")], favorites.clone()); + + let all_models = create_models_with_favorites( + vec![ + ("zed", "claude"), + ("zed", "gemini"), + ("openai", "gpt-4"), + ("openai", "gpt-3.5"), + ], + favorites, + ); + + let grouped_models = GroupedModels::new(all_models, recommended_models); + + assert_models_eq(grouped_models.favorites, vec!["zed/gemini", "openai/gpt-4"]); + assert_models_eq(grouped_models.recommended, vec!["zed/claude"]); + assert_models_eq( + grouped_models.all.values().flatten().cloned().collect(), + vec!["zed/claude", "zed/gemini", "openai/gpt-4", "openai/gpt-3.5"], + ); + } } diff --git a/crates/agent_ui/src/text_thread_editor.rs b/crates/agent_ui/src/text_thread_editor.rs index 5e3f348c17de3cd0dae9f5fe41a2477211d6ddd8..881eb213a3886b894a778a34cb6ba129bf42c1a4 100644 --- a/crates/agent_ui/src/text_thread_editor.rs +++ b/crates/agent_ui/src/text_thread_editor.rs @@ -304,17 +304,31 @@ impl TextThreadEditor { language_model_selector: cx.new(|cx| { language_model_selector( |cx| LanguageModelRegistry::read_global(cx).default_model(), - move |model, cx| { - update_settings_file(fs.clone(), cx, move |settings, _| { - let provider = model.provider_id().0.to_string(); - let model = model.id().0.to_string(); - settings.agent.get_or_insert_default().set_model( - LanguageModelSelection { - provider: LanguageModelProviderSetting(provider), - model, - }, - ) - }); + { + let fs = fs.clone(); + move |model, cx| { + update_settings_file(fs.clone(), cx, move |settings, _| { + let provider = model.provider_id().0.to_string(); + let model = model.id().0.to_string(); + settings.agent.get_or_insert_default().set_model( + LanguageModelSelection { + provider: LanguageModelProviderSetting(provider), + model, + }, + ) + }); + } + }, + { + let fs = fs.clone(); + move |model, should_be_favorite, cx| { + crate::favorite_models::toggle_in_settings( + model, + should_be_favorite, + fs.clone(), + cx, + ); + } }, true, // Use popover styles for picker focus_handle, diff --git a/crates/agent_ui/src/ui/model_selector_components.rs b/crates/agent_ui/src/ui/model_selector_components.rs index 3218daef7c9aadae5cd45b2fc65807d8a32254bd..184c8e0ba2d3ea307c869e42a13b75f36e713c42 100644 --- a/crates/agent_ui/src/ui/model_selector_components.rs +++ b/crates/agent_ui/src/ui/model_selector_components.rs @@ -1,5 +1,5 @@ use gpui::{Action, FocusHandle, prelude::*}; -use ui::{KeyBinding, ListItem, ListItemSpacing, prelude::*}; +use ui::{ElevationIndex, KeyBinding, ListItem, ListItemSpacing, Tooltip, prelude::*}; #[derive(IntoElement)] pub struct ModelSelectorHeader { @@ -42,6 +42,8 @@ pub struct ModelSelectorListItem { icon: Option, is_selected: bool, is_focused: bool, + is_favorite: bool, + on_toggle_favorite: Option>, } impl ModelSelectorListItem { @@ -52,6 +54,8 @@ impl ModelSelectorListItem { icon: None, is_selected: false, is_focused: false, + is_favorite: false, + on_toggle_favorite: None, } } @@ -69,6 +73,16 @@ impl ModelSelectorListItem { self.is_focused = is_focused; self } + + pub fn is_favorite(mut self, is_favorite: bool) -> Self { + self.is_favorite = is_favorite; + self + } + + pub fn on_toggle_favorite(mut self, handler: impl Fn(&App) + 'static) -> Self { + self.on_toggle_favorite = Some(Box::new(handler)); + self + } } impl RenderOnce for ModelSelectorListItem { @@ -79,6 +93,8 @@ impl RenderOnce for ModelSelectorListItem { Color::Muted }; + let is_favorite = self.is_favorite; + ListItem::new(self.index) .inset(true) .spacing(ListItemSpacing::Sparse) @@ -103,6 +119,23 @@ impl RenderOnce for ModelSelectorListItem { .size(IconSize::Small), ) })) + .end_hover_slot(div().pr_2().when_some(self.on_toggle_favorite, { + |this, handle_click| { + let (icon, color, tooltip) = if is_favorite { + (IconName::StarFilled, Color::Accent, "Unfavorite Model") + } else { + (IconName::Star, Color::Default, "Favorite Model") + }; + this.child( + IconButton::new(("toggle-favorite", self.index), icon) + .layer(ElevationIndex::ElevatedSurface) + .icon_color(color) + .icon_size(IconSize::Small) + .tooltip(Tooltip::text(tooltip)) + .on_click(move |_, _, cx| (handle_click)(cx)), + ) + } + })) } } diff --git a/crates/settings/src/settings_content/agent.rs b/crates/settings/src/settings_content/agent.rs index f7a88deb7d8ba88db6497da2cf79035a64446456..d3a8e40084fc5db7fd348908b1b721617c7c8206 100644 --- a/crates/settings/src/settings_content/agent.rs +++ b/crates/settings/src/settings_content/agent.rs @@ -38,6 +38,9 @@ pub struct AgentSettingsContent { pub default_height: Option, /// The default model to use when creating new chats and for other features when a specific model is not specified. pub default_model: Option, + /// Favorite models to show at the top of the model selector. + #[serde(default)] + pub favorite_models: Vec, /// Model to use for the inline assistant. Defaults to default_model when not specified. pub inline_assistant_model: Option, /// Model to use for the inline assistant when streaming tools are enabled. @@ -176,6 +179,16 @@ impl AgentSettingsContent { pub fn set_profile(&mut self, profile_id: Arc) { self.default_profile = Some(profile_id); } + + pub fn add_favorite_model(&mut self, model: LanguageModelSelection) { + if !self.favorite_models.contains(&model) { + self.favorite_models.push(model); + } + } + + pub fn remove_favorite_model(&mut self, model: &LanguageModelSelection) { + self.favorite_models.retain(|m| m != model); + } } #[with_fallible_options] From d16619a654780aad7534caa2f3562a9b7cab423c Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Tue, 16 Dec 2025 14:32:41 -0500 Subject: [PATCH 081/266] Improve token count accuracy using Anthropic's API (#44943) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #38533 Screenshot 2025-12-16 at 2 32 21 PM Release Notes: - Use up-to-date token counts from LLM responses when reporting tokens used per thread --------- Co-authored-by: Claude Haiku 4.5 --- crates/agent/src/tests/mod.rs | 178 +++++++++++ crates/agent/src/thread.rs | 22 ++ crates/anthropic/src/anthropic.rs | 65 ++++ .../language_models/src/provider/anthropic.rs | 292 ++++++++++++++---- crates/language_models/src/provider/cloud.rs | 10 +- 5 files changed, 507 insertions(+), 60 deletions(-) diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rs index 5a581c5db80a4c4f527efc8b1711fbf16c8097f8..45028902e467fe67945ddf444c9ae417dcaed654 100644 --- a/crates/agent/src/tests/mod.rs +++ b/crates/agent/src/tests/mod.rs @@ -2809,3 +2809,181 @@ fn setup_context_server( cx.run_until_parked(); mcp_tool_calls_rx } + +#[gpui::test] +async fn test_tokens_before_message(cx: &mut TestAppContext) { + let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await; + let fake_model = model.as_fake(); + + // First message + let message_1_id = UserMessageId::new(); + thread + .update(cx, |thread, cx| { + thread.send(message_1_id.clone(), ["First message"], cx) + }) + .unwrap(); + cx.run_until_parked(); + + // Before any response, tokens_before_message should return None for first message + thread.read_with(cx, |thread, _| { + assert_eq!( + thread.tokens_before_message(&message_1_id), + None, + "First message should have no tokens before it" + ); + }); + + // Complete first message with usage + fake_model.send_last_completion_stream_text_chunk("Response 1"); + fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::UsageUpdate( + language_model::TokenUsage { + input_tokens: 100, + output_tokens: 50, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + )); + fake_model.end_last_completion_stream(); + cx.run_until_parked(); + + // First message still has no tokens before it + thread.read_with(cx, |thread, _| { + assert_eq!( + thread.tokens_before_message(&message_1_id), + None, + "First message should still have no tokens before it after response" + ); + }); + + // Second message + let message_2_id = UserMessageId::new(); + thread + .update(cx, |thread, cx| { + thread.send(message_2_id.clone(), ["Second message"], cx) + }) + .unwrap(); + cx.run_until_parked(); + + // Second message should have first message's input tokens before it + thread.read_with(cx, |thread, _| { + assert_eq!( + thread.tokens_before_message(&message_2_id), + Some(100), + "Second message should have 100 tokens before it (from first request)" + ); + }); + + // Complete second message + fake_model.send_last_completion_stream_text_chunk("Response 2"); + fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::UsageUpdate( + language_model::TokenUsage { + input_tokens: 250, // Total for this request (includes previous context) + output_tokens: 75, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + )); + fake_model.end_last_completion_stream(); + cx.run_until_parked(); + + // Third message + let message_3_id = UserMessageId::new(); + thread + .update(cx, |thread, cx| { + thread.send(message_3_id.clone(), ["Third message"], cx) + }) + .unwrap(); + cx.run_until_parked(); + + // Third message should have second message's input tokens (250) before it + thread.read_with(cx, |thread, _| { + assert_eq!( + thread.tokens_before_message(&message_3_id), + Some(250), + "Third message should have 250 tokens before it (from second request)" + ); + // Second message should still have 100 + assert_eq!( + thread.tokens_before_message(&message_2_id), + Some(100), + "Second message should still have 100 tokens before it" + ); + // First message still has none + assert_eq!( + thread.tokens_before_message(&message_1_id), + None, + "First message should still have no tokens before it" + ); + }); +} + +#[gpui::test] +async fn test_tokens_before_message_after_truncate(cx: &mut TestAppContext) { + let ThreadTest { model, thread, .. } = setup(cx, TestModel::Fake).await; + let fake_model = model.as_fake(); + + // Set up three messages with responses + let message_1_id = UserMessageId::new(); + thread + .update(cx, |thread, cx| { + thread.send(message_1_id.clone(), ["Message 1"], cx) + }) + .unwrap(); + cx.run_until_parked(); + fake_model.send_last_completion_stream_text_chunk("Response 1"); + fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::UsageUpdate( + language_model::TokenUsage { + input_tokens: 100, + output_tokens: 50, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + )); + fake_model.end_last_completion_stream(); + cx.run_until_parked(); + + let message_2_id = UserMessageId::new(); + thread + .update(cx, |thread, cx| { + thread.send(message_2_id.clone(), ["Message 2"], cx) + }) + .unwrap(); + cx.run_until_parked(); + fake_model.send_last_completion_stream_text_chunk("Response 2"); + fake_model.send_last_completion_stream_event(LanguageModelCompletionEvent::UsageUpdate( + language_model::TokenUsage { + input_tokens: 250, + output_tokens: 75, + cache_creation_input_tokens: 0, + cache_read_input_tokens: 0, + }, + )); + fake_model.end_last_completion_stream(); + cx.run_until_parked(); + + // Verify initial state + thread.read_with(cx, |thread, _| { + assert_eq!(thread.tokens_before_message(&message_2_id), Some(100)); + }); + + // Truncate at message 2 (removes message 2 and everything after) + thread + .update(cx, |thread, cx| thread.truncate(message_2_id.clone(), cx)) + .unwrap(); + cx.run_until_parked(); + + // After truncation, message_2_id no longer exists, so lookup should return None + thread.read_with(cx, |thread, _| { + assert_eq!( + thread.tokens_before_message(&message_2_id), + None, + "After truncation, message 2 no longer exists" + ); + // Message 1 still exists but has no tokens before it + assert_eq!( + thread.tokens_before_message(&message_1_id), + None, + "First message still has no tokens before it" + ); + }); +} diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index bb22470b9e7db934f949a13b86fd13f9dc58beed..f8f46af5fe2bbea5888ded6e24495afee71680dd 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -1095,6 +1095,28 @@ impl Thread { }) } + /// Get the total input token count as of the message before the given message. + /// + /// Returns `None` if: + /// - `target_id` is the first message (no previous message) + /// - The previous message hasn't received a response yet (no usage data) + /// - `target_id` is not found in the messages + pub fn tokens_before_message(&self, target_id: &UserMessageId) -> Option { + let mut previous_user_message_id: Option<&UserMessageId> = None; + + for message in &self.messages { + if let Message::User(user_msg) = message { + if &user_msg.id == target_id { + let prev_id = previous_user_message_id?; + let usage = self.request_token_usage.get(prev_id)?; + return Some(usage.input_tokens); + } + previous_user_message_id = Some(&user_msg.id); + } + } + None + } + /// Look up the active profile and resolve its preferred model if one is configured. fn resolve_profile_model( profile_id: &AgentProfileId, diff --git a/crates/anthropic/src/anthropic.rs b/crates/anthropic/src/anthropic.rs index e976b7f5dc36905d2a32b4cdc04869f3267705fe..f0dde3eedea657ea2d2ebe9ede457e329bd8b9a5 100644 --- a/crates/anthropic/src/anthropic.rs +++ b/crates/anthropic/src/anthropic.rs @@ -1052,6 +1052,71 @@ pub fn parse_prompt_too_long(message: &str) -> Option { .ok() } +/// Request body for the token counting API. +/// Similar to `Request` but without `max_tokens` since it's not needed for counting. +#[derive(Debug, Serialize)] +pub struct CountTokensRequest { + pub model: String, + pub messages: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub tools: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub thinking: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub tool_choice: Option, +} + +/// Response from the token counting API. +#[derive(Debug, Deserialize)] +pub struct CountTokensResponse { + pub input_tokens: u64, +} + +/// Count the number of tokens in a message without creating it. +pub async fn count_tokens( + client: &dyn HttpClient, + api_url: &str, + api_key: &str, + request: CountTokensRequest, +) -> Result { + let uri = format!("{api_url}/v1/messages/count_tokens"); + + let request_builder = HttpRequest::builder() + .method(Method::POST) + .uri(uri) + .header("Anthropic-Version", "2023-06-01") + .header("X-Api-Key", api_key.trim()) + .header("Content-Type", "application/json"); + + let serialized_request = + serde_json::to_string(&request).map_err(AnthropicError::SerializeRequest)?; + let http_request = request_builder + .body(AsyncBody::from(serialized_request)) + .map_err(AnthropicError::BuildRequestBody)?; + + let mut response = client + .send(http_request) + .await + .map_err(AnthropicError::HttpSend)?; + + let rate_limits = RateLimitInfo::from_headers(response.headers()); + + if response.status().is_success() { + let mut body = String::new(); + response + .body_mut() + .read_to_string(&mut body) + .await + .map_err(AnthropicError::ReadResponse)?; + + serde_json::from_str(&body).map_err(AnthropicError::DeserializeResponse) + } else { + Err(handle_error_response(response, rate_limits).await) + } +} + #[test] fn test_match_window_exceeded() { let error = ApiError { diff --git a/crates/language_models/src/provider/anthropic.rs b/crates/language_models/src/provider/anthropic.rs index 25ba7615dc23e2561648e173588be6d93c28e295..d8c972399c33922386bfba4236e1369d03d338dc 100644 --- a/crates/language_models/src/provider/anthropic.rs +++ b/crates/language_models/src/provider/anthropic.rs @@ -1,6 +1,6 @@ use anthropic::{ - ANTHROPIC_API_URL, AnthropicError, AnthropicModelMode, ContentDelta, Event, ResponseContent, - ToolResultContent, ToolResultPart, Usage, + ANTHROPIC_API_URL, AnthropicError, AnthropicModelMode, ContentDelta, CountTokensRequest, Event, + ResponseContent, ToolResultContent, ToolResultPart, Usage, }; use anyhow::{Result, anyhow}; use collections::{BTreeMap, HashMap}; @@ -219,68 +219,215 @@ pub struct AnthropicModel { request_limiter: RateLimiter, } -pub fn count_anthropic_tokens( +/// Convert a LanguageModelRequest to an Anthropic CountTokensRequest. +pub fn into_anthropic_count_tokens_request( request: LanguageModelRequest, - cx: &App, -) -> BoxFuture<'static, Result> { - cx.background_spawn(async move { - let messages = request.messages; - let mut tokens_from_images = 0; - let mut string_messages = Vec::with_capacity(messages.len()); - - for message in messages { - use language_model::MessageContent; - - let mut string_contents = String::new(); - - for content in message.content { - match content { - MessageContent::Text(text) => { - string_contents.push_str(&text); - } - MessageContent::Thinking { .. } => { - // Thinking blocks are not included in the input token count. - } - MessageContent::RedactedThinking(_) => { - // Thinking blocks are not included in the input token count. - } - MessageContent::Image(image) => { - tokens_from_images += image.estimate_tokens(); - } - MessageContent::ToolUse(_tool_use) => { - // TODO: Estimate token usage from tool uses. - } - MessageContent::ToolResult(tool_result) => match &tool_result.content { - LanguageModelToolResultContent::Text(text) => { - string_contents.push_str(text); + model: String, + mode: AnthropicModelMode, +) -> CountTokensRequest { + let mut new_messages: Vec = Vec::new(); + let mut system_message = String::new(); + + for message in request.messages { + if message.contents_empty() { + continue; + } + + match message.role { + Role::User | Role::Assistant => { + let anthropic_message_content: Vec = message + .content + .into_iter() + .filter_map(|content| match content { + MessageContent::Text(text) => { + let text = if text.chars().last().is_some_and(|c| c.is_whitespace()) { + text.trim_end().to_string() + } else { + text + }; + if !text.is_empty() { + Some(anthropic::RequestContent::Text { + text, + cache_control: None, + }) + } else { + None + } + } + MessageContent::Thinking { + text: thinking, + signature, + } => { + if !thinking.is_empty() { + Some(anthropic::RequestContent::Thinking { + thinking, + signature: signature.unwrap_or_default(), + cache_control: None, + }) + } else { + None + } + } + MessageContent::RedactedThinking(data) => { + if !data.is_empty() { + Some(anthropic::RequestContent::RedactedThinking { data }) + } else { + None + } } - LanguageModelToolResultContent::Image(image) => { - tokens_from_images += image.estimate_tokens(); + MessageContent::Image(image) => Some(anthropic::RequestContent::Image { + source: anthropic::ImageSource { + source_type: "base64".to_string(), + media_type: "image/png".to_string(), + data: image.source.to_string(), + }, + cache_control: None, + }), + MessageContent::ToolUse(tool_use) => { + Some(anthropic::RequestContent::ToolUse { + id: tool_use.id.to_string(), + name: tool_use.name.to_string(), + input: tool_use.input, + cache_control: None, + }) + } + MessageContent::ToolResult(tool_result) => { + Some(anthropic::RequestContent::ToolResult { + tool_use_id: tool_result.tool_use_id.to_string(), + is_error: tool_result.is_error, + content: match tool_result.content { + LanguageModelToolResultContent::Text(text) => { + ToolResultContent::Plain(text.to_string()) + } + LanguageModelToolResultContent::Image(image) => { + ToolResultContent::Multipart(vec![ToolResultPart::Image { + source: anthropic::ImageSource { + source_type: "base64".to_string(), + media_type: "image/png".to_string(), + data: image.source.to_string(), + }, + }]) + } + }, + cache_control: None, + }) } - }, + }) + .collect(); + let anthropic_role = match message.role { + Role::User => anthropic::Role::User, + Role::Assistant => anthropic::Role::Assistant, + Role::System => unreachable!("System role should never occur here"), + }; + if let Some(last_message) = new_messages.last_mut() + && last_message.role == anthropic_role + { + last_message.content.extend(anthropic_message_content); + continue; } - } - if !string_contents.is_empty() { - string_messages.push(tiktoken_rs::ChatCompletionRequestMessage { - role: match message.role { - Role::User => "user".into(), - Role::Assistant => "assistant".into(), - Role::System => "system".into(), - }, - content: Some(string_contents), - name: None, - function_call: None, + new_messages.push(anthropic::Message { + role: anthropic_role, + content: anthropic_message_content, }); } + Role::System => { + if !system_message.is_empty() { + system_message.push_str("\n\n"); + } + system_message.push_str(&message.string_contents()); + } + } + } + + CountTokensRequest { + model, + messages: new_messages, + system: if system_message.is_empty() { + None + } else { + Some(anthropic::StringOrContents::String(system_message)) + }, + thinking: if request.thinking_allowed + && let AnthropicModelMode::Thinking { budget_tokens } = mode + { + Some(anthropic::Thinking::Enabled { budget_tokens }) + } else { + None + }, + tools: request + .tools + .into_iter() + .map(|tool| anthropic::Tool { + name: tool.name, + description: tool.description, + input_schema: tool.input_schema, + }) + .collect(), + tool_choice: request.tool_choice.map(|choice| match choice { + LanguageModelToolChoice::Auto => anthropic::ToolChoice::Auto, + LanguageModelToolChoice::Any => anthropic::ToolChoice::Any, + LanguageModelToolChoice::None => anthropic::ToolChoice::None, + }), + } +} + +/// Estimate tokens using tiktoken. Used as a fallback when the API is unavailable, +/// or by providers (like Zed Cloud) that don't have direct Anthropic API access. +pub fn count_anthropic_tokens_with_tiktoken(request: LanguageModelRequest) -> Result { + let messages = request.messages; + let mut tokens_from_images = 0; + let mut string_messages = Vec::with_capacity(messages.len()); + + for message in messages { + let mut string_contents = String::new(); + + for content in message.content { + match content { + MessageContent::Text(text) => { + string_contents.push_str(&text); + } + MessageContent::Thinking { .. } => { + // Thinking blocks are not included in the input token count. + } + MessageContent::RedactedThinking(_) => { + // Thinking blocks are not included in the input token count. + } + MessageContent::Image(image) => { + tokens_from_images += image.estimate_tokens(); + } + MessageContent::ToolUse(_tool_use) => { + // TODO: Estimate token usage from tool uses. + } + MessageContent::ToolResult(tool_result) => match &tool_result.content { + LanguageModelToolResultContent::Text(text) => { + string_contents.push_str(text); + } + LanguageModelToolResultContent::Image(image) => { + tokens_from_images += image.estimate_tokens(); + } + }, + } + } + + if !string_contents.is_empty() { + string_messages.push(tiktoken_rs::ChatCompletionRequestMessage { + role: match message.role { + Role::User => "user".into(), + Role::Assistant => "assistant".into(), + Role::System => "system".into(), + }, + content: Some(string_contents), + name: None, + function_call: None, + }); } + } - // Tiktoken doesn't yet support these models, so we manually use the - // same tokenizer as GPT-4. - tiktoken_rs::num_tokens_from_messages("gpt-4", &string_messages) - .map(|tokens| (tokens + tokens_from_images) as u64) - }) - .boxed() + // Tiktoken doesn't yet support these models, so we manually use the + // same tokenizer as GPT-4. + tiktoken_rs::num_tokens_from_messages("gpt-4", &string_messages) + .map(|tokens| (tokens + tokens_from_images) as u64) } impl AnthropicModel { @@ -386,7 +533,40 @@ impl LanguageModel for AnthropicModel { request: LanguageModelRequest, cx: &App, ) -> BoxFuture<'static, Result> { - count_anthropic_tokens(request, cx) + let http_client = self.http_client.clone(); + let model_id = self.model.request_id().to_string(); + let mode = self.model.mode(); + + let (api_key, api_url) = self.state.read_with(cx, |state, cx| { + let api_url = AnthropicLanguageModelProvider::api_url(cx); + ( + state.api_key_state.key(&api_url).map(|k| k.to_string()), + api_url.to_string(), + ) + }); + + async move { + // If no API key, fall back to tiktoken estimation + let Some(api_key) = api_key else { + return count_anthropic_tokens_with_tiktoken(request); + }; + + let count_request = + into_anthropic_count_tokens_request(request.clone(), model_id, mode); + + match anthropic::count_tokens(http_client.as_ref(), &api_url, &api_key, count_request) + .await + { + Ok(response) => Ok(response.input_tokens), + Err(err) => { + log::error!( + "Anthropic count_tokens API failed, falling back to tiktoken: {err:?}" + ); + count_anthropic_tokens_with_tiktoken(request) + } + } + } + .boxed() } fn stream_completion( diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index 508a77d38abcf2143170382e945ab6ce31f3a623..def1cef84d3166d08dcc7638ca5a29cabbd149c5 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -42,7 +42,9 @@ use thiserror::Error; use ui::{TintColor, prelude::*}; use util::{ResultExt as _, maybe}; -use crate::provider::anthropic::{AnthropicEventMapper, count_anthropic_tokens, into_anthropic}; +use crate::provider::anthropic::{ + AnthropicEventMapper, count_anthropic_tokens_with_tiktoken, into_anthropic, +}; use crate::provider::google::{GoogleEventMapper, into_google}; use crate::provider::open_ai::{OpenAiEventMapper, count_open_ai_tokens, into_open_ai}; use crate::provider::x_ai::count_xai_tokens; @@ -667,9 +669,9 @@ impl LanguageModel for CloudLanguageModel { cx: &App, ) -> BoxFuture<'static, Result> { match self.model.provider { - cloud_llm_client::LanguageModelProvider::Anthropic => { - count_anthropic_tokens(request, cx) - } + cloud_llm_client::LanguageModelProvider::Anthropic => cx + .background_spawn(async move { count_anthropic_tokens_with_tiktoken(request) }) + .boxed(), cloud_llm_client::LanguageModelProvider::OpenAi => { let model = match open_ai::Model::from_id(&self.model.id.0) { Ok(model) => model, From abcf5a127357e8d24b033550eed38c5966eee6cb Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Tue, 16 Dec 2025 14:41:59 -0500 Subject: [PATCH 082/266] Revert "gpui: Take advantage of unified memory on Apple silicon (#44273)" (#45022) This reverts commit 2441dc3f6637431a781ae10b2e1aa8c4704b9502. Release Notes: - N/A --- crates/gpui/src/platform/mac/metal_atlas.rs | 9 --- .../gpui/src/platform/mac/metal_renderer.rs | 61 ++++--------------- 2 files changed, 12 insertions(+), 58 deletions(-) diff --git a/crates/gpui/src/platform/mac/metal_atlas.rs b/crates/gpui/src/platform/mac/metal_atlas.rs index 9b43efe361a0816e32e858a44cafec66c42e7f85..8282530c5efdc13ca95a1f04c0f6ef1a23c8366c 100644 --- a/crates/gpui/src/platform/mac/metal_atlas.rs +++ b/crates/gpui/src/platform/mac/metal_atlas.rs @@ -15,9 +15,6 @@ pub(crate) struct MetalAtlas(Mutex); impl MetalAtlas { pub(crate) fn new(device: Device) -> Self { MetalAtlas(Mutex::new(MetalAtlasState { - // Shared memory can be used only if CPU and GPU share the same memory space. - // https://developer.apple.com/documentation/metal/setting-resource-storage-modes - unified_memory: device.has_unified_memory(), device: AssertSend(device), monochrome_textures: Default::default(), polychrome_textures: Default::default(), @@ -32,7 +29,6 @@ impl MetalAtlas { struct MetalAtlasState { device: AssertSend, - unified_memory: bool, monochrome_textures: AtlasTextureList, polychrome_textures: AtlasTextureList, tiles_by_key: FxHashMap, @@ -150,11 +146,6 @@ impl MetalAtlasState { } texture_descriptor.set_pixel_format(pixel_format); texture_descriptor.set_usage(usage); - texture_descriptor.set_storage_mode(if self.unified_memory { - metal::MTLStorageMode::Shared - } else { - metal::MTLStorageMode::Managed - }); let metal_texture = self.device.new_texture(&texture_descriptor); let texture_list = match kind { diff --git a/crates/gpui/src/platform/mac/metal_renderer.rs b/crates/gpui/src/platform/mac/metal_renderer.rs index 6d7b82507fb581ec1f124e153e5bb91d3eaf9d25..550041a0ccb4cd39bc7a86317d9540e806af2a28 100644 --- a/crates/gpui/src/platform/mac/metal_renderer.rs +++ b/crates/gpui/src/platform/mac/metal_renderer.rs @@ -76,22 +76,12 @@ impl InstanceBufferPool { self.buffers.clear(); } - pub(crate) fn acquire( - &mut self, - device: &metal::Device, - unified_memory: bool, - ) -> InstanceBuffer { + pub(crate) fn acquire(&mut self, device: &metal::Device) -> InstanceBuffer { let buffer = self.buffers.pop().unwrap_or_else(|| { - let options = if unified_memory { - MTLResourceOptions::StorageModeShared - // Buffers are write only which can benefit from the combined cache - // https://developer.apple.com/documentation/metal/mtlresourceoptions/cpucachemodewritecombined - | MTLResourceOptions::CPUCacheModeWriteCombined - } else { - MTLResourceOptions::StorageModeManaged - }; - - device.new_buffer(self.buffer_size as u64, options) + device.new_buffer( + self.buffer_size as u64, + MTLResourceOptions::StorageModeManaged, + ) }); InstanceBuffer { metal_buffer: buffer, @@ -109,7 +99,6 @@ impl InstanceBufferPool { pub(crate) struct MetalRenderer { device: metal::Device, layer: metal::MetalLayer, - unified_memory: bool, presents_with_transaction: bool, command_queue: CommandQueue, paths_rasterization_pipeline_state: metal::RenderPipelineState, @@ -190,10 +179,6 @@ impl MetalRenderer { output } - // Shared memory can be used only if CPU and GPU share the same memory space. - // https://developer.apple.com/documentation/metal/setting-resource-storage-modes - let unified_memory = device.has_unified_memory(); - let unit_vertices = [ to_float2_bits(point(0., 0.)), to_float2_bits(point(1., 0.)), @@ -205,12 +190,7 @@ impl MetalRenderer { let unit_vertices = device.new_buffer_with_data( unit_vertices.as_ptr() as *const c_void, mem::size_of_val(&unit_vertices) as u64, - if unified_memory { - MTLResourceOptions::StorageModeShared - | MTLResourceOptions::CPUCacheModeWriteCombined - } else { - MTLResourceOptions::StorageModeManaged - }, + MTLResourceOptions::StorageModeManaged, ); let paths_rasterization_pipeline_state = build_path_rasterization_pipeline_state( @@ -288,7 +268,6 @@ impl MetalRenderer { device, layer, presents_with_transaction: false, - unified_memory, command_queue, paths_rasterization_pipeline_state, path_sprites_pipeline_state, @@ -358,23 +337,14 @@ impl MetalRenderer { texture_descriptor.set_width(size.width.0 as u64); texture_descriptor.set_height(size.height.0 as u64); texture_descriptor.set_pixel_format(metal::MTLPixelFormat::BGRA8Unorm); - texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private); texture_descriptor .set_usage(metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead); self.path_intermediate_texture = Some(self.device.new_texture(&texture_descriptor)); if self.path_sample_count > 1 { - // https://developer.apple.com/documentation/metal/choosing-a-resource-storage-mode-for-apple-gpus - // Rendering MSAA textures are done in a single pass, so we can use memory-less storage on Apple Silicon - let storage_mode = if self.unified_memory { - metal::MTLStorageMode::Memoryless - } else { - metal::MTLStorageMode::Private - }; - let mut msaa_descriptor = texture_descriptor; msaa_descriptor.set_texture_type(metal::MTLTextureType::D2Multisample); - msaa_descriptor.set_storage_mode(storage_mode); + msaa_descriptor.set_storage_mode(metal::MTLStorageMode::Private); msaa_descriptor.set_sample_count(self.path_sample_count as _); self.path_intermediate_msaa_texture = Some(self.device.new_texture(&msaa_descriptor)); } else { @@ -408,10 +378,7 @@ impl MetalRenderer { }; loop { - let mut instance_buffer = self - .instance_buffer_pool - .lock() - .acquire(&self.device, self.unified_memory); + let mut instance_buffer = self.instance_buffer_pool.lock().acquire(&self.device); let command_buffer = self.draw_primitives(scene, &mut instance_buffer, drawable, viewport_size); @@ -583,14 +550,10 @@ impl MetalRenderer { command_encoder.end_encoding(); - if !self.unified_memory { - // Sync the instance buffer to the GPU - instance_buffer.metal_buffer.did_modify_range(NSRange { - location: 0, - length: instance_offset as NSUInteger, - }); - } - + instance_buffer.metal_buffer.did_modify_range(NSRange { + location: 0, + length: instance_offset as NSUInteger, + }); Ok(command_buffer.to_owned()) } From 7972baafe98b7d4acbc4b0a847944552c2a17a24 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Tue, 16 Dec 2025 21:07:10 +0100 Subject: [PATCH 083/266] git: Prevent customizing commit message prompt for legacy Zed Pro users (#45016) We need to prevent this, since commit message generation did not count as a prompt in the old billing model. If users of Legacy Zed Pro customise the prompt, it will count as an actual prompt since our matching algorithm will fail. We can remove this once we stop supporting Legacy Zed Pro on 17 January. Release Notes: - N/A --- crates/git_ui/src/git_panel.rs | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index d7be4dfe723e9cbe312420e920e4b4e90f080585..390f5cf2c28bfc0ff1aef5226e125d08db37dd68 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -43,7 +43,8 @@ use gpui::{ use itertools::Itertools; use language::{Buffer, File}; use language_model::{ - ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role, + ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, + Role, ZED_CLOUD_PROVIDER_ID, }; use menu::{Confirm, SecondaryConfirm, SelectFirst, SelectLast, SelectNext, SelectPrevious}; use multi_buffer::ExcerptInfo; @@ -2422,9 +2423,20 @@ impl GitPanel { } } - async fn load_commit_message_prompt(cx: &mut AsyncApp) -> String { + async fn load_commit_message_prompt( + is_using_legacy_zed_pro: bool, + cx: &mut AsyncApp, + ) -> String { const DEFAULT_PROMPT: &str = include_str!("commit_message_prompt.txt"); + // Remove this once we stop supporting legacy Zed Pro + // In legacy Zed Pro, Git commit summary generation did not count as a + // prompt. If the user changes the prompt, our classification will fail, + // meaning that users will be charged for generating commit messages. + if is_using_legacy_zed_pro { + return DEFAULT_PROMPT.to_string(); + } + let load = async { let store = cx.update(|cx| PromptStore::global(cx)).ok()?.await.ok()?; store @@ -2466,6 +2478,13 @@ impl GitPanel { let project = self.project.clone(); let repo_work_dir = repo.read(cx).work_directory_abs_path.clone(); + // Remove this once we stop supporting legacy Zed Pro + let is_using_legacy_zed_pro = provider.id() == ZED_CLOUD_PROVIDER_ID + && self.workspace.upgrade().map_or(false, |workspace| { + workspace.read(cx).user_store().read(cx).plan() + == Some(cloud_llm_client::Plan::V1(cloud_llm_client::PlanV1::ZedPro)) + }); + self.generate_commit_message_task = Some(cx.spawn(async move |this, mut cx| { async move { let _defer = cx.on_drop(&this, |this, _cx| { @@ -2501,7 +2520,7 @@ impl GitPanel { let rules_content = Self::load_project_rules(&project, &repo_work_dir, &mut cx).await; - let prompt = Self::load_commit_message_prompt(&mut cx).await; + let prompt = Self::load_commit_message_prompt(is_using_legacy_zed_pro, &mut cx).await; let subject = this.update(cx, |this, cx| { this.commit_editor.read(cx).text(cx).lines().next().map(ToOwned::to_owned).unwrap_or_default() From 301d7fbc6163df5e8404853f7686ee54e4168e85 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 18:23:30 -0300 Subject: [PATCH 084/266] agent_ui: Add keybinding to cycle through favorited models (#45032) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Similar to how you can use `shift-tab` to cycle through profiles/modes, you can now use `alt-tab` to cycle through the language models you have favorited. Screenshot 2025-12-16 at 5  23@2x Release Notes: - agent: Added the ability to cycle through favorited models using the `alt-tab` keybinding. --- assets/keymaps/default-linux.json | 2 + assets/keymaps/default-macos.json | 5 ++ assets/keymaps/default-windows.json | 3 + crates/agent_ui/src/acp/model_selector.rs | 61 +++++++++++++++++++ .../src/acp/model_selector_popover.rs | 58 +++++++++++++++--- crates/agent_ui/src/acp/thread_view.rs | 11 +++- crates/agent_ui/src/agent_ui.rs | 2 + .../agent_ui/src/language_model_selector.rs | 35 +++++++++++ crates/agent_ui/src/text_thread_editor.rs | 54 ++++++++++++++-- .../src/ui/model_selector_components.rs | 8 +-- 10 files changed, 220 insertions(+), 19 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 5a37614180d46b4a79b97f9a23665cbf5372cc0a..1016a20bd6facdc8f5ef9163ebda3e03d451c5cf 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -252,6 +252,7 @@ "ctrl-y": "agent::AllowOnce", "ctrl-alt-y": "agent::AllowAlways", "ctrl-alt-z": "agent::RejectOnce", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -346,6 +347,7 @@ "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", "shift-tab": "agent::CycleModeSelector", + "alt-tab": "agent::CycleFavoriteModels", }, }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 8c8094495e16a9f26adaa380f584abe5e3bc2947..c80edf01a02347cf678fe9cb24390f2fca41d70e 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -266,6 +266,7 @@ "cmd-g": "search::SelectNextMatch", "cmd-shift-g": "search::SelectPreviousMatch", "cmd-k l": "agent::OpenRulesLibrary", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -292,6 +293,7 @@ "cmd-y": "agent::AllowOnce", "cmd-alt-y": "agent::AllowAlways", "cmd-alt-z": "agent::RejectOnce", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -386,6 +388,7 @@ "cmd-shift-y": "agent::KeepAll", "cmd-shift-n": "agent::RejectAll", "shift-tab": "agent::CycleModeSelector", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -397,6 +400,7 @@ "cmd-shift-y": "agent::KeepAll", "cmd-shift-n": "agent::RejectAll", "shift-tab": "agent::CycleModeSelector", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -880,6 +884,7 @@ "use_key_equivalents": true, "bindings": { "cmd-alt-/": "agent::ToggleModelSelector", + "alt-tab": "agent::CycleFavoriteModels", "ctrl-[": "agent::CyclePreviousInlineAssist", "ctrl-]": "agent::CycleNextInlineAssist", "cmd-shift-enter": "inline_assistant::ThumbsUpResult", diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index 74320ae637080da92108f195eabca537e3a71406..dcc828ddf2ef63f3fef6e7e12d9349bead57572e 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -253,6 +253,7 @@ "shift-alt-a": "agent::AllowOnce", "ctrl-alt-y": "agent::AllowAlways", "shift-alt-z": "agent::RejectOnce", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -342,6 +343,7 @@ "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", "shift-tab": "agent::CycleModeSelector", + "alt-tab": "agent::CycleFavoriteModels", }, }, { @@ -353,6 +355,7 @@ "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", "shift-tab": "agent::CycleModeSelector", + "alt-tab": "agent::CycleFavoriteModels", }, }, { diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs index f885ff12e598168abdf7727dc03e4814e5de3b49..cff5334a00472fd6f49abcb17897b4ed3c9f590e 100644 --- a/crates/agent_ui/src/acp/model_selector.rs +++ b/crates/agent_ui/src/acp/model_selector.rs @@ -119,6 +119,67 @@ impl AcpModelPickerDelegate { pub fn active_model(&self) -> Option<&AgentModelInfo> { self.selected_model.as_ref() } + + pub fn cycle_favorite_models(&mut self, window: &mut Window, cx: &mut Context>) { + if !self.selector.supports_favorites() { + return; + } + + let favorites = AgentSettings::get_global(cx).favorite_model_ids(); + + if favorites.is_empty() { + return; + } + + let Some(models) = self.models.clone() else { + return; + }; + + let all_models: Vec = match models { + AgentModelList::Flat(list) => list, + AgentModelList::Grouped(index_map) => index_map + .into_values() + .flatten() + .collect::>(), + }; + + let favorite_models = all_models + .iter() + .filter(|model| favorites.contains(&model.id)) + .unique_by(|model| &model.id) + .cloned() + .collect::>(); + + let current_id = self.selected_model.as_ref().map(|m| m.id.clone()); + + let current_index_in_favorites = current_id + .as_ref() + .and_then(|id| favorite_models.iter().position(|m| &m.id == id)) + .unwrap_or(usize::MAX); + + let next_index = if current_index_in_favorites == usize::MAX { + 0 + } else { + (current_index_in_favorites + 1) % favorite_models.len() + }; + + let next_model = favorite_models[next_index].clone(); + + self.selector + .select_model(next_model.id.clone(), cx) + .detach_and_log_err(cx); + + self.selected_model = Some(next_model); + + // Keep the picker selection aligned with the newly-selected model + if let Some(new_index) = self.filtered_entries.iter().position(|entry| { + matches!(entry, AcpModelPickerEntry::Model(model_info, _) if self.selected_model.as_ref().is_some_and(|selected| model_info.id == selected.id)) + }) { + self.set_selected_index(new_index, window, cx); + } else { + cx.notify(); + } + } } impl PickerDelegate for AcpModelPickerDelegate { diff --git a/crates/agent_ui/src/acp/model_selector_popover.rs b/crates/agent_ui/src/acp/model_selector_popover.rs index e2393c11bd6c23b79397abf274fb6539c0c7063f..d6709081863c9545fba4c6e2304f195e77b013df 100644 --- a/crates/agent_ui/src/acp/model_selector_popover.rs +++ b/crates/agent_ui/src/acp/model_selector_popover.rs @@ -3,15 +3,15 @@ use std::sync::Arc; use acp_thread::{AgentModelInfo, AgentModelSelector}; use agent_servers::AgentServer; +use agent_settings::AgentSettings; use fs::Fs; use gpui::{Entity, FocusHandle}; use picker::popover_menu::PickerPopoverMenu; -use ui::{ - ButtonLike, Context, IntoElement, PopoverMenuHandle, SharedString, TintColor, Tooltip, Window, - prelude::*, -}; +use settings::Settings as _; +use ui::{ButtonLike, KeyBinding, PopoverMenuHandle, TintColor, Tooltip, prelude::*}; use zed_actions::agent::ToggleModelSelector; +use crate::CycleFavoriteModels; use crate::acp::{AcpModelSelector, model_selector::acp_model_selector}; pub struct AcpModelSelectorPopover { @@ -54,6 +54,12 @@ impl AcpModelSelectorPopover { pub fn active_model<'a>(&self, cx: &'a App) -> Option<&'a AgentModelInfo> { self.selector.read(cx).delegate.active_model() } + + pub fn cycle_favorite_models(&self, window: &mut Window, cx: &mut Context) { + self.selector.update(cx, |selector, cx| { + selector.delegate.cycle_favorite_models(window, cx); + }); + } } impl Render for AcpModelSelectorPopover { @@ -74,6 +80,46 @@ impl Render for AcpModelSelectorPopover { (Color::Muted, IconName::ChevronDown) }; + let tooltip = Tooltip::element({ + move |_, cx| { + let focus_handle = focus_handle.clone(); + let should_show_cycle_row = !AgentSettings::get_global(cx) + .favorite_model_ids() + .is_empty(); + + v_flex() + .gap_1() + .child( + h_flex() + .gap_2() + .justify_between() + .child(Label::new("Change Model")) + .child(KeyBinding::for_action_in( + &ToggleModelSelector, + &focus_handle, + cx, + )), + ) + .when(should_show_cycle_row, |this| { + this.child( + h_flex() + .pt_1() + .gap_2() + .border_t_1() + .border_color(cx.theme().colors().border_variant) + .justify_between() + .child(Label::new("Cycle Favorited Models")) + .child(KeyBinding::for_action_in( + &CycleFavoriteModels, + &focus_handle, + cx, + )), + ) + }) + .into_any() + } + }); + PickerPopoverMenu::new( self.selector.clone(), ButtonLike::new("active-model") @@ -88,9 +134,7 @@ impl Render for AcpModelSelectorPopover { .ml_0p5(), ) .child(Icon::new(icon).color(Color::Muted).size(IconSize::XSmall)), - move |_window, cx| { - Tooltip::for_action_in("Change Model", &ToggleModelSelector, &focus_handle, cx) - }, + tooltip, gpui::Corner::BottomRight, cx, ) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 90134ebfb458a37f01ed99fe7345238c763e5418..05162348db060bff05aa7b1dd223815895f02e2d 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -66,8 +66,8 @@ use crate::profile_selector::{ProfileProvider, ProfileSelector}; use crate::ui::{AgentNotification, AgentNotificationEvent, BurnModeTooltip, UsageCallout}; use crate::{ AgentDiffPane, AgentPanel, AllowAlways, AllowOnce, ContinueThread, ContinueWithBurnMode, - CycleModeSelector, ExpandMessageEditor, Follow, KeepAll, NewThread, OpenAgentDiff, OpenHistory, - RejectAll, RejectOnce, ToggleBurnMode, ToggleProfileSelector, + CycleFavoriteModels, CycleModeSelector, ExpandMessageEditor, Follow, KeepAll, NewThread, + OpenAgentDiff, OpenHistory, RejectAll, RejectOnce, ToggleBurnMode, ToggleProfileSelector, }; #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -4293,6 +4293,13 @@ impl AcpThreadView { .update(cx, |model_selector, cx| model_selector.toggle(window, cx)); } })) + .on_action(cx.listener(|this, _: &CycleFavoriteModels, window, cx| { + if let Some(model_selector) = this.model_selector.as_ref() { + model_selector.update(cx, |model_selector, cx| { + model_selector.cycle_favorite_models(window, cx); + }); + } + })) .p_2() .gap_2() .border_t_1() diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index 1622d17f5852d825b9c8d69996fad7c89bb89dce..c80c7b43644ab949e748609435e33dfe9f31d54e 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -68,6 +68,8 @@ actions!( ToggleProfileSelector, /// Cycles through available session modes. CycleModeSelector, + /// Cycles through favorited models in the ACP model selector. + CycleFavoriteModels, /// Expands the message editor to full size. ExpandMessageEditor, /// Removes all thread history. diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs index 7bb42fb330dcccb4b5401217d0181d3d616fe66f..77c8c95255908dc54639ad7ac6c55f1e8b8151f0 100644 --- a/crates/agent_ui/src/language_model_selector.rs +++ b/crates/agent_ui/src/language_model_selector.rs @@ -249,6 +249,41 @@ impl LanguageModelPickerDelegate { pub fn active_model(&self, cx: &App) -> Option { (self.get_active_model)(cx) } + + pub fn cycle_favorite_models(&mut self, window: &mut Window, cx: &mut Context>) { + if self.all_models.favorites.is_empty() { + return; + } + + let active_model = (self.get_active_model)(cx); + let active_provider_id = active_model.as_ref().map(|m| m.provider.id()); + let active_model_id = active_model.as_ref().map(|m| m.model.id()); + + let current_index = self + .all_models + .favorites + .iter() + .position(|info| { + Some(info.model.provider_id()) == active_provider_id + && Some(info.model.id()) == active_model_id + }) + .unwrap_or(usize::MAX); + + let next_index = if current_index == usize::MAX { + 0 + } else { + (current_index + 1) % self.all_models.favorites.len() + }; + + let next_model = self.all_models.favorites[next_index].model.clone(); + + (self.on_model_changed)(next_model, cx); + + // Align the picker selection with the newly-active model + let new_index = + Self::get_active_model_index(&self.filtered_entries, (self.get_active_model)(cx)); + self.set_selected_index(new_index, window, cx); + } } struct GroupedModels { diff --git a/crates/agent_ui/src/text_thread_editor.rs b/crates/agent_ui/src/text_thread_editor.rs index 881eb213a3886b894a778a34cb6ba129bf42c1a4..947afe050639f89922873a12baa8b1eadfc44995 100644 --- a/crates/agent_ui/src/text_thread_editor.rs +++ b/crates/agent_ui/src/text_thread_editor.rs @@ -2,7 +2,7 @@ use crate::{ language_model_selector::{LanguageModelSelector, language_model_selector}, ui::BurnModeTooltip, }; -use agent_settings::CompletionMode; +use agent_settings::{AgentSettings, CompletionMode}; use anyhow::Result; use assistant_slash_command::{SlashCommand, SlashCommandOutputSection, SlashCommandWorkingSet}; use assistant_slash_commands::{DefaultSlashCommand, FileSlashCommand, selections_creases}; @@ -73,6 +73,8 @@ use workspace::{ }; use zed_actions::agent::{AddSelectionToThread, ToggleModelSelector}; +use crate::CycleFavoriteModels; + use crate::{slash_command::SlashCommandCompletionProvider, slash_command_picker}; use assistant_text_thread::{ CacheStatus, Content, InvokedSlashCommandId, InvokedSlashCommandStatus, Message, MessageId, @@ -2209,12 +2211,53 @@ impl TextThreadEditor { }; let focus_handle = self.editor().focus_handle(cx); + let (color, icon) = if self.language_model_selector_menu_handle.is_deployed() { (Color::Accent, IconName::ChevronUp) } else { (Color::Muted, IconName::ChevronDown) }; + let tooltip = Tooltip::element({ + move |_, cx| { + let focus_handle = focus_handle.clone(); + let should_show_cycle_row = !AgentSettings::get_global(cx) + .favorite_model_ids() + .is_empty(); + + v_flex() + .gap_1() + .child( + h_flex() + .gap_2() + .justify_between() + .child(Label::new("Change Model")) + .child(KeyBinding::for_action_in( + &ToggleModelSelector, + &focus_handle, + cx, + )), + ) + .when(should_show_cycle_row, |this| { + this.child( + h_flex() + .pt_1() + .gap_2() + .border_t_1() + .border_color(cx.theme().colors().border_variant) + .justify_between() + .child(Label::new("Cycle Favorited Models")) + .child(KeyBinding::for_action_in( + &CycleFavoriteModels, + &focus_handle, + cx, + )), + ) + }) + .into_any() + } + }); + PickerPopoverMenu::new( self.language_model_selector.clone(), ButtonLike::new("active-model") @@ -2231,9 +2274,7 @@ impl TextThreadEditor { ) .child(Icon::new(icon).color(color).size(IconSize::XSmall)), ), - move |_window, cx| { - Tooltip::for_action_in("Change Model", &ToggleModelSelector, &focus_handle, cx) - }, + tooltip, gpui::Corner::BottomRight, cx, ) @@ -2593,6 +2634,11 @@ impl Render for TextThreadEditor { .on_action(move |_: &ToggleModelSelector, window, cx| { language_model_selector.toggle(window, cx); }) + .on_action(cx.listener(|this, _: &CycleFavoriteModels, window, cx| { + this.language_model_selector.update(cx, |selector, cx| { + selector.delegate.cycle_favorite_models(window, cx); + }); + })) .size_full() .child( div() diff --git a/crates/agent_ui/src/ui/model_selector_components.rs b/crates/agent_ui/src/ui/model_selector_components.rs index 184c8e0ba2d3ea307c869e42a13b75f36e713c42..061b4f58288798696b068a091fb392c033906627 100644 --- a/crates/agent_ui/src/ui/model_selector_components.rs +++ b/crates/agent_ui/src/ui/model_selector_components.rs @@ -113,13 +113,9 @@ impl RenderOnce for ModelSelectorListItem { .child(Label::new(self.title).truncate()), ) .end_slot(div().pr_2().when(self.is_selected, |this| { - this.child( - Icon::new(IconName::Check) - .color(Color::Accent) - .size(IconSize::Small), - ) + this.child(Icon::new(IconName::Check).color(Color::Accent)) })) - .end_hover_slot(div().pr_2().when_some(self.on_toggle_favorite, { + .end_hover_slot(div().pr_1p5().when_some(self.on_toggle_favorite, { |this, handle_click| { let (icon, color, tooltip) = if is_favorite { (IconName::StarFilled, Color::Accent, "Unfavorite Model") From eba811a127170a0fba4ebdf47bf52865ee5f5dc7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Torstein=20S=C3=B8rnes?= Date: Tue, 16 Dec 2025 22:44:39 +0100 Subject: [PATCH 085/266] Add support for MCP tools/list_changed notification (#42453) ## Summary This PR adds support for the MCP (Model Context Protocol) `notifications/tools/list_changed` notification, enabling dynamic tool discovery when MCP servers add, remove, or modify their available tools at runtime. ## Release Notes: - Improved: MCP tools are now automatically reloaded when a context server sends a `tools/list_changed` notification, eliminating the need to restart the server to discover new tools. ## Changes - Register a notification handler for `notifications/tools/list_changed` in `ContextServerRegistry` - Automatically reload tools when the notification is received - Handler is registered both on initial server startup and when a server transitions to `Running` status ## Motivation The MCP specification includes a `notifications/tools/list_changed` notification to inform clients when the list of available tools has changed. Previously, Zed's agent would only load tools once when a context server started. This meant that: 1. If an MCP server dynamically registered new tools after initialization, they would not be available to the agent 2. The only way to refresh tools was to restart the entire context server 3. Tools that were removed or modified would remain in the old state until restart ## Implementation Details The implementation follows these steps: 1. When a context server transitions to `Running` status, register a notification handler for `notifications/tools/list_changed` 2. The handler captures a weak reference to the `ContextServerRegistry` entity 3. When the notification is received, spawn a task that calls `reload_tools_for_server` with the server ID 4. The existing `reload_tools_for_server` method handles fetching the updated tool list and notifying observers This approach is minimal and reuses existing tool-loading infrastructure. ## Testing - [x] Code compiles with `./script/clippy -p agent` - The notification handler infrastructure already exists and is tested in the codebase - The `reload_tools_for_server` method is already tested and working ## Benefits - Improves developer experience by enabling hot-reloading of MCP tools - Aligns with the MCP specification's capability negotiation system - No breaking changes to existing functionality - Enables more flexible and dynamic MCP server implementations ## Related Issues This implements part of the MCP specification that was already defined in the type system but not wired up to actually handle the notifications. --------- Co-authored-by: Agus Zubiaga --- Cargo.lock | 1 + .../src/tools/context_server_registry.rs | 68 +++++++++--- crates/context_server/Cargo.toml | 1 + crates/context_server/src/client.rs | 103 +++++++++++++++--- crates/context_server/src/context_server.rs | 16 --- crates/context_server/src/protocol.rs | 6 +- 6 files changed, 148 insertions(+), 47 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6908a8ed5185ea71cc51a34d63990decaaf082d9..080a6a4cf4183fb5cade03ba36072b448ab4b70a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3623,6 +3623,7 @@ dependencies = [ "serde", "serde_json", "settings", + "slotmap", "smol", "tempfile", "terminal", diff --git a/crates/agent/src/tools/context_server_registry.rs b/crates/agent/src/tools/context_server_registry.rs index 735a47ae9fb99decbf97beb74a590f13f8f74878..3b01b2feb7dd36615a8ba7c63d81a81694e0d268 100644 --- a/crates/agent/src/tools/context_server_registry.rs +++ b/crates/agent/src/tools/context_server_registry.rs @@ -2,7 +2,7 @@ use crate::{AgentToolOutput, AnyAgentTool, ToolCallEventStream}; use agent_client_protocol::ToolKind; use anyhow::{Result, anyhow, bail}; use collections::{BTreeMap, HashMap}; -use context_server::ContextServerId; +use context_server::{ContextServerId, client::NotificationSubscription}; use gpui::{App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Task}; use project::context_server_store::{ContextServerStatus, ContextServerStore}; use std::sync::Arc; @@ -31,17 +31,7 @@ struct RegisteredContextServer { prompts: BTreeMap, load_tools: Task>, load_prompts: Task>, -} - -impl RegisteredContextServer { - fn new() -> Self { - Self { - tools: BTreeMap::default(), - prompts: BTreeMap::default(), - load_tools: Task::ready(Ok(())), - load_prompts: Task::ready(Ok(())), - } - } + _tools_updated_subscription: Option, } impl ContextServerRegistry { @@ -111,10 +101,57 @@ impl ContextServerRegistry { fn get_or_register_server( &mut self, server_id: &ContextServerId, + cx: &mut Context, ) -> &mut RegisteredContextServer { self.registered_servers .entry(server_id.clone()) - .or_insert_with(RegisteredContextServer::new) + .or_insert_with(|| Self::init_registered_server(server_id, &self.server_store, cx)) + } + + fn init_registered_server( + server_id: &ContextServerId, + server_store: &Entity, + cx: &mut Context, + ) -> RegisteredContextServer { + let tools_updated_subscription = server_store + .read(cx) + .get_running_server(server_id) + .and_then(|server| { + let client = server.client()?; + + if !client.capable(context_server::protocol::ServerCapability::Tools) { + return None; + } + + let server_id = server.id(); + let this = cx.entity().downgrade(); + + Some(client.on_notification( + "notifications/tools/list_changed", + Box::new(move |_params, cx: AsyncApp| { + let server_id = server_id.clone(); + let this = this.clone(); + cx.spawn(async move |cx| { + this.update(cx, |this, cx| { + log::info!( + "Received tools/list_changed notification for server {}", + server_id + ); + this.reload_tools_for_server(server_id, cx); + }) + }) + .detach(); + }), + )) + }); + + RegisteredContextServer { + tools: BTreeMap::default(), + prompts: BTreeMap::default(), + load_tools: Task::ready(Ok(())), + load_prompts: Task::ready(Ok(())), + _tools_updated_subscription: tools_updated_subscription, + } } fn reload_tools_for_server(&mut self, server_id: ContextServerId, cx: &mut Context) { @@ -124,11 +161,12 @@ impl ContextServerRegistry { let Some(client) = server.client() else { return; }; + if !client.capable(context_server::protocol::ServerCapability::Tools) { return; } - let registered_server = self.get_or_register_server(&server_id); + let registered_server = self.get_or_register_server(&server_id, cx); registered_server.load_tools = cx.spawn(async move |this, cx| { let response = client .request::(()) @@ -167,7 +205,7 @@ impl ContextServerRegistry { return; } - let registered_server = self.get_or_register_server(&server_id); + let registered_server = self.get_or_register_server(&server_id, cx); registered_server.load_prompts = cx.spawn(async move |this, cx| { let response = client diff --git a/crates/context_server/Cargo.toml b/crates/context_server/Cargo.toml index cb48b7e6f7d000ed7f2db7aaf3cfe4d6317fe278..539b873c3527b5a01f1dfcf7b768f0758dc869b5 100644 --- a/crates/context_server/Cargo.toml +++ b/crates/context_server/Cargo.toml @@ -29,6 +29,7 @@ schemars.workspace = true serde_json.workspace = true serde.workspace = true settings.workspace = true +slotmap.workspace = true smol.workspace = true tempfile.workspace = true url = { workspace = true, features = ["serde"] } diff --git a/crates/context_server/src/client.rs b/crates/context_server/src/client.rs index f891e96250f3334540aa859fe438c87297fc0100..605f24178916faa5173c32c28be6c80ee625cb6c 100644 --- a/crates/context_server/src/client.rs +++ b/crates/context_server/src/client.rs @@ -6,6 +6,7 @@ use parking_lot::Mutex; use postage::barrier; use serde::{Deserialize, Serialize, de::DeserializeOwned}; use serde_json::{Value, value::RawValue}; +use slotmap::SlotMap; use smol::channel; use std::{ fmt, @@ -50,7 +51,7 @@ pub(crate) struct Client { next_id: AtomicI32, outbound_tx: channel::Sender, name: Arc, - notification_handlers: Arc>>, + subscription_set: Arc>, response_handlers: Arc>>>, #[allow(clippy::type_complexity)] #[allow(dead_code)] @@ -191,21 +192,20 @@ impl Client { let (outbound_tx, outbound_rx) = channel::unbounded::(); let (output_done_tx, output_done_rx) = barrier::channel(); - let notification_handlers = - Arc::new(Mutex::new(HashMap::<_, NotificationHandler>::default())); + let subscription_set = Arc::new(Mutex::new(NotificationSubscriptionSet::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 subscription_set = subscription_set.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, + subscription_set, request_handlers, response_handlers, cx, @@ -236,7 +236,7 @@ impl Client { Ok(Self { server_id, - notification_handlers, + subscription_set, response_handlers, name: server_name, next_id: Default::default(), @@ -257,7 +257,7 @@ impl Client { /// to pending requests) and notifications (which trigger registered handlers). async fn handle_input( transport: Arc, - notification_handlers: Arc>>, + subscription_set: Arc>, request_handlers: Arc>>, response_handlers: Arc>>>, cx: &mut AsyncApp, @@ -282,10 +282,11 @@ impl Client { handler(Ok(message.to_string())); } } else if let Ok(notification) = serde_json::from_str::(&message) { - let mut notification_handlers = notification_handlers.lock(); - if let Some(handler) = notification_handlers.get_mut(notification.method.as_str()) { - handler(notification.params.unwrap_or(Value::Null), cx.clone()); - } + subscription_set.lock().notify( + ¬ification.method, + notification.params.unwrap_or(Value::Null), + cx, + ) } else { log::error!("Unhandled JSON from context_server: {}", message); } @@ -451,12 +452,18 @@ impl Client { Ok(()) } + #[must_use] pub fn on_notification( &self, method: &'static str, f: Box, - ) { - self.notification_handlers.lock().insert(method, f); + ) -> NotificationSubscription { + let mut notification_subscriptions = self.subscription_set.lock(); + + NotificationSubscription { + id: notification_subscriptions.add_handler(method, f), + set: self.subscription_set.clone(), + } } } @@ -485,3 +492,73 @@ impl fmt::Debug for Client { .finish_non_exhaustive() } } + +slotmap::new_key_type! { + struct NotificationSubscriptionId; +} + +#[derive(Default)] +pub struct NotificationSubscriptionSet { + // we have very few subscriptions at the moment + methods: Vec<(&'static str, Vec)>, + handlers: SlotMap, +} + +impl NotificationSubscriptionSet { + #[must_use] + fn add_handler( + &mut self, + method: &'static str, + handler: NotificationHandler, + ) -> NotificationSubscriptionId { + let id = self.handlers.insert(handler); + if let Some((_, handler_ids)) = self + .methods + .iter_mut() + .find(|(probe_method, _)| method == *probe_method) + { + debug_assert!( + handler_ids.len() < 20, + "Too many MCP handlers for {}. Consider using a different data structure.", + method + ); + + handler_ids.push(id); + } else { + self.methods.push((method, vec![id])); + }; + id + } + + fn notify(&mut self, method: &str, payload: Value, cx: &mut AsyncApp) { + let Some((_, handler_ids)) = self + .methods + .iter_mut() + .find(|(probe_method, _)| method == *probe_method) + else { + return; + }; + + for handler_id in handler_ids { + if let Some(handler) = self.handlers.get_mut(*handler_id) { + handler(payload.clone(), cx.clone()); + } + } + } +} + +pub struct NotificationSubscription { + id: NotificationSubscriptionId, + set: Arc>, +} + +impl Drop for NotificationSubscription { + fn drop(&mut self) { + let mut set = self.set.lock(); + set.handlers.remove(self.id); + set.methods.retain_mut(|(_, handler_ids)| { + handler_ids.retain(|id| *id != self.id); + !handler_ids.is_empty() + }); + } +} diff --git a/crates/context_server/src/context_server.rs b/crates/context_server/src/context_server.rs index 553e845df87a2fec30b1afbffa05b970d5d672f6..92804549c69b01dd3729efb3a0b47905cd73d813 100644 --- a/crates/context_server/src/context_server.rs +++ b/crates/context_server/src/context_server.rs @@ -96,22 +96,6 @@ impl ContextServer { self.initialize(self.new_client(cx)?).await } - /// Starts the context server, making sure handlers are registered before initialization happens - pub async fn start_with_handlers( - &self, - notification_handlers: Vec<( - &'static str, - Box, - )>, - cx: &AsyncApp, - ) -> Result<()> { - let client = self.new_client(cx)?; - for (method, handler) in notification_handlers { - client.on_notification(method, handler); - } - self.initialize(client).await - } - fn new_client(&self, cx: &AsyncApp) -> Result { Ok(match &self.configuration { ContextServerTransport::Stdio(command, working_directory) => Client::stdio( diff --git a/crates/context_server/src/protocol.rs b/crates/context_server/src/protocol.rs index 5355f20f620b5bed76bf945e863fdb5cbcc2ff43..a218a8a3e0e6352997e4152214077cb3851317b3 100644 --- a/crates/context_server/src/protocol.rs +++ b/crates/context_server/src/protocol.rs @@ -12,7 +12,7 @@ use futures::channel::oneshot; use gpui::AsyncApp; use serde_json::Value; -use crate::client::Client; +use crate::client::{Client, NotificationSubscription}; use crate::types::{self, Notification, Request}; pub struct ModelContextProtocol { @@ -119,7 +119,7 @@ impl InitializedContextServerProtocol { &self, method: &'static str, f: Box, - ) { - self.inner.on_notification(method, f); + ) -> NotificationSubscription { + self.inner.on_notification(method, f) } } From 78cd106b6453e5893728698c4bb5555af82f15ca Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Tue, 16 Dec 2025 18:47:56 -0300 Subject: [PATCH 086/266] inline assistant: Add some slight touch ups to the rating UI (#45034) Just touching up the tooltip casing, colors, and a bit of spacing. Also added the keybiniding to close the assistant. Maybe it was obvious already but I don't think it hurts. Release Notes: - N/A --- crates/agent_ui/src/inline_prompt_editor.rs | 86 ++++++++++++++++----- 1 file changed, 65 insertions(+), 21 deletions(-) diff --git a/crates/agent_ui/src/inline_prompt_editor.rs b/crates/agent_ui/src/inline_prompt_editor.rs index 51e65447b2f888ab70f5942baca108134b239593..517f8f08a6e7e9e31b2f88d1f5ee9444202009d5 100644 --- a/crates/agent_ui/src/inline_prompt_editor.rs +++ b/crates/agent_ui/src/inline_prompt_editor.rs @@ -844,26 +844,59 @@ impl PromptEditor { if show_rating_buttons { buttons.push( - IconButton::new("thumbs-down", IconName::ThumbsDown) - .icon_color(if rated { Color::Muted } else { Color::Default }) - .shape(IconButtonShape::Square) - .disabled(rated) - .tooltip(Tooltip::text("Bad result")) - .on_click(cx.listener(|this, _, window, cx| { - this.thumbs_down(&ThumbsDownResult, window, cx); - })) - .into_any_element(), - ); - - buttons.push( - IconButton::new("thumbs-up", IconName::ThumbsUp) - .icon_color(if rated { Color::Muted } else { Color::Default }) - .shape(IconButtonShape::Square) - .disabled(rated) - .tooltip(Tooltip::text("Good result")) - .on_click(cx.listener(|this, _, window, cx| { - this.thumbs_up(&ThumbsUpResult, window, cx); - })) + h_flex() + .pl_1() + .gap_1() + .border_l_1() + .border_color(cx.theme().colors().border_variant) + .child( + IconButton::new("thumbs-up", IconName::ThumbsUp) + .shape(IconButtonShape::Square) + .map(|this| { + if rated { + this.disabled(true) + .icon_color(Color::Ignored) + .tooltip(move |_, cx| { + Tooltip::with_meta( + "Good Result", + None, + "You already rated this result", + cx, + ) + }) + } else { + this.icon_color(Color::Muted) + .tooltip(Tooltip::text("Good Result")) + } + }) + .on_click(cx.listener(|this, _, window, cx| { + this.thumbs_up(&ThumbsUpResult, window, cx); + })), + ) + .child( + IconButton::new("thumbs-down", IconName::ThumbsDown) + .shape(IconButtonShape::Square) + .map(|this| { + if rated { + this.disabled(true) + .icon_color(Color::Ignored) + .tooltip(move |_, cx| { + Tooltip::with_meta( + "Bad Result", + None, + "You already rated this result", + cx, + ) + }) + } else { + this.icon_color(Color::Muted) + .tooltip(Tooltip::text("Bad Result")) + } + }) + .on_click(cx.listener(|this, _, window, cx| { + this.thumbs_down(&ThumbsDownResult, window, cx); + })), + ) .into_any_element(), ); } @@ -927,10 +960,21 @@ impl PromptEditor { } fn render_close_button(&self, cx: &mut Context) -> AnyElement { + let focus_handle = self.editor.focus_handle(cx); + IconButton::new("cancel", IconName::Close) .icon_color(Color::Muted) .shape(IconButtonShape::Square) - .tooltip(Tooltip::text("Close Assistant")) + .tooltip({ + move |_window, cx| { + Tooltip::for_action_in( + "Close Assistant", + &editor::actions::Cancel, + &focus_handle, + cx, + ) + } + }) .on_click(cx.listener(|_, _, _, cx| cx.emit(PromptEditorEvent::CancelRequested))) .into_any_element() } From ab4cd95e9c05fa786dc36934b683995e13c4a99f Mon Sep 17 00:00:00 2001 From: Remco Smits Date: Tue, 16 Dec 2025 22:53:30 +0100 Subject: [PATCH 087/266] git_ui: Fix select next/previous entry selects non-visible entry when tree view is enabled (#45030) Before this commit, we would select a non-visible entry when a directory is collapsed. Now we correctly select the visible entry that is visually the previous/next entry in the list. **Note**: I removed the `cx.notify()` call as it's already part of the `self.scroll_to_selected_entry(cx)` call. So we don't notify twice :). Follow-up: https://github.com/zed-industries/zed/pull/45002 **Before** https://github.com/user-attachments/assets/da0b8084-0081-4d98-ad8a-c11c3b95a1b7 **After** https://github.com/user-attachments/assets/8a16afb0-fdde-4317-b419-13143d5d608e Release Notes: - git_ui: Fix select next/previous entry selects non-visible entry when tree view is enabled --- crates/git_ui/src/git_panel.rs | 91 ++++++++++++++++++++++------------ 1 file changed, 59 insertions(+), 32 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 390f5cf2c28bfc0ff1aef5226e125d08db37dd68..37926eae5db12c83ab69613a09c4eceda1f5ffeb 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -961,28 +961,44 @@ impl GitPanel { return; } - if let Some(selected_entry) = self.selected_entry { - let new_selected_entry = if selected_entry > 0 { - selected_entry - 1 - } else { - selected_entry - }; + let Some(selected_entry) = self.selected_entry else { + return; + }; - if matches!( - self.entries.get(new_selected_entry), - Some(GitListEntry::Header(..)) - ) { - if new_selected_entry > 0 { - self.selected_entry = Some(new_selected_entry - 1) - } - } else { - self.selected_entry = Some(new_selected_entry); + let new_index = match &self.view_mode { + GitPanelViewMode::Flat => selected_entry.saturating_sub(1), + GitPanelViewMode::Tree(state) => { + let Some(current_logical_index) = state + .logical_indices + .iter() + .position(|&i| i == selected_entry) + else { + return; + }; + + state.logical_indices[current_logical_index.saturating_sub(1)] } + }; - self.scroll_to_selected_entry(cx); + if selected_entry == 0 && new_index == 0 { + return; } - cx.notify(); + if matches!( + self.entries.get(new_index.saturating_sub(1)), + Some(GitListEntry::Header(..)) + ) && new_index == 0 + { + return; + } + + if matches!(self.entries.get(new_index), Some(GitListEntry::Header(..))) { + self.selected_entry = Some(new_index.saturating_sub(1)); + } else { + self.selected_entry = Some(new_index); + } + + self.scroll_to_selected_entry(cx); } fn select_next(&mut self, _: &SelectNext, _window: &mut Window, cx: &mut Context) { @@ -991,25 +1007,36 @@ impl GitPanel { return; } - if let Some(selected_entry) = self.selected_entry { - let new_selected_entry = if selected_entry < item_count - 1 { - selected_entry + 1 - } else { - selected_entry - }; - if matches!( - self.entries.get(new_selected_entry), - Some(GitListEntry::Header(..)) - ) { - self.selected_entry = Some(new_selected_entry + 1); - } else { - self.selected_entry = Some(new_selected_entry); + let Some(selected_entry) = self.selected_entry else { + return; + }; + + if selected_entry == item_count - 1 { + return; + } + + let new_index = match &self.view_mode { + GitPanelViewMode::Flat => selected_entry.saturating_add(1), + GitPanelViewMode::Tree(state) => { + let Some(current_logical_index) = state + .logical_indices + .iter() + .position(|&i| i == selected_entry) + else { + return; + }; + + state.logical_indices[current_logical_index.saturating_add(1)] } + }; - self.scroll_to_selected_entry(cx); + if matches!(self.entries.get(new_index), Some(GitListEntry::Header(..))) { + self.selected_entry = Some(new_index.saturating_add(1)); + } else { + self.selected_entry = Some(new_index); } - cx.notify(); + self.scroll_to_selected_entry(cx); } fn select_last(&mut self, _: &SelectLast, _window: &mut Window, cx: &mut Context) { From 3a013d8090e1a96461c66c6688ddd6e51bd5f896 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Tue, 16 Dec 2025 17:03:30 -0500 Subject: [PATCH 088/266] gpui: Add `is_action_available_in` function (#45029) This compliments the `window.is_action_available` function that already exists. Release Notes: - N/A --- crates/gpui/src/window.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index 36e46f6961ae8a1e8581b3c01987f4641377d677..c606409661eb022b8627fe9bc9f6c53565f5569f 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -1961,7 +1961,7 @@ impl Window { } /// Determine whether the given action is available along the dispatch path to the currently focused element. - pub fn is_action_available(&self, action: &dyn Action, cx: &mut App) -> bool { + pub fn is_action_available(&self, action: &dyn Action, cx: &App) -> bool { let node_id = self.focus_node_id_in_rendered_frame(self.focused(cx).map(|handle| handle.id)); self.rendered_frame @@ -1969,6 +1969,14 @@ impl Window { .is_action_available(action, node_id) } + /// Determine whether the given action is available along the dispatch path to the given focus_handle. + pub fn is_action_available_in(&self, action: &dyn Action, focus_handle: &FocusHandle) -> bool { + let node_id = self.focus_node_id_in_rendered_frame(Some(focus_handle.id)); + self.rendered_frame + .dispatch_tree + .is_action_available(action, node_id) + } + /// The position of the mouse relative to the window. pub fn mouse_position(&self) -> Point { self.mouse_position From 28868068098d4c761465624fe8d0cd331710aea8 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Tue, 16 Dec 2025 17:51:33 -0500 Subject: [PATCH 089/266] Display all branches and remotes by default in the branch picker (#45041) This both matches VS Code's branch picker and makes the "Filter Remotes" button make more sense. SCR-20251216-pgkv SCR-20251216-pgqp Release Notes: - Display all branches and remotes by default in the branch picker --- crates/git_ui/src/branch_picker.rs | 143 +++++++++++++++++------------ 1 file changed, 82 insertions(+), 61 deletions(-) diff --git a/crates/git_ui/src/branch_picker.rs b/crates/git_ui/src/branch_picker.rs index 79cd89d1485f6d99349b43d92c17261cf8a644e2..c7cf72cdbd880bbd0bca7611474b42a3a600cc48 100644 --- a/crates/git_ui/src/branch_picker.rs +++ b/crates/git_ui/src/branch_picker.rs @@ -316,17 +316,17 @@ impl Entry { #[derive(Clone, Copy, PartialEq)] enum BranchFilter { - /// Only show local branches - Local, - /// Only show remote branches + /// Show both local and remote branches. + All, + /// Only show remote branches. Remote, } impl BranchFilter { fn invert(&self) -> Self { match self { - BranchFilter::Local => BranchFilter::Remote, - BranchFilter::Remote => BranchFilter::Local, + BranchFilter::All => BranchFilter::Remote, + BranchFilter::Remote => BranchFilter::All, } } } @@ -375,7 +375,7 @@ impl BranchListDelegate { selected_index: 0, last_query: Default::default(), modifiers: Default::default(), - branch_filter: BranchFilter::Local, + branch_filter: BranchFilter::All, state: PickerState::List, focus_handle: cx.focus_handle(), } @@ -518,7 +518,7 @@ impl PickerDelegate for BranchListDelegate { match self.state { PickerState::List | PickerState::NewRemote | PickerState::NewBranch => { match self.branch_filter { - BranchFilter::Local => "Select branch…", + BranchFilter::All => "Select branch or remote…", BranchFilter::Remote => "Select remote…", } } @@ -560,8 +560,8 @@ impl PickerDelegate for BranchListDelegate { self.editor_position() == PickerEditorPosition::End, |this| { let tooltip_label = match self.branch_filter { - BranchFilter::Local => "Turn Off Remote Filter", - BranchFilter::Remote => "Filter Remote Branches", + BranchFilter::All => "Filter Remote Branches", + BranchFilter::Remote => "Show All Branches", }; this.gap_1().justify_between().child({ @@ -625,40 +625,38 @@ impl PickerDelegate for BranchListDelegate { return Task::ready(()); }; - let display_remotes = self.branch_filter; + let branch_filter = self.branch_filter; cx.spawn_in(window, async move |picker, cx| { + let branch_matches_filter = |branch: &Branch| match branch_filter { + BranchFilter::All => true, + BranchFilter::Remote => branch.is_remote(), + }; + let mut matches: Vec = if query.is_empty() { - all_branches + let mut matches: Vec = all_branches .into_iter() - .filter(|branch| { - if display_remotes == BranchFilter::Remote { - branch.is_remote() - } else { - !branch.is_remote() - } - }) + .filter(|branch| branch_matches_filter(branch)) .map(|branch| Entry::Branch { branch, positions: Vec::new(), }) - .collect() + .collect(); + + // Keep the existing recency sort within each group, but show local branches first. + matches.sort_by_key(|entry| entry.as_branch().is_some_and(|b| b.is_remote())); + + matches } else { let branches = all_branches .iter() - .filter(|branch| { - if display_remotes == BranchFilter::Remote { - branch.is_remote() - } else { - !branch.is_remote() - } - }) + .filter(|branch| branch_matches_filter(branch)) .collect::>(); let candidates = branches .iter() .enumerate() .map(|(ix, branch)| StringMatchCandidate::new(ix, branch.name())) .collect::>(); - fuzzy::match_strings( + let mut matches: Vec = fuzzy::match_strings( &candidates, &query, true, @@ -673,7 +671,12 @@ impl PickerDelegate for BranchListDelegate { branch: branches[candidate.candidate_id].clone(), positions: candidate.positions, }) - .collect() + .collect(); + + // Keep fuzzy-relevance ordering within local/remote groups, but show locals first. + matches.sort_by_key(|entry| entry.as_branch().is_some_and(|b| b.is_remote())); + + matches }; picker .update(cx, |picker, _| { @@ -841,10 +844,13 @@ impl PickerDelegate for BranchListDelegate { Entry::NewUrl { .. } | Entry::NewBranch { .. } | Entry::NewRemoteName { .. } => { Icon::new(IconName::Plus).color(Color::Muted) } - Entry::Branch { .. } => match self.branch_filter { - BranchFilter::Local => Icon::new(IconName::GitBranchAlt).color(Color::Muted), - BranchFilter::Remote => Icon::new(IconName::Screen).color(Color::Muted), - }, + Entry::Branch { branch, .. } => { + if branch.is_remote() { + Icon::new(IconName::Screen).color(Color::Muted) + } else { + Icon::new(IconName::GitBranchAlt).color(Color::Muted) + } + } }; let entry_title = match entry { @@ -1036,8 +1042,8 @@ impl PickerDelegate for BranchListDelegate { ) -> Option { matches!(self.state, PickerState::List).then(|| { let label = match self.branch_filter { - BranchFilter::Local => "Local", - BranchFilter::Remote => "Remote", + BranchFilter::All => "Branches", + BranchFilter::Remote => "Remotes", }; ListHeader::new(label).inset(true).into_any_element() @@ -1532,7 +1538,7 @@ mod tests { } #[gpui::test] - async fn test_update_remote_matches_with_query(cx: &mut TestAppContext) { + async fn test_branch_filter_shows_all_then_remotes_and_applies_query(cx: &mut TestAppContext) { init_test(cx); let branches = vec![ @@ -1547,34 +1553,49 @@ mod tests { update_branch_list_matches_with_empty_query(&branch_list, cx).await; - // Check matches, it should match all existing branches and no option to create new branch - branch_list - .update_in(cx, |branch_list, window, cx| { - branch_list.picker.update(cx, |picker, cx| { - assert_eq!(picker.delegate.matches.len(), 2); - let branches = picker - .delegate - .matches - .iter() - .map(|be| be.name()) - .collect::>(); - assert_eq!( - branches, - ["feature-ui", "develop"] - .into_iter() - .collect::>() - ); + branch_list.update(cx, |branch_list, cx| { + branch_list.picker.update(cx, |picker, _cx| { + assert_eq!(picker.delegate.matches.len(), 4); - // Verify the last entry is NOT the "create new branch" option - let last_match = picker.delegate.matches.last().unwrap(); - assert!(!last_match.is_new_branch()); - assert!(!last_match.is_new_url()); - picker.delegate.branch_filter = BranchFilter::Remote; - picker.delegate.update_matches(String::new(), window, cx) - }) + let branches = picker + .delegate + .matches + .iter() + .map(|be| be.name()) + .collect::>(); + assert_eq!( + branches, + ["origin/main", "fork/feature-auth", "feature-ui", "develop"] + .into_iter() + .collect::>() + ); + + // Locals should be listed before remotes. + let ordered = picker + .delegate + .matches + .iter() + .map(|be| be.name()) + .collect::>(); + assert_eq!( + ordered, + vec!["feature-ui", "develop", "origin/main", "fork/feature-auth"] + ); + + // Verify the last entry is NOT the "create new branch" option + let last_match = picker.delegate.matches.last().unwrap(); + assert!(!last_match.is_new_branch()); + assert!(!last_match.is_new_url()); }) - .await; - cx.run_until_parked(); + }); + + branch_list.update(cx, |branch_list, cx| { + branch_list.picker.update(cx, |picker, _cx| { + picker.delegate.branch_filter = BranchFilter::Remote; + }) + }); + + update_branch_list_matches_with_empty_query(&branch_list, cx).await; branch_list .update_in(cx, |branch_list, window, cx| { From bd20339f82c9c8f8b2d6d96d5c928ebc535b1295 Mon Sep 17 00:00:00 2001 From: Michael Benfield Date: Tue, 16 Dec 2025 15:30:36 -0800 Subject: [PATCH 090/266] Don't apply StripInvalidSpans for tool using inline assistant (#45040) It can occasionally mutilate the text when used with the tool format. Release Notes: - N/A --- crates/agent_ui/src/buffer_codegen.rs | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/crates/agent_ui/src/buffer_codegen.rs b/crates/agent_ui/src/buffer_codegen.rs index 25395278745a9eb18fbbfa1cd920af3e3b26e24d..87ce6d386b38f31a0d7b550aab00bb766ce75010 100644 --- a/crates/agent_ui/src/buffer_codegen.rs +++ b/crates/agent_ui/src/buffer_codegen.rs @@ -441,7 +441,8 @@ impl CodegenAlternative { }) .boxed_local() }; - self.generation = self.handle_stream(model, stream, cx); + self.generation = + self.handle_stream(model, /* strip_invalid_spans: */ true, stream, cx); } Ok(()) @@ -629,6 +630,7 @@ impl CodegenAlternative { pub fn handle_stream( &mut self, model: Arc, + strip_invalid_spans: bool, stream: impl 'static + Future>, cx: &mut Context, ) -> Task<()> { @@ -713,10 +715,16 @@ impl CodegenAlternative { let mut response_latency = None; let request_start = Instant::now(); let diff = async { - let chunks = StripInvalidSpans::new( - stream?.stream.map_err(|error| error.into()), - ); - futures::pin_mut!(chunks); + let raw_stream = stream?.stream.map_err(|error| error.into()); + + let stripped; + let mut chunks: Pin> + Send>> = + if strip_invalid_spans { + stripped = StripInvalidSpans::new(raw_stream); + Box::pin(stripped) + } else { + Box::pin(raw_stream) + }; let mut diff = StreamingDiff::new(selected_text.to_string()); let mut line_diff = LineDiff::default(); @@ -1307,7 +1315,12 @@ impl CodegenAlternative { let Some(task) = codegen .update(cx, move |codegen, cx| { - codegen.handle_stream(model, async { Ok(language_model_text_stream) }, cx) + codegen.handle_stream( + model, + /* strip_invalid_spans: */ false, + async { Ok(language_model_text_stream) }, + cx, + ) }) .ok() else { @@ -1846,6 +1859,7 @@ mod tests { codegen.update(cx, |codegen, cx| { codegen.generation = codegen.handle_stream( model, + /* strip_invalid_spans: */ false, future::ready(Ok(LanguageModelTextStream { message_id: None, stream: chunks_rx.map(Ok).boxed(), From 83de583fb1f8f0b6f1670494eec697171cf6f335 Mon Sep 17 00:00:00 2001 From: AidanV <84053180+AidanV@users.noreply.github.com> Date: Tue, 16 Dec 2025 18:57:26 -0500 Subject: [PATCH 091/266] nix: Resolve 'hostPlatform' rename warning in dev shell (#45045) This PR fixes the warning from entering the nix development shell: ``` evaluation warning: 'hostPlatform' has been renamed to/replaced by 'stdenv.hostPlatform' ``` Decided to go with `zed-editor = mkZed pkgs;` instead of `zed-editor = packages.${pkgs.stdenv.hostPlatform.system}.default;`, because it is simpler and with my understanding it is logically equivalent (i.e. we are getting `packages..default` which we can see in the definition of packages is equal to `mkZed pkgs;`). Release Notes: - N/A --- flake.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/flake.nix b/flake.nix index fe7a09701beb714506742f2712cb3a74b676bc19..744ca708a3a2104f0050cd85e8ee05f04e49a713 100644 --- a/flake.nix +++ b/flake.nix @@ -37,14 +37,14 @@ rustToolchain = rustBin.fromRustupToolchainFile ./rust-toolchain.toml; }; in - rec { + { packages = forAllSystems (pkgs: rec { default = mkZed pkgs; debug = default.override { profile = "dev"; }; }); devShells = forAllSystems (pkgs: { default = pkgs.callPackage ./nix/shell.nix { - zed-editor = packages.${pkgs.hostPlatform.system}.default; + zed-editor = mkZed pkgs; }; }); formatter = forAllSystems (pkgs: pkgs.nixfmt-rfc-style); From af3902a33f86d6d7d030a1167f6151912a697c11 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Wed, 17 Dec 2025 01:59:34 +0200 Subject: [PATCH 092/266] Move DB away from the project (#45036) Follow-up of https://github.com/zed-industries/zed/pull/44887 This fixes remote server builds. Additionally: * slightly rewords workspace trust text in the security modal * eagerly ask for worktree trust on open Release Notes: - N/A --- .../remote_editing_collaboration_tests.rs | 2 + crates/editor/src/editor_tests.rs | 1 + crates/project/Cargo.toml | 1 - crates/project/src/persistence.rs | 355 +----------------- crates/project/src/project.rs | 1 - crates/project/src/trusted_worktrees.rs | 159 +++----- crates/remote_server/src/unix.rs | 3 +- crates/workspace/src/persistence.rs | 158 +++++++- crates/workspace/src/security_modal.rs | 6 +- crates/workspace/src/workspace.rs | 90 ++++- crates/zed/src/main.rs | 9 +- 11 files changed, 295 insertions(+), 490 deletions(-) diff --git a/crates/collab/src/tests/remote_editing_collaboration_tests.rs b/crates/collab/src/tests/remote_editing_collaboration_tests.rs index a66d7a1856c195a41a495123b468dc2b6ac8a1ca..5342b0bbd4b11afb24ccbaa6d4bf17df036cec76 100644 --- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs +++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs @@ -859,9 +859,11 @@ async fn test_ssh_remote_worktree_trust(cx_a: &mut TestAppContext, server_cx: &m cx_a.update(|cx| { release_channel::init(semver::Version::new(0, 0, 0), cx); + project::trusted_worktrees::init(HashMap::default(), None, None, cx); }); server_cx.update(|cx| { release_channel::init(semver::Version::new(0, 0, 0), cx); + project::trusted_worktrees::init(HashMap::default(), None, None, cx); }); let mut server = TestServer::start(cx_a.executor().clone()).await; diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index f379b2b4e014ae7f51b5d8ffd842112dba54279b..84d3837d1cb516b6f70f6998ce588beed9bd9804 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -29370,6 +29370,7 @@ async fn test_find_references_single_case(cx: &mut TestAppContext) { #[gpui::test] async fn test_local_worktree_trust(cx: &mut TestAppContext) { init_test(cx, |_| {}); + cx.update(|cx| project::trusted_worktrees::init(HashMap::default(), None, None, cx)); cx.update(|cx| { SettingsStore::update_global(cx, |store, cx| { diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml index b589af2d50c77b68da6d94334904505f104b37e8..f39c368218511b6ddf560dda1198ef5c06bd0a2e 100644 --- a/crates/project/Cargo.toml +++ b/crates/project/Cargo.toml @@ -40,7 +40,6 @@ clock.workspace = true collections.workspace = true context_server.workspace = true dap.workspace = true -db.workspace = true extension.workspace = true fancy-regex.workspace = true fs.workspace = true diff --git a/crates/project/src/persistence.rs b/crates/project/src/persistence.rs index be844c58384aa001fdbffa5fbac5dc513e98c535..5c4e664bdeba02a317da0610cf857e948bd5c93e 100644 --- a/crates/project/src/persistence.rs +++ b/crates/project/src/persistence.rs @@ -37,143 +37,7 @@ impl Domain for ProjectDb { db::static_connection!(PROJECT_DB, ProjectDb, []); -impl ProjectDb { - pub(crate) async fn save_trusted_worktrees( - &self, - trusted_worktrees: HashMap, HashSet>, - trusted_workspaces: HashSet>, - ) -> anyhow::Result<()> { - use anyhow::Context as _; - use db::sqlez::statement::Statement; - use itertools::Itertools as _; - - PROJECT_DB - .clear_trusted_worktrees() - .await - .context("clearing previous trust state")?; - - let trusted_worktrees = trusted_worktrees - .into_iter() - .flat_map(|(host, abs_paths)| { - abs_paths - .into_iter() - .map(move |abs_path| (Some(abs_path), host.clone())) - }) - .chain(trusted_workspaces.into_iter().map(|host| (None, host))) - .collect::>(); - let mut first_worktree; - let mut last_worktree = 0_usize; - for (count, placeholders) in std::iter::once("(?, ?, ?)") - .cycle() - .take(trusted_worktrees.len()) - .chunks(MAX_QUERY_PLACEHOLDERS / 3) - .into_iter() - .map(|chunk| { - let mut count = 0; - let placeholders = chunk - .inspect(|_| { - count += 1; - }) - .join(", "); - (count, placeholders) - }) - .collect::>() - { - first_worktree = last_worktree; - last_worktree = last_worktree + count; - let query = format!( - r#"INSERT INTO trusted_worktrees(absolute_path, user_name, host_name) -VALUES {placeholders};"# - ); - - let trusted_worktrees = trusted_worktrees[first_worktree..last_worktree].to_vec(); - self.write(move |conn| { - let mut statement = Statement::prepare(conn, query)?; - let mut next_index = 1; - for (abs_path, host) in trusted_worktrees { - let abs_path = abs_path.as_ref().map(|abs_path| abs_path.to_string_lossy()); - next_index = statement.bind( - &abs_path.as_ref().map(|abs_path| abs_path.as_ref()), - next_index, - )?; - next_index = statement.bind( - &host - .as_ref() - .and_then(|host| Some(host.user_name.as_ref()?.as_str())), - next_index, - )?; - next_index = statement.bind( - &host.as_ref().map(|host| host.host_identifier.as_str()), - next_index, - )?; - } - statement.exec() - }) - .await - .context("inserting new trusted state")?; - } - Ok(()) - } - - pub(crate) fn fetch_trusted_worktrees( - &self, - worktree_store: Option>, - host: Option, - cx: &App, - ) -> anyhow::Result, HashSet>> { - let trusted_worktrees = PROJECT_DB.trusted_worktrees()?; - Ok(trusted_worktrees - .into_iter() - .map(|(abs_path, user_name, host_name)| { - let db_host = match (user_name, host_name) { - (_, None) => None, - (None, Some(host_name)) => Some(RemoteHostLocation { - user_name: None, - host_identifier: SharedString::new(host_name), - }), - (Some(user_name), Some(host_name)) => Some(RemoteHostLocation { - user_name: Some(SharedString::new(user_name)), - host_identifier: SharedString::new(host_name), - }), - }; - - match abs_path { - Some(abs_path) => { - if db_host != host { - (db_host, PathTrust::AbsPath(abs_path)) - } else if let Some(worktree_store) = &worktree_store { - find_worktree_in_store(worktree_store.read(cx), &abs_path, cx) - .map(PathTrust::Worktree) - .map(|trusted_worktree| (host.clone(), trusted_worktree)) - .unwrap_or_else(|| (db_host.clone(), PathTrust::AbsPath(abs_path))) - } else { - (db_host, PathTrust::AbsPath(abs_path)) - } - } - None => (db_host, PathTrust::Workspace), - } - }) - .fold(HashMap::default(), |mut acc, (remote_host, path_trust)| { - acc.entry(remote_host) - .or_insert_with(HashSet::default) - .insert(path_trust); - acc - })) - } - - query! { - fn trusted_worktrees() -> Result, Option, Option)>> { - SELECT absolute_path, user_name, host_name - FROM trusted_worktrees - } - } - - query! { - pub async fn clear_trusted_worktrees() -> Result<()> { - DELETE FROM trusted_worktrees - } - } -} +impl ProjectDb {} #[cfg(test)] mod tests { @@ -192,220 +56,5 @@ mod tests { trusted_worktrees::{PathTrust, RemoteHostLocation}, }; - static TEST_LOCK: Mutex<()> = Mutex::new(()); - - #[gpui::test] - async fn test_save_and_fetch_trusted_worktrees(cx: &mut TestAppContext) { - cx.executor().allow_parking(); - let _guard = TEST_LOCK.lock().await; - PROJECT_DB.clear_trusted_worktrees().await.unwrap(); - cx.update(|cx| { - if cx.try_global::().is_none() { - let settings = SettingsStore::test(cx); - cx.set_global(settings); - } - }); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree( - path!("/"), - json!({ - "project_a": { "main.rs": "" }, - "project_b": { "lib.rs": "" } - }), - ) - .await; - - let project = Project::test( - fs, - [path!("/project_a").as_ref(), path!("/project_b").as_ref()], - cx, - ) - .await; - let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); - - let mut trusted_paths: HashMap, HashSet> = - HashMap::default(); - trusted_paths.insert( - None, - HashSet::from_iter([ - PathBuf::from(path!("/project_a")), - PathBuf::from(path!("/project_b")), - ]), - ); - - PROJECT_DB - .save_trusted_worktrees(trusted_paths, HashSet::default()) - .await - .unwrap(); - - let fetched = cx.update(|cx| { - PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) - }); - let fetched = fetched.unwrap(); - - let local_trust = fetched.get(&None).expect("should have local host entry"); - assert_eq!(local_trust.len(), 2); - assert!( - local_trust - .iter() - .all(|p| matches!(p, PathTrust::Worktree(_))) - ); - - let fetched_no_store = cx - .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) - .unwrap(); - let local_trust_no_store = fetched_no_store - .get(&None) - .expect("should have local host entry"); - assert_eq!(local_trust_no_store.len(), 2); - assert!( - local_trust_no_store - .iter() - .all(|p| matches!(p, PathTrust::AbsPath(_))) - ); - } - - #[gpui::test] - async fn test_save_and_fetch_workspace_trust(cx: &mut TestAppContext) { - cx.executor().allow_parking(); - let _guard = TEST_LOCK.lock().await; - PROJECT_DB.clear_trusted_worktrees().await.unwrap(); - cx.update(|cx| { - if cx.try_global::().is_none() { - let settings = SettingsStore::test(cx); - cx.set_global(settings); - } - }); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); - - let trusted_workspaces = HashSet::from_iter([None]); - PROJECT_DB - .save_trusted_worktrees(HashMap::default(), trusted_workspaces) - .await - .unwrap(); - - let fetched = cx.update(|cx| { - PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) - }); - let fetched = fetched.unwrap(); - - let local_trust = fetched.get(&None).expect("should have local host entry"); - assert!(local_trust.contains(&PathTrust::Workspace)); - - let fetched_no_store = cx - .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) - .unwrap(); - let local_trust_no_store = fetched_no_store - .get(&None) - .expect("should have local host entry"); - assert!(local_trust_no_store.contains(&PathTrust::Workspace)); - } - - #[gpui::test] - async fn test_save_and_fetch_remote_host_trust(cx: &mut TestAppContext) { - cx.executor().allow_parking(); - let _guard = TEST_LOCK.lock().await; - PROJECT_DB.clear_trusted_worktrees().await.unwrap(); - cx.update(|cx| { - if cx.try_global::().is_none() { - let settings = SettingsStore::test(cx); - cx.set_global(settings); - } - }); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); - - let remote_host = Some(RemoteHostLocation { - user_name: Some(SharedString::from("testuser")), - host_identifier: SharedString::from("remote.example.com"), - }); - - let mut trusted_paths: HashMap, HashSet> = - HashMap::default(); - trusted_paths.insert( - remote_host.clone(), - HashSet::from_iter([PathBuf::from("/home/testuser/project")]), - ); - - PROJECT_DB - .save_trusted_worktrees(trusted_paths, HashSet::default()) - .await - .unwrap(); - - let fetched = cx.update(|cx| { - PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) - }); - let fetched = fetched.unwrap(); - - let remote_trust = fetched - .get(&remote_host) - .expect("should have remote host entry"); - assert_eq!(remote_trust.len(), 1); - assert!(remote_trust - .iter() - .any(|p| matches!(p, PathTrust::AbsPath(path) if path == &PathBuf::from("/home/testuser/project")))); - - let fetched_no_store = cx - .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) - .unwrap(); - let remote_trust_no_store = fetched_no_store - .get(&remote_host) - .expect("should have remote host entry"); - assert_eq!(remote_trust_no_store.len(), 1); - assert!(remote_trust_no_store - .iter() - .any(|p| matches!(p, PathTrust::AbsPath(path) if path == &PathBuf::from("/home/testuser/project")))); - } - - #[gpui::test] - async fn test_clear_trusted_worktrees(cx: &mut TestAppContext) { - cx.executor().allow_parking(); - let _guard = TEST_LOCK.lock().await; - PROJECT_DB.clear_trusted_worktrees().await.unwrap(); - cx.update(|cx| { - if cx.try_global::().is_none() { - let settings = SettingsStore::test(cx); - cx.set_global(settings); - } - }); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |p, _| p.worktree_store()); - - let trusted_workspaces = HashSet::from_iter([None]); - PROJECT_DB - .save_trusted_worktrees(HashMap::default(), trusted_workspaces) - .await - .unwrap(); - - PROJECT_DB.clear_trusted_worktrees().await.unwrap(); - - let fetched = cx.update(|cx| { - PROJECT_DB.fetch_trusted_worktrees(Some(worktree_store.clone()), None, cx) - }); - let fetched = fetched.unwrap(); - - assert!(fetched.is_empty(), "should be empty after clear"); - - let fetched_no_store = cx - .update(|cx| PROJECT_DB.fetch_trusted_worktrees(None, None, cx)) - .unwrap(); - assert!(fetched_no_store.is_empty(), "should be empty after clear"); - } + static TEST_WORKTREE_TRUST_LOCK: Mutex<()> = Mutex::new(()); } diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 79d37f0e99f35f5c059a98017f5036e95e18bf01..bbf91eb3c18a53f32f48f1a044c991bf5cfd9fdf 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -10,7 +10,6 @@ pub mod image_store; pub mod lsp_command; pub mod lsp_store; mod manifest_tree; -mod persistence; pub mod prettier_store; mod project_search; pub mod project_settings; diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rs index 733e8d48294b863f8bf35cdb1ea458acd59dcadb..d9f5d4a7a43d8cb8b8220f4d3de8ca35d366a8f5 100644 --- a/crates/project/src/trusted_worktrees.rs +++ b/crates/project/src/trusted_worktrees.rs @@ -68,19 +68,21 @@ use util::debug_panic; use crate::{project_settings::ProjectSettings, worktree_store::WorktreeStore}; -#[cfg(not(any(test, feature = "test-support")))] -use crate::persistence::PROJECT_DB; -#[cfg(not(any(test, feature = "test-support")))] -use util::ResultExt as _; - pub fn init( + db_trusted_paths: TrustedPaths, downstream_client: Option<(AnyProtoClient, u64)>, upstream_client: Option<(AnyProtoClient, u64)>, cx: &mut App, ) { if TrustedWorktrees::try_get_global(cx).is_none() { - let trusted_worktrees = cx.new(|cx| { - TrustedWorktreesStore::new(None, None, downstream_client, upstream_client, cx) + let trusted_worktrees = cx.new(|_| { + TrustedWorktreesStore::new( + db_trusted_paths, + None, + None, + downstream_client, + upstream_client, + ) }); cx.set_global(TrustedWorktrees(trusted_worktrees)) } @@ -126,18 +128,7 @@ pub fn track_worktree_trust( } }); } - None => { - let trusted_worktrees = cx.new(|cx| { - TrustedWorktreesStore::new( - Some(worktree_store.clone()), - remote_host, - downstream_client, - upstream_client, - cx, - ) - }); - cx.set_global(TrustedWorktrees(trusted_worktrees)) - } + None => log::debug!("No TrustedWorktrees initialized, not tracking worktree trust"), } } @@ -212,9 +203,7 @@ pub struct TrustedWorktreesStore { downstream_client: Option<(AnyProtoClient, u64)>, upstream_client: Option<(AnyProtoClient, u64)>, worktree_stores: HashMap, Option>, - trusted_paths: HashMap, HashSet>, - #[cfg(not(any(test, feature = "test-support")))] - serialization_task: Task<()>, + trusted_paths: TrustedPaths, restricted: HashSet, remote_host: Option, restricted_workspaces: HashSet>, @@ -307,36 +296,16 @@ pub enum TrustedWorktreesEvent { impl EventEmitter for TrustedWorktreesStore {} +pub type TrustedPaths = HashMap, HashSet>; + impl TrustedWorktreesStore { fn new( + trusted_paths: TrustedPaths, worktree_store: Option>, remote_host: Option, downstream_client: Option<(AnyProtoClient, u64)>, upstream_client: Option<(AnyProtoClient, u64)>, - cx: &App, ) -> Self { - #[cfg(any(test, feature = "test-support"))] - let _ = cx; - - #[cfg(not(any(test, feature = "test-support")))] - let trusted_paths = if downstream_client.is_none() { - match PROJECT_DB.fetch_trusted_worktrees( - worktree_store.clone(), - remote_host.clone(), - cx, - ) { - Ok(trusted_paths) => trusted_paths, - Err(e) => { - log::error!("Failed to do initial trusted worktrees fetch: {e:#}"); - HashMap::default() - } - } - } else { - HashMap::default() - }; - #[cfg(any(test, feature = "test-support"))] - let trusted_paths = HashMap::, HashSet>::default(); - if let Some((upstream_client, upstream_project_id)) = &upstream_client { let trusted_paths = trusted_paths .iter() @@ -366,8 +335,6 @@ impl TrustedWorktreesStore { remote_host, restricted_workspaces: HashSet::default(), restricted: HashSet::default(), - #[cfg(not(any(test, feature = "test-support")))] - serialization_task: Task::ready(()), worktree_stores, } } @@ -496,41 +463,6 @@ impl TrustedWorktreesStore { trusted_paths.clone(), )); - #[cfg(not(any(test, feature = "test-support")))] - if self.downstream_client.is_none() { - let mut new_trusted_workspaces = HashSet::default(); - let new_trusted_worktrees = self - .trusted_paths - .clone() - .into_iter() - .map(|(host, paths)| { - let abs_paths = paths - .into_iter() - .flat_map(|path| match path { - PathTrust::Worktree(worktree_id) => self - .find_worktree_data(worktree_id, cx) - .map(|(abs_path, ..)| abs_path.to_path_buf()), - PathTrust::AbsPath(abs_path) => Some(abs_path), - PathTrust::Workspace => { - new_trusted_workspaces.insert(host.clone()); - None - } - }) - .collect(); - (host, abs_paths) - }) - .collect(); - // Do not persist auto trusted worktrees - if !ProjectSettings::get_global(cx).session.trust_all_worktrees { - self.serialization_task = cx.background_spawn(async move { - PROJECT_DB - .save_trusted_worktrees(new_trusted_worktrees, new_trusted_workspaces) - .await - .log_err(); - }); - } - } - if let Some((upstream_client, upstream_project_id)) = &self.upstream_client { let trusted_paths = trusted_paths .iter() @@ -578,31 +510,8 @@ impl TrustedWorktreesStore { /// Erases all trust information. /// Requires Zed's restart to take proper effect. - pub fn clear_trusted_paths(&mut self, cx: &App) -> Task<()> { - if self.downstream_client.is_none() { - self.trusted_paths.clear(); - - #[cfg(not(any(test, feature = "test-support")))] - { - let (tx, rx) = smol::channel::bounded(1); - self.serialization_task = cx.background_spawn(async move { - PROJECT_DB.clear_trusted_worktrees().await.log_err(); - tx.send(()).await.ok(); - }); - - return cx.background_spawn(async move { - rx.recv().await.ok(); - }); - } - - #[cfg(any(test, feature = "test-support"))] - { - let _ = cx; - Task::ready(()) - } - } else { - Task::ready(()) - } + pub fn clear_trusted_paths(&mut self) { + self.trusted_paths.clear(); } /// Checks whether a certain worktree is trusted (or on a larger trust level). @@ -785,6 +694,39 @@ impl TrustedWorktreesStore { } } + /// Returns a normalized representation of the trusted paths to store in the DB. + pub fn trusted_paths_for_serialization( + &mut self, + cx: &mut Context, + ) -> ( + HashSet>, + HashMap, HashSet>, + ) { + let mut new_trusted_workspaces = HashSet::default(); + let new_trusted_worktrees = self + .trusted_paths + .clone() + .into_iter() + .map(|(host, paths)| { + let abs_paths = paths + .into_iter() + .flat_map(|path| match path { + PathTrust::Worktree(worktree_id) => self + .find_worktree_data(worktree_id, cx) + .map(|(abs_path, ..)| abs_path.to_path_buf()), + PathTrust::AbsPath(abs_path) => Some(abs_path), + PathTrust::Workspace => { + new_trusted_workspaces.insert(host.clone()); + None + } + }) + .collect(); + (host, abs_paths) + }) + .collect(); + (new_trusted_workspaces, new_trusted_worktrees) + } + fn find_worktree_data( &mut self, worktree_id: WorktreeId, @@ -841,7 +783,7 @@ impl TrustedWorktreesStore { } } -pub(crate) fn find_worktree_in_store( +pub fn find_worktree_in_store( worktree_store: &WorktreeStore, abs_path: &Path, cx: &App, @@ -885,6 +827,7 @@ mod tests { cx: &mut TestAppContext, ) -> Entity { cx.update(|cx| { + init(HashMap::default(), None, None, cx); track_worktree_trust(worktree_store, None, None, None, cx); TrustedWorktrees::try_get_global(cx).expect("global should be set") }) diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs index f4f769474b39f182ee90cbaf146e09eab440dc15..af603998171e19d4776d47479ff81aa08d26d258 100644 --- a/crates/remote_server/src/unix.rs +++ b/crates/remote_server/src/unix.rs @@ -2,6 +2,7 @@ use crate::HeadlessProject; use crate::headless_project::HeadlessAppState; use anyhow::{Context as _, Result, anyhow}; use client::ProxySettings; +use collections::HashMap; use project::trusted_worktrees; use util::ResultExt; @@ -419,7 +420,7 @@ pub fn execute_run( log::info!("gpui app started, initializing server"); let session = start_server(listeners, log_rx, cx, is_wsl_interop); - trusted_worktrees::init(Some((session.clone(), REMOTE_SERVER_PROJECT_ID)), None, cx); + trusted_worktrees::init(HashMap::default(), Some((session.clone(), REMOTE_SERVER_PROJECT_ID)), None, cx); GitHostingProviderRegistry::set_global(git_hosting_provider_registry, cx); git_hosting_providers::init(cx); diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index f1835caf8dd84e1f729e0415b5711ffa69981d9b..dc113db68e33dc527e6b8d2cb66f644bcd83b661 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -9,14 +9,18 @@ use std::{ }; use anyhow::{Context as _, Result, bail}; -use collections::{HashMap, IndexSet}; +use collections::{HashMap, HashSet, IndexSet}; use db::{ query, sqlez::{connection::Connection, domain::Domain}, sqlez_macros::sql, }; -use gpui::{Axis, Bounds, Task, WindowBounds, WindowId, point, size}; -use project::debugger::breakpoint_store::{BreakpointState, SourceBreakpoint}; +use gpui::{Axis, Bounds, Entity, Task, WindowBounds, WindowId, point, size}; +use project::{ + debugger::breakpoint_store::{BreakpointState, SourceBreakpoint}, + trusted_worktrees::{PathTrust, RemoteHostLocation, find_worktree_in_store}, + worktree_store::WorktreeStore, +}; use language::{LanguageName, Toolchain, ToolchainScope}; use project::WorktreeId; @@ -46,6 +50,11 @@ use model::{ use self::model::{DockStructure, SerializedWorkspaceLocation}; +// https://www.sqlite.org/limits.html +// > <..> the maximum value of a host parameter number is SQLITE_MAX_VARIABLE_NUMBER, +// > which defaults to <..> 32766 for SQLite versions after 3.32.0. +const MAX_QUERY_PLACEHOLDERS: usize = 32000; + #[derive(Copy, Clone, Debug, PartialEq)] pub(crate) struct SerializedAxis(pub(crate) gpui::Axis); impl sqlez::bindable::StaticColumnCount for SerializedAxis {} @@ -708,6 +717,14 @@ impl Domain for WorkspaceDb { ALTER TABLE remote_connections ADD COLUMN name TEXT; ALTER TABLE remote_connections ADD COLUMN container_id TEXT; ), + sql!( + CREATE TABLE IF NOT EXISTS trusted_worktrees ( + trust_id INTEGER PRIMARY KEY AUTOINCREMENT, + absolute_path TEXT, + user_name TEXT, + host_name TEXT + ) STRICT; + ), ]; // Allow recovering from bad migration that was initially shipped to nightly @@ -1796,6 +1813,141 @@ impl WorkspaceDb { Ok(()) }).await } + + pub(crate) async fn save_trusted_worktrees( + &self, + trusted_worktrees: HashMap, HashSet>, + trusted_workspaces: HashSet>, + ) -> anyhow::Result<()> { + use anyhow::Context as _; + use db::sqlez::statement::Statement; + use itertools::Itertools as _; + + DB.clear_trusted_worktrees() + .await + .context("clearing previous trust state")?; + + let trusted_worktrees = trusted_worktrees + .into_iter() + .flat_map(|(host, abs_paths)| { + abs_paths + .into_iter() + .map(move |abs_path| (Some(abs_path), host.clone())) + }) + .chain(trusted_workspaces.into_iter().map(|host| (None, host))) + .collect::>(); + let mut first_worktree; + let mut last_worktree = 0_usize; + for (count, placeholders) in std::iter::once("(?, ?, ?)") + .cycle() + .take(trusted_worktrees.len()) + .chunks(MAX_QUERY_PLACEHOLDERS / 3) + .into_iter() + .map(|chunk| { + let mut count = 0; + let placeholders = chunk + .inspect(|_| { + count += 1; + }) + .join(", "); + (count, placeholders) + }) + .collect::>() + { + first_worktree = last_worktree; + last_worktree = last_worktree + count; + let query = format!( + r#"INSERT INTO trusted_worktrees(absolute_path, user_name, host_name) +VALUES {placeholders};"# + ); + + let trusted_worktrees = trusted_worktrees[first_worktree..last_worktree].to_vec(); + self.write(move |conn| { + let mut statement = Statement::prepare(conn, query)?; + let mut next_index = 1; + for (abs_path, host) in trusted_worktrees { + let abs_path = abs_path.as_ref().map(|abs_path| abs_path.to_string_lossy()); + next_index = statement.bind( + &abs_path.as_ref().map(|abs_path| abs_path.as_ref()), + next_index, + )?; + next_index = statement.bind( + &host + .as_ref() + .and_then(|host| Some(host.user_name.as_ref()?.as_str())), + next_index, + )?; + next_index = statement.bind( + &host.as_ref().map(|host| host.host_identifier.as_str()), + next_index, + )?; + } + statement.exec() + }) + .await + .context("inserting new trusted state")?; + } + Ok(()) + } + + pub fn fetch_trusted_worktrees( + &self, + worktree_store: Option>, + host: Option, + cx: &App, + ) -> Result, HashSet>> { + let trusted_worktrees = DB.trusted_worktrees()?; + Ok(trusted_worktrees + .into_iter() + .map(|(abs_path, user_name, host_name)| { + let db_host = match (user_name, host_name) { + (_, None) => None, + (None, Some(host_name)) => Some(RemoteHostLocation { + user_name: None, + host_identifier: SharedString::new(host_name), + }), + (Some(user_name), Some(host_name)) => Some(RemoteHostLocation { + user_name: Some(SharedString::new(user_name)), + host_identifier: SharedString::new(host_name), + }), + }; + + match abs_path { + Some(abs_path) => { + if db_host != host { + (db_host, PathTrust::AbsPath(abs_path)) + } else if let Some(worktree_store) = &worktree_store { + find_worktree_in_store(worktree_store.read(cx), &abs_path, cx) + .map(PathTrust::Worktree) + .map(|trusted_worktree| (host.clone(), trusted_worktree)) + .unwrap_or_else(|| (db_host.clone(), PathTrust::AbsPath(abs_path))) + } else { + (db_host, PathTrust::AbsPath(abs_path)) + } + } + None => (db_host, PathTrust::Workspace), + } + }) + .fold(HashMap::default(), |mut acc, (remote_host, path_trust)| { + acc.entry(remote_host) + .or_insert_with(HashSet::default) + .insert(path_trust); + acc + })) + } + + query! { + fn trusted_worktrees() -> Result, Option, Option)>> { + SELECT absolute_path, user_name, host_name + FROM trusted_worktrees + } + } + + query! { + pub async fn clear_trusted_worktrees() -> Result<()> { + DELETE FROM trusted_worktrees + } + } } pub fn delete_unloaded_items( diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs index f2a94ad81661a2572f35d1d746b04b31fa24f00c..44242a3588017aabf117300310dd10a4a28b292f 100644 --- a/crates/workspace/src/security_modal.rs +++ b/crates/workspace/src/security_modal.rs @@ -131,14 +131,14 @@ impl Render for SecurityModal { None => match &restricted_path.host { Some(remote_host) => match &remote_host.user_name { Some(user_name) => format!( - "Empty project ({}@{})", + "Workspace trust ({}@{})", user_name, remote_host.host_identifier ), None => { - format!("Empty project ({})", remote_host.host_identifier) + format!("Workspace trust ({})", remote_host.host_identifier) } }, - None => "Empty project".to_string(), + None => "Workspace trust".to_string(), }, }; h_flex() diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 34593f5bc8f6af3b9cbac87e8fbff50d3f954a95..00412cfb75fce58b19a697e283f77c5a57ebb683 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -80,7 +80,7 @@ use project::{ debugger::{breakpoint_store::BreakpointStoreEvent, session::ThreadStatus}, project_settings::ProjectSettings, toolchain_store::ToolchainStoreEvent, - trusted_worktrees::TrustedWorktrees, + trusted_worktrees::{TrustedWorktrees, TrustedWorktreesEvent}, }; use remote::{ RemoteClientDelegate, RemoteConnection, RemoteConnectionOptions, @@ -1184,6 +1184,7 @@ pub struct Workspace { _observe_current_user: Task>, _schedule_serialize_workspace: Option>, _schedule_serialize_ssh_paths: Option>, + _schedule_serialize_worktree_trust: Task<()>, pane_history_timestamp: Arc, bounds: Bounds, pub centered_layout: bool, @@ -1229,16 +1230,43 @@ impl Workspace { window: &mut Window, cx: &mut Context, ) -> Self { - cx.observe_global::(|_, cx| { - if ProjectSettings::get_global(cx).session.trust_all_worktrees { - if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { - trusted_worktrees.update(cx, |trusted_worktrees, cx| { - trusted_worktrees.auto_trust_all(cx); - }) + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + cx.subscribe(&trusted_worktrees, |workspace, worktrees_store, e, cx| { + if let TrustedWorktreesEvent::Trusted(..) = e { + let (new_trusted_workspaces, new_trusted_worktrees) = worktrees_store + .update(cx, |worktrees_store, cx| { + worktrees_store.trusted_paths_for_serialization(cx) + }); + // Do not persist auto trusted worktrees + if !ProjectSettings::get_global(cx).session.trust_all_worktrees { + let timeout = cx.background_executor().timer(SERIALIZATION_THROTTLE_TIME); + workspace._schedule_serialize_worktree_trust = + cx.background_spawn(async move { + timeout.await; + persistence::DB + .save_trusted_worktrees( + new_trusted_worktrees, + new_trusted_workspaces, + ) + .await + .log_err(); + }); + } } - } - }) - .detach(); + }) + .detach(); + + cx.observe_global::(|_, cx| { + if ProjectSettings::get_global(cx).session.trust_all_worktrees { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.auto_trust_all(cx); + }) + } + } + }) + .detach(); + } cx.subscribe_in(&project, window, move |this, _, event, window, cx| { match event { @@ -1250,11 +1278,25 @@ impl Workspace { this.collaborator_left(*peer_id, window, cx); } - project::Event::WorktreeRemoved(_) | project::Event::WorktreeAdded(_) => { - this.update_window_title(window, cx); - this.serialize_workspace(window, cx); - // This event could be triggered by `AddFolderToProject` or `RemoveFromProject`. - this.update_history(cx); + project::Event::WorktreeUpdatedEntries(worktree_id, _) => { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust(*worktree_id, cx); + }); + } + } + + project::Event::WorktreeRemoved(_) => { + this.update_worktree_data(window, cx); + } + + project::Event::WorktreeAdded(worktree_id) => { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + trusted_worktrees.can_trust(*worktree_id, cx); + }); + } + this.update_worktree_data(window, cx); } project::Event::DisconnectedFromHost => { @@ -1540,6 +1582,7 @@ impl Workspace { _apply_leader_updates, _schedule_serialize_workspace: None, _schedule_serialize_ssh_paths: None, + _schedule_serialize_worktree_trust: Task::ready(()), leader_updates_tx, _subscriptions: subscriptions, pane_history_timestamp, @@ -5970,12 +6013,14 @@ impl Workspace { .on_action( cx.listener(|_: &mut Workspace, _: &ClearTrustedWorktrees, _, cx| { if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { - let clear_task = trusted_worktrees.update(cx, |trusted_worktrees, cx| { - trusted_worktrees.clear_trusted_paths(cx) + trusted_worktrees.update(cx, |trusted_worktrees, _| { + trusted_worktrees.clear_trusted_paths() }); + let clear_task = persistence::DB.clear_trusted_worktrees(); cx.spawn(async move |_, cx| { - clear_task.await; - cx.update(|cx| reload(cx)).ok(); + if clear_task.await.log_err().is_some() { + cx.update(|cx| reload(cx)).ok(); + } }) .detach(); } @@ -6496,6 +6541,13 @@ impl Workspace { } } } + + fn update_worktree_data(&mut self, window: &mut Window, cx: &mut Context<'_, Self>) { + self.update_window_title(window, cx); + self.serialize_workspace(window, cx); + // This event could be triggered by `AddFolderToProject` or `RemoveFromProject`. + self.update_history(cx); + } } fn leader_border_for_pane( diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index 353baba02cca9b0060a647f438fa8be4e81e9142..c8137a71c0f2a8524f6310d7cd711978ed833d1a 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -407,7 +407,14 @@ pub fn main() { }); app.run(move |cx| { - trusted_worktrees::init(None, None, cx); + let trusted_paths = match workspace::WORKSPACE_DB.fetch_trusted_worktrees(None, None, cx) { + Ok(trusted_paths) => trusted_paths, + Err(e) => { + log::error!("Failed to do initial trusted worktrees fetch: {e:#}"); + HashMap::default() + } + }; + trusted_worktrees::init(trusted_paths, None, None, cx); menu::init(); zed_actions::init(); From 4fe6dc06ea96b0f7a81f2fc7f2200ea27d4eb0a4 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Tue, 16 Dec 2025 19:02:46 -0500 Subject: [PATCH 093/266] git: Align checkboxes in git panel (#45048) Before this fix checkboxes would overflow off the visible view which isn't ideal. This aligns the checkboxes by allowing the path name to overflow. #### Before image #### After image Release Notes: - N/A Co-authored-by: Cole Miller Co-authored-by: Matt Miller --- crates/git_ui/src/git_panel.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 37926eae5db12c83ab69613a09c4eceda1f5ffeb..8b32a79311f1f52036d8e54d182139d45bf64d10 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -4949,7 +4949,7 @@ impl GitPanel { cx.stop_propagation(); }, ) - .child(name_row) + .child(name_row.overflow_x_hidden()) .child( div() .id(checkbox_wrapper_id) @@ -5103,7 +5103,7 @@ impl GitPanel { this.toggle_directory(&key, window, cx); }) }) - .child(name_row) + .child(name_row.overflow_x_hidden()) .child( div() .id(checkbox_wrapper_id) From 975a76bbf09e2b3b0207c2d02947851591500c2f Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Wed, 17 Dec 2025 01:42:04 +0100 Subject: [PATCH 094/266] Bump Rust version to 1.92 (#44649) Release Notes: - N/A --------- Co-authored-by: Julia Ryan --- Dockerfile-collab | 2 +- crates/editor/src/editor.rs | 7 +++---- crates/git_ui/src/branch_picker.rs | 6 +++--- crates/gpui/src/elements/surface.rs | 1 + crates/gpui/src/elements/uniform_list.rs | 4 ++-- crates/language/src/buffer.rs | 3 +-- crates/project/src/lsp_store.rs | 14 ++++++-------- crates/vim/src/motion.rs | 8 +------- crates/zed/src/zed.rs | 2 ++ flake.lock | 22 ++++++++++------------ rust-toolchain.toml | 2 +- 11 files changed, 31 insertions(+), 40 deletions(-) diff --git a/Dockerfile-collab b/Dockerfile-collab index 68f898618a5d0cd1ad9999e5482c53dc0cb26da6..188e7daddfb471c41b237ca75469355cfc866ae3 100644 --- a/Dockerfile-collab +++ b/Dockerfile-collab @@ -1,6 +1,6 @@ # syntax = docker/dockerfile:1.2 -FROM rust:1.91.1-bookworm as builder +FROM rust:1.92-bookworm as builder WORKDIR app COPY . . diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index f4a83f900da68d90803b82c0aec1287fcaa71cd3..4072b1db7a1935e5dbb9c63d2a3aa19db270f131 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -15534,10 +15534,9 @@ impl Editor { I: IntoIterator, P: AsRef<[u8]>, { - let case_sensitive = self.select_next_is_case_sensitive.map_or_else( - || EditorSettings::get_global(cx).search.case_sensitive, - |value| value, - ); + let case_sensitive = self + .select_next_is_case_sensitive + .unwrap_or_else(|| EditorSettings::get_global(cx).search.case_sensitive); let mut builder = AhoCorasickBuilder::new(); builder.ascii_case_insensitive(!case_sensitive); diff --git a/crates/git_ui/src/branch_picker.rs b/crates/git_ui/src/branch_picker.rs index c7cf72cdbd880bbd0bca7611474b42a3a600cc48..cbf3fea72a9937a0ab882f9ccca2c4274afdf0e2 100644 --- a/crates/git_ui/src/branch_picker.rs +++ b/crates/git_ui/src/branch_picker.rs @@ -969,12 +969,12 @@ impl PickerDelegate for BranchListDelegate { "No commits found".into(), |subject| { if show_author_name - && author_name.is_some() + && let Some(author) = + author_name { format!( "{} • {}", - author_name.unwrap(), - subject + author, subject ) } else { subject.to_string() diff --git a/crates/gpui/src/elements/surface.rs b/crates/gpui/src/elements/surface.rs index b4fced1001b3f9881b66f2f93e81588c750aa64c..ac1c247b47ec81bca06e458827786f549ca2d747 100644 --- a/crates/gpui/src/elements/surface.rs +++ b/crates/gpui/src/elements/surface.rs @@ -29,6 +29,7 @@ pub struct Surface { } /// Create a new surface element. +#[cfg(target_os = "macos")] pub fn surface(source: impl Into) -> Surface { Surface { source: source.into(), diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs index 1e38b0e7ac9abcf891201b7db61b819abe00ef1e..1ad71b97673e6f54015dbc67fa829725dd4fccb2 100644 --- a/crates/gpui/src/elements/uniform_list.rs +++ b/crates/gpui/src/elements/uniform_list.rs @@ -712,8 +712,8 @@ mod test { #[gpui::test] fn test_scroll_strategy_nearest(cx: &mut TestAppContext) { use crate::{ - Context, FocusHandle, ScrollStrategy, UniformListScrollHandle, Window, actions, div, - prelude::*, px, uniform_list, + Context, FocusHandle, ScrollStrategy, UniformListScrollHandle, Window, div, prelude::*, + px, uniform_list, }; use std::ops::Range; diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 59795c375ab9b663339dbbebccc60062058c6ef9..a0ec214c765fccacff1c72e3f22de586570b3cd3 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -3303,8 +3303,7 @@ impl BufferSnapshot { // set its end to the outdent position if let Some(range_to_truncate) = indent_ranges .iter_mut() - .filter(|indent_range| indent_range.contains(&outdent_position)) - .next_back() + .rfind(|indent_range| indent_range.contains(&outdent_position)) { range_to_truncate.end = outdent_position; } diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 2ea3dbf70fcb4359f3f5985cc6cd3bb4db7df009..83c2abfbb863166fd52e177dd75b497ca5111999 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -2285,12 +2285,10 @@ impl LocalLspStore { && lsp_action.data.is_some() && (lsp_action.command.is_none() || lsp_action.edit.is_none()) { - *lsp_action = Box::new( - lang_server - .request::(*lsp_action.clone()) - .await - .into_response()?, - ); + **lsp_action = lang_server + .request::(*lsp_action.clone()) + .await + .into_response()?; } } LspAction::CodeLens(lens) => { @@ -6480,7 +6478,7 @@ impl LspStore { server_id == *completion_server_id, "server_id mismatch, applying completion resolve for {server_id} but completion server id is {completion_server_id}" ); - *lsp_completion = Box::new(resolved_completion); + **lsp_completion = resolved_completion; *resolved = true; } Ok(()) @@ -6639,7 +6637,7 @@ impl LspStore { server_id == *completion_server_id, "remote server_id mismatch, applying completion resolve for {server_id} but completion server id is {completion_server_id}" ); - *lsp_completion = Box::new(resolved_lsp_completion); + **lsp_completion = resolved_lsp_completion; *resolved = true; } diff --git a/crates/vim/src/motion.rs b/crates/vim/src/motion.rs index 6ba28a1c236ada7c08eeabac9d9189991434a807..f2e629faf2dd4a5d1ff47a49278cdd022f75d8d4 100644 --- a/crates/vim/src/motion.rs +++ b/crates/vim/src/motion.rs @@ -1,5 +1,5 @@ use editor::{ - Anchor, Bias, BufferOffset, DisplayPoint, Editor, MultiBufferOffset, RowExt, ToOffset, ToPoint, + Anchor, Bias, BufferOffset, DisplayPoint, Editor, MultiBufferOffset, RowExt, ToOffset, display_map::{DisplayRow, DisplaySnapshot, FoldPoint, ToDisplayPoint}, movement::{ self, FindRange, TextLayoutDetails, find_boundary, find_preceding_boundary_display_point, @@ -2262,7 +2262,6 @@ fn go_to_line(map: &DisplaySnapshot, display_point: DisplayPoint, line: usize) - .offset_to_point(excerpt.map_offset_from_buffer(BufferOffset(offset))); return map.clip_point(map.point_to_display_point(point, Bias::Left), Bias::Left); } - let mut last_position = None; for (excerpt, buffer, range) in map.buffer_snapshot().excerpts() { let excerpt_range = language::ToOffset::to_offset(&range.context.start, buffer) ..language::ToOffset::to_offset(&range.context.end, buffer); @@ -2273,14 +2272,9 @@ fn go_to_line(map: &DisplaySnapshot, display_point: DisplayPoint, line: usize) - } else if offset <= excerpt_range.start { let anchor = Anchor::in_buffer(excerpt, range.context.start); return anchor.to_display_point(map); - } else { - last_position = Some(Anchor::in_buffer(excerpt, range.context.end)); } } - let mut last_point = last_position.unwrap().to_point(&map.buffer_snapshot()); - last_point.column = point.column; - map.clip_point( map.point_to_display_point( map.buffer_snapshot().clip_point(point, Bias::Left), diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index c1d98936aa2ad20e6eef7f18bfed2d2c0615395a..fc5e74a76905d1ea45fa8bad2df12e22a23122e3 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -353,6 +353,8 @@ pub fn initialize_workspace( ) { let mut _on_close_subscription = bind_on_window_closed(cx); cx.observe_global::(move |cx| { + // A 1.92 regression causes unused-assignment to trigger on this variable. + _ = _on_close_subscription.is_some(); _on_close_subscription = bind_on_window_closed(cx); }) .detach(); diff --git a/flake.lock b/flake.lock index 520dcb3f7469319dbf755bfd70103cb5de1b2c48..561919d5745a2355aad14a4fe9972bf9fbf3d8d2 100644 --- a/flake.lock +++ b/flake.lock @@ -2,11 +2,11 @@ "nodes": { "crane": { "locked": { - "lastModified": 1762538466, - "narHash": "sha256-8zrIPl6J+wLm9MH5ksHcW7BUHo7jSNOu0/hA0ohOOaM=", + "lastModified": 1765145449, + "narHash": "sha256-aBVHGWWRzSpfL++LubA0CwOOQ64WNLegrYHwsVuVN7A=", "owner": "ipetkov", "repo": "crane", - "rev": "0cea393fffb39575c46b7a0318386467272182fe", + "rev": "69f538cdce5955fcd47abfed4395dc6d5194c1c5", "type": "github" }, "original": { @@ -17,11 +17,11 @@ }, "flake-compat": { "locked": { - "lastModified": 1761588595, - "narHash": "sha256-XKUZz9zewJNUj46b4AJdiRZJAvSZ0Dqj2BNfXvFlJC4=", + "lastModified": 1765121682, + "narHash": "sha256-4VBOP18BFeiPkyhy9o4ssBNQEvfvv1kXkasAYd0+rrA=", "owner": "edolstra", "repo": "flake-compat", - "rev": "f387cd2afec9419c8ee37694406ca490c3f34ee5", + "rev": "65f23138d8d09a92e30f1e5c87611b23ef451bf3", "type": "github" }, "original": { @@ -53,16 +53,14 @@ }, "rust-overlay": { "inputs": { - "nixpkgs": [ - "nixpkgs" - ] + "nixpkgs": ["nixpkgs"] }, "locked": { - "lastModified": 1762915112, - "narHash": "sha256-d9j1g8nKmYDHy+/bIOPQTh9IwjRliqaTM0QLHMV92Ic=", + "lastModified": 1765465581, + "narHash": "sha256-fCXT0aZXmTalM3NPCTedVs9xb0egBG5BOZkcrYo5PGE=", "owner": "oxalica", "repo": "rust-overlay", - "rev": "aa1e85921cfa04de7b6914982a94621fbec5cc02", + "rev": "99cc5667eece98bb35dcf35f7e511031a8b7a125", "type": "github" }, "original": { diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 59765d94abe9c04e6668203de31b598dd6b34dc7..e7cc22421d71ba35b592dd2163da1927c4abf118 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,5 +1,5 @@ [toolchain] -channel = "1.91.1" +channel = "1.92" profile = "minimal" components = [ "rustfmt", "clippy" ] targets = [ From 1c33dbcb667e6c019408b165740aef4008bbceb8 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Tue, 16 Dec 2025 17:41:06 -0800 Subject: [PATCH 095/266] Fix slow tree-sitter query execution by limiting the range that queries search (#39416) Part of https://github.com/zed-industries/zed/issues/39594 Closes https://github.com/zed-industries/zed/issues/4701 Closes https://github.com/zed-industries/zed/issues/42861 Closes https://github.com/zed-industries/zed/issues/44503 ~Depends on https://github.com/tree-sitter/tree-sitter/pull/4919~ Release Notes: - Fixed some performance bottlenecks related to syntax analysis when editing very large files --------- Co-authored-by: Kirill Bulatov --- crates/language/src/buffer.rs | 30 ++++++++++++++++++++---------- crates/language/src/syntax_map.rs | 21 ++++++++++++++++++++- 2 files changed, 40 insertions(+), 11 deletions(-) diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index a0ec214c765fccacff1c72e3f22de586570b3cd3..2a9b4ea1df4fc0b4772586f0e51016cdd1882722 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -8,8 +8,8 @@ use crate::{ outline::OutlineItem, row_chunk::RowChunks, syntax_map::{ - SyntaxLayer, SyntaxMap, SyntaxMapCapture, SyntaxMapCaptures, SyntaxMapMatch, - SyntaxMapMatches, SyntaxSnapshot, ToTreeSitterPoint, + MAX_BYTES_TO_QUERY, SyntaxLayer, SyntaxMap, SyntaxMapCapture, SyntaxMapCaptures, + SyntaxMapMatch, SyntaxMapMatches, SyntaxSnapshot, ToTreeSitterPoint, }, task_context::RunnableRange, text_diff::text_diff, @@ -3222,9 +3222,15 @@ impl BufferSnapshot { let start = Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0); let end = Point::new(row_range.end, 0); let range = (start..end).to_offset(&self.text); - let mut matches = self.syntax.matches(range.clone(), &self.text, |grammar| { - Some(&grammar.indents_config.as_ref()?.query) - }); + let mut matches = self.syntax.matches_with_options( + range.clone(), + &self.text, + TreeSitterOptions { + max_bytes_to_query: Some(MAX_BYTES_TO_QUERY), + max_start_depth: None, + }, + |grammar| Some(&grammar.indents_config.as_ref()?.query), + ); let indent_configs = matches .grammars() .iter() @@ -4335,11 +4341,15 @@ impl BufferSnapshot { let mut opens = Vec::new(); let mut color_pairs = Vec::new(); - let mut matches = self - .syntax - .matches(chunk_range.clone(), &self.text, |grammar| { - grammar.brackets_config.as_ref().map(|c| &c.query) - }); + let mut matches = self.syntax.matches_with_options( + chunk_range.clone(), + &self.text, + TreeSitterOptions { + max_bytes_to_query: Some(MAX_BYTES_TO_QUERY), + max_start_depth: None, + }, + |grammar| grammar.brackets_config.as_ref().map(|c| &c.query), + ); let configs = matches .grammars() .iter() diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs index 17285ca315fb64dd518d00039d28266c0a7f51ab..77e90c4ca89d0b6e5b8cb0a604175ec9a97e719e 100644 --- a/crates/language/src/syntax_map.rs +++ b/crates/language/src/syntax_map.rs @@ -21,6 +21,8 @@ use sum_tree::{Bias, Dimensions, SeekTarget, SumTree}; use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point, Rope, ToOffset, ToPoint}; use tree_sitter::{Node, Query, QueryCapture, QueryCaptures, QueryCursor, QueryMatches, Tree}; +pub const MAX_BYTES_TO_QUERY: usize = 16 * 1024; + pub struct SyntaxMap { snapshot: SyntaxSnapshot, language_registry: Option>, @@ -1096,12 +1098,15 @@ impl<'a> SyntaxMapCaptures<'a> { #[derive(Default)] pub struct TreeSitterOptions { - max_start_depth: Option, + pub max_start_depth: Option, + pub max_bytes_to_query: Option, } + impl TreeSitterOptions { pub fn max_start_depth(max_start_depth: u32) -> Self { Self { max_start_depth: Some(max_start_depth), + max_bytes_to_query: None, } } } @@ -1135,6 +1140,14 @@ impl<'a> SyntaxMapMatches<'a> { }; cursor.set_max_start_depth(options.max_start_depth); + if let Some(max_bytes_to_query) = options.max_bytes_to_query { + let midpoint = (range.start + range.end) / 2; + let containing_range_start = midpoint.saturating_sub(max_bytes_to_query / 2); + let containing_range_end = + containing_range_start.saturating_add(max_bytes_to_query); + cursor.set_containing_byte_range(containing_range_start..containing_range_end); + } + cursor.set_byte_range(range.clone()); let matches = cursor.matches(query, layer.node(), TextProvider(text)); let grammar_index = result @@ -1642,6 +1655,10 @@ impl<'a> SyntaxLayer<'a> { let mut query_cursor = QueryCursorHandle::new(); query_cursor.set_byte_range(offset.saturating_sub(1)..offset.saturating_add(1)); + query_cursor.set_containing_byte_range( + offset.saturating_sub(MAX_BYTES_TO_QUERY / 2) + ..offset.saturating_add(MAX_BYTES_TO_QUERY / 2), + ); let mut smallest_match: Option<(u32, Range)> = None; let mut matches = query_cursor.matches(&config.query, self.node(), text); @@ -1928,6 +1945,8 @@ impl Drop for QueryCursorHandle { let mut cursor = self.0.take().unwrap(); cursor.set_byte_range(0..usize::MAX); cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point()); + cursor.set_containing_byte_range(0..usize::MAX); + cursor.set_containing_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point()); QUERY_CURSORS.lock().push(cursor) } } From 92b1f1fffb5a1c91d40b9b27e906beb87b301246 Mon Sep 17 00:00:00 2001 From: Matthew Chisolm <39521893+mchisolm0@users.noreply.github.com> Date: Tue, 16 Dec 2025 22:59:47 -0600 Subject: [PATCH 096/266] workspace: Persist window values without project (#44937) Persist and restore window values (size, position, etc.) to the KV Store when there are no projects open. Relates to Discussion https://github.com/zed-industries/zed/discussions/24228#discussioncomment-15224666 Release Notes: - Added persistence for window size when no projects are open --------- Co-authored-by: Conrad Irwin --- crates/workspace/src/persistence.rs | 138 ++++++++++++++++++++++++---- crates/workspace/src/workspace.rs | 37 ++++++-- 2 files changed, 150 insertions(+), 25 deletions(-) diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index dc113db68e33dc527e6b8d2cb66f644bcd83b661..4a8aab364db3ec37f7f089b8dc3df4ca1114ee28 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -11,6 +11,7 @@ use std::{ use anyhow::{Context as _, Result, bail}; use collections::{HashMap, HashSet, IndexSet}; use db::{ + kvp::KEY_VALUE_STORE, query, sqlez::{connection::Connection, domain::Domain}, sqlez_macros::sql, @@ -27,6 +28,7 @@ use project::WorktreeId; use remote::{ DockerConnectionOptions, RemoteConnectionOptions, SshConnectionOptions, WslConnectionOptions, }; +use serde::{Deserialize, Serialize}; use sqlez::{ bindable::{Bind, Column, StaticColumnCount}, statement::Statement, @@ -163,6 +165,124 @@ impl Column for SerializedWindowBounds { } } +const DEFAULT_WINDOW_BOUNDS_KEY: &str = "default_window_bounds"; + +pub fn read_default_window_bounds() -> Option<(Uuid, WindowBounds)> { + let json_str = KEY_VALUE_STORE + .read_kvp(DEFAULT_WINDOW_BOUNDS_KEY) + .log_err() + .flatten()?; + + let (display_uuid, persisted) = + serde_json::from_str::<(Uuid, WindowBoundsJson)>(&json_str).ok()?; + Some((display_uuid, persisted.into())) +} + +pub async fn write_default_window_bounds( + bounds: WindowBounds, + display_uuid: Uuid, +) -> anyhow::Result<()> { + let persisted = WindowBoundsJson::from(bounds); + let json_str = serde_json::to_string(&(display_uuid, persisted))?; + KEY_VALUE_STORE + .write_kvp(DEFAULT_WINDOW_BOUNDS_KEY.to_string(), json_str) + .await?; + Ok(()) +} + +#[derive(Serialize, Deserialize)] +pub enum WindowBoundsJson { + Windowed { + x: i32, + y: i32, + width: i32, + height: i32, + }, + Maximized { + x: i32, + y: i32, + width: i32, + height: i32, + }, + Fullscreen { + x: i32, + y: i32, + width: i32, + height: i32, + }, +} + +impl From for WindowBoundsJson { + fn from(b: WindowBounds) -> Self { + match b { + WindowBounds::Windowed(bounds) => { + let origin = bounds.origin; + let size = bounds.size; + WindowBoundsJson::Windowed { + x: f32::from(origin.x).round() as i32, + y: f32::from(origin.y).round() as i32, + width: f32::from(size.width).round() as i32, + height: f32::from(size.height).round() as i32, + } + } + WindowBounds::Maximized(bounds) => { + let origin = bounds.origin; + let size = bounds.size; + WindowBoundsJson::Maximized { + x: f32::from(origin.x).round() as i32, + y: f32::from(origin.y).round() as i32, + width: f32::from(size.width).round() as i32, + height: f32::from(size.height).round() as i32, + } + } + WindowBounds::Fullscreen(bounds) => { + let origin = bounds.origin; + let size = bounds.size; + WindowBoundsJson::Fullscreen { + x: f32::from(origin.x).round() as i32, + y: f32::from(origin.y).round() as i32, + width: f32::from(size.width).round() as i32, + height: f32::from(size.height).round() as i32, + } + } + } + } +} + +impl From for WindowBounds { + fn from(n: WindowBoundsJson) -> Self { + match n { + WindowBoundsJson::Windowed { + x, + y, + width, + height, + } => WindowBounds::Windowed(Bounds { + origin: point(px(x as f32), px(y as f32)), + size: size(px(width as f32), px(height as f32)), + }), + WindowBoundsJson::Maximized { + x, + y, + width, + height, + } => WindowBounds::Maximized(Bounds { + origin: point(px(x as f32), px(y as f32)), + size: size(px(width as f32), px(height as f32)), + }), + WindowBoundsJson::Fullscreen { + x, + y, + width, + height, + } => WindowBounds::Fullscreen(Bounds { + origin: point(px(x as f32), px(y as f32)), + size: size(px(width as f32), px(height as f32)), + }), + } + } +} + #[derive(Debug)] pub struct Breakpoint { pub position: u32, @@ -1381,24 +1501,6 @@ impl WorkspaceDb { } } - pub(crate) fn last_window( - &self, - ) -> anyhow::Result<(Option, Option)> { - let mut prepared_query = - self.select::<(Option, Option)>(sql!( - SELECT - display, - window_state, window_x, window_y, window_width, window_height - FROM workspaces - WHERE paths - IS NOT NULL - ORDER BY timestamp DESC - LIMIT 1 - ))?; - let result = prepared_query()?; - Ok(result.into_iter().next().unwrap_or((None, None))) - } - query! { pub async fn delete_workspace_by_id(id: WorkspaceId) -> Result<()> { DELETE FROM workspaces diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 00412cfb75fce58b19a697e283f77c5a57ebb683..5947cb1703b37017bf75bfe412603332b8d5016a 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -1508,6 +1508,15 @@ impl Workspace { && let Ok(display_uuid) = display.uuid() { let window_bounds = window.inner_window_bounds(); + let has_paths = !this.root_paths(cx).is_empty(); + if !has_paths { + cx.background_executor() + .spawn(persistence::write_default_window_bounds( + window_bounds, + display_uuid, + )) + .detach_and_log_err(cx); + } if let Some(database_id) = workspace_id { cx.background_executor() .spawn(DB.set_window_open_status( @@ -1516,6 +1525,13 @@ impl Workspace { display_uuid, )) .detach_and_log_err(cx); + } else { + cx.background_executor() + .spawn(persistence::write_default_window_bounds( + window_bounds, + display_uuid, + )) + .detach_and_log_err(cx); } } this.bounds_save_task_queued.take(); @@ -1724,6 +1740,7 @@ impl Workspace { window } else { let window_bounds_override = window_bounds_env_override(); + let is_empty_workspace = project_paths.is_empty(); let (window_bounds, display) = if let Some(bounds) = window_bounds_override { (Some(WindowBounds::Windowed(bounds)), None) @@ -1736,6 +1753,13 @@ impl Workspace { } else { (None, None) } + } else if is_empty_workspace { + // Empty workspace - try to restore the last known no-project window bounds + if let Some((display, bounds)) = persistence::read_default_window_bounds() { + (Some(bounds), Some(display)) + } else { + (None, None) + } } else { // New window - let GPUI's default_bounds() handle cascading (None, None) @@ -8820,14 +8844,13 @@ pub fn remote_workspace_position_from_db( } else { let restorable_bounds = serialized_workspace .as_ref() - .and_then(|workspace| Some((workspace.display?, workspace.window_bounds?))) - .or_else(|| { - let (display, window_bounds) = DB.last_window().log_err()?; - Some((display?, window_bounds?)) - }); + .and_then(|workspace| { + Some((workspace.display?, workspace.window_bounds.map(|b| b.0)?)) + }) + .or_else(|| persistence::read_default_window_bounds()); - if let Some((serialized_display, serialized_status)) = restorable_bounds { - (Some(serialized_status.0), Some(serialized_display)) + if let Some((serialized_display, serialized_bounds)) = restorable_bounds { + (Some(serialized_bounds), Some(serialized_display)) } else { (None, None) } From 76665a78d1ed9e630599a109320b659b2db3b364 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Tue, 16 Dec 2025 22:47:44 -0700 Subject: [PATCH 097/266] More secure auto-fixer (#44952) Split running `cargo clippy` out of the job that has access to ZIPPY secrets as a precaution against accidentally leaking the secrets through build.rs or something... Release Notes: - N/A --- .github/workflows/autofix_pr.yml | 78 ++++++++--- .../xtask/src/tasks/workflows/autofix_pr.rs | 129 ++++++++++++++---- 2 files changed, 159 insertions(+), 48 deletions(-) diff --git a/.github/workflows/autofix_pr.yml b/.github/workflows/autofix_pr.yml index 308849ccbeed0be7f9ab5c8f7e5846ed61a8724d..762b86c446f4592e8fd76c8f5a00cf8cf8ab3f38 100644 --- a/.github/workflows/autofix_pr.yml +++ b/.github/workflows/autofix_pr.yml @@ -9,26 +9,23 @@ on: description: pr_number required: true type: string + run_clippy: + description: run_clippy + type: boolean + default: 'true' jobs: run_autofix: runs-on: namespace-profile-16x32-ubuntu-2204 steps: - - id: get-app-token - name: autofix_pr::run_autofix::authenticate_as_zippy - uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 - with: - app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} - private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }} - - name: steps::checkout_repo_with_token + - name: steps::checkout_repo uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 with: clean: false - token: ${{ steps.get-app-token.outputs.token }} - name: autofix_pr::run_autofix::checkout_pr run: gh pr checkout ${{ inputs.pr_number }} shell: bash -euxo pipefail {0} env: - GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: steps::setup_cargo_config run: | mkdir -p ./../.cargo @@ -58,26 +55,71 @@ jobs: run: cargo fmt --all shell: bash -euxo pipefail {0} - name: autofix_pr::run_autofix::run_clippy_fix + if: ${{ inputs.run_clippy }} run: cargo clippy --workspace --release --all-targets --all-features --fix --allow-dirty --allow-staged shell: bash -euxo pipefail {0} - - name: autofix_pr::run_autofix::commit_and_push + - id: create-patch + name: autofix_pr::run_autofix::create_patch run: | if git diff --quiet; then echo "No changes to commit" + echo "has_changes=false" >> "$GITHUB_OUTPUT" else - git add -A - git commit -m "Autofix" - git push + git diff > autofix.patch + echo "has_changes=true" >> "$GITHUB_OUTPUT" fi shell: bash -euxo pipefail {0} + - name: upload artifact autofix-patch + uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 + with: + name: autofix-patch + path: autofix.patch + if-no-files-found: ignore + retention-days: '1' + - name: steps::cleanup_cargo_config + if: always() + run: | + rm -rf ./../.cargo + shell: bash -euxo pipefail {0} + outputs: + has_changes: ${{ steps.create-patch.outputs.has_changes }} + commit_changes: + needs: + - run_autofix + if: needs.run_autofix.outputs.has_changes == 'true' + runs-on: namespace-profile-2x4-ubuntu-2404 + steps: + - id: get-app-token + name: autofix_pr::commit_changes::authenticate_as_zippy + uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 + with: + app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} + private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }} + - name: steps::checkout_repo_with_token + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + with: + clean: false + token: ${{ steps.get-app-token.outputs.token }} + - name: autofix_pr::commit_changes::checkout_pr + run: gh pr checkout ${{ inputs.pr_number }} + shell: bash -euxo pipefail {0} + env: + GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} + - name: autofix_pr::download_patch_artifact + uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 + with: + name: autofix-patch + - name: autofix_pr::commit_changes::apply_patch + run: git apply autofix.patch + shell: bash -euxo pipefail {0} + - name: autofix_pr::commit_changes::commit_and_push + run: | + git commit -am "Autofix" + git push + shell: bash -euxo pipefail {0} env: GIT_COMMITTER_NAME: Zed Zippy GIT_COMMITTER_EMAIL: 234243425+zed-zippy[bot]@users.noreply.github.com GIT_AUTHOR_NAME: Zed Zippy GIT_AUTHOR_EMAIL: 234243425+zed-zippy[bot]@users.noreply.github.com GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} - - name: steps::cleanup_cargo_config - if: always() - run: | - rm -rf ./../.cargo - shell: bash -euxo pipefail {0} diff --git a/tooling/xtask/src/tasks/workflows/autofix_pr.rs b/tooling/xtask/src/tasks/workflows/autofix_pr.rs index 835750e282dad39a3455fc0b5eb69bf82cc42201..44dd0f9ea9b840163767e15b973192e72b57f4a8 100644 --- a/tooling/xtask/src/tasks/workflows/autofix_pr.rs +++ b/tooling/xtask/src/tasks/workflows/autofix_pr.rs @@ -8,31 +8,49 @@ use crate::tasks::workflows::{ pub fn autofix_pr() -> Workflow { let pr_number = WorkflowInput::string("pr_number", None); - let autofix = run_autofix(&pr_number); + let run_clippy = WorkflowInput::bool("run_clippy", Some(true)); + let run_autofix = run_autofix(&pr_number, &run_clippy); + let commit_changes = commit_changes(&pr_number, &run_autofix); named::workflow() .run_name(format!("autofix PR #{pr_number}")) .on(Event::default().workflow_dispatch( - WorkflowDispatch::default().add_input(pr_number.name, pr_number.input()), + WorkflowDispatch::default() + .add_input(pr_number.name, pr_number.input()) + .add_input(run_clippy.name, run_clippy.input()), )) - .add_job(autofix.name, autofix.job) + .add_job(run_autofix.name.clone(), run_autofix.job) + .add_job(commit_changes.name, commit_changes.job) } -fn run_autofix(pr_number: &WorkflowInput) -> NamedJob { - fn authenticate_as_zippy() -> (Step, StepOutput) { - let step = named::uses( +const PATCH_ARTIFACT_NAME: &str = "autofix-patch"; +const PATCH_FILE_PATH: &str = "autofix.patch"; + +fn upload_patch_artifact() -> Step { + Step::new(format!("upload artifact {}", PATCH_ARTIFACT_NAME)) + .uses( "actions", - "create-github-app-token", - "bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1", + "upload-artifact", + "330a01c490aca151604b8cf639adc76d48f6c5d4", // v5 ) - .add_with(("app-id", vars::ZED_ZIPPY_APP_ID)) - .add_with(("private-key", vars::ZED_ZIPPY_APP_PRIVATE_KEY)) - .id("get-app-token"); - let output = StepOutput::new(&step, "token"); - (step, output) - } + .add_with(("name", PATCH_ARTIFACT_NAME)) + .add_with(("path", PATCH_FILE_PATH)) + .add_with(("if-no-files-found", "ignore")) + .add_with(("retention-days", "1")) +} - fn checkout_pr(pr_number: &WorkflowInput, token: &StepOutput) -> Step { - named::bash(&format!("gh pr checkout {pr_number}")).add_env(("GITHUB_TOKEN", token)) +fn download_patch_artifact() -> Step { + named::uses( + "actions", + "download-artifact", + "018cc2cf5baa6db3ef3c5f8a56943fffe632ef53", // v6.0.0 + ) + .add_with(("name", PATCH_ARTIFACT_NAME)) +} + +fn run_autofix(pr_number: &WorkflowInput, run_clippy: &WorkflowInput) -> NamedJob { + fn checkout_pr(pr_number: &WorkflowInput) -> Step { + named::bash(&format!("gh pr checkout {pr_number}")) + .add_env(("GITHUB_TOKEN", vars::GITHUB_TOKEN)) } fn run_cargo_fmt() -> Step { @@ -49,16 +67,68 @@ fn run_autofix(pr_number: &WorkflowInput) -> NamedJob { named::bash("./script/prettier --write") } - fn commit_and_push(token: &StepOutput) -> Step { + fn create_patch() -> Step { named::bash(indoc::indoc! {r#" if git diff --quiet; then echo "No changes to commit" + echo "has_changes=false" >> "$GITHUB_OUTPUT" else - git add -A - git commit -m "Autofix" - git push + git diff > autofix.patch + echo "has_changes=true" >> "$GITHUB_OUTPUT" fi "#}) + .id("create-patch") + } + + named::job( + Job::default() + .runs_on(runners::LINUX_DEFAULT) + .outputs([( + "has_changes".to_owned(), + "${{ steps.create-patch.outputs.has_changes }}".to_owned(), + )]) + .add_step(steps::checkout_repo()) + .add_step(checkout_pr(pr_number)) + .add_step(steps::setup_cargo_config(runners::Platform::Linux)) + .add_step(steps::cache_rust_dependencies_namespace()) + .map(steps::install_linux_dependencies) + .add_step(steps::setup_pnpm()) + .add_step(run_prettier_fix()) + .add_step(run_cargo_fmt()) + .add_step(run_clippy_fix().if_condition(Expression::new(run_clippy.to_string()))) + .add_step(create_patch()) + .add_step(upload_patch_artifact()) + .add_step(steps::cleanup_cargo_config(runners::Platform::Linux)), + ) +} + +fn commit_changes(pr_number: &WorkflowInput, autofix_job: &NamedJob) -> NamedJob { + fn authenticate_as_zippy() -> (Step, StepOutput) { + let step = named::uses( + "actions", + "create-github-app-token", + "bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1", + ) + .add_with(("app-id", vars::ZED_ZIPPY_APP_ID)) + .add_with(("private-key", vars::ZED_ZIPPY_APP_PRIVATE_KEY)) + .id("get-app-token"); + let output = StepOutput::new(&step, "token"); + (step, output) + } + + fn checkout_pr(pr_number: &WorkflowInput, token: &StepOutput) -> Step { + named::bash(&format!("gh pr checkout {pr_number}")).add_env(("GITHUB_TOKEN", token)) + } + + fn apply_patch() -> Step { + named::bash("git apply autofix.patch") + } + + fn commit_and_push(token: &StepOutput) -> Step { + named::bash(indoc::indoc! {r#" + git commit -am "Autofix" + git push + "#}) .add_env(("GIT_COMMITTER_NAME", "Zed Zippy")) .add_env(( "GIT_COMMITTER_EMAIL", @@ -76,18 +146,17 @@ fn run_autofix(pr_number: &WorkflowInput) -> NamedJob { named::job( Job::default() - .runs_on(runners::LINUX_DEFAULT) + .runs_on(runners::LINUX_SMALL) + .needs(vec![autofix_job.name.clone()]) + .cond(Expression::new(format!( + "needs.{}.outputs.has_changes == 'true'", + autofix_job.name + ))) .add_step(authenticate) .add_step(steps::checkout_repo_with_token(&token)) .add_step(checkout_pr(pr_number, &token)) - .add_step(steps::setup_cargo_config(runners::Platform::Linux)) - .add_step(steps::cache_rust_dependencies_namespace()) - .map(steps::install_linux_dependencies) - .add_step(steps::setup_pnpm()) - .add_step(run_prettier_fix()) - .add_step(run_cargo_fmt()) - .add_step(run_clippy_fix()) - .add_step(commit_and_push(&token)) - .add_step(steps::cleanup_cargo_config(runners::Platform::Linux)), + .add_step(download_patch_artifact()) + .add_step(apply_patch()) + .add_step(commit_and_push(&token)), ) } From 6f5da5e34e85654a3c5d1328b8508d83fed91535 Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Tue, 16 Dec 2025 23:04:16 -0700 Subject: [PATCH 098/266] Fix NewWindow flicker by creating buffer synchronously (#44915) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #20613 Release Notes: - Fixed: New windows no longer flicker between "Open a file or project to get started" and an empty editor. --- When opening a new window (`cmd-shift-n`), the window rendered showing the empty state message before the editor was created, causing a visible flicker. **Changes:** - Modified `Workspace::new_local` to accept an optional `init` callback that executes inside the window build closure - The init callback runs within `cx.new` (the `build_root_view` closure), before `window.draw()` is called for the first render - Changed the NewWindow action handler to use `Project::create_local_buffer()` (synchronous) instead of `Editor::new_file()` (asynchronous) - Updated `open_new` to pass the editor creation callback to `new_local` - All other `new_local` call sites pass `None` to maintain existing behavior **Key Technical Detail:** The window creation sequence in `cx.open_window()` is: 1. `build_root_view` closure is called (creates workspace via `cx.new`) 2. `window.draw(cx)` is called (first render) 3. `open_window` returns The fix uses `Project::create_local_buffer()` which creates a buffer **synchronously** (returns `Entity` directly), rather than `Editor::new_file()` which is asynchronous (calls `project.create_buffer()` which returns a `Task`). The editor is created from this buffer inside the `cx.new` closure (step 1), ensuring it exists before step 2 renders the first frame. **Before:** ```rust let task = Workspace::new_local(Vec::new(), app_state, None, env, cx); cx.spawn(async move |cx| { let (workspace, _) = task.await?; // Window already drawn workspace.update(cx, |workspace, window, cx| { Editor::new_file(workspace, ...) // Async - editor not present for first render })?; }) ``` **After:** ```rust cx.open_window(options, { move |window, cx| { cx.new(|cx| { let mut workspace = Workspace::new(...); // Create buffer synchronously, then create editor if let Some(init) = init { init(&mut workspace, window, cx); // Uses create_local_buffer (sync) } workspace }) } })? ``` The editor is now part of the workspace before the window's first frame is rendered, eliminating the flicker.
Original prompt > > ---- > > *This section details on the original issue you should resolve* > > Opening a new window flickers before opening an empty buffer > ### Check for existing issues > > - [x] Completed > > ### Describe the bug / provide steps to reproduce it > > Opening a new window, with e.g. `cmd-shift-n`, flickers for a fraction of a second. The new window first shows the startup page, "Open a file or project to get started.". Then, a frame or two later, a new empty buffer opens. > > Not sure if I'm sensitive or something but these kinds of flashes can knock me out of focus/flow pretty easily. > > It'd be great to either have the empty buffer open from the first frame, or to have an option to simply not open that empty buffer when a new window is opened. > > ### Zed Version and System Specs > > Zed: v0.170.4 (Zed) > OS: macOS 14.6.1 > Memory: 36 GiB > Architecture: aarch64 > > ### If applicable, add screenshots or screencasts of the incorrect state / behavior > > https://github.com/user-attachments/assets/6d9ba791-8a02-4e13-857c-66a33eb0905b > > ### If applicable, attach your Zed.log file to this issue. > > N/A > > We should make sure that the window is created in the correct state, and not have an intermediate render before the editor opens. > > ## Comments on the Issue (you are @copilot in this section) > > > @ConradIrwin > Ugh, no. I don't believe I never noticed this before, but now I can't unsee it :s > > If you'd like to pair on this: https://cal.com/conradirwin/pairing, otherwise I'll see if I get around to it. > @ConradIrwin > Yeah... I wonder if that can be a preview tab or something. It's nice when you want it, but not so nice when you don't. > > Fixing this will also make zed-industries/zed#33334 feel much smoother. > @zelenenka > @robinplace do you maybe have an opportunity to test it with the latest stable version, 0.213.3? > >
- Fixes zed-industries/zed#23742 --- 💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more [Copilot coding agent tips](https://gh.io/copilot-coding-agent-tips) in the docs. --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: ConradIrwin <94272+ConradIrwin@users.noreply.github.com> Co-authored-by: Conrad Irwin --- crates/workspace/src/workspace.rs | 46 +++++++++++++++++++++++-------- crates/zed/src/zed.rs | 16 ++++++++++- 2 files changed, 50 insertions(+), 12 deletions(-) diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 5947cb1703b37017bf75bfe412603332b8d5016a..516dc867ae14f7138dff0a968e210e214d0beb29 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -1627,6 +1627,7 @@ impl Workspace { app_state: Arc, requesting_window: Option>, env: Option>, + init: Option) + Send>>, cx: &mut App, ) -> Task< anyhow::Result<( @@ -1734,6 +1735,12 @@ impl Workspace { ); workspace.centered_layout = centered_layout; + + // Call init callback to add items before window renders + if let Some(init) = init { + init(&mut workspace, window, cx); + } + workspace }); })?; @@ -1785,6 +1792,12 @@ impl Workspace { cx, ); workspace.centered_layout = centered_layout; + + // Call init callback to add items before window renders + if let Some(init) = init { + init(&mut workspace, window, cx); + } + workspace }) } @@ -2350,7 +2363,7 @@ impl Workspace { Task::ready(Ok(callback(self, window, cx))) } else { let env = self.project.read(cx).cli_environment(cx); - let task = Self::new_local(Vec::new(), self.app_state.clone(), None, env, cx); + let task = Self::new_local(Vec::new(), self.app_state.clone(), None, env, None, cx); cx.spawn_in(window, async move |_vh, cx| { let (workspace, _) = task.await?; workspace.update(cx, callback) @@ -7758,7 +7771,14 @@ pub fn join_channel( // no open workspaces, make one to show the error in (blergh) let (window_handle, _) = cx .update(|cx| { - Workspace::new_local(vec![], app_state.clone(), requesting_window, None, cx) + Workspace::new_local( + vec![], + app_state.clone(), + requesting_window, + None, + None, + cx, + ) })? .await?; @@ -7824,7 +7844,7 @@ pub async fn get_any_active_workspace( // find an existing workspace to focus and show call controls let active_window = activate_any_workspace_window(&mut cx); if active_window.is_none() { - cx.update(|cx| Workspace::new_local(vec![], app_state.clone(), None, None, cx))? + cx.update(|cx| Workspace::new_local(vec![], app_state.clone(), None, None, None, cx))? .await?; } activate_any_workspace_window(&mut cx).context("could not open zed") @@ -7991,6 +8011,7 @@ pub fn open_paths( app_state.clone(), open_options.replace_window, open_options.env, + None, cx, ) })? @@ -8035,14 +8056,17 @@ pub fn open_new( cx: &mut App, init: impl FnOnce(&mut Workspace, &mut Window, &mut Context) + 'static + Send, ) -> Task> { - let task = Workspace::new_local(Vec::new(), app_state, None, open_options.env, cx); - cx.spawn(async move |cx| { - let (workspace, opened_paths) = task.await?; - workspace.update(cx, |workspace, window, cx| { - if opened_paths.is_empty() { - init(workspace, window, cx) - } - })?; + let task = Workspace::new_local( + Vec::new(), + app_state, + None, + open_options.env, + Some(Box::new(init)), + cx, + ); + cx.spawn(async move |_cx| { + let (_workspace, _opened_paths) = task.await?; + // Init callback is called synchronously during workspace creation Ok(()) }) } diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index fc5e74a76905d1ea45fa8bad2df12e22a23122e3..d2764c5c334ba32730982fc55e80d6197de3a2aa 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -1111,7 +1111,21 @@ fn register_actions( cx, |workspace, window, cx| { cx.activate(true); - Editor::new_file(workspace, &Default::default(), window, cx) + // Create buffer synchronously to avoid flicker + let project = workspace.project().clone(); + let buffer = project.update(cx, |project, cx| { + project.create_local_buffer("", None, true, cx) + }); + let editor = cx.new(|cx| { + Editor::for_buffer(buffer, Some(project), window, cx) + }); + workspace.add_item_to_active_pane( + Box::new(editor), + None, + true, + window, + cx, + ); }, ) .detach(); From 949cbc2b185bbe0aa7a8d6429745265ee0f240ff Mon Sep 17 00:00:00 2001 From: tidely <43219534+tidely@users.noreply.github.com> Date: Wed, 17 Dec 2025 09:56:05 +0200 Subject: [PATCH 099/266] gpui: Remove intermediate allocations when reconstructing text from a `TextLayout` (#45037) Closes #ISSUE Remove some intermediate allocations when reconstructing text or wrapped text from a `TextLayout`. Currently creates a intermediate `Vec` which gets joined, when you could join an `impl Iterator` Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/gpui/src/elements/text.rs | 18 +++++++++++------- crates/markdown/src/markdown.rs | 9 ++++++--- 2 files changed, 17 insertions(+), 10 deletions(-) diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs index 914e8a286510a2ffd833db4c4d3ef85c84db073f..1b1bfd778c7bc746c67551eb31cf70f60b1485ea 100644 --- a/crates/gpui/src/elements/text.rs +++ b/crates/gpui/src/elements/text.rs @@ -6,6 +6,7 @@ use crate::{ register_tooltip_mouse_handlers, set_tooltip_on_window, }; use anyhow::Context as _; +use itertools::Itertools; use smallvec::SmallVec; use std::{ borrow::Cow, @@ -597,14 +598,14 @@ impl TextLayout { .unwrap() .lines .iter() - .map(|s| s.text.to_string()) - .collect::>() + .map(|s| &s.text) .join("\n") } /// The text for this layout (with soft-wraps as newlines) pub fn wrapped_text(&self) -> String { - let mut lines = Vec::new(); + let mut accumulator = String::new(); + for wrapped in self.0.borrow().as_ref().unwrap().lines.iter() { let mut seen = 0; for boundary in wrapped.layout.wrap_boundaries.iter() { @@ -612,13 +613,16 @@ impl TextLayout { [boundary.glyph_ix] .index; - lines.push(wrapped.text[seen..index].to_string()); + accumulator.push_str(&wrapped.text[seen..index]); + accumulator.push('\n'); seen = index; } - lines.push(wrapped.text[seen..].to_string()); + accumulator.push_str(&wrapped.text[seen..]); + accumulator.push('\n'); } - - lines.join("\n") + // Remove trailing newline + accumulator.pop(); + accumulator } } diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index 536d9fd6a2439e9b23b9f99d20a4aff425eda956..3654418e419bb58f5c9c29ac1baf7172a423156f 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -1919,7 +1919,7 @@ impl RenderedText { } fn text_for_range(&self, range: Range) -> String { - let mut ret = vec![]; + let mut accumulator = String::new(); for line in self.lines.iter() { if range.start > line.source_end { @@ -1944,9 +1944,12 @@ impl RenderedText { } .min(text.len()); - ret.push(text[start..end].to_string()); + accumulator.push_str(&text[start..end]); + accumulator.push('\n'); } - ret.join("\n") + // Remove trailing newline + accumulator.pop(); + accumulator } fn link_for_position(&self, position: Point) -> Option<&RenderedLink> { From 280864e7f260e43de186d77ad7119942f37f5562 Mon Sep 17 00:00:00 2001 From: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> Date: Wed, 17 Dec 2025 08:59:27 +0100 Subject: [PATCH 100/266] remote: Support IPv6 when using SSH (#43591) Closes #33650 Release Notes: - Added support for remote connections over IPv6 --------- Signed-off-by: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> --- .../recent_projects/src/remote_connections.rs | 4 +- crates/recent_projects/src/remote_servers.rs | 8 +- crates/remote/src/remote_client.rs | 6 +- crates/remote/src/transport/ssh.rs | 171 ++++++++++++++---- crates/workspace/src/persistence.rs | 20 +- 5 files changed, 159 insertions(+), 50 deletions(-) diff --git a/crates/recent_projects/src/remote_connections.rs b/crates/recent_projects/src/remote_connections.rs index be40df4d1c80c3a1dda7c3f8fdfa370bc231bbfb..1c6da9b82a9a661307fd5eec1cd647ceb6c292bb 100644 --- a/crates/recent_projects/src/remote_connections.rs +++ b/crates/recent_projects/src/remote_connections.rs @@ -52,7 +52,7 @@ impl SshSettings { pub fn fill_connection_options_from_settings(&self, options: &mut SshConnectionOptions) { for conn in self.ssh_connections() { - if conn.host == options.host + if conn.host == options.host.to_string() && conn.username == options.username && conn.port == options.port { @@ -72,7 +72,7 @@ impl SshSettings { username: Option, ) -> SshConnectionOptions { let mut options = SshConnectionOptions { - host, + host: host.into(), port, username, ..Default::default() diff --git a/crates/recent_projects/src/remote_servers.rs b/crates/recent_projects/src/remote_servers.rs index 84cc216805897d81ee8d7cbba3b0f6d8a66cbdf9..a4388c6026ab7aa6bbdfc75d025e095b5a2a6187 100644 --- a/crates/recent_projects/src/remote_servers.rs +++ b/crates/recent_projects/src/remote_servers.rs @@ -1518,7 +1518,7 @@ impl RemoteServerProjects { .ssh_connections .get_or_insert(Default::default()) .push(SshConnection { - host: SharedString::from(connection_options.host), + host: SharedString::from(connection_options.host.to_string()), username: connection_options.username, port: connection_options.port, projects: BTreeSet::new(), @@ -1983,7 +1983,7 @@ impl RemoteServerProjects { .size_full() .child(match &options { ViewServerOptionsState::Ssh { connection, .. } => SshConnectionHeader { - connection_string: connection.host.clone().into(), + connection_string: connection.host.to_string().into(), paths: Default::default(), nickname: connection.nickname.clone().map(|s| s.into()), is_wsl: false, @@ -2148,7 +2148,7 @@ impl RemoteServerProjects { window: &mut Window, cx: &mut Context, ) -> impl IntoElement { - let connection_string = SharedString::new(connection.host.clone()); + let connection_string = SharedString::new(connection.host.to_string()); v_flex() .child({ @@ -2659,7 +2659,7 @@ impl RemoteServerProjects { self.add_ssh_server( SshConnectionOptions { - host: ssh_config_host.to_string(), + host: ssh_config_host.to_string().into(), ..SshConnectionOptions::default() }, cx, diff --git a/crates/remote/src/remote_client.rs b/crates/remote/src/remote_client.rs index e8fa4fe4a3e727e823fc5912ddf3e940adf0f78f..9c6508e5f16027eb23225f0eceb1cb691f4a33c9 100644 --- a/crates/remote/src/remote_client.rs +++ b/crates/remote/src/remote_client.rs @@ -921,10 +921,12 @@ impl RemoteClient { client_cx: &mut gpui::TestAppContext, server_cx: &mut gpui::TestAppContext, ) -> (RemoteConnectionOptions, AnyProtoClient) { + use crate::transport::ssh::SshConnectionHost; + let port = client_cx .update(|cx| cx.default_global::().connections.len() as u16 + 1); let opts = RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: "".to_string(), + host: SshConnectionHost::from("".to_string()), port: Some(port), ..Default::default() }); @@ -1089,7 +1091,7 @@ pub enum RemoteConnectionOptions { impl RemoteConnectionOptions { pub fn display_name(&self) -> String { match self { - RemoteConnectionOptions::Ssh(opts) => opts.host.clone(), + RemoteConnectionOptions::Ssh(opts) => opts.host.to_string(), RemoteConnectionOptions::Wsl(opts) => opts.distro_name.clone(), RemoteConnectionOptions::Docker(opts) => opts.name.clone(), } diff --git a/crates/remote/src/transport/ssh.rs b/crates/remote/src/transport/ssh.rs index c445c0565837d33dc044087fc53e6573e06ee54c..37921b88637f19b68f9625170d9d99e85b5a9bdf 100644 --- a/crates/remote/src/transport/ssh.rs +++ b/crates/remote/src/transport/ssh.rs @@ -23,6 +23,7 @@ use smol::{ process::{self, Child, Stdio}, }; use std::{ + net::IpAddr, path::{Path, PathBuf}, sync::Arc, time::Instant, @@ -47,9 +48,58 @@ pub(crate) struct SshRemoteConnection { _temp_dir: TempDir, } +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum SshConnectionHost { + IpAddr(IpAddr), + Hostname(String), +} + +impl SshConnectionHost { + pub fn to_bracketed_string(&self) -> String { + match self { + Self::IpAddr(IpAddr::V4(ip)) => ip.to_string(), + Self::IpAddr(IpAddr::V6(ip)) => format!("[{}]", ip), + Self::Hostname(hostname) => hostname.clone(), + } + } + + pub fn to_string(&self) -> String { + match self { + Self::IpAddr(ip) => ip.to_string(), + Self::Hostname(hostname) => hostname.clone(), + } + } +} + +impl From<&str> for SshConnectionHost { + fn from(value: &str) -> Self { + if let Ok(address) = value.parse() { + Self::IpAddr(address) + } else { + Self::Hostname(value.to_string()) + } + } +} + +impl From for SshConnectionHost { + fn from(value: String) -> Self { + if let Ok(address) = value.parse() { + Self::IpAddr(address) + } else { + Self::Hostname(value) + } + } +} + +impl Default for SshConnectionHost { + fn default() -> Self { + Self::Hostname(Default::default()) + } +} + #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)] pub struct SshConnectionOptions { - pub host: String, + pub host: SshConnectionHost, pub username: Option, pub port: Option, pub password: Option, @@ -64,7 +114,7 @@ pub struct SshConnectionOptions { impl From for SshConnectionOptions { fn from(val: settings::SshConnection) -> Self { SshConnectionOptions { - host: val.host.into(), + host: val.host.to_string().into(), username: val.username, port: val.port, password: None, @@ -96,7 +146,7 @@ impl MasterProcess { askpass_script_path: &std::ffi::OsStr, additional_args: Vec, socket_path: &std::path::Path, - url: &str, + destination: &str, ) -> Result { let args = [ "-N", @@ -120,7 +170,7 @@ impl MasterProcess { master_process.arg(format!("ControlPath={}", socket_path.display())); - let process = master_process.arg(&url).spawn()?; + let process = master_process.arg(&destination).spawn()?; Ok(MasterProcess { process }) } @@ -143,7 +193,7 @@ impl MasterProcess { pub fn new( askpass_script_path: &std::ffi::OsStr, additional_args: Vec, - url: &str, + destination: &str, ) -> Result { // On Windows, `ControlMaster` and `ControlPath` are not supported: // https://github.com/PowerShell/Win32-OpenSSH/issues/405 @@ -165,7 +215,7 @@ impl MasterProcess { .env("SSH_ASKPASS_REQUIRE", "force") .env("SSH_ASKPASS", askpass_script_path) .args(additional_args) - .arg(url) + .arg(destination) .args(args); let process = master_process.spawn()?; @@ -412,7 +462,7 @@ impl SshRemoteConnection { ) -> Result { use askpass::AskPassResult; - let url = connection_options.ssh_url(); + let destination = connection_options.ssh_destination(); let temp_dir = tempfile::Builder::new() .prefix("zed-ssh-session") @@ -437,14 +487,14 @@ impl SshRemoteConnection { let mut master_process = MasterProcess::new( askpass.script_path().as_ref(), connection_options.additional_args(), - &url, + &destination, )?; #[cfg(not(target_os = "windows"))] let mut master_process = MasterProcess::new( askpass.script_path().as_ref(), connection_options.additional_args(), &socket_path, - &url, + &destination, )?; let result = select_biased! { @@ -840,7 +890,7 @@ impl SshRemoteConnection { } command.arg(src_path).arg(format!( "{}:{}", - self.socket.connection_options.scp_url(), + self.socket.connection_options.scp_destination(), dest_path_str )); command @@ -856,7 +906,7 @@ impl SshRemoteConnection { .unwrap_or_default(), ); command.arg("-b").arg("-"); - command.arg(self.socket.connection_options.scp_url()); + command.arg(self.socket.connection_options.scp_destination()); command.stdin(Stdio::piped()); command } @@ -986,7 +1036,7 @@ impl SshSocket { let separator = shell_kind.sequential_commands_separator(); let to_run = format!("cd{separator} {to_run}"); self.ssh_options(&mut command, true) - .arg(self.connection_options.ssh_url()); + .arg(self.connection_options.ssh_destination()); if !allow_pseudo_tty { command.arg("-T"); } @@ -1063,7 +1113,7 @@ impl SshSocket { "ControlMaster=no".to_string(), "-o".to_string(), format!("ControlPath={}", self.socket_path.display()), - self.connection_options.ssh_url(), + self.connection_options.ssh_destination(), ]); arguments } @@ -1071,7 +1121,7 @@ impl SshSocket { #[cfg(target_os = "windows")] fn ssh_args(&self) -> Vec { let mut arguments = self.connection_options.additional_args(); - arguments.push(self.connection_options.ssh_url()); + arguments.push(self.connection_options.ssh_destination()); arguments } @@ -1208,10 +1258,24 @@ impl SshConnectionOptions { input = rest; username = Some(u.to_string()); } - if let Some((rest, p)) = input.split_once(':') { + + // Handle port parsing, accounting for IPv6 addresses + // IPv6 addresses can be: 2001:db8::1 or [2001:db8::1]:22 + if input.starts_with('[') { + if let Some((rest, p)) = input.rsplit_once("]:") { + input = rest.strip_prefix('[').unwrap_or(rest); + port = p.parse().ok(); + } else if input.ends_with(']') { + input = input.strip_prefix('[').unwrap_or(input); + input = input.strip_suffix(']').unwrap_or(input); + } + } else if let Some((rest, p)) = input.rsplit_once(':') + && !rest.contains(":") + { input = rest; - port = p.parse().ok() + port = p.parse().ok(); } + hostname = Some(input.to_string()) } @@ -1225,7 +1289,7 @@ impl SshConnectionOptions { }; Ok(Self { - host: hostname, + host: hostname.into(), username, port, port_forwards, @@ -1237,19 +1301,16 @@ impl SshConnectionOptions { }) } - pub fn ssh_url(&self) -> String { - let mut result = String::from("ssh://"); + pub fn ssh_destination(&self) -> String { + let mut result = String::default(); if let Some(username) = &self.username { // Username might be: username1@username2@ip2 let username = urlencoding::encode(username); result.push_str(&username); result.push('@'); } - result.push_str(&self.host); - if let Some(port) = self.port { - result.push(':'); - result.push_str(&port.to_string()); - } + + result.push_str(&self.host.to_string()); result } @@ -1264,6 +1325,11 @@ impl SshConnectionOptions { args.extend(["-o".to_string(), format!("ConnectTimeout={}", timeout)]); } + if let Some(port) = self.port { + args.push("-p".to_string()); + args.push(port.to_string()); + } + if let Some(forwards) = &self.port_forwards { args.extend(forwards.iter().map(|pf| { let local_host = match &pf.local_host { @@ -1285,22 +1351,23 @@ impl SshConnectionOptions { args } - fn scp_url(&self) -> String { + fn scp_destination(&self) -> String { if let Some(username) = &self.username { - format!("{}@{}", username, self.host) + format!("{}@{}", username, self.host.to_bracketed_string()) } else { - self.host.clone() + self.host.to_string() } } pub fn connection_string(&self) -> String { - let host = if let Some(username) = &self.username { - format!("{}@{}", username, self.host) + let host = if let Some(port) = &self.port { + format!("{}:{}", self.host.to_bracketed_string(), port) } else { - self.host.clone() + self.host.to_string() }; - if let Some(port) = &self.port { - format!("{}:{}", host, port) + + if let Some(username) = &self.username { + format!("{}@{}", username, host) } else { host } @@ -1510,4 +1577,44 @@ mod tests { ] ); } + + #[test] + fn test_host_parsing() -> Result<()> { + let opts = SshConnectionOptions::parse_command_line("user@2001:db8::1")?; + assert_eq!(opts.host, "2001:db8::1".into()); + assert_eq!(opts.username, Some("user".to_string())); + assert_eq!(opts.port, None); + + let opts = SshConnectionOptions::parse_command_line("user@[2001:db8::1]:2222")?; + assert_eq!(opts.host, "2001:db8::1".into()); + assert_eq!(opts.username, Some("user".to_string())); + assert_eq!(opts.port, Some(2222)); + + let opts = SshConnectionOptions::parse_command_line("user@[2001:db8::1]")?; + assert_eq!(opts.host, "2001:db8::1".into()); + assert_eq!(opts.username, Some("user".to_string())); + assert_eq!(opts.port, None); + + let opts = SshConnectionOptions::parse_command_line("2001:db8::1")?; + assert_eq!(opts.host, "2001:db8::1".into()); + assert_eq!(opts.username, None); + assert_eq!(opts.port, None); + + let opts = SshConnectionOptions::parse_command_line("[2001:db8::1]:2222")?; + assert_eq!(opts.host, "2001:db8::1".into()); + assert_eq!(opts.username, None); + assert_eq!(opts.port, Some(2222)); + + let opts = SshConnectionOptions::parse_command_line("user@example.com:2222")?; + assert_eq!(opts.host, "example.com".into()); + assert_eq!(opts.username, Some("user".to_string())); + assert_eq!(opts.port, Some(2222)); + + let opts = SshConnectionOptions::parse_command_line("user@192.168.1.1:2222")?; + assert_eq!(opts.host, "192.168.1.1".into()); + assert_eq!(opts.username, Some("user".to_string())); + assert_eq!(opts.port, Some(2222)); + + Ok(()) + } } diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index 4a8aab364db3ec37f7f089b8dc3df4ca1114ee28..a992a9e1a20d1346a0c201afd72bb51327f00381 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -1273,7 +1273,7 @@ impl WorkspaceDb { match options { RemoteConnectionOptions::Ssh(options) => { kind = RemoteConnectionKind::Ssh; - host = Some(options.host); + host = Some(options.host.to_string()); port = options.port; user = options.username; } @@ -1486,7 +1486,7 @@ impl WorkspaceDb { user: user, })), RemoteConnectionKind::Ssh => Some(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host?, + host: host?.into(), port, username: user, ..Default::default() @@ -2757,7 +2757,7 @@ mod tests { let connection_id = db .get_or_create_remote_connection(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: "my-host".to_string(), + host: "my-host".into(), port: Some(1234), ..Default::default() })) @@ -2946,7 +2946,7 @@ mod tests { .into_iter() .map(|(host, user)| async { let options = RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host.to_string(), + host: host.into(), username: Some(user.to_string()), ..Default::default() }); @@ -3037,7 +3037,7 @@ mod tests { let connection_id = db .get_or_create_remote_connection(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host.clone(), + host: host.clone().into(), port, username: user.clone(), ..Default::default() @@ -3048,7 +3048,7 @@ mod tests { // Test that calling the function again with the same parameters returns the same project let same_connection = db .get_or_create_remote_connection(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host.clone(), + host: host.clone().into(), port, username: user.clone(), ..Default::default() @@ -3065,7 +3065,7 @@ mod tests { let different_connection = db .get_or_create_remote_connection(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host2.clone(), + host: host2.clone().into(), port: port2, username: user2.clone(), ..Default::default() @@ -3084,7 +3084,7 @@ mod tests { let connection_id = db .get_or_create_remote_connection(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host.clone(), + host: host.clone().into(), port, username: None, ..Default::default() @@ -3094,7 +3094,7 @@ mod tests { let same_connection_id = db .get_or_create_remote_connection(RemoteConnectionOptions::Ssh(SshConnectionOptions { - host: host.clone(), + host: host.clone().into(), port, username: user.clone(), ..Default::default() @@ -3124,7 +3124,7 @@ mod tests { ids.push( db.get_or_create_remote_connection(RemoteConnectionOptions::Ssh( SshConnectionOptions { - host: host.clone(), + host: host.clone().into(), port: *port, username: user.clone(), ..Default::default() From edcde6d90c4a82a3ab64dda91e56bafaded28bc5 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Wed, 17 Dec 2025 09:28:59 +0100 Subject: [PATCH 101/266] Fix semantic merge conflict (#45078) Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/project/src/trusted_worktrees.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rs index d9f5d4a7a43d8cb8b8220f4d3de8ca35d366a8f5..9f849ceaf1db62c1a88e269565e95bc97bc56011 100644 --- a/crates/project/src/trusted_worktrees.rs +++ b/crates/project/src/trusted_worktrees.rs @@ -223,7 +223,7 @@ impl From for RemoteHostLocation { let (user_name, host_name) = match options { RemoteConnectionOptions::Ssh(ssh) => ( ssh.username.map(SharedString::new), - SharedString::new(ssh.host), + SharedString::new(ssh.host.to_string()), ), RemoteConnectionOptions::Wsl(wsl) => ( wsl.user.map(SharedString::new), From 25b89dd8e91dde4e9525bae81aec2994613366f9 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Wed, 17 Dec 2025 09:43:34 +0100 Subject: [PATCH 102/266] workspace: Don't debug display paths to users in trust popup (#45079) On windows this will render two backslashes otherwise Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/workspace/src/security_modal.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs index 44242a3588017aabf117300310dd10a4a28b292f..1b5509d4d64e5b1377c9675fb49d2981e8173668 100644 --- a/crates/workspace/src/security_modal.rs +++ b/crates/workspace/src/security_modal.rs @@ -265,8 +265,8 @@ impl SecurityModal { } } 1 => Some(Cow::Owned(format!( - "Trust all projects in the {:?} folder", - self.shorten_path(available_parents[0]) + "Trust all projects in the {:} folder", + self.shorten_path(available_parents[0]).display() ))), _ => Some(Cow::Borrowed("Trust all projects in the parent folders")), } From 79e2e520128e4d08f159e1cec9d01d5c387aafad Mon Sep 17 00:00:00 2001 From: Mayank Verma Date: Wed, 17 Dec 2025 14:29:29 +0530 Subject: [PATCH 103/266] project: Clear stale settings when switching remote projects (#45021) Closes #44898 Release Notes: - Fixed stale settings persisting when switching remote projects --- crates/project/src/project.rs | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index bbf91eb3c18a53f32f48f1a044c991bf5cfd9fdf..9152096508b76d34fe3b2209cba94b4755b6ac67 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -2483,13 +2483,11 @@ impl Project { cx: &mut Context, ) -> Result<()> { cx.update_global::(|store, cx| { - self.worktree_store.update(cx, |worktree_store, cx| { - for worktree in worktree_store.worktrees() { - store - .clear_local_settings(worktree.read(cx).id(), cx) - .log_err(); - } - }); + for worktree_metadata in &message.worktrees { + store + .clear_local_settings(WorktreeId::from_proto(worktree_metadata.id), cx) + .log_err(); + } }); self.join_project_response_message_id = message_id; @@ -4729,6 +4727,14 @@ impl Project { this.update(&mut cx, |this, cx| { // Don't handle messages that were sent before the response to us joining the project if envelope.message_id > this.join_project_response_message_id { + cx.update_global::(|store, cx| { + for worktree_metadata in &envelope.payload.worktrees { + store + .clear_local_settings(WorktreeId::from_proto(worktree_metadata.id), cx) + .log_err(); + } + }); + this.set_worktrees_from_proto(envelope.payload.worktrees, cx)?; } Ok(()) From c5b3b06b94f455383e736d163b181fc37eda7207 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Wed, 17 Dec 2025 10:04:10 +0100 Subject: [PATCH 104/266] python: Fetch non pre-release versions of `ty` (#45080) 0.0.2 is not a pre-release artifact unlike the previous one, so our version fetch ignored it. Fixes https://github.com/zed-industries/zed/issues/45061 Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/languages/src/python.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs index fbdeb59b7f15a22d4f4097a3b0e60b4aeb9bf202..b987d059ccaf53126e427a36c4f598817acd63de 100644 --- a/crates/languages/src/python.rs +++ b/crates/languages/src/python.rs @@ -280,7 +280,7 @@ impl LspInstaller for TyLspAdapter { _: &mut AsyncApp, ) -> Result { let release = - latest_github_release("astral-sh/ty", true, true, delegate.http_client()).await?; + latest_github_release("astral-sh/ty", true, false, delegate.http_client()).await?; let (_, asset_name) = Self::build_asset_name()?; let asset = release .assets From 637ff342545523e66f2e2964e6c16fdeaa227dee Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Wed, 17 Dec 2025 10:17:45 +0100 Subject: [PATCH 105/266] Fix editor hang when positioned above viewport (#45077) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes the hang introduced in #44995 (which was reverted in #45011) and re-enables the optimization. ## Background PR #44995 introduced an optimization to skip rendering lines that are clipped by parent containers (e.g., when a large AutoHeight editor is inside a scrollable List). This significantly improved performance for large diffs in the Agent Panel. However, #45011 reverted this change because it caused the main thread to hang for 100+ seconds in certain scenarios, requiring a force quit to recover. ## Root Cause The original analysis in #45011 suggested that visible_bounds wasn’t being intersected properly, but that was incorrect—the intersection via with_content_mask works correctly. The actual bug: when an editor is positioned above the visible viewport (e.g., scrolled past in a List), the clipping calculation produces a start_row that exceeds max_row: 1. Editor’s bounds.origin.y becomes very negative (e.g., -10000px) 2. After intersection, visible_bounds.origin.y is at the viewport top (e.g., 0) 3. clipped_top_in_lines = (0 - (-10000)) / line_height = huge number 4. start_row = huge number, but end_row is clamped to max_row 5. This creates an invalid range where start_row > end_row This caused two different failures depending on build mode: - Debug mode: Panic from subtraction overflow in Range::len() - Release mode: Integer wraparound causing blocks_in_range to enter an infinite loop (the 100+ second hang) ## Fix Simply clamp start_row to max_row, ensuring the row range is always valid: ```rs let start_row = cmp::min( DisplayRow((scroll_position.y + clipped_top_in_lines).floor() as u32), max_row, ); ``` ## Testing Added a regression test that draws an editor at y=-10000 to simulate an editor that’s been scrolled past in a List. This would panic in debug mode (and hang in release mode) before the fix. Release Notes: - Improved agent panel performance when rendering large diffs. --- crates/editor/src/editor_tests.rs | 35 +++++++++++++++++++++++++++++++ crates/editor/src/element.rs | 19 +++++++++++++++-- crates/editor/src/test.rs | 8 +++---- 3 files changed, 55 insertions(+), 7 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 84d3837d1cb516b6f70f6998ce588beed9bd9804..be72cd347beda25b92525842d1f94e5ae18fa15f 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -29530,3 +29530,38 @@ async fn test_local_worktree_trust(cx: &mut TestAppContext) { trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); assert!(can_trust_after, "worktree should be trusted after trust()"); } + +#[gpui::test] +fn test_editor_rendering_when_positioned_above_viewport(cx: &mut TestAppContext) { + // This test reproduces a bug where drawing an editor at a position above the viewport + // (simulating what happens when an AutoHeight editor inside a List is scrolled past) + // causes an infinite loop in blocks_in_range. + // + // The issue: when the editor's bounds.origin.y is very negative (above the viewport), + // the content mask intersection produces visible_bounds with origin at the viewport top. + // This makes clipped_top_in_lines very large, causing start_row to exceed max_row. + // When blocks_in_range is called with start_row > max_row, the cursor seeks to the end + // but the while loop after seek never terminates because cursor.next() is a no-op at end. + init_test(cx, |_| {}); + + let window = cx.add_window(|_, _| gpui::Empty); + let mut cx = VisualTestContext::from_window(*window, cx); + + let buffer = cx.update(|_, cx| MultiBuffer::build_simple("a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n", cx)); + let editor = cx.new_window_entity(|window, cx| build_editor(buffer, window, cx)); + + // Simulate a small viewport (500x500 pixels at origin 0,0) + cx.simulate_resize(gpui::size(px(500.), px(500.))); + + // Draw the editor at a very negative Y position, simulating an editor that's been + // scrolled way above the visible viewport (like in a List that has scrolled past it). + // The editor is 3000px tall but positioned at y=-10000, so it's entirely above the viewport. + // This should NOT hang - it should just render nothing. + cx.draw( + gpui::point(px(0.), px(-10000.)), + gpui::size(px(500.), px(3000.)), + |_, _| editor.clone(), + ); + + // If we get here without hanging, the test passes +} diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 8de660275ba9b455aec610568c41347888654495..85b32324a1c1cc7fb84162fb120e8ef0e4e8b599 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -9164,6 +9164,15 @@ impl Element for EditorElement { let height_in_lines = f64::from(bounds.size.height / line_height); let max_row = snapshot.max_point().row().as_f64(); + // Calculate how much of the editor is clipped by parent containers (e.g., List). + // This allows us to only render lines that are actually visible, which is + // critical for performance when large AutoHeight editors are inside Lists. + let visible_bounds = window.content_mask().bounds; + let clipped_top = (visible_bounds.origin.y - bounds.origin.y).max(px(0.)); + let clipped_top_in_lines = f64::from(clipped_top / line_height); + let visible_height_in_lines = + f64::from(visible_bounds.size.height / line_height); + // The max scroll position for the top of the window let max_scroll_top = if matches!( snapshot.mode, @@ -9220,10 +9229,16 @@ impl Element for EditorElement { let mut scroll_position = snapshot.scroll_position(); // The scroll position is a fractional point, the whole number of which represents // the top of the window in terms of display rows. - let start_row = DisplayRow(scroll_position.y as u32); + // We add clipped_top_in_lines to skip rows that are clipped by parent containers, + // but we don't modify scroll_position itself since the parent handles positioning. let max_row = snapshot.max_point().row(); + let start_row = cmp::min( + DisplayRow((scroll_position.y + clipped_top_in_lines).floor() as u32), + max_row, + ); let end_row = cmp::min( - (scroll_position.y + height_in_lines).ceil() as u32, + (scroll_position.y + clipped_top_in_lines + visible_height_in_lines).ceil() + as u32, max_row.next_row().0, ); let end_row = DisplayRow(end_row); diff --git a/crates/editor/src/test.rs b/crates/editor/src/test.rs index 5a0652bdd199a638f92234b1d50232071db18e07..1cc619385446502db6a3a0dceb6e70fa4b4e8416 100644 --- a/crates/editor/src/test.rs +++ b/crates/editor/src/test.rs @@ -176,11 +176,9 @@ pub fn block_content_for_tests( } pub fn editor_content_with_blocks(editor: &Entity, cx: &mut VisualTestContext) -> String { - cx.draw( - gpui::Point::default(), - size(px(3000.0), px(3000.0)), - |_, _| editor.clone(), - ); + let draw_size = size(px(3000.0), px(3000.0)); + cx.simulate_resize(draw_size); + cx.draw(gpui::Point::default(), draw_size, |_, _| editor.clone()); let (snapshot, mut lines, blocks) = editor.update_in(cx, |editor, window, cx| { let snapshot = editor.snapshot(window, cx); let text = editor.display_text(cx); From a7bab0b0506845a9d67d92319b513a16cd7647cd Mon Sep 17 00:00:00 2001 From: Jeff Brennan <42007840+jeffbrennan@users.noreply.github.com> Date: Wed, 17 Dec 2025 05:10:39 -0500 Subject: [PATCH 106/266] language: Fix auto-indentation for Python code blocks in Markdown (#43853) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #43722 Release Notes: - Fixed an issue where auto-indentation didn’t work correctly for Python code blocks in Markdown. --------- Co-authored-by: Smit Barmase --- crates/editor/src/editor_tests.rs | 42 +++++++++++++++++++++++++++++++ crates/language/src/buffer.rs | 35 ++++++++++++++++++-------- 2 files changed, 67 insertions(+), 10 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index be72cd347beda25b92525842d1f94e5ae18fa15f..bac3d12638a23bc54f4a981b874da35b77894fff 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -25972,6 +25972,48 @@ async fn test_indent_on_newline_for_python(cx: &mut TestAppContext) { "}); } +#[gpui::test] +async fn test_python_indent_in_markdown(cx: &mut TestAppContext) { + init_test(cx, |_| {}); + + let language_registry = Arc::new(language::LanguageRegistry::test(cx.executor())); + let python_lang = languages::language("python", tree_sitter_python::LANGUAGE.into()); + language_registry.add(markdown_lang()); + language_registry.add(python_lang); + + let mut cx = EditorTestContext::new(cx).await; + cx.update_buffer(|buffer, cx| { + buffer.set_language_registry(language_registry); + buffer.set_language(Some(markdown_lang()), cx); + }); + + // Test that `else:` correctly outdents to match `if:` inside the Python code block + cx.set_state(indoc! {" + # Heading + + ```python + def main(): + if condition: + pass + ˇ + ``` + "}); + cx.update_editor(|editor, window, cx| { + editor.handle_input("else:", window, cx); + }); + cx.run_until_parked(); + cx.assert_editor_state(indoc! {" + # Heading + + ```python + def main(): + if condition: + pass + else:ˇ + ``` + "}); +} + #[gpui::test] async fn test_tab_in_leading_whitespace_auto_indents_for_bash(cx: &mut TestAppContext) { init_test(cx, |_| {}); diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 2a9b4ea1df4fc0b4772586f0e51016cdd1882722..39003773f83718c6c61d4cfda55b9528f7c6eb2a 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -3216,6 +3216,7 @@ impl BufferSnapshot { struct StartPosition { start: Point, suffix: SharedString, + language: Arc, } // Find the suggested indentation ranges based on the syntax tree. @@ -3259,6 +3260,7 @@ impl BufferSnapshot { start_positions.push(StartPosition { start: Point::from_ts_point(capture.node.start_position()), suffix: suffix.clone(), + language: mat.language.clone(), }); } } @@ -3319,7 +3321,7 @@ impl BufferSnapshot { // Find the suggested indentation increases and decreased based on regexes. let mut regex_outdent_map = HashMap::default(); - let mut last_seen_suffix: HashMap> = HashMap::default(); + let mut last_seen_suffix: HashMap> = HashMap::default(); let mut start_positions_iter = start_positions.iter().peekable(); let mut indent_change_rows = Vec::<(u32, Ordering)>::new(); @@ -3327,14 +3329,21 @@ impl BufferSnapshot { Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0) ..Point::new(row_range.end, 0), |row, line| { - if config + let indent_len = self.indent_size_for_line(row).len; + let row_language = self.language_at(Point::new(row, indent_len)).cloned(); + let row_language_config = row_language + .as_ref() + .map(|lang| lang.config()) + .unwrap_or(config); + + if row_language_config .decrease_indent_pattern .as_ref() .is_some_and(|regex| regex.is_match(line)) { indent_change_rows.push((row, Ordering::Less)); } - if config + if row_language_config .increase_indent_pattern .as_ref() .is_some_and(|regex| regex.is_match(line)) @@ -3343,16 +3352,16 @@ impl BufferSnapshot { } while let Some(pos) = start_positions_iter.peek() { if pos.start.row < row { - let pos = start_positions_iter.next().unwrap(); + let pos = start_positions_iter.next().unwrap().clone(); last_seen_suffix .entry(pos.suffix.to_string()) .or_default() - .push(pos.start); + .push(pos); } else { break; } } - for rule in &config.decrease_indent_patterns { + for rule in &row_language_config.decrease_indent_patterns { if rule.pattern.as_ref().is_some_and(|r| r.is_match(line)) { let row_start_column = self.indent_size_for_line(row).len; let basis_row = rule @@ -3360,10 +3369,16 @@ impl BufferSnapshot { .iter() .filter_map(|valid_suffix| last_seen_suffix.get(valid_suffix)) .flatten() - .filter(|start_point| start_point.column <= row_start_column) - .max_by_key(|start_point| start_point.row); - if let Some(outdent_to_row) = basis_row { - regex_outdent_map.insert(row, outdent_to_row.row); + .filter(|pos| { + row_language + .as_ref() + .or(self.language.as_ref()) + .is_some_and(|lang| Arc::ptr_eq(lang, &pos.language)) + }) + .filter(|pos| pos.start.column <= row_start_column) + .max_by_key(|pos| pos.start.row); + if let Some(outdent_to) = basis_row { + regex_outdent_map.insert(row, outdent_to.start.row); } break; } From 93246163c677d226e184606f3782f54edccc7fc2 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 17 Dec 2025 05:20:43 -0500 Subject: [PATCH 107/266] git: Fix deletion icon button in branch list deleting the wrong branch (#45087) Closes #45033 This bug happened because the deletion icon would use the selected entry index to choose what branch to delete. This works for all cases except when hovering on an entry, so the fix was passing in the entry index to the deletion button on_click handler. I also disabled the deletion button from working if a branch is HEAD, because it's an illegal operation to delete a branch a user is currently on. Finally, I made WeakEntity a non-optional field on `BranchList` because a workspace should always be present, and it's used to show toast notifications when a git operation fails. The popover view wouldn't have a workspace before, so users wouldn't get error messages when a git operation failed in that view. Release Notes: - git: Fix bug where branch list deletion button would delete the wrong branch --- crates/git_ui/src/branch_picker.rs | 139 ++++++++++++++++------------- crates/git_ui/src/commit_modal.rs | 11 ++- crates/git_ui/src/git_panel.rs | 16 +++- 3 files changed, 101 insertions(+), 65 deletions(-) diff --git a/crates/git_ui/src/branch_picker.rs b/crates/git_ui/src/branch_picker.rs index cbf3fea72a9937a0ab882f9ccca2c4274afdf0e2..7395f1588fececcf4f374ec0e66cdac6024656d7 100644 --- a/crates/git_ui/src/branch_picker.rs +++ b/crates/git_ui/src/branch_picker.rs @@ -72,25 +72,19 @@ pub fn open( let repository = workspace.project().read(cx).active_repository(cx); let style = BranchListStyle::Modal; workspace.toggle_modal(window, cx, |window, cx| { - BranchList::new( - Some(workspace_handle), - repository, - style, - rems(34.), - window, - cx, - ) + BranchList::new(workspace_handle, repository, style, rems(34.), window, cx) }) } pub fn popover( + workspace: WeakEntity, repository: Option>, window: &mut Window, cx: &mut App, ) -> Entity { cx.new(|cx| { let list = BranchList::new( - None, + workspace, repository, BranchListStyle::Popover, rems(20.), @@ -117,7 +111,7 @@ pub struct BranchList { impl BranchList { fn new( - workspace: Option>, + workspace: WeakEntity, repository: Option>, style: BranchListStyle, width: Rems, @@ -332,7 +326,7 @@ impl BranchFilter { } pub struct BranchListDelegate { - workspace: Option>, + workspace: WeakEntity, matches: Vec, all_branches: Option>, default_branch: Option, @@ -360,7 +354,7 @@ enum PickerState { impl BranchListDelegate { fn new( - workspace: Option>, + workspace: WeakEntity, repo: Option>, style: BranchListStyle, cx: &mut Context, @@ -464,7 +458,7 @@ impl BranchListDelegate { log::error!("Failed to delete branch: {}", e); } - if let Some(workspace) = workspace.and_then(|w| w.upgrade()) { + if let Some(workspace) = workspace.upgrade() { cx.update(|_window, cx| { if is_remote { show_error_toast( @@ -880,19 +874,21 @@ impl PickerDelegate for BranchListDelegate { Entry::NewUrl { .. } | Entry::NewBranch { .. } | Entry::NewRemoteName { .. } ); - let delete_branch_button = IconButton::new("delete", IconName::Trash) - .tooltip(move |_, cx| { - Tooltip::for_action_in( - "Delete Branch", - &branch_picker::DeleteBranch, - &focus_handle, - cx, - ) - }) - .on_click(cx.listener(|this, _, window, cx| { - let selected_idx = this.delegate.selected_index(); - this.delegate.delete_at(selected_idx, window, cx); - })); + let deleted_branch_icon = |entry_ix: usize, is_head_branch: bool| { + IconButton::new(("delete", entry_ix), IconName::Trash) + .tooltip(move |_, cx| { + Tooltip::for_action_in( + "Delete Branch", + &branch_picker::DeleteBranch, + &focus_handle, + cx, + ) + }) + .disabled(is_head_branch) + .on_click(cx.listener(move |this, _, window, cx| { + this.delegate.delete_at(entry_ix, window, cx); + })) + }; let create_from_default_button = self.default_branch.as_ref().map(|default_branch| { let tooltip_label: SharedString = format!("Create New From: {default_branch}").into(); @@ -1008,10 +1004,12 @@ impl PickerDelegate for BranchListDelegate { self.editor_position() == PickerEditorPosition::End && !is_new_items, |this| { this.map(|this| { + let is_head_branch = + entry.as_branch().is_some_and(|branch| branch.is_head); if self.selected_index() == ix { - this.end_slot(delete_branch_button) + this.end_slot(deleted_branch_icon(ix, is_head_branch)) } else { - this.end_hover_slot(delete_branch_button) + this.end_hover_slot(deleted_branch_icon(ix, is_head_branch)) } }) }, @@ -1236,7 +1234,7 @@ mod tests { use super::*; use git::repository::{CommitSummary, Remote}; - use gpui::{TestAppContext, VisualTestContext}; + use gpui::{AppContext, TestAppContext, VisualTestContext}; use project::{FakeFs, Project}; use rand::{Rng, rngs::StdRng}; use serde_json::json; @@ -1285,35 +1283,47 @@ mod tests { ] } - fn init_branch_list_test( + async fn init_branch_list_test( repository: Option>, branches: Vec, cx: &mut TestAppContext, ) -> (Entity, VisualTestContext) { - let window = cx.add_window(|window, cx| { - let mut delegate = - BranchListDelegate::new(None, repository, BranchListStyle::Modal, cx); - delegate.all_branches = Some(branches); - let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx)); - let picker_focus_handle = picker.focus_handle(cx); - picker.update(cx, |picker, _| { - picker.delegate.focus_handle = picker_focus_handle.clone(); - }); + let fs = FakeFs::new(cx.executor()); + let project = Project::test(fs, [], cx).await; - let _subscription = cx.subscribe(&picker, |_, _, _, cx| { - cx.emit(DismissEvent); - }); + let workspace = cx.add_window(|window, cx| Workspace::test_new(project, window, cx)); - BranchList { - picker, - picker_focus_handle, - width: rems(34.), - _subscription, - } - }); + let branch_list = workspace + .update(cx, |workspace, window, cx| { + cx.new(|cx| { + let mut delegate = BranchListDelegate::new( + workspace.weak_handle(), + repository, + BranchListStyle::Modal, + cx, + ); + delegate.all_branches = Some(branches); + let picker = cx.new(|cx| Picker::uniform_list(delegate, window, cx)); + let picker_focus_handle = picker.focus_handle(cx); + picker.update(cx, |picker, _| { + picker.delegate.focus_handle = picker_focus_handle.clone(); + }); + + let _subscription = cx.subscribe(&picker, |_, _, _, cx| { + cx.emit(DismissEvent); + }); - let branch_list = window.root(cx).unwrap(); - let cx = VisualTestContext::from_window(*window, cx); + BranchList { + picker, + picker_focus_handle, + width: rems(34.), + _subscription, + } + }) + }) + .unwrap(); + + let cx = VisualTestContext::from_window(*workspace, cx); (branch_list, cx) } @@ -1349,7 +1359,7 @@ mod tests { init_test(cx); let branches = create_test_branches(); - let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx).await; let cx = &mut ctx; branch_list @@ -1425,7 +1435,7 @@ mod tests { .await; cx.run_until_parked(); - let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, cx).await; let cx = &mut ctx; update_branch_list_matches_with_empty_query(&branch_list, cx).await; @@ -1490,7 +1500,7 @@ mod tests { .await; cx.run_until_parked(); - let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, cx).await; let cx = &mut ctx; // Enable remote filter branch_list.update(cx, |branch_list, cx| { @@ -1548,7 +1558,7 @@ mod tests { create_test_branch("develop", false, None, Some(700)), ]; - let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx).await; let cx = &mut ctx; update_branch_list_matches_with_empty_query(&branch_list, cx).await; @@ -1658,7 +1668,8 @@ mod tests { create_test_branch(FEATURE_BRANCH, false, None, Some(900)), ]; - let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, test_cx); + let (branch_list, mut ctx) = + init_branch_list_test(repository.into(), branches, test_cx).await; let cx = &mut ctx; branch_list @@ -1717,7 +1728,7 @@ mod tests { let repository = init_fake_repository(cx).await; let branches = vec![create_test_branch("main", true, None, Some(1000))]; - let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(repository.into(), branches, cx).await; let cx = &mut ctx; branch_list @@ -1795,7 +1806,7 @@ mod tests { init_test(cx); let branches = vec![create_test_branch("main_branch", true, None, Some(1000))]; - let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx).await; let cx = &mut ctx; branch_list @@ -1858,7 +1869,7 @@ mod tests { init_test(cx); let branches = vec![create_test_branch("main", true, None, Some(1000))]; - let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx).await; let cx = &mut ctx; let subscription = cx.update(|_, cx| { @@ -1870,6 +1881,11 @@ mod tests { branch_list .update_in(cx, |branch_list, window, cx| { window.focus(&branch_list.picker_focus_handle); + assert!( + branch_list.picker_focus_handle.is_focused(window), + "Branch picker should be focused when selecting an entry" + ); + branch_list.picker.update(cx, |picker, cx| { picker .delegate @@ -1881,6 +1897,9 @@ mod tests { cx.run_until_parked(); branch_list.update_in(cx, |branch_list, window, cx| { + // Re-focus the picker since workspace initialization during run_until_parked + window.focus(&branch_list.picker_focus_handle); + branch_list.picker.update(cx, |picker, cx| { let last_match = picker.delegate.matches.last().unwrap(); assert!(last_match.is_new_url()); @@ -1914,7 +1933,7 @@ mod tests { .map(|i| create_test_branch(&format!("branch-{:02}", i), i == 0, None, Some(i * 100))) .collect(); - let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx); + let (branch_list, mut ctx) = init_branch_list_test(None, branches, cx).await; let cx = &mut ctx; update_branch_list_matches_with_empty_query(&branch_list, cx).await; diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs index 822b2c8385c2d573ceb2dc2872a685c47ff51379..291a96f47590b145b5c190150af54bd3d43c2fff 100644 --- a/crates/git_ui/src/commit_modal.rs +++ b/crates/git_ui/src/commit_modal.rs @@ -337,6 +337,7 @@ impl CommitModal { active_repo, is_amend_pending, is_signoff_enabled, + workspace, ) = 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(); @@ -354,6 +355,7 @@ impl CommitModal { active_repo, is_amend_pending, is_signoff_enabled, + git_panel.workspace.clone(), ) }); @@ -375,7 +377,14 @@ impl CommitModal { .style(ButtonStyle::Transparent); let branch_picker = PopoverMenu::new("popover-button") - .menu(move |window, cx| Some(branch_picker::popover(active_repo.clone(), window, cx))) + .menu(move |window, cx| { + Some(branch_picker::popover( + workspace.clone(), + active_repo.clone(), + window, + cx, + )) + }) .with_handle(self.branch_list_handle.clone()) .trigger_with_tooltip( branch_picker_button, diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 8b32a79311f1f52036d8e54d182139d45bf64d10..1426ed1e65412da5cb8be22e7592e5a42917b367 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -594,7 +594,7 @@ pub struct GitPanel { tracked_staged_count: usize, update_visible_entries_task: Task<()>, width: Option, - workspace: WeakEntity, + pub(crate) workspace: WeakEntity, context_menu: Option<(Entity, Point, Subscription)>, modal_open: bool, show_placeholders: bool, @@ -5617,10 +5617,14 @@ impl RenderOnce for PanelRepoFooter { .as_ref() .map(|panel| panel.read(cx).project.clone()); - let repo = self + let (workspace, repo) = self .git_panel .as_ref() - .and_then(|panel| panel.read(cx).active_repository.clone()); + .map(|panel| { + let panel = panel.read(cx); + (panel.workspace.clone(), panel.active_repository.clone()) + }) + .unzip(); let single_repo = project .as_ref() @@ -5708,7 +5712,11 @@ impl RenderOnce for PanelRepoFooter { }); let branch_selector = PopoverMenu::new("popover-button") - .menu(move |window, cx| Some(branch_picker::popover(repo.clone(), window, cx))) + .menu(move |window, cx| { + let workspace = workspace.clone()?; + let repo = repo.clone().flatten(); + Some(branch_picker::popover(workspace, repo, window, cx)) + }) .trigger_with_tooltip( branch_selector_button, Tooltip::for_action_title("Switch Branch", &zed_actions::git::Switch), From f5ba029313556c28ec4c80f376f82900d8a88fbc Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Wed, 17 Dec 2025 11:31:18 +0100 Subject: [PATCH 108/266] remote: Implement client side connection support for windows remotes (#45084) Obviously this doesn't do too much without having an actual windows server binary for the remote side, but it does at least improve the error message as right now we will complain about `uname` not being a valid powershell command. Release Notes: - N/A *or* Added/Fixed/Improved ... --- .../recent_projects/src/remote_connections.rs | 8 +- crates/remote/src/remote.rs | 5 +- crates/remote/src/remote_client.rs | 55 +++++- crates/remote/src/transport.rs | 68 ++++--- crates/remote/src/transport/docker.rs | 14 +- crates/remote/src/transport/ssh.rs | 182 ++++++++++++++---- crates/remote/src/transport/wsl.rs | 7 +- 7 files changed, 254 insertions(+), 85 deletions(-) diff --git a/crates/recent_projects/src/remote_connections.rs b/crates/recent_projects/src/remote_connections.rs index 1c6da9b82a9a661307fd5eec1cd647ceb6c292bb..e8349601b5303331c0a6a38aca306fe57ab07ed3 100644 --- a/crates/recent_projects/src/remote_connections.rs +++ b/crates/recent_projects/src/remote_connections.rs @@ -533,8 +533,8 @@ impl remote::RemoteClientDelegate for RemoteClientDelegate { AutoUpdater::download_remote_server_release( release_channel, version.clone(), - platform.os, - platform.arch, + platform.os.as_str(), + platform.arch.as_str(), move |status, cx| this.set_status(Some(status), cx), cx, ) @@ -564,8 +564,8 @@ impl remote::RemoteClientDelegate for RemoteClientDelegate { AutoUpdater::get_remote_server_release_url( release_channel, version, - platform.os, - platform.arch, + platform.os.as_str(), + platform.arch.as_str(), cx, ) .await diff --git a/crates/remote/src/remote.rs b/crates/remote/src/remote.rs index 51b71c988a6dc57e875b3baa28103bef0d8fd729..2db918ecce331acac91bb974df1b784f0d6532b3 100644 --- a/crates/remote/src/remote.rs +++ b/crates/remote/src/remote.rs @@ -7,8 +7,9 @@ mod transport; #[cfg(target_os = "windows")] pub use remote_client::OpenWslPath; pub use remote_client::{ - ConnectionIdentifier, ConnectionState, RemoteClient, RemoteClientDelegate, RemoteClientEvent, - RemoteConnection, RemoteConnectionOptions, RemotePlatform, connect, + ConnectionIdentifier, ConnectionState, RemoteArch, RemoteClient, RemoteClientDelegate, + RemoteClientEvent, RemoteConnection, RemoteConnectionOptions, RemoteOs, RemotePlatform, + connect, }; pub use transport::docker::DockerConnectionOptions; pub use transport::ssh::{SshConnectionOptions, SshPortForwardOption}; diff --git a/crates/remote/src/remote_client.rs b/crates/remote/src/remote_client.rs index 9c6508e5f16027eb23225f0eceb1cb691f4a33c9..79bdbe540d070bfa18a6417622b386458ff221a8 100644 --- a/crates/remote/src/remote_client.rs +++ b/crates/remote/src/remote_client.rs @@ -49,10 +49,58 @@ use util::{ paths::{PathStyle, RemotePathBuf}, }; +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum RemoteOs { + Linux, + MacOs, + Windows, +} + +impl RemoteOs { + pub fn as_str(&self) -> &'static str { + match self { + RemoteOs::Linux => "linux", + RemoteOs::MacOs => "macos", + RemoteOs::Windows => "windows", + } + } + + pub fn is_windows(&self) -> bool { + matches!(self, RemoteOs::Windows) + } +} + +impl std::fmt::Display for RemoteOs { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(self.as_str()) + } +} + +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum RemoteArch { + X86_64, + Aarch64, +} + +impl RemoteArch { + pub fn as_str(&self) -> &'static str { + match self { + RemoteArch::X86_64 => "x86_64", + RemoteArch::Aarch64 => "aarch64", + } + } +} + +impl std::fmt::Display for RemoteArch { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(self.as_str()) + } +} + #[derive(Copy, Clone, Debug)] pub struct RemotePlatform { - pub os: &'static str, - pub arch: &'static str, + pub os: RemoteOs, + pub arch: RemoteArch, } #[derive(Clone, Debug)] @@ -89,7 +137,8 @@ pub trait RemoteClientDelegate: Send + Sync { const MAX_MISSED_HEARTBEATS: usize = 5; const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(5); const HEARTBEAT_TIMEOUT: Duration = Duration::from_secs(5); -const INITIAL_CONNECTION_TIMEOUT: Duration = Duration::from_secs(60); +const INITIAL_CONNECTION_TIMEOUT: Duration = + Duration::from_secs(if cfg!(debug_assertions) { 5 } else { 60 }); const MAX_RECONNECT_ATTEMPTS: usize = 3; diff --git a/crates/remote/src/transport.rs b/crates/remote/src/transport.rs index 4cafbf60eec338addbb43e46d156960621301ab0..ebf643352fce8a14d88b7c870b177d2c6b7e7de0 100644 --- a/crates/remote/src/transport.rs +++ b/crates/remote/src/transport.rs @@ -1,5 +1,5 @@ use crate::{ - RemotePlatform, + RemoteArch, RemoteOs, RemotePlatform, json_log::LogRecord, protocol::{MESSAGE_LEN_SIZE, message_len_from_buffer, read_message_with_len, write_message}, }; @@ -26,8 +26,8 @@ fn parse_platform(output: &str) -> Result { }; let os = match os { - "Darwin" => "macos", - "Linux" => "linux", + "Darwin" => RemoteOs::MacOs, + "Linux" => RemoteOs::Linux, _ => anyhow::bail!( "Prebuilt remote servers are not yet available for {os:?}. See https://zed.dev/docs/remote-development" ), @@ -39,9 +39,9 @@ fn parse_platform(output: &str) -> Result { || arch.starts_with("arm64") || arch.starts_with("aarch64") { - "aarch64" + RemoteArch::Aarch64 } else if arch.starts_with("x86") { - "x86_64" + RemoteArch::X86_64 } else { anyhow::bail!( "Prebuilt remote servers are not yet available for {arch:?}. See https://zed.dev/docs/remote-development" @@ -193,7 +193,8 @@ async fn build_remote_server_from_source( .await?; anyhow::ensure!( output.status.success(), - "Failed to run command: {command:?}" + "Failed to run command: {command:?}: output: {}", + String::from_utf8_lossy(&output.stderr) ); Ok(()) } @@ -203,14 +204,15 @@ async fn build_remote_server_from_source( "{}-{}", platform.arch, match platform.os { - "linux" => + RemoteOs::Linux => if use_musl { "unknown-linux-musl" } else { "unknown-linux-gnu" }, - "macos" => "apple-darwin", - _ => anyhow::bail!("can't cross compile for: {:?}", platform), + RemoteOs::MacOs => "apple-darwin", + RemoteOs::Windows if cfg!(windows) => "pc-windows-msvc", + RemoteOs::Windows => "pc-windows-gnu", } ); let mut rust_flags = match std::env::var("RUSTFLAGS") { @@ -221,7 +223,7 @@ async fn build_remote_server_from_source( String::new() } }; - if platform.os == "linux" && use_musl { + if platform.os == RemoteOs::Linux && use_musl { rust_flags.push_str(" -C target-feature=+crt-static"); if let Ok(path) = std::env::var("ZED_ZSTD_MUSL_LIB") { @@ -232,7 +234,9 @@ async fn build_remote_server_from_source( rust_flags.push_str(" -C link-arg=-fuse-ld=mold"); } - if platform.arch == std::env::consts::ARCH && platform.os == std::env::consts::OS { + if platform.arch.as_str() == std::env::consts::ARCH + && platform.os.as_str() == std::env::consts::OS + { delegate.set_status(Some("Building remote server binary from source"), cx); log::info!("building remote server binary from source"); run_cmd( @@ -308,7 +312,8 @@ async fn build_remote_server_from_source( .join("remote_server") .join(&triple) .join("debug") - .join("remote_server"); + .join("remote_server") + .with_extension(if platform.os.is_windows() { "exe" } else { "" }); let path = if !build_remote_server.contains("nocompress") { delegate.set_status(Some("Compressing binary"), cx); @@ -374,35 +379,44 @@ mod tests { #[test] fn test_parse_platform() { let result = parse_platform("Linux x86_64\n").unwrap(); - assert_eq!(result.os, "linux"); - assert_eq!(result.arch, "x86_64"); + assert_eq!(result.os, RemoteOs::Linux); + assert_eq!(result.arch, RemoteArch::X86_64); let result = parse_platform("Darwin arm64\n").unwrap(); - assert_eq!(result.os, "macos"); - assert_eq!(result.arch, "aarch64"); + assert_eq!(result.os, RemoteOs::MacOs); + assert_eq!(result.arch, RemoteArch::Aarch64); let result = parse_platform("Linux x86_64").unwrap(); - assert_eq!(result.os, "linux"); - assert_eq!(result.arch, "x86_64"); + assert_eq!(result.os, RemoteOs::Linux); + assert_eq!(result.arch, RemoteArch::X86_64); let result = parse_platform("some shell init output\nLinux aarch64\n").unwrap(); - assert_eq!(result.os, "linux"); - assert_eq!(result.arch, "aarch64"); + assert_eq!(result.os, RemoteOs::Linux); + assert_eq!(result.arch, RemoteArch::Aarch64); let result = parse_platform("some shell init output\nLinux aarch64").unwrap(); - assert_eq!(result.os, "linux"); - assert_eq!(result.arch, "aarch64"); + assert_eq!(result.os, RemoteOs::Linux); + assert_eq!(result.arch, RemoteArch::Aarch64); - assert_eq!(parse_platform("Linux armv8l\n").unwrap().arch, "aarch64"); - assert_eq!(parse_platform("Linux aarch64\n").unwrap().arch, "aarch64"); - assert_eq!(parse_platform("Linux x86_64\n").unwrap().arch, "x86_64"); + assert_eq!( + parse_platform("Linux armv8l\n").unwrap().arch, + RemoteArch::Aarch64 + ); + assert_eq!( + parse_platform("Linux aarch64\n").unwrap().arch, + RemoteArch::Aarch64 + ); + assert_eq!( + parse_platform("Linux x86_64\n").unwrap().arch, + RemoteArch::X86_64 + ); let result = parse_platform( r#"Linux x86_64 - What you're referring to as Linux, is in fact, GNU/Linux...\n"#, ) .unwrap(); - assert_eq!(result.os, "linux"); - assert_eq!(result.arch, "x86_64"); + assert_eq!(result.os, RemoteOs::Linux); + assert_eq!(result.arch, RemoteArch::X86_64); assert!(parse_platform("Windows x86_64\n").is_err()); assert!(parse_platform("Linux armv7l\n").is_err()); diff --git a/crates/remote/src/transport/docker.rs b/crates/remote/src/transport/docker.rs index 09f5935ec621260e933f11f46aa57493a31ace6d..9c14aa874941a5cdcd824d4adaeb41d694e347d8 100644 --- a/crates/remote/src/transport/docker.rs +++ b/crates/remote/src/transport/docker.rs @@ -24,8 +24,8 @@ use gpui::{App, AppContext, AsyncApp, Task}; use rpc::proto::Envelope; use crate::{ - RemoteClientDelegate, RemoteConnection, RemoteConnectionOptions, RemotePlatform, - remote_client::CommandTemplate, + RemoteArch, RemoteClientDelegate, RemoteConnection, RemoteConnectionOptions, RemoteOs, + RemotePlatform, remote_client::CommandTemplate, }; #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)] @@ -70,7 +70,7 @@ impl DockerExecConnection { let remote_platform = this.check_remote_platform().await?; this.path_style = match remote_platform.os { - "windows" => Some(PathStyle::Windows), + RemoteOs::Windows => Some(PathStyle::Windows), _ => Some(PathStyle::Posix), }; @@ -124,8 +124,8 @@ impl DockerExecConnection { }; let os = match os.trim() { - "Darwin" => "macos", - "Linux" => "linux", + "Darwin" => RemoteOs::MacOs, + "Linux" => RemoteOs::Linux, _ => anyhow::bail!( "Prebuilt remote servers are not yet available for {os:?}. See https://zed.dev/docs/remote-development" ), @@ -136,9 +136,9 @@ impl DockerExecConnection { || arch.starts_with("arm64") || arch.starts_with("aarch64") { - "aarch64" + RemoteArch::Aarch64 } else if arch.starts_with("x86") { - "x86_64" + RemoteArch::X86_64 } else { anyhow::bail!( "Prebuilt remote servers are not yet available for {arch:?}. See https://zed.dev/docs/remote-development" diff --git a/crates/remote/src/transport/ssh.rs b/crates/remote/src/transport/ssh.rs index 37921b88637f19b68f9625170d9d99e85b5a9bdf..6c8eb49c1c2158322a275e064162b53e2f5f3d5e 100644 --- a/crates/remote/src/transport/ssh.rs +++ b/crates/remote/src/transport/ssh.rs @@ -1,5 +1,5 @@ use crate::{ - RemoteClientDelegate, RemotePlatform, + RemoteArch, RemoteClientDelegate, RemoteOs, RemotePlatform, remote_client::{CommandTemplate, RemoteConnection, RemoteConnectionOptions}, transport::{parse_platform, parse_shell}, }; @@ -402,30 +402,50 @@ impl RemoteConnection for SshRemoteConnection { delegate: Arc, cx: &mut AsyncApp, ) -> Task> { + const VARS: [&str; 3] = ["RUST_LOG", "RUST_BACKTRACE", "ZED_GENERATE_MINIDUMPS"]; delegate.set_status(Some("Starting proxy"), cx); let Some(remote_binary_path) = self.remote_binary_path.clone() else { return Task::ready(Err(anyhow!("Remote binary path not set"))); }; - let mut proxy_args = vec![]; - for env_var in ["RUST_LOG", "RUST_BACKTRACE", "ZED_GENERATE_MINIDUMPS"] { - if let Some(value) = std::env::var(env_var).ok() { - proxy_args.push(format!("{}='{}'", env_var, value)); + let mut ssh_command = if self.ssh_platform.os.is_windows() { + // TODO: Set the `VARS` environment variables, we do not have `env` on windows + // so this needs a different approach + let mut proxy_args = vec![]; + proxy_args.push("proxy".to_owned()); + proxy_args.push("--identifier".to_owned()); + proxy_args.push(unique_identifier); + + if reconnect { + proxy_args.push("--reconnect".to_owned()); } - } - proxy_args.push(remote_binary_path.display(self.path_style()).into_owned()); - proxy_args.push("proxy".to_owned()); - proxy_args.push("--identifier".to_owned()); - proxy_args.push(unique_identifier); + self.socket.ssh_command( + self.ssh_shell_kind, + &remote_binary_path.display(self.path_style()), + &proxy_args, + false, + ) + } else { + let mut proxy_args = vec![]; + for env_var in VARS { + if let Some(value) = std::env::var(env_var).ok() { + proxy_args.push(format!("{}='{}'", env_var, value)); + } + } + proxy_args.push(remote_binary_path.display(self.path_style()).into_owned()); + proxy_args.push("proxy".to_owned()); + proxy_args.push("--identifier".to_owned()); + proxy_args.push(unique_identifier); - if reconnect { - proxy_args.push("--reconnect".to_owned()); - } + if reconnect { + proxy_args.push("--reconnect".to_owned()); + } + self.socket + .ssh_command(self.ssh_shell_kind, "env", &proxy_args, false) + }; - let ssh_proxy_process = match self - .socket - .ssh_command(self.ssh_shell_kind, "env", &proxy_args, false) + let ssh_proxy_process = match ssh_command // IMPORTANT: we kill this process when we drop the task that uses it. .kill_on_drop(true) .spawn() @@ -545,22 +565,20 @@ impl SshRemoteConnection { .await?; drop(askpass); - let ssh_shell = socket.shell().await; + let is_windows = socket.probe_is_windows().await; + log::info!("Remote is windows: {}", is_windows); + + let ssh_shell = socket.shell(is_windows).await; log::info!("Remote shell discovered: {}", ssh_shell); - let ssh_platform = socket.platform(ShellKind::new(&ssh_shell, false)).await?; + + let ssh_shell_kind = ShellKind::new(&ssh_shell, is_windows); + let ssh_platform = socket.platform(ssh_shell_kind, is_windows).await?; log::info!("Remote platform discovered: {:?}", ssh_platform); - let ssh_path_style = match ssh_platform.os { - "windows" => PathStyle::Windows, - _ => PathStyle::Posix, + + let (ssh_path_style, ssh_default_system_shell) = match ssh_platform.os { + RemoteOs::Windows => (PathStyle::Windows, ssh_shell.clone()), + _ => (PathStyle::Posix, String::from("/bin/sh")), }; - let ssh_default_system_shell = String::from("/bin/sh"); - let ssh_shell_kind = ShellKind::new( - &ssh_shell, - match ssh_platform.os { - "windows" => true, - _ => false, - }, - ); let mut this = Self { socket, @@ -596,9 +614,14 @@ impl SshRemoteConnection { _ => version.to_string(), }; let binary_name = format!( - "zed-remote-server-{}-{}", + "zed-remote-server-{}-{}{}", release_channel.dev_name(), - version_str + version_str, + if self.ssh_platform.os.is_windows() { + ".exe" + } else { + "" + } ); let dst_path = paths::remote_server_dir_relative().join(RelPath::unix(&binary_name).unwrap()); @@ -710,14 +733,19 @@ impl SshRemoteConnection { cx: &mut AsyncApp, ) -> Result<()> { if let Some(parent) = tmp_path_gz.parent() { - self.socket + let res = self + .socket .run_command( self.ssh_shell_kind, "mkdir", &["-p", parent.display(self.path_style()).as_ref()], true, ) - .await?; + .await; + if !self.ssh_platform.os.is_windows() { + // mkdir fails on windows if the path already exists ... + res?; + } } delegate.set_status(Some("Downloading remote development server on host"), cx); @@ -805,17 +833,24 @@ impl SshRemoteConnection { cx: &mut AsyncApp, ) -> Result<()> { if let Some(parent) = tmp_path_gz.parent() { - self.socket + let res = self + .socket .run_command( self.ssh_shell_kind, "mkdir", &["-p", parent.display(self.path_style()).as_ref()], true, ) - .await?; + .await; + if !self.ssh_platform.os.is_windows() { + // mkdir fails on windows if the path already exists ... + res?; + } } - let src_stat = fs::metadata(&src_path).await?; + let src_stat = fs::metadata(&src_path) + .await + .with_context(|| format!("failed to get metadata for {:?}", src_path))?; let size = src_stat.len(); let t0 = Instant::now(); @@ -866,7 +901,7 @@ impl SshRemoteConnection { }; let args = shell_kind.args_for_shell(false, script.to_string()); self.socket - .run_command(shell_kind, "sh", &args, true) + .run_command(self.ssh_shell_kind, "sh", &args, true) .await?; Ok(()) } @@ -1054,6 +1089,7 @@ impl SshSocket { ) -> Result { let mut command = self.ssh_command(shell_kind, program, args, allow_pseudo_tty); let output = command.output().await?; + log::debug!("{:?}: {:?}", command, output); anyhow::ensure!( output.status.success(), "failed to run command {command:?}: {}", @@ -1125,12 +1161,71 @@ impl SshSocket { arguments } - async fn platform(&self, shell: ShellKind) -> Result { - let output = self.run_command(shell, "uname", &["-sm"], false).await?; + async fn platform(&self, shell: ShellKind, is_windows: bool) -> Result { + if is_windows { + self.platform_windows(shell).await + } else { + self.platform_posix(shell).await + } + } + + async fn platform_posix(&self, shell: ShellKind) -> Result { + let output = self + .run_command(shell, "uname", &["-sm"], false) + .await + .context("Failed to run 'uname -sm' to determine platform")?; parse_platform(&output) } - async fn shell(&self) -> String { + async fn platform_windows(&self, shell: ShellKind) -> Result { + let output = self + .run_command( + shell, + "cmd", + &["/c", "echo", "%PROCESSOR_ARCHITECTURE%"], + false, + ) + .await + .context( + "Failed to run 'echo %PROCESSOR_ARCHITECTURE%' to determine Windows architecture", + )?; + + Ok(RemotePlatform { + os: RemoteOs::Windows, + arch: match output.trim() { + "AMD64" => RemoteArch::X86_64, + "ARM64" => RemoteArch::Aarch64, + arch => anyhow::bail!( + "Prebuilt remote servers are not yet available for windows-{arch}. See https://zed.dev/docs/remote-development" + ), + }, + }) + } + + /// Probes whether the remote host is running Windows. + /// + /// This is done by attempting to run a simple Windows-specific command. + /// If it succeeds and returns Windows-like output, we assume it's Windows. + async fn probe_is_windows(&self) -> bool { + match self + .run_command(ShellKind::PowerShell, "cmd", &["/c", "ver"], false) + .await + { + // Windows 'ver' command outputs something like "Microsoft Windows [Version 10.0.19045.5011]" + Ok(output) => output.trim().contains("indows"), + Err(_) => false, + } + } + + async fn shell(&self, is_windows: bool) -> String { + if is_windows { + self.shell_windows().await + } else { + self.shell_posix().await + } + } + + async fn shell_posix(&self) -> String { const DEFAULT_SHELL: &str = "sh"; match self .run_command(ShellKind::Posix, "sh", &["-c", "echo $SHELL"], false) @@ -1143,6 +1238,13 @@ impl SshSocket { } } } + + async fn shell_windows(&self) -> String { + // powershell is always the default, and cannot really be removed from the system + // so we can rely on that fact and reasonably assume that we will be running in a + // powershell environment + "powershell.exe".to_owned() + } } fn parse_port_number(port_str: &str) -> Result { diff --git a/crates/remote/src/transport/wsl.rs b/crates/remote/src/transport/wsl.rs index d27648e67840681765248ae1cce12c15d7a13228..32dd9ebe8247bb4a0b631a79b1a93deb621e6ed1 100644 --- a/crates/remote/src/transport/wsl.rs +++ b/crates/remote/src/transport/wsl.rs @@ -1,5 +1,5 @@ use crate::{ - RemoteClientDelegate, RemotePlatform, + RemoteArch, RemoteClientDelegate, RemoteOs, RemotePlatform, remote_client::{CommandTemplate, RemoteConnection, RemoteConnectionOptions}, transport::{parse_platform, parse_shell}, }; @@ -70,7 +70,10 @@ impl WslRemoteConnection { let mut this = Self { connection_options, remote_binary_path: None, - platform: RemotePlatform { os: "", arch: "" }, + platform: RemotePlatform { + os: RemoteOs::Linux, + arch: RemoteArch::X86_64, + }, shell: String::new(), shell_kind: ShellKind::Posix, default_system_shell: String::from("/bin/sh"), From 14958a47ed2356ef635d7eaf441bca538536aba1 Mon Sep 17 00:00:00 2001 From: Dino Date: Wed, 17 Dec 2025 10:31:36 +0000 Subject: [PATCH 109/266] vim: Attempt to fix flaky vim tests on windows (#45089) Both `test_miniquotes_object` and `test_minibrackets_object` rely on tree-sitter parsing for `MultiBufferSnapshot.bracket_ranges` to find quote/bracket pairs. The `VimTestContext.set_state` call eventually triggers async tree-sitter parsing, but `run_until_parked` doesn't guarantee parsing completion. We suspect this is what might be causing the flakiness on Windows, as the syntax might not yet be parsed when the `VimTestContext.simulate_keystrokes` call is made, so there's no bracket pairs returned. This commit adds an explicit await call on `Bufffer.parsing_idle` after each `VimTestContext.set_state` call, to ensure tree-sitter parsing completes before simulating keystrokes. Release Notes: - N/A --- crates/vim/src/object.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/crates/vim/src/object.rs b/crates/vim/src/object.rs index 98c14855a3e20623c87d6204c1c4233f20008cbb..02150332405c6d5ea4d5dd78f477348be968fddf 100644 --- a/crates/vim/src/object.rs +++ b/crates/vim/src/object.rs @@ -2807,9 +2807,8 @@ mod test { for (keystrokes, initial_state, expected_state, expected_mode) in TEST_CASES { cx.set_state(initial_state, Mode::Normal); - + cx.buffer(|buffer, _| buffer.parsing_idle()).await; cx.simulate_keystrokes(keystrokes); - cx.assert_state(expected_state, *expected_mode); } @@ -2830,9 +2829,8 @@ mod test { for (keystrokes, initial_state, mode) in INVALID_CASES { cx.set_state(initial_state, Mode::Normal); - + cx.buffer(|buffer, _| buffer.parsing_idle()).await; cx.simulate_keystrokes(keystrokes); - cx.assert_state(initial_state, *mode); } } @@ -3185,9 +3183,8 @@ mod test { for (keystrokes, initial_state, expected_state, expected_mode) in TEST_CASES { cx.set_state(initial_state, Mode::Normal); - + cx.buffer(|buffer, _| buffer.parsing_idle()).await; cx.simulate_keystrokes(keystrokes); - cx.assert_state(expected_state, *expected_mode); } @@ -3208,9 +3205,8 @@ mod test { for (keystrokes, initial_state, mode) in INVALID_CASES { cx.set_state(initial_state, Mode::Normal); - + cx.buffer(|buffer, _| buffer.parsing_idle()).await; cx.simulate_keystrokes(keystrokes); - cx.assert_state(initial_state, *mode); } } From 010b871a8e94d50f1ae33cb60819b46a9334e332 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 17 Dec 2025 05:52:27 -0500 Subject: [PATCH 110/266] git: Show pure white space changes in word diffs (#45090) Closes #44624 Before this change, white space would be trimmed from word diff ranges. Users found this behavior confusing, so we're changing it to be more inline with how GitHub treats whitespace in their word diffs. Release Notes: - git: Word diffs won't filter out pure whitespace diffs now --- crates/buffer_diff/src/buffer_diff.rs | 11 +++- crates/language/src/text_diff.rs | 61 +++---------------- crates/multi_buffer/src/multi_buffer_tests.rs | 13 ++++ 3 files changed, 30 insertions(+), 55 deletions(-) diff --git a/crates/buffer_diff/src/buffer_diff.rs b/crates/buffer_diff/src/buffer_diff.rs index 55de3f968bc1cc9ff5d640b0d3ca30221e413632..22525096d3cbca456aa114b5acc9b4239b570dda 100644 --- a/crates/buffer_diff/src/buffer_diff.rs +++ b/crates/buffer_diff/src/buffer_diff.rs @@ -2155,7 +2155,7 @@ mod tests { let range = diff_1.inner.compare(&empty_diff.inner, &buffer).unwrap(); assert_eq!(range.to_point(&buffer), Point::new(0, 0)..Point::new(8, 0)); - // Edit does not affect the diff. + // Edit does affects the diff because it recalculates word diffs. buffer.edit_via_marked_text( &" one @@ -2170,7 +2170,14 @@ mod tests { .unindent(), ); let diff_2 = BufferDiffSnapshot::new_sync(buffer.clone(), base_text.clone(), cx); - assert_eq!(None, diff_2.inner.compare(&diff_1.inner, &buffer)); + assert_eq!( + Point::new(4, 0)..Point::new(5, 0), + diff_2 + .inner + .compare(&diff_1.inner, &buffer) + .unwrap() + .to_point(&buffer) + ); // Edit turns a deletion hunk into a modification. buffer.edit_via_marked_text( diff --git a/crates/language/src/text_diff.rs b/crates/language/src/text_diff.rs index 1fb94b9f5e87015f317e3e88a963c06c7ea41b70..bc07ec73f0ad2c4738a2ca5f6ff955b53327acc3 100644 --- a/crates/language/src/text_diff.rs +++ b/crates/language/src/text_diff.rs @@ -48,7 +48,6 @@ pub fn text_diff(old_text: &str, new_text: &str) -> Vec<(Range, Arc) /// /// Returns a tuple of (old_ranges, new_ranges) where each vector contains /// the byte ranges of changed words in the respective text. -/// Whitespace-only changes are excluded from the results. pub fn word_diff_ranges( old_text: &str, new_text: &str, @@ -62,23 +61,23 @@ pub fn word_diff_ranges( let mut new_ranges: Vec> = Vec::new(); diff_internal(&input, |old_byte_range, new_byte_range, _, _| { - for range in split_on_whitespace(old_text, &old_byte_range) { + if !old_byte_range.is_empty() { if let Some(last) = old_ranges.last_mut() - && last.end >= range.start + && last.end >= old_byte_range.start { - last.end = range.end; + last.end = old_byte_range.end; } else { - old_ranges.push(range); + old_ranges.push(old_byte_range); } } - for range in split_on_whitespace(new_text, &new_byte_range) { + if !new_byte_range.is_empty() { if let Some(last) = new_ranges.last_mut() - && last.end >= range.start + && last.end >= new_byte_range.start { - last.end = range.end; + last.end = new_byte_range.end; } else { - new_ranges.push(range); + new_ranges.push(new_byte_range); } } }); @@ -86,50 +85,6 @@ pub fn word_diff_ranges( (old_ranges, new_ranges) } -fn split_on_whitespace(text: &str, range: &Range) -> Vec> { - if range.is_empty() { - return Vec::new(); - } - - let slice = &text[range.clone()]; - let mut ranges = Vec::new(); - let mut offset = 0; - - for line in slice.lines() { - let line_start = offset; - let line_end = line_start + line.len(); - offset = line_end + 1; - let trimmed = line.trim(); - - if !trimmed.is_empty() { - let leading = line.len() - line.trim_start().len(); - let trailing = line.len() - line.trim_end().len(); - let trimmed_start = range.start + line_start + leading; - let trimmed_end = range.start + line_end - trailing; - - let original_line_start = text[..range.start + line_start] - .rfind('\n') - .map(|i| i + 1) - .unwrap_or(0); - let original_line_end = text[range.start + line_start..] - .find('\n') - .map(|i| range.start + line_start + i) - .unwrap_or(text.len()); - let original_line = &text[original_line_start..original_line_end]; - let original_trimmed_start = - original_line_start + (original_line.len() - original_line.trim_start().len()); - let original_trimmed_end = - original_line_end - (original_line.len() - original_line.trim_end().len()); - - if trimmed_start > original_trimmed_start || trimmed_end < original_trimmed_end { - ranges.push(trimmed_start..trimmed_end); - } - } - } - - ranges -} - pub struct DiffOptions { pub language_scope: Option, pub max_word_diff_len: usize, diff --git a/crates/multi_buffer/src/multi_buffer_tests.rs b/crates/multi_buffer/src/multi_buffer_tests.rs index fc2edcac15be72c60309c5c386393ad83c387860..fb6dce079268e3dfed868a0c65c81bd12e226704 100644 --- a/crates/multi_buffer/src/multi_buffer_tests.rs +++ b/crates/multi_buffer/src/multi_buffer_tests.rs @@ -4480,6 +4480,19 @@ async fn test_word_diff_simple_replacement(cx: &mut TestAppContext) { assert_eq!(word_diffs, vec!["world", "bar", "WORLD", "BAR"]); } +#[gpui::test] +async fn test_word_diff_white_space(cx: &mut TestAppContext) { + let settings_store = cx.update(|cx| SettingsStore::test(cx)); + cx.set_global(settings_store); + + let base_text = "hello world foo bar\n"; + let modified_text = " hello world foo bar\n"; + + let word_diffs = collect_word_diffs(base_text, modified_text, cx); + + assert_eq!(word_diffs, vec![" "]); +} + #[gpui::test] async fn test_word_diff_consecutive_modified_lines(cx: &mut TestAppContext) { let settings_store = cx.update(|cx| SettingsStore::test(cx)); From c0b3422941bbc2a110c1999ff288ff99aa77aeca Mon Sep 17 00:00:00 2001 From: tidely <43219534+tidely@users.noreply.github.com> Date: Wed, 17 Dec 2025 13:27:06 +0200 Subject: [PATCH 111/266] node_runtime: Use `semver::Version` to represent package versions (#44342) Closes #ISSUE This PR is rather a nice to have change than anything critical, so review priority should remain low. Switch to using `semver::Version` for representing node binary and npm package versions. This is in an effort to root out implicit behavior and improve type safety when interacting with the `node_runtime` crate by catching invalid versions where they appear. Currently Zed may implicitly assume the current version is correct, or always install the newest version when a invalid version is passed. `semver::Version` also doesn't require the heap, which is probably more of a fun fact than anything useful. `npm_install_packages` still takes versions as a `&str`, because `latest` can be used to fetch the latest version on npm. This could likely be made into an enum as well, but would make the PR even larger. I tested changes with some node based language servers and external agents, which all worked fine. It would be nice to have some e2e tests for node. To be safe I'd put it on nightly after a Wednesday release. Release Notes: - N/A *or* Added/Fixed/Improved ... --- Cargo.lock | 2 + crates/copilot/src/copilot.rs | 5 +- .../src/wasm_host/wit/since_v0_8_0.rs | 2 + crates/language/Cargo.toml | 1 + crates/language/src/language.rs | 3 +- crates/languages/Cargo.toml | 1 + crates/languages/src/css.rs | 10 +-- crates/languages/src/json.rs | 10 +-- crates/languages/src/python.rs | 11 ++-- crates/languages/src/tailwind.rs | 10 +-- crates/languages/src/typescript.rs | 19 +++--- crates/languages/src/vtsls.rs | 19 +++--- crates/languages/src/yaml.rs | 11 ++-- crates/node_runtime/src/node_runtime.rs | 65 ++++++++----------- crates/project/src/agent_server_store.rs | 20 +++--- crates/project/src/debugger/session.rs | 23 ++++--- crates/project/src/lsp_store.rs | 3 +- crates/project/src/prettier_store.rs | 2 +- 18 files changed, 118 insertions(+), 99 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 080a6a4cf4183fb5cade03ba36072b448ab4b70a..20f19de832c567c6866731f128f049bd77d7be57 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8814,6 +8814,7 @@ dependencies = [ "regex", "rpc", "schemars", + "semver", "serde", "serde_json", "settings", @@ -9048,6 +9049,7 @@ dependencies = [ "regex", "rope", "rust-embed", + "semver", "serde", "serde_json", "serde_json_lenient", diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs index 45f0796bf53acfef1fb1e81146c0de7c5187fb99..f248fbdb43ec37b19ca951992df6a7ddbc4f7313 100644 --- a/crates/copilot/src/copilot.rs +++ b/crates/copilot/src/copilot.rs @@ -1246,7 +1246,10 @@ async fn get_copilot_lsp(fs: Arc, node_runtime: NodeRuntime) -> anyhow:: .await; if should_install { node_runtime - .npm_install_packages(paths::copilot_dir(), &[(PACKAGE_NAME, &latest_version)]) + .npm_install_packages( + paths::copilot_dir(), + &[(PACKAGE_NAME, &latest_version.to_string())], + ) .await?; } diff --git a/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs b/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs index b2e0a1a4fbbf302a41cd509c27df9f52dc9a788d..8b3f8e86b71e959eade1e5d3710ce66b5b2d3008 100644 --- a/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs +++ b/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs @@ -736,6 +736,7 @@ impl nodejs::Host for WasmState { .node_runtime .npm_package_latest_version(&package_name) .await + .map(|v| v.to_string()) .to_wasmtime_result() } @@ -747,6 +748,7 @@ impl nodejs::Host for WasmState { .node_runtime .npm_package_installed_version(&self.work_dir(), &package_name) .await + .map(|option| option.map(|version| version.to_string())) .to_wasmtime_result() } diff --git a/crates/language/Cargo.toml b/crates/language/Cargo.toml index 49ea681290c3edc878391a337c5423fa795dba4f..3ba93476d2a9fa5371b9d146cfc0c5833a748842 100644 --- a/crates/language/Cargo.toml +++ b/crates/language/Cargo.toml @@ -48,6 +48,7 @@ rand = { workspace = true, optional = true } regex.workspace = true rpc.workspace = true schemars.workspace = true +semver.workspace = true serde.workspace = true serde_json.workspace = true settings.workspace = true diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs index b0805c4ddd9d1203a1f1a3071e8640fd016c1fb1..eceb68f3e578fda97af292fee395a8ac4f0829c9 100644 --- a/crates/language/src/language.rs +++ b/crates/language/src/language.rs @@ -43,6 +43,7 @@ pub use manifest::{ManifestDelegate, ManifestName, ManifestProvider, ManifestQue use parking_lot::Mutex; use regex::Regex; use schemars::{JsonSchema, SchemaGenerator, json_schema}; +use semver::Version; use serde::{Deserialize, Deserializer, Serialize, Serializer, de}; use serde_json::Value; use settings::WorktreeId; @@ -347,7 +348,7 @@ pub trait LspAdapterDelegate: Send + Sync { async fn npm_package_installed_version( &self, package_name: &str, - ) -> Result>; + ) -> Result>; async fn which(&self, command: &OsStr) -> Option; async fn shell_env(&self) -> HashMap; async fn read_text_file(&self, path: &RelPath) -> Result; diff --git a/crates/languages/Cargo.toml b/crates/languages/Cargo.toml index c0aa9c39aacd86e45071bfe7f7289e50cb64b9b1..8529bdb82ace33d6f3c747ed707b9aac9d319627 100644 --- a/crates/languages/Cargo.toml +++ b/crates/languages/Cargo.toml @@ -68,6 +68,7 @@ serde_json.workspace = true serde_json_lenient.workspace = true settings.workspace = true smallvec.workspace = true +semver.workspace = true smol.workspace = true snippet.workspace = true task.workspace = true diff --git a/crates/languages/src/css.rs b/crates/languages/src/css.rs index 6a925586a622adbf6d8e2e3b1076278c3680a39a..ca6bbd827e1c58beb13244d61e69d5c14a29c89d 100644 --- a/crates/languages/src/css.rs +++ b/crates/languages/src/css.rs @@ -5,6 +5,7 @@ use language::{LspAdapter, LspAdapterDelegate, LspInstaller, Toolchain}; use lsp::{LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::lsp_store::language_server_settings; +use semver::Version; use serde_json::json; use std::{ ffi::OsString, @@ -32,14 +33,14 @@ impl CssLspAdapter { } impl LspInstaller for CssLspAdapter { - type BinaryVersion = String; + type BinaryVersion = Version; async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { self.node .npm_package_latest_version("vscode-langservers-extracted") .await @@ -65,11 +66,12 @@ impl LspInstaller for CssLspAdapter { async fn fetch_server_binary( &self, - latest_version: String, + latest_version: Self::BinaryVersion, container_dir: PathBuf, _: &dyn LspAdapterDelegate, ) -> Result { let server_path = container_dir.join(SERVER_PATH); + let latest_version = latest_version.to_string(); self.node .npm_install_packages( @@ -87,7 +89,7 @@ impl LspInstaller for CssLspAdapter { async fn check_if_version_installed( &self, - version: &String, + version: &Self::BinaryVersion, container_dir: &PathBuf, _: &dyn LspAdapterDelegate, ) -> Option { diff --git a/crates/languages/src/json.rs b/crates/languages/src/json.rs index 5168ba6e6188da62745df72a031f1d3bcda9a5d2..5e0f4907ef09973ad5d7b4f67c19ced1f1ddf05e 100644 --- a/crates/languages/src/json.rs +++ b/crates/languages/src/json.rs @@ -13,6 +13,7 @@ use language::{ use lsp::{LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::lsp_store::language_server_settings; +use semver::Version; use serde_json::{Value, json}; use smol::{ fs::{self}, @@ -142,14 +143,14 @@ impl JsonLspAdapter { } impl LspInstaller for JsonLspAdapter { - type BinaryVersion = String; + type BinaryVersion = Version; async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { self.node .npm_package_latest_version(Self::PACKAGE_NAME) .await @@ -175,7 +176,7 @@ impl LspInstaller for JsonLspAdapter { async fn check_if_version_installed( &self, - version: &String, + version: &Self::BinaryVersion, container_dir: &PathBuf, _: &dyn LspAdapterDelegate, ) -> Option { @@ -204,11 +205,12 @@ impl LspInstaller for JsonLspAdapter { async fn fetch_server_binary( &self, - latest_version: String, + latest_version: Self::BinaryVersion, container_dir: PathBuf, _: &dyn LspAdapterDelegate, ) -> Result { let server_path = container_dir.join(SERVER_PATH); + let latest_version = latest_version.to_string(); self.node .npm_install_packages( diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs index b987d059ccaf53126e427a36c4f598817acd63de..77d4be6f49a4928731d39d2154cbe4f0e38024ef 100644 --- a/crates/languages/src/python.rs +++ b/crates/languages/src/python.rs @@ -19,6 +19,7 @@ use pet_core::python_environment::{PythonEnvironment, PythonEnvironmentKind}; use pet_virtualenv::is_virtualenv_dir; use project::Fs; use project::lsp_store::language_server_settings; +use semver::Version; use serde::{Deserialize, Serialize}; use serde_json::{Value, json}; use settings::Settings; @@ -621,14 +622,14 @@ impl LspAdapter for PyrightLspAdapter { } impl LspInstaller for PyrightLspAdapter { - type BinaryVersion = String; + type BinaryVersion = Version; async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { self.node .npm_package_latest_version(Self::SERVER_NAME.as_ref()) .await @@ -672,6 +673,7 @@ impl LspInstaller for PyrightLspAdapter { delegate: &dyn LspAdapterDelegate, ) -> Result { let server_path = container_dir.join(Self::SERVER_PATH); + let latest_version = latest_version.to_string(); self.node .npm_install_packages( @@ -2040,14 +2042,14 @@ impl LspAdapter for BasedPyrightLspAdapter { } impl LspInstaller for BasedPyrightLspAdapter { - type BinaryVersion = String; + type BinaryVersion = Version; async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { self.node .npm_package_latest_version(Self::SERVER_NAME.as_ref()) .await @@ -2092,6 +2094,7 @@ impl LspInstaller for BasedPyrightLspAdapter { delegate: &dyn LspAdapterDelegate, ) -> Result { let server_path = container_dir.join(Self::SERVER_PATH); + let latest_version = latest_version.to_string(); self.node .npm_install_packages( diff --git a/crates/languages/src/tailwind.rs b/crates/languages/src/tailwind.rs index 7e23c4ba5255c0413904797d1f8094e67834fa6a..b4b6f76cec28d5d21c31ea67aa72ead6814eae7d 100644 --- a/crates/languages/src/tailwind.rs +++ b/crates/languages/src/tailwind.rs @@ -6,6 +6,7 @@ use language::{LanguageName, LspAdapter, LspAdapterDelegate, LspInstaller, Toolc use lsp::{LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::lsp_store::language_server_settings; +use semver::Version; use serde_json::{Value, json}; use std::{ ffi::OsString, @@ -39,14 +40,14 @@ impl TailwindLspAdapter { } impl LspInstaller for TailwindLspAdapter { - type BinaryVersion = String; + type BinaryVersion = Version; async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { self.node .npm_package_latest_version(Self::PACKAGE_NAME) .await @@ -70,11 +71,12 @@ impl LspInstaller for TailwindLspAdapter { async fn fetch_server_binary( &self, - latest_version: String, + latest_version: Self::BinaryVersion, container_dir: PathBuf, _: &dyn LspAdapterDelegate, ) -> Result { let server_path = container_dir.join(SERVER_PATH); + let latest_version = latest_version.to_string(); self.node .npm_install_packages( @@ -92,7 +94,7 @@ impl LspInstaller for TailwindLspAdapter { async fn check_if_version_installed( &self, - version: &String, + version: &Self::BinaryVersion, container_dir: &PathBuf, _: &dyn LspAdapterDelegate, ) -> Option { diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs index 7daf178d37229a5b051461e199c3dbf8d830cf22..4f9476d5afa488074b3d770b9f007d155b4863e7 100644 --- a/crates/languages/src/typescript.rs +++ b/crates/languages/src/typescript.rs @@ -12,6 +12,7 @@ use language::{ use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::{Fs, lsp_store::language_server_settings}; +use semver::Version; use serde_json::{Value, json}; use smol::lock::RwLock; use std::{ @@ -635,8 +636,8 @@ impl TypeScriptLspAdapter { } pub struct TypeScriptVersions { - typescript_version: String, - server_version: String, + typescript_version: Version, + server_version: Version, } impl LspInstaller for TypeScriptLspAdapter { @@ -647,7 +648,7 @@ impl LspInstaller for TypeScriptLspAdapter { _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { Ok(TypeScriptVersions { typescript_version: self .node @@ -662,7 +663,7 @@ impl LspInstaller for TypeScriptLspAdapter { async fn check_if_version_installed( &self, - version: &TypeScriptVersions, + version: &Self::BinaryVersion, container_dir: &PathBuf, _: &dyn LspAdapterDelegate, ) -> Option { @@ -674,7 +675,7 @@ impl LspInstaller for TypeScriptLspAdapter { Self::PACKAGE_NAME, &server_path, container_dir, - VersionStrategy::Latest(version.typescript_version.as_str()), + VersionStrategy::Latest(&version.typescript_version), ) .await { @@ -687,7 +688,7 @@ impl LspInstaller for TypeScriptLspAdapter { Self::SERVER_PACKAGE_NAME, &server_path, container_dir, - VersionStrategy::Latest(version.server_version.as_str()), + VersionStrategy::Latest(&version.server_version), ) .await { @@ -703,7 +704,7 @@ impl LspInstaller for TypeScriptLspAdapter { async fn fetch_server_binary( &self, - latest_version: TypeScriptVersions, + latest_version: Self::BinaryVersion, container_dir: PathBuf, _: &dyn LspAdapterDelegate, ) -> Result { @@ -715,11 +716,11 @@ impl LspInstaller for TypeScriptLspAdapter { &[ ( Self::PACKAGE_NAME, - latest_version.typescript_version.as_str(), + &latest_version.typescript_version.to_string(), ), ( Self::SERVER_PACKAGE_NAME, - latest_version.server_version.as_str(), + &latest_version.server_version.to_string(), ), ], ) diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs index b21ae1a4de24e0a8035e8fda7d61223b5143c5ff..3d38e022afe06f79d7e555263183a948c941f337 100644 --- a/crates/languages/src/vtsls.rs +++ b/crates/languages/src/vtsls.rs @@ -7,6 +7,7 @@ use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::{Fs, lsp_store::language_server_settings}; use regex::Regex; +use semver::Version; use serde_json::Value; use std::{ ffi::OsString, @@ -74,8 +75,8 @@ impl VtslsLspAdapter { } pub struct TypeScriptVersions { - typescript_version: String, - server_version: String, + typescript_version: Version, + server_version: Version, } const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("vtsls"); @@ -88,7 +89,7 @@ impl LspInstaller for VtslsLspAdapter { _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { Ok(TypeScriptVersions { typescript_version: self.node.npm_package_latest_version("typescript").await?, server_version: self @@ -115,12 +116,15 @@ impl LspInstaller for VtslsLspAdapter { async fn fetch_server_binary( &self, - latest_version: TypeScriptVersions, + latest_version: Self::BinaryVersion, container_dir: PathBuf, _: &dyn LspAdapterDelegate, ) -> Result { let server_path = container_dir.join(Self::SERVER_PATH); + let typescript_version = latest_version.typescript_version.to_string(); + let server_version = latest_version.server_version.to_string(); + let mut packages_to_install = Vec::new(); if self @@ -133,7 +137,7 @@ impl LspInstaller for VtslsLspAdapter { ) .await { - packages_to_install.push((Self::PACKAGE_NAME, latest_version.server_version.as_str())); + packages_to_install.push((Self::PACKAGE_NAME, server_version.as_str())); } if self @@ -146,10 +150,7 @@ impl LspInstaller for VtslsLspAdapter { ) .await { - packages_to_install.push(( - Self::TYPESCRIPT_PACKAGE_NAME, - latest_version.typescript_version.as_str(), - )); + packages_to_install.push((Self::TYPESCRIPT_PACKAGE_NAME, typescript_version.as_str())); } self.node diff --git a/crates/languages/src/yaml.rs b/crates/languages/src/yaml.rs index 57f254a68f126ac7f05c57d25ef0f920103f2233..6c1d8bc2d9e74578868dc687ec76a3b95790c5a9 100644 --- a/crates/languages/src/yaml.rs +++ b/crates/languages/src/yaml.rs @@ -7,6 +7,7 @@ use language::{ use lsp::{LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::lsp_store::language_server_settings; +use semver::Version; use serde_json::Value; use settings::{Settings, SettingsLocation}; use std::{ @@ -35,14 +36,14 @@ impl YamlLspAdapter { } impl LspInstaller for YamlLspAdapter { - type BinaryVersion = String; + type BinaryVersion = Version; async fn fetch_latest_server_version( &self, _: &dyn LspAdapterDelegate, _: bool, _: &mut AsyncApp, - ) -> Result { + ) -> Result { self.node .npm_package_latest_version("yaml-language-server") .await @@ -66,7 +67,7 @@ impl LspInstaller for YamlLspAdapter { async fn fetch_server_binary( &self, - latest_version: String, + latest_version: Self::BinaryVersion, container_dir: PathBuf, _: &dyn LspAdapterDelegate, ) -> Result { @@ -75,7 +76,7 @@ impl LspInstaller for YamlLspAdapter { self.node .npm_install_packages( &container_dir, - &[(Self::PACKAGE_NAME, latest_version.as_str())], + &[(Self::PACKAGE_NAME, &latest_version.to_string())], ) .await?; @@ -88,7 +89,7 @@ impl LspInstaller for YamlLspAdapter { async fn check_if_version_installed( &self, - version: &String, + version: &Self::BinaryVersion, container_dir: &PathBuf, _: &dyn LspAdapterDelegate, ) -> Option { diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs index 322117cd717cac5c604ba215a2a1c7e0f7d87f06..5e4297988b665c3b89771838ef629ee87e88fb5b 100644 --- a/crates/node_runtime/src/node_runtime.rs +++ b/crates/node_runtime/src/node_runtime.rs @@ -34,9 +34,9 @@ pub struct NodeBinaryOptions { pub enum VersionStrategy<'a> { /// Install if current version doesn't match pinned version - Pin(&'a str), + Pin(&'a Version), /// Install if current version is older than latest version - Latest(&'a str), + Latest(&'a Version), } #[derive(Clone)] @@ -230,14 +230,14 @@ impl NodeRuntime { &self, local_package_directory: &Path, name: &str, - ) -> Result> { + ) -> Result> { self.instance() .await .npm_package_installed_version(local_package_directory, name) .await } - pub async fn npm_package_latest_version(&self, name: &str) -> Result { + pub async fn npm_package_latest_version(&self, name: &str) -> Result { let http = self.0.lock().await.http.clone(); let output = self .instance() @@ -280,16 +280,19 @@ impl NodeRuntime { .map(|(name, version)| format!("{name}@{version}")) .collect(); - let mut arguments: Vec<_> = packages.iter().map(|p| p.as_str()).collect(); - arguments.extend_from_slice(&[ - "--save-exact", - "--fetch-retry-mintimeout", - "2000", - "--fetch-retry-maxtimeout", - "5000", - "--fetch-timeout", - "5000", - ]); + let arguments: Vec<_> = packages + .iter() + .map(|p| p.as_str()) + .chain([ + "--save-exact", + "--fetch-retry-mintimeout", + "2000", + "--fetch-retry-maxtimeout", + "5000", + "--fetch-timeout", + "5000", + ]) + .collect(); // This is also wrong because the directory is wrong. self.run_npm_subcommand(Some(directory), "install", &arguments) @@ -320,23 +323,9 @@ impl NodeRuntime { return true; }; - let Some(installed_version) = Version::parse(&installed_version).log_err() else { - return true; - }; - match version_strategy { - VersionStrategy::Pin(pinned_version) => { - let Some(pinned_version) = Version::parse(pinned_version).log_err() else { - return true; - }; - installed_version != pinned_version - } - VersionStrategy::Latest(latest_version) => { - let Some(latest_version) = Version::parse(latest_version).log_err() else { - return true; - }; - installed_version < latest_version - } + VersionStrategy::Pin(pinned_version) => &installed_version != pinned_version, + VersionStrategy::Latest(latest_version) => &installed_version < latest_version, } } } @@ -351,12 +340,12 @@ enum ArchiveType { pub struct NpmInfo { #[serde(default)] dist_tags: NpmInfoDistTags, - versions: Vec, + versions: Vec, } #[derive(Debug, Deserialize, Default)] pub struct NpmInfoDistTags { - latest: Option, + latest: Option, } #[async_trait::async_trait] @@ -376,7 +365,7 @@ trait NodeRuntimeTrait: Send + Sync { &self, local_package_directory: &Path, name: &str, - ) -> Result>; + ) -> Result>; } #[derive(Clone)] @@ -610,7 +599,7 @@ impl NodeRuntimeTrait for ManagedNodeRuntime { &self, local_package_directory: &Path, name: &str, - ) -> Result> { + ) -> Result> { read_package_installed_version(local_package_directory.join("node_modules"), name).await } } @@ -735,7 +724,7 @@ impl NodeRuntimeTrait for SystemNodeRuntime { &self, local_package_directory: &Path, name: &str, - ) -> Result> { + ) -> Result> { read_package_installed_version(local_package_directory.join("node_modules"), name).await // todo: allow returning a globally installed version (requires callers not to hard-code the path) } @@ -744,7 +733,7 @@ impl NodeRuntimeTrait for SystemNodeRuntime { pub async fn read_package_installed_version( node_module_directory: PathBuf, name: &str, -) -> Result> { +) -> Result> { let package_json_path = node_module_directory.join(name).join("package.json"); let mut file = match fs::File::open(package_json_path).await { @@ -760,7 +749,7 @@ pub async fn read_package_installed_version( #[derive(Deserialize)] struct PackageJson { - version: String, + version: Version, } let mut contents = String::new(); @@ -797,7 +786,7 @@ impl NodeRuntimeTrait for UnavailableNodeRuntime { &self, _local_package_directory: &Path, _: &str, - ) -> Result> { + ) -> Result> { bail!("{}", self.error_message) } } diff --git a/crates/project/src/agent_server_store.rs b/crates/project/src/agent_server_store.rs index a2cc57beae9702e4d5b495a135e7c357c638c17a..287b25935676e2d5a09e92285a6cc94b81e52e13 100644 --- a/crates/project/src/agent_server_store.rs +++ b/crates/project/src/agent_server_store.rs @@ -22,6 +22,7 @@ use rpc::{ proto::{self, ExternalExtensionAgent}, }; use schemars::JsonSchema; +use semver::Version; use serde::{Deserialize, Serialize}; use settings::{RegisterSetting, SettingsStore}; use task::{Shell, SpawnInTerminal}; @@ -974,11 +975,10 @@ fn get_or_npm_install_builtin_agent( } versions.sort(); - let newest_version = if let Some((version, file_name)) = versions.last().cloned() + let newest_version = if let Some((version, _)) = versions.last().cloned() && minimum_version.is_none_or(|minimum_version| version >= minimum_version) { - versions.pop(); - Some(file_name) + versions.pop() } else { None }; @@ -1004,9 +1004,8 @@ fn get_or_npm_install_builtin_agent( }) .detach(); - let version = if let Some(file_name) = newest_version { + let version = if let Some((version, file_name)) = newest_version { cx.background_spawn({ - let file_name = file_name.clone(); let dir = dir.clone(); let fs = fs.clone(); async move { @@ -1015,7 +1014,7 @@ fn get_or_npm_install_builtin_agent( .await .ok(); if let Some(latest_version) = latest_version - && &latest_version != &file_name.to_string_lossy() + && latest_version != version { let download_result = download_latest_version( fs, @@ -1028,7 +1027,9 @@ fn get_or_npm_install_builtin_agent( if let Some(mut new_version_available) = new_version_available && download_result.is_some() { - new_version_available.send(Some(latest_version)).ok(); + new_version_available + .send(Some(latest_version.to_string())) + .ok(); } } } @@ -1047,6 +1048,7 @@ fn get_or_npm_install_builtin_agent( package_name.clone(), )) .await? + .to_string() .into() }; @@ -1093,7 +1095,7 @@ async fn download_latest_version( dir: PathBuf, node_runtime: NodeRuntime, package_name: SharedString, -) -> Result { +) -> Result { log::debug!("downloading latest version of {package_name}"); let tmp_dir = tempfile::tempdir_in(&dir)?; @@ -1109,7 +1111,7 @@ async fn download_latest_version( fs.rename( &tmp_dir.keep(), - &dir.join(&version), + &dir.join(version.to_string()), RenameOptions { ignore_if_exists: true, overwrite: true, diff --git a/crates/project/src/debugger/session.rs b/crates/project/src/debugger/session.rs index 82a139ea242889f89c3a6a0c6d41e83e00cbfec2..1bc41df4bd89b4a32b71ed4f0bec0a61e729f998 100644 --- a/crates/project/src/debugger/session.rs +++ b/crates/project/src/debugger/session.rs @@ -3118,10 +3118,11 @@ async fn get_or_install_companion(node: NodeRuntime, cx: &mut AsyncApp) -> Resul .await .context("getting installed companion version")? .context("companion was not installed")?; - smol::fs::rename(temp_dir.path(), dir.join(&version)) + let version_folder = dir.join(version.to_string()); + smol::fs::rename(temp_dir.path(), &version_folder) .await .context("moving companion package into place")?; - Ok(dir.join(version)) + Ok(version_folder) } let dir = paths::debug_adapters_dir().join("js-debug-companion"); @@ -3134,19 +3135,23 @@ async fn get_or_install_companion(node: NodeRuntime, cx: &mut AsyncApp) -> Resul .await .context("creating companion installation directory")?; - let mut children = smol::fs::read_dir(&dir) + let children = smol::fs::read_dir(&dir) .await .context("reading companion installation directory")? .try_collect::>() .await .context("reading companion installation directory entries")?; - children - .sort_by_key(|child| semver::Version::parse(child.file_name().to_str()?).ok()); - let latest_installed_version = children.last().and_then(|child| { - let version = child.file_name().into_string().ok()?; - Some((child.path(), version)) - }); + let latest_installed_version = children + .iter() + .filter_map(|child| { + Some(( + child.path(), + semver::Version::parse(child.file_name().to_str()?).ok()?, + )) + }) + .max_by_key(|(_, version)| version.clone()); + let latest_version = node .npm_package_latest_version(PACKAGE_NAME) .await diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 83c2abfbb863166fd52e177dd75b497ca5111999..9b3eeebed79724196290738b51376e412ca11b22 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -93,6 +93,7 @@ use rpc::{ AnyProtoClient, ErrorCode, ErrorExt as _, proto::{LspRequestId, LspRequestMessage as _}, }; +use semver::Version; use serde::Serialize; use serde_json::Value; use settings::{Settings, SettingsLocation, SettingsStore}; @@ -13981,7 +13982,7 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate { async fn npm_package_installed_version( &self, package_name: &str, - ) -> Result> { + ) -> Result> { let local_package_directory = self.worktree_root_path(); let node_modules_directory = local_package_directory.join("node_modules"); diff --git a/crates/project/src/prettier_store.rs b/crates/project/src/prettier_store.rs index 40deac76404ddb4378fe08cae931d0f0e3583487..a8b6fe37701d85d06d837a0a5e494e2a294777ec 100644 --- a/crates/project/src/prettier_store.rs +++ b/crates/project/src/prettier_store.rs @@ -905,7 +905,7 @@ async fn install_prettier_packages( .with_context(|| { format!("fetching latest npm version for package {returned_package_name}") })?; - anyhow::Ok((returned_package_name, latest_version)) + anyhow::Ok((returned_package_name, latest_version.to_string())) }), ) .await From edf21a38c18070554602441eeb8d3cfcf1ca0210 Mon Sep 17 00:00:00 2001 From: Shardul Vaidya <31039336+5herlocked@users.noreply.github.com> Date: Wed, 17 Dec 2025 06:54:57 -0500 Subject: [PATCH 112/266] bedrock: Add Bedrock API key authentication support (#41393) --- Cargo.lock | 65 +-- Cargo.toml | 10 +- crates/bedrock/src/bedrock.rs | 2 +- .../language_models/src/provider/bedrock.rs | 455 ++++++++++++------ .../src/settings_content/language_model.rs | 2 + 5 files changed, 351 insertions(+), 183 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 20f19de832c567c6866731f128f049bd77d7be57..de9cb227c6cfb799099abf446c1bdee61ec85bff 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1441,9 +1441,9 @@ dependencies = [ [[package]] name = "aws-config" -version = "1.8.8" +version = "1.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37cf2b6af2a95a20e266782b4f76f1a5e12bf412a9db2de9c1e9123b9d8c0ad8" +checksum = "1856b1b48b65f71a4dd940b1c0931f9a7b646d4a924b9828ffefc1454714668a" dependencies = [ "aws-credential-types", "aws-runtime", @@ -1507,9 +1507,9 @@ dependencies = [ [[package]] name = "aws-runtime" -version = "1.5.12" +version = "1.5.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa006bb32360ed90ac51203feafb9d02e3d21046e1fd3a450a404b90ea73e5d" +checksum = "9f2402da1a5e16868ba98725e5d73f26b8116eaa892e56f2cd0bf5eec7985f70" dependencies = [ "aws-credential-types", "aws-sigv4", @@ -1532,9 +1532,9 @@ dependencies = [ [[package]] name = "aws-sdk-bedrockruntime" -version = "1.109.0" +version = "1.112.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbfdfd941dcb253c17bf70baddbf1e5b22f19e29d313d2e049bad4b1dadb2011" +checksum = "c06c037e6823696d752702ec2bad758d3cf95d1b92b712c8ac7e93824b5e2391" dependencies = [ "aws-credential-types", "aws-runtime", @@ -1614,9 +1614,9 @@ dependencies = [ [[package]] name = "aws-sdk-sso" -version = "1.86.0" +version = "1.88.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a0abbfab841446cce6e87af853a3ba2cc1bc9afcd3f3550dd556c43d434c86d" +checksum = "d05b276777560aa9a196dbba2e3aada4d8006d3d7eeb3ba7fe0c317227d933c4" dependencies = [ "aws-credential-types", "aws-runtime", @@ -1636,9 +1636,9 @@ dependencies = [ [[package]] name = "aws-sdk-ssooidc" -version = "1.88.0" +version = "1.90.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a68d675582afea0e94d38b6ca9c5aaae4ca14f1d36faa6edb19b42e687e70d7" +checksum = "f9be14d6d9cd761fac3fd234a0f47f7ed6c0df62d83c0eeb7012750e4732879b" dependencies = [ "aws-credential-types", "aws-runtime", @@ -1658,9 +1658,9 @@ dependencies = [ [[package]] name = "aws-sdk-sts" -version = "1.88.0" +version = "1.90.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d30990923f4f675523c51eb1c0dec9b752fb267b36a61e83cbc219c9d86da715" +checksum = "98a862d704c817d865c8740b62d8bbeb5adcb30965e93b471df8a5bcefa20a80" dependencies = [ "aws-credential-types", "aws-runtime", @@ -1681,9 +1681,9 @@ dependencies = [ [[package]] name = "aws-sigv4" -version = "1.3.5" +version = "1.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bffc03068fbb9c8dd5ce1c6fb240678a5cffb86fb2b7b1985c999c4b83c8df68" +checksum = "c35452ec3f001e1f2f6db107b6373f1f48f05ec63ba2c5c9fa91f07dad32af11" dependencies = [ "aws-credential-types", "aws-smithy-eventstream", @@ -1740,9 +1740,9 @@ dependencies = [ [[package]] name = "aws-smithy-eventstream" -version = "0.60.12" +version = "0.60.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9656b85088f8d9dc7ad40f9a6c7228e1e8447cdf4b046c87e152e0805dea02fa" +checksum = "e29a304f8319781a39808847efb39561351b1bb76e933da7aa90232673638658" dependencies = [ "aws-smithy-types", "bytes 1.10.1", @@ -1751,9 +1751,9 @@ dependencies = [ [[package]] name = "aws-smithy-http" -version = "0.62.4" +version = "0.62.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3feafd437c763db26aa04e0cc7591185d0961e64c61885bece0fb9d50ceac671" +checksum = "445d5d720c99eed0b4aa674ed00d835d9b1427dd73e04adaf2f94c6b2d6f9fca" dependencies = [ "aws-smithy-eventstream", "aws-smithy-runtime-api", @@ -1761,6 +1761,7 @@ dependencies = [ "bytes 1.10.1", "bytes-utils", "futures-core", + "futures-util", "http 0.2.12", "http 1.3.1", "http-body 0.4.6", @@ -1772,9 +1773,9 @@ dependencies = [ [[package]] name = "aws-smithy-http-client" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1053b5e587e6fa40ce5a79ea27957b04ba660baa02b28b7436f64850152234f1" +checksum = "623254723e8dfd535f566ee7b2381645f8981da086b5c4aa26c0c41582bb1d2c" dependencies = [ "aws-smithy-async", "aws-smithy-runtime-api", @@ -1802,9 +1803,9 @@ dependencies = [ [[package]] name = "aws-smithy-json" -version = "0.61.6" +version = "0.61.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cff418fc8ec5cadf8173b10125f05c2e7e1d46771406187b2c878557d4503390" +checksum = "2db31f727935fc63c6eeae8b37b438847639ec330a9161ece694efba257e0c54" dependencies = [ "aws-smithy-types", ] @@ -1830,9 +1831,9 @@ dependencies = [ [[package]] name = "aws-smithy-runtime" -version = "1.9.3" +version = "1.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40ab99739082da5347660c556689256438defae3bcefd66c52b095905730e404" +checksum = "0bbe9d018d646b96c7be063dd07987849862b0e6d07c778aad7d93d1be6c1ef0" dependencies = [ "aws-smithy-async", "aws-smithy-http", @@ -1854,9 +1855,9 @@ dependencies = [ [[package]] name = "aws-smithy-runtime-api" -version = "1.9.1" +version = "1.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3683c5b152d2ad753607179ed71988e8cfd52964443b4f74fd8e552d0bbfeb46" +checksum = "ec7204f9fd94749a7c53b26da1b961b4ac36bf070ef1e0b94bb09f79d4f6c193" dependencies = [ "aws-smithy-async", "aws-smithy-types", @@ -1871,9 +1872,9 @@ dependencies = [ [[package]] name = "aws-smithy-types" -version = "1.3.3" +version = "1.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f5b3a7486f6690ba25952cabf1e7d75e34d69eaff5081904a47bc79074d6457" +checksum = "25f535879a207fce0db74b679cfc3e91a3159c8144d717d55f5832aea9eef46e" dependencies = [ "base64-simd", "bytes 1.10.1", @@ -1897,18 +1898,18 @@ dependencies = [ [[package]] name = "aws-smithy-xml" -version = "0.60.11" +version = "0.60.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e9c34127e8c624bc2999f3b657e749c1393bedc9cd97b92a804db8ced4d2e163" +checksum = "eab77cdd036b11056d2a30a7af7b775789fb024bf216acc13884c6c97752ae56" dependencies = [ "xmlparser", ] [[package]] name = "aws-types" -version = "1.3.9" +version = "1.3.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2fd329bf0e901ff3f60425691410c69094dc2a1f34b331f37bfc4e9ac1565a1" +checksum = "d79fb68e3d7fe5d4833ea34dc87d2e97d26d3086cb3da660bb6b1f76d98680b6" dependencies = [ "aws-credential-types", "aws-smithy-async", diff --git a/Cargo.toml b/Cargo.toml index f46ffa2583c022be8704e95684ddce65b19d3fab..a8002e207d7ba9d3699832ac76be530e1979ead4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -455,15 +455,15 @@ async-task = "4.7" async-trait = "0.1" async-tungstenite = "0.31.0" async_zip = { version = "0.0.18", features = ["deflate", "deflate64"] } -aws-config = { version = "1.6.1", features = ["behavior-version-latest"] } -aws-credential-types = { version = "1.2.2", features = [ +aws-config = { version = "1.8.10", features = ["behavior-version-latest"] } +aws-credential-types = { version = "1.2.8", features = [ "hardcoded-credentials", ] } -aws-sdk-bedrockruntime = { version = "1.80.0", features = [ +aws-sdk-bedrockruntime = { version = "1.112.0", features = [ "behavior-version-latest", ] } -aws-smithy-runtime-api = { version = "1.7.4", features = ["http-1x", "client"] } -aws-smithy-types = { version = "1.3.0", features = ["http-body-1-x"] } +aws-smithy-runtime-api = { version = "1.9.2", features = ["http-1x", "client"] } +aws-smithy-types = { version = "1.3.4", features = ["http-body-1-x"] } backtrace = "0.3" base64 = "0.22" bincode = "1.2.1" diff --git a/crates/bedrock/src/bedrock.rs b/crates/bedrock/src/bedrock.rs index ec0b4070906fdfd31195668312b3e7b425cd28ee..744dde38076a5a12c9bc957a75e2435b1b753d96 100644 --- a/crates/bedrock/src/bedrock.rs +++ b/crates/bedrock/src/bedrock.rs @@ -87,7 +87,7 @@ pub async fn stream_completion( Ok(None) => None, Err(err) => Some(( Err(BedrockError::ClientError(anyhow!( - "{:?}", + "{}", aws_sdk_bedrockruntime::error::DisplayErrorContext(err) ))), stream, diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs index b85a038bb235d97bd9de8614f19764ecabf7bbfe..9273234161a8169abf68190ca8fe4627b8f769dc 100644 --- a/crates/language_models/src/provider/bedrock.rs +++ b/crates/language_models/src/provider/bedrock.rs @@ -5,7 +5,7 @@ use std::sync::Arc; use anyhow::{Context as _, Result, anyhow}; use aws_config::stalled_stream_protection::StalledStreamProtectionConfig; use aws_config::{BehaviorVersion, Region}; -use aws_credential_types::Credentials; +use aws_credential_types::{Credentials, Token}; use aws_http_client::AwsHttpClient; use bedrock::bedrock_client::Client as BedrockClient; use bedrock::bedrock_client::config::timeout::TimeoutConfig; @@ -30,18 +30,19 @@ use gpui::{ use gpui_tokio::Tokio; use http_client::HttpClient; use language_model::{ - AuthenticateError, LanguageModel, LanguageModelCacheConfiguration, + AuthenticateError, EnvVar, LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, RateLimiter, Role, - TokenUsage, + TokenUsage, env_var, }; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use serde_json::Value; use settings::{BedrockAvailableModel as AvailableModel, Settings, SettingsStore}; use smol::lock::OnceCell; +use std::sync::LazyLock; use strum::{EnumIter, IntoEnumIterator, IntoStaticStr}; use ui::{ButtonLink, ConfiguredApiCard, List, ListBulletItem, prelude::*}; use ui_input::InputField; @@ -54,12 +55,52 @@ actions!(bedrock, [Tab, TabPrev]); const PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("amazon-bedrock"); const PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new("Amazon Bedrock"); +/// Credentials stored in the keychain for static authentication. +/// Region is handled separately since it's orthogonal to auth method. #[derive(Default, Clone, Deserialize, Serialize, PartialEq, Debug)] pub struct BedrockCredentials { pub access_key_id: String, pub secret_access_key: String, pub session_token: Option, - pub region: String, + pub bearer_token: Option, +} + +/// Resolved authentication configuration for Bedrock. +/// Settings take priority over UX-provided credentials. +#[derive(Clone, Debug, PartialEq)] +pub enum BedrockAuth { + /// Use default AWS credential provider chain (IMDSv2, PodIdentity, env vars, etc.) + Automatic, + /// Use AWS named profile from ~/.aws/credentials or ~/.aws/config + NamedProfile { profile_name: String }, + /// Use AWS SSO profile + SingleSignOn { profile_name: String }, + /// Use IAM credentials (access key + secret + optional session token) + IamCredentials { + access_key_id: String, + secret_access_key: String, + session_token: Option, + }, + /// Use Bedrock API Key (bearer token authentication) + ApiKey { api_key: String }, +} + +impl BedrockCredentials { + /// Convert stored credentials to the appropriate auth variant. + /// Prefers API key if present, otherwise uses IAM credentials. + fn into_auth(self) -> Option { + if let Some(api_key) = self.bearer_token.filter(|t| !t.is_empty()) { + Some(BedrockAuth::ApiKey { api_key }) + } else if !self.access_key_id.is_empty() && !self.secret_access_key.is_empty() { + Some(BedrockAuth::IamCredentials { + access_key_id: self.access_key_id, + secret_access_key: self.secret_access_key, + session_token: self.session_token.filter(|t| !t.is_empty()), + }) + } else { + None + } + } } #[derive(Default, Clone, Debug, PartialEq)] @@ -79,6 +120,8 @@ pub enum BedrockAuthMethod { NamedProfile, #[serde(rename = "sso")] SingleSignOn, + #[serde(rename = "api_key")] + ApiKey, /// IMDSv2, PodIdentity, env vars, etc. #[serde(rename = "default")] Automatic, @@ -90,6 +133,7 @@ impl From for BedrockAuthMethod { settings::BedrockAuthMethodContent::SingleSignOn => BedrockAuthMethod::SingleSignOn, settings::BedrockAuthMethodContent::Automatic => BedrockAuthMethod::Automatic, settings::BedrockAuthMethodContent::NamedProfile => BedrockAuthMethod::NamedProfile, + settings::BedrockAuthMethodContent::ApiKey => BedrockAuthMethod::ApiKey, } } } @@ -130,23 +174,26 @@ impl From for ModelMode { const AMAZON_AWS_URL: &str = "https://amazonaws.com"; // These environment variables all use a `ZED_` prefix because we don't want to overwrite the user's AWS credentials. -const ZED_BEDROCK_ACCESS_KEY_ID_VAR: &str = "ZED_ACCESS_KEY_ID"; -const ZED_BEDROCK_SECRET_ACCESS_KEY_VAR: &str = "ZED_SECRET_ACCESS_KEY"; -const ZED_BEDROCK_SESSION_TOKEN_VAR: &str = "ZED_SESSION_TOKEN"; -const ZED_AWS_PROFILE_VAR: &str = "ZED_AWS_PROFILE"; -const ZED_BEDROCK_REGION_VAR: &str = "ZED_AWS_REGION"; -const ZED_AWS_CREDENTIALS_VAR: &str = "ZED_AWS_CREDENTIALS"; -const ZED_AWS_ENDPOINT_VAR: &str = "ZED_AWS_ENDPOINT"; +static ZED_BEDROCK_ACCESS_KEY_ID_VAR: LazyLock = env_var!("ZED_ACCESS_KEY_ID"); +static ZED_BEDROCK_SECRET_ACCESS_KEY_VAR: LazyLock = env_var!("ZED_SECRET_ACCESS_KEY"); +static ZED_BEDROCK_SESSION_TOKEN_VAR: LazyLock = env_var!("ZED_SESSION_TOKEN"); +static ZED_AWS_PROFILE_VAR: LazyLock = env_var!("ZED_AWS_PROFILE"); +static ZED_BEDROCK_REGION_VAR: LazyLock = env_var!("ZED_AWS_REGION"); +static ZED_AWS_ENDPOINT_VAR: LazyLock = env_var!("ZED_AWS_ENDPOINT"); +static ZED_BEDROCK_BEARER_TOKEN_VAR: LazyLock = env_var!("ZED_BEDROCK_BEARER_TOKEN"); pub struct State { - credentials: Option, + /// The resolved authentication method. Settings take priority over UX credentials. + auth: Option, + /// Raw settings from settings.json settings: Option, + /// Whether credentials came from environment variables (only relevant for static credentials) credentials_from_env: bool, _subscription: Subscription, } impl State { - fn reset_credentials(&self, cx: &mut Context) -> Task> { + fn reset_auth(&self, cx: &mut Context) -> Task> { let credentials_provider = ::global(cx); cx.spawn(async move |this, cx| { credentials_provider @@ -154,19 +201,19 @@ impl State { .await .log_err(); this.update(cx, |this, cx| { - this.credentials = None; + this.auth = None; this.credentials_from_env = false; - this.settings = None; cx.notify(); }) }) } - fn set_credentials( + fn set_static_credentials( &mut self, credentials: BedrockCredentials, cx: &mut Context, ) -> Task> { + let auth = credentials.clone().into_auth(); let credentials_provider = ::global(cx); cx.spawn(async move |this, cx| { credentials_provider @@ -178,50 +225,131 @@ impl State { ) .await?; this.update(cx, |this, cx| { - this.credentials = Some(credentials); + this.auth = auth; + this.credentials_from_env = false; cx.notify(); }) }) } fn is_authenticated(&self) -> bool { - let derived = self - .settings - .as_ref() - .and_then(|s| s.authentication_method.as_ref()); - let creds = self.credentials.as_ref(); - - derived.is_some() || creds.is_some() + self.auth.is_some() } + /// Resolve authentication. Settings take priority over UX-provided credentials. fn authenticate(&self, cx: &mut Context) -> Task> { if self.is_authenticated() { return Task::ready(Ok(())); } + // Step 1: Check if settings specify an auth method (enterprise control) + if let Some(settings) = &self.settings { + if let Some(method) = &settings.authentication_method { + let profile_name = settings + .profile_name + .clone() + .unwrap_or_else(|| "default".to_string()); + + let auth = match method { + BedrockAuthMethod::Automatic => BedrockAuth::Automatic, + BedrockAuthMethod::NamedProfile => BedrockAuth::NamedProfile { profile_name }, + BedrockAuthMethod::SingleSignOn => BedrockAuth::SingleSignOn { profile_name }, + BedrockAuthMethod::ApiKey => { + // ApiKey method means "use static credentials from keychain/env" + // Fall through to load them below + return self.load_static_credentials(cx); + } + }; + + return cx.spawn(async move |this, cx| { + this.update(cx, |this, cx| { + this.auth = Some(auth); + this.credentials_from_env = false; + cx.notify(); + })?; + Ok(()) + }); + } + } + + // Step 2: No settings auth method - try to load static credentials + self.load_static_credentials(cx) + } + + /// Load static credentials from environment variables or keychain. + fn load_static_credentials( + &self, + cx: &mut Context, + ) -> Task> { let credentials_provider = ::global(cx); cx.spawn(async move |this, cx| { - let (credentials, from_env) = - if let Ok(credentials) = std::env::var(ZED_AWS_CREDENTIALS_VAR) { - (credentials, true) - } else { - let (_, credentials) = credentials_provider - .read_credentials(AMAZON_AWS_URL, cx) - .await? - .ok_or_else(|| AuthenticateError::CredentialsNotFound)?; + // Try environment variables first + let (auth, from_env) = if let Some(bearer_token) = &ZED_BEDROCK_BEARER_TOKEN_VAR.value { + if !bearer_token.is_empty() { ( - String::from_utf8(credentials) - .context("invalid {PROVIDER_NAME} credentials")?, - false, + Some(BedrockAuth::ApiKey { + api_key: bearer_token.to_string(), + }), + true, ) - }; + } else { + (None, false) + } + } else if let Some(access_key_id) = &ZED_BEDROCK_ACCESS_KEY_ID_VAR.value { + if let Some(secret_access_key) = &ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.value { + if !access_key_id.is_empty() && !secret_access_key.is_empty() { + let session_token = ZED_BEDROCK_SESSION_TOKEN_VAR + .value + .as_deref() + .filter(|s| !s.is_empty()) + .map(|s| s.to_string()); + ( + Some(BedrockAuth::IamCredentials { + access_key_id: access_key_id.to_string(), + secret_access_key: secret_access_key.to_string(), + session_token, + }), + true, + ) + } else { + (None, false) + } + } else { + (None, false) + } + } else { + (None, false) + }; + + // If we got auth from env vars, use it + if let Some(auth) = auth { + this.update(cx, |this, cx| { + this.auth = Some(auth); + this.credentials_from_env = from_env; + cx.notify(); + })?; + return Ok(()); + } + + // Try keychain + let (_, credentials_bytes) = credentials_provider + .read_credentials(AMAZON_AWS_URL, cx) + .await? + .ok_or(AuthenticateError::CredentialsNotFound)?; + + let credentials_str = String::from_utf8(credentials_bytes) + .context("invalid {PROVIDER_NAME} credentials")?; let credentials: BedrockCredentials = - serde_json::from_str(&credentials).context("failed to parse credentials")?; + serde_json::from_str(&credentials_str).context("failed to parse credentials")?; + + let auth = credentials + .into_auth() + .ok_or(AuthenticateError::CredentialsNotFound)?; this.update(cx, |this, cx| { - this.credentials = Some(credentials); - this.credentials_from_env = from_env; + this.auth = Some(auth); + this.credentials_from_env = false; cx.notify(); })?; @@ -229,15 +357,19 @@ impl State { }) } + /// Get the resolved region. Checks env var, then settings, then defaults to us-east-1. fn get_region(&self) -> String { - // Get region - from credentials or directly from settings - let credentials_region = self.credentials.as_ref().map(|s| s.region.clone()); - let settings_region = self.settings.as_ref().and_then(|s| s.region.clone()); - - // Use credentials region if available, otherwise use settings region, finally fall back to default - credentials_region - .or(settings_region) - .unwrap_or(String::from("us-east-1")) + // Priority: env var > settings > default + if let Some(region) = ZED_BEDROCK_REGION_VAR.value.as_deref() { + if !region.is_empty() { + return region.to_string(); + } + } + + self.settings + .as_ref() + .and_then(|s| s.region.clone()) + .unwrap_or_else(|| "us-east-1".to_string()) } fn get_allow_global(&self) -> bool { @@ -257,7 +389,7 @@ pub struct BedrockLanguageModelProvider { impl BedrockLanguageModelProvider { pub fn new(http_client: Arc, cx: &mut App) -> Self { let state = cx.new(|cx| State { - credentials: None, + auth: None, settings: Some(AllLanguageModelSettings::get_global(cx).bedrock.clone()), credentials_from_env: false, _subscription: cx.observe_global::(|_, cx| { @@ -266,7 +398,7 @@ impl BedrockLanguageModelProvider { }); Self { - http_client: AwsHttpClient::new(http_client.clone()), + http_client: AwsHttpClient::new(http_client), handle: Tokio::handle(cx), state, } @@ -312,7 +444,6 @@ impl LanguageModelProvider for BedrockLanguageModelProvider { for model in bedrock::Model::iter() { if !matches!(model, bedrock::Model::Custom { .. }) { - // TODO: Sonnet 3.7 vs. 3.7 Thinking bug is here. models.insert(model.id().to_string(), model); } } @@ -366,8 +497,7 @@ impl LanguageModelProvider for BedrockLanguageModelProvider { } fn reset_credentials(&self, cx: &mut App) -> Task> { - self.state - .update(cx, |state, cx| state.reset_credentials(cx)) + self.state.update(cx, |state, cx| state.reset_auth(cx)) } } @@ -393,25 +523,11 @@ impl BedrockModel { fn get_or_init_client(&self, cx: &AsyncApp) -> anyhow::Result<&BedrockClient> { self.client .get_or_try_init_blocking(|| { - let (auth_method, credentials, endpoint, region, settings) = - cx.read_entity(&self.state, |state, _cx| { - let auth_method = state - .settings - .as_ref() - .and_then(|s| s.authentication_method.clone()); - - let endpoint = state.settings.as_ref().and_then(|s| s.endpoint.clone()); - - let region = state.get_region(); - - ( - auth_method, - state.credentials.clone(), - endpoint, - region, - state.settings.clone(), - ) - })?; + let (auth, endpoint, region) = cx.read_entity(&self.state, |state, _cx| { + let endpoint = state.settings.as_ref().and_then(|s| s.endpoint.clone()); + let region = state.get_region(); + (state.auth.clone(), endpoint, region) + })?; let mut config_builder = aws_config::defaults(BehaviorVersion::latest()) .stalled_stream_protection(StalledStreamProtectionConfig::disabled()) @@ -425,37 +541,39 @@ impl BedrockModel { config_builder = config_builder.endpoint_url(endpoint_url); } - match auth_method { - None => { - if let Some(creds) = credentials { - let aws_creds = Credentials::new( - creds.access_key_id, - creds.secret_access_key, - creds.session_token, - None, - "zed-bedrock-provider", - ); - config_builder = config_builder.credentials_provider(aws_creds); - } + match auth { + Some(BedrockAuth::Automatic) | None => { + // Use default AWS credential provider chain } - Some(BedrockAuthMethod::NamedProfile) - | Some(BedrockAuthMethod::SingleSignOn) => { - // Currently NamedProfile and SSO behave the same way but only the instructions change - // Until we support BearerAuth through SSO, this will not change. - let profile_name = settings - .and_then(|s| s.profile_name) - .unwrap_or_else(|| "default".to_string()); - + Some(BedrockAuth::NamedProfile { profile_name }) + | Some(BedrockAuth::SingleSignOn { profile_name }) => { if !profile_name.is_empty() { config_builder = config_builder.profile_name(profile_name); } } - Some(BedrockAuthMethod::Automatic) => { - // Use default credential provider chain + Some(BedrockAuth::IamCredentials { + access_key_id, + secret_access_key, + session_token, + }) => { + let aws_creds = Credentials::new( + access_key_id, + secret_access_key, + session_token, + None, + "zed-bedrock-provider", + ); + config_builder = config_builder.credentials_provider(aws_creds); + } + Some(BedrockAuth::ApiKey { api_key }) => { + config_builder = config_builder + .auth_scheme_preference(["httpBearerAuth".into()]) // https://github.com/smithy-lang/smithy-rs/pull/4241 + .token_provider(Token::new(api_key, None)); } } let config = self.handle.block_on(config_builder.load()); + anyhow::Ok(BedrockClient::new(&config)) }) .context("initializing Bedrock client")?; @@ -1024,7 +1142,7 @@ struct ConfigurationView { access_key_id_editor: Entity, secret_access_key_editor: Entity, session_token_editor: Entity, - region_editor: Entity, + bearer_token_editor: Entity, state: Entity, load_credentials_task: Option>, focus_handle: FocusHandle, @@ -1035,7 +1153,7 @@ impl ConfigurationView { const PLACEHOLDER_SECRET_ACCESS_KEY_TEXT: &'static str = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; const PLACEHOLDER_SESSION_TOKEN_TEXT: &'static str = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; - const PLACEHOLDER_REGION: &'static str = "us-east-1"; + const PLACEHOLDER_BEARER_TOKEN_TEXT: &'static str = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; fn new(state: Entity, window: &mut Window, cx: &mut Context) -> Self { let focus_handle = cx.focus_handle(); @@ -1066,9 +1184,9 @@ impl ConfigurationView { .tab_stop(true) }); - let region_editor = cx.new(|cx| { - InputField::new(window, cx, Self::PLACEHOLDER_REGION) - .label("Region") + let bearer_token_editor = cx.new(|cx| { + InputField::new(window, cx, Self::PLACEHOLDER_BEARER_TOKEN_TEXT) + .label("Bedrock API Key") .tab_index(3) .tab_stop(true) }); @@ -1095,7 +1213,7 @@ impl ConfigurationView { access_key_id_editor, secret_access_key_editor, session_token_editor, - region_editor, + bearer_token_editor, state, load_credentials_task, focus_handle, @@ -1131,25 +1249,30 @@ impl ConfigurationView { } else { Some(session_token) }; - let region = self.region_editor.read(cx).text(cx).trim().to_string(); - let region = if region.is_empty() { - "us-east-1".to_string() + let bearer_token = self + .bearer_token_editor + .read(cx) + .text(cx) + .trim() + .to_string(); + let bearer_token = if bearer_token.is_empty() { + None } else { - region + Some(bearer_token) }; let state = self.state.clone(); cx.spawn(async move |_, cx| { state .update(cx, |state, cx| { - let credentials: BedrockCredentials = BedrockCredentials { - region: region.clone(), - access_key_id: access_key_id.clone(), - secret_access_key: secret_access_key.clone(), - session_token: session_token.clone(), + let credentials = BedrockCredentials { + access_key_id, + secret_access_key, + session_token, + bearer_token, }; - state.set_credentials(credentials, cx) + state.set_static_credentials(credentials, cx) })? .await }) @@ -1163,16 +1286,12 @@ impl ConfigurationView { .update(cx, |editor, cx| editor.set_text("", window, cx)); self.session_token_editor .update(cx, |editor, cx| editor.set_text("", window, cx)); - self.region_editor + self.bearer_token_editor .update(cx, |editor, cx| editor.set_text("", window, cx)); let state = self.state.clone(); - cx.spawn(async move |_, cx| { - state - .update(cx, |state, cx| state.reset_credentials(cx))? - .await - }) - .detach_and_log_err(cx); + cx.spawn(async move |_, cx| state.update(cx, |state, cx| state.reset_auth(cx))?.await) + .detach_and_log_err(cx); } fn should_render_editor(&self, cx: &Context) -> bool { @@ -1195,9 +1314,11 @@ impl ConfigurationView { impl Render for ConfigurationView { fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { - let env_var_set = self.state.read(cx).credentials_from_env; - let bedrock_settings = self.state.read(cx).settings.as_ref(); - let bedrock_method = bedrock_settings + let state = self.state.read(cx); + let env_var_set = state.credentials_from_env; + let auth = state.auth.clone(); + let settings_auth_method = state + .settings .as_ref() .and_then(|s| s.authentication_method.clone()); @@ -1205,34 +1326,62 @@ impl Render for ConfigurationView { return div().child(Label::new("Loading credentials...")).into_any(); } - let configured_label = if env_var_set { - format!( - "Access Key ID is set in {ZED_BEDROCK_ACCESS_KEY_ID_VAR}, Secret Key is set in {ZED_BEDROCK_SECRET_ACCESS_KEY_VAR}, Region is set in {ZED_BEDROCK_REGION_VAR} environment variables." - ) - } else { - match bedrock_method { - Some(BedrockAuthMethod::Automatic) => "You are using automatic credentials.".into(), - Some(BedrockAuthMethod::NamedProfile) => "You are using named profile.".into(), - Some(BedrockAuthMethod::SingleSignOn) => { - "You are using a single sign on profile.".into() - } - None => "You are using static credentials.".into(), + let configured_label = match &auth { + Some(BedrockAuth::Automatic) => { + "Using automatic credentials (AWS default chain)".into() } + Some(BedrockAuth::NamedProfile { profile_name }) => { + format!("Using AWS profile: {profile_name}") + } + Some(BedrockAuth::SingleSignOn { profile_name }) => { + format!("Using AWS SSO profile: {profile_name}") + } + Some(BedrockAuth::IamCredentials { .. }) if env_var_set => { + format!( + "Using IAM credentials from {} and {} environment variables", + ZED_BEDROCK_ACCESS_KEY_ID_VAR.name, ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.name + ) + } + Some(BedrockAuth::IamCredentials { .. }) => "Using IAM credentials".into(), + Some(BedrockAuth::ApiKey { .. }) if env_var_set => { + format!( + "Using Bedrock API Key from {} environment variable", + ZED_BEDROCK_BEARER_TOKEN_VAR.name + ) + } + Some(BedrockAuth::ApiKey { .. }) => "Using Bedrock API Key".into(), + None => "Not authenticated".into(), }; + // Determine if credentials can be reset + // Settings-derived auth (non-ApiKey) cannot be reset from UI + let is_settings_derived = matches!( + settings_auth_method, + Some(BedrockAuthMethod::Automatic) + | Some(BedrockAuthMethod::NamedProfile) + | Some(BedrockAuthMethod::SingleSignOn) + ); + let tooltip_label = if env_var_set { Some(format!( - "To reset your credentials, unset the {ZED_BEDROCK_ACCESS_KEY_ID_VAR}, {ZED_BEDROCK_SECRET_ACCESS_KEY_VAR}, and {ZED_BEDROCK_REGION_VAR} environment variables." + "To reset your credentials, unset the {}, {}, and {} or {} environment variables.", + ZED_BEDROCK_ACCESS_KEY_ID_VAR.name, + ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.name, + ZED_BEDROCK_SESSION_TOKEN_VAR.name, + ZED_BEDROCK_BEARER_TOKEN_VAR.name )) - } else if bedrock_method.is_some() { - Some("You cannot reset credentials as they're being derived, check Zed settings to understand how.".to_string()) + } else if is_settings_derived { + Some( + "Authentication method is configured in settings. Edit settings.json to change." + .to_string(), + ) } else { None }; if self.should_render_editor(cx) { return ConfiguredApiCard::new(configured_label) - .disabled(env_var_set || bedrock_method.is_some()) + .disabled(env_var_set || is_settings_derived) .on_click(cx.listener(|this, _, window, cx| this.reset_credentials(window, cx))) .when_some(tooltip_label, |this, label| this.tooltip_label(label)) .into_any_element(); @@ -1262,7 +1411,7 @@ impl Render for ConfigurationView { .child(self.render_static_credentials_ui()) .child( Label::new( - format!("You can also assign the {ZED_BEDROCK_ACCESS_KEY_ID_VAR}, {ZED_BEDROCK_SECRET_ACCESS_KEY_VAR} AND {ZED_BEDROCK_REGION_VAR} environment variables and restart Zed."), + format!("You can also assign the {}, {} AND {} environment variables (or {} for Bedrock API Key authentication) and restart Zed.", ZED_BEDROCK_ACCESS_KEY_ID_VAR.name, ZED_BEDROCK_SECRET_ACCESS_KEY_VAR.name, ZED_BEDROCK_REGION_VAR.name, ZED_BEDROCK_BEARER_TOKEN_VAR.name), ) .size(LabelSize::Small) .color(Color::Muted) @@ -1270,7 +1419,7 @@ impl Render for ConfigurationView { ) .child( Label::new( - format!("Optionally, if your environment uses AWS CLI profiles, you can set {ZED_AWS_PROFILE_VAR}; if it requires a custom endpoint, you can set {ZED_AWS_ENDPOINT_VAR}; and if it requires a Session Token, you can set {ZED_BEDROCK_SESSION_TOKEN_VAR}."), + format!("Optionally, if your environment uses AWS CLI profiles, you can set {}; if it requires a custom endpoint, you can set {}; and if it requires a Session Token, you can set {}.", ZED_AWS_PROFILE_VAR.name, ZED_AWS_ENDPOINT_VAR.name, ZED_BEDROCK_SESSION_TOKEN_VAR.name), ) .size(LabelSize::Small) .color(Color::Muted), @@ -1292,31 +1441,47 @@ impl ConfigurationView { ) .child( Label::new( - "This method uses your AWS access key ID and secret access key directly.", + "This method uses your AWS access key ID and secret access key, or a Bedrock API Key.", ) ) .child( List::new() .child( ListBulletItem::new("") - .child(Label::new("Create an IAM user in the AWS console with programmatic access")) + .child(Label::new("For access keys: Create an IAM user in the AWS console with programmatic access")) .child(ButtonLink::new("IAM Console", "https://us-east-1.console.aws.amazon.com/iam/home?region=us-east-1#/users")) ) .child( ListBulletItem::new("") - .child(Label::new("Attach the necessary Bedrock permissions to this")) - .child(ButtonLink::new("user", "https://docs.aws.amazon.com/bedrock/latest/userguide/inference-prereq.html")) + .child(Label::new("For Bedrock API Keys: Generate an API key from the")) + .child(ButtonLink::new("Bedrock Console", "https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys-use.html")) ) .child( - ListBulletItem::new("Copy the access key ID and secret access key when provided") + ListBulletItem::new("") + .child(Label::new("Attach the necessary Bedrock permissions to this")) + .child(ButtonLink::new("user", "https://docs.aws.amazon.com/bedrock/latest/userguide/inference-prereq.html")) ) .child( - ListBulletItem::new("Enter these credentials below") - ) + ListBulletItem::new("Enter either access keys OR a Bedrock API Key below (not both)") + ), ) .child(self.access_key_id_editor.clone()) .child(self.secret_access_key_editor.clone()) .child(self.session_token_editor.clone()) - .child(self.region_editor.clone()) + .child( + Label::new("OR") + .size(LabelSize::Default) + .weight(FontWeight::BOLD) + .my_1(), + ) + .child(self.bearer_token_editor.clone()) + .child( + Label::new( + format!("Region is configured via {} environment variable or settings.json (defaults to us-east-1).", ZED_BEDROCK_REGION_VAR.name), + ) + .size(LabelSize::Small) + .color(Color::Muted) + .mt_2(), + ) } } diff --git a/crates/settings/src/settings_content/language_model.rs b/crates/settings/src/settings_content/language_model.rs index b106f3d9925cb4afe058cff44649f998c8b73d8a..e523286e5f56af88110c2d4a7d874c22195ea2b1 100644 --- a/crates/settings/src/settings_content/language_model.rs +++ b/crates/settings/src/settings_content/language_model.rs @@ -83,6 +83,8 @@ pub enum BedrockAuthMethodContent { NamedProfile, #[serde(rename = "sso")] SingleSignOn, + #[serde(rename = "api_key")] + ApiKey, /// IMDSv2, PodIdentity, env vars, etc. #[serde(rename = "default")] Automatic, From b29e8244d5f74dd4cd34be2fff1386b51ff5e462 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yara=20=F0=9F=8F=B3=EF=B8=8F=E2=80=8D=E2=9A=A7=EF=B8=8F?= Date: Wed, 17 Dec 2025 13:06:46 +0100 Subject: [PATCH 113/266] Fix Yara's GitHub handle (#45095) Release Notes: - N/A --- REVIEWERS.conl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/REVIEWERS.conl b/REVIEWERS.conl index 45155ba3468f29062b58aa9094defc7f86110885..bca694d7a06fe1112f7f8bab158dad63a365ea74 100644 --- a/REVIEWERS.conl +++ b/REVIEWERS.conl @@ -28,7 +28,7 @@ ai = @rtfeldman audio - = @dvdsk + = @yara-blue crashes = @p1n3appl3 @@ -53,7 +53,7 @@ extension git = @cole-miller = @danilo-leal - = @dvdsk + = @yara-blue = @kubkon = @Anthony-Eid = @cameron1024 @@ -76,7 +76,7 @@ languages linux = @cole-miller - = @dvdsk + = @yara-blue = @p1n3appl3 = @probably-neb = @smitbarmase @@ -92,7 +92,7 @@ multi_buffer = @SomeoneToIgnore pickers - = @dvdsk + = @yara-blue = @p1n3appl3 = @SomeoneToIgnore From 4af26f085280f1e3a889400b443592f881081445 Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Wed, 17 Dec 2025 13:42:43 +0100 Subject: [PATCH 114/266] Fix tab bar button flickering when opening menus (#45098) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #33018 ### Problem When opening a `PopoverMenu` or `RightClickMenu`, the pane's tab bar buttons would flicker (disappear for a couple frames then reappear). This happened because: 1. The menu is created and `window.focus()` was called immediately 2. However, menus are rendered using `deferred()`, so their focus handles aren't connected in the dispatch tree until after the deferred draw callback runs 3. When the pane checks `has_focus()`, it calls `contains_focused()` which walks up the focus hierarchy — but the menu's focus handle isn't linked yet 4. `has_focus()` returns false → tab bar buttons disappear 5. Next frame, the menu is rendered and linked → `has_focus()` returns true → buttons reappear ### Solution Delay the focus transfer by 2 frames using nested `on_next_frame()` calls before focusing the menu. **Why 2 frames instead of 1?** The frame lifecycle in GPUI runs `next_frame_callbacks` BEFORE `draw()`: ``` on_request_frame: 1. Run next_frame_callbacks 2. window.draw() ← menu rendered here via deferred() 3. Present ``` So: - **Frame 1**: First `on_next_frame` callback runs, queues second callback. Then `draw()` renders the menu and connects its focus handle to the dispatch tree. - **Frame 2**: Second `on_next_frame` callback runs and focuses the menu. Now the focus handle is connected (from Frame 1's draw), so `contains_focused()` returns true. With only 1 frame, the focus would happen BEFORE `draw()`, when the menu's focus handle isn't connected yet. This follows the same pattern established in b709996ec6 which fixed the identical issue for the editor's `MouseContextMenu`. --- crates/ui/src/components/popover_menu.rs | 14 +++++++++++++- crates/ui/src/components/right_click_menu.rs | 14 +++++++++++++- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/crates/ui/src/components/popover_menu.rs b/crates/ui/src/components/popover_menu.rs index b1a52bec8fdf1f7030b5b321bed7702d602ff212..7fdb39126b5244e367a4646c6ef6df1547a8a52f 100644 --- a/crates/ui/src/components/popover_menu.rs +++ b/crates/ui/src/components/popover_menu.rs @@ -287,7 +287,19 @@ fn show_menu( window.refresh(); }) .detach(); - window.focus(&new_menu.focus_handle(cx)); + + // Since menus are rendered in a deferred fashion, their focus handles are + // not linked in the dispatch tree until after the deferred draw callback + // runs. We need to wait for that to happen before focusing it, so that + // calling `contains_focused` on the parent's focus handle returns `true` + // when the menu is focused. This prevents the pane's tab bar buttons from + // flickering when opening popover menus. + let focus_handle = new_menu.focus_handle(cx); + window.on_next_frame(move |window, _cx| { + window.on_next_frame(move |window, _cx| { + window.focus(&focus_handle); + }); + }); *menu.borrow_mut() = Some(new_menu); window.refresh(); diff --git a/crates/ui/src/components/right_click_menu.rs b/crates/ui/src/components/right_click_menu.rs index dff423073710121bb0bc0fafdb8ab3108b746bde..5b654c295e8c9721cd38af8b4807ba5d8e6d6cb9 100644 --- a/crates/ui/src/components/right_click_menu.rs +++ b/crates/ui/src/components/right_click_menu.rs @@ -259,7 +259,19 @@ impl Element for RightClickMenu { window.refresh(); }) .detach(); - window.focus(&new_menu.focus_handle(cx)); + + // Since menus are rendered in a deferred fashion, their focus handles are + // not linked in the dispatch tree until after the deferred draw callback + // runs. We need to wait for that to happen before focusing it, so that + // calling `contains_focused` on the parent's focus handle returns `true` + // when the menu is focused. This prevents the pane's tab bar buttons from + // flickering when opening menus. + let focus_handle = new_menu.focus_handle(cx); + window.on_next_frame(move |window, _cx| { + window.on_next_frame(move |window, _cx| { + window.focus(&focus_handle); + }); + }); *menu.borrow_mut() = Some(new_menu); *position.borrow_mut() = if let Some(child_bounds) = child_bounds { if let Some(attach) = attach { From 9b8bc63524a50fba6699558df60e973961618280 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 17 Dec 2025 09:49:19 -0300 Subject: [PATCH 115/266] Revert "Remove CopyAsMarkdown" (#45101) Reverts https://github.com/zed-industries/zed/pull/44933. It turns out that if you're copying agent responses to paste it anywhere else that isn't the message editor (e.g., for a follow up prompt), getting Markdown formatting is helpful. However, with the revert, the underlying issue in https://github.com/zed-industries/zed/issues/42958 remains, so I'll reopen that issue, unfortunately. Release Notes: - N/A --- assets/keymaps/default-linux.json | 6 +++--- assets/keymaps/default-macos.json | 2 +- assets/keymaps/default-windows.json | 2 +- crates/markdown/src/markdown.rs | 18 ++++++++++++++++++ 4 files changed, 23 insertions(+), 5 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index 1016a20bd6facdc8f5ef9163ebda3e03d451c5cf..f09ac0a812c3e875618c57da15bcf16e1f983d6e 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -264,9 +264,9 @@ { "context": "AgentPanel > Markdown", "bindings": { - "copy": "markdown::Copy", - "ctrl-insert": "markdown::Copy", - "ctrl-c": "markdown::Copy", + "copy": "markdown::CopyAsMarkdown", + "ctrl-insert": "markdown::CopyAsMarkdown", + "ctrl-c": "markdown::CopyAsMarkdown", }, }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index c80edf01a02347cf678fe9cb24390f2fca41d70e..1d489771febc770e300b63e265024ffca3d14a90 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -306,7 +306,7 @@ "context": "AgentPanel > Markdown", "use_key_equivalents": true, "bindings": { - "cmd-c": "markdown::Copy", + "cmd-c": "markdown::CopyAsMarkdown", }, }, { diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index dcc828ddf2ef63f3fef6e7e12d9349bead57572e..9154cc43afb86c287329229c6f0d699f59a82b36 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -267,7 +267,7 @@ "context": "AgentPanel > Markdown", "use_key_equivalents": true, "bindings": { - "ctrl-c": "markdown::Copy", + "ctrl-c": "markdown::CopyAsMarkdown", }, }, { diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index 3654418e419bb58f5c9c29ac1baf7172a423156f..706fe894699afe8d1ae32c0525214ec6bf614912 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -151,6 +151,8 @@ actions!( [ /// Copies the selected text to the clipboard. Copy, + /// Copies the selected text as markdown to the clipboard. + CopyAsMarkdown ] ); @@ -295,6 +297,14 @@ impl Markdown { cx.write_to_clipboard(ClipboardItem::new_string(text)); } + fn copy_as_markdown(&self, _: &mut Window, cx: &mut Context) { + if self.selection.end <= self.selection.start { + return; + } + let text = self.source[self.selection.start..self.selection.end].to_string(); + cx.write_to_clipboard(ClipboardItem::new_string(text)); + } + fn parse(&mut self, cx: &mut Context) { if self.source.is_empty() { return; @@ -1356,6 +1366,14 @@ impl Element for MarkdownElement { } } }); + window.on_action(std::any::TypeId::of::(), { + let entity = self.markdown.clone(); + move |_, phase, window, cx| { + if phase == DispatchPhase::Bubble { + entity.update(cx, move |this, cx| this.copy_as_markdown(window, cx)) + } + } + }); self.paint_mouse_listeners(hitbox, &rendered_markdown.text, window, cx); rendered_markdown.element.paint(window, cx); From acae823fb10d27b0a8b324df64fc0218f63adf06 Mon Sep 17 00:00:00 2001 From: Aero Date: Wed, 17 Dec 2025 21:22:17 +0800 Subject: [PATCH 116/266] agent_ui: Add regeneration button to text and agent thread titles (#43859) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Screenshot 2025-12-17 at 10  10@2x Release Notes: - agent: Added the ability to regenerate the auto-summarized title of threads to the "Regenerate Thread Title" button available the ellipsis menu of the agent panel. --------- Co-authored-by: Danilo Leal --- crates/agent/src/thread.rs | 6 +- crates/agent_ui/src/acp/thread_view.rs | 11 +++ crates/agent_ui/src/agent_panel.rs | 112 ++++++++++++++++++++++++- 3 files changed, 125 insertions(+), 4 deletions(-) diff --git a/crates/agent/src/thread.rs b/crates/agent/src/thread.rs index f8f46af5fe2bbea5888ded6e24495afee71680dd..ef3ca23c3caf816a28e91e9e75b21f2cc80451e7 100644 --- a/crates/agent/src/thread.rs +++ b/crates/agent/src/thread.rs @@ -1725,6 +1725,10 @@ impl Thread { self.pending_summary_generation.is_some() } + pub fn is_generating_title(&self) -> bool { + self.pending_title_generation.is_some() + } + pub fn summary(&mut self, cx: &mut Context) -> Shared>> { if let Some(summary) = self.summary.as_ref() { return Task::ready(Some(summary.clone())).shared(); @@ -1792,7 +1796,7 @@ impl Thread { task } - fn generate_title(&mut self, cx: &mut Context) { + pub fn generate_title(&mut self, cx: &mut Context) { let Some(model) = self.summarization_model.clone() else { return; }; diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 05162348db060bff05aa7b1dd223815895f02e2d..e7c40db7118468ae9d43bb5976992d05b745f182 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1898,6 +1898,17 @@ impl AcpThreadView { }) } + pub fn has_user_submitted_prompt(&self, cx: &App) -> bool { + self.thread().is_some_and(|thread| { + thread.read(cx).entries().iter().any(|entry| { + matches!( + entry, + AgentThreadEntry::UserMessage(user_message) if user_message.id.is_some() + ) + }) + }) + } + fn authorize_tool_call( &mut self, tool_call_id: acp::ToolCallId, diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index ff8cf8db969e9ef2d1d86b306c0f38fb66a67fde..071283e7224f08efd0f8df2cdf7a1aca63419081 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -1749,8 +1749,13 @@ impl AgentPanel { let content = match &self.active_view { ActiveView::ExternalAgentThread { thread_view } => { + let is_generating_title = thread_view + .read(cx) + .as_native_thread(cx) + .map_or(false, |t| t.read(cx).is_generating_title()); + if let Some(title_editor) = thread_view.read(cx).title_editor() { - div() + let container = div() .w_full() .on_action({ let thread_view = thread_view.downgrade(); @@ -1768,8 +1773,21 @@ impl AgentPanel { } } }) - .child(title_editor) - .into_any_element() + .child(title_editor); + + if is_generating_title { + container + .with_animation( + "generating_title", + Animation::new(Duration::from_secs(2)) + .repeat() + .with_easing(pulsating_between(0.4, 0.8)), + |div, delta| div.opacity(delta), + ) + .into_any_element() + } else { + container.into_any_element() + } } else { Label::new(thread_view.read(cx).title(cx)) .color(Color::Muted) @@ -1799,6 +1817,13 @@ impl AgentPanel { Label::new(LOADING_SUMMARY_PLACEHOLDER) .truncate() .color(Color::Muted) + .with_animation( + "generating_title", + Animation::new(Duration::from_secs(2)) + .repeat() + .with_easing(pulsating_between(0.4, 0.8)), + |label, delta| label.alpha(delta), + ) .into_any_element() } } @@ -1842,6 +1867,25 @@ impl AgentPanel { .into_any() } + fn handle_regenerate_thread_title(thread_view: Entity, cx: &mut App) { + thread_view.update(cx, |thread_view, cx| { + if let Some(thread) = thread_view.as_native_thread(cx) { + thread.update(cx, |thread, cx| { + thread.generate_title(cx); + }); + } + }); + } + + fn handle_regenerate_text_thread_title( + text_thread_editor: Entity, + cx: &mut App, + ) { + text_thread_editor.update(cx, |text_thread_editor, cx| { + text_thread_editor.regenerate_summary(cx); + }); + } + fn render_panel_options_menu( &self, window: &mut Window, @@ -1861,6 +1905,35 @@ impl AgentPanel { let selected_agent = self.selected_agent.clone(); + let text_thread_view = match &self.active_view { + ActiveView::TextThread { + text_thread_editor, .. + } => Some(text_thread_editor.clone()), + _ => None, + }; + let text_thread_with_messages = match &self.active_view { + ActiveView::TextThread { + text_thread_editor, .. + } => text_thread_editor + .read(cx) + .text_thread() + .read(cx) + .messages(cx) + .any(|message| message.role == language_model::Role::Assistant), + _ => false, + }; + + let thread_view = match &self.active_view { + ActiveView::ExternalAgentThread { thread_view } => Some(thread_view.clone()), + _ => None, + }; + let thread_with_messages = match &self.active_view { + ActiveView::ExternalAgentThread { thread_view } => { + thread_view.read(cx).has_user_submitted_prompt(cx) + } + _ => false, + }; + PopoverMenu::new("agent-options-menu") .trigger_with_tooltip( IconButton::new("agent-options-menu", IconName::Ellipsis) @@ -1883,6 +1956,7 @@ impl AgentPanel { 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()) @@ -1920,6 +1994,38 @@ impl AgentPanel { .separator() } + if thread_with_messages | text_thread_with_messages { + menu = menu.header("Current Thread"); + + if let Some(text_thread_view) = text_thread_view.as_ref() { + menu = menu + .entry("Regenerate Thread Title", None, { + let text_thread_view = text_thread_view.clone(); + move |_, cx| { + Self::handle_regenerate_text_thread_title( + text_thread_view.clone(), + cx, + ); + } + }) + .separator(); + } + + if let Some(thread_view) = thread_view.as_ref() { + menu = menu + .entry("Regenerate Thread Title", None, { + let thread_view = thread_view.clone(); + move |_, cx| { + Self::handle_regenerate_thread_title( + thread_view.clone(), + cx, + ); + } + }) + .separator(); + } + } + menu = menu .header("MCP Servers") .action( From 71e8b5504cd0432832e87460ef10cd00940b8489 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Wed, 17 Dec 2025 14:25:48 +0100 Subject: [PATCH 117/266] nightly: Temporarly delete commit message prompt from rules library (#45106) Relevant for Nightly Users only, follow up to #45004. In case you use nightly this will break preview/stable since deserialisation will fail. Shipping this to Nightly so that staff does not run into this issue. We can revert this PR in the following days. I'll make a follow up PR which only stores the prompt in the database in case you customise it. Release Notes: - N/A --- crates/prompt_store/src/prompt_store.rs | 20 ++------------------ 1 file changed, 2 insertions(+), 18 deletions(-) diff --git a/crates/prompt_store/src/prompt_store.rs b/crates/prompt_store/src/prompt_store.rs index 6417a7ad214c84258d4cc18eddc0b1c1d785ca18..7823f7a6957caf282f4ad7f1d6f884971364518e 100644 --- a/crates/prompt_store/src/prompt_store.rs +++ b/crates/prompt_store/src/prompt_store.rs @@ -199,24 +199,8 @@ impl PromptStore { let metadata = db_env.create_database(&mut txn, Some("metadata.v2"))?; let bodies = db_env.create_database(&mut txn, Some("bodies.v2"))?; - // Insert default commit message prompt if not present - if metadata.get(&txn, &PromptId::CommitMessage)?.is_none() { - metadata.put( - &mut txn, - &PromptId::CommitMessage, - &PromptMetadata { - id: PromptId::CommitMessage, - title: Some("Git Commit Message".into()), - default: false, - saved_at: Utc::now(), - }, - )?; - } - if bodies.get(&txn, &PromptId::CommitMessage)?.is_none() { - let commit_message_prompt = - include_str!("../../git_ui/src/commit_message_prompt.txt"); - bodies.put(&mut txn, &PromptId::CommitMessage, commit_message_prompt)?; - } + metadata.delete(&mut txn, &PromptId::CommitMessage)?; + bodies.delete(&mut txn, &PromptId::CommitMessage)?; txn.commit()?; From 1b24b442c6d44437a896b8537d0200c3716ef319 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9=20Eriksson?= Date: Wed, 17 Dec 2025 15:16:37 +0100 Subject: [PATCH 118/266] docs: Add Tailwind configuration section for JavaScript/TypeScript (#45057) Addresses some tasks in #43969. Namely adding TailwindCSS documentation for the following languages: HTML, JavaScript and Typescript. **Some Notes** - Maybe the additional information in the HTML section is unnecessary, unsure open to suggestions. - I tried utilizing capturing groups with alternatives like `\\.(add|remove|toggle|contains)` but this didn't seem to work, so I was forced to use multiple lines. Release Notes: - N/A --------- Co-authored-by: Danilo Leal --- docs/src/languages/javascript.md | 30 +++++++++++++++++++++++++++++- docs/src/languages/ruby.md | 11 ++--------- docs/src/languages/tailwindcss.md | 30 ++++++++++++++++-------------- docs/src/languages/typescript.md | 30 +++++++++++++++++++++++++++++- 4 files changed, 76 insertions(+), 25 deletions(-) diff --git a/docs/src/languages/javascript.md b/docs/src/languages/javascript.md index 1b87dac5553f0dc44153d4706be1dd4bd2e341d5..f043c642b305a8dba2b0985a75954438bb024c4c 100644 --- a/docs/src/languages/javascript.md +++ b/docs/src/languages/javascript.md @@ -175,6 +175,34 @@ You can configure ESLint's `workingDirectory` setting: } ``` +## Using the Tailwind CSS Language Server with JavaScript + +To get all the features (autocomplete, linting, etc.) from the [Tailwind CSS language server](https://github.com/tailwindlabs/tailwindcss-intellisense/tree/HEAD/packages/tailwindcss-language-server#readme) in vanilla JavaScript files (`.js`), you can customize the `classRegex` field under it in your `settings.json`: + +```json [settings] +{ + "lsp": { + "tailwindcss-language-server": { + "settings": { + "experimental": { + "classRegex": [ + "\\.className\\s*[+]?=\\s*['\"]([^'\"]*)['\"]", + "\\.setAttributeNS\\(.*,\\s*['\"]class['\"],\\s*['\"]([^'\"]*)['\"]", + "\\.setAttribute\\(['\"]class['\"],\\s*['\"]([^'\"]*)['\"]", + "\\.classList\\.add\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.remove\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.toggle\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.contains\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.replace\\(\\s*['\"]([^'\"]*)['\"]", + "\\.classList\\.replace\\([^,)]+,\\s*['\"]([^'\"]*)['\"]" + ] + } + } + } + } +} +``` + ## Debugging Zed supports debugging JavaScript code out of the box with `vscode-js-debug`. @@ -186,7 +214,7 @@ The following can be debugged without writing additional configuration: Run {#action debugger::Start} ({#kb debugger::Start}) to see a contextual list of these predefined debug tasks. > **Note:** Bun test is automatically detected when `@types/bun` is present in `package.json`. -> + > **Note:** Node test is automatically detected when `@types/node` is present in `package.json` (requires Node.js 20+). As for all languages, configurations from `.vscode/launch.json` are also available for debugging in Zed. diff --git a/docs/src/languages/ruby.md b/docs/src/languages/ruby.md index 7e072ac5d32ab990584a2c2b0be57eb3076b1ec9..f7f0ccce83354fb24372f6916f27c63156f8cb3c 100644 --- a/docs/src/languages/ruby.md +++ b/docs/src/languages/ruby.md @@ -258,17 +258,10 @@ To enable Steep, add `\"steep\"` to the `language_servers` list for Ruby in your ## Using the Tailwind CSS Language Server with Ruby -It's possible to use the [Tailwind CSS Language Server](https://github.com/tailwindlabs/tailwindcss-intellisense/tree/HEAD/packages/tailwindcss-language-server#readme) in Ruby and ERB files. - -In order to do that, you need to configure the language server so that it knows about where to look for CSS classes in Ruby/ERB files by adding the following to your `settings.json`: +To get all the features (autocomplete, linting, etc.) from the [Tailwind CSS language server](https://github.com/tailwindlabs/tailwindcss-intellisense/tree/HEAD/packages/tailwindcss-language-server#readme) in Ruby/ERB files, you need to configure the language server so that it knows about where to look for CSS classes by adding the following to your `settings.json`: ```json [settings] { - "languages": { - "Ruby": { - "language_servers": ["tailwindcss-language-server", "..."] - } - }, "lsp": { "tailwindcss-language-server": { "settings": { @@ -281,7 +274,7 @@ In order to do that, you need to configure the language server so that it knows } ``` -With these settings you will get completions for Tailwind CSS classes in HTML attributes inside ERB files and inside Ruby/ERB strings that are coming after a `class:` key. Examples: +With these settings, you will get completions for Tailwind CSS classes in HTML attributes inside ERB files and inside Ruby/ERB strings that are coming after a `class:` key. Examples: ```rb # Ruby file: diff --git a/docs/src/languages/tailwindcss.md b/docs/src/languages/tailwindcss.md index be9c9437d1382dfd356120663ebea2c1fe012684..457c71f9768610f5bfdf345e72c27311632f1bef 100644 --- a/docs/src/languages/tailwindcss.md +++ b/docs/src/languages/tailwindcss.md @@ -4,9 +4,23 @@ Zed has built-in support for Tailwind CSS autocomplete, linting, and hover previ - Language Server: [tailwindlabs/tailwindcss-intellisense](https://github.com/tailwindlabs/tailwindcss-intellisense) +Languages which can be used with Tailwind CSS in Zed: + +- [Astro](./astro.md) +- [CSS](./css.md) +- [ERB](./ruby.md) +- [Gleam](./gleam.md) +- [HEEx](./elixir.md#heex) +- [HTML](./html.md) +- [TypeScript](./typescript.md) +- [JavaScript](./javascript.md) +- [PHP](./php.md) +- [Svelte](./svelte.md) +- [Vue](./vue.md) + ## Configuration -To configure the Tailwind CSS language server, refer [to the extension settings](https://github.com/tailwindlabs/tailwindcss-intellisense?tab=readme-ov-file#extension-settings) and add them to the `lsp` section of your `settings.json`: +If by default the language server isn't enough to make Tailwind work for a given language, you can configure the language server settings and add them to the `lsp` section of your `settings.json`: ```json [settings] { @@ -23,19 +37,7 @@ To configure the Tailwind CSS language server, refer [to the extension settings] } ``` -Languages which can be used with Tailwind CSS in Zed: - -- [Astro](./astro.md) -- [CSS](./css.md) -- [ERB](./ruby.md) -- [Gleam](./gleam.md) -- [HEEx](./elixir.md#heex) -- [HTML](./html.md) -- [TypeScript](./typescript.md) -- [JavaScript](./javascript.md) -- [PHP](./php.md) -- [Svelte](./svelte.md) -- [Vue](./vue.md) +Refer to [the Tailwind CSS language server settings docs](https://github.com/tailwindlabs/tailwindcss-intellisense?tab=readme-ov-file#extension-settings) for more information. ### Prettier Plugin diff --git a/docs/src/languages/typescript.md b/docs/src/languages/typescript.md index a6ec5b71ecb1815aeb4ff3811eec6f9a5c57a54b..d4fccc38f8a460e9ec097dee249a6441bd34a344 100644 --- a/docs/src/languages/typescript.md +++ b/docs/src/languages/typescript.md @@ -45,6 +45,34 @@ Prettier will also be used for TypeScript files by default. To disable this: } ``` +## Using the Tailwind CSS Language Server with TypeScript + +To get all the features (autocomplete, linting, etc.) from the [Tailwind CSS language server](https://github.com/tailwindlabs/tailwindcss-intellisense/tree/HEAD/packages/tailwindcss-language-server#readme) in vanilla TypeScript files (`.ts`), you can customize the `classRegex` field under it in your `settings.json`: + +```json [settings] +{ + "lsp": { + "tailwindcss-language-server": { + "settings": { + "experimental": { + "classRegex": [ + "\\.className\\s*[+]?=\\s*['\"]([^'\"]*)['\"]", + "\\.setAttributeNS\\(.*,\\s*['\"]class['\"],\\s*['\"]([^'\"]*)['\"]", + "\\.setAttribute\\(['\"]class['\"],\\s*['\"]([^'\"]*)['\"]", + "\\.classList\\.add\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.remove\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.toggle\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.contains\\(['\"]([^'\"]*)['\"]", + "\\.classList\\.replace\\(\\s*['\"]([^'\"]*)['\"]", + "\\.classList\\.replace\\([^,)]+,\\s*['\"]([^'\"]*)['\"]" + ] + } + } + } + } +} +``` + ## Large projects `vtsls` may run out of memory on very large projects. We default the limit to 8092 (8 GiB) vs. the default of 3072 but this may not be sufficient for you: @@ -167,7 +195,7 @@ The following can be debugged without writing additional configuration: Run {#action debugger::Start} ({#kb debugger::Start}) to see a contextual list of these predefined debug tasks. > **Note:** Bun test is automatically detected when `@types/bun` is present in `package.json`. -> + > **Note:** Node test is automatically detected when `@types/node` is present in `package.json` (requires Node.js 20+). As for all languages, configurations from `.vscode/launch.json` are also available for debugging in Zed. From 0c304c0e1b7d72ce1e81242ba0df2ab99754088d Mon Sep 17 00:00:00 2001 From: Gaauwe Rombouts Date: Wed, 17 Dec 2025 15:19:01 +0100 Subject: [PATCH 119/266] lsp: Persist vtsls update imports on rename choice (#45105) Closes #35930 When a TypeScript file is renamed or moved, vtsls can automatically update the imports in other files. It pops up a message with the option to always automatically update imports. This choice would previously only be remembered for the current session and would pop up again after a restart. Now we persist that choice to the vtsls LSP settings in Zed, so that it remembers across editor sessions. Release Notes: - When renaming a TypeScript or JavaScript file, the selected option to automatically update imports will now be remembered across editor sessions. --- crates/language/src/language.rs | 20 ++++++++++++ crates/languages/src/vtsls.rs | 57 ++++++++++++++++++++++++++++++++- crates/project/src/lsp_store.rs | 11 +++++++ 3 files changed, 87 insertions(+), 1 deletion(-) diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs index eceb68f3e578fda97af292fee395a8ac4f0829c9..a573e3d78a4de03c6ccf382c80bc33eaf0b5690d 100644 --- a/crates/language/src/language.rs +++ b/crates/language/src/language.rs @@ -330,6 +330,10 @@ impl CachedLspAdapter { .cloned() .unwrap_or_else(|| language_name.lsp_id()) } + + pub fn process_prompt_response(&self, context: &PromptResponseContext, cx: &mut AsyncApp) { + self.adapter.process_prompt_response(context, cx) + } } /// [`LspAdapterDelegate`] allows [`LspAdapter]` implementations to interface with the application @@ -355,6 +359,17 @@ pub trait LspAdapterDelegate: Send + Sync { async fn try_exec(&self, binary: LanguageServerBinary) -> Result<()>; } +/// Context provided to LSP adapters when a user responds to a ShowMessageRequest prompt. +/// This allows adapters to intercept preference selections (like "Always" or "Never") +/// and potentially persist them to Zed's settings. +#[derive(Debug, Clone)] +pub struct PromptResponseContext { + /// The original message shown to the user + pub message: String, + /// The action (button) the user selected + pub selected_action: lsp::MessageActionItem, +} + #[async_trait(?Send)] pub trait LspAdapter: 'static + Send + Sync + DynLspInstaller { fn name(&self) -> LanguageServerName; @@ -511,6 +526,11 @@ pub trait LspAdapter: 'static + Send + Sync + DynLspInstaller { fn is_extension(&self) -> bool { false } + + /// Called when a user responds to a ShowMessageRequest from this language server. + /// This allows adapters to intercept preference selections (like "Always" or "Never") + /// for settings that should be persisted to Zed's settings file. + fn process_prompt_response(&self, _context: &PromptResponseContext, _cx: &mut AsyncApp) {} } pub trait LspInstaller { diff --git a/crates/languages/src/vtsls.rs b/crates/languages/src/vtsls.rs index 3d38e022afe06f79d7e555263183a948c941f337..29b21a7cd80f1f0457e7720d68a6fb37954a02c5 100644 --- a/crates/languages/src/vtsls.rs +++ b/crates/languages/src/vtsls.rs @@ -2,13 +2,17 @@ use anyhow::Result; use async_trait::async_trait; use collections::HashMap; use gpui::AsyncApp; -use language::{LanguageName, LspAdapter, LspAdapterDelegate, LspInstaller, Toolchain}; +use language::{ + LanguageName, LspAdapter, LspAdapterDelegate, LspInstaller, PromptResponseContext, Toolchain, +}; use lsp::{CodeActionKind, LanguageServerBinary, LanguageServerName, Uri}; use node_runtime::{NodeRuntime, VersionStrategy}; use project::{Fs, lsp_store::language_server_settings}; use regex::Regex; use semver::Version; use serde_json::Value; +use serde_json::json; +use settings::update_settings_file; use std::{ ffi::OsString, path::{Path, PathBuf}, @@ -16,6 +20,11 @@ use std::{ }; use util::{ResultExt, maybe, merge_json_value_into}; +const ACTION_ALWAYS: &str = "Always"; +const ACTION_NEVER: &str = "Never"; +const UPDATE_IMPORTS_MESSAGE_PATTERN: &str = "Update imports for"; +const VTSLS_SERVER_NAME: &str = "vtsls"; + fn typescript_server_binary_arguments(server_path: &Path) -> Vec { vec![server_path.into(), "--stdio".into()] } @@ -302,6 +311,52 @@ impl LspAdapter for VtslsLspAdapter { (LanguageName::new_static("TSX"), "typescriptreact".into()), ]) } + + fn process_prompt_response(&self, context: &PromptResponseContext, cx: &mut AsyncApp) { + let selected_title = context.selected_action.title.as_str(); + let is_preference_response = + selected_title == ACTION_ALWAYS || selected_title == ACTION_NEVER; + if !is_preference_response { + return; + } + + if context.message.contains(UPDATE_IMPORTS_MESSAGE_PATTERN) { + let setting_value = match selected_title { + ACTION_ALWAYS => "always", + ACTION_NEVER => "never", + _ => return, + }; + + let settings = json!({ + "typescript": { + "updateImportsOnFileMove": { + "enabled": setting_value + } + }, + "javascript": { + "updateImportsOnFileMove": { + "enabled": setting_value + } + } + }); + + let _ = cx.update(|cx| { + update_settings_file(self.fs.clone(), cx, move |content, _| { + let lsp_settings = content + .project + .lsp + .entry(VTSLS_SERVER_NAME.into()) + .or_default(); + + if let Some(existing) = &mut lsp_settings.settings { + merge_json_value_into(settings, existing); + } else { + lsp_settings.settings = Some(settings); + } + }); + }); + } + } } async fn get_cached_ts_server_binary( diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 9b3eeebed79724196290738b51376e412ca11b22..f3ebac277b027232d2043213aa393492dbc1dfdb 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -1056,12 +1056,15 @@ impl LocalLspStore { .on_request::({ let this = lsp_store.clone(); let name = name.to_string(); + let adapter = adapter.clone(); move |params, cx| { let this = this.clone(); let name = name.to_string(); + let adapter = adapter.clone(); let mut cx = cx.clone(); async move { let actions = params.actions.unwrap_or_default(); + let message = params.message.clone(); let (tx, rx) = smol::channel::bounded(1); let request = LanguageServerPromptRequest { level: match params.typ { @@ -1082,6 +1085,14 @@ impl LocalLspStore { .is_ok(); if did_update { let response = rx.recv().await.ok(); + if let Some(ref selected_action) = response { + let context = language::PromptResponseContext { + message, + selected_action: selected_action.clone(), + }; + adapter.process_prompt_response(&context, &mut cx) + } + Ok(response) } else { Ok(None) From c186877ff740c41a225c268f9c0bd47496d2acb2 Mon Sep 17 00:00:00 2001 From: Gaauwe Rombouts Date: Wed, 17 Dec 2025 15:29:48 +0100 Subject: [PATCH 120/266] lsp: Open updated imports in multibuffer after file rename (#45110) Fixes an issue where we would update the imports after a file rename in TypeScript, but those changes wouldn't surface anywhere until those buffers were manually opened (https://github.com/zed-industries/zed/issues/35930#issuecomment-3366852945). In https://github.com/zed-industries/zed/pull/36681 we already added support for opening a multibuffer with edits, but vtsls has a different flow for renames. Release Notes: - Files with updated imports now open in a multibuffer when renaming or moving TypeScript or JavaScript files --- crates/editor/src/editor.rs | 114 +++++++++++++++++++++----------- crates/project/src/lsp_store.rs | 5 +- crates/project/src/project.rs | 4 ++ 3 files changed, 82 insertions(+), 41 deletions(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 4072b1db7a1935e5dbb9c63d2a3aa19db270f131..a66d92ceb8b0b6fa1631d0636294fbe3bd42af06 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -2063,46 +2063,34 @@ impl Editor { }) }); }); - let edited_buffers_already_open = { - let other_editors: Vec> = workspace - .read(cx) - .panes() - .iter() - .flat_map(|pane| pane.read(cx).items_of_type::()) - .filter(|editor| editor.entity_id() != cx.entity_id()) - .collect(); - - transaction.0.keys().all(|buffer| { - other_editors.iter().any(|editor| { - let multi_buffer = editor.read(cx).buffer(); - multi_buffer.read(cx).is_singleton() - && multi_buffer.read(cx).as_singleton().map_or( - false, - |singleton| { - singleton.entity_id() == buffer.entity_id() - }, - ) - }) - }) - }; - if !edited_buffers_already_open { - let workspace = workspace.downgrade(); - let transaction = transaction.clone(); - cx.defer_in(window, move |_, window, cx| { - cx.spawn_in(window, async move |editor, cx| { - Self::open_project_transaction( - &editor, - workspace, - transaction, - "Rename".to_string(), - cx, - ) - .await - .ok() - }) - .detach(); - }); - } + + Self::open_transaction_for_hidden_buffers( + workspace, + transaction.clone(), + "Rename".to_string(), + window, + cx, + ); + } + } + + project::Event::WorkspaceEditApplied(transaction) => { + let Some(workspace) = editor.workspace() else { + return; + }; + let Some(active_editor) = workspace.read(cx).active_item_as::(cx) + else { + return; + }; + + if active_editor.entity_id() == cx.entity_id() { + Self::open_transaction_for_hidden_buffers( + workspace, + transaction.clone(), + "LSP Edit".to_string(), + window, + cx, + ); } } @@ -6672,6 +6660,52 @@ impl Editor { } } + fn open_transaction_for_hidden_buffers( + workspace: Entity, + transaction: ProjectTransaction, + title: String, + window: &mut Window, + cx: &mut Context, + ) { + if transaction.0.is_empty() { + return; + } + + let edited_buffers_already_open = { + let other_editors: Vec> = workspace + .read(cx) + .panes() + .iter() + .flat_map(|pane| pane.read(cx).items_of_type::()) + .filter(|editor| editor.entity_id() != cx.entity_id()) + .collect(); + + transaction.0.keys().all(|buffer| { + other_editors.iter().any(|editor| { + let multi_buffer = editor.read(cx).buffer(); + multi_buffer.read(cx).is_singleton() + && multi_buffer + .read(cx) + .as_singleton() + .map_or(false, |singleton| { + singleton.entity_id() == buffer.entity_id() + }) + }) + }) + }; + if !edited_buffers_already_open { + let workspace = workspace.downgrade(); + cx.defer_in(window, move |_, window, cx| { + cx.spawn_in(window, async move |editor, cx| { + Self::open_project_transaction(&editor, workspace, transaction, title, cx) + .await + .ok() + }) + .detach(); + }); + } + } + pub async fn open_project_transaction( editor: &WeakEntity, workspace: WeakEntity, diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index f3ebac277b027232d2043213aa393492dbc1dfdb..6696ec8c4c280199a55d098ab63a321f126eea5e 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -3311,8 +3311,10 @@ impl LocalLspStore { ) .await .log_err(); - this.update(cx, |this, _| { + this.update(cx, |this, cx| { if let Some(transaction) = transaction { + cx.emit(LspStoreEvent::WorkspaceEditApplied(transaction.clone())); + this.as_local_mut() .unwrap() .last_workspace_edits_by_language_server @@ -3852,6 +3854,7 @@ pub enum LspStoreEvent { edits: Vec<(lsp::Range, Snippet)>, most_recent_edit: clock::Lamport, }, + WorkspaceEditApplied(ProjectTransaction), } #[derive(Clone, Debug, Serialize)] diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 9152096508b76d34fe3b2209cba94b4755b6ac67..b348fcdae2c414aa1b3f34f616ca3426899fe1d3 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -350,6 +350,7 @@ pub enum Event { SnippetEdit(BufferId, Vec<(lsp::Range, Snippet)>), ExpandedAllForEntry(WorktreeId, ProjectEntryId), EntryRenamed(ProjectTransaction, ProjectPath, PathBuf), + WorkspaceEditApplied(ProjectTransaction), AgentLocationChanged, } @@ -3249,6 +3250,9 @@ impl Project { cx.emit(Event::SnippetEdit(*buffer_id, edits.clone())) } } + LspStoreEvent::WorkspaceEditApplied(transaction) => { + cx.emit(Event::WorkspaceEditApplied(transaction.clone())) + } } } From a16f0712c8b4a1c63bdc919aca5780af25e4469c Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 17 Dec 2025 11:36:01 -0300 Subject: [PATCH 121/266] agent_ui: Fix double axis scroll in the edited files list (#45116) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Previously, the list of edit files had a double axis scroll issue because the list itself scrolled vertically and each file row would scroll horizontally, causing a bad UX. The horizontal scroll intention was so that you could see the whole path, but I've included it in the tooltip in case it becomes obscured due to a small panel width. Screenshot 2025-12-17 at 11  24@2x Release Notes: - agent: N/A --- crates/agent_ui/src/acp/thread_view.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index e7c40db7118468ae9d43bb5976992d05b745f182..63f0054ab7e1d25145974c3862ec7361007bace6 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -4121,6 +4121,8 @@ impl AcpThreadView { .ml_1p5() }); + let full_path = path.display(path_style).to_string(); + let file_icon = FileIcons::get_icon(path.as_std_path(), cx) .map(Icon::from_path) .map(|icon| icon.color(Color::Muted).size(IconSize::Small)) @@ -4154,7 +4156,6 @@ impl AcpThreadView { .relative() .pr_8() .w_full() - .overflow_x_scroll() .child( h_flex() .id(("file-name-path", index)) @@ -4166,7 +4167,14 @@ impl AcpThreadView { .child(file_icon) .children(file_name) .children(file_path) - .tooltip(Tooltip::text("Go to File")) + .tooltip(move |_, cx| { + Tooltip::with_meta( + "Go to File", + None, + full_path.clone(), + cx, + ) + }) .on_click({ let buffer = buffer.clone(); cx.listener(move |this, _, window, cx| { From 5b8e4e58c5f548ff1eda6ccd57997e2fda89e4b6 Mon Sep 17 00:00:00 2001 From: Remco Smits Date: Wed, 17 Dec 2025 16:31:36 +0100 Subject: [PATCH 122/266] git_ui: Fix select first entry selects the wrong visual first entry when tree view is enabled (#45108) This PR fixes a bug where the select first didn't select the first visual entry when the first entry is a collapsed directory. Follow-up: https://github.com/zed-industries/zed/pull/45030 **Before**: https://github.com/user-attachments/assets/5e5865cc-ec0f-471d-a81b-9521fb70df41 **After**: https://github.com/user-attachments/assets/05562572-e43f-4d1e-9638-80e4dccc0998 Release Notes: - git_ui: Fix select first entry selects the wrong visual first entry when tree view is enabled --- crates/git_ui/src/git_panel.rs | 42 ++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 15 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 1426ed1e65412da5cb8be22e7592e5a42917b367..cc9227093034ac0fa42b55324c0c2ab74a44903e 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -279,6 +279,13 @@ impl GitListEntry { _ => None, } } + + fn directory_entry(&self) -> Option<&GitTreeDirEntry> { + match self { + GitListEntry::Directory(entry) => Some(entry), + _ => None, + } + } } enum GitPanelViewMode { @@ -895,12 +902,6 @@ impl GitPanel { cx.notify(); } - fn first_status_entry_index(&self) -> Option { - self.entries - .iter() - .position(|entry| entry.status_entry().is_some()) - } - fn expand_selected_entry( &mut self, _: &ExpandSelectedEntry, @@ -944,7 +945,21 @@ impl GitPanel { } fn select_first(&mut self, _: &SelectFirst, _window: &mut Window, cx: &mut Context) { - if let Some(first_entry) = self.first_status_entry_index() { + let first_entry = match &self.view_mode { + GitPanelViewMode::Flat => self + .entries + .iter() + .position(|entry| entry.status_entry().is_some()), + GitPanelViewMode::Tree(state) => { + let index = self.entries.iter().position(|entry| { + entry.status_entry().is_some() || entry.directory_entry().is_some() + }); + + index.map(|index| state.logical_indices[index]) + } + }; + + if let Some(first_entry) = first_entry { self.selected_entry = Some(first_entry); self.scroll_to_selected_entry(cx); } @@ -1053,15 +1068,13 @@ impl GitPanel { cx.notify(); } - fn select_first_entry_if_none(&mut self, cx: &mut Context) { + fn select_first_entry_if_none(&mut self, window: &mut Window, cx: &mut Context) { let have_entries = self .active_repository .as_ref() .is_some_and(|active_repository| active_repository.read(cx).status_summary().count > 0); if have_entries && self.selected_entry.is_none() { - self.selected_entry = self.first_status_entry_index(); - self.scroll_to_selected_entry(cx); - cx.notify(); + self.select_first(&SelectFirst, window, cx); } } @@ -1071,10 +1084,9 @@ impl GitPanel { window: &mut Window, cx: &mut Context, ) { - self.select_first_entry_if_none(cx); - self.focus_handle.focus(window); - cx.notify(); + + self.select_first_entry_if_none(window, cx); } fn get_selected_entry(&self) -> Option<&GitListEntry> { @@ -3549,7 +3561,7 @@ impl GitPanel { self.bulk_staging = bulk_staging; } - self.select_first_entry_if_none(cx); + self.select_first_entry_if_none(window, cx); let suggested_commit_message = self.suggest_commit_message(cx); let placeholder_text = suggested_commit_message.unwrap_or("Enter commit message".into()); From 00ee06137ecda0bc00efce23797711a25990f10f Mon Sep 17 00:00:00 2001 From: peter schilling Date: Wed, 17 Dec 2025 07:32:37 -0800 Subject: [PATCH 123/266] Allow opening git commit view via URI scheme (#43341) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add support for `zed://git/commit/#` (**EDIT:** now changed to `zed://git/commit/?repo=`) URI scheme to access the git commit view implement parsing and handling of git commit URIs to navigate directly to commit views from external links. the main use case for me is to use OSC8 hyperlinks to link from a git sha into zed. this allows me e.g. to easily navigate from a terminal into zed **questions** - is this URI scheme appropriate? it was the first one i thought of, but wondering if `?ref=` might make more sense – the git/commit namespace was also an equally arbitrary choice
video demo showing navigation from zed's built in terminal https://github.com/user-attachments/assets/18ad7e64-6b39-44b2-a440-1a9eb71cd212
video demo showing navigation from ghostty to zed's commit view https://github.com/user-attachments/assets/1825e753-523f-4f98-b59c-7188ae2f5f19
Release Notes: - Added support for `zed://git/commit/?repo=` URI scheme to access the git commit view --------- Co-authored-by: Agus Zubiaga --- crates/zed/src/main.rs | 38 ++++++++++ crates/zed/src/zed/open_listener.rs | 107 ++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+) diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index c8137a71c0f2a8524f6310d7cd711978ed833d1a..bd26812a1a3037e9d7fe0bf38c84c61143cc23e8 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -900,6 +900,44 @@ fn handle_open_request(request: OpenRequest, app_state: Arc, cx: &mut }) .detach_and_log_err(cx); } + OpenRequestKind::GitCommit { sha } => { + cx.spawn(async move |cx| { + let paths_with_position = + derive_paths_with_position(app_state.fs.as_ref(), request.open_paths).await; + let (workspace, _results) = open_paths_with_positions( + &paths_with_position, + &[], + app_state, + workspace::OpenOptions::default(), + cx, + ) + .await?; + + workspace + .update(cx, |workspace, window, cx| { + let Some(repo) = workspace.project().read(cx).active_repository(cx) + else { + log::error!("no active repository found for commit view"); + return Err(anyhow::anyhow!("no active repository found")); + }; + + git_ui::commit_view::CommitView::open( + sha, + repo.downgrade(), + workspace.weak_handle(), + None, + None, + window, + cx, + ); + Ok(()) + }) + .log_err(); + + anyhow::Ok(()) + }) + .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 6352c20e5c0dcd0bd25063ca3a7bbcae87e48e3f..d61de0a291f3d3e7869225c0e07424cc3523f69b 100644 --- a/crates/zed/src/zed/open_listener.rs +++ b/crates/zed/src/zed/open_listener.rs @@ -58,6 +58,9 @@ pub enum OpenRequestKind { /// `None` opens settings without navigating to a specific path. setting_path: Option, }, + GitCommit { + sha: String, + }, } impl OpenRequest { @@ -110,6 +113,8 @@ impl OpenRequest { this.kind = Some(OpenRequestKind::Setting { setting_path: Some(setting_path.to_string()), }); + } else if let Some(commit_path) = url.strip_prefix("zed://git/commit/") { + this.parse_git_commit_url(commit_path)? } else if url.starts_with("ssh://") { this.parse_ssh_file_path(&url, cx)? } else if let Some(zed_link) = parse_zed_link(&url, cx) { @@ -138,6 +143,28 @@ impl OpenRequest { } } + fn parse_git_commit_url(&mut self, commit_path: &str) -> Result<()> { + // Format: ?repo= + let (sha, query) = commit_path + .split_once('?') + .context("invalid git commit url: missing query string")?; + anyhow::ensure!(!sha.is_empty(), "invalid git commit url: missing sha"); + + let repo = url::form_urlencoded::parse(query.as_bytes()) + .find_map(|(key, value)| (key == "repo").then_some(value)) + .filter(|s| !s.is_empty()) + .context("invalid git commit url: missing repo query parameter")? + .to_string(); + + self.open_paths.push(repo); + + self.kind = Some(OpenRequestKind::GitCommit { + sha: sha.to_string(), + }); + + Ok(()) + } + fn parse_ssh_file_path(&mut self, file: &str, cx: &App) -> Result<()> { let url = url::Url::parse(file)?; let host = url @@ -688,6 +715,86 @@ mod tests { assert_eq!(request.open_paths, vec!["/"]); } + #[gpui::test] + fn test_parse_git_commit_url(cx: &mut TestAppContext) { + let _app_state = init_test(cx); + + // Test basic git commit URL + let request = cx.update(|cx| { + OpenRequest::parse( + RawOpenRequest { + urls: vec!["zed://git/commit/abc123?repo=path/to/repo".into()], + ..Default::default() + }, + cx, + ) + .unwrap() + }); + + match request.kind.unwrap() { + OpenRequestKind::GitCommit { sha } => { + assert_eq!(sha, "abc123"); + } + _ => panic!("expected GitCommit variant"), + } + // Verify path was added to open_paths for workspace routing + assert_eq!(request.open_paths, vec!["path/to/repo"]); + + // Test with URL encoded path + let request = cx.update(|cx| { + OpenRequest::parse( + RawOpenRequest { + urls: vec!["zed://git/commit/def456?repo=path%20with%20spaces".into()], + ..Default::default() + }, + cx, + ) + .unwrap() + }); + + match request.kind.unwrap() { + OpenRequestKind::GitCommit { sha } => { + assert_eq!(sha, "def456"); + } + _ => panic!("expected GitCommit variant"), + } + assert_eq!(request.open_paths, vec!["path with spaces"]); + + // Test with empty path + cx.update(|cx| { + assert!( + OpenRequest::parse( + RawOpenRequest { + urls: vec!["zed://git/commit/abc123?repo=".into()], + ..Default::default() + }, + cx, + ) + .unwrap_err() + .to_string() + .contains("missing repo") + ); + }); + + // Test error case: missing SHA + let result = cx.update(|cx| { + OpenRequest::parse( + RawOpenRequest { + urls: vec!["zed://git/commit/abc123?foo=bar".into()], + ..Default::default() + }, + cx, + ) + }); + assert!(result.is_err()); + assert!( + result + .unwrap_err() + .to_string() + .contains("missing repo query parameter") + ); + } + #[gpui::test] async fn test_open_workspace_with_directory(cx: &mut TestAppContext) { let app_state = init_test(cx); From 1cf3422787cea9fe494ba37fcbab1c7a1a2ae899 Mon Sep 17 00:00:00 2001 From: Smit Barmase Date: Wed, 17 Dec 2025 21:06:22 +0530 Subject: [PATCH 124/266] editor: Separate delimiters computation from the newline method (#45119) Some refactoring I ran into while working on automatic Markdown list continuation on newline. This PR: - Moves `comment_delimiter` and `documentation_delimiter` computation outside of newline method. - Adds `NewlineFormatting`, which holds info about how newlines affect indentation and other formatting we need. - Moves newline-specific methods into the new `NewlineFormatting` struct. Release Notes: - N/A --- crates/editor/src/editor.rs | 537 +++++++++++++++++++----------------- 1 file changed, 282 insertions(+), 255 deletions(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index a66d92ceb8b0b6fa1631d0636294fbe3bd42af06..f9ffd835245ebb2ac7df8e8b7b667a1501c254fd 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -124,8 +124,9 @@ use language::{ AutoindentMode, BlockCommentConfig, BracketMatch, BracketPair, Buffer, BufferRow, BufferSnapshot, Capability, CharClassifier, CharKind, CharScopeContext, CodeLabel, CursorShape, DiagnosticEntryRef, DiffOptions, EditPredictionsMode, EditPreview, HighlightedText, IndentKind, - IndentSize, Language, LanguageName, LanguageRegistry, OffsetRangeExt, OutlineItem, Point, - Runnable, Selection, SelectionGoal, TextObject, TransactionId, TreeSitterOptions, WordsQuery, + IndentSize, Language, LanguageName, LanguageRegistry, LanguageScope, OffsetRangeExt, + OutlineItem, Point, Runnable, Selection, SelectionGoal, TextObject, TransactionId, + TreeSitterOptions, WordsQuery, language_settings::{ self, LanguageSettings, LspInsertMode, RewrapBehavior, WordsCompletionMode, all_language_settings, language_settings, @@ -4790,205 +4791,51 @@ impl Editor { let end = selection.end; let selection_is_empty = start == end; let language_scope = buffer.language_scope_at(start); - let ( - comment_delimiter, - doc_delimiter, - insert_extra_newline, - indent_on_newline, - indent_on_extra_newline, - ) = if let Some(language) = &language_scope { - let mut insert_extra_newline = - insert_extra_newline_brackets(&buffer, start..end, language) - || insert_extra_newline_tree_sitter(&buffer, start..end); - - // Comment extension on newline is allowed only for cursor selections - let comment_delimiter = maybe!({ - if !selection_is_empty { - return None; - } - - if !multi_buffer.language_settings(cx).extend_comment_on_newline { - return None; - } - - let delimiters = language.line_comment_prefixes(); - let max_len_of_delimiter = - delimiters.iter().map(|delimiter| delimiter.len()).max()?; - let (snapshot, range) = - buffer.buffer_line_for_row(MultiBufferRow(start_point.row))?; - - let num_of_whitespaces = snapshot - .chars_for_range(range.clone()) - .take_while(|c| c.is_whitespace()) - .count(); - let comment_candidate = snapshot - .chars_for_range(range.clone()) - .skip(num_of_whitespaces) - .take(max_len_of_delimiter) - .collect::(); - let (delimiter, trimmed_len) = delimiters - .iter() - .filter_map(|delimiter| { - let prefix = delimiter.trim_end(); - if comment_candidate.starts_with(prefix) { - Some((delimiter, prefix.len())) - } else { - None - } - }) - .max_by_key(|(_, len)| *len)?; - - 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()) { - let line_content = snapshot - .chars_for_range(range) - .skip(num_of_whitespaces) - .take(block_start_trimmed.len()) - .collect::(); - - if line_content.starts_with(block_start_trimmed) { - return None; - } + let (comment_delimiter, doc_delimiter, newline_formatting) = + if let Some(language) = &language_scope { + let mut newline_formatting = + NewlineFormatting::new(&buffer, start..end, language); + + // Comment extension on newline is allowed only for cursor selections + let comment_delimiter = maybe!({ + if !selection_is_empty { + return None; } - } - let cursor_is_placed_after_comment_marker = - num_of_whitespaces + trimmed_len <= start_point.column as usize; - if cursor_is_placed_after_comment_marker { - Some(delimiter.clone()) - } else { - None - } - }); - - let mut indent_on_newline = IndentSize::spaces(0); - let mut indent_on_extra_newline = IndentSize::spaces(0); - - let doc_delimiter = maybe!({ - if !selection_is_empty { - return None; - } - - if !multi_buffer.language_settings(cx).extend_comment_on_newline { - return None; - } - - let BlockCommentConfig { - start: start_tag, - end: end_tag, - prefix: delimiter, - tab_size: len, - } = language.documentation_comment()?; - let is_within_block_comment = buffer - .language_scope_at(start_point) - .is_some_and(|scope| scope.override_name() == Some("comment")); - if !is_within_block_comment { - return None; - } - - let (snapshot, range) = - buffer.buffer_line_for_row(MultiBufferRow(start_point.row))?; - - let num_of_whitespaces = snapshot - .chars_for_range(range.clone()) - .take_while(|c| c.is_whitespace()) - .count(); - - // It is safe to use a column from MultiBufferPoint in context of a single buffer ranges, because we're only ever looking at a single line at a time. - let column = start_point.column; - let cursor_is_after_start_tag = { - let start_tag_len = start_tag.len(); - let start_tag_line = snapshot - .chars_for_range(range.clone()) - .skip(num_of_whitespaces) - .take(start_tag_len) - .collect::(); - if start_tag_line.starts_with(start_tag.as_ref()) { - num_of_whitespaces + start_tag_len <= column as usize - } else { - false + if !multi_buffer.language_settings(cx).extend_comment_on_newline + { + return None; } - }; - let cursor_is_after_delimiter = { - let delimiter_trim = delimiter.trim_end(); - let delimiter_line = snapshot - .chars_for_range(range.clone()) - .skip(num_of_whitespaces) - .take(delimiter_trim.len()) - .collect::(); - if delimiter_line.starts_with(delimiter_trim) { - num_of_whitespaces + delimiter_trim.len() <= column as usize - } else { - false - } - }; + return comment_delimiter_for_newline( + &start_point, + &buffer, + language, + ); + }); - let cursor_is_before_end_tag_if_exists = { - let mut char_position = 0u32; - let mut end_tag_offset = None; - - 'outer: for chunk in snapshot.text_for_range(range) { - if let Some(byte_pos) = chunk.find(&**end_tag) { - let chars_before_match = - chunk[..byte_pos].chars().count() as u32; - end_tag_offset = - Some(char_position + chars_before_match); - break 'outer; - } - char_position += chunk.chars().count() as u32; + let doc_delimiter = maybe!({ + if !selection_is_empty { + return None; } - if let Some(end_tag_offset) = end_tag_offset { - let cursor_is_before_end_tag = column <= end_tag_offset; - if cursor_is_after_start_tag { - if cursor_is_before_end_tag { - insert_extra_newline = true; - } - 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; - } - } - cursor_is_before_end_tag - } else { - true + if !multi_buffer.language_settings(cx).extend_comment_on_newline + { + return None; } - }; - if (cursor_is_after_start_tag || cursor_is_after_delimiter) - && cursor_is_before_end_tag_if_exists - { - if cursor_is_after_start_tag { - indent_on_newline.len = *len; - } - Some(delimiter.clone()) - } else { - None - } - }); + return documentation_delimiter_for_newline( + &start_point, + &buffer, + language, + &mut newline_formatting, + ); + }); - ( - comment_delimiter, - doc_delimiter, - insert_extra_newline, - indent_on_newline, - indent_on_extra_newline, - ) - } else { - ( - None, - None, - false, - IndentSize::default(), - IndentSize::default(), - ) - }; + (comment_delimiter, doc_delimiter, newline_formatting) + } else { + (None, None, NewlineFormatting::default()) + }; let prevent_auto_indent = doc_delimiter.is_some(); let delimiter = comment_delimiter.or(doc_delimiter); @@ -4998,28 +4845,28 @@ impl Editor { let mut new_text = String::with_capacity( 1 + capacity_for_delimiter + existing_indent.len as usize - + indent_on_newline.len as usize - + indent_on_extra_newline.len as usize, + + newline_formatting.indent_on_newline.len as usize + + newline_formatting.indent_on_extra_newline.len as usize, ); new_text.push('\n'); new_text.extend(existing_indent.chars()); - new_text.extend(indent_on_newline.chars()); + new_text.extend(newline_formatting.indent_on_newline.chars()); if let Some(delimiter) = &delimiter { new_text.push_str(delimiter); } - if insert_extra_newline { + if newline_formatting.insert_extra_newline { new_text.push('\n'); new_text.extend(existing_indent.chars()); - new_text.extend(indent_on_extra_newline.chars()); + new_text.extend(newline_formatting.indent_on_extra_newline.chars()); } let anchor = buffer.anchor_after(end); let new_selection = selection.map(|_| anchor); ( ((start..end, new_text), prevent_auto_indent), - (insert_extra_newline, new_selection), + (newline_formatting.insert_extra_newline, new_selection), ) }) .unzip() @@ -23507,76 +23354,256 @@ struct CompletionEdit { snippet: Option, } -fn insert_extra_newline_brackets( +fn comment_delimiter_for_newline( + start_point: &Point, buffer: &MultiBufferSnapshot, - range: Range, - language: &language::LanguageScope, -) -> bool { - let leading_whitespace_len = buffer - .reversed_chars_at(range.start) - .take_while(|c| c.is_whitespace() && *c != '\n') - .map(|c| c.len_utf8()) - .sum::(); - let trailing_whitespace_len = buffer - .chars_at(range.end) - .take_while(|c| c.is_whitespace() && *c != '\n') - .map(|c| c.len_utf8()) - .sum::(); - let range = range.start - leading_whitespace_len..range.end + trailing_whitespace_len; - - language.brackets().any(|(pair, enabled)| { - let pair_start = pair.start.trim_end(); - let pair_end = pair.end.trim_start(); - - enabled - && pair.newline - && buffer.contains_str_at(range.end, pair_end) - && buffer.contains_str_at( - range.start.saturating_sub_usize(pair_start.len()), - pair_start, - ) - }) + language: &LanguageScope, +) -> Option> { + let delimiters = language.line_comment_prefixes(); + let max_len_of_delimiter = delimiters.iter().map(|delimiter| delimiter.len()).max()?; + let (snapshot, range) = buffer.buffer_line_for_row(MultiBufferRow(start_point.row))?; + + let num_of_whitespaces = snapshot + .chars_for_range(range.clone()) + .take_while(|c| c.is_whitespace()) + .count(); + let comment_candidate = snapshot + .chars_for_range(range.clone()) + .skip(num_of_whitespaces) + .take(max_len_of_delimiter) + .collect::(); + let (delimiter, trimmed_len) = delimiters + .iter() + .filter_map(|delimiter| { + let prefix = delimiter.trim_end(); + if comment_candidate.starts_with(prefix) { + Some((delimiter, prefix.len())) + } else { + None + } + }) + .max_by_key(|(_, len)| *len)?; + + 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()) { + let line_content = snapshot + .chars_for_range(range) + .skip(num_of_whitespaces) + .take(block_start_trimmed.len()) + .collect::(); + + if line_content.starts_with(block_start_trimmed) { + return None; + } + } + } + + let cursor_is_placed_after_comment_marker = + num_of_whitespaces + trimmed_len <= start_point.column as usize; + if cursor_is_placed_after_comment_marker { + Some(delimiter.clone()) + } else { + None + } } -fn insert_extra_newline_tree_sitter( +fn documentation_delimiter_for_newline( + start_point: &Point, buffer: &MultiBufferSnapshot, - range: Range, -) -> bool { - let (buffer, range) = match buffer.range_to_buffer_ranges(range).as_slice() { - [(buffer, range, _)] => (*buffer, range.clone()), - _ => return false, + language: &LanguageScope, + newline_formatting: &mut NewlineFormatting, +) -> Option> { + let BlockCommentConfig { + start: start_tag, + end: end_tag, + prefix: delimiter, + tab_size: len, + } = language.documentation_comment()?; + let is_within_block_comment = buffer + .language_scope_at(*start_point) + .is_some_and(|scope| scope.override_name() == Some("comment")); + if !is_within_block_comment { + return None; + } + + let (snapshot, range) = buffer.buffer_line_for_row(MultiBufferRow(start_point.row))?; + + let num_of_whitespaces = snapshot + .chars_for_range(range.clone()) + .take_while(|c| c.is_whitespace()) + .count(); + + // It is safe to use a column from MultiBufferPoint in context of a single buffer ranges, because we're only ever looking at a single line at a time. + let column = start_point.column; + let cursor_is_after_start_tag = { + let start_tag_len = start_tag.len(); + let start_tag_line = snapshot + .chars_for_range(range.clone()) + .skip(num_of_whitespaces) + .take(start_tag_len) + .collect::(); + if start_tag_line.starts_with(start_tag.as_ref()) { + num_of_whitespaces + start_tag_len <= column as usize + } else { + false + } }; - let pair = { - let mut result: Option> = None; - for pair in buffer - .all_bracket_ranges(range.start.0..range.end.0) - .filter(move |pair| { - pair.open_range.start <= range.start.0 && pair.close_range.end >= range.end.0 - }) - { - let len = pair.close_range.end - pair.open_range.start; + let cursor_is_after_delimiter = { + let delimiter_trim = delimiter.trim_end(); + let delimiter_line = snapshot + .chars_for_range(range.clone()) + .skip(num_of_whitespaces) + .take(delimiter_trim.len()) + .collect::(); + if delimiter_line.starts_with(delimiter_trim) { + num_of_whitespaces + delimiter_trim.len() <= column as usize + } else { + false + } + }; - if let Some(existing) = &result { - let existing_len = existing.close_range.end - existing.open_range.start; - if len > existing_len { - continue; + let cursor_is_before_end_tag_if_exists = { + let mut char_position = 0u32; + let mut end_tag_offset = None; + + 'outer: for chunk in snapshot.text_for_range(range) { + if let Some(byte_pos) = chunk.find(&**end_tag) { + let chars_before_match = chunk[..byte_pos].chars().count() as u32; + end_tag_offset = Some(char_position + chars_before_match); + break 'outer; + } + char_position += chunk.chars().count() as u32; + } + + if let Some(end_tag_offset) = end_tag_offset { + let cursor_is_before_end_tag = column <= end_tag_offset; + if cursor_is_after_start_tag { + if cursor_is_before_end_tag { + newline_formatting.insert_extra_newline = true; + } + let cursor_is_at_start_of_end_tag = column == end_tag_offset; + if cursor_is_at_start_of_end_tag { + newline_formatting.indent_on_extra_newline.len = *len; } } + cursor_is_before_end_tag + } else { + true + } + }; - result = Some(pair); + if (cursor_is_after_start_tag || cursor_is_after_delimiter) + && cursor_is_before_end_tag_if_exists + { + if cursor_is_after_start_tag { + newline_formatting.indent_on_newline.len = *len; } + Some(delimiter.clone()) + } else { + None + } +} - result - }; - let Some(pair) = pair else { - return false; - }; - pair.newline_only - && buffer - .chars_for_range(pair.open_range.end..range.start.0) - .chain(buffer.chars_for_range(range.end.0..pair.close_range.start)) - .all(|c| c.is_whitespace() && c != '\n') +#[derive(Debug, Default)] +struct NewlineFormatting { + insert_extra_newline: bool, + indent_on_newline: IndentSize, + indent_on_extra_newline: IndentSize, +} + +impl NewlineFormatting { + fn new( + buffer: &MultiBufferSnapshot, + range: Range, + language: &LanguageScope, + ) -> Self { + Self { + insert_extra_newline: Self::insert_extra_newline_brackets( + buffer, + range.clone(), + language, + ) || Self::insert_extra_newline_tree_sitter(buffer, range), + indent_on_newline: IndentSize::spaces(0), + indent_on_extra_newline: IndentSize::spaces(0), + } + } + + fn insert_extra_newline_brackets( + buffer: &MultiBufferSnapshot, + range: Range, + language: &language::LanguageScope, + ) -> bool { + let leading_whitespace_len = buffer + .reversed_chars_at(range.start) + .take_while(|c| c.is_whitespace() && *c != '\n') + .map(|c| c.len_utf8()) + .sum::(); + let trailing_whitespace_len = buffer + .chars_at(range.end) + .take_while(|c| c.is_whitespace() && *c != '\n') + .map(|c| c.len_utf8()) + .sum::(); + let range = range.start - leading_whitespace_len..range.end + trailing_whitespace_len; + + language.brackets().any(|(pair, enabled)| { + let pair_start = pair.start.trim_end(); + let pair_end = pair.end.trim_start(); + + enabled + && pair.newline + && buffer.contains_str_at(range.end, pair_end) + && buffer.contains_str_at( + range.start.saturating_sub_usize(pair_start.len()), + pair_start, + ) + }) + } + + fn insert_extra_newline_tree_sitter( + buffer: &MultiBufferSnapshot, + range: Range, + ) -> bool { + let (buffer, range) = match buffer.range_to_buffer_ranges(range).as_slice() { + [(buffer, range, _)] => (*buffer, range.clone()), + _ => return false, + }; + let pair = { + let mut result: Option> = None; + + for pair in buffer + .all_bracket_ranges(range.start.0..range.end.0) + .filter(move |pair| { + pair.open_range.start <= range.start.0 && pair.close_range.end >= range.end.0 + }) + { + let len = pair.close_range.end - pair.open_range.start; + + if let Some(existing) = &result { + let existing_len = existing.close_range.end - existing.open_range.start; + if len > existing_len { + continue; + } + } + + result = Some(pair); + } + + result + }; + let Some(pair) = pair else { + return false; + }; + pair.newline_only + && buffer + .chars_for_range(pair.open_range.end..range.start.0) + .chain(buffer.chars_for_range(range.end.0..pair.close_range.start)) + .all(|c| c.is_whitespace() && c != '\n') + } } fn update_uncommitted_diff_for_buffer( From 1705a7ce4e86fd2160e32b16e1e3ebe6c92d4dfa Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 17 Dec 2025 13:00:50 -0300 Subject: [PATCH 125/266] ui: Remove `InlineCode` component (#45123) We recently added this `InlineCode` component but I'd forgotten that many months ago I also introduced an `inline_code` method to the Label component which does the same thing. That means we don't need a standalone component at all! Release Notes: - N/A --- .../language_models/src/provider/lmstudio.rs | 4 +- crates/language_models/src/provider/ollama.rs | 10 +-- crates/ui/src/components.rs | 2 - crates/ui/src/components/inline_code.rs | 64 ------------------- 4 files changed, 7 insertions(+), 73 deletions(-) delete mode 100644 crates/ui/src/components/inline_code.rs diff --git a/crates/language_models/src/provider/lmstudio.rs b/crates/language_models/src/provider/lmstudio.rs index 8e42d12db4c24ef6a66ddef470a34c620ed7ee00..94f99f10afc8928fb7fbc8526ab46e7dca37a5ce 100644 --- a/crates/language_models/src/provider/lmstudio.rs +++ b/crates/language_models/src/provider/lmstudio.rs @@ -20,7 +20,7 @@ use settings::{Settings, SettingsStore}; use std::pin::Pin; use std::str::FromStr; use std::{collections::BTreeMap, sync::Arc}; -use ui::{ButtonLike, Indicator, InlineCode, List, ListBulletItem, prelude::*}; +use ui::{ButtonLike, Indicator, List, ListBulletItem, prelude::*}; use util::ResultExt; use crate::AllLanguageModelSettings; @@ -691,7 +691,7 @@ impl Render for ConfigurationView { .child( ListBulletItem::new("") .child(Label::new("To get your first model, try running")) - .child(InlineCode::new("lms get qwen2.5-coder-7b")), + .child(Label::new("lms get qwen2.5-coder-7b").inline_code(cx)), ), ), ) diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index 6f3c49f8669885bfd02e5b11b81a091b1248227c..c5a8bf41711563110cbcb5d81698b7029b04a713 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -23,8 +23,8 @@ use std::sync::LazyLock; use std::sync::atomic::{AtomicU64, Ordering}; use std::{collections::HashMap, sync::Arc}; use ui::{ - ButtonLike, ButtonLink, ConfiguredApiCard, ElevationIndex, InlineCode, List, ListBulletItem, - Tooltip, prelude::*, + ButtonLike, ButtonLink, ConfiguredApiCard, ElevationIndex, List, ListBulletItem, Tooltip, + prelude::*, }; use ui_input::InputField; @@ -724,7 +724,7 @@ impl ConfigurationView { cx.notify(); } - fn render_instructions() -> Div { + fn render_instructions(cx: &mut Context) -> Div { v_flex() .gap_2() .child(Label::new( @@ -742,7 +742,7 @@ impl ConfigurationView { .child( ListBulletItem::new("") .child(Label::new("Start Ollama and download a model:")) - .child(InlineCode::new("ollama run gpt-oss:20b")), + .child(Label::new("ollama run gpt-oss:20b").inline_code(cx)), ) .child(ListBulletItem::new( "Click 'Connect' below to start using Ollama in Zed", @@ -833,7 +833,7 @@ impl Render for ConfigurationView { v_flex() .gap_2() - .child(Self::render_instructions()) + .child(Self::render_instructions(cx)) .child(self.render_api_url_editor(cx)) .child(self.render_api_key_editor(cx)) .child( diff --git a/crates/ui/src/components.rs b/crates/ui/src/components.rs index c9cb943277c6c6a5e6bc1b472040c31d9caac45c..c08e46c5882cf3c9e0a8e205c8b23224d3a7a8e1 100644 --- a/crates/ui/src/components.rs +++ b/crates/ui/src/components.rs @@ -17,7 +17,6 @@ mod icon; mod image; mod indent_guides; mod indicator; -mod inline_code; mod keybinding; mod keybinding_hint; mod label; @@ -64,7 +63,6 @@ pub use icon::*; pub use image::*; pub use indent_guides::*; pub use indicator::*; -pub use inline_code::*; pub use keybinding::*; pub use keybinding_hint::*; pub use label::*; diff --git a/crates/ui/src/components/inline_code.rs b/crates/ui/src/components/inline_code.rs deleted file mode 100644 index 43507127fef478e5a38cfad2d84446673af15f2e..0000000000000000000000000000000000000000 --- a/crates/ui/src/components/inline_code.rs +++ /dev/null @@ -1,64 +0,0 @@ -use crate::prelude::*; -use gpui::{AnyElement, IntoElement, ParentElement, Styled}; - -/// InlineCode mimics the way inline code is rendered when wrapped in backticks in Markdown. -/// -/// # Usage Example -/// -/// ``` -/// use ui::InlineCode; -/// -/// let InlineCode = InlineCode::new("
hey
"); -/// ``` -#[derive(IntoElement, RegisterComponent)] -pub struct InlineCode { - label: SharedString, - label_size: LabelSize, -} - -impl InlineCode { - pub fn new(label: impl Into) -> Self { - Self { - label: label.into(), - label_size: LabelSize::Default, - } - } - - /// Sets the size of the label. - pub fn label_size(mut self, size: LabelSize) -> Self { - self.label_size = size; - self - } -} - -impl RenderOnce for InlineCode { - fn render(self, _: &mut Window, cx: &mut App) -> impl IntoElement { - h_flex() - .min_w_0() - .px_0p5() - .overflow_hidden() - .bg(cx.theme().colors().text.opacity(0.05)) - .child(Label::new(self.label).size(self.label_size).buffer_font(cx)) - } -} - -impl Component for InlineCode { - fn scope() -> ComponentScope { - ComponentScope::DataDisplay - } - - fn preview(_window: &mut Window, _cx: &mut App) -> Option { - Some( - v_flex() - .gap_6() - .child( - example_group(vec![single_example( - "Simple", - InlineCode::new("zed.dev").into_any_element(), - )]) - .vertical(), - ) - .into_any_element(), - ) - } -} From 80aefbe8e15d560e38e829b326c159d07c4ff09f Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Wed, 17 Dec 2025 11:14:29 -0500 Subject: [PATCH 126/266] Unified wording for discarding file changes in git panel (#45124) In the `...` menu, we use `Discard...` SCR-20251217-kbdh But in the context menu of each entry, we use "Restore..." SCR-20251217-kbcj This PR just makes this more consistent, by using "Discard..." in the second case. Release Notes: - Unified wording for discarding file changes in git panel --- crates/git_ui/src/git_panel.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index cc9227093034ac0fa42b55324c0c2ab74a44903e..b855d9b98708fe81328d69106ac1dda3b374080e 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -1220,14 +1220,14 @@ impl GitPanel { let prompt = window.prompt( PromptLevel::Warning, &format!( - "Are you sure you want to restore {}?", + "Are you sure you want to discard changes to {}?", entry .repo_path .file_name() .unwrap_or(entry.repo_path.display(path_style).as_ref()), ), None, - &["Restore", "Cancel"], + &["Discard Changes", "Cancel"], cx, ); cx.background_spawn(prompt) @@ -4710,7 +4710,7 @@ impl GitPanel { let restore_title = if entry.status.is_created() { "Trash File" } else { - "Restore File" + "Discard Changes" }; let context_menu = ContextMenu::build(window, cx, |context_menu, _, _| { let is_created = entry.status.is_created(); From 1446d84941cf0f04912559f31a399bb79053238b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yara=20=F0=9F=8F=B3=EF=B8=8F=E2=80=8D=E2=9A=A7=EF=B8=8F?= Date: Wed, 17 Dec 2025 17:14:57 +0100 Subject: [PATCH 127/266] Blockmap sync fix (#44743) Release Notes: - Improved display map rendering performance with many lines in the the multi-buffer. --------- Co-authored-by: cameron Co-authored-by: Cole Miller --- .mailmap | 3 + crates/editor/src/display_map.rs | 49 +++++++++ crates/editor/src/display_map/block_map.rs | 3 +- crates/editor/src/display_map/inlay_map.rs | 9 ++ crates/editor/src/display_map/wrap_map.rs | 118 ++++++++++++++++++--- crates/gpui/src/test.rs | 5 +- crates/ztracing/src/lib.rs | 22 ++-- 7 files changed, 185 insertions(+), 24 deletions(-) diff --git a/.mailmap b/.mailmap index db4632d6ca34346d3e8fa289222d7f310b7bdfe5..1e956c52cf76589fc016e1410122ccd94e4818ae 100644 --- a/.mailmap +++ b/.mailmap @@ -141,6 +141,9 @@ Uladzislau Kaminski Uladzislau Kaminski Vitaly Slobodin Vitaly Slobodin +Yara +Yara +Yara Will Bradley Will Bradley WindSoilder diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs index cab5b3686ee2f77dade059b434b1090cf9b2f7e5..413766cb283dfa2c5de0351b3ff10ff9b90a9c56 100644 --- a/crates/editor/src/display_map.rs +++ b/crates/editor/src/display_map.rs @@ -14,8 +14,57 @@ //! - [`DisplayMap`] that adds background highlights to the regions of text. //! Each one of those builds on top of preceding map. //! +//! ## Structure of the display map layers +//! +//! Each layer in the map (and the multibuffer itself to some extent) has a few +//! structures that are used to implement the public API available to the layer +//! above: +//! - a `Transform` type - this represents a region of text that the layer in +//! question is "managing", that it transforms into a more "processed" text +//! for the layer above. For example, the inlay map has an `enum Transform` +//! that has two variants: +//! - `Isomorphic`, representing a region of text that has no inlay hints (i.e. +//! is passed through the map transparently) +//! - `Inlay`, representing a location where an inlay hint is to be inserted. +//! - a `TransformSummary` type, which is usually a struct with two fields: +//! [`input: TextSummary`][`TextSummary`] and [`output: TextSummary`][`TextSummary`]. Here, +//! `input` corresponds to "text in the layer below", and `output` corresponds to the text +//! exposed to the layer above. So in the inlay map case, a `Transform::Isomorphic`'s summary is +//! just `input = output = summary`, where `summary` is the [`TextSummary`] stored in that +//! variant. Conversely, a `Transform::Inlay` always has an empty `input` summary, because it's +//! not "replacing" any text that exists on disk. The `output` is the summary of the inlay text +//! to be injected. - Various newtype wrappers for co-ordinate spaces (e.g. [`WrapRow`] +//! represents a row index, after soft-wrapping (and all lower layers)). +//! - A `Snapshot` type (e.g. [`InlaySnapshot`]) that captures the state of a layer at a specific +//! point in time. +//! - various APIs which drill through the layers below to work with the underlying text. Notably: +//! - `fn text_summary_for_offset()` returns a [`TextSummary`] for the range in the co-ordinate +//! space that the map in question is responsible for. +//! - `fn _point_to__point()` converts a point in co-ordinate space `A` into co-ordinate +//! space `B`. +//! - A [`RowInfo`] iterator (e.g. [`InlayBufferRows`]) and a [`Chunk`] iterator +//! (e.g. [`InlayChunks`]) +//! - A `sync` function (e.g. [`InlayMap::sync`]) that takes a snapshot and list of [`Edit`]s, +//! and returns a new snapshot and a list of transformed [`Edit`]s. Note that the generic +//! parameter on `Edit` changes, since these methods take in edits in the co-ordinate space of +//! the lower layer, and return edits in their own co-ordinate space. The term "edit" is +//! slightly misleading, since an [`Edit`] doesn't tell you what changed - rather it can be +//! thought of as a "region to invalidate". In theory, it would be correct to always use a +//! single edit that covers the entire range. However, this would lead to lots of unnecessary +//! recalculation. +//! +//! See the docs for the [`inlay_map`] module for a more in-depth explanation of how a single layer +//! works. +//! //! [Editor]: crate::Editor //! [EditorElement]: crate::element::EditorElement +//! [`TextSummary`]: multi_buffer::MBTextSummary +//! [`WrapRow`]: wrap_map::WrapRow +//! [`InlayBufferRows`]: inlay_map::InlayBufferRows +//! [`InlayChunks`]: inlay_map::InlayChunks +//! [`Edit`]: text::Edit +//! [`Edit`]: text::Edit +//! [`Chunk`]: language::Chunk #[macro_use] mod dimensions; diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs index 9c7f9d8632224208248a6585fc6f94939ee076fe..15bf012cd907da2455c1a2205bcccd363162fd46 100644 --- a/crates/editor/src/display_map/block_map.rs +++ b/crates/editor/src/display_map/block_map.rs @@ -545,7 +545,7 @@ impl BlockMap { { let max_point = wrap_snapshot.max_point(); let edit_start = wrap_snapshot.prev_row_boundary(max_point); - let edit_end = max_point.row() + WrapRow(1); + let edit_end = max_point.row() + WrapRow(1); // this is end of file edits = edits.compose([WrapEdit { old: edit_start..edit_end, new: edit_start..edit_end, @@ -715,6 +715,7 @@ impl BlockMap { let placement = block.placement.to_wrap_row(wrap_snapshot)?; if let BlockPlacement::Above(row) = placement && row < new_start + // this will be true more often now { return None; } diff --git a/crates/editor/src/display_map/inlay_map.rs b/crates/editor/src/display_map/inlay_map.rs index d85f761a82e2f466b6868c4ce28bcb3a4e6b061d..cbdc4b18fee452163c5a11932c968cb7cc500f96 100644 --- a/crates/editor/src/display_map/inlay_map.rs +++ b/crates/editor/src/display_map/inlay_map.rs @@ -1,3 +1,10 @@ +//! The inlay map. See the [`display_map`][super] docs for an overview of how the inlay map fits +//! into the rest of the [`DisplayMap`][super::DisplayMap]. Much of the documentation for this +//! module generalizes to other layers. +//! +//! The core of this module is the [`InlayMap`] struct, which maintains a vec of [`Inlay`]s, and +//! [`InlaySnapshot`], which holds a sum tree of [`Transform`]s. + use crate::{ ChunkRenderer, HighlightStyles, inlays::{Inlay, InlayContent}, @@ -69,7 +76,9 @@ impl sum_tree::Item for Transform { #[derive(Clone, Debug, Default)] struct TransformSummary { + /// Summary of the text before inlays have been applied. input: MBTextSummary, + /// Summary of the text after inlays have been applied. output: MBTextSummary, } diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs index 4d6b79d06170a22aaffafa05e0f144219e4d20a7..879ca11be1a84ffd44daa6e53677b06887172026 100644 --- a/crates/editor/src/display_map/wrap_map.rs +++ b/crates/editor/src/display_map/wrap_map.rs @@ -840,35 +840,62 @@ impl WrapSnapshot { self.tab_point_to_wrap_point(self.tab_snapshot.clip_point(self.to_tab_point(point), bias)) } - #[ztracing::instrument(skip_all, fields(point=?point, ret))] - pub fn prev_row_boundary(&self, mut point: WrapPoint) -> WrapRow { + /// Try to find a TabRow start that is also a WrapRow start + /// Every TabRow start is a WrapRow start + #[ztracing::instrument(skip_all, fields(point=?point))] + pub fn prev_row_boundary(&self, point: WrapPoint) -> WrapRow { if self.transforms.is_empty() { return WrapRow(0); } - *point.column_mut() = 0; + let point = WrapPoint::new(point.row(), 0); let mut cursor = self .transforms .cursor::>(()); - // start + cursor.seek(&point, Bias::Right); - // end if cursor.item().is_none() { cursor.prev(); } - // start + // real newline fake fake + // text: helloworldasldlfjasd\njdlasfalsk\naskdjfasdkfj\n + // dimensions v v v v v + // transforms |-------|-----NW----|-----W------|-----W------| + // cursor ^ ^^^^^^^^^^^^^ ^ + // (^) ^^^^^^^^^^^^^^ + // point: ^ + // point(col_zero): (^) + while let Some(transform) = cursor.item() { - if transform.is_isomorphic() && cursor.start().1.column() == 0 { - return cmp::min(cursor.end().0.row(), point.row()); - } else { - cursor.prev(); + if transform.is_isomorphic() { + // this transform only has real linefeeds + let tab_summary = &transform.summary.input; + // is the wrap just before the end of the transform a tab row? + // thats only if this transform has at least one newline + // + // "this wrap row is a tab row" <=> self.to_tab_point(WrapPoint::new(wrap_row, 0)).column() == 0 + + // Note on comparison: + // We have code that relies on this to be row > 1 + // It should work with row >= 1 but it does not :( + // + // That means that if every line is wrapped we walk back all the + // way to the start. Which invalidates the entire state triggering + // a full re-render. + if tab_summary.lines.row > 1 { + let wrap_point_at_end = cursor.end().0.row(); + return cmp::min(wrap_point_at_end - RowDelta(1), point.row()); + } else if cursor.start().1.column() == 0 { + return cmp::min(cursor.end().0.row(), point.row()); + } } + + cursor.prev(); } - // end - unreachable!() + WrapRow(0) } #[ztracing::instrument(skip_all)] @@ -891,13 +918,11 @@ impl WrapSnapshot { } #[cfg(test)] - #[ztracing::instrument(skip_all)] pub fn text(&self) -> String { self.text_chunks(WrapRow(0)).collect() } #[cfg(test)] - #[ztracing::instrument(skip_all)] pub fn text_chunks(&self, wrap_row: WrapRow) -> impl Iterator { self.chunks( wrap_row..self.max_point().row() + WrapRow(1), @@ -1298,6 +1323,71 @@ mod tests { use text::Rope; use theme::LoadThemes; + #[gpui::test] + async fn test_prev_row_boundary(cx: &mut gpui::TestAppContext) { + init_test(cx); + + fn test_wrap_snapshot( + text: &str, + soft_wrap_every: usize, // font size multiple + cx: &mut gpui::TestAppContext, + ) -> WrapSnapshot { + let text_system = cx.read(|cx| cx.text_system().clone()); + let tab_size = 4.try_into().unwrap(); + let font = test_font(); + let _font_id = text_system.resolve_font(&font); + let font_size = px(14.0); + // this is very much an estimate to try and get the wrapping to + // occur at `soft_wrap_every` we check that it pans out for every test case + let soft_wrapping = Some(font_size * soft_wrap_every * 0.6); + + let buffer = cx.new(|cx| language::Buffer::local(text, cx)); + let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx)); + let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx)); + let (_inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot); + let (_fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot); + let (mut tab_map, _) = TabMap::new(fold_snapshot, tab_size); + let tabs_snapshot = tab_map.set_max_expansion_column(32); + let (_wrap_map, wrap_snapshot) = + cx.update(|cx| WrapMap::new(tabs_snapshot, font, font_size, soft_wrapping, cx)); + + wrap_snapshot + } + + // These two should pass but dont, see the comparison note in + // prev_row_boundary about why. + // + // // 0123 4567 wrap_rows + // let wrap_snapshot = test_wrap_snapshot("1234\n5678", 1, cx); + // assert_eq!(wrap_snapshot.text(), "1\n2\n3\n4\n5\n6\n7\n8"); + // let row = wrap_snapshot.prev_row_boundary(wrap_snapshot.max_point()); + // assert_eq!(row.0, 3); + + // // 012 345 678 wrap_rows + // let wrap_snapshot = test_wrap_snapshot("123\n456\n789", 1, cx); + // assert_eq!(wrap_snapshot.text(), "1\n2\n3\n4\n5\n6\n7\n8\n9"); + // let row = wrap_snapshot.prev_row_boundary(wrap_snapshot.max_point()); + // assert_eq!(row.0, 5); + + // 012345678 wrap_rows + let wrap_snapshot = test_wrap_snapshot("123456789", 1, cx); + assert_eq!(wrap_snapshot.text(), "1\n2\n3\n4\n5\n6\n7\n8\n9"); + let row = wrap_snapshot.prev_row_boundary(wrap_snapshot.max_point()); + assert_eq!(row.0, 0); + + // 111 2222 44 wrap_rows + let wrap_snapshot = test_wrap_snapshot("123\n4567\n\n89", 4, cx); + assert_eq!(wrap_snapshot.text(), "123\n4567\n\n89"); + let row = wrap_snapshot.prev_row_boundary(wrap_snapshot.max_point()); + assert_eq!(row.0, 2); + + // 11 2223 wrap_rows + let wrap_snapshot = test_wrap_snapshot("12\n3456\n\n", 3, cx); + assert_eq!(wrap_snapshot.text(), "12\n345\n6\n\n"); + let row = wrap_snapshot.prev_row_boundary(wrap_snapshot.max_point()); + assert_eq!(row.0, 3); + } + #[gpui::test(iterations = 100)] async fn test_random_wraps(cx: &mut gpui::TestAppContext, mut rng: StdRng) { // todo this test is flaky diff --git a/crates/gpui/src/test.rs b/crates/gpui/src/test.rs index 5ae72d2be1688893374e16a55445558b5bc33040..2a5711a01a9c8f2874cea4803fc517089cafd0fe 100644 --- a/crates/gpui/src/test.rs +++ b/crates/gpui/src/test.rs @@ -69,7 +69,10 @@ pub fn run_test( std::mem::forget(error); } else { if is_multiple_runs { - eprintln!("failing seed: {}", seed); + eprintln!("failing seed: {seed}"); + eprintln!( + "You can rerun from this seed by setting the environmental variable SEED to {seed}" + ); } if let Some(on_fail_fn) = on_fail_fn { on_fail_fn() diff --git a/crates/ztracing/src/lib.rs b/crates/ztracing/src/lib.rs index b9b318cc3565d8ced2a5496f1240409542d23c5a..c9007be1ed43150ef877d51c882aee77845e5bd6 100644 --- a/crates/ztracing/src/lib.rs +++ b/crates/ztracing/src/lib.rs @@ -1,8 +1,8 @@ -pub use tracing::Level; +pub use tracing::{Level, field}; #[cfg(ztracing)] pub use tracing::{ - debug_span, error_span, event, info_span, instrument, span, trace_span, warn_span, + Span, debug_span, error_span, event, info_span, instrument, span, trace_span, warn_span, }; #[cfg(not(ztracing))] pub use ztracing_macro::instrument; @@ -26,17 +26,23 @@ pub use __consume_all_tokens as span; #[macro_export] macro_rules! __consume_all_tokens { ($($t:tt)*) => { - $crate::FakeSpan + $crate::Span }; } -pub struct FakeSpan; -impl FakeSpan { +#[cfg(not(ztracing))] +pub struct Span; + +#[cfg(not(ztracing))] +impl Span { + pub fn current() -> Self { + Self + } + pub fn enter(&self) {} -} -// #[cfg(not(ztracing))] -// pub use span; + pub fn record(&self, _t: T, _s: S) {} +} #[cfg(ztracing)] pub fn init() { From 081e820c43d9786287c85cf942024aa1adf88695 Mon Sep 17 00:00:00 2001 From: Katie Geer Date: Wed, 17 Dec 2025 08:28:32 -0800 Subject: [PATCH 128/266] docs: Dev container (#44498) Release Notes: - N/A --------- Co-authored-by: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Co-authored-by: Danilo Leal --- docs/src/SUMMARY.md | 1 + docs/src/dev-containers.md | 50 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+) create mode 100644 docs/src/dev-containers.md diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index d6dd7a0aef9737fb095e87705e813f87fd0ed683..d64aed93de16e8806b5e384452816c5d62ed621d 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -46,6 +46,7 @@ - [Tasks](./tasks.md) - [Tab Switcher](./tab-switcher.md) - [Remote Development](./remote-development.md) +- [Dev Containers](./dev-containers.md) - [Environment Variables](./environment.md) - [REPL](./repl.md) diff --git a/docs/src/dev-containers.md b/docs/src/dev-containers.md new file mode 100644 index 0000000000000000000000000000000000000000..c87b204ee9cded48edb95752dd234fa55df71338 --- /dev/null +++ b/docs/src/dev-containers.md @@ -0,0 +1,50 @@ +# Dev Containers + +Dev Containers provide a consistent, reproducible development environment by defining your project's dependencies, tools, and settings in a container configuration. + +If your repository includes a `.devcontainer/devcontainer.json` file, Zed can open a project inside a development container. + +## Requirements + +- Docker must be installed and available in your `PATH`. Zed requires the `docker` command to be present. If you use Podman, you can alias it to `docker` (e.g., `alias docker=podman`). +- Your project must contain a `.devcontainer/devcontainer.json` directory/file. + +## Using Dev Containers in Zed + +### Automatic prompt + +When you open a project that contains the `.devcontainer/devcontainer.json` directory/file, Zed will display a prompt asking whether to open the project inside the dev container. Choosing "Open in Container" will: + +1. Build the dev container image (if needed). +2. Launch the container. +3. Reopen the project connected to the container environment. + +### Manual open + +If you dismiss the prompt or want to reopen the project inside a container later, you can use Zed's command palette to run the "Project: Open Remote" command and select the option to open the project in a dev container. +Alternatively, you can reach for the Remote Projects modal (through the {#kb projects::OpenRemote} binding) and choose the "Connect Dev Container" option. + +## Editing the dev container configuration + +If you modify `.devcontainer/devcontainer.json`, Zed does not currently rebuild or reload the container automatically. After changing configuration: + +- Stop or kill the existing container manually (e.g., via `docker kill `). +- Reopen the project in the container. + +## Working in a Dev Container + +Once connected, Zed operates inside the container environment for tasks, terminals, and language servers. +Files are linked from your workspace into the container according to the dev container specification. + +## Known Limitations + +> **Note:** This feature is still in development. + +- **Extensions:** Zed does not yet manage extensions separately for container environments. The host's extensions are used as-is. +- **Port forwarding:** Only the `appPort` field is supported. `forwardPorts` and other advanced port-forwarding features are not implemented. +- **Configuration changes:** Updates to `devcontainer.json` do not trigger automatic rebuilds or reloads; containers must be manually restarted. + +## See also + +- [Remote Development](./remote-development.md) for connecting to remote servers over SSH. +- [Tasks](./tasks.md) for running commands in the integrated terminal. From f6c944f8651c8dedbb0f0e3fdc9c13f955f5e7a6 Mon Sep 17 00:00:00 2001 From: Antonio Scandurra Date: Wed, 17 Dec 2025 17:28:42 +0100 Subject: [PATCH 129/266] Fix focus lost when navigating to settings subpages (#45111) Fixes #42668 When clicking 'Configure' to enter a settings subpage, focus was being lost because push_sub_page only called cx.notify() without managing focus. Similarly, pop_sub_page had the same issue when navigating back. This fix: - Adds window parameter to push_sub_page and pop_sub_page - Focuses the content area when entering/leaving subpages - Resets scroll position when entering a subpage Release Notes: - Fixed a bug that prevented keyboard navigation in the settings window. --- crates/settings_ui/src/settings_ui.rs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs index 40678f6cf8d1c6773ccf1168e065cb318ae9f14f..101f52159a263910fba0d65782f06784f8183fd0 100644 --- a/crates/settings_ui/src/settings_ui.rs +++ b/crates/settings_ui/src/settings_ui.rs @@ -890,7 +890,7 @@ impl SettingsPageItem { .size(ButtonSize::Medium) .on_click({ let sub_page_link = sub_page_link.clone(); - cx.listener(move |this, _, _, cx| { + cx.listener(move |this, _, window, cx| { let mut section_index = item_index; let current_page = this.current_page(); @@ -909,7 +909,7 @@ impl SettingsPageItem { ) }; - this.push_sub_page(sub_page_link.clone(), header, cx) + this.push_sub_page(sub_page_link.clone(), header, window, cx) }) }), ) @@ -2995,8 +2995,8 @@ impl SettingsWindow { IconButton::new("back-btn", IconName::ArrowLeft) .icon_size(IconSize::Small) .shape(IconButtonShape::Square) - .on_click(cx.listener(|this, _, _, cx| { - this.pop_sub_page(cx); + .on_click(cx.listener(|this, _, window, cx| { + this.pop_sub_page(window, cx); })), ) .child(self.render_sub_page_breadcrumbs()), @@ -3355,17 +3355,22 @@ impl SettingsWindow { &mut self, sub_page_link: SubPageLink, section_header: &'static str, + window: &mut Window, cx: &mut Context, ) { sub_page_stack_mut().push(SubPage { link: sub_page_link, section_header, }); + self.sub_page_scroll_handle + .set_offset(point(px(0.), px(0.))); + self.content_focus_handle.focus_handle(cx).focus(window); cx.notify(); } - fn pop_sub_page(&mut self, cx: &mut Context) { + fn pop_sub_page(&mut self, window: &mut Window, cx: &mut Context) { sub_page_stack_mut().pop(); + self.content_focus_handle.focus_handle(cx).focus(window); cx.notify(); } From 74b4013e67ce1a11497806300ca886ba4231ef15 Mon Sep 17 00:00:00 2001 From: Ramon <55579979+van-sprundel@users.noreply.github.com> Date: Wed, 17 Dec 2025 17:32:50 +0100 Subject: [PATCH 130/266] git: Mark entries as pending when staging a files making the staged highlighting more "optimistic" (#43434) This at least speeds it up, not sure if this would close the issue On main (342eba6f220625c015d00334c6bc354f0e2c52e1): https://github.com/user-attachments/assets/55d10187-b4e6-410d-9002-06509e8015c9 This branch: https://github.com/user-attachments/assets/e9a5c14f-9694-4321-a81c-88d6f62fb342 Closes #26870 Release Notes: - Added optimistic staged hunk updating --- crates/project/src/git_store.rs | 81 +++++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index c73ab914b788fb92e69ea3a47db5446223098c2d..a414a03320a2defa4c9dbd4b6193a131e761d2c7 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -1672,6 +1672,59 @@ impl GitStore { } } + fn mark_entries_pending_by_project_paths( + &mut self, + project_paths: &[ProjectPath], + stage: bool, + cx: &mut Context, + ) { + let buffer_store = &self.buffer_store; + + for project_path in project_paths { + let Some(buffer) = buffer_store.read(cx).get_by_path(project_path) else { + continue; + }; + + let buffer_id = buffer.read(cx).remote_id(); + let Some(diff_state) = self.diffs.get(&buffer_id) else { + continue; + }; + + diff_state.update(cx, |diff_state, cx| { + let Some(uncommitted_diff) = diff_state.uncommitted_diff() else { + return; + }; + + let buffer_snapshot = buffer.read(cx).text_snapshot(); + let file_exists = buffer + .read(cx) + .file() + .is_some_and(|file| file.disk_state().exists()); + + let all_hunks: Vec<_> = uncommitted_diff + .read(cx) + .hunks_intersecting_range( + text::Anchor::MIN..text::Anchor::MAX, + &buffer_snapshot, + cx, + ) + .collect(); + + if !all_hunks.is_empty() { + uncommitted_diff.update(cx, |diff, cx| { + diff.stage_or_unstage_hunks( + stage, + &all_hunks, + &buffer_snapshot, + file_exists, + cx, + ); + }); + } + }); + } + } + pub fn git_clone( &self, repo: String, @@ -4200,6 +4253,28 @@ impl Repository { save_futures } + fn mark_entries_pending_for_stage( + &self, + entries: &[RepoPath], + stage: bool, + cx: &mut Context, + ) { + let Some(git_store) = self.git_store() else { + return; + }; + + let mut project_paths = Vec::new(); + for repo_path in entries { + if let Some(project_path) = self.repo_path_to_project_path(repo_path, cx) { + project_paths.push(project_path); + } + } + + git_store.update(cx, move |git_store, cx| { + git_store.mark_entries_pending_by_project_paths(&project_paths, stage, cx); + }); + } + pub fn stage_entries( &mut self, entries: Vec, @@ -4208,6 +4283,9 @@ impl Repository { if entries.is_empty() { return Task::ready(Ok(())); } + + self.mark_entries_pending_for_stage(&entries, true, cx); + let id = self.id; let save_tasks = self.save_buffers(&entries, cx); let paths = entries @@ -4273,6 +4351,9 @@ impl Repository { if entries.is_empty() { return Task::ready(Ok(())); } + + self.mark_entries_pending_for_stage(&entries, false, cx); + let id = self.id; let save_tasks = self.save_buffers(&entries, cx); let paths = entries From ad58f1f68b322e9654c993b6fe32fd35fb091b30 Mon Sep 17 00:00:00 2001 From: Katie Geer Date: Wed, 17 Dec 2025 08:44:48 -0800 Subject: [PATCH 131/266] docs: Add migrate docs for Webstorm / Pycharm / RustRover (#45128) Release Notes: - N/A --- docs/.rules | 1 + docs/src/SUMMARY.md | 3 + docs/src/migrate/_research-notes.md | 73 ++++ docs/src/migrate/intellij.md | 6 +- docs/src/migrate/pycharm.md | 438 ++++++++++++++++++++++++ docs/src/migrate/rustrover.md | 501 ++++++++++++++++++++++++++++ docs/src/migrate/webstorm.md | 455 +++++++++++++++++++++++++ 7 files changed, 1474 insertions(+), 3 deletions(-) create mode 100644 docs/src/migrate/_research-notes.md create mode 100644 docs/src/migrate/pycharm.md create mode 100644 docs/src/migrate/rustrover.md create mode 100644 docs/src/migrate/webstorm.md diff --git a/docs/.rules b/docs/.rules index 17c0e97450ce50f6846c865d58289257f2008f5c..4e6ca312f13b12a54a73d736ffeed8a8e09061ef 100644 --- a/docs/.rules +++ b/docs/.rules @@ -17,6 +17,7 @@ - Apologetic tone for missing features—state the limitation and move on - Comparisons that disparage other tools—be factual, not competitive - Meta-commentary about honesty ("the honest take is...", "to be frank...", "honestly...")—let honesty show through frank assessments, not announcements +- LLM-isms and filler words ("entirely," "certainly,", "deeply," "definitely," "actually")—these add nothing ## Content Structure diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index d64aed93de16e8806b5e384452816c5d62ed621d..1f9c5750ea76b35a2f7f5464b7b6684401108d2b 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -92,6 +92,9 @@ - [VS Code](./migrate/vs-code.md) - [IntelliJ IDEA](./migrate/intellij.md) +- [PyCharm](./migrate/pycharm.md) +- [WebStorm](./migrate/webstorm.md) +- [RustRover](./migrate/rustrover.md) # Language Support diff --git a/docs/src/migrate/_research-notes.md b/docs/src/migrate/_research-notes.md new file mode 100644 index 0000000000000000000000000000000000000000..e23a3d3529a9762368e1721f97a6720382cd764b --- /dev/null +++ b/docs/src/migrate/_research-notes.md @@ -0,0 +1,73 @@ + + +# Migration Research Notes + +## Completed Guides + +All three JetBrains migration guides have been populated with full content: + +1. **pycharm.md** - Python development, virtual environments, Ruff/Pyright, Django/Flask workflows +2. **webstorm.md** - JavaScript/TypeScript development, npm workflows, framework considerations +3. **rustrover.md** - Rust development, rust-analyzer parity, Cargo workflows, licensing notes + +## Key Sources Used + +- IntelliJ IDEA migration doc (structural template) +- JetBrains PyCharm Getting Started docs +- JetBrains WebStorm Getting Started docs +- JetBrains RustRover Quick Start Guide +- External community feedback (Reddit, Hacker News, Medium) + +## External Quotes Incorporated + +### WebStorm Guide + +> "I work for AWS and the applications I deal with are massive. Often I need to keep many projects open due to tight dependencies. I'm talking about complex microservices and micro frontend infrastructure which oftentimes lead to 2-15 minutes of indexing wait time whenever I open a project or build the system locally." + +### RustRover Guide + +- Noted rust-analyzer shared foundation between RustRover and Zed +- Addressed licensing/telemetry concerns that motivate some users to switch +- Included debugger caveats based on community feedback + +## Cross-Cutting Themes Applied to All Guides + +### Universal Pain Points Addressed + +1. Indexing (instant in Zed) +2. Resource usage (Zed is lightweight) +3. Startup time (Zed is near-instant) +4. UI clutter (Zed is minimal by design) + +### Universal Missing Features Documented + +- No project model / SDK management +- No database tools +- No framework-specific integration +- No visual run configurations (use tasks) +- No built-in HTTP client + +### JetBrains Keymap Emphasized + +All three guides emphasize: + +- Select JetBrains keymap during onboarding or in settings +- `Shift Shift` for Search Everywhere works +- Most familiar shortcuts preserved + +## Next Steps (Optional Enhancements) + +- [ ] Cross-link guides to JetBrains docs for users who want to reference original IDE features +- [ ] Add a consolidated "hub page" linking to all migration guides +- [ ] Consider adding VS Code migration guide using similar structure +- [ ] Review for tone consistency against Zed Documentation Guidelines diff --git a/docs/src/migrate/intellij.md b/docs/src/migrate/intellij.md index d931fde4f1c2cd98db6b154d7009feff6fcb6a5b..24c85774ec5686f605d1d781913d0873ac0abd7f 100644 --- a/docs/src/migrate/intellij.md +++ b/docs/src/migrate/intellij.md @@ -33,7 +33,7 @@ This opens the current directory in Zed. If you're coming from IntelliJ, the fastest way to feel at home is to use the JetBrains keymap. During onboarding, you can select it as your base keymap. If you missed that step, you can change it anytime: 1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) -2. Search for `base_keymap` +2. Search for `Base Keymap` 3. Select `JetBrains` Or add this directly to your `settings.json`: @@ -147,7 +147,7 @@ If you've used IntelliJ on large projects, you know the wait: "Indexing..." can Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size. -The trade-off is real: IntelliJ's index powers features like finding all usages across your entire codebase, understanding class hierarchies, and detecting dead code. Zed delegates this work to language servers, which may not analyze as deeply or as broadly. +IntelliJ's index powers features like finding all usages across your entire codebase, understanding class hierarchies, and detecting dead code. Zed delegates this work to language servers, which may not analyze at the same depth. **How to adapt:** @@ -158,7 +158,7 @@ The trade-off is real: IntelliJ's index powers features like finding all usages ### LSP vs. Native Language Intelligence -IntelliJ has its own language analysis engine built from scratch for each supported language. For Java, Kotlin, and other JVM languages, this engine understands your code deeply: it resolves types, tracks data flow, knows about framework annotations, and offers dozens of specialized refactorings. +IntelliJ has its own language analysis engine built from scratch for each supported language. For Java, Kotlin, and other JVM languages, this engine understands your code thoroughly: it resolves types, tracks data flow, knows about framework annotations, and offers dozens of specialized refactorings. Zed uses the Language Server Protocol (LSP) for code intelligence. Each language has its own server: `jdtls` for Java, `rust-analyzer` for Rust, and so on. diff --git a/docs/src/migrate/pycharm.md b/docs/src/migrate/pycharm.md new file mode 100644 index 0000000000000000000000000000000000000000..636bc69eeba1c09b3e0e8a0d74ccd859aedbb342 --- /dev/null +++ b/docs/src/migrate/pycharm.md @@ -0,0 +1,438 @@ +# How to Migrate from PyCharm to Zed + +This guide covers how to set up Zed if you're coming from PyCharm, including keybindings, settings, and the differences you should expect. + +## Install Zed + +Zed is available on macOS, Windows, and Linux. + +For macOS, you can download it from zed.dev/download, or install via Homebrew: + +```sh +brew install --cask zed +``` + +For Windows, download the installer from zed.dev/download, or install via winget: + +```sh +winget install Zed.Zed +``` + +For most Linux users, the easiest way to install Zed is through our installation script: + +```sh +curl -f https://zed.dev/install.sh | sh +``` + +After installation, you can launch Zed from your Applications folder (macOS), Start menu (Windows), or directly from the terminal using: +`zed .` +This opens the current directory in Zed. + +## Set Up the JetBrains Keymap + +If you're coming from PyCharm, the fastest way to feel at home is to use the JetBrains keymap. During onboarding, you can select it as your base keymap. If you missed that step, you can change it anytime: + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Search for `Base Keymap` +3. Select `JetBrains` + +Or add this directly to your `settings.json`: + +```json +{ + "base_keymap": "JetBrains" +} +``` + +This maps familiar shortcuts like `Shift Shift` for Search Everywhere, `Cmd+O` for Go to Class, and `Cmd+Shift+A` for Find Action. + +## Set Up Editor Preferences + +You can configure settings manually in the Settings Editor. + +To edit your settings: + +1. `Cmd+,` to open the Settings Editor. +2. Run `zed: open settings` in the Command Palette. + +Settings PyCharm users typically configure first: + +| Zed Setting | What it does | +| ----------------------- | ------------------------------------------------------------------------------- | +| `format_on_save` | Auto-format when saving. Set to `"on"` to enable. | +| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` | +| `preferred_line_length` | Column width for wrapping and rulers. Default is 80, PEP 8 recommends 79. | +| `inlay_hints` | Show parameter names and type hints inline, like PyCharm's hints. | +| `relative_line_numbers` | Useful if you're coming from IdeaVim. | + +Zed also supports per-project settings. Create a `.zed/settings.json` file in your project root to override global settings for that project, similar to how you might use `.idea` folders in PyCharm. + +> **Tip:** If you're joining an existing project, check `format_on_save` before making your first commit. Otherwise you might accidentally reformat an entire file when you only meant to change one line. + +## Open or Create a Project + +After setup, press `Cmd+Shift+O` (with JetBrains keymap) to open a folder. This becomes your workspace in Zed. Unlike PyCharm, there's no project configuration wizard, no interpreter selection dialog, and no project structure setup required. + +To start a new project, create a directory using your terminal or file manager, then open it in Zed. The editor will treat that folder as the root of your project. + +You can also launch Zed from the terminal inside any folder with: +`zed .` + +Once inside a project: + +- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like PyCharm's "Recent Files") +- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like PyCharm's "Search Everywhere") +- Use `Cmd+O` to search for symbols (like PyCharm's "Go to Symbol") + +Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like PyCharm's Project tool window). + +## Differences in Keybindings + +If you chose the JetBrains keymap during onboarding, most of your shortcuts should already feel familiar. Here's a quick reference for how Zed compares to PyCharm. + +### Common Shared Keybindings + +| Action | Shortcut | +| ----------------------------- | ----------------------- | +| Search Everywhere | `Shift Shift` | +| Find Action / Command Palette | `Cmd + Shift + A` | +| Go to File | `Cmd + Shift + O` | +| Go to Symbol | `Cmd + O` | +| Recent Files | `Cmd + E` | +| Go to Definition | `Cmd + B` | +| Find Usages | `Alt + F7` | +| Rename Symbol | `Shift + F6` | +| Reformat Code | `Cmd + Alt + L` | +| Toggle Project Panel | `Cmd + 1` | +| Toggle Terminal | `Alt + F12` | +| Duplicate Line | `Cmd + D` | +| Delete Line | `Cmd + Backspace` | +| Move Line Up/Down | `Shift + Alt + Up/Down` | +| Expand/Shrink Selection | `Alt + Up/Down` | +| Comment Line | `Cmd + /` | +| Go Back / Forward | `Cmd + [` / `Cmd + ]` | +| Toggle Breakpoint | `Ctrl + F8` | + +### Different Keybindings (PyCharm → Zed) + +| Action | PyCharm | Zed (JetBrains keymap) | +| ---------------------- | ----------- | ------------------------ | +| File Structure | `Cmd + F12` | `Cmd + F12` (outline) | +| Navigate to Next Error | `F2` | `F2` | +| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) | +| Debug | `Ctrl + D` | `Alt + Shift + F9` | +| Stop | `Cmd + F2` | `Ctrl + F2` | + +### Unique to Zed + +| Action | Shortcut | Notes | +| ----------------- | -------------------------- | ------------------------------ | +| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications | +| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction | + +### How to Customize Keybindings + +- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`) +- Run `Zed: Open Keymap Editor` + +This opens a list of all available bindings. You can override individual shortcuts or remove conflicts. + +Zed also supports key sequences (multi-key shortcuts). + +## Differences in User Interfaces + +### No Indexing + +If you've used PyCharm on large projects, you know the wait: "Indexing..." can take anywhere from 30 seconds to several minutes depending on project size and dependencies. PyCharm builds a comprehensive index of your entire codebase to power its code intelligence, and it re-indexes when dependencies change or when you install new packages. + +Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size. For many PyCharm users, this alone is reason enough to switch—no more waiting, no more "Indexing paused" interruptions. + +PyCharm's index powers features like finding all usages across your entire codebase, understanding class hierarchies, and detecting unused imports project-wide. Zed delegates this work to language servers, which may not analyze as deeply or as broadly. + +**How to adapt:** + +- For project-wide symbol search, use `Cmd+O` / Go to Symbol (relies on your language server) +- For finding files by name, use `Cmd+Shift+O` / Go to File +- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases +- For deep static analysis, consider running tools like `mypy`, `pylint`, or `ruff check` from the terminal + +### LSP vs. Native Language Intelligence + +PyCharm has its own language analysis engine built specifically for Python. This engine understands your code deeply: it resolves types without annotations, tracks data flow, knows about Django models and Flask routes, and offers specialized refactorings. + +Zed uses the Language Server Protocol (LSP) for code intelligence. For Python, Zed provides several language servers out of the box: + +- **basedpyright** (default) — Fast type checking and completions +- **Ruff** (default) — Linting and formatting +- **Ty** — Up-and-coming language server from Astral, built for speed +- **Pyright** — Microsoft's type checker +- **PyLSP** — Plugin-based server with tool integrations + +The LSP experience for Python is strong. basedpyright provides accurate completions, type checking, and navigation. Ruff handles formatting and linting with excellent performance. + +Where you might notice differences: + +- Framework-specific intelligence (Django ORM, Flask routes) isn't built-in +- Some complex refactorings (extract method with proper scope analysis) may be less sophisticated +- Auto-import suggestions depend on what the language server knows about your environment + +**How to adapt:** + +- Use `Alt+Enter` for available code actions—the list will vary by language server +- Ensure your virtual environment is selected so the language server can resolve your dependencies +- Use Ruff for fast, consistent formatting (it's enabled by default) +- For code inspection similar to PyCharm's "Inspect Code," run `ruff check .` or check the Diagnostics panel (`Cmd+6`)—basedpyright and Ruff together catch many of the same issues + +### Virtual Environments and Interpreters + +In PyCharm, you select a Python interpreter through a GUI, and PyCharm manages the connection between your project and that interpreter. It shows available packages, lets you install new ones, and keeps track of which environment each project uses. + +Zed handles virtual environments through its toolchain system: + +- Zed automatically discovers virtual environments in common locations (`.venv`, `venv`, `.env`, `env`) +- When a virtual environment is detected, the terminal auto-activates it +- Language servers are automatically configured to use the discovered environment +- You can manually select a toolchain if auto-detection picks the wrong one + +**How to adapt:** + +- Create your virtual environment with `python -m venv .venv` or `uv sync` +- Open the folder in Zed—it will detect the environment automatically +- If you need to switch environments, use the toolchain selector +- For conda environments, ensure they're activated in your shell before launching Zed + +> **Tip:** If basedpyright shows import errors for packages you've installed, check that Zed has selected the correct virtual environment. Use the toolchain selector to verify or change the active environment. + +### No Project Model + +PyCharm manages projects through `.idea` folders containing XML configuration files, interpreter assignments, and run configurations. This model lets PyCharm remember your interpreter choice, manage dependencies through the UI, and persist complex run/debug setups. + +Zed has no project model. A project is a folder. There's no wizard, no interpreter selection screen, no project structure configuration. + +This means: + +- Run configurations don't exist. You define tasks or use the terminal. Your existing PyCharm run configs in `.idea/` won't be read—you'll recreate the ones you need in `tasks.json`. +- Interpreter management is external. Zed discovers environments but doesn't create them. +- Dependencies are managed through pip, uv, poetry, or conda—not through the editor. +- There's no Python Console (interactive REPL) panel. Use `python` or `ipython` in the terminal instead. + +**How to adapt:** + +- Create a `.zed/settings.json` in your project root for project-specific settings +- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`): + +```json +[ + { + "label": "run", + "command": "python main.py" + }, + { + "label": "test", + "command": "pytest" + }, + { + "label": "test current file", + "command": "pytest $ZED_FILE" + } +] +``` + +- Use `Ctrl+Alt+R` to run tasks quickly +- Lean on your terminal (`Alt+F12`) for anything tasks don't cover + +### No Framework Integration + +PyCharm Professional's value for web development comes largely from its framework integration. Django templates are understood and navigable. Flask routes are indexed. SQLAlchemy models get special treatment. Template variables autocomplete. + +Zed has none of this. The language server sees Python code as Python code—it doesn't understand that `@app.route` defines an endpoint or that a Django model class creates database tables. + +**How to adapt:** + +- Use grep and file search liberally. `Cmd+Shift+F` with a regex can find route definitions, model classes, or template usages. +- Rely on your language server's "find references" (`Alt+F7`) for navigation—it works, just without framework context +- Consider using framework-specific CLI tools (`python manage.py`, `flask routes`) from Zed's terminal + +> **Tip:** For database work, pick up a dedicated tool like DataGrip, DBeaver, or TablePlus. Many developers who switch to Zed keep DataGrip around specifically for SQL. + +### Tool Windows vs. Docks + +PyCharm organizes auxiliary views into numbered tool windows (Project = 1, Python Console = 4, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks": + +| PyCharm Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) | +| ------------------- | -------------- | --------------------------- | +| Project (1) | Project Panel | `Cmd + 1` | +| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` | +| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` | +| Structure (7) | Outline Panel | `Cmd + 7` | +| Problems (6) | Diagnostics | `Cmd + 6` | +| Debug (5) | Debug Panel | `Cmd + 5` | + +Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings. + +### Debugging + +Both PyCharm and Zed offer integrated debugging, but the experience differs: + +- Zed uses `debugpy` (the same debug adapter that VS Code uses) +- Set breakpoints with `Ctrl+F8` +- Start debugging with `Alt+Shift+F9` or press `F4` and select a debug target +- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out) +- Continue execution with `F9` + +Zed can automatically detect debuggable entry points. Press `F4` to see available options, including: + +- Python scripts +- Modules +- pytest tests + +For more control, create a `.zed/debug.json` file: + +```json +[ + { + "label": "Debug Current File", + "adapter": "Debugpy", + "program": "$ZED_FILE", + "request": "launch" + }, + { + "label": "Debug Flask App", + "adapter": "Debugpy", + "request": "launch", + "module": "flask", + "args": ["run", "--debug"], + "env": { + "FLASK_APP": "app.py" + } + } +] +``` + +### Running Tests + +PyCharm has a dedicated test runner with a visual interface showing pass/fail status for each test. Zed provides test running through: + +- **Gutter icons** — Click the play button next to test functions or classes +- **Tasks** — Define pytest or unittest commands in `tasks.json` +- **Terminal** — Run `pytest` directly + +The test output appears in the terminal panel. For pytest, use `--tb=short` for concise tracebacks or `-v` for verbose output. + +### Extensions vs. Plugins + +PyCharm has a plugin ecosystem covering everything from additional language support to database tools to deployment integrations. + +Zed's extension ecosystem is smaller and more focused: + +- Language support and syntax highlighting +- Themes +- Slash commands for AI +- Context servers + +Several features that require plugins in PyCharm are built into Zed: + +- Real-time collaboration with voice chat +- AI coding assistance +- Built-in terminal +- Task runner +- LSP-based code intelligence +- Ruff formatting and linting + +### What's Not in Zed + +To set expectations clearly, here's what PyCharm offers that Zed doesn't have: + +- **Scientific Mode / Jupyter integration** — For notebooks and data science workflows, use JupyterLab or VS Code with the Jupyter extension alongside Zed for your Python editing +- **Database tools** — Use DataGrip, DBeaver, or TablePlus +- **Django/Flask template navigation** — Use file search and grep +- **Visual package manager** — Use pip, uv, or poetry from the terminal +- **Remote interpreters** — Zed has remote development, but it works differently +- **Profiler integration** — Use cProfile, py-spy, or similar tools externally + +## Collaboration in Zed vs. PyCharm + +PyCharm offers Code With Me as a separate plugin for collaboration. Zed has collaboration built into the core experience. + +- Open the Collab Panel in the left dock +- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join +- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly + +Once connected, you'll see each other's cursors, selections, and edits in real time. Voice chat is included. There's no need for separate tools or third-party logins. + +## Using AI in Zed + +If you're used to AI assistants in PyCharm (like GitHub Copilot or JetBrains AI Assistant), Zed offers similar capabilities with more flexibility. + +### Configuring GitHub Copilot + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Navigate to **AI → Edit Predictions** +3. Click **Configure** next to "Configure Providers" +4. Under **GitHub Copilot**, click **Sign in to GitHub** + +Once signed in, just start typing. Zed will offer suggestions inline for you to accept. + +### Additional AI Options + +To use other AI models in Zed, you have several options: + +- Use Zed's hosted models, with higher rate limits. Requires [authentication](https://zed.dev/docs/accounts.html) and subscription to [Zed Pro](https://zed.dev/docs/ai/subscription.html). +- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed +- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html) + +## Advanced Config and Productivity Tweaks + +Zed exposes advanced settings for power users who want to fine-tune their environment. + +Here are a few useful tweaks: + +**Format on Save:** + +```json +"format_on_save": "on" +``` + +**Enable direnv support (useful for Python projects using direnv):** + +```json +"load_direnv": "shell_hook" +``` + +**Customize virtual environment detection:** + +```json +{ + "terminal": { + "detect_venv": { + "on": { + "directories": [".venv", "venv", ".env", "env"], + "activate_script": "default" + } + } + } +} +``` + +**Configure basedpyright type checking strictness:** + +If you find basedpyright too strict or too lenient, configure it in your project's `pyrightconfig.json`: + +```json +{ + "typeCheckingMode": "basic" +} +``` + +Options are `"off"`, `"basic"`, `"standard"` (default), `"strict"`, or `"all"`. + +## Next Steps + +Now that you're set up, here are some resources to help you get the most out of Zed: + +- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior +- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap +- [Tasks](../tasks.md) — Set up build and run commands for your projects +- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion +- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time +- [Python in Zed](../languages/python.md) — Python-specific setup and configuration diff --git a/docs/src/migrate/rustrover.md b/docs/src/migrate/rustrover.md new file mode 100644 index 0000000000000000000000000000000000000000..4d0e85cfe9b981243044290929070e87876987d3 --- /dev/null +++ b/docs/src/migrate/rustrover.md @@ -0,0 +1,501 @@ +# How to Migrate from RustRover to Zed + +This guide covers how to set up Zed if you're coming from RustRover, including keybindings, settings, and the differences you should expect as a Rust developer. + +## Install Zed + +Zed is available on macOS, Windows, and Linux. + +For macOS, you can download it from zed.dev/download, or install via Homebrew: + +```sh +brew install --cask zed +``` + +For Windows, download the installer from zed.dev/download, or install via winget: + +```sh +winget install Zed.Zed +``` + +For most Linux users, the easiest way to install Zed is through our installation script: + +```sh +curl -f https://zed.dev/install.sh | sh +``` + +After installation, you can launch Zed from your Applications folder (macOS), Start menu (Windows), or directly from the terminal using: +`zed .` +This opens the current directory in Zed. + +## Set Up the JetBrains Keymap + +If you're coming from RustRover, the fastest way to feel at home is to use the JetBrains keymap. During onboarding, you can select it as your base keymap. If you missed that step, you can change it anytime: + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Search for `Base Keymap` +3. Select `JetBrains` + +Or add this directly to your `settings.json`: + +```json +{ + "base_keymap": "JetBrains" +} +``` + +This maps familiar shortcuts like `Shift Shift` for Search Everywhere, `Cmd+O` for Go to Class, and `Cmd+Shift+A` for Find Action. + +## Set Up Editor Preferences + +You can configure settings manually in the Settings Editor. + +To edit your settings: + +1. `Cmd+,` to open the Settings Editor. +2. Run `zed: open settings` in the Command Palette. + +Settings RustRover users typically configure first: + +| Zed Setting | What it does | +| ----------------------- | ------------------------------------------------------------------------------- | +| `format_on_save` | Auto-format when saving. Set to `"on"` to enable (uses rustfmt by default). | +| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` | +| `preferred_line_length` | Column width for wrapping and rulers. Rust convention is 100. | +| `inlay_hints` | Show type hints, parameter names, and chaining hints inline. | +| `relative_line_numbers` | Useful if you're coming from IdeaVim. | + +Zed also supports per-project settings. Create a `.zed/settings.json` file in your project root to override global settings for that project, similar to how you might use `.idea` folders in RustRover. + +> **Tip:** If you're joining an existing project, check `format_on_save` before making your first commit. Otherwise you might accidentally reformat an entire file when you only meant to change one line. + +## Open or Create a Project + +After setup, press `Cmd+Shift+O` (with JetBrains keymap) to open a folder. This becomes your workspace in Zed. Unlike RustRover, there's no project configuration wizard, no toolchain selection dialog, and no Cargo project setup screen. + +To start a new project, use Cargo from the terminal: + +```sh +cargo new my_project +cd my_project +zed . +``` + +Or for a library: + +```sh +cargo new --lib my_library +``` + +You can also launch Zed from the terminal inside any existing Cargo project with: +`zed .` + +Once inside a project: + +- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like RustRover's "Recent Files") +- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like RustRover's "Search Everywhere") +- Use `Cmd+O` to search for symbols (like RustRover's "Go to Symbol") + +Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like RustRover's Project tool window). + +## Differences in Keybindings + +If you chose the JetBrains keymap during onboarding, most of your shortcuts should already feel familiar. Here's a quick reference for how Zed compares to RustRover. + +### Common Shared Keybindings + +| Action | Shortcut | +| ----------------------------- | ----------------------- | +| Search Everywhere | `Shift Shift` | +| Find Action / Command Palette | `Cmd + Shift + A` | +| Go to File | `Cmd + Shift + O` | +| Go to Symbol | `Cmd + O` | +| Recent Files | `Cmd + E` | +| Go to Definition | `Cmd + B` | +| Find Usages | `Alt + F7` | +| Rename Symbol | `Shift + F6` | +| Reformat Code | `Cmd + Alt + L` | +| Toggle Project Panel | `Cmd + 1` | +| Toggle Terminal | `Alt + F12` | +| Duplicate Line | `Cmd + D` | +| Delete Line | `Cmd + Backspace` | +| Move Line Up/Down | `Shift + Alt + Up/Down` | +| Expand/Shrink Selection | `Alt + Up/Down` | +| Comment Line | `Cmd + /` | +| Go Back / Forward | `Cmd + [` / `Cmd + ]` | +| Toggle Breakpoint | `Ctrl + F8` | + +### Different Keybindings (RustRover → Zed) + +| Action | RustRover | Zed (JetBrains keymap) | +| ---------------------- | ----------- | ------------------------ | +| File Structure | `Cmd + F12` | `Cmd + F12` (outline) | +| Navigate to Next Error | `F2` | `F2` | +| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) | +| Debug | `Ctrl + D` | `Alt + Shift + F9` | +| Stop | `Cmd + F2` | `Ctrl + F2` | +| Expand Macro | `Alt+Enter` | `Cmd + Shift + M` | + +### Unique to Zed + +| Action | Shortcut | Notes | +| ----------------- | -------------------------- | ------------------------------ | +| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications | +| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction | + +### How to Customize Keybindings + +- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`) +- Run `Zed: Open Keymap Editor` + +This opens a list of all available bindings. You can override individual shortcuts or remove conflicts. + +Zed also supports key sequences (multi-key shortcuts). + +## Differences in User Interfaces + +### No Indexing + +RustRover indexes your project when you first open it to build a model of your codebase. This process runs whenever you open a project or when dependencies change via Cargo. + +Zed skips the indexing step. You open a folder and start working right away. Since both editors rely on rust-analyzer for Rust intelligence, the analysis still happens—but in Zed it runs in the background without blocking the UI or showing modal progress dialogs. + +**How to adapt:** + +- Use `Cmd+O` to search symbols across your crate (rust-analyzer handles this) +- Jump to files by name with `Cmd+Shift+O` +- `Cmd+Shift+F` gives you fast text search across the entire project +- For linting and deeper checks, run `cargo clippy` in the terminal + +### rust-analyzer: Shared Foundation, Different Integration + +Here's what makes the RustRover-to-Zed transition unique: **both editors use rust-analyzer** for Rust language intelligence. This means the core code analysis—completions, go-to-definition, find references, type inference—is fundamentally the same. + +RustRover integrates rust-analyzer into its JetBrains platform, adding a GUI layer, additional refactorings, and its own indexing on top. Zed uses rust-analyzer more directly through the Language Server Protocol (LSP). + +What this means for you: + +- **Completions** — Same quality, powered by rust-analyzer +- **Type inference** — Identical, it's the same engine +- **Go to definition / Find usages** — Works the same way +- **Macro expansion** — Available in both (use `Cmd+Shift+M` in Zed) +- **Inlay hints** — Both support type hints, parameter hints, and chaining hints + +Where you might notice differences: + +- Some refactorings available in RustRover may not have rust-analyzer equivalents +- RustRover's GUI for configuring rust-analyzer is replaced by JSON configuration in Zed +- RustRover-specific inspections (beyond Clippy) won't exist in Zed + +**How to adapt:** + +- Use `Alt+Enter` for available code actions—rust-analyzer provides many +- Configure rust-analyzer settings in `.zed/settings.json` for project-specific needs +- Run `cargo clippy` for linting (it integrates with rust-analyzer diagnostics) + +### No Project Model + +RustRover manages projects through `.idea` folders containing XML configuration files, toolchain assignments, and run configurations. The Cargo tool window provides a visual interface for your project structure, targets, and dependencies. + +Zed keeps it simpler: a project is a folder with a `Cargo.toml`. No project wizard, no toolchain dialogs, no visual Cargo management layer. + +In practice: + +- Run configurations don't carry over. Your `.idea/` setup stays behind—define the commands you need in `tasks.json` instead. +- Toolchains are managed externally via `rustup`. +- Dependencies live in `Cargo.toml`. Edit the file directly; rust-analyzer provides completions for crate names and versions. + +**How to adapt:** + +- Create a `.zed/settings.json` in your project root for project-specific settings +- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`): + +```json +[ + { + "label": "cargo run", + "command": "cargo run" + }, + { + "label": "cargo build", + "command": "cargo build" + }, + { + "label": "cargo test", + "command": "cargo test" + }, + { + "label": "cargo clippy", + "command": "cargo clippy" + }, + { + "label": "cargo run --release", + "command": "cargo run --release" + } +] +``` + +- Use `Ctrl+Alt+R` to run tasks quickly +- Lean on your terminal (`Alt+F12`) for anything tasks don't cover + +### No Cargo Integration UI + +RustRover's Cargo tool window provides visual access to your project's targets, dependencies, and common Cargo commands. You can run builds, tests, and benchmarks with a click. + +Zed doesn't have a Cargo GUI. You work with Cargo through: + +- **Terminal** — Run any Cargo command directly +- **Tasks** — Define shortcuts for common commands +- **Gutter icons** — Run tests and binaries with clickable icons + +**How to adapt:** + +- Get comfortable with Cargo CLI commands: `cargo build`, `cargo run`, `cargo test`, `cargo clippy`, `cargo doc` +- Use tasks for commands you run frequently +- For dependency management, edit `Cargo.toml` directly (rust-analyzer provides completions for crate names and versions) + +### Tool Windows vs. Docks + +RustRover organizes auxiliary views into numbered tool windows (Project = 1, Cargo = Alt+1, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks": + +| RustRover Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) | +| --------------------- | -------------- | --------------------------- | +| Project (1) | Project Panel | `Cmd + 1` | +| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` | +| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` | +| Structure (7) | Outline Panel | `Cmd + 7` | +| Problems (6) | Diagnostics | `Cmd + 6` | +| Debug (5) | Debug Panel | `Cmd + 5` | + +Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings. + +Note that there's no dedicated Cargo tool window in Zed. Use the terminal or define tasks for your common Cargo commands. + +### Debugging + +Both RustRover and Zed offer integrated debugging for Rust, but using different backends: + +- RustRover uses its own debugger integration +- Zed uses **CodeLLDB** (the same debug adapter popular in VS Code) + +To debug Rust code in Zed: + +- Set breakpoints with `Ctrl+F8` +- Start debugging with `Alt+Shift+F9` or press `F4` and select a debug target +- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out) +- Continue execution with `F9` + +Zed can automatically detect debuggable targets in your Cargo project. Press `F4` to see available options. + +For more control, create a `.zed/debug.json` file: + +```json +[ + { + "label": "Debug Binary", + "adapter": "CodeLLDB", + "request": "launch", + "program": "${workspaceFolder}/target/debug/my_project" + }, + { + "label": "Debug Tests", + "adapter": "CodeLLDB", + "request": "launch", + "cargo": { + "args": ["test", "--no-run"], + "filter": { + "kind": "test" + } + } + }, + { + "label": "Debug with Arguments", + "adapter": "CodeLLDB", + "request": "launch", + "program": "${workspaceFolder}/target/debug/my_project", + "args": ["--config", "dev.toml"] + } +] +``` + +> **Note:** Some users have reported that RustRover's debugger can have issues with variable inspection and breakpoints in certain scenarios. CodeLLDB in Zed provides a solid alternative, though debugging Rust can be challenging in any editor due to optimizations and macro-generated code. + +### Running Tests + +RustRover has a dedicated test runner with a visual interface showing pass/fail status for each test. Zed provides test running through: + +- **Gutter icons** — Click the play button next to `#[test]` functions or test modules +- **Tasks** — Define `cargo test` commands in `tasks.json` +- **Terminal** — Run `cargo test` directly + +The test output appears in the terminal panel. For more detailed output, use: + +- `cargo test -- --nocapture` to see println! output +- `cargo test -- --test-threads=1` for sequential test execution +- `cargo test specific_test_name` to run a single test + +### Extensions vs. Plugins + +RustRover has a plugin ecosystem, though it's more limited than other JetBrains IDEs since Rust support is built-in. + +Zed's extension ecosystem is smaller and more focused: + +- Language support and syntax highlighting +- Themes +- Slash commands for AI +- Context servers + +Several features that might require plugins in other editors are built into Zed: + +- Real-time collaboration with voice chat +- AI coding assistance +- Built-in terminal +- Task runner +- rust-analyzer integration +- rustfmt formatting + +### What's Not in Zed + +To set expectations clearly, here's what RustRover offers that Zed doesn't have: + +- **Cargo.toml GUI editor** — Edit the file directly (rust-analyzer helps with completions) +- **Visual dependency management** — Use `cargo add`, `cargo remove`, or edit `Cargo.toml` +- **Profiler integration** — Use `cargo flamegraph`, `perf`, or external profiling tools +- **Database tools** — Use DataGrip, DBeaver, or TablePlus +- **HTTP Client** — Use tools like `curl`, `httpie`, or Postman +- **Coverage visualization** — Use `cargo tarpaulin` or `cargo llvm-cov` externally + +## A Note on Licensing and Telemetry + +If you're moving from RustRover partly due to licensing concerns or telemetry policies, you should know: + +- **Zed is open source** (MIT licensed for the editor, AGPL for collaboration services) +- **Telemetry is optional** and can be disabled during onboarding or in settings +- **No license tiers**: All features are available to everyone + +## Collaboration in Zed vs. RustRover + +RustRover offers Code With Me as a separate feature for collaboration. Zed has collaboration built into the core experience. + +- Open the Collab Panel in the left dock +- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join +- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly + +Once connected, you'll see each other's cursors, selections, and edits in real time. Voice chat is included. There's no need for separate tools or third-party logins. + +## Using AI in Zed + +If you're used to AI assistants in RustRover (like JetBrains AI Assistant), Zed offers similar capabilities with more flexibility. + +### Configuring GitHub Copilot + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Navigate to **AI → Edit Predictions** +3. Click **Configure** next to "Configure Providers" +4. Under **GitHub Copilot**, click **Sign in to GitHub** + +Once signed in, just start typing. Zed will offer suggestions inline for you to accept. + +### Additional AI Options + +To use other AI models in Zed, you have several options: + +- Use Zed's hosted models, with higher rate limits. Requires [authentication](https://zed.dev/docs/accounts.html) and subscription to [Zed Pro](https://zed.dev/docs/ai/subscription.html). +- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed +- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html) + +## Advanced Config and Productivity Tweaks + +Zed exposes advanced settings for power users who want to fine-tune their environment. + +Here are a few useful tweaks for Rust developers: + +**Format on Save (uses rustfmt by default):** + +```json +"format_on_save": "on" +``` + +**Configure inlay hints for Rust:** + +```json +{ + "inlay_hints": { + "enabled": true, + "show_type_hints": true, + "show_parameter_hints": true, + "show_other_hints": true + } +} +``` + +**Configure rust-analyzer settings:** + +```json +{ + "lsp": { + "rust-analyzer": { + "initialization_options": { + "checkOnSave": { + "command": "clippy" + }, + "cargo": { + "allFeatures": true + }, + "procMacro": { + "enable": true + } + } + } + } +} +``` + +**Use a separate target directory for rust-analyzer (faster builds):** + +```json +{ + "lsp": { + "rust-analyzer": { + "initialization_options": { + "rust-analyzer.cargo.targetDir": true + } + } + } +} +``` + +This tells rust-analyzer to use `target/rust-analyzer` instead of `target`, so IDE analysis doesn't conflict with your manual `cargo build` commands. + +**Enable direnv support (useful for Rust projects using direnv):** + +```json +"load_direnv": "shell_hook" +``` + +**Configure linked projects for workspaces:** + +If you work with multiple Cargo projects that aren't in a workspace, you can tell rust-analyzer about them: + +```json +{ + "lsp": { + "rust-analyzer": { + "initialization_options": { + "linkedProjects": ["./project-a/Cargo.toml", "./project-b/Cargo.toml"] + } + } + } +} +``` + +## Next Steps + +Now that you're set up, here are some resources to help you get the most out of Zed: + +- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior +- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap +- [Tasks](../tasks.md) — Set up build and run commands for your projects +- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion +- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time +- [Rust in Zed](../languages/rust.md) — Rust-specific setup and configuration diff --git a/docs/src/migrate/webstorm.md b/docs/src/migrate/webstorm.md new file mode 100644 index 0000000000000000000000000000000000000000..78b80b355b47370a821f08fd6108d947182f0acf --- /dev/null +++ b/docs/src/migrate/webstorm.md @@ -0,0 +1,455 @@ +# How to Migrate from WebStorm to Zed + +This guide covers how to set up Zed if you're coming from WebStorm, including keybindings, settings, and the differences you should expect as a JavaScript/TypeScript developer. + +## Install Zed + +Zed is available on macOS, Windows, and Linux. + +For macOS, you can download it from zed.dev/download, or install via Homebrew: + +```sh +brew install --cask zed +``` + +For Windows, download the installer from zed.dev/download, or install via winget: + +```sh +winget install Zed.Zed +``` + +For most Linux users, the easiest way to install Zed is through our installation script: + +```sh +curl -f https://zed.dev/install.sh | sh +``` + +After installation, you can launch Zed from your Applications folder (macOS), Start menu (Windows), or directly from the terminal using: +`zed .` +This opens the current directory in Zed. + +## Set Up the JetBrains Keymap + +If you're coming from WebStorm, the fastest way to feel at home is to use the JetBrains keymap. During onboarding, you can select it as your base keymap. If you missed that step, you can change it anytime: + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Search for `Base Keymap` +3. Select `JetBrains` + +Or add this directly to your `settings.json`: + +```json +{ + "base_keymap": "JetBrains" +} +``` + +This maps familiar shortcuts like `Shift Shift` for Search Everywhere, `Cmd+O` for Go to Class, and `Cmd+Shift+A` for Find Action. + +## Set Up Editor Preferences + +You can configure settings manually in the Settings Editor. + +To edit your settings: + +1. `Cmd+,` to open the Settings Editor. +2. Run `zed: open settings` in the Command Palette. + +Settings WebStorm users typically configure first: + +| Zed Setting | What it does | +| ----------------------- | ------------------------------------------------------------------------------- | +| `format_on_save` | Auto-format when saving. Set to `"on"` to enable. | +| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` | +| `preferred_line_length` | Column width for wrapping and rulers. Default is 80. | +| `inlay_hints` | Show parameter names and type hints inline, like WebStorm's hints. | +| `relative_line_numbers` | Useful if you're coming from IdeaVim. | + +Zed also supports per-project settings. Create a `.zed/settings.json` file in your project root to override global settings for that project, similar to how you might use `.idea` folders in WebStorm. + +> **Tip:** If you're joining an existing project, check `format_on_save` before making your first commit. Otherwise you might accidentally reformat an entire file when you only meant to change one line. + +## Open or Create a Project + +After setup, press `Cmd+Shift+O` (with JetBrains keymap) to open a folder. This becomes your workspace in Zed. Unlike WebStorm, there's no project configuration wizard, no framework selection dialog, and no project structure setup required. + +To start a new project, create a directory using your terminal or file manager, then open it in Zed. The editor will treat that folder as the root of your project. For new projects, you'd typically run `npm init`, `pnpm create`, or your framework's CLI tool first, then open the resulting folder in Zed. + +You can also launch Zed from the terminal inside any folder with: +`zed .` + +Once inside a project: + +- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like WebStorm's "Recent Files") +- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like WebStorm's "Search Everywhere") +- Use `Cmd+O` to search for symbols (like WebStorm's "Go to Symbol") + +Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like WebStorm's Project tool window). + +## Differences in Keybindings + +If you chose the JetBrains keymap during onboarding, most of your shortcuts should already feel familiar. Here's a quick reference for how Zed compares to WebStorm. + +### Common Shared Keybindings + +| Action | Shortcut | +| ----------------------------- | ----------------------- | +| Search Everywhere | `Shift Shift` | +| Find Action / Command Palette | `Cmd + Shift + A` | +| Go to File | `Cmd + Shift + O` | +| Go to Symbol | `Cmd + O` | +| Recent Files | `Cmd + E` | +| Go to Definition | `Cmd + B` | +| Find Usages | `Alt + F7` | +| Rename Symbol | `Shift + F6` | +| Reformat Code | `Cmd + Alt + L` | +| Toggle Project Panel | `Cmd + 1` | +| Toggle Terminal | `Alt + F12` | +| Duplicate Line | `Cmd + D` | +| Delete Line | `Cmd + Backspace` | +| Move Line Up/Down | `Shift + Alt + Up/Down` | +| Expand/Shrink Selection | `Alt + Up/Down` | +| Comment Line | `Cmd + /` | +| Go Back / Forward | `Cmd + [` / `Cmd + ]` | +| Toggle Breakpoint | `Ctrl + F8` | + +### Different Keybindings (WebStorm → Zed) + +| Action | WebStorm | Zed (JetBrains keymap) | +| ---------------------- | ----------- | ------------------------ | +| File Structure | `Cmd + F12` | `Cmd + F12` (outline) | +| Navigate to Next Error | `F2` | `F2` | +| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) | +| Debug | `Ctrl + D` | `Alt + Shift + F9` | +| Stop | `Cmd + F2` | `Ctrl + F2` | + +### Unique to Zed + +| Action | Shortcut | Notes | +| ----------------- | -------------------------- | ------------------------------ | +| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications | +| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction | + +### How to Customize Keybindings + +- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`) +- Run `Zed: Open Keymap Editor` + +This opens a list of all available bindings. You can override individual shortcuts or remove conflicts. + +Zed also supports key sequences (multi-key shortcuts). + +## Differences in User Interfaces + +### No Indexing + +If you've used WebStorm on large projects, you know the wait. Opening a project with many dependencies can mean watching "Indexing..." for anywhere from 30 seconds to several minutes. WebStorm indexes your entire codebase and `node_modules` to power its code intelligence, and re-indexes when dependencies change. + +Zed doesn't index. You open a folder and start coding immediately—no progress bars, no "Indexing paused" banners. File search and navigation stay fast regardless of project size or how many `node_modules` dependencies you have. + +WebStorm's index enables features like finding all usages across your entire codebase, tracking import hierarchies, and flagging unused exports project-wide. Zed relies on language servers for this analysis, which may not cover as much ground. + +**How to adapt:** + +- Search symbols across the project with `Cmd+O` (powered by the TypeScript language server) +- Find files by name with `Cmd+Shift+O` +- Use `Cmd+Shift+F` for text search—it stays fast even in large monorepos +- Run `tsc --noEmit` or `eslint .` from the terminal when you need deeper project-wide analysis + +### LSP vs. Native Language Intelligence + +WebStorm has its own JavaScript and TypeScript analysis engine built by JetBrains. This engine understands your code deeply: it resolves types, tracks data flow, knows about framework-specific patterns, and offers specialized refactorings. + +Zed uses the Language Server Protocol (LSP) for code intelligence. For JavaScript and TypeScript, Zed supports: + +- **vtsls** (default) — Fast TypeScript language server with excellent performance +- **typescript-language-server** — The standard TypeScript LSP implementation +- **ESLint** — Linting integration +- **Prettier** — Code formatting (built-in) + +The TypeScript LSP experience is mature and robust. You get accurate completions, type checking, go-to-definition, and find-references. The experience is comparable to VS Code, which uses the same underlying TypeScript services. + +Where you might notice differences: + +- Framework-specific intelligence (Angular templates, Vue SFCs) may be less integrated +- Some complex refactorings (extract component with proper imports) may be less sophisticated +- Auto-import suggestions depend on what the language server knows about your project + +**How to adapt:** + +- Use `Alt+Enter` for available code actions—the list will vary by language server +- Ensure your `tsconfig.json` is properly configured so the language server understands your project structure +- Use Prettier for consistent formatting (it's enabled by default for JS/TS) +- For code inspection similar to WebStorm's "Inspect Code," check the Diagnostics panel (`Cmd+6`)—ESLint and TypeScript together catch many of the same issues + +### No Project Model + +WebStorm manages projects through `.idea` folders containing XML configuration files, framework detection, and run configurations. This model lets WebStorm remember your project settings, manage npm scripts through the UI, and persist run/debug setups. + +Zed takes a different approach: a project is just a folder. There's no setup wizard, no framework detection dialog, no project structure to configure. + +What this means in practice: + +- Run configurations aren't a thing. Define reusable commands in `tasks.json` instead. Note that your existing `.idea/` configurations won't carry over—you'll set up the ones you need fresh. +- npm scripts live in the terminal. Run `npm run dev`, `pnpm build`, or `yarn test` directly—there's no dedicated npm panel. +- No framework detection. Zed treats React, Angular, Vue, and vanilla JS/TS the same way. + +**How to adapt:** + +- Create a `.zed/settings.json` in your project root for project-specific settings +- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`): + +```json +[ + { + "label": "dev", + "command": "npm run dev" + }, + { + "label": "build", + "command": "npm run build" + }, + { + "label": "test", + "command": "npm test" + }, + { + "label": "test current file", + "command": "npm test -- $ZED_FILE" + } +] +``` + +- Use `Ctrl+Alt+R` to run tasks quickly +- Lean on your terminal (`Alt+F12`) for anything tasks don't cover + +### No Framework Integration + +WebStorm's value for web development comes largely from its framework integration. React components get special treatment. Angular has dedicated tooling. Vue single-file components are fully understood. The npm tool window shows all your scripts. + +Zed has none of this built-in. The TypeScript language server sees your code as TypeScript—it doesn't understand that a function is a React component or that a file is an Angular service. + +**How to adapt:** + +- Use grep and file search liberally. `Cmd+Shift+F` with a regex can find component definitions, route configurations, or API endpoints. +- Rely on your language server's "find references" (`Alt+F7`) for navigation—it works, just without framework context +- Consider using framework-specific CLI tools (`ng`, `next`, `vite`) from Zed's terminal +- For React, JSX/TSX syntax and TypeScript types still provide good intelligence + +> **Tip:** For projects with complex configurations, keep your framework's documentation handy. Zed's speed comes with less hand-holding for framework-specific features. + +### Tool Windows vs. Docks + +WebStorm organizes auxiliary views into numbered tool windows (Project = 1, npm = Alt+F11, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks": + +| WebStorm Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) | +| -------------------- | -------------- | --------------------------- | +| Project (1) | Project Panel | `Cmd + 1` | +| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` | +| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` | +| Structure (7) | Outline Panel | `Cmd + 7` | +| Problems (6) | Diagnostics | `Cmd + 6` | +| Debug (5) | Debug Panel | `Cmd + 5` | + +Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings. + +Note that there's no dedicated npm tool window in Zed. Use the terminal or define tasks for your common npm scripts. + +### Debugging + +Both WebStorm and Zed offer integrated debugging for JavaScript and TypeScript: + +- Zed uses `vscode-js-debug` (the same debug adapter that VS Code uses) +- Set breakpoints with `Ctrl+F8` +- Start debugging with `Alt+Shift+F9` or press `F4` and select a debug target +- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out) +- Continue execution with `F9` + +Zed can debug: + +- Node.js applications and scripts +- Chrome/browser JavaScript +- Jest, Mocha, Vitest, and other test frameworks +- Next.js (both server and client-side) + +For more control, create a `.zed/debug.json` file: + +```json +[ + { + "label": "Debug Current File", + "adapter": "JavaScript", + "program": "$ZED_FILE", + "request": "launch" + }, + { + "label": "Debug Node Server", + "adapter": "JavaScript", + "request": "launch", + "program": "${workspaceFolder}/src/server.js" + }, + { + "label": "Attach to Chrome", + "adapter": "JavaScript", + "request": "attach", + "port": 9222 + } +] +``` + +Zed also recognizes `.vscode/launch.json` configurations, so existing VS Code debug setups often work out of the box. + +### Running Tests + +WebStorm has a dedicated test runner with a visual interface showing pass/fail status for each test. Zed provides test running through: + +- **Gutter icons** — Click the play button next to test functions or describe blocks +- **Tasks** — Define test commands in `tasks.json` +- **Terminal** — Run `npm test`, `jest`, `vitest`, etc. directly + +Zed supports auto-detection for common test frameworks: + +- Jest +- Mocha +- Vitest +- Jasmine +- Bun test +- Node.js test runner + +The test output appears in the terminal panel. For Jest, use `--verbose` for detailed output or `--watch` for continuous testing during development. + +### Extensions vs. Plugins + +WebStorm has a plugin ecosystem covering additional language support, themes, and tool integrations. + +Zed's extension ecosystem is smaller and more focused: + +- Language support and syntax highlighting +- Themes +- Slash commands for AI +- Context servers + +Several features that require plugins in WebStorm are built into Zed: + +- Real-time collaboration with voice chat +- AI coding assistance +- Built-in terminal +- Task runner +- LSP-based code intelligence +- Prettier formatting +- ESLint integration + +### What's Not in Zed + +To set expectations clearly, here's what WebStorm offers that Zed doesn't have: + +- **npm tool window** — Use the terminal or tasks instead +- **HTTP Client** — Use tools like Postman, Insomnia, or curl +- **Database tools** — Use DataGrip, DBeaver, or TablePlus +- **Framework-specific tooling** (Angular schematics, React refactorings) — Use CLI tools +- **Visual package.json editor** — Edit the file directly +- **Built-in REST client** — Use external tools or extensions +- **Profiler integration** — Use Chrome DevTools or Node.js profiling tools + +## Collaboration in Zed vs. WebStorm + +WebStorm offers Code With Me as a separate feature for collaboration. Zed has collaboration built into the core experience. + +- Open the Collab Panel in the left dock +- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join +- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly + +Once connected, you'll see each other's cursors, selections, and edits in real time. Voice chat is included. There's no need for separate tools or third-party logins. + +## Using AI in Zed + +If you're used to AI assistants in WebStorm (like GitHub Copilot, JetBrains AI Assistant, or Junie), Zed offers similar capabilities with more flexibility. + +### Configuring GitHub Copilot + +1. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows) +2. Navigate to **AI → Edit Predictions** +3. Click **Configure** next to "Configure Providers" +4. Under **GitHub Copilot**, click **Sign in to GitHub** + +Once signed in, just start typing. Zed will offer suggestions inline for you to accept. + +### Additional AI Options + +To use other AI models in Zed, you have several options: + +- Use Zed's hosted models, with higher rate limits. Requires [authentication](https://zed.dev/docs/accounts.html) and subscription to [Zed Pro](https://zed.dev/docs/ai/subscription.html). +- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed +- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html) + +## Advanced Config and Productivity Tweaks + +Zed exposes advanced settings for power users who want to fine-tune their environment. + +Here are a few useful tweaks for JavaScript/TypeScript developers: + +**Format on Save:** + +```json +"format_on_save": "on" +``` + +**Configure Prettier as the default formatter:** + +```json +{ + "formatter": { + "external": { + "command": "prettier", + "arguments": ["--stdin-filepath", "{buffer_path}"] + } + } +} +``` + +**Enable ESLint code actions:** + +```json +{ + "lsp": { + "eslint": { + "settings": { + "codeActionOnSave": { + "rules": ["import/order"] + } + } + } + } +} +``` + +**Configure TypeScript strict mode hints:** + +In your `tsconfig.json`, enable strict mode for better type checking: + +```json +{ + "compilerOptions": { + "strict": true, + "noUncheckedIndexedAccess": true + } +} +``` + +**Enable direnv support (useful for projects using direnv for environment variables):** + +```json +"load_direnv": "shell_hook" +``` + +## Next Steps + +Now that you're set up, here are some resources to help you get the most out of Zed: + +- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior +- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap +- [Tasks](../tasks.md) — Set up build and run commands for your projects +- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion +- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time +- [JavaScript in Zed](../languages/javascript.md) — JavaScript-specific setup and configuration +- [TypeScript in Zed](../languages/typescript.md) — TypeScript-specific setup and configuration From f084e20c56afec3c823a743e3278eade9515f2dd Mon Sep 17 00:00:00 2001 From: Xipeng Jin <56369076+xipeng-jin@users.noreply.github.com> Date: Wed, 17 Dec 2025 11:51:16 -0500 Subject: [PATCH 132/266] Fix stale pending keybinding indicators on focus change (#44678) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #ISSUE Problem: - The status bar’s pending keystroke indicator (shown next to --NORMAL-- in Vim mode) didn’t clear when focus moved to another context, e.g. hitting g in the editor then clicking the Git panel. The keymap state correctly canceled the prefix, but observers that render the indicator never received a “pending input changed” notification, so the UI kept showing stale prefixes until a new keystroke occurred. Fix: - The change introduces a `pending_input_changed_queued` flag and a new helper `notify_pending_input_if_needed` which will flushes the queued notification as soon as we have an App context. The `pending_input_changed` now resets the flag after notifying subscribers. Before: https://github.com/user-attachments/assets/7bec4c34-acbf-42bd-b0d1-88df5ff099aa After: https://github.com/user-attachments/assets/2264dc93-3405-4d63-ad8f-50ada6733ae7 Release Notes: - Fixed: pending keybinding prefixes on the status bar now clear immediately when focus moves to another panel or UI context. --------- Co-authored-by: Nathan Sobo Co-authored-by: Conrad Irwin --- crates/agent_ui/src/acp/message_editor.rs | 6 +- crates/agent_ui/src/acp/thread_view.rs | 14 +- .../add_llm_provider_modal.rs | 10 +- .../configure_context_server_modal.rs | 2 +- .../manage_profiles_modal.rs | 16 +- crates/agent_ui/src/agent_diff.rs | 8 +- crates/agent_ui/src/agent_panel.rs | 16 +- crates/agent_ui/src/inline_assistant.rs | 4 +- crates/agent_ui/src/inline_prompt_editor.rs | 2 +- .../agent_ui/src/terminal_inline_assistant.rs | 6 +- crates/agent_ui/src/text_thread_editor.rs | 2 +- .../agent_ui/src/ui/acp_onboarding_modal.rs | 4 +- .../src/ui/claude_code_onboarding_modal.rs | 4 +- crates/agent_ui/src/ui/onboarding_modal.rs | 4 +- crates/collab_ui/src/collab_panel.rs | 16 +- .../src/collab_panel/channel_modal.rs | 2 +- crates/command_palette/src/command_palette.rs | 6 +- .../src/copilot_edit_prediction_delegate.rs | 4 +- crates/copilot/src/sign_in.rs | 4 +- crates/debugger_ui/src/debugger_panel.rs | 4 +- crates/debugger_ui/src/new_process_modal.rs | 22 +- crates/debugger_ui/src/onboarding_modal.rs | 4 +- crates/debugger_ui/src/session/running.rs | 2 +- .../src/session/running/breakpoint_list.rs | 10 +- .../src/session/running/console.rs | 2 +- .../src/session/running/memory_view.rs | 2 +- .../src/session/running/variable_list.rs | 4 +- crates/diagnostics/src/buffer_diagnostics.rs | 6 +- crates/diagnostics/src/diagnostic_renderer.rs | 2 +- crates/diagnostics/src/diagnostics.rs | 6 +- .../edit_prediction/src/onboarding_modal.rs | 4 +- .../src/rate_prediction_modal.rs | 2 +- crates/editor/benches/editor_render.rs | 6 +- crates/editor/src/editor.rs | 20 +- crates/editor/src/editor_tests.rs | 2 +- crates/editor/src/hover_links.rs | 2 +- crates/editor/src/mouse_context_menu.rs | 10 +- .../src/test/editor_lsp_test_context.rs | 2 +- crates/editor/src/test/editor_test_context.rs | 4 +- crates/file_finder/src/file_finder.rs | 2 +- crates/git_ui/src/branch_picker.rs | 6 +- crates/git_ui/src/commit_modal.rs | 6 +- crates/git_ui/src/file_history_view.rs | 4 +- crates/git_ui/src/git_panel.rs | 18 +- crates/git_ui/src/git_ui.rs | 2 +- crates/git_ui/src/onboarding.rs | 4 +- crates/git_ui/src/project_diff.rs | 10 +- crates/go_to_line/src/go_to_line.rs | 2 +- crates/gpui/examples/focus_visible.rs | 10 +- crates/gpui/examples/input.rs | 2 +- crates/gpui/examples/on_window_close_quit.rs | 4 +- crates/gpui/examples/tab_stop.rs | 10 +- crates/gpui/src/app.rs | 7 +- crates/gpui/src/app/async_context.rs | 2 +- crates/gpui/src/app/context.rs | 4 +- crates/gpui/src/app/test_context.rs | 2 +- crates/gpui/src/elements/div.rs | 6 +- crates/gpui/src/elements/uniform_list.rs | 2 +- crates/gpui/src/interactive.rs | 4 +- crates/gpui/src/key_dispatch.rs | 218 +++++++++++++++++- crates/gpui/src/window.rs | 28 ++- crates/gpui/src/window/prompts.rs | 6 +- .../gpui_macros/src/derive_visual_context.rs | 2 +- crates/keymap_editor/src/keymap_editor.rs | 28 +-- .../src/ui_components/keystroke_input.rs | 4 +- .../language_models/src/provider/bedrock.rs | 8 +- crates/language_tools/src/lsp_log_view.rs | 14 +- crates/language_tools/src/syntax_tree_view.rs | 2 +- crates/markdown/src/markdown.rs | 2 +- .../src/markdown_preview_view.rs | 4 +- crates/onboarding/src/onboarding.rs | 6 +- crates/outline/src/outline.rs | 2 +- crates/outline_panel/src/outline_panel.rs | 12 +- crates/picker/src/picker.rs | 2 +- crates/project_panel/src/project_panel.rs | 18 +- .../recent_projects/src/remote_connections.rs | 2 +- crates/recent_projects/src/remote_servers.rs | 24 +- crates/rules_library/src/rules_library.rs | 14 +- crates/search/src/buffer_search.rs | 26 +-- crates/search/src/project_search.rs | 16 +- crates/search/src/search.rs | 2 +- crates/search/src/search_bar.rs | 2 +- crates/settings_ui/src/settings_ui.rs | 53 ++--- crates/terminal_view/src/terminal_element.rs | 4 +- crates/terminal_view/src/terminal_panel.rs | 20 +- crates/terminal_view/src/terminal_view.rs | 2 +- crates/title_bar/src/title_bar.rs | 2 +- .../src/toolchain_selector.rs | 10 +- crates/ui/src/components/context_menu.rs | 4 +- crates/ui/src/components/navigable.rs | 4 +- crates/ui/src/components/popover_menu.rs | 6 +- crates/ui/src/components/right_click_menu.rs | 6 +- crates/ui_input/src/number_field.rs | 4 +- crates/workspace/src/dock.rs | 8 +- crates/workspace/src/item.rs | 2 +- crates/workspace/src/modal_layer.rs | 4 +- crates/workspace/src/pane.rs | 10 +- crates/workspace/src/welcome.rs | 4 +- crates/workspace/src/workspace.rs | 40 ++-- crates/zed/src/main.rs | 2 +- crates/zed/src/zed.rs | 2 +- crates/zed/src/zed/component_preview.rs | 4 +- 102 files changed, 606 insertions(+), 380 deletions(-) diff --git a/crates/agent_ui/src/acp/message_editor.rs b/crates/agent_ui/src/acp/message_editor.rs index 5e9c55cc56868ac2e7db65043d13eb46efcd89a6..308230a24c6d2ba7fb0c3995b886e9e924d8e1b7 100644 --- a/crates/agent_ui/src/acp/message_editor.rs +++ b/crates/agent_ui/src/acp/message_editor.rs @@ -1365,7 +1365,7 @@ mod tests { cx, ); }); - message_editor.read(cx).focus_handle(cx).focus(window); + message_editor.read(cx).focus_handle(cx).focus(window, cx); message_editor.read(cx).editor().clone() }); @@ -1587,7 +1587,7 @@ mod tests { cx, ); }); - message_editor.read(cx).focus_handle(cx).focus(window); + message_editor.read(cx).focus_handle(cx).focus(window, cx); let editor = message_editor.read(cx).editor().clone(); (message_editor, editor) }); @@ -2315,7 +2315,7 @@ mod tests { cx, ); }); - message_editor.read(cx).focus_handle(cx).focus(window); + message_editor.read(cx).focus_handle(cx).focus(window, cx); let editor = message_editor.read(cx).editor().clone(); (message_editor, editor) }); diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 63f0054ab7e1d25145974c3862ec7361007bace6..9e9af499727ad8478fa5fc1d46dc3b3bf8e20a71 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -253,7 +253,7 @@ impl ThreadFeedbackState { editor }); - editor.read(cx).focus_handle(cx).focus(window); + editor.read(cx).focus_handle(cx).focus(window, cx); editor } } @@ -682,7 +682,7 @@ impl AcpThreadView { }) }); - this.message_editor.focus_handle(cx).focus(window); + this.message_editor.focus_handle(cx).focus(window, cx); cx.notify(); } @@ -784,7 +784,7 @@ impl AcpThreadView { _subscription: subscription, }; if this.message_editor.focus_handle(cx).is_focused(window) { - this.focus_handle.focus(window) + this.focus_handle.focus(window, cx) } cx.notify(); }) @@ -804,7 +804,7 @@ impl AcpThreadView { ThreadState::LoadError(LoadError::Other(format!("{:#}", err).into())) } if self.message_editor.focus_handle(cx).is_focused(window) { - self.focus_handle.focus(window) + self.focus_handle.focus(window, cx) } cx.notify(); } @@ -1270,7 +1270,7 @@ impl AcpThreadView { } }) }; - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); cx.notify(); } @@ -1322,7 +1322,7 @@ impl AcpThreadView { .await?; this.update_in(cx, |this, window, cx| { this.send_impl(message_editor, window, cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); })?; anyhow::Ok(()) }) @@ -1465,7 +1465,7 @@ impl AcpThreadView { self.thread_retry_status.take(); self.thread_state = ThreadState::LoadError(error.clone()); if self.message_editor.focus_handle(cx).is_focused(window) { - self.focus_handle.focus(window) + self.focus_handle.focus(window, cx) } } AcpThreadEvent::TitleUpdated => { 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 index 02269511bb9a4d9b95fe27b66e3ca0a9e5c498c5..e443df33b4ddcaeba32b9b2623c0fdca85fac51c 100644 --- a/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs +++ b/crates/agent_ui/src/agent_configuration/add_llm_provider_modal.rs @@ -446,17 +446,17 @@ impl AddLlmProviderModal { }) } - fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, _: &mut Context) { - window.focus_next(); + fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context) { + window.focus_next(cx); } fn on_tab_prev( &mut self, _: &menu::SelectPrevious, window: &mut Window, - _: &mut Context, + cx: &mut Context, ) { - window.focus_prev(); + window.focus_prev(cx); } } @@ -493,7 +493,7 @@ impl Render for AddLlmProviderModal { .on_action(cx.listener(Self::on_tab)) .on_action(cx.listener(Self::on_tab_prev)) .capture_any_mouse_down(cx.listener(|this, _, window, cx| { - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); })) .child( Modal::new("configure-context-server", None) 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 a0f0be886a1bf5e1485a2d36440b9f91648ef0c6..b30f1494f0d4dcbf3ef63cc7f549d16374f4899b 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 @@ -831,7 +831,7 @@ impl Render for ConfigureContextServerModal { }), ) .capture_any_mouse_down(cx.listener(|this, _, window, cx| { - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); })) .child( Modal::new("configure-context-server", None) diff --git a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs index 127852fd50e81cf56ae37a7af430f88ae2accf99..c7f395ebbd813cfd7c28f33a7e69ec32f6d90fca 100644 --- a/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs +++ b/crates/agent_ui/src/agent_configuration/manage_profiles_modal.rs @@ -156,7 +156,7 @@ impl ManageProfilesModal { cx.observe_global_in::(window, |this, window, cx| { if matches!(this.mode, Mode::ChooseProfile(_)) { this.mode = Mode::choose_profile(window, cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); cx.notify(); } }); @@ -173,7 +173,7 @@ impl ManageProfilesModal { fn choose_profile(&mut self, window: &mut Window, cx: &mut Context) { self.mode = Mode::choose_profile(window, cx); - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } fn new_profile( @@ -191,7 +191,7 @@ impl ManageProfilesModal { name_editor, base_profile_id, }); - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } pub fn view_profile( @@ -209,7 +209,7 @@ impl ManageProfilesModal { delete_profile: NavigableEntry::focusable(cx), cancel_item: NavigableEntry::focusable(cx), }); - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } fn configure_default_model( @@ -300,7 +300,7 @@ impl ManageProfilesModal { model_picker, _subscription: dismiss_subscription, }; - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } fn configure_mcp_tools( @@ -336,7 +336,7 @@ impl ManageProfilesModal { tool_picker, _subscription: dismiss_subscription, }; - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } fn configure_builtin_tools( @@ -377,7 +377,7 @@ impl ManageProfilesModal { tool_picker, _subscription: dismiss_subscription, }; - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } fn confirm(&mut self, window: &mut Window, cx: &mut Context) { @@ -951,7 +951,7 @@ impl Render for ManageProfilesModal { .on_action(cx.listener(|this, _: &menu::Cancel, window, cx| this.cancel(window, cx))) .on_action(cx.listener(|this, _: &menu::Confirm, window, cx| this.confirm(window, cx))) .capture_any_mouse_down(cx.listener(|this, _, window, cx| { - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); })) .on_mouse_down_out(cx.listener(|_this, _, _, cx| cx.emit(DismissEvent))) .child(match &self.mode { diff --git a/crates/agent_ui/src/agent_diff.rs b/crates/agent_ui/src/agent_diff.rs index 06fce64819d3ce66b9e39f2b83cbebefb6ba9698..91d345b7ebb9dae5225626d7a054d0de1882dfe0 100644 --- a/crates/agent_ui/src/agent_diff.rs +++ b/crates/agent_ui/src/agent_diff.rs @@ -212,10 +212,10 @@ impl AgentDiffPane { .focus_handle(cx) .contains_focused(window, cx) { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } else if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() { self.editor.update(cx, |editor, cx| { - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); }); } } @@ -874,12 +874,12 @@ impl AgentDiffToolbar { match active_item { AgentDiffToolbarItem::Pane(agent_diff) => { if let Some(agent_diff) = agent_diff.upgrade() { - agent_diff.focus_handle(cx).focus(window); + agent_diff.focus_handle(cx).focus(window, cx); } } AgentDiffToolbarItem::Editor { editor, .. } => { if let Some(editor) = editor.upgrade() { - editor.read(cx).focus_handle(cx).focus(window); + editor.read(cx).focus_handle(cx).focus(window, cx); } } } diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 071283e7224f08efd0f8df2cdf7a1aca63419081..e41c8b7f5482b3709db2492f5fd81b6f3e7d6eb0 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -880,7 +880,7 @@ impl AgentPanel { window, cx, ); - text_thread_editor.focus_handle(cx).focus(window); + text_thread_editor.focus_handle(cx).focus(window, cx); } fn external_thread( @@ -1034,7 +1034,7 @@ impl AgentPanel { if let Some(thread_view) = self.active_thread_view() { thread_view.update(cx, |view, cx| { view.expand_message_editor(&ExpandMessageEditor, window, cx); - view.focus_handle(cx).focus(window); + view.focus_handle(cx).focus(window, cx); }); } } @@ -1115,12 +1115,12 @@ impl AgentPanel { match &self.active_view { ActiveView::ExternalAgentThread { thread_view } => { - thread_view.focus_handle(cx).focus(window); + thread_view.focus_handle(cx).focus(window, cx); } ActiveView::TextThread { text_thread_editor, .. } => { - text_thread_editor.focus_handle(cx).focus(window); + text_thread_editor.focus_handle(cx).focus(window, cx); } ActiveView::History | ActiveView::Configuration => {} } @@ -1268,7 +1268,7 @@ impl AgentPanel { Self::handle_agent_configuration_event, )); - configuration.focus_handle(cx).focus(window); + configuration.focus_handle(cx).focus(window, cx); } } @@ -1404,7 +1404,7 @@ impl AgentPanel { } if focus { - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } } @@ -1761,7 +1761,7 @@ impl AgentPanel { let thread_view = thread_view.downgrade(); move |_: &menu::Confirm, window, cx| { if let Some(thread_view) = thread_view.upgrade() { - thread_view.focus_handle(cx).focus(window); + thread_view.focus_handle(cx).focus(window, cx); } } }) @@ -1769,7 +1769,7 @@ impl AgentPanel { let thread_view = thread_view.downgrade(); move |_: &editor::actions::Cancel, window, cx| { if let Some(thread_view) = thread_view.upgrade() { - thread_view.focus_handle(cx).focus(window); + thread_view.focus_handle(cx).focus(window, cx); } } }) diff --git a/crates/agent_ui/src/inline_assistant.rs b/crates/agent_ui/src/inline_assistant.rs index 6e3ab7a162bc69a5b0ec081b060b4a2ba08b09aa..052d8598a76d1044c6d97b5378041b5cd12e23b3 100644 --- a/crates/agent_ui/src/inline_assistant.rs +++ b/crates/agent_ui/src/inline_assistant.rs @@ -1197,7 +1197,7 @@ impl InlineAssistant { assist .editor - .update(cx, |editor, cx| window.focus(&editor.focus_handle(cx))) + .update(cx, |editor, cx| window.focus(&editor.focus_handle(cx), cx)) .ok(); } @@ -1209,7 +1209,7 @@ impl InlineAssistant { if let Some(decorations) = assist.decorations.as_ref() { decorations.prompt_editor.update(cx, |prompt_editor, cx| { prompt_editor.editor.update(cx, |editor, cx| { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor.select_all(&SelectAll, window, cx); }) }); diff --git a/crates/agent_ui/src/inline_prompt_editor.rs b/crates/agent_ui/src/inline_prompt_editor.rs index 517f8f08a6e7e9e31b2f88d1f5ee9444202009d5..8d96d56ea67cc9366df420b23e2221636d3450fb 100644 --- a/crates/agent_ui/src/inline_prompt_editor.rs +++ b/crates/agent_ui/src/inline_prompt_editor.rs @@ -357,7 +357,7 @@ impl PromptEditor { creases = insert_message_creases(&mut editor, &existing_creases, window, cx); if focus { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); } editor }); diff --git a/crates/agent_ui/src/terminal_inline_assistant.rs b/crates/agent_ui/src/terminal_inline_assistant.rs index 84a74242b80d0b2f8479b3c6dbca1c7d0bb2cb6d..cacbc316bb84e74e5c369451791f777a9bf58e82 100644 --- a/crates/agent_ui/src/terminal_inline_assistant.rs +++ b/crates/agent_ui/src/terminal_inline_assistant.rs @@ -127,7 +127,7 @@ impl TerminalInlineAssistant { if let Some(prompt_editor) = assist.prompt_editor.as_ref() { prompt_editor.update(cx, |this, cx| { this.editor.update(cx, |editor, cx| { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor.select_all(&SelectAll, window, cx); }); }); @@ -292,7 +292,7 @@ impl TerminalInlineAssistant { .terminal .update(cx, |this, cx| { this.clear_block_below_cursor(cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); }) .log_err(); @@ -369,7 +369,7 @@ impl TerminalInlineAssistant { .terminal .update(cx, |this, cx| { this.clear_block_below_cursor(cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); }) .is_ok() } diff --git a/crates/agent_ui/src/text_thread_editor.rs b/crates/agent_ui/src/text_thread_editor.rs index 947afe050639f89922873a12baa8b1eadfc44995..b26ee44ce53503f3f9b9e77b27a22c0bc39d6473 100644 --- a/crates/agent_ui/src/text_thread_editor.rs +++ b/crates/agent_ui/src/text_thread_editor.rs @@ -1341,7 +1341,7 @@ impl TextThreadEditor { if let Some((text, _)) = Self::get_selection_or_code_block(&context_editor_view, cx) { active_editor_view.update(cx, |editor, cx| { editor.insert(&text, window, cx); - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); }) } } diff --git a/crates/agent_ui/src/ui/acp_onboarding_modal.rs b/crates/agent_ui/src/ui/acp_onboarding_modal.rs index 8433904fb3b540c2d78c8634b7a6755303d6e15c..e48a36bd5af3eff578e230195dc2247900977173 100644 --- a/crates/agent_ui/src/ui/acp_onboarding_modal.rs +++ b/crates/agent_ui/src/ui/acp_onboarding_modal.rs @@ -222,8 +222,8 @@ impl Render for AcpOnboardingModal { acp_onboarding_event!("Canceled", trigger = "Action"); cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| { - this.focus_handle.focus(window); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + this.focus_handle.focus(window, cx); })) .child(illustration) .child( diff --git a/crates/agent_ui/src/ui/claude_code_onboarding_modal.rs b/crates/agent_ui/src/ui/claude_code_onboarding_modal.rs index 06980f18977aefe228bb7f09962e69fe2b3a5068..a8f007666d8957a7195fdf36b612b578b16f543c 100644 --- a/crates/agent_ui/src/ui/claude_code_onboarding_modal.rs +++ b/crates/agent_ui/src/ui/claude_code_onboarding_modal.rs @@ -230,8 +230,8 @@ impl Render for ClaudeCodeOnboardingModal { claude_code_onboarding_event!("Canceled", trigger = "Action"); cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| { - this.focus_handle.focus(window); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + this.focus_handle.focus(window, cx); })) .child(illustration) .child( diff --git a/crates/agent_ui/src/ui/onboarding_modal.rs b/crates/agent_ui/src/ui/onboarding_modal.rs index ad404afa784974631f914e6fece2de6b6c7d6a46..b8ec2b00657efca29fede32a5cc23b669ede66e7 100644 --- a/crates/agent_ui/src/ui/onboarding_modal.rs +++ b/crates/agent_ui/src/ui/onboarding_modal.rs @@ -83,8 +83,8 @@ impl Render for AgentOnboardingModal { agent_onboarding_event!("Canceled", trigger = "Action"); cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| { - this.focus_handle.focus(window); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + this.focus_handle.focus(window, cx); })) .child( div() diff --git a/crates/collab_ui/src/collab_panel.rs b/crates/collab_ui/src/collab_panel.rs index 2f1e2842cbd2f5024df0608578b7cb7f4bbc158d..0ae4ff270bd672ca028d638484b9a23f5981de1a 100644 --- a/crates/collab_ui/src/collab_panel.rs +++ b/crates/collab_ui/src/collab_panel.rs @@ -1252,7 +1252,7 @@ impl CollabPanel { context_menu }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe_in( &context_menu, window, @@ -1424,7 +1424,7 @@ impl CollabPanel { context_menu }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe_in( &context_menu, window, @@ -1487,7 +1487,7 @@ impl CollabPanel { }) }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe_in( &context_menu, window, @@ -1521,9 +1521,9 @@ impl CollabPanel { if cx.stop_active_drag(window) { return; } else if self.take_editing_state(window, cx) { - window.focus(&self.filter_editor.focus_handle(cx)); + window.focus(&self.filter_editor.focus_handle(cx), cx); } else if !self.reset_filter_editor_text(window, cx) { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } if self.context_menu.is_some() { @@ -1826,7 +1826,7 @@ impl CollabPanel { }); self.update_entries(false, cx); self.select_channel_editor(); - window.focus(&self.channel_name_editor.focus_handle(cx)); + window.focus(&self.channel_name_editor.focus_handle(cx), cx); cx.notify(); } @@ -1851,7 +1851,7 @@ impl CollabPanel { }); self.update_entries(false, cx); self.select_channel_editor(); - window.focus(&self.channel_name_editor.focus_handle(cx)); + window.focus(&self.channel_name_editor.focus_handle(cx), cx); cx.notify(); } @@ -1900,7 +1900,7 @@ impl CollabPanel { editor.set_text(channel.name.clone(), window, cx); editor.select_all(&Default::default(), window, cx); }); - window.focus(&self.channel_name_editor.focus_handle(cx)); + window.focus(&self.channel_name_editor.focus_handle(cx), cx); self.update_entries(false, cx); self.select_channel_editor(); } diff --git a/crates/collab_ui/src/collab_panel/channel_modal.rs b/crates/collab_ui/src/collab_panel/channel_modal.rs index 9d882562cab710f562145087e5c38474fda4808b..ae5b537f2c66dc273d504a70f2b75cb8bec0be20 100644 --- a/crates/collab_ui/src/collab_panel/channel_modal.rs +++ b/crates/collab_ui/src/collab_panel/channel_modal.rs @@ -642,7 +642,7 @@ impl ChannelModalDelegate { }); menu }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe_in( &context_menu, window, diff --git a/crates/command_palette/src/command_palette.rs b/crates/command_palette/src/command_palette.rs index daf97bf676e27b5dd81ce4882c102dbfdefc502a..038b58ac5f4e90544232ccc8da55d0ca71ec28df 100644 --- a/crates/command_palette/src/command_palette.rs +++ b/crates/command_palette/src/command_palette.rs @@ -588,7 +588,7 @@ impl PickerDelegate for CommandPaletteDelegate { }) .detach_and_log_err(cx); let action = command.action; - window.focus(&self.previous_focus_handle); + window.focus(&self.previous_focus_handle, cx); self.dismissed(window, cx); window.dispatch_action(action, cx); } @@ -784,7 +784,7 @@ mod tests { workspace.update_in(cx, |workspace, window, cx| { workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx); - editor.update(cx, |editor, cx| window.focus(&editor.focus_handle(cx))) + editor.update(cx, |editor, cx| window.focus(&editor.focus_handle(cx), cx)) }); cx.simulate_keystrokes("cmd-shift-p"); @@ -855,7 +855,7 @@ mod tests { workspace.update_in(cx, |workspace, window, cx| { workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx); - editor.update(cx, |editor, cx| window.focus(&editor.focus_handle(cx))) + editor.update(cx, |editor, cx| window.focus(&editor.focus_handle(cx), cx)) }); // Test normalize (trimming whitespace and double colons) diff --git a/crates/copilot/src/copilot_edit_prediction_delegate.rs b/crates/copilot/src/copilot_edit_prediction_delegate.rs index 0e0cfe6cdca78d2a8b382269ce1ca9a340d1e69c..bbda32e1102f096e96a41cbc59268f597b1629ba 100644 --- a/crates/copilot/src/copilot_edit_prediction_delegate.rs +++ b/crates/copilot/src/copilot_edit_prediction_delegate.rs @@ -753,7 +753,7 @@ mod tests { editor .update(cx, |editor, window, cx| { use gpui::Focusable; - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); }) .unwrap(); let copilot_provider = cx.new(|_| CopilotEditPredictionDelegate::new(copilot)); @@ -1000,7 +1000,7 @@ mod tests { editor .update(cx, |editor, window, cx| { use gpui::Focusable; - window.focus(&editor.focus_handle(cx)) + window.focus(&editor.focus_handle(cx), cx) }) .unwrap(); let copilot_provider = cx.new(|_| CopilotEditPredictionDelegate::new(copilot)); diff --git a/crates/copilot/src/sign_in.rs b/crates/copilot/src/sign_in.rs index 20e31525a8fdb09fce04934d3445d51ba4226a2e..4f71a34408e23f099d4d3c145d86af24e607e3c3 100644 --- a/crates/copilot/src/sign_in.rs +++ b/crates/copilot/src/sign_in.rs @@ -435,8 +435,8 @@ impl Render for CopilotCodeVerification { .on_action(cx.listener(|_, _: &menu::Cancel, _, cx| { cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _| { - window.focus(&this.focus_handle); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + window.focus(&this.focus_handle, cx); })) .child( Vector::new(VectorName::ZedXCopilot, rems(8.), rems(4.)) diff --git a/crates/debugger_ui/src/debugger_panel.rs b/crates/debugger_ui/src/debugger_panel.rs index 104a85dc097c575e7a4cd8f4a66a98a8bb6b0d69..35ce80d3f64e362735c1c020363dbbfc2703a101 100644 --- a/crates/debugger_ui/src/debugger_panel.rs +++ b/crates/debugger_ui/src/debugger_panel.rs @@ -577,7 +577,7 @@ impl DebugPanel { menu }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe(&context_menu, |this, _, _: &DismissEvent, cx| { this.context_menu.take(); cx.notify(); @@ -1052,7 +1052,7 @@ impl DebugPanel { cx: &mut Context, ) { debug_assert!(self.sessions_with_children.contains_key(&session_item)); - session_item.focus_handle(cx).focus(window); + session_item.focus_handle(cx).focus(window, cx); session_item.update(cx, |this, cx| { this.running_state().update(cx, |this, cx| { this.go_to_selected_stack_frame(window, cx); diff --git a/crates/debugger_ui/src/new_process_modal.rs b/crates/debugger_ui/src/new_process_modal.rs index 8aaa61aad6380752a7bdd62ee35635ebb6d160e4..68e391562b57d530a21624b0626173eeb7a67c16 100644 --- a/crates/debugger_ui/src/new_process_modal.rs +++ b/crates/debugger_ui/src/new_process_modal.rs @@ -574,7 +574,7 @@ impl Render for NewProcessModal { NewProcessMode::Launch => NewProcessMode::Task, }; - this.mode_focus_handle(cx).focus(window); + this.mode_focus_handle(cx).focus(window, cx); })) .on_action( cx.listener(|this, _: &pane::ActivatePreviousItem, window, cx| { @@ -585,7 +585,7 @@ impl Render for NewProcessModal { NewProcessMode::Launch => NewProcessMode::Attach, }; - this.mode_focus_handle(cx).focus(window); + this.mode_focus_handle(cx).focus(window, cx); }), ) .child( @@ -602,7 +602,7 @@ impl Render for NewProcessModal { NewProcessMode::Task.to_string(), cx.listener(|this, _, window, cx| { this.mode = NewProcessMode::Task; - this.mode_focus_handle(cx).focus(window); + this.mode_focus_handle(cx).focus(window, cx); cx.notify(); }), ) @@ -611,7 +611,7 @@ impl Render for NewProcessModal { NewProcessMode::Debug.to_string(), cx.listener(|this, _, window, cx| { this.mode = NewProcessMode::Debug; - this.mode_focus_handle(cx).focus(window); + this.mode_focus_handle(cx).focus(window, cx); cx.notify(); }), ) @@ -629,7 +629,7 @@ impl Render for NewProcessModal { cx, ); } - this.mode_focus_handle(cx).focus(window); + this.mode_focus_handle(cx).focus(window, cx); cx.notify(); }), ) @@ -638,7 +638,7 @@ impl Render for NewProcessModal { NewProcessMode::Launch.to_string(), cx.listener(|this, _, window, cx| { this.mode = NewProcessMode::Launch; - this.mode_focus_handle(cx).focus(window); + this.mode_focus_handle(cx).focus(window, cx); cx.notify(); }), ) @@ -840,17 +840,17 @@ impl ConfigureMode { } } - fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, _: &mut Context) { - window.focus_next(); + fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context) { + window.focus_next(cx); } fn on_tab_prev( &mut self, _: &menu::SelectPrevious, window: &mut Window, - _: &mut Context, + cx: &mut Context, ) { - window.focus_prev(); + window.focus_prev(cx); } fn render( @@ -923,7 +923,7 @@ impl AttachMode { window, cx, ); - window.focus(&modal.focus_handle(cx)); + window.focus(&modal.focus_handle(cx), cx); modal }); diff --git a/crates/debugger_ui/src/onboarding_modal.rs b/crates/debugger_ui/src/onboarding_modal.rs index 18205209983421691046e8a9d93eb6de32cd4563..b6f1ab944183c4f44d2bc5f6855731abb65ce1f7 100644 --- a/crates/debugger_ui/src/onboarding_modal.rs +++ b/crates/debugger_ui/src/onboarding_modal.rs @@ -83,8 +83,8 @@ impl Render for DebuggerOnboardingModal { debugger_onboarding_event!("Canceled", trigger = "Action"); cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| { - this.focus_handle.focus(window); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + this.focus_handle.focus(window, cx); })) .child( div() diff --git a/crates/debugger_ui/src/session/running.rs b/crates/debugger_ui/src/session/running.rs index 4898ec95ca3c5b55669896b3c1d898326851c0c3..422207d3cbf4880e0c8e3c02e01dbe373800ea62 100644 --- a/crates/debugger_ui/src/session/running.rs +++ b/crates/debugger_ui/src/session/running.rs @@ -604,7 +604,7 @@ impl DebugTerminal { let focus_handle = cx.focus_handle(); let focus_subscription = cx.on_focus(&focus_handle, window, |this, window, cx| { if let Some(terminal) = this.terminal.as_ref() { - terminal.focus_handle(cx).focus(window); + terminal.focus_handle(cx).focus(window, cx); } }); diff --git a/crates/debugger_ui/src/session/running/breakpoint_list.rs b/crates/debugger_ui/src/session/running/breakpoint_list.rs index 2c7e2074678290356b7669228dcf29008f1cc36b..f154757429a2bbfe153ee40c2c513dd06f05aa03 100644 --- a/crates/debugger_ui/src/session/running/breakpoint_list.rs +++ b/crates/debugger_ui/src/session/running/breakpoint_list.rs @@ -310,7 +310,7 @@ impl BreakpointList { fn dismiss(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context) { if self.input.focus_handle(cx).contains_focused(window, cx) { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } else if self.strip_mode.is_some() { self.strip_mode.take(); cx.notify(); @@ -364,9 +364,9 @@ impl BreakpointList { } } } - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } else { - handle.focus(window); + handle.focus(window, cx); } return; @@ -627,7 +627,7 @@ impl BreakpointList { .on_click({ let focus_handle = focus_handle.clone(); move |_, window, cx| { - focus_handle.focus(window); + focus_handle.focus(window, cx); window.dispatch_action(ToggleEnableBreakpoint.boxed_clone(), cx) } }), @@ -654,7 +654,7 @@ impl BreakpointList { ) .on_click({ move |_, window, cx| { - focus_handle.focus(window); + focus_handle.focus(window, cx); window.dispatch_action(UnsetBreakpoint.boxed_clone(), cx) } }), diff --git a/crates/debugger_ui/src/session/running/console.rs b/crates/debugger_ui/src/session/running/console.rs index 927a57dc8bdf956eb7f7ff63d3ea058500abf6c3..040953bff6e8f0efa6045c1629c964ac98929547 100644 --- a/crates/debugger_ui/src/session/running/console.rs +++ b/crates/debugger_ui/src/session/running/console.rs @@ -105,7 +105,7 @@ impl Console { cx.subscribe(&stack_frame_list, Self::handle_stack_frame_list_events), cx.on_focus(&focus_handle, window, |console, window, cx| { if console.is_running(cx) { - console.query_bar.focus_handle(cx).focus(window); + console.query_bar.focus_handle(cx).focus(window, cx); } }), ]; diff --git a/crates/debugger_ui/src/session/running/memory_view.rs b/crates/debugger_ui/src/session/running/memory_view.rs index 55a8e8429eb23cd0bfcaa7d592d16797c061d2ae..f10e5179e37f87be0e27985b557fcb63cf089a42 100644 --- a/crates/debugger_ui/src/session/running/memory_view.rs +++ b/crates/debugger_ui/src/session/running/memory_view.rs @@ -403,7 +403,7 @@ impl MemoryView { this.set_placeholder_text("Write to Selected Memory Range", window, cx); }); self.is_writing_memory = true; - self.query_editor.focus_handle(cx).focus(window); + self.query_editor.focus_handle(cx).focus(window, cx); } else { self.query_editor.update(cx, |this, cx| { this.clear(window, cx); diff --git a/crates/debugger_ui/src/session/running/variable_list.rs b/crates/debugger_ui/src/session/running/variable_list.rs index 7b23cd685d93e6353d68dc57cd3998099ea56ad7..8329a6baf04061cc33e8130a4e6b3a33b35267b6 100644 --- a/crates/debugger_ui/src/session/running/variable_list.rs +++ b/crates/debugger_ui/src/session/running/variable_list.rs @@ -529,7 +529,7 @@ impl VariableList { fn cancel(&mut self, _: &menu::Cancel, window: &mut Window, cx: &mut Context) { self.edited_path.take(); - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); cx.notify(); } @@ -1067,7 +1067,7 @@ impl VariableList { editor.select_all(&editor::actions::SelectAll, window, cx); editor }); - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); editor } diff --git a/crates/diagnostics/src/buffer_diagnostics.rs b/crates/diagnostics/src/buffer_diagnostics.rs index ca28f2805adca78846a66e7b1f4d9f3fc57bb557..ba10f6fbdabf05a095a7fed7c6ae682d4dc177c7 100644 --- a/crates/diagnostics/src/buffer_diagnostics.rs +++ b/crates/diagnostics/src/buffer_diagnostics.rs @@ -175,7 +175,7 @@ impl BufferDiagnosticsEditor { // `BufferDiagnosticsEditor` instance. EditorEvent::Focused => { if buffer_diagnostics_editor.multibuffer.read(cx).is_empty() { - window.focus(&buffer_diagnostics_editor.focus_handle); + window.focus(&buffer_diagnostics_editor.focus_handle, cx); } } EditorEvent::Blurred => { @@ -517,7 +517,7 @@ impl BufferDiagnosticsEditor { .editor .read(cx) .focus_handle(cx) - .focus(window); + .focus(window, cx); } } } @@ -617,7 +617,7 @@ impl BufferDiagnosticsEditor { // not empty, focus on the editor instead, which will allow the user to // start interacting and editing the buffer's contents. if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() { - self.editor.focus_handle(cx).focus(window) + self.editor.focus_handle(cx).focus(window, cx) } } diff --git a/crates/diagnostics/src/diagnostic_renderer.rs b/crates/diagnostics/src/diagnostic_renderer.rs index 72ad7b591413832183bb85d58d188e692d46ffad..521752ff1959fccc12b74857e342ff33a0444f3f 100644 --- a/crates/diagnostics/src/diagnostic_renderer.rs +++ b/crates/diagnostics/src/diagnostic_renderer.rs @@ -315,6 +315,6 @@ impl DiagnosticBlock { editor.change_selections(Default::default(), window, cx, |s| { s.select_ranges([range.start..range.start]); }); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); } } diff --git a/crates/diagnostics/src/diagnostics.rs b/crates/diagnostics/src/diagnostics.rs index 0999bebdb6aa9ca744e3a5121670a1b7357411a9..d85eb07f68619e15bfe44d26282db3a3e49df4f3 100644 --- a/crates/diagnostics/src/diagnostics.rs +++ b/crates/diagnostics/src/diagnostics.rs @@ -243,7 +243,7 @@ impl ProjectDiagnosticsEditor { match event { EditorEvent::Focused => { if this.multibuffer.read(cx).is_empty() { - window.focus(&this.focus_handle); + window.focus(&this.focus_handle, cx); } } EditorEvent::Blurred => this.close_diagnosticless_buffers(cx, false), @@ -434,7 +434,7 @@ impl ProjectDiagnosticsEditor { fn focus_in(&mut self, window: &mut Window, cx: &mut Context) { if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() { - self.editor.focus_handle(cx).focus(window) + self.editor.focus_handle(cx).focus(window, cx) } } @@ -650,7 +650,7 @@ impl ProjectDiagnosticsEditor { }) }); if this.focus_handle.is_focused(window) { - this.editor.read(cx).focus_handle(cx).focus(window); + this.editor.read(cx).focus_handle(cx).focus(window, cx); } } diff --git a/crates/edit_prediction/src/onboarding_modal.rs b/crates/edit_prediction/src/onboarding_modal.rs index ed7adfc75476afb07f9c56b9c9c03abbbcef1134..97f529ae38df350ef21ffc04b79df6e8e6a7a501 100644 --- a/crates/edit_prediction/src/onboarding_modal.rs +++ b/crates/edit_prediction/src/onboarding_modal.rs @@ -131,8 +131,8 @@ impl Render for ZedPredictModal { onboarding_event!("Cancelled", trigger = "Action"); cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| { - this.focus_handle.focus(window); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + this.focus_handle.focus(window, cx); })) .child( div() diff --git a/crates/edit_prediction_ui/src/rate_prediction_modal.rs b/crates/edit_prediction_ui/src/rate_prediction_modal.rs index 22e82bc445b394cc122e1cb1aa3604b45c25d1d1..1af65ad58083e3cccfa51ea7b674da01cad810a0 100644 --- a/crates/edit_prediction_ui/src/rate_prediction_modal.rs +++ b/crates/edit_prediction_ui/src/rate_prediction_modal.rs @@ -305,7 +305,7 @@ impl RatePredictionsModal { && prediction.id == prev_prediction.prediction.id { if focus { - window.focus(&prev_prediction.feedback_editor.focus_handle(cx)); + window.focus(&prev_prediction.feedback_editor.focus_handle(cx), cx); } return; } diff --git a/crates/editor/benches/editor_render.rs b/crates/editor/benches/editor_render.rs index 4323c6c973f3729623d8939ca89ecf3ac403bcbf..daaeede790cbd75a7238a81559513c5d3165a054 100644 --- a/crates/editor/benches/editor_render.rs +++ b/crates/editor/benches/editor_render.rs @@ -29,7 +29,7 @@ fn editor_input_with_1000_cursors(bencher: &mut Bencher<'_>, cx: &TestAppContext ); editor }); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor }); @@ -72,7 +72,7 @@ fn open_editor_with_one_long_line(bencher: &mut Bencher<'_>, args: &(String, Tes editor.set_style(editor::EditorStyle::default(), window, cx); editor }); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor }); }); @@ -100,7 +100,7 @@ fn editor_render(bencher: &mut Bencher<'_>, cx: &TestAppContext) { editor.set_style(editor::EditorStyle::default(), window, cx); editor }); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor }); diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index f9ffd835245ebb2ac7df8e8b7b667a1501c254fd..7da06c3d8de91709cdcea8cbc923918464021079 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -3816,7 +3816,7 @@ impl Editor { ) { if !self.focus_handle.is_focused(window) { self.last_focused_descendant = None; - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx)); @@ -3921,7 +3921,7 @@ impl Editor { ) { if !self.focus_handle.is_focused(window) { self.last_focused_descendant = None; - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx)); @@ -6712,7 +6712,7 @@ impl Editor { }) }) .on_click(cx.listener(move |editor, _: &ClickEvent, window, cx| { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor.toggle_code_actions( &crate::actions::ToggleCodeActions { deployed_from: Some(crate::actions::CodeActionSource::Indicator( @@ -8605,7 +8605,7 @@ impl Editor { BreakpointEditAction::Toggle }; - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor.edit_breakpoint_at_anchor( position, breakpoint.as_ref().clone(), @@ -8797,7 +8797,7 @@ impl Editor { ClickEvent::Mouse(e) => e.down.button == MouseButton::Left, }; - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor.toggle_code_actions( &ToggleCodeActions { deployed_from: Some(CodeActionSource::RunMenu(row)), @@ -11212,7 +11212,7 @@ impl Editor { }]; let focus_handle = bp_prompt.focus_handle(cx); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); let block_ids = self.insert_blocks(blocks, None, cx); bp_prompt.update(cx, |prompt, _| { @@ -18039,7 +18039,7 @@ impl Editor { cx, ); let rename_focus_handle = rename_editor.focus_handle(cx); - window.focus(&rename_focus_handle); + window.focus(&rename_focus_handle, cx); let block_id = this.insert_blocks( [BlockProperties { style: BlockStyle::Flex, @@ -18153,7 +18153,7 @@ impl Editor { ) -> Option { let rename = self.pending_rename.take()?; if rename.editor.focus_handle(cx).is_focused(window) { - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } self.remove_blocks( @@ -22723,7 +22723,7 @@ impl Editor { .take() .and_then(|descendant| descendant.upgrade()) { - window.focus(&descendant); + window.focus(&descendant, cx); } else { if let Some(blame) = self.blame.as_ref() { blame.update(cx, GitBlame::focus) @@ -25969,7 +25969,7 @@ impl BreakpointPromptEditor { self.editor .update(cx, |editor, cx| { editor.remove_blocks(self.block_ids.clone(), None, cx); - window.focus(&editor.focus_handle); + window.focus(&editor.focus_handle, cx); }) .log_err(); } diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index bac3d12638a23bc54f4a981b874da35b77894fff..1b84197471bd9ad65dc0ac31bf42c6ddc5ee3bf5 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -18201,7 +18201,7 @@ async fn test_on_type_formatting_not_triggered(cx: &mut TestAppContext) { ); editor_handle.update_in(cx, |editor, window, cx| { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { s.select_ranges([Point::new(0, 21)..Point::new(0, 20)]) }); diff --git a/crates/editor/src/hover_links.rs b/crates/editor/src/hover_links.rs index d7e4169a721765e0f93805bf0c157033bf0cafab..1c00acbfa9f1a69cbe01c45758db5a0cd4fee757 100644 --- a/crates/editor/src/hover_links.rs +++ b/crates/editor/src/hover_links.rs @@ -218,7 +218,7 @@ impl Editor { self.hide_hovered_link(cx); if !hovered_link_state.links.is_empty() { if !self.focus_handle.is_focused(window) { - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } // exclude links pointing back to the current anchor diff --git a/crates/editor/src/mouse_context_menu.rs b/crates/editor/src/mouse_context_menu.rs index 36521d46a6c20223e973346b9d1e9391db3306ca..7314991bd5e4842f395383888a87b4e2db7e0a0c 100644 --- a/crates/editor/src/mouse_context_menu.rs +++ b/crates/editor/src/mouse_context_menu.rs @@ -90,8 +90,8 @@ impl MouseContextMenu { // `true` when the `ContextMenu` is focused. let focus_handle = context_menu_focus.clone(); cx.on_next_frame(window, move |_, window, cx| { - cx.on_next_frame(window, move |_, window, _cx| { - window.focus(&focus_handle); + cx.on_next_frame(window, move |_, window, cx| { + window.focus(&focus_handle, cx); }); }); @@ -100,7 +100,7 @@ impl MouseContextMenu { move |editor, _, _event: &DismissEvent, window, cx| { editor.mouse_context_menu.take(); if context_menu_focus.contains_focused(window, cx) { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); } } }); @@ -127,7 +127,7 @@ impl MouseContextMenu { } editor.mouse_context_menu.take(); if context_menu_focus.contains_focused(window, cx) { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); } }, ); @@ -161,7 +161,7 @@ pub fn deploy_context_menu( cx: &mut Context, ) { if !editor.is_focused(window) { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); } // Don't show context menu for inline editors diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs index 3afe0e6134221fc69837abd30618f2b74ae069f5..7c4c0e48d36dbb9f74a1c835c63fa2b91c5681d9 100644 --- a/crates/editor/src/test/editor_lsp_test_context.rs +++ b/crates/editor/src/test/editor_lsp_test_context.rs @@ -126,7 +126,7 @@ impl EditorLspTestContext { .read(cx) .nav_history_for_item(&cx.entity()); editor.set_nav_history(Some(nav_history)); - window.focus(&editor.focus_handle(cx)) + window.focus(&editor.focus_handle(cx), cx) }); let lsp = fake_servers.next().await.unwrap(); diff --git a/crates/editor/src/test/editor_test_context.rs b/crates/editor/src/test/editor_test_context.rs index bcfaeea3a7330539b2f2790e7dbe9a4969c76981..267058691d0070678830ba9d7c40f54a9363737b 100644 --- a/crates/editor/src/test/editor_test_context.rs +++ b/crates/editor/src/test/editor_test_context.rs @@ -78,7 +78,7 @@ impl EditorTestContext { cx, ); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor }); let editor_view = editor.root(cx).unwrap(); @@ -139,7 +139,7 @@ impl EditorTestContext { let editor = cx.add_window(|window, cx| { let editor = build_editor(buffer, window, cx); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor }); diff --git a/crates/file_finder/src/file_finder.rs b/crates/file_finder/src/file_finder.rs index 050d7a45a1b46e94a195f88e49fd6795ce37f09f..73b21bb828a598d5bbc53c0ecf4511988c30bc65 100644 --- a/crates/file_finder/src/file_finder.rs +++ b/crates/file_finder/src/file_finder.rs @@ -1713,7 +1713,7 @@ impl PickerDelegate for FileFinderDelegate { ui::IconPosition::End, Some(ToggleIncludeIgnored.boxed_clone()), move |window, cx| { - window.focus(&focus_handle); + window.focus(&focus_handle, cx); window.dispatch_action( ToggleIncludeIgnored.boxed_clone(), cx, diff --git a/crates/git_ui/src/branch_picker.rs b/crates/git_ui/src/branch_picker.rs index 7395f1588fececcf4f374ec0e66cdac6024656d7..4db37e91b8720e51ff0416cc471842483ab1d0ca 100644 --- a/crates/git_ui/src/branch_picker.rs +++ b/crates/git_ui/src/branch_picker.rs @@ -91,7 +91,7 @@ pub fn popover( window, cx, ); - list.focus_handle(cx).focus(window); + list.focus_handle(cx).focus(window, cx); list }) } @@ -1880,7 +1880,7 @@ mod tests { branch_list .update_in(cx, |branch_list, window, cx| { - window.focus(&branch_list.picker_focus_handle); + window.focus(&branch_list.picker_focus_handle, cx); assert!( branch_list.picker_focus_handle.is_focused(window), "Branch picker should be focused when selecting an entry" @@ -1898,7 +1898,7 @@ mod tests { branch_list.update_in(cx, |branch_list, window, cx| { // Re-focus the picker since workspace initialization during run_until_parked - window.focus(&branch_list.picker_focus_handle); + window.focus(&branch_list.picker_focus_handle, cx); branch_list.picker.update(cx, |picker, cx| { let last_match = picker.delegate.matches.last().unwrap(); diff --git a/crates/git_ui/src/commit_modal.rs b/crates/git_ui/src/commit_modal.rs index 291a96f47590b145b5c190150af54bd3d43c2fff..e154933adc794221159c7f1b28b3d1e33cf1854d 100644 --- a/crates/git_ui/src/commit_modal.rs +++ b/crates/git_ui/src/commit_modal.rs @@ -521,7 +521,7 @@ impl CommitModal { fn toggle_branch_selector(&mut self, window: &mut Window, cx: &mut Context) { if self.branch_list_handle.is_focused(window, cx) { - self.focus_handle(cx).focus(window) + self.focus_handle(cx).focus(window, cx) } else { self.branch_list_handle.toggle(window, cx); } @@ -587,8 +587,8 @@ impl Render for CommitModal { .bg(cx.theme().colors().editor_background) .border_1() .border_color(cx.theme().colors().border_variant) - .on_click(cx.listener(move |_, _: &ClickEvent, window, _cx| { - window.focus(&editor_focus_handle); + .on_click(cx.listener(move |_, _: &ClickEvent, window, cx| { + window.focus(&editor_focus_handle, cx); })) .child( div() diff --git a/crates/git_ui/src/file_history_view.rs b/crates/git_ui/src/file_history_view.rs index 4e91fe7e06a5823caac5bf00be8f48cc98dc8da4..f48160719ba5d9b00b8961b75e9ea402c80dd06a 100644 --- a/crates/git_ui/src/file_history_view.rs +++ b/crates/git_ui/src/file_history_view.rs @@ -633,9 +633,9 @@ impl Item for FileHistoryView { &mut self, _workspace: &mut Workspace, window: &mut Window, - _cx: &mut Context, + cx: &mut Context, ) { - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } fn show_toolbar(&self) -> bool { diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index b855d9b98708fe81328d69106ac1dda3b374080e..cf73406b3851b46ad1a7d056d6cb335666b9ac65 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -1063,7 +1063,7 @@ impl GitPanel { fn focus_editor(&mut self, _: &FocusEditor, window: &mut Window, cx: &mut Context) { self.commit_editor.update(cx, |editor, cx| { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); }); cx.notify(); } @@ -1084,8 +1084,7 @@ impl GitPanel { window: &mut Window, cx: &mut Context, ) { - self.focus_handle.focus(window); - + self.focus_handle.focus(window, cx); self.select_first_entry_if_none(window, cx); } @@ -1107,7 +1106,7 @@ impl GitPanel { .project_path_to_repo_path(&project_path, cx) .as_ref() { - project_diff.focus_handle(cx).focus(window); + project_diff.focus_handle(cx).focus(window, cx); project_diff.update(cx, |project_diff, cx| project_diff.autoscroll(cx)); return None; }; @@ -1117,7 +1116,7 @@ impl GitPanel { ProjectDiff::deploy_at(workspace, Some(entry.clone()), window, cx); }) .ok(); - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); Some(()) }); @@ -2128,7 +2127,10 @@ impl GitPanel { let commit_message = self.custom_or_suggested_commit_message(window, cx); let Some(mut message) = commit_message else { - self.commit_editor.read(cx).focus_handle(cx).focus(window); + self.commit_editor + .read(cx) + .focus_handle(cx) + .focus(window, cx); return; }; @@ -4146,7 +4148,7 @@ impl GitPanel { .border_color(cx.theme().colors().border) .cursor_text() .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| { - window.focus(&this.commit_editor.focus_handle(cx)); + window.focus(&this.commit_editor.focus_handle(cx), cx); })) .child( h_flex() @@ -4940,7 +4942,7 @@ impl GitPanel { this.open_file(&Default::default(), window, cx) } else { this.open_diff(&Default::default(), window, cx); - this.focus_handle.focus(window); + this.focus_handle.focus(window, cx); } }) }) diff --git a/crates/git_ui/src/git_ui.rs b/crates/git_ui/src/git_ui.rs index 54adc8130d78e80af5c561541efb8128f1b2a017..5f50e4ef8029d8f57cd159bc7da68b668b628f48 100644 --- a/crates/git_ui/src/git_ui.rs +++ b/crates/git_ui/src/git_ui.rs @@ -817,7 +817,7 @@ impl GitCloneModal { }); let focus_handle = repo_input.focus_handle(cx); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); Self { panel, diff --git a/crates/git_ui/src/onboarding.rs b/crates/git_ui/src/onboarding.rs index d1709e043b92216e974c1a4f451db5c28b98f773..eccb18a5400647ff86e44f4426d271d6c9361164 100644 --- a/crates/git_ui/src/onboarding.rs +++ b/crates/git_ui/src/onboarding.rs @@ -85,8 +85,8 @@ impl Render for GitOnboardingModal { git_onboarding_event!("Cancelled", trigger = "Action"); cx.emit(DismissEvent); })) - .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, _cx| { - this.focus_handle.focus(window); + .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, window, cx| { + this.focus_handle.focus(window, cx); })) .child( div().p_1p5().absolute().inset_0().h(px(160.)).child( diff --git a/crates/git_ui/src/project_diff.rs b/crates/git_ui/src/project_diff.rs index 4d7a27354b1b4b6e972579e73c48bcd4c2448a5c..0e0632d9d049f54a648f65c55a96d639c9103e4d 100644 --- a/crates/git_ui/src/project_diff.rs +++ b/crates/git_ui/src/project_diff.rs @@ -492,7 +492,7 @@ impl ProjectDiff { if editor.focus_handle(cx).contains_focused(window, cx) && self.multibuffer.read(cx).is_empty() { - self.focus_handle.focus(window) + self.focus_handle.focus(window, cx) } } @@ -597,10 +597,10 @@ impl ProjectDiff { .focus_handle(cx) .contains_focused(window, cx) { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } else if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() { self.editor.update(cx, |editor, cx| { - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); }); } if self.pending_scroll.as_ref() == Some(&path_key) { @@ -983,7 +983,7 @@ impl Render for ProjectDiff { cx, )) .on_click(move |_, window, cx| { - window.focus(&keybinding_focus_handle); + window.focus(&keybinding_focus_handle, cx); window.dispatch_action( Box::new(CloseActiveItem::default()), cx, @@ -1153,7 +1153,7 @@ impl ProjectDiffToolbar { fn dispatch_action(&self, action: &dyn Action, window: &mut Window, cx: &mut Context) { if let Some(project_diff) = self.project_diff(cx) { - project_diff.focus_handle(cx).focus(window); + project_diff.focus_handle(cx).focus(window, cx); } let action = action.boxed_clone(); cx.defer(move |cx| { diff --git a/crates/go_to_line/src/go_to_line.rs b/crates/go_to_line/src/go_to_line.rs index 461b0be659fc3ffb7b7bc984485dc68ece988500..7c42972a75420ae87bf3c5b9caaf041852efc009 100644 --- a/crates/go_to_line/src/go_to_line.rs +++ b/crates/go_to_line/src/go_to_line.rs @@ -268,7 +268,7 @@ impl GoToLine { cx, |s| s.select_anchor_ranges([start..start]), ); - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); cx.notify() }); self.prev_scroll_position.take(); diff --git a/crates/gpui/examples/focus_visible.rs b/crates/gpui/examples/focus_visible.rs index 737317cabadb7d3358c9c0497b52d4c2ff2e1028..d7c15396f0381ef29b3d6600347fd90a602256f5 100644 --- a/crates/gpui/examples/focus_visible.rs +++ b/crates/gpui/examples/focus_visible.rs @@ -29,7 +29,7 @@ impl Example { ]; let focus_handle = cx.focus_handle(); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); Self { focus_handle, @@ -40,13 +40,13 @@ impl Example { } } - fn on_tab(&mut self, _: &Tab, window: &mut Window, _: &mut Context) { - window.focus_next(); + fn on_tab(&mut self, _: &Tab, window: &mut Window, cx: &mut Context) { + window.focus_next(cx); self.message = SharedString::from("Pressed Tab - focus-visible border should appear!"); } - fn on_tab_prev(&mut self, _: &TabPrev, window: &mut Window, _: &mut Context) { - window.focus_prev(); + fn on_tab_prev(&mut self, _: &TabPrev, window: &mut Window, cx: &mut Context) { + window.focus_prev(cx); self.message = SharedString::from("Pressed Shift-Tab - focus-visible border should appear!"); } diff --git a/crates/gpui/examples/input.rs b/crates/gpui/examples/input.rs index 37115feaa551a787562e7299c9d44bcc97b5fca3..44fae4ffe6bb9e120a8f96c10e0af8f4f8026cdd 100644 --- a/crates/gpui/examples/input.rs +++ b/crates/gpui/examples/input.rs @@ -736,7 +736,7 @@ fn main() { window .update(cx, |view, window, cx| { - window.focus(&view.text_input.focus_handle(cx)); + window.focus(&view.text_input.focus_handle(cx), cx); cx.activate(true); }) .unwrap(); diff --git a/crates/gpui/examples/on_window_close_quit.rs b/crates/gpui/examples/on_window_close_quit.rs index 8fe24001445d94b1629bf766294d850d0918a5e8..9a2b2f2fee43f753aece55d076be647ad8060965 100644 --- a/crates/gpui/examples/on_window_close_quit.rs +++ b/crates/gpui/examples/on_window_close_quit.rs @@ -55,7 +55,7 @@ fn main() { cx.activate(false); cx.new(|cx| { let focus_handle = cx.focus_handle(); - focus_handle.focus(window); + focus_handle.focus(window, cx); ExampleWindow { focus_handle } }) }, @@ -72,7 +72,7 @@ fn main() { |window, cx| { cx.new(|cx| { let focus_handle = cx.focus_handle(); - focus_handle.focus(window); + focus_handle.focus(window, cx); ExampleWindow { focus_handle } }) }, diff --git a/crates/gpui/examples/tab_stop.rs b/crates/gpui/examples/tab_stop.rs index 8dbcbeccb7351fda18e8d36fe38d8f26c4a70cc9..4d99da1a07a123e9a18b3c64a90834c31bd76909 100644 --- a/crates/gpui/examples/tab_stop.rs +++ b/crates/gpui/examples/tab_stop.rs @@ -22,7 +22,7 @@ impl Example { ]; let focus_handle = cx.focus_handle(); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); Self { focus_handle, @@ -31,13 +31,13 @@ impl Example { } } - fn on_tab(&mut self, _: &Tab, window: &mut Window, _: &mut Context) { - window.focus_next(); + fn on_tab(&mut self, _: &Tab, window: &mut Window, cx: &mut Context) { + window.focus_next(cx); self.message = SharedString::from("You have pressed `Tab`."); } - fn on_tab_prev(&mut self, _: &TabPrev, window: &mut Window, _: &mut Context) { - window.focus_prev(); + fn on_tab_prev(&mut self, _: &TabPrev, window: &mut Window, cx: &mut Context) { + window.focus_prev(cx); self.message = SharedString::from("You have pressed `Shift-Tab`."); } } diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index aa1acae33b8fb55fc5e2f8fa8c0f5b8bb91758f3..7bd0daf56a466666b8cf5ae70f6b7cb5597a0d10 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -1900,8 +1900,11 @@ impl App { pub(crate) fn clear_pending_keystrokes(&mut self) { for window in self.windows() { window - .update(self, |_, window, _| { - window.clear_pending_keystrokes(); + .update(self, |_, window, cx| { + if window.pending_input_keystrokes().is_some() { + window.clear_pending_keystrokes(); + window.pending_input_changed(cx); + } }) .ok(); } diff --git a/crates/gpui/src/app/async_context.rs b/crates/gpui/src/app/async_context.rs index f5dcd30ae943954cbc042e1ce02edad39370a04a..805dfced162cd27f0cc785a8282ae3b802c2873a 100644 --- a/crates/gpui/src/app/async_context.rs +++ b/crates/gpui/src/app/async_context.rs @@ -487,7 +487,7 @@ impl VisualContext for AsyncWindowContext { V: Focusable, { self.app.update_window(self.window, |_, window, cx| { - view.read(cx).focus_handle(cx).focus(window); + view.read(cx).focus_handle(cx).focus(window, cx); }) } } diff --git a/crates/gpui/src/app/context.rs b/crates/gpui/src/app/context.rs index 27ccbecaf83cafe7bf7562c32a164268a74a396b..b780ca426c15c99030f24ee48bde978ad38526e7 100644 --- a/crates/gpui/src/app/context.rs +++ b/crates/gpui/src/app/context.rs @@ -285,7 +285,7 @@ impl<'a, T: 'static> Context<'a, T> { /// Focus the given view in the given window. View type is required to implement Focusable. pub fn focus_view(&mut self, view: &Entity, window: &mut Window) { - window.focus(&view.focus_handle(self)); + window.focus(&view.focus_handle(self), self); } /// Sets a given callback to be run on the next frame. @@ -732,7 +732,7 @@ impl<'a, T: 'static> Context<'a, T> { { let view = self.entity(); window.defer(self, move |window, cx| { - view.read(cx).focus_handle(cx).focus(window) + view.read(cx).focus_handle(cx).focus(window, cx) }) } } diff --git a/crates/gpui/src/app/test_context.rs b/crates/gpui/src/app/test_context.rs index 5be2e394e8edfd26a25c70c79c321a7fb8fdc8ba..9b982f9a1ca3c14b99dfc93e938aafe4e2f75cff 100644 --- a/crates/gpui/src/app/test_context.rs +++ b/crates/gpui/src/app/test_context.rs @@ -1045,7 +1045,7 @@ impl VisualContext for VisualTestContext { fn focus(&mut self, view: &Entity) -> Self::Result<()> { self.window .update(&mut self.cx, |_, window, cx| { - view.read(cx).focus_handle(cx).focus(window) + view.read(cx).focus_handle(cx).focus(window, cx) }) .unwrap() } diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs index 374fd2c55a8e1cd5280d6ea9378a64c265a5c508..cf55edefaf70c080e171a8e21b350fd3c6d82f75 100644 --- a/crates/gpui/src/elements/div.rs +++ b/crates/gpui/src/elements/div.rs @@ -654,7 +654,7 @@ pub trait InteractiveElement: Sized { /// Set whether this element is a tab stop. /// /// When false, the element remains in tab-index order but cannot be reached via keyboard navigation. - /// Useful for container elements: focus the container, then call `window.focus_next()` to focus + /// Useful for container elements: focus the container, then call `window.focus_next(cx)` to focus /// the first tab stop inside it while having the container element itself be unreachable via the keyboard. /// Should only be used with `tab_index`. fn tab_stop(mut self, tab_stop: bool) -> Self { @@ -2096,12 +2096,12 @@ impl Interactivity { // This behavior can be suppressed by using `cx.prevent_default()`. if let Some(focus_handle) = self.tracked_focus_handle.clone() { let hitbox = hitbox.clone(); - window.on_mouse_event(move |_: &MouseDownEvent, phase, window, _| { + window.on_mouse_event(move |_: &MouseDownEvent, phase, window, cx| { if phase == DispatchPhase::Bubble && hitbox.is_hovered(window) && !window.default_prevented() { - window.focus(&focus_handle); + window.focus(&focus_handle, cx); // If there is a parent that is also focusable, prevent it // from transferring focus because we already did so. window.prevent_default(); diff --git a/crates/gpui/src/elements/uniform_list.rs b/crates/gpui/src/elements/uniform_list.rs index 1ad71b97673e6f54015dbc67fa829725dd4fccb2..a7486f0c00ac4e11ef807af90f6fb75b74b5d142 100644 --- a/crates/gpui/src/elements/uniform_list.rs +++ b/crates/gpui/src/elements/uniform_list.rs @@ -788,7 +788,7 @@ mod test { let (view, cx) = cx.add_window_view(|window, cx| { let focus_handle = cx.focus_handle(); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); TestView { scroll_handle: UniformListScrollHandle::new(), index: 0, diff --git a/crates/gpui/src/interactive.rs b/crates/gpui/src/interactive.rs index 6852b9596a3f74e1d533fc2a7e9a7b7eeab71cda..a500ac46f0bbf96fc2b9d326a3a61da42c40b7ec 100644 --- a/crates/gpui/src/interactive.rs +++ b/crates/gpui/src/interactive.rs @@ -705,8 +705,8 @@ mod test { }); window - .update(cx, |test_view, window, _cx| { - window.focus(&test_view.focus_handle) + .update(cx, |test_view, window, cx| { + window.focus(&test_view.focus_handle, cx) }) .unwrap(); diff --git a/crates/gpui/src/key_dispatch.rs b/crates/gpui/src/key_dispatch.rs index ae4553408fa8d0dc7ed640319ae0b0a178465b74..85aa550fa96ca76e46f8d75ab84e91a7e9ba43cd 100644 --- a/crates/gpui/src/key_dispatch.rs +++ b/crates/gpui/src/key_dispatch.rs @@ -610,8 +610,8 @@ impl DispatchTree { #[cfg(test)] mod tests { use crate::{ - self as gpui, DispatchResult, Element, ElementId, GlobalElementId, InspectorElementId, - Keystroke, LayoutId, Style, + self as gpui, AppContext, DispatchResult, Element, ElementId, GlobalElementId, + InspectorElementId, Keystroke, LayoutId, Style, }; use core::panic; use smallvec::SmallVec; @@ -619,8 +619,8 @@ mod tests { use crate::{ Action, ActionRegistry, App, Bounds, Context, DispatchTree, FocusHandle, InputHandler, - IntoElement, KeyBinding, KeyContext, Keymap, Pixels, Point, Render, TestAppContext, - UTF16Selection, Window, + IntoElement, KeyBinding, KeyContext, Keymap, Pixels, Point, Render, Subscription, + TestAppContext, UTF16Selection, Window, }; #[derive(PartialEq, Eq)] @@ -723,6 +723,213 @@ mod tests { assert!(!result.pending_has_binding); } + #[crate::test] + fn test_pending_input_observers_notified_on_focus_change(cx: &mut TestAppContext) { + #[derive(Clone)] + struct CustomElement { + focus_handle: FocusHandle, + text: Rc>, + } + + impl CustomElement { + fn new(cx: &mut Context) -> Self { + Self { + focus_handle: cx.focus_handle(), + text: Rc::default(), + } + } + } + + impl Element for CustomElement { + type RequestLayoutState = (); + + type PrepaintState = (); + + fn id(&self) -> Option { + Some("custom".into()) + } + + fn source_location(&self) -> Option<&'static panic::Location<'static>> { + None + } + + fn request_layout( + &mut self, + _: Option<&GlobalElementId>, + _: Option<&InspectorElementId>, + window: &mut Window, + cx: &mut App, + ) -> (LayoutId, Self::RequestLayoutState) { + (window.request_layout(Style::default(), [], cx), ()) + } + + fn prepaint( + &mut self, + _: Option<&GlobalElementId>, + _: Option<&InspectorElementId>, + _: Bounds, + _: &mut Self::RequestLayoutState, + window: &mut Window, + cx: &mut App, + ) -> Self::PrepaintState { + window.set_focus_handle(&self.focus_handle, cx); + } + + fn paint( + &mut self, + _: Option<&GlobalElementId>, + _: Option<&InspectorElementId>, + _: Bounds, + _: &mut Self::RequestLayoutState, + _: &mut Self::PrepaintState, + window: &mut Window, + cx: &mut App, + ) { + let mut key_context = KeyContext::default(); + key_context.add("Terminal"); + window.set_key_context(key_context); + window.handle_input(&self.focus_handle, self.clone(), cx); + window.on_action(std::any::TypeId::of::(), |_, _, _, _| {}); + } + } + + impl IntoElement for CustomElement { + type Element = Self; + + fn into_element(self) -> Self::Element { + self + } + } + + impl InputHandler for CustomElement { + fn selected_text_range( + &mut self, + _: bool, + _: &mut Window, + _: &mut App, + ) -> Option { + None + } + + fn marked_text_range(&mut self, _: &mut Window, _: &mut App) -> Option> { + None + } + + fn text_for_range( + &mut self, + _: Range, + _: &mut Option>, + _: &mut Window, + _: &mut App, + ) -> Option { + None + } + + fn replace_text_in_range( + &mut self, + replacement_range: Option>, + text: &str, + _: &mut Window, + _: &mut App, + ) { + if replacement_range.is_some() { + unimplemented!() + } + self.text.borrow_mut().push_str(text) + } + + fn replace_and_mark_text_in_range( + &mut self, + replacement_range: Option>, + new_text: &str, + _: Option>, + _: &mut Window, + _: &mut App, + ) { + if replacement_range.is_some() { + unimplemented!() + } + self.text.borrow_mut().push_str(new_text) + } + + fn unmark_text(&mut self, _: &mut Window, _: &mut App) {} + + fn bounds_for_range( + &mut self, + _: Range, + _: &mut Window, + _: &mut App, + ) -> Option> { + None + } + + fn character_index_for_point( + &mut self, + _: Point, + _: &mut Window, + _: &mut App, + ) -> Option { + None + } + } + + impl Render for CustomElement { + fn render(&mut self, _: &mut Window, _: &mut Context) -> impl IntoElement { + self.clone() + } + } + + cx.update(|cx| { + cx.bind_keys([KeyBinding::new("ctrl-b", TestAction, Some("Terminal"))]); + cx.bind_keys([KeyBinding::new("ctrl-b h", TestAction, Some("Terminal"))]); + }); + + let (test, cx) = cx.add_window_view(|_, cx| CustomElement::new(cx)); + let focus_handle = test.update(cx, |test, _| test.focus_handle.clone()); + + let pending_input_changed_count = Rc::new(RefCell::new(0usize)); + let pending_input_changed_count_for_observer = pending_input_changed_count.clone(); + + struct PendingInputObserver { + _subscription: Subscription, + } + + let _observer = cx.update(|window, cx| { + cx.new(|cx| PendingInputObserver { + _subscription: cx.observe_pending_input(window, move |_, _, _| { + *pending_input_changed_count_for_observer.borrow_mut() += 1; + }), + }) + }); + + cx.update(|window, cx| { + window.focus(&focus_handle, cx); + window.activate_window(); + }); + + cx.simulate_keystrokes("ctrl-b"); + + let count_after_pending = Rc::new(RefCell::new(0usize)); + let count_after_pending_for_assertion = count_after_pending.clone(); + + cx.update(|window, cx| { + assert!(window.has_pending_keystrokes()); + *count_after_pending.borrow_mut() = *pending_input_changed_count.borrow(); + assert!(*count_after_pending.borrow() > 0); + + window.focus(&cx.focus_handle(), cx); + + assert!(!window.has_pending_keystrokes()); + }); + + // Focus-triggered pending-input notifications are deferred to the end of the current + // effect cycle, so the observer callback should run after the focus update completes. + cx.update(|_, _| { + let count_after_focus_change = *pending_input_changed_count.borrow(); + assert!(count_after_focus_change > *count_after_pending_for_assertion.borrow()); + }); + } + #[crate::test] fn test_input_handler_pending(cx: &mut TestAppContext) { #[derive(Clone)] @@ -876,8 +1083,9 @@ mod tests { cx.bind_keys([KeyBinding::new("ctrl-b h", TestAction, Some("Terminal"))]); }); let (test, cx) = cx.add_window_view(|_, cx| CustomElement::new(cx)); + let focus_handle = test.update(cx, |test, _| test.focus_handle.clone()); cx.update(|window, cx| { - window.focus(&test.read(cx).focus_handle); + window.focus(&focus_handle, cx); window.activate_window(); }); cx.simulate_keystrokes("ctrl-b ["); diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index c606409661eb022b8627fe9bc9f6c53565f5569f..dd20f71c22e388e0c739083d45941270ac8eac8e 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -345,8 +345,8 @@ impl FocusHandle { } /// Moves the focus to the element associated with this handle. - pub fn focus(&self, window: &mut Window) { - window.focus(self) + pub fn focus(&self, window: &mut Window, cx: &mut App) { + window.focus(self, cx) } /// Obtains whether the element associated with this handle is currently focused. @@ -1436,13 +1436,25 @@ impl Window { } /// Move focus to the element associated with the given [`FocusHandle`]. - pub fn focus(&mut self, handle: &FocusHandle) { + pub fn focus(&mut self, handle: &FocusHandle, cx: &mut App) { if !self.focus_enabled || self.focus == Some(handle.id) { return; } self.focus = Some(handle.id); self.clear_pending_keystrokes(); + + // Avoid re-entrant entity updates by deferring observer notifications to the end of the + // current effect cycle, and only for this window. + let window_handle = self.handle; + cx.defer(move |cx| { + window_handle + .update(cx, |_, window, cx| { + window.pending_input_changed(cx); + }) + .ok(); + }); + self.refresh(); } @@ -1463,24 +1475,24 @@ impl Window { } /// Move focus to next tab stop. - pub fn focus_next(&mut self) { + pub fn focus_next(&mut self, cx: &mut App) { if !self.focus_enabled { return; } if let Some(handle) = self.rendered_frame.tab_stops.next(self.focus.as_ref()) { - self.focus(&handle) + self.focus(&handle, cx) } } /// Move focus to previous tab stop. - pub fn focus_prev(&mut self) { + pub fn focus_prev(&mut self, cx: &mut App) { if !self.focus_enabled { return; } if let Some(handle) = self.rendered_frame.tab_stops.prev(self.focus.as_ref()) { - self.focus(&handle) + self.focus(&handle, cx) } } @@ -4020,7 +4032,7 @@ impl Window { self.dispatch_keystroke_observers(event, None, context_stack, cx); } - fn pending_input_changed(&mut self, cx: &mut App) { + pub(crate) fn pending_input_changed(&mut self, cx: &mut App) { self.pending_input_observers .clone() .retain(&(), |callback| callback(self, cx)); diff --git a/crates/gpui/src/window/prompts.rs b/crates/gpui/src/window/prompts.rs index 63ad1668bec298a6b59d218bf7d4ca7cdce11e8c..980c6f6812405a8fbf4f8c6e24388ab4f967a94c 100644 --- a/crates/gpui/src/window/prompts.rs +++ b/crates/gpui/src/window/prompts.rs @@ -44,10 +44,10 @@ impl PromptHandle { if let Some(sender) = sender.take() { sender.send(e.0).ok(); window_handle - .update(cx, |_, window, _cx| { + .update(cx, |_, window, cx| { window.prompt.take(); if let Some(previous_focus) = &previous_focus { - window.focus(previous_focus); + window.focus(previous_focus, cx); } }) .ok(); @@ -55,7 +55,7 @@ impl PromptHandle { }) .detach(); - window.focus(&view.focus_handle(cx)); + window.focus(&view.focus_handle(cx), cx); RenderablePromptHandle { view: Box::new(view), diff --git a/crates/gpui_macros/src/derive_visual_context.rs b/crates/gpui_macros/src/derive_visual_context.rs index f2681bb29b92f31d31599ebb7201a42a482283d8..b827e753d9678efba01d3fdd77f8e66ea62b6bbd 100644 --- a/crates/gpui_macros/src/derive_visual_context.rs +++ b/crates/gpui_macros/src/derive_visual_context.rs @@ -62,7 +62,7 @@ pub fn derive_visual_context(input: TokenStream) -> TokenStream { V: gpui::Focusable, { let focus_handle = gpui::Focusable::focus_handle(entity, self.#app_variable); - self.#window_variable.focus(&focus_handle) + self.#window_variable.focus(&focus_handle, self.#app_variable) } } }; diff --git a/crates/keymap_editor/src/keymap_editor.rs b/crates/keymap_editor/src/keymap_editor.rs index 9e243d32151e3caeec2b8c51c7889d2ebe93f29b..be20feaf5f8c1feea5b08fa3a6a3b542b26ef5ce 100644 --- a/crates/keymap_editor/src/keymap_editor.rs +++ b/crates/keymap_editor/src/keymap_editor.rs @@ -911,7 +911,7 @@ impl KeymapEditor { .focus_handle(cx) .contains_focused(window, cx) { - window.focus(&self.filter_editor.focus_handle(cx)); + window.focus(&self.filter_editor.focus_handle(cx), cx); } else { self.filter_editor.update(cx, |editor, cx| { editor.select_all(&Default::default(), window, cx); @@ -948,7 +948,7 @@ impl KeymapEditor { if let Some(scroll_strategy) = scroll { self.scroll_to_item(index, scroll_strategy, cx); } - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); cx.notify(); } } @@ -998,7 +998,7 @@ impl KeymapEditor { }); let context_menu_handle = context_menu.focus_handle(cx); - window.defer(cx, move |window, _cx| window.focus(&context_menu_handle)); + window.defer(cx, move |window, cx| window.focus(&context_menu_handle, cx)); let subscription = cx.subscribe_in( &context_menu, window, @@ -1014,7 +1014,7 @@ impl KeymapEditor { fn dismiss_context_menu(&mut self, window: &mut Window, cx: &mut Context) { self.context_menu.take(); - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); cx.notify(); } @@ -1230,7 +1230,7 @@ impl KeymapEditor { window, cx, ); - window.focus(&modal.focus_handle(cx)); + window.focus(&modal.focus_handle(cx), cx); modal }); }) @@ -1338,7 +1338,7 @@ impl KeymapEditor { editor.stop_recording(&StopRecording, window, cx); editor.clear_keystrokes(&ClearKeystrokes, window, cx); }); - window.focus(&self.filter_editor.focus_handle(cx)); + window.focus(&self.filter_editor.focus_handle(cx), cx); } } } @@ -2698,32 +2698,32 @@ impl KeybindingEditorModalFocusState { .map(|i| i as i32) } - fn focus_index(&self, mut index: i32, window: &mut Window) { + fn focus_index(&self, mut index: i32, window: &mut Window, cx: &mut App) { if index < 0 { index = self.handles.len() as i32 - 1; } if index >= self.handles.len() as i32 { index = 0; } - window.focus(&self.handles[index as usize]); + window.focus(&self.handles[index as usize], cx); } - fn focus_next(&self, window: &mut Window, cx: &App) { + fn focus_next(&self, window: &mut Window, cx: &mut App) { let index_to_focus = if let Some(index) = self.focused_index(window, cx) { index + 1 } else { 0 }; - self.focus_index(index_to_focus, window); + self.focus_index(index_to_focus, window, cx); } - fn focus_previous(&self, window: &mut Window, cx: &App) { + fn focus_previous(&self, window: &mut Window, cx: &mut App) { let index_to_focus = if let Some(index) = self.focused_index(window, cx) { index - 1 } else { self.handles.len() as i32 - 1 }; - self.focus_index(index_to_focus, window); + self.focus_index(index_to_focus, window, cx); } } @@ -2757,7 +2757,7 @@ impl ActionArgumentsEditor { ) -> Self { let focus_handle = cx.focus_handle(); cx.on_focus_in(&focus_handle, window, |this, window, cx| { - this.editor.focus_handle(cx).focus(window); + this.editor.focus_handle(cx).focus(window, cx); }) .detach(); let editor = cx.new(|cx| { @@ -2810,7 +2810,7 @@ impl ActionArgumentsEditor { this.update_in(cx, |this, window, cx| { if this.editor.focus_handle(cx).is_focused(window) { - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); } this.editor = editor; this.backup_temp_dir = backup_temp_dir; diff --git a/crates/keymap_editor/src/ui_components/keystroke_input.rs b/crates/keymap_editor/src/ui_components/keystroke_input.rs index 6936de784f9d5c16b218d0952c41d6336299a0f9..496a8ae7e6359bc169845542a0f05800008a4786 100644 --- a/crates/keymap_editor/src/ui_components/keystroke_input.rs +++ b/crates/keymap_editor/src/ui_components/keystroke_input.rs @@ -388,7 +388,7 @@ impl KeystrokeInput { window: &mut Window, cx: &mut Context, ) { - window.focus(&self.inner_focus_handle); + window.focus(&self.inner_focus_handle, cx); self.clear_keystrokes(&ClearKeystrokes, window, cx); self.previous_modifiers = window.modifiers(); #[cfg(test)] @@ -407,7 +407,7 @@ impl KeystrokeInput { if !self.is_recording(window) { return; } - window.focus(&self.outer_focus_handle); + window.focus(&self.outer_focus_handle, cx); if let Some(close_keystrokes_start) = self.close_keystrokes_start.take() && close_keystrokes_start < self.keystrokes.len() { diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs index 9273234161a8169abf68190ca8fe4627b8f769dc..286f9ec1a4bf67c22868cf83e00e7b46e0737ba8 100644 --- a/crates/language_models/src/provider/bedrock.rs +++ b/crates/language_models/src/provider/bedrock.rs @@ -1298,17 +1298,17 @@ impl ConfigurationView { self.state.read(cx).is_authenticated() } - fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, _: &mut Context) { - window.focus_next(); + fn on_tab(&mut self, _: &menu::SelectNext, window: &mut Window, cx: &mut Context) { + window.focus_next(cx); } fn on_tab_prev( &mut self, _: &menu::SelectPrevious, window: &mut Window, - _: &mut Context, + cx: &mut Context, ) { - window.focus_prev(); + window.focus_prev(cx); } } diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs index 314dcc0b9bde998a0fec65b2847ae13641f0d011..6fc061cd07edd9e22609ba698f27860b1b905765 100644 --- a/crates/language_tools/src/lsp_log_view.rs +++ b/crates/language_tools/src/lsp_log_view.rs @@ -269,7 +269,7 @@ impl LspLogView { let focus_handle = cx.focus_handle(); let focus_subscription = cx.on_focus(&focus_handle, window, |log_view, window, cx| { - window.focus(&log_view.editor.focus_handle(cx)); + window.focus(&log_view.editor.focus_handle(cx), cx); }); cx.on_release(|log_view, cx| { @@ -462,7 +462,7 @@ impl LspLogView { self.editor_subscriptions = editor_subscriptions; cx.notify(); } - self.editor.read(cx).focus_handle(cx).focus(window); + self.editor.read(cx).focus_handle(cx).focus(window, cx); self.log_store.update(cx, |log_store, cx| { let state = log_store.get_language_server_state(server_id)?; state.toggled_log_kind = Some(LogKind::Logs); @@ -494,7 +494,7 @@ impl LspLogView { cx.notify(); } - self.editor.read(cx).focus_handle(cx).focus(window); + self.editor.read(cx).focus_handle(cx).focus(window, cx); } fn show_trace_for_server( @@ -528,7 +528,7 @@ impl LspLogView { }); cx.notify(); } - self.editor.read(cx).focus_handle(cx).focus(window); + self.editor.read(cx).focus_handle(cx).focus(window, cx); } fn show_rpc_trace_for_server( @@ -572,7 +572,7 @@ impl LspLogView { cx.notify(); } - self.editor.read(cx).focus_handle(cx).focus(window); + self.editor.read(cx).focus_handle(cx).focus(window, cx); } fn toggle_rpc_trace_for_server( @@ -660,7 +660,7 @@ impl LspLogView { self.editor = editor; self.editor_subscriptions = editor_subscriptions; cx.notify(); - self.editor.read(cx).focus_handle(cx).focus(window); + self.editor.read(cx).focus_handle(cx).focus(window, cx); self.log_store.update(cx, |log_store, cx| { let state = log_store.get_language_server_state(server_id)?; if let Some(log_kind) = state.toggled_log_kind.take() { @@ -1314,7 +1314,7 @@ impl LspLogToolbarItemView { log_view.show_rpc_trace_for_server(id, window, cx); cx.notify(); } - window.focus(&log_view.focus_handle); + window.focus(&log_view.focus_handle, cx); }); } cx.notify(); diff --git a/crates/language_tools/src/syntax_tree_view.rs b/crates/language_tools/src/syntax_tree_view.rs index 0fbcdcca5eca80a01738888266389db5a678f3e8..15776e07d6d18835885ac5bafb2b29191d9e6bed 100644 --- a/crates/language_tools/src/syntax_tree_view.rs +++ b/crates/language_tools/src/syntax_tree_view.rs @@ -659,7 +659,7 @@ impl SyntaxTreeToolbarItemView { buffer_state.active_layer = Some(layer.to_owned()); view.selected_descendant_ix = None; cx.notify(); - view.focus_handle.focus(window); + view.focus_handle.focus(window, cx); Some(()) }) } diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs index 706fe894699afe8d1ae32c0525214ec6bf614912..0bc3b9eb726e1782bafb2a31229ea21f308adc6e 100644 --- a/crates/markdown/src/markdown.rs +++ b/crates/markdown/src/markdown.rs @@ -707,7 +707,7 @@ impl MarkdownElement { pending: true, mode, }; - window.focus(&markdown.focus_handle); + window.focus(&markdown.focus_handle, cx); } window.prevent_default(); diff --git a/crates/markdown_preview/src/markdown_preview_view.rs b/crates/markdown_preview/src/markdown_preview_view.rs index 20613b112eeccf76ec8be12bddc49c12b600ff9b..650f369309561d76669289737277b45fb99af5ec 100644 --- a/crates/markdown_preview/src/markdown_preview_view.rs +++ b/crates/markdown_preview/src/markdown_preview_view.rs @@ -96,7 +96,7 @@ impl MarkdownPreviewView { pane.add_item(Box::new(view.clone()), false, false, None, window, cx) } }); - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); cx.notify(); } }); @@ -370,7 +370,7 @@ impl MarkdownPreviewView { cx, |selections| selections.select_ranges(vec![selection]), ); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); }); } } diff --git a/crates/onboarding/src/onboarding.rs b/crates/onboarding/src/onboarding.rs index 66402f33d31c6e9ce5894c56872c8d92d2c4c36c..495a55411fc936d476dfa0d443e155d1fa7faecd 100644 --- a/crates/onboarding/src/onboarding.rs +++ b/crates/onboarding/src/onboarding.rs @@ -190,7 +190,7 @@ pub fn show_onboarding_view(app_state: Arc, cx: &mut App) -> Task(); - window.focus(&active_editor.focus_handle(cx)); + window.focus(&active_editor.focus_handle(cx), cx); } }); diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs index 8dbf7b681d9be45bda0fd9803cbb8e2cd434e921..5a32bd73b74a9e8caade1042a381983af0da71d3 100644 --- a/crates/outline_panel/src/outline_panel.rs +++ b/crates/outline_panel/src/outline_panel.rs @@ -998,9 +998,9 @@ impl OutlinePanel { fn cancel(&mut self, _: &Cancel, window: &mut Window, cx: &mut Context) { if self.filter_editor.focus_handle(cx).is_focused(window) { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } else { - self.filter_editor.focus_handle(cx).focus(window); + self.filter_editor.focus_handle(cx).focus(window, cx); } if self.context_menu.is_some() { @@ -1153,9 +1153,9 @@ impl OutlinePanel { } if change_focus { - active_editor.focus_handle(cx).focus(window); + active_editor.focus_handle(cx).focus(window, cx); } else { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } } } @@ -1458,7 +1458,7 @@ impl OutlinePanel { Box::new(zed_actions::workspace::CopyRelativePath), ) }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe(&context_menu, |outline_panel, _, _: &DismissEvent, cx| { outline_panel.context_menu.take(); cx.notify(); @@ -4539,7 +4539,7 @@ impl OutlinePanel { cx: &mut Context, ) { if focus { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } let ix = self .cached_entries diff --git a/crates/picker/src/picker.rs b/crates/picker/src/picker.rs index 3d6ae27dfa0c6b60088995de6ccc1d85b08c9428..2da40b5bf4b47651df7236b0decb25fac67a3b1b 100644 --- a/crates/picker/src/picker.rs +++ b/crates/picker/src/picker.rs @@ -384,7 +384,7 @@ impl Picker { } pub fn focus(&self, window: &mut Window, cx: &mut App) { - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); } /// Handles the selecting an index, and passing the change to the delegate. diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs index ea667ecbb479ca347914ee11ec789a14f29cf474..00aba96ef428eea643e8868e513ab9c3aaa1b910 100644 --- a/crates/project_panel/src/project_panel.rs +++ b/crates/project_panel/src/project_panel.rs @@ -880,7 +880,7 @@ impl ProjectPanel { }); if !focus_opened_item { let focus_handle = project_panel.read(cx).focus_handle.clone(); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); } } } @@ -1169,7 +1169,7 @@ impl ProjectPanel { }) }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe(&context_menu, |this, _, _: &DismissEvent, cx| { this.context_menu.take(); cx.notify(); @@ -1376,7 +1376,7 @@ impl ProjectPanel { } }); self.update_visible_entries(Some((worktree_id, entry_id)), false, false, window, cx); - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); cx.notify(); } } @@ -1399,7 +1399,7 @@ impl ProjectPanel { } } self.update_visible_entries(Some((worktree_id, entry_id)), false, false, window, cx); - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); cx.notify(); } } @@ -1719,7 +1719,7 @@ impl ProjectPanel { }; if let Some(existing) = worktree.read(cx).entry_for_path(&new_path) { if existing.id == entry.id && refocus { - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } return None; } @@ -1730,7 +1730,7 @@ impl ProjectPanel { }; if refocus { - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); } edit_state.processing_filename = Some(filename); cx.notify(); @@ -1839,7 +1839,7 @@ impl ProjectPanel { self.autoscroll(cx); } - window.focus(&self.focus_handle); + window.focus(&self.focus_handle, cx); cx.notify(); } @@ -3616,7 +3616,7 @@ impl ProjectPanel { if this.update_visible_entries_task.focus_filename_editor { this.update_visible_entries_task.focus_filename_editor = false; this.filename_editor.update(cx, |editor, cx| { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); }); } if this.update_visible_entries_task.autoscroll { @@ -5952,7 +5952,7 @@ impl Render for ProjectPanel { cx.stop_propagation(); this.state.selection = None; this.marked_entries.clear(); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); })) .on_mouse_down( MouseButton::Right, diff --git a/crates/recent_projects/src/remote_connections.rs b/crates/recent_projects/src/remote_connections.rs index e8349601b5303331c0a6a38aca306fe57ab07ed3..1bab31b4d0ebb80444c40c99feb984ebd23feb60 100644 --- a/crates/recent_projects/src/remote_connections.rs +++ b/crates/recent_projects/src/remote_connections.rs @@ -209,7 +209,7 @@ impl RemoteConnectionPrompt { let markdown = cx.new(|cx| Markdown::new_text(prompt.into(), cx)); self.prompt = Some((markdown, tx)); self.status_message.take(); - window.focus(&self.editor.focus_handle(cx)); + window.focus(&self.editor.focus_handle(cx), cx); cx.notify(); } diff --git a/crates/recent_projects/src/remote_servers.rs b/crates/recent_projects/src/remote_servers.rs index a4388c6026ab7aa6bbdfc75d025e095b5a2a6187..15735b6664e4b72749b0149013d02428eb2735de 100644 --- a/crates/recent_projects/src/remote_servers.rs +++ b/crates/recent_projects/src/remote_servers.rs @@ -76,7 +76,7 @@ impl CreateRemoteServer { fn new(window: &mut Window, cx: &mut App) -> Self { let address_editor = cx.new(|cx| Editor::single_line(window, cx)); address_editor.update(cx, |this, cx| { - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); }); Self { address_editor, @@ -107,7 +107,7 @@ struct CreateRemoteDevContainer { impl CreateRemoteDevContainer { fn new(window: &mut Window, cx: &mut Context) -> Self { let entries = std::array::from_fn(|_| NavigableEntry::focusable(cx)); - entries[0].focus_handle.focus(window); + entries[0].focus_handle.focus(window, cx); Self { entries, progress: DevContainerCreationProgress::Initial, @@ -199,7 +199,7 @@ impl EditNicknameState { this.set_text(starting_text, window, cx); } }); - this.editor.focus_handle(cx).focus(window); + this.editor.focus_handle(cx).focus(window, cx); this } } @@ -792,7 +792,7 @@ impl RemoteServerProjects { this.retained_connections.push(client); this.add_ssh_server(connection_options, cx); this.mode = Mode::default_mode(&this.ssh_config_servers, cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); cx.notify() }) .log_err(), @@ -875,7 +875,7 @@ impl RemoteServerProjects { crate::add_wsl_distro(fs, &connection_options, cx); this.mode = Mode::default_mode(&BTreeSet::new(), cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); cx.notify(); }), _ => this.update(cx, |this, cx| { @@ -924,7 +924,7 @@ impl RemoteServerProjects { return; } }); - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); cx.notify(); } @@ -933,7 +933,7 @@ impl RemoteServerProjects { CreateRemoteDevContainer::new(window, cx) .progress(DevContainerCreationProgress::Creating), ); - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); cx.notify(); } @@ -1068,7 +1068,7 @@ impl RemoteServerProjects { } }); self.mode = Mode::default_mode(&self.ssh_config_servers, cx); - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } #[cfg(target_os = "windows")] Mode::AddWslDistro(state) => { @@ -1094,7 +1094,7 @@ impl RemoteServerProjects { } _ => { self.mode = Mode::default_mode(&self.ssh_config_servers, cx); - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); cx.notify(); } } @@ -1640,7 +1640,7 @@ impl RemoteServerProjects { ) -> impl IntoElement { match &state.progress { DevContainerCreationProgress::Error(message) => { - self.focus_handle(cx).focus(window); + self.focus_handle(cx).focus(window, cx); return div() .track_focus(&self.focus_handle(cx)) .size_full() @@ -1952,7 +1952,7 @@ impl RemoteServerProjects { let connection_prompt = state.connection_prompt.clone(); state.picker.update(cx, |picker, cx| { - picker.focus_handle(cx).focus(window); + picker.focus_handle(cx).focus(window, cx); }); v_flex() @@ -2752,7 +2752,7 @@ impl Render for RemoteServerProjects { .on_action(cx.listener(Self::cancel)) .on_action(cx.listener(Self::confirm)) .capture_any_mouse_down(cx.listener(|this, _, window, cx| { - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); })) .on_mouse_down_out(cx.listener(|this, _, _, cx| { if matches!(this.mode, Mode::Default(_)) { diff --git a/crates/rules_library/src/rules_library.rs b/crates/rules_library/src/rules_library.rs index 00cf939f7af45f7701cd9d3599a103ece4a6f393..642d6b64f79ed0f52b9cdb7feee900cf87af83cc 100644 --- a/crates/rules_library/src/rules_library.rs +++ b/crates/rules_library/src/rules_library.rs @@ -720,7 +720,7 @@ impl RulesLibrary { if focus { rule_editor .body_editor - .update(cx, |editor, cx| window.focus(&editor.focus_handle(cx))); + .update(cx, |editor, cx| window.focus(&editor.focus_handle(cx), cx)); } self.set_active_rule(Some(prompt_id), window, cx); } else if let Some(rule_metadata) = self.store.read(cx).metadata(prompt_id) { @@ -763,7 +763,7 @@ impl RulesLibrary { editor.set_current_line_highlight(Some(CurrentLineHighlight::None)); editor.set_completion_provider(Some(make_completion_provider())); if focus { - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); } editor }); @@ -939,7 +939,7 @@ impl RulesLibrary { if let Some(active_rule) = self.active_rule_id { self.rule_editors[&active_rule] .body_editor - .update(cx, |editor, cx| window.focus(&editor.focus_handle(cx))); + .update(cx, |editor, cx| window.focus(&editor.focus_handle(cx), cx)); cx.stop_propagation(); } } @@ -998,7 +998,7 @@ impl RulesLibrary { if let Some(rule_id) = self.active_rule_id && let Some(rule_editor) = self.rule_editors.get(&rule_id) { - window.focus(&rule_editor.body_editor.focus_handle(cx)); + window.focus(&rule_editor.body_editor.focus_handle(cx), cx); } } @@ -1011,7 +1011,7 @@ impl RulesLibrary { if let Some(rule_id) = self.active_rule_id && let Some(rule_editor) = self.rule_editors.get(&rule_id) { - window.focus(&rule_editor.title_editor.focus_handle(cx)); + window.focus(&rule_editor.title_editor.focus_handle(cx), cx); } } @@ -1308,8 +1308,8 @@ impl RulesLibrary { .size_full() .relative() .overflow_hidden() - .on_click(cx.listener(move |_, _, window, _| { - window.focus(&focus_handle); + .on_click(cx.listener(move |_, _, window, cx| { + window.focus(&focus_handle, cx); })) .child( h_flex() diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs index 686d385aa07accac168062fa598790b36e80199f..66641e91a882b0b994e16673e3c65a1d51f27650 100644 --- a/crates/search/src/buffer_search.rs +++ b/crates/search/src/buffer_search.rs @@ -518,7 +518,7 @@ impl BufferSearchBar { pub fn register(registrar: &mut impl SearchActionsRegistrar) { registrar.register_handler(ForDeployed(|this, _: &FocusSearch, window, cx| { - this.query_editor.focus_handle(cx).focus(window); + this.query_editor.focus_handle(cx).focus(window, cx); this.select_query(window, cx); })); registrar.register_handler(ForDeployed( @@ -706,7 +706,7 @@ impl BufferSearchBar { active_editor.search_bar_visibility_changed(false, window, cx); active_editor.toggle_filtered_search_ranges(None, window, cx); let handle = active_editor.item_focus_handle(cx); - self.focus(&handle, window); + self.focus(&handle, window, cx); } cx.emit(Event::UpdateLocation); @@ -749,7 +749,7 @@ impl BufferSearchBar { self.select_query(window, cx); } - window.focus(&handle); + window.focus(&handle, cx); } return true; } @@ -878,7 +878,7 @@ impl BufferSearchBar { } pub fn focus_replace(&mut self, window: &mut Window, cx: &mut Context) { - self.focus(&self.replacement_editor.focus_handle(cx), window); + self.focus(&self.replacement_editor.focus_handle(cx), window, cx); cx.notify(); } @@ -909,7 +909,7 @@ impl BufferSearchBar { pub fn focus_editor(&mut self, _: &FocusEditor, window: &mut Window, cx: &mut Context) { if let Some(active_editor) = self.active_searchable_item.as_ref() { let handle = active_editor.item_focus_handle(cx); - window.focus(&handle); + window.focus(&handle, cx); } } @@ -1384,7 +1384,7 @@ impl BufferSearchBar { Direction::Prev => (current_index - 1) % handles.len(), }; let next_focus_handle = &handles[new_index]; - self.focus(next_focus_handle, window); + self.focus(next_focus_handle, window, cx); cx.stop_propagation(); } @@ -1431,9 +1431,9 @@ impl BufferSearchBar { } } - fn focus(&self, handle: &gpui::FocusHandle, window: &mut Window) { + fn focus(&self, handle: &gpui::FocusHandle, window: &mut Window, cx: &mut App) { window.invalidate_character_coordinates(); - window.focus(handle); + window.focus(handle, cx); } fn toggle_replace(&mut self, _: &ToggleReplace, window: &mut Window, cx: &mut Context) { @@ -1444,7 +1444,7 @@ impl BufferSearchBar { } else { self.query_editor.focus_handle(cx) }; - self.focus(&handle, window); + self.focus(&handle, window, cx); cx.notify(); } } @@ -2038,7 +2038,7 @@ mod tests { .update(cx, |_, window, cx| { search_bar.update(cx, |search_bar, cx| { let handle = search_bar.query_editor.focus_handle(cx); - window.focus(&handle); + window.focus(&handle, cx); search_bar.activate_current_match(window, cx); }); assert!( @@ -2056,7 +2056,7 @@ mod tests { search_bar.update(cx, |search_bar, cx| { assert_eq!(search_bar.active_match_index, Some(0)); let handle = search_bar.query_editor.focus_handle(cx); - window.focus(&handle); + window.focus(&handle, cx); search_bar.select_all_matches(&SelectAllMatches, window, cx); }); assert!( @@ -2109,7 +2109,7 @@ mod tests { "Match index should be updated to the next one" ); let handle = search_bar.query_editor.focus_handle(cx); - window.focus(&handle); + window.focus(&handle, cx); search_bar.select_all_matches(&SelectAllMatches, window, cx); }); }) @@ -2175,7 +2175,7 @@ mod tests { .update(cx, |_, window, cx| { search_bar.update(cx, |search_bar, cx| { let handle = search_bar.query_editor.focus_handle(cx); - window.focus(&handle); + window.focus(&handle, cx); search_bar.search("abas_nonexistent_match", None, true, window, cx) }) }) diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rs index 278f2e86b7b13fd5a82777054c12ff2e1b6239bb..e0bbf58ce6f1d0c752914bbbfa6fcdf70ea30175 100644 --- a/crates/search/src/project_search.rs +++ b/crates/search/src/project_search.rs @@ -954,9 +954,9 @@ impl ProjectSearchView { cx.on_next_frame(window, |this, window, cx| { if this.focus_handle.is_focused(window) { if this.has_matches() { - this.results_editor.focus_handle(cx).focus(window); + this.results_editor.focus_handle(cx).focus(window, cx); } else { - this.query_editor.focus_handle(cx).focus(window); + this.query_editor.focus_handle(cx).focus(window, cx); } } }); @@ -1453,7 +1453,7 @@ impl ProjectSearchView { query_editor.select_all(&SelectAll, window, cx); }); let editor_handle = self.query_editor.focus_handle(cx); - window.focus(&editor_handle); + window.focus(&editor_handle, cx); } fn set_query(&mut self, query: &str, window: &mut Window, cx: &mut Context) { @@ -1493,7 +1493,7 @@ impl ProjectSearchView { }); }); let results_handle = self.results_editor.focus_handle(cx); - window.focus(&results_handle); + window.focus(&results_handle, cx); } fn entity_changed(&mut self, window: &mut Window, cx: &mut Context) { @@ -1750,7 +1750,7 @@ impl ProjectSearchBar { fn focus_search(&mut self, window: &mut Window, cx: &mut Context) { if let Some(search_view) = self.active_project_search.as_ref() { search_view.update(cx, |search_view, cx| { - search_view.query_editor.focus_handle(cx).focus(window); + search_view.query_editor.focus_handle(cx).focus(window, cx); }); } } @@ -1783,7 +1783,7 @@ impl ProjectSearchBar { Direction::Prev => (current_index - 1) % views.len(), }; let next_focus_handle = &views[new_index]; - window.focus(next_focus_handle); + window.focus(next_focus_handle, cx); cx.stop_propagation(); }); } @@ -1832,7 +1832,7 @@ impl ProjectSearchBar { } else { this.query_editor.focus_handle(cx) }; - window.focus(&editor_to_focus); + window.focus(&editor_to_focus, cx); cx.notify(); }); } @@ -4352,7 +4352,7 @@ pub mod tests { let buffer_search_query = "search bar query"; buffer_search_bar .update_in(&mut cx, |buffer_search_bar, window, cx| { - buffer_search_bar.focus_handle(cx).focus(window); + buffer_search_bar.focus_handle(cx).focus(window, cx); buffer_search_bar.search(buffer_search_query, None, true, window, cx) }) .await diff --git a/crates/search/src/search.rs b/crates/search/src/search.rs index 6663f8c3184aba9fedbcd5faa3d80d5889181074..3aa40894ea91ed7af3441fad210f6ce0f9e1dd53 100644 --- a/crates/search/src/search.rs +++ b/crates/search/src/search.rs @@ -143,7 +143,7 @@ impl SearchOption { let focus_handle = focus_handle.clone(); button.on_click(move |_: &ClickEvent, window, cx| { if !focus_handle.is_focused(window) { - window.focus(&focus_handle); + window.focus(&focus_handle, cx); } window.dispatch_action(action.boxed_clone(), cx); }) diff --git a/crates/search/src/search_bar.rs b/crates/search/src/search_bar.rs index 13b4df9574aa6b2568dd6db25c6b63551d9b6d03..a1f6c070724c4d57b438c452ef4b4ae3cf20e66d 100644 --- a/crates/search/src/search_bar.rs +++ b/crates/search/src/search_bar.rs @@ -27,7 +27,7 @@ pub(super) fn render_action_button( let focus_handle = focus_handle.clone(); move |_, window, cx| { if !focus_handle.is_focused(window) { - window.focus(&focus_handle); + window.focus(&focus_handle, cx); } window.dispatch_action(action.boxed_clone(), cx); } diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs index 101f52159a263910fba0d65782f06784f8183fd0..0ec6d0aee308ce3c20b67a5db9c6a6d9224bf229 100644 --- a/crates/settings_ui/src/settings_ui.rs +++ b/crates/settings_ui/src/settings_ui.rs @@ -345,8 +345,8 @@ impl NonFocusableHandle { fn from_handle(handle: FocusHandle, window: &mut Window, cx: &mut App) -> Entity { cx.new(|cx| { let _subscription = cx.on_focus(&handle, window, { - move |_, window, _| { - window.focus_next(); + move |_, window, cx| { + window.focus_next(cx); } }); Self { @@ -1537,7 +1537,7 @@ impl SettingsWindow { this.build_search_index(); this.search_bar.update(cx, |editor, cx| { - editor.focus_handle(cx).focus(window); + editor.focus_handle(cx).focus(window, cx); }); this @@ -2174,7 +2174,7 @@ impl SettingsWindow { let focus_handle = focus_handle.clone(); move |this, _: &gpui::ClickEvent, window, cx| { this.change_file(ix, window, cx); - focus_handle.focus(window); + focus_handle.focus(window, cx); } })) }; @@ -2251,7 +2251,7 @@ impl SettingsWindow { this.update(cx, |this, cx| { this.change_file(ix, window, cx); }); - focus_handle.focus(window); + focus_handle.focus(window, cx); } }, ); @@ -2385,7 +2385,7 @@ impl SettingsWindow { let focused_entry_parent = this.root_entry_containing(focused_entry); if this.navbar_entries[focused_entry_parent].expanded { this.toggle_navbar_entry(focused_entry_parent); - window.focus(&this.navbar_entries[focused_entry_parent].focus_handle); + window.focus(&this.navbar_entries[focused_entry_parent].focus_handle, cx); } cx.notify(); })) @@ -2534,6 +2534,7 @@ impl SettingsWindow { window.focus( &this.navbar_entries[entry_index] .focus_handle, + cx, ); cx.notify(); }, @@ -2658,7 +2659,7 @@ impl SettingsWindow { // back to back. cx.on_next_frame(window, move |_, window, cx| { if let Some(handle) = handle_to_focus.as_ref() { - window.focus(handle); + window.focus(handle, cx); } cx.on_next_frame(window, |_, _, cx| { @@ -2725,7 +2726,7 @@ impl SettingsWindow { }; self.navbar_scroll_handle .scroll_to_item(position, gpui::ScrollStrategy::Top); - window.focus(&self.navbar_entries[nav_entry_index].focus_handle); + window.focus(&self.navbar_entries[nav_entry_index].focus_handle, cx); cx.notify(); } @@ -3100,7 +3101,7 @@ impl SettingsWindow { .id("settings-ui-page") .on_action(cx.listener(|this, _: &menu::SelectNext, window, cx| { if !sub_page_stack().is_empty() { - window.focus_next(); + window.focus_next(cx); return; } for (logical_index, (actual_index, _)) in this.visible_page_items().enumerate() { @@ -3120,7 +3121,7 @@ impl SettingsWindow { cx.on_next_frame(window, |_, window, cx| { cx.notify(); cx.on_next_frame(window, |_, window, cx| { - window.focus_next(); + window.focus_next(cx); cx.notify(); }); }); @@ -3128,11 +3129,11 @@ impl SettingsWindow { return; } } - window.focus_next(); + window.focus_next(cx); })) .on_action(cx.listener(|this, _: &menu::SelectPrevious, window, cx| { if !sub_page_stack().is_empty() { - window.focus_prev(); + window.focus_prev(cx); return; } let mut prev_was_header = false; @@ -3152,7 +3153,7 @@ impl SettingsWindow { cx.on_next_frame(window, |_, window, cx| { cx.notify(); cx.on_next_frame(window, |_, window, cx| { - window.focus_prev(); + window.focus_prev(cx); cx.notify(); }); }); @@ -3161,7 +3162,7 @@ impl SettingsWindow { } prev_was_header = is_header; } - window.focus_prev(); + window.focus_prev(cx); })) .when(sub_page_stack().is_empty(), |this| { this.vertical_scrollbar_for(&self.list_state, window, cx) @@ -3364,19 +3365,19 @@ impl SettingsWindow { }); self.sub_page_scroll_handle .set_offset(point(px(0.), px(0.))); - self.content_focus_handle.focus_handle(cx).focus(window); + self.content_focus_handle.focus_handle(cx).focus(window, cx); cx.notify(); } fn pop_sub_page(&mut self, window: &mut Window, cx: &mut Context) { sub_page_stack_mut().pop(); - self.content_focus_handle.focus_handle(cx).focus(window); + self.content_focus_handle.focus_handle(cx).focus(window, cx); cx.notify(); } - fn focus_file_at_index(&mut self, index: usize, window: &mut Window) { + fn focus_file_at_index(&mut self, index: usize, window: &mut Window, cx: &mut App) { if let Some((_, handle)) = self.files.get(index) { - handle.focus(window); + handle.focus(window, cx); } } @@ -3456,7 +3457,7 @@ impl Render for SettingsWindow { window.minimize_window(); }) .on_action(cx.listener(|this, _: &search::FocusSearch, window, cx| { - this.search_bar.focus_handle(cx).focus(window); + this.search_bar.focus_handle(cx).focus(window, cx); })) .on_action(cx.listener(|this, _: &ToggleFocusNav, window, cx| { if this @@ -3476,8 +3477,8 @@ impl Render for SettingsWindow { } })) .on_action(cx.listener( - |this, FocusFile(file_index): &FocusFile, window, _| { - this.focus_file_at_index(*file_index as usize, window); + |this, FocusFile(file_index): &FocusFile, window, cx| { + this.focus_file_at_index(*file_index as usize, window, cx); }, )) .on_action(cx.listener(|this, _: &FocusNextFile, window, cx| { @@ -3485,11 +3486,11 @@ impl Render for SettingsWindow { this.focused_file_index(window, cx) + 1, this.files.len().saturating_sub(1), ); - this.focus_file_at_index(next_index, window); + this.focus_file_at_index(next_index, window, cx); })) .on_action(cx.listener(|this, _: &FocusPreviousFile, window, cx| { let prev_index = this.focused_file_index(window, cx).saturating_sub(1); - this.focus_file_at_index(prev_index, window); + this.focus_file_at_index(prev_index, window, cx); })) .on_action(cx.listener(|this, _: &menu::SelectNext, window, cx| { if this @@ -3499,11 +3500,11 @@ impl Render for SettingsWindow { { this.focus_and_scroll_to_first_visible_nav_entry(window, cx); } else { - window.focus_next(); + window.focus_next(cx); } })) - .on_action(|_: &menu::SelectPrevious, window, _| { - window.focus_prev(); + .on_action(|_: &menu::SelectPrevious, window, cx| { + window.focus_prev(cx); }) .flex() .flex_row() diff --git a/crates/terminal_view/src/terminal_element.rs b/crates/terminal_view/src/terminal_element.rs index fd9568b0c582d4c191267183e296976f3d429eb3..b5324b7c6c7e0c467c657b122717fbf17cf9f7b9 100644 --- a/crates/terminal_view/src/terminal_element.rs +++ b/crates/terminal_view/src/terminal_element.rs @@ -632,7 +632,7 @@ impl TerminalElement { ) -> impl Fn(&E, &mut Window, &mut App) { move |event, window, cx| { if steal_focus { - window.focus(&focus_handle); + window.focus(&focus_handle, cx); } else if !focus_handle.is_focused(window) { return; } @@ -661,7 +661,7 @@ impl TerminalElement { let terminal_view = terminal_view.clone(); move |e, window, cx| { - window.focus(&focus); + window.focus(&focus, cx); let scroll_top = terminal_view.read(cx).scroll_top; terminal.update(cx, |terminal, cx| { diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs index fb660e759c75aee9752cbaa3bdc8c8e0a47615e3..85c6b81f406597e097cabc27408d3df70aad6395 100644 --- a/crates/terminal_view/src/terminal_panel.rs +++ b/crates/terminal_view/src/terminal_panel.rs @@ -351,7 +351,7 @@ impl TerminalPanel { } else if let Some(focus_on_pane) = focus_on_pane.as_ref().or_else(|| self.center.panes().pop()) { - focus_on_pane.focus_handle(cx).focus(window); + focus_on_pane.focus_handle(cx).focus(window, cx); } } pane::Event::ZoomIn => { @@ -397,7 +397,7 @@ impl TerminalPanel { .center .split(&pane, &new_pane, direction, cx) .log_err(); - window.focus(&new_pane.focus_handle(cx)); + window.focus(&new_pane.focus_handle(cx), cx); }) .ok(); }) @@ -419,7 +419,7 @@ impl TerminalPanel { pane.add_item(item, true, true, None, window, cx); }); self.center.split(&pane, &new_pane, direction, cx).log_err(); - window.focus(&new_pane.focus_handle(cx)); + window.focus(&new_pane.focus_handle(cx), cx); } } pane::Event::Focus => { @@ -998,7 +998,7 @@ impl TerminalPanel { RevealStrategy::NoFocus => match reveal_target { RevealTarget::Center => { task_workspace.update_in(cx, |workspace, window, cx| { - workspace.active_pane().focus_handle(cx).focus(window); + workspace.active_pane().focus_handle(cx).focus(window, cx); })?; } RevealTarget::Dock => { @@ -1053,7 +1053,7 @@ impl TerminalPanel { .center .find_pane_in_direction(&self.active_pane, direction, cx) { - window.focus(&pane.focus_handle(cx)); + window.focus(&pane.focus_handle(cx), cx); } else { self.workspace .update(cx, |workspace, cx| { @@ -1297,7 +1297,7 @@ fn add_paths_to_terminal( .active_item() .and_then(|item| item.downcast::()) { - window.focus(&terminal_view.focus_handle(cx)); + window.focus(&terminal_view.focus_handle(cx), cx); let mut new_text = paths.iter().map(|path| format!(" {path:?}")).join(""); new_text.push(' '); terminal_view.update(cx, |terminal_view, cx| { @@ -1451,7 +1451,7 @@ impl Render for TerminalPanel { .position(|pane| **pane == terminal_panel.active_pane) { let next_ix = (ix + 1) % panes.len(); - window.focus(&panes[next_ix].focus_handle(cx)); + window.focus(&panes[next_ix].focus_handle(cx), cx); } }), ) @@ -1463,7 +1463,7 @@ impl Render for TerminalPanel { .position(|pane| **pane == terminal_panel.active_pane) { let prev_ix = cmp::min(ix.wrapping_sub(1), panes.len() - 1); - window.focus(&panes[prev_ix].focus_handle(cx)); + window.focus(&panes[prev_ix].focus_handle(cx), cx); } }, )) @@ -1471,7 +1471,7 @@ impl Render for TerminalPanel { cx.listener(|terminal_panel, action: &ActivatePane, window, cx| { let panes = terminal_panel.center.panes(); if let Some(&pane) = panes.get(action.0) { - window.focus(&pane.read(cx).focus_handle(cx)); + window.focus(&pane.read(cx).focus_handle(cx), cx); } else { let future = terminal_panel.new_pane_with_cloned_active_terminal(window, cx); @@ -1490,7 +1490,7 @@ impl Render for TerminalPanel { ) .log_err(); let new_pane = new_pane.read(cx); - window.focus(&new_pane.focus_handle(cx)); + window.focus(&new_pane.focus_handle(cx), cx); }, ); } diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs index 98f7a17a2778e05b258f2ab6135cb94ba91ba547..54808934ba7b098a695a8b104a048a379966e6f1 100644 --- a/crates/terminal_view/src/terminal_view.rs +++ b/crates/terminal_view/src/terminal_view.rs @@ -409,7 +409,7 @@ impl TerminalView { ) }); - window.focus(&context_menu.focus_handle(cx)); + window.focus(&context_menu.focus_handle(cx), cx); let subscription = cx.subscribe_in( &context_menu, window, diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs index 608fea7383176460cb4b7519824cd2dc118dbb69..23572677919509d859a141cb09cce8f5822697ef 100644 --- a/crates/title_bar/src/title_bar.rs +++ b/crates/title_bar/src/title_bar.rs @@ -605,7 +605,7 @@ impl TitleBar { }) .on_click(move |_, window, cx| { let _ = workspace.update(cx, |this, cx| { - window.focus(&this.active_pane().focus_handle(cx)); + window.focus(&this.active_pane().focus_handle(cx), cx); window.dispatch_action(zed_actions::git::Branch.boxed_clone(), cx); }); }) diff --git a/crates/toolchain_selector/src/toolchain_selector.rs b/crates/toolchain_selector/src/toolchain_selector.rs index b58b2f8d699f59c15525c452543cf5bdf071ad2c..f7262c248f15f0f68fcd7a903ee01cac6b22d0af 100644 --- a/crates/toolchain_selector/src/toolchain_selector.rs +++ b/crates/toolchain_selector/src/toolchain_selector.rs @@ -225,7 +225,7 @@ impl AddToolchainState { ); }); *input_state = Self::wait_for_path(rx, window, cx); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); } }); return Err(anyhow::anyhow!("Failed to resolve toolchain")); @@ -260,7 +260,7 @@ impl AddToolchainState { toolchain, scope_picker, }; - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); }); Result::<_, anyhow::Error>::Ok(()) @@ -333,7 +333,7 @@ impl AddToolchainState { }); _ = self.weak.update(cx, |this, cx| { this.state = State::Search((this.create_search_state)(window, cx)); - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); cx.notify(); }); } @@ -383,7 +383,7 @@ impl Render for AddToolchainState { &weak, |this: &mut ToolchainSelector, _: &menu::Cancel, window, cx| { this.state = State::Search((this.create_search_state)(window, cx)); - this.state.focus_handle(cx).focus(window); + this.state.focus_handle(cx).focus(window, cx); cx.notify(); }, )) @@ -703,7 +703,7 @@ impl ToolchainSelector { window, cx, )); - self.state.focus_handle(cx).focus(window); + self.state.focus_handle(cx).focus(window, cx); cx.notify(); } } diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs index a4bae647408f860ec8425266a26efc173099f225..756a2a9364193d6f1cdace8ed8c92cecf401a864 100644 --- a/crates/ui/src/components/context_menu.rs +++ b/crates/ui/src/components/context_menu.rs @@ -562,7 +562,7 @@ impl ContextMenu { action: Some(action.boxed_clone()), handler: Rc::new(move |context, window, cx| { if let Some(context) = &context { - window.focus(context); + window.focus(context, cx); } window.dispatch_action(action.boxed_clone(), cx); }), @@ -594,7 +594,7 @@ impl ContextMenu { action: Some(action.boxed_clone()), handler: Rc::new(move |context, window, cx| { if let Some(context) = &context { - window.focus(context); + window.focus(context, cx); } window.dispatch_action(action.boxed_clone(), cx); }), diff --git a/crates/ui/src/components/navigable.rs b/crates/ui/src/components/navigable.rs index a592bcc36f4cc490c4676a83660ace050025ee39..07e761f9c0c14daf551d272c1a1894da84e1b3cf 100644 --- a/crates/ui/src/components/navigable.rs +++ b/crates/ui/src/components/navigable.rs @@ -75,7 +75,7 @@ impl RenderOnce for Navigable { }) .unwrap_or(0); if let Some(entry) = children.get(target) { - entry.focus_handle.focus(window); + entry.focus_handle.focus(window, cx); if let Some(anchor) = &entry.scroll_anchor { anchor.scroll_to(window, cx); } @@ -89,7 +89,7 @@ impl RenderOnce for Navigable { .and_then(|index| index.checked_sub(1)) .or(children.len().checked_sub(1)); if let Some(entry) = target.and_then(|target| children.get(target)) { - entry.focus_handle.focus(window); + entry.focus_handle.focus(window, cx); if let Some(anchor) = &entry.scroll_anchor { anchor.scroll_to(window, cx); } diff --git a/crates/ui/src/components/popover_menu.rs b/crates/ui/src/components/popover_menu.rs index 7fdb39126b5244e367a4646c6ef6df1547a8a52f..cd79e50ce01b1f4e697b252801c2ae76765726d2 100644 --- a/crates/ui/src/components/popover_menu.rs +++ b/crates/ui/src/components/popover_menu.rs @@ -281,7 +281,7 @@ fn show_menu( if modal.focus_handle(cx).contains_focused(window, cx) && let Some(previous_focus_handle) = previous_focus_handle.as_ref() { - window.focus(previous_focus_handle); + window.focus(previous_focus_handle, cx); } *menu2.borrow_mut() = None; window.refresh(); @@ -296,8 +296,8 @@ fn show_menu( // flickering when opening popover menus. let focus_handle = new_menu.focus_handle(cx); window.on_next_frame(move |window, _cx| { - window.on_next_frame(move |window, _cx| { - window.focus(&focus_handle); + window.on_next_frame(move |window, cx| { + window.focus(&focus_handle, cx); }); }); *menu.borrow_mut() = Some(new_menu); diff --git a/crates/ui/src/components/right_click_menu.rs b/crates/ui/src/components/right_click_menu.rs index 5b654c295e8c9721cd38af8b4807ba5d8e6d6cb9..faf2cb3429b610727209e13188656c174aefb655 100644 --- a/crates/ui/src/components/right_click_menu.rs +++ b/crates/ui/src/components/right_click_menu.rs @@ -253,7 +253,7 @@ impl Element for RightClickMenu { && let Some(previous_focus_handle) = previous_focus_handle.as_ref() { - window.focus(previous_focus_handle); + window.focus(previous_focus_handle, cx); } *menu2.borrow_mut() = None; window.refresh(); @@ -268,8 +268,8 @@ impl Element for RightClickMenu { // flickering when opening menus. let focus_handle = new_menu.focus_handle(cx); window.on_next_frame(move |window, _cx| { - window.on_next_frame(move |window, _cx| { - window.focus(&focus_handle); + window.on_next_frame(move |window, cx| { + window.focus(&focus_handle, cx); }); }); *menu.borrow_mut() = Some(new_menu); diff --git a/crates/ui_input/src/number_field.rs b/crates/ui_input/src/number_field.rs index ee5c57b43b7c44db1c2ded122d3d4272a541c32e..2d596a2498f445f6a0d18ce48b02bddf20aee8da 100644 --- a/crates/ui_input/src/number_field.rs +++ b/crates/ui_input/src/number_field.rs @@ -476,7 +476,7 @@ impl RenderOnce for NumberField { if let Some(previous) = previous_focus_handle.as_ref() { - window.focus(previous); + window.focus(previous, cx); } on_change(&new_value, window, cx); }; @@ -485,7 +485,7 @@ impl RenderOnce for NumberField { }) .detach(); - window.focus(&editor.focus_handle(cx)); + window.focus(&editor.focus_handle(cx), cx); editor } diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index edc5705a28ecd7d378c0f959ac82a6493c82d325..b358cf7b53ff16bae3756499470a2a55211618a8 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -350,7 +350,7 @@ impl Dock { let focus_subscription = cx.on_focus(&focus_handle, window, |dock: &mut Dock, window, cx| { if let Some(active_entry) = dock.active_panel_entry() { - active_entry.panel.panel_focus_handle(cx).focus(window) + active_entry.panel.panel_focus_handle(cx).focus(window, cx) } }); let zoom_subscription = cx.subscribe(&workspace, |dock, workspace, e: &Event, cx| { @@ -593,7 +593,7 @@ impl Dock { this.set_panel_zoomed(&panel.to_any(), true, window, cx); if !PanelHandle::panel_focus_handle(panel, cx).contains_focused(window, cx) { - window.focus(&panel.focus_handle(cx)); + window.focus(&panel.focus_handle(cx), cx); } workspace .update(cx, |workspace, cx| { @@ -625,7 +625,7 @@ impl Dock { { this.set_open(true, window, cx); this.activate_panel(ix, window, cx); - window.focus(&panel.read(cx).focus_handle(cx)); + window.focus(&panel.read(cx).focus_handle(cx), cx); } } PanelEvent::Close => { @@ -1052,7 +1052,7 @@ impl Render for PanelButtons { name = name, toggle_state = !is_open ); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); window.dispatch_action(action.boxed_clone(), cx) } }) diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs index bb4b10fa63dc884b8cf0ab8eee8e3bc34880b2a5..4bde632ce720dad792d19677c60ab62fd51d3637 100644 --- a/crates/workspace/src/item.rs +++ b/crates/workspace/src/item.rs @@ -1042,7 +1042,7 @@ impl ItemHandle for Entity { fn relay_action(&self, action: Box, window: &mut Window, cx: &mut App) { self.update(cx, |this, cx| { - this.focus_handle(cx).focus(window); + this.focus_handle(cx).focus(window, cx); window.dispatch_action(action, cx); }) } diff --git a/crates/workspace/src/modal_layer.rs b/crates/workspace/src/modal_layer.rs index d6f10f703100d89bef5babd4baa590df5fa0c8fd..10b24497a28faf68ed0820211f0d8860da558786 100644 --- a/crates/workspace/src/modal_layer.rs +++ b/crates/workspace/src/modal_layer.rs @@ -116,7 +116,7 @@ impl ModalLayer { focus_handle, }); cx.defer_in(window, move |_, window, cx| { - window.focus(&new_modal.focus_handle(cx)); + window.focus(&new_modal.focus_handle(cx), cx); }); cx.notify(); } @@ -144,7 +144,7 @@ impl ModalLayer { if let Some(previous_focus) = active_modal.previous_focus_handle && active_modal.focus_handle.contains_focused(window, cx) { - previous_focus.focus(window); + previous_focus.focus(window, cx); } cx.notify(); } diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs index 036723c13755ff2a7b2b10e9684d822f239a8e0b..f6256aee46b9e2b5c29c020e9ee12f6ff510210f 100644 --- a/crates/workspace/src/pane.rs +++ b/crates/workspace/src/pane.rs @@ -625,11 +625,11 @@ impl Pane { self.last_focus_handle_by_item.get(&active_item.item_id()) && let Some(focus_handle) = weak_last_focus_handle.upgrade() { - focus_handle.focus(window); + focus_handle.focus(window, cx); return; } - active_item.item_focus_handle(cx).focus(window); + active_item.item_focus_handle(cx).focus(window, cx); } else if let Some(focused) = window.focused(cx) && !self.context_menu_focused(window, cx) { @@ -638,7 +638,7 @@ impl Pane { } } else if let Some(welcome_page) = self.welcome_page.as_ref() { if self.focus_handle.is_focused(window) { - welcome_page.read(cx).focus_handle(cx).focus(window); + welcome_page.read(cx).focus_handle(cx).focus(window, cx); } } } @@ -1999,7 +1999,7 @@ impl Pane { let should_activate = activate_pane || self.has_focus(window, cx); if self.items.len() == 1 && should_activate { - self.focus_handle.focus(window); + self.focus_handle.focus(window, cx); } else { self.activate_item( index_to_activate, @@ -2350,7 +2350,7 @@ impl Pane { pub fn focus_active_item(&mut self, window: &mut Window, cx: &mut Context) { if let Some(active_item) = self.active_item() { let focus_handle = active_item.item_focus_handle(cx); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); } } diff --git a/crates/workspace/src/welcome.rs b/crates/workspace/src/welcome.rs index 93ff1ea266ff9f40b64064ea03d9bd1b91161300..4d84f3072f87ffa3246a313cbc749ddd61287d25 100644 --- a/crates/workspace/src/welcome.rs +++ b/crates/workspace/src/welcome.rs @@ -250,12 +250,12 @@ impl WelcomePage { } fn select_next(&mut self, _: &SelectNext, window: &mut Window, cx: &mut Context) { - window.focus_next(); + window.focus_next(cx); cx.notify(); } fn select_previous(&mut self, _: &SelectPrevious, window: &mut Window, cx: &mut Context) { - window.focus_prev(); + window.focus_prev(cx); cx.notify(); } diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 516dc867ae14f7138dff0a968e210e214d0beb29..9baf2a2d6c2155f0c30221be1308d8296c0b62a0 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -1393,7 +1393,7 @@ impl Workspace { cx.on_focus_lost(window, |this, window, cx| { let focus_handle = this.focus_handle(cx); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); }) .detach(); @@ -1417,7 +1417,7 @@ impl Workspace { cx.subscribe_in(¢er_pane, window, Self::handle_pane_event) .detach(); - window.focus(¢er_pane.focus_handle(cx)); + window.focus(¢er_pane.focus_handle(cx), cx); cx.emit(Event::PaneAdded(center_pane.clone())); @@ -2057,7 +2057,7 @@ impl Workspace { ) -> Task> { let to_load = if let Some(pane) = pane.upgrade() { pane.update(cx, |pane, cx| { - window.focus(&pane.focus_handle(cx)); + window.focus(&pane.focus_handle(cx), cx); loop { // Retrieve the weak item handle from the history. let entry = pane.nav_history_mut().pop(mode, cx)?; @@ -3176,7 +3176,7 @@ impl Workspace { } } else { let focus_handle = &active_panel.panel_focus_handle(cx); - window.focus(focus_handle); + window.focus(focus_handle, cx); reveal_dock = true; } } @@ -3188,7 +3188,7 @@ impl Workspace { if focus_center { self.active_pane - .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx))) + .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx), cx)) } cx.notify(); @@ -3356,7 +3356,7 @@ impl Workspace { if let Some(panel) = panel.as_ref() { if should_focus(&**panel, window, cx) { dock.set_open(true, window, cx); - panel.panel_focus_handle(cx).focus(window); + panel.panel_focus_handle(cx).focus(window, cx); } else { focus_center = true; } @@ -3366,7 +3366,7 @@ impl Workspace { if focus_center { self.active_pane - .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx))) + .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx), cx)) } result_panel = panel; @@ -3440,7 +3440,7 @@ impl Workspace { if focus_center { self.active_pane - .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx))) + .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx), cx)) } if self.zoomed_position != dock_to_reveal { @@ -3471,7 +3471,7 @@ impl Workspace { .detach(); self.panes.push(pane.clone()); - window.focus(&pane.focus_handle(cx)); + window.focus(&pane.focus_handle(cx), cx); cx.emit(Event::PaneAdded(pane.clone())); pane @@ -3866,7 +3866,7 @@ impl Workspace { ) { let panes = self.center.panes(); if let Some(pane) = panes.get(action.0).map(|p| (*p).clone()) { - window.focus(&pane.focus_handle(cx)); + window.focus(&pane.focus_handle(cx), cx); } else { self.split_and_clone(self.active_pane.clone(), SplitDirection::Right, window, cx) .detach(); @@ -3936,7 +3936,7 @@ impl Workspace { if let Some(ix) = panes.iter().position(|pane| **pane == self.active_pane) { let next_ix = (ix + 1) % panes.len(); let next_pane = panes[next_ix].clone(); - window.focus(&next_pane.focus_handle(cx)); + window.focus(&next_pane.focus_handle(cx), cx); } } @@ -3945,7 +3945,7 @@ impl Workspace { if let Some(ix) = panes.iter().position(|pane| **pane == self.active_pane) { let prev_ix = cmp::min(ix.wrapping_sub(1), panes.len() - 1); let prev_pane = panes[prev_ix].clone(); - window.focus(&prev_pane.focus_handle(cx)); + window.focus(&prev_pane.focus_handle(cx), cx); } } @@ -4041,7 +4041,7 @@ impl Workspace { Some(ActivateInDirectionTarget::Pane(pane)) => { let pane = pane.read(cx); if let Some(item) = pane.active_item() { - item.item_focus_handle(cx).focus(window); + item.item_focus_handle(cx).focus(window, cx); } else { log::error!( "Could not find a focus target when in switching focus in {direction} direction for a pane", @@ -4053,7 +4053,7 @@ impl Workspace { window.defer(cx, move |window, cx| { let dock = dock.read(cx); if let Some(panel) = dock.active_panel() { - panel.panel_focus_handle(cx).focus(window); + panel.panel_focus_handle(cx).focus(window, cx); } else { log::error!("Could not find a focus target when in switching focus in {direction} direction for a {:?} dock", dock.position()); } @@ -4673,7 +4673,7 @@ impl Workspace { // if you're already following, find the right pane and focus it. if let Some(follower_state) = self.follower_states.get(&leader_id) { - window.focus(&follower_state.pane().focus_handle(cx)); + window.focus(&follower_state.pane().focus_handle(cx), cx); return; } @@ -5485,12 +5485,12 @@ impl Workspace { ) { self.panes.retain(|p| p != pane); if let Some(focus_on) = focus_on { - focus_on.update(cx, |pane, cx| window.focus(&pane.focus_handle(cx))); + focus_on.update(cx, |pane, cx| window.focus(&pane.focus_handle(cx), cx)); } else if self.active_pane() == pane { self.panes .last() .unwrap() - .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx))); + .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx), cx)); } if self.last_active_center_pane == Some(pane.downgrade()) { self.last_active_center_pane = None; @@ -6248,7 +6248,7 @@ impl Workspace { let workspace = Self::new(Default::default(), project, app_state, window, cx); workspace .active_pane - .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx))); + .update(cx, |pane, cx| window.focus(&pane.focus_handle(cx), cx)); workspace } @@ -8722,7 +8722,7 @@ fn move_all_items( // This automatically removes duplicate items in the pane to_pane.update(cx, |destination, cx| { destination.add_item(item_handle, true, true, None, window, cx); - window.focus(&destination.focus_handle(cx)) + window.focus(&destination.focus_handle(cx), cx) }); } } @@ -8766,7 +8766,7 @@ pub fn move_item( cx, ); if activate { - window.focus(&destination.focus_handle(cx)) + window.focus(&destination.focus_handle(cx), cx) } }); } diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index bd26812a1a3037e9d7fe0bf38c84c61143cc23e8..f527872ad8c90c4db2782fde62dcbe6a5320e4d7 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -819,7 +819,7 @@ fn handle_open_request(request: OpenRequest, app_state: Arc, cx: &mut 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); + panel.focus_handle(cx).focus(window, cx); } }) }) diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index d2764c5c334ba32730982fc55e80d6197de3a2aa..f6218c97c31b98db76a2ae46b3f89876d426ac33 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -477,7 +477,7 @@ pub fn initialize_workspace( initialize_panels(prompt_builder.clone(), window, cx); register_actions(app_state.clone(), workspace, window, cx); - workspace.focus_handle(cx).focus(window); + workspace.focus_handle(cx).focus(window, cx); }) .detach(); } diff --git a/crates/zed/src/zed/component_preview.rs b/crates/zed/src/zed/component_preview.rs index 14a46d8882d1d3d371c50e9886062a124917a48d..e3c7fc8df542448d5b8b290e96405546be7b4b1e 100644 --- a/crates/zed/src/zed/component_preview.rs +++ b/crates/zed/src/zed/component_preview.rs @@ -161,7 +161,7 @@ impl ComponentPreview { component_preview.update_component_list(cx); let focus_handle = component_preview.filter_editor.read(cx).focus_handle(cx); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); Ok(component_preview) } @@ -770,7 +770,7 @@ impl Item for ComponentPreview { self.workspace_id = workspace.database_id(); let focus_handle = self.filter_editor.read(cx).focus_handle(cx); - window.focus(&focus_handle); + window.focus(&focus_handle, cx); } } From ec6702aa736b54307f11f0727de1eaaef942b29a Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Wed, 17 Dec 2025 18:53:42 +0200 Subject: [PATCH 133/266] Remove global workspace trust concept (#45129) Follow-up of https://github.com/zed-industries/zed/pull/44887 Trims the worktree trust mechanism to the actual `worktree`s, so now "global", workspace-level things like `prettier`, `NodeRuntime`, `copilot` and global MCP servers are considered as "trusted" a priori. In the future, a separate mechanism for those will be considered and added. Release Notes: - N/A --- crates/agent_ui/src/agent_panel.rs | 131 +---- crates/agent_ui/src/agent_ui.rs | 10 - crates/edit_prediction_cli/src/headless.rs | 2 +- crates/eval/src/eval.rs | 2 +- crates/node_runtime/src/node_runtime.rs | 9 - crates/project/src/context_server_store.rs | 19 - crates/project/src/project.rs | 5 +- crates/project/src/trusted_worktrees.rs | 538 +------------------ crates/project_benchmarks/src/main.rs | 2 +- crates/proto/proto/worktree.proto | 6 +- crates/remote_server/src/headless_project.rs | 5 +- crates/remote_server/src/unix.rs | 4 - crates/workspace/src/persistence.rs | 30 +- crates/workspace/src/security_modal.rs | 72 +-- crates/workspace/src/workspace.rs | 13 +- crates/zed/src/main.rs | 10 +- docs/src/worktree-trust.md | 18 +- 17 files changed, 77 insertions(+), 799 deletions(-) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index e41c8b7f5482b3709db2492f5fd81b6f3e7d6eb0..294cd8b4888950f6ea92d6bea1eba78c3d6d6de2 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -7,7 +7,6 @@ use db::kvp::{Dismissable, KEY_VALUE_STORE}; use project::{ ExternalAgentServerName, agent_server_store::{CLAUDE_CODE_NAME, CODEX_NAME, GEMINI_NAME}, - trusted_worktrees::{RemoteHostLocation, TrustedWorktrees, wait_for_workspace_trust}, }; use serde::{Deserialize, Serialize}; use settings::{ @@ -264,17 +263,6 @@ impl AgentType { Self::Custom { .. } => Some(IconName::Sparkle), } } - - fn is_mcp(&self) -> bool { - match self { - Self::NativeAgent => false, - Self::TextThread => false, - Self::Custom { .. } => false, - Self::Gemini => true, - Self::ClaudeCode => true, - Self::Codex => true, - } - } } impl From for AgentType { @@ -455,9 +443,7 @@ pub struct AgentPanel { pending_serialization: Option>>, onboarding: Entity, selected_agent: AgentType, - new_agent_thread_task: Task<()>, show_trust_workspace_message: bool, - _worktree_trust_subscription: Option, } impl AgentPanel { @@ -681,48 +667,6 @@ impl AgentPanel { None }; - let mut show_trust_workspace_message = false; - let worktree_trust_subscription = - TrustedWorktrees::try_get_global(cx).and_then(|trusted_worktrees| { - let has_global_trust = trusted_worktrees.update(cx, |trusted_worktrees, cx| { - trusted_worktrees.can_trust_workspace( - project - .read(cx) - .remote_connection_options(cx) - .map(RemoteHostLocation::from), - cx, - ) - }); - if has_global_trust { - None - } else { - show_trust_workspace_message = true; - let project = project.clone(); - Some(cx.subscribe( - &trusted_worktrees, - move |agent_panel, trusted_worktrees, _, cx| { - let new_show_trust_workspace_message = - !trusted_worktrees.update(cx, |trusted_worktrees, cx| { - trusted_worktrees.can_trust_workspace( - project - .read(cx) - .remote_connection_options(cx) - .map(RemoteHostLocation::from), - cx, - ) - }); - if new_show_trust_workspace_message - != agent_panel.show_trust_workspace_message - { - agent_panel.show_trust_workspace_message = - new_show_trust_workspace_message; - cx.notify(); - }; - }, - )) - } - }); - let mut panel = Self { active_view, workspace, @@ -745,14 +689,12 @@ impl AgentPanel { height: None, zoomed: false, pending_serialization: None, - new_agent_thread_task: Task::ready(()), onboarding, acp_history, history_store, selected_agent: AgentType::default(), loading: false, - show_trust_workspace_message, - _worktree_trust_subscription: worktree_trust_subscription, + show_trust_workspace_message: false, }; // Initial sync of agent servers from extensions @@ -945,47 +887,6 @@ impl AgentPanel { } }; - if ext_agent.is_mcp() { - let wait_task = this.update(cx, |agent_panel, cx| { - agent_panel.project.update(cx, |project, cx| { - wait_for_workspace_trust( - project.remote_connection_options(cx), - "context servers", - cx, - ) - }) - })?; - if let Some(wait_task) = wait_task { - this.update_in(cx, |agent_panel, window, cx| { - agent_panel.show_trust_workspace_message = true; - cx.notify(); - agent_panel.new_agent_thread_task = - cx.spawn_in(window, async move |agent_panel, cx| { - wait_task.await; - let server = ext_agent.server(fs, history); - agent_panel - .update_in(cx, |agent_panel, window, cx| { - agent_panel.show_trust_workspace_message = false; - cx.notify(); - agent_panel._external_thread( - server, - resume_thread, - summarize_thread, - workspace, - project, - loading, - ext_agent, - window, - cx, - ); - }) - .ok(); - }); - })?; - return Ok(()); - } - } - let server = ext_agent.server(fs, history); this.update_in(cx, |agent_panel, window, cx| { agent_panel._external_thread( @@ -1510,36 +1411,6 @@ impl AgentPanel { window: &mut Window, cx: &mut Context, ) { - let wait_task = if agent.is_mcp() { - self.project.update(cx, |project, cx| { - wait_for_workspace_trust( - project.remote_connection_options(cx), - "context servers", - cx, - ) - }) - } else { - None - }; - if let Some(wait_task) = wait_task { - self.show_trust_workspace_message = true; - cx.notify(); - self.new_agent_thread_task = cx.spawn_in(window, async move |agent_panel, cx| { - wait_task.await; - agent_panel - .update_in(cx, |agent_panel, window, cx| { - agent_panel.show_trust_workspace_message = false; - cx.notify(); - agent_panel._new_agent_thread(agent, window, cx); - }) - .ok(); - }); - } else { - self._new_agent_thread(agent, window, cx); - } - } - - fn _new_agent_thread(&mut self, agent: AgentType, window: &mut Window, cx: &mut Context) { match agent { AgentType::TextThread => { window.dispatch_action(NewTextThread.boxed_clone(), cx); diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index c80c7b43644ab949e748609435e33dfe9f31d54e..02cb7e59948b10274302bd8cd6f74f1accbd30a3 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -174,16 +174,6 @@ impl ExternalAgent { Self::Custom { name } => Rc::new(agent_servers::CustomAgentServer::new(name.clone())), } } - - pub fn is_mcp(&self) -> bool { - match self { - Self::Gemini => true, - Self::ClaudeCode => true, - Self::Codex => true, - Self::NativeAgent => false, - Self::Custom { .. } => false, - } - } } /// Opens the profile management interface for configuring agent tools and settings. diff --git a/crates/edit_prediction_cli/src/headless.rs b/crates/edit_prediction_cli/src/headless.rs index 489e78d364d0fdbb08b93eab89fd5f91f345f68e..da96e7ef6520e952e2b7696eee6b82c243e90e4e 100644 --- a/crates/edit_prediction_cli/src/headless.rs +++ b/crates/edit_prediction_cli/src/headless.rs @@ -114,7 +114,7 @@ pub fn init(cx: &mut App) -> EpAppState { tx.send(Some(options)).log_err(); }) .detach(); - let node_runtime = NodeRuntime::new(client.http_client(), None, rx, None); + let node_runtime = NodeRuntime::new(client.http_client(), None, rx); let extension_host_proxy = ExtensionHostProxy::global(cx); diff --git a/crates/eval/src/eval.rs b/crates/eval/src/eval.rs index 3a2891922c80b95c85f0daed25603bea14b41842..80633696b7d5e655bb7db3627568b881642cf62c 100644 --- a/crates/eval/src/eval.rs +++ b/crates/eval/src/eval.rs @@ -422,7 +422,7 @@ pub fn init(cx: &mut App) -> Arc { tx.send(Some(options)).log_err(); }) .detach(); - let node_runtime = NodeRuntime::new(client.http_client(), None, rx, None); + let node_runtime = NodeRuntime::new(client.http_client(), None, rx); let extension_host_proxy = ExtensionHostProxy::global(cx); debug_adapter_extension::init(extension_host_proxy.clone(), cx); diff --git a/crates/node_runtime/src/node_runtime.rs b/crates/node_runtime/src/node_runtime.rs index 5e4297988b665c3b89771838ef629ee87e88fb5b..eb8a5b45797baf7329554cb0b8d4a4f67a1f6579 100644 --- a/crates/node_runtime/src/node_runtime.rs +++ b/crates/node_runtime/src/node_runtime.rs @@ -9,8 +9,6 @@ use serde::Deserialize; use smol::io::BufReader; use smol::{fs, lock::Mutex}; use std::fmt::Display; -use std::future::Future; -use std::pin::Pin; use std::{ env::{self, consts}, ffi::OsString, @@ -48,7 +46,6 @@ struct NodeRuntimeState { last_options: Option, options: watch::Receiver>, shell_env_loaded: Shared>, - trust_task: Option + Send>>>, } impl NodeRuntime { @@ -56,11 +53,9 @@ impl NodeRuntime { http: Arc, shell_env_loaded: Option>, options: watch::Receiver>, - trust_task: Option + Send>>>, ) -> Self { NodeRuntime(Arc::new(Mutex::new(NodeRuntimeState { http, - trust_task, instance: None, last_options: None, options, @@ -75,15 +70,11 @@ impl NodeRuntime { last_options: None, options: watch::channel(Some(NodeBinaryOptions::default())).1, shell_env_loaded: oneshot::channel().1.shared(), - trust_task: None, }))) } async fn instance(&self) -> Box { let mut state = self.0.lock().await; - if let Some(trust_task) = state.trust_task.take() { - trust_task.await; - } let options = loop { if let Some(options) = state.options.borrow().as_ref() { diff --git a/crates/project/src/context_server_store.rs b/crates/project/src/context_server_store.rs index 7d060db887b1b5d07dd4d6de9ca85297adfd0c6f..7ba46a46872ba57c758baccf9f67b0039818ee75 100644 --- a/crates/project/src/context_server_store.rs +++ b/crates/project/src/context_server_store.rs @@ -15,7 +15,6 @@ use util::{ResultExt as _, rel_path::RelPath}; use crate::{ Project, project_settings::{ContextServerSettings, ProjectSettings}, - trusted_worktrees::wait_for_workspace_trust, worktree_store::WorktreeStore, }; @@ -333,15 +332,6 @@ impl ContextServerStore { pub fn start_server(&mut self, server: Arc, cx: &mut Context) { cx.spawn(async move |this, cx| { - let wait_task = this.update(cx, |context_server_store, cx| { - context_server_store.project.update(cx, |project, cx| { - let remote_host = project.remote_connection_options(cx); - wait_for_workspace_trust(remote_host, "context servers", cx) - }) - })??; - if let Some(wait_task) = wait_task { - wait_task.await; - } let this = this.upgrade().context("Context server store dropped")?; let settings = this .update(cx, |this, _| { @@ -582,15 +572,6 @@ impl ContextServerStore { } async fn maintain_servers(this: WeakEntity, cx: &mut AsyncApp) -> Result<()> { - let wait_task = this.update(cx, |context_server_store, cx| { - context_server_store.project.update(cx, |project, cx| { - let remote_host = project.remote_connection_options(cx); - wait_for_workspace_trust(remote_host, "context servers", cx) - }) - })??; - if let Some(wait_task) = wait_task { - wait_task.await; - } let (mut configured_servers, registry, worktree_store) = this.update(cx, |this, _| { ( this.context_server_settings.clone(), diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index b348fcdae2c414aa1b3f34f616ca3426899fe1d3..8b57413b22ac95a16e35a95d70a04b3ae49d4b31 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -4895,16 +4895,13 @@ impl Project { .update(|cx| TrustedWorktrees::try_get_global(cx))? .context("missing trusted worktrees")?; trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| { - let mut restricted_paths = envelope + let restricted_paths = envelope .payload .worktree_ids .into_iter() .map(WorktreeId::from_proto) .map(PathTrust::Worktree) .collect::>(); - if envelope.payload.restrict_workspace { - restricted_paths.insert(PathTrust::Workspace); - } let remote_host = this .read(cx) .remote_connection_options(cx) diff --git a/crates/project/src/trusted_worktrees.rs b/crates/project/src/trusted_worktrees.rs index 9f849ceaf1db62c1a88e269565e95bc97bc56011..0e1a8b4011bf56b150fe99a502eece905dcc9d78 100644 --- a/crates/project/src/trusted_worktrees.rs +++ b/crates/project/src/trusted_worktrees.rs @@ -27,36 +27,20 @@ //! Spawning a language server is potentially dangerous, and Zed needs to restrict that by default. //! Each single file worktree requires a separate trust permission, unless a more global level is trusted. //! -//! * "workspace" -//! -//! Even an empty Zed instance with no files or directories open is potentially dangerous: opening an Assistant Panel and creating new external agent thread might require installing and running MCP servers. -//! -//! Disabling the entire panel is possible with ai-related settings. -//! Yet when it's enabled, it's still reasonably safe to use remote AI agents and control their permissions in the Assistant Panel. -//! -//! Unlike that, MCP servers are similar to language servers and may require fetching, installing and running packages or binaries. -//! Given that those servers are not tied to any particular worktree, this level of trust is required to operate any MCP server. -//! -//! Workspace level of trust assumes all single file worktrees are trusted too, for the same host: if we allow global MCP server-related functionality, we can already allow spawning language servers for single file worktrees as well. -//! //! * "directory worktree" //! //! If a directory is open in Zed, it's a full worktree which may spawn multiple language servers associated with it. //! Each such worktree requires a separate trust permission, so each separate directory worktree has to be trusted separately, unless a more global level is trusted. //! -//! When a directory worktree is trusted and language servers are allowed to be downloaded and started, hence we also allow workspace level of trust (hence, "single file worktree" level of trust also). +//! When a directory worktree is trusted and language servers are allowed to be downloaded and started, hence, "single file worktree" level of trust also. //! //! * "path override" //! //! To ease trusting multiple directory worktrees at once, it's possible to trust a parent directory of a certain directory worktree opened in Zed. //! Trusting a directory means trusting all its subdirectories as well, including all current and potential directory worktrees. -//! -//! If we trust multiple projects to install and spawn various language server processes, we can also allow workspace trust requests for MCP servers installation and spawning. use collections::{HashMap, HashSet}; -use gpui::{ - App, AppContext as _, Context, Entity, EventEmitter, Global, SharedString, Task, WeakEntity, -}; +use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Global, SharedString, WeakEntity}; use remote::RemoteConnectionOptions; use rpc::{AnyProtoClient, proto}; use settings::{Settings as _, WorktreeId}; @@ -132,57 +116,6 @@ pub fn track_worktree_trust( } } -/// Waits until at least [`PathTrust::Workspace`] level of trust is granted for the host the [`TrustedWorktrees`] was initialized with. -pub fn wait_for_default_workspace_trust( - what_waits: &'static str, - cx: &mut App, -) -> Option> { - let trusted_worktrees = TrustedWorktrees::try_get_global(cx)?; - wait_for_workspace_trust( - trusted_worktrees.read(cx).remote_host.clone(), - what_waits, - cx, - ) -} - -/// Waits until at least [`PathTrust::Workspace`] level of trust is granted for a particular host. -pub fn wait_for_workspace_trust( - remote_host: Option>, - what_waits: &'static str, - cx: &mut App, -) -> Option> { - let trusted_worktrees = TrustedWorktrees::try_get_global(cx)?; - let remote_host = remote_host.map(|host| host.into()); - - let remote_host = if trusted_worktrees.update(cx, |trusted_worktrees, cx| { - trusted_worktrees.can_trust_workspace(remote_host.clone(), cx) - }) { - None - } else { - Some(remote_host) - }?; - - Some(cx.spawn(async move |cx| { - log::info!("Waiting for workspace to be trusted before starting {what_waits}"); - let (tx, restricted_worktrees_task) = smol::channel::bounded::<()>(1); - let Ok(_subscription) = cx.update(|cx| { - cx.subscribe(&trusted_worktrees, move |_, e, _| { - if let TrustedWorktreesEvent::Trusted(trusted_host, trusted_paths) = e { - if trusted_host == &remote_host && trusted_paths.contains(&PathTrust::Workspace) - { - log::info!("Workspace is trusted for {what_waits}"); - tx.send_blocking(()).ok(); - } - } - }) - }) else { - return; - }; - - restricted_worktrees_task.recv().await.ok(); - })) -} - /// A collection of worktree trust metadata, can be accessed globally (if initialized) and subscribed to. pub struct TrustedWorktrees(Entity); @@ -205,8 +138,6 @@ pub struct TrustedWorktreesStore { worktree_stores: HashMap, Option>, trusted_paths: TrustedPaths, restricted: HashSet, - remote_host: Option, - restricted_workspaces: HashSet>, } /// An identifier of a host to split the trust questions by. @@ -246,9 +177,6 @@ impl From for RemoteHostLocation { /// See module-level documentation on the trust model. #[derive(Debug, PartialEq, Eq, Clone, Hash)] pub enum PathTrust { - /// General, no worktrees or files open case. - /// E.g. MCP servers can be spawned from a blank Zed instance, but will do `npm i` and other potentially malicious actions. - Workspace, /// A worktree that is familiar to this workspace. /// Either a single file or a directory worktree. Worktree(WorktreeId), @@ -260,9 +188,6 @@ pub enum PathTrust { impl PathTrust { fn to_proto(&self) -> proto::PathTrust { match self { - Self::Workspace => proto::PathTrust { - content: Some(proto::path_trust::Content::Workspace(0)), - }, Self::Worktree(worktree_id) => proto::PathTrust { content: Some(proto::path_trust::Content::WorktreeId( worktree_id.to_proto(), @@ -282,7 +207,6 @@ impl PathTrust { Self::Worktree(WorktreeId::from_proto(id)) } proto::path_trust::Content::AbsPath(path) => Self::AbsPath(PathBuf::from(path)), - proto::path_trust::Content::Workspace(_) => Self::Workspace, }) } } @@ -322,9 +246,7 @@ impl TrustedWorktreesStore { } let worktree_stores = match worktree_store { - Some(worktree_store) => { - HashMap::from_iter([(worktree_store.downgrade(), remote_host.clone())]) - } + Some(worktree_store) => HashMap::from_iter([(worktree_store.downgrade(), remote_host)]), None => HashMap::default(), }; @@ -332,8 +254,6 @@ impl TrustedWorktreesStore { trusted_paths, downstream_client, upstream_client, - remote_host, - restricted_workspaces: HashSet::default(), restricted: HashSet::default(), worktree_stores, } @@ -345,11 +265,9 @@ impl TrustedWorktreesStore { worktree_store: &Entity, cx: &App, ) -> bool { - let Some(remote_host) = self.worktree_stores.get(&worktree_store.downgrade()) else { - return false; - }; - self.restricted_workspaces.contains(remote_host) - || self.restricted.iter().any(|restricted_worktree| { + self.worktree_stores + .contains_key(&worktree_store.downgrade()) + && self.restricted.iter().any(|restricted_worktree| { worktree_store .read(cx) .worktree_for_id(*restricted_worktree, cx) @@ -366,7 +284,6 @@ impl TrustedWorktreesStore { remote_host: Option, cx: &mut Context, ) { - let mut new_workspace_trusted = false; let mut new_trusted_single_file_worktrees = HashSet::default(); let mut new_trusted_other_worktrees = HashSet::default(); let mut new_trusted_abs_paths = HashSet::default(); @@ -377,7 +294,6 @@ impl TrustedWorktreesStore { .flat_map(|current_trusted| current_trusted.iter()), ) { match trusted_path { - PathTrust::Workspace => new_workspace_trusted = true, PathTrust::Worktree(worktree_id) => { self.restricted.remove(worktree_id); if let Some((abs_path, is_file, host)) = @@ -388,13 +304,11 @@ impl TrustedWorktreesStore { new_trusted_single_file_worktrees.insert(*worktree_id); } else { new_trusted_other_worktrees.insert((abs_path, *worktree_id)); - new_workspace_trusted = true; } } } } PathTrust::AbsPath(path) => { - new_workspace_trusted = true; debug_assert!( path.is_absolute(), "Cannot trust non-absolute path {path:?}" @@ -404,11 +318,6 @@ impl TrustedWorktreesStore { } } - if new_workspace_trusted { - new_trusted_single_file_worktrees.clear(); - self.restricted_workspaces.remove(&remote_host); - trusted_paths.insert(PathTrust::Workspace); - } new_trusted_other_worktrees.retain(|(worktree_abs_path, _)| { new_trusted_abs_paths .iter() @@ -428,8 +337,7 @@ impl TrustedWorktreesStore { if restricted_host != remote_host { return true; } - let retain = (!is_file - || (!new_workspace_trusted && new_trusted_other_worktrees.is_empty())) + let retain = (!is_file || new_trusted_other_worktrees.is_empty()) && new_trusted_abs_paths.iter().all(|new_trusted_path| { !restricted_worktree_path.starts_with(new_trusted_path) }); @@ -453,9 +361,6 @@ impl TrustedWorktreesStore { .into_iter() .map(PathTrust::Worktree), ); - if trusted_paths.is_empty() && new_workspace_trusted { - trusted_paths.insert(PathTrust::Workspace); - } } cx.emit(TrustedWorktreesEvent::Trusted( @@ -489,13 +394,6 @@ impl TrustedWorktreesStore { ) { for restricted_path in restricted_paths { match restricted_path { - PathTrust::Workspace => { - self.restricted_workspaces.insert(remote_host.clone()); - cx.emit(TrustedWorktreesEvent::Restricted( - remote_host.clone(), - HashSet::from_iter([PathTrust::Workspace]), - )); - } PathTrust::Worktree(worktree_id) => { self.restricted.insert(worktree_id); cx.emit(TrustedWorktreesEvent::Restricted( @@ -568,7 +466,6 @@ impl TrustedWorktreesStore { downstream_client .send(proto::RestrictWorktrees { project_id: *downstream_project_id, - restrict_workspace: false, worktree_ids: vec![worktree_id.to_proto()], }) .ok(); @@ -577,7 +474,6 @@ impl TrustedWorktreesStore { upstream_client .send(proto::RestrictWorktrees { project_id: *upstream_project_id, - restrict_workspace: false, worktree_ids: vec![worktree_id.to_proto()], }) .ok(); @@ -585,61 +481,12 @@ impl TrustedWorktreesStore { false } - /// Checks whether a certain worktree is trusted globally (or on a larger trust level). - /// If not, emits [`TrustedWorktreesEvent::Restricted`] event if checked for the first time and not trusted. - /// - /// No events or data adjustment happens when `trust_all_worktrees` auto trust is enabled. - pub fn can_trust_workspace( - &mut self, - remote_host: Option, - cx: &mut Context, - ) -> bool { - if ProjectSettings::get_global(cx).session.trust_all_worktrees { - return true; - } - if self.restricted_workspaces.contains(&remote_host) { - return false; - } - if self.trusted_paths.contains_key(&remote_host) { - return true; - } - - self.restricted_workspaces.insert(remote_host.clone()); - cx.emit(TrustedWorktreesEvent::Restricted( - remote_host.clone(), - HashSet::from_iter([PathTrust::Workspace]), - )); - - if remote_host == self.remote_host { - if let Some((downstream_client, downstream_project_id)) = &self.downstream_client { - downstream_client - .send(proto::RestrictWorktrees { - project_id: *downstream_project_id, - restrict_workspace: true, - worktree_ids: Vec::new(), - }) - .ok(); - } - if let Some((upstream_client, upstream_project_id)) = &self.upstream_client { - upstream_client - .send(proto::RestrictWorktrees { - project_id: *upstream_project_id, - restrict_workspace: true, - worktree_ids: Vec::new(), - }) - .ok(); - } - } - false - } - - /// Lists all explicitly restricted worktrees (via [`TrustedWorktreesStore::can_trust`] and [`TrustedWorktreesStore::can_trust_workspace`] method calls) for a particular worktree store on a particular host. + /// Lists all explicitly restricted worktrees (via [`TrustedWorktreesStore::can_trust`] method calls) for a particular worktree store on a particular host. pub fn restricted_worktrees( &self, worktree_store: &WorktreeStore, - remote_host: Option, cx: &App, - ) -> HashSet)>> { + ) -> HashSet<(WorktreeId, Arc)> { let mut single_file_paths = HashSet::default(); let other_paths = self .restricted @@ -649,19 +496,16 @@ impl TrustedWorktreesStore { let worktree = worktree.read(cx); let abs_path = worktree.abs_path(); if worktree.is_single_file() { - single_file_paths.insert(Some((restricted_worktree_id, abs_path))); + single_file_paths.insert((restricted_worktree_id, abs_path)); None } else { Some((restricted_worktree_id, abs_path)) } }) - .map(Some) .collect::>(); if !other_paths.is_empty() { return other_paths; - } else if self.restricted_workspaces.contains(&remote_host) { - return HashSet::from_iter([None]); } else { single_file_paths } @@ -670,7 +514,7 @@ impl TrustedWorktreesStore { /// Switches the "trust nothing" mode to "automatically trust everything". /// This does not influence already persisted data, but stops adding new worktrees there. pub fn auto_trust_all(&mut self, cx: &mut Context) { - for (remote_host, mut worktrees) in std::mem::take(&mut self.restricted) + for (remote_host, worktrees) in std::mem::take(&mut self.restricted) .into_iter() .flat_map(|restricted_worktree| { let (_, _, host) = self.find_worktree_data(restricted_worktree, cx)?; @@ -683,26 +527,15 @@ impl TrustedWorktreesStore { acc }) { - if self.restricted_workspaces.remove(&remote_host) { - worktrees.insert(PathTrust::Workspace); - } self.trust(worktrees, remote_host, cx); } - - for remote_host in std::mem::take(&mut self.restricted_workspaces) { - self.trust(HashSet::from_iter([PathTrust::Workspace]), remote_host, cx); - } } /// Returns a normalized representation of the trusted paths to store in the DB. pub fn trusted_paths_for_serialization( &mut self, cx: &mut Context, - ) -> ( - HashSet>, - HashMap, HashSet>, - ) { - let mut new_trusted_workspaces = HashSet::default(); + ) -> HashMap, HashSet> { let new_trusted_worktrees = self .trusted_paths .clone() @@ -715,16 +548,12 @@ impl TrustedWorktreesStore { .find_worktree_data(worktree_id, cx) .map(|(abs_path, ..)| abs_path.to_path_buf()), PathTrust::AbsPath(abs_path) => Some(abs_path), - PathTrust::Workspace => { - new_trusted_workspaces.insert(host.clone()); - None - } }) .collect(); (host, abs_paths) }) .collect(); - (new_trusted_workspaces, new_trusted_worktrees) + new_trusted_worktrees } fn find_worktree_data( @@ -888,15 +717,9 @@ mod tests { assert!(has_restricted, "should have restricted worktrees"); let restricted = worktree_store.read_with(cx, |ws, cx| { - trusted_worktrees - .read(cx) - .restricted_worktrees(ws, None, cx) + trusted_worktrees.read(cx).restricted_worktrees(ws, cx) }); - assert!( - restricted - .iter() - .any(|r| r.as_ref().map(|(id, _)| *id) == Some(worktree_id)) - ); + assert!(restricted.iter().any(|(id, _)| *id == worktree_id)); events.borrow_mut().clear(); @@ -941,9 +764,7 @@ mod tests { ); let restricted_after = worktree_store.read_with(cx, |ws, cx| { - trusted_worktrees - .read(cx) - .restricted_worktrees(ws, None, cx) + trusted_worktrees.read(cx).restricted_worktrees(ws, cx) }); assert!( restricted_after.is_empty(), @@ -951,92 +772,6 @@ mod tests { ); } - #[gpui::test] - async fn test_workspace_trust_no_worktrees(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({})).await; - - let project = Project::test(fs, Vec::<&Path>::new(), cx).await; - let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); - - let trusted_worktrees = init_trust_global(worktree_store, cx); - - let events: Rc>> = Rc::default(); - cx.update({ - let events = events.clone(); - |cx| { - cx.subscribe(&trusted_worktrees, move |_, event, _| { - events.borrow_mut().push(match event { - TrustedWorktreesEvent::Trusted(host, paths) => { - TrustedWorktreesEvent::Trusted(host.clone(), paths.clone()) - } - TrustedWorktreesEvent::Restricted(host, paths) => { - TrustedWorktreesEvent::Restricted(host.clone(), paths.clone()) - } - }); - }) - } - }) - .detach(); - - let can_trust_workspace = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - !can_trust_workspace, - "workspace should be restricted by default" - ); - - { - let events = events.borrow(); - assert_eq!(events.len(), 1); - match &events[0] { - TrustedWorktreesEvent::Restricted(host, paths) => { - assert!(host.is_none()); - assert!(paths.contains(&PathTrust::Workspace)); - } - _ => panic!("expected Restricted event"), - } - } - - events.borrow_mut().clear(); - - let can_trust_workspace_again = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - !can_trust_workspace_again, - "workspace should still be restricted" - ); - assert!( - events.borrow().is_empty(), - "no duplicate Restricted event on repeated can_trust_workspace" - ); - - trusted_worktrees.update(cx, |store, cx| { - store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); - }); - - { - let events = events.borrow(); - assert_eq!(events.len(), 1); - match &events[0] { - TrustedWorktreesEvent::Trusted(host, paths) => { - assert!(host.is_none()); - assert!(paths.contains(&PathTrust::Workspace)); - } - _ => panic!("expected Trusted event"), - } - } - - let can_trust_workspace_after = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - can_trust_workspace_after, - "workspace should be trusted after trust()" - ); - } - #[gpui::test] async fn test_single_file_worktree_trust(cx: &mut TestAppContext) { init_test(cx); @@ -1122,58 +857,6 @@ mod tests { ); } - #[gpui::test] - async fn test_workspace_trust_unlocks_single_file_worktree(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "foo.rs": "fn foo() {}" })) - .await; - - let project = Project::test(fs, [path!("/root/foo.rs").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); - let worktree_id = worktree_store.read_with(cx, |store, cx| { - let worktree = store.worktrees().next().unwrap(); - let worktree = worktree.read(cx); - assert!(worktree.is_single_file(), "expected single-file worktree"); - worktree.id() - }); - - let trusted_worktrees = init_trust_global(worktree_store, cx); - - let can_trust_workspace = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - !can_trust_workspace, - "workspace should be restricted by default" - ); - - let can_trust_file = - trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); - assert!( - !can_trust_file, - "single-file worktree should be restricted by default" - ); - - trusted_worktrees.update(cx, |store, cx| { - store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); - }); - - let can_trust_workspace_after = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - can_trust_workspace_after, - "workspace should be trusted after trust(Workspace)" - ); - - let can_trust_file_after = - trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); - assert!( - can_trust_file_after, - "single-file worktree should be trusted after workspace trust" - ); - } - #[gpui::test] async fn test_multiple_single_file_worktrees_trust_one(cx: &mut TestAppContext) { init_test(cx); @@ -1319,47 +1002,6 @@ mod tests { assert!(can_trust_b, "project_b should now be trusted"); } - #[gpui::test] - async fn test_directory_worktree_trust_enables_workspace(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); - let worktree_id = worktree_store.read_with(cx, |store, cx| { - let worktree = store.worktrees().next().unwrap(); - assert!(!worktree.read(cx).is_single_file()); - worktree.read(cx).id() - }); - - let trusted_worktrees = init_trust_global(worktree_store, cx); - - let can_trust_workspace = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - !can_trust_workspace, - "workspace should be restricted initially" - ); - - trusted_worktrees.update(cx, |store, cx| { - store.trust( - HashSet::from_iter([PathTrust::Worktree(worktree_id)]), - None, - cx, - ); - }); - - let can_trust_workspace_after = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - can_trust_workspace_after, - "workspace should be trusted after trusting directory worktree" - ); - } - #[gpui::test] async fn test_directory_worktree_trust_enables_single_file(cx: &mut TestAppContext) { init_test(cx); @@ -1428,7 +1070,7 @@ mod tests { let fs = FakeFs::new(cx.executor()); fs.insert_tree( - path!("/workspace"), + path!("/root"), json!({ "project_a": { "main.rs": "fn main() {}" }, "project_b": { "lib.rs": "pub fn lib() {}" } @@ -1439,8 +1081,8 @@ mod tests { let project = Project::test( fs, [ - path!("/workspace/project_a").as_ref(), - path!("/workspace/project_b").as_ref(), + path!("/root/project_a").as_ref(), + path!("/root/project_b").as_ref(), ], cx, ) @@ -1464,7 +1106,7 @@ mod tests { trusted_worktrees.update(cx, |store, cx| { store.trust( - HashSet::from_iter([PathTrust::AbsPath(PathBuf::from(path!("/workspace")))]), + HashSet::from_iter([PathTrust::AbsPath(PathBuf::from(path!("/root")))]), None, cx, ); @@ -1539,12 +1181,6 @@ mod tests { trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx)); assert!(!can_trust, "worktree should be restricted initially"); } - let can_trust_workspace = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - !can_trust_workspace, - "workspace should be restricted initially" - ); let has_restricted = trusted_worktrees.read_with(cx, |store, cx| { store.has_restricted_worktrees(&worktree_store, cx) @@ -1566,13 +1202,6 @@ mod tests { ); } - let can_trust_workspace = - trusted_worktrees.update(cx, |store, cx| store.can_trust_workspace(None, cx)); - assert!( - can_trust_workspace, - "workspace should be trusted after auto_trust_all" - ); - let has_restricted_after = trusted_worktrees.read_with(cx, |store, cx| { store.has_restricted_worktrees(&worktree_store, cx) }); @@ -1592,100 +1221,6 @@ mod tests { ); } - #[gpui::test] - async fn test_wait_for_global_trust_already_trusted(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); - - let trusted_worktrees = init_trust_global(worktree_store, cx); - - trusted_worktrees.update(cx, |store, cx| { - store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); - }); - - let task = cx.update(|cx| wait_for_workspace_trust(None::, "test", cx)); - assert!(task.is_none(), "should return None when already trusted"); - } - - #[gpui::test] - async fn test_wait_for_workspace_trust_resolves_on_trust(cx: &mut TestAppContext) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); - - let trusted_worktrees = init_trust_global(worktree_store, cx); - - let task = cx.update(|cx| wait_for_workspace_trust(None::, "test", cx)); - assert!( - task.is_some(), - "should return Some(Task) when not yet trusted" - ); - - let task = task.unwrap(); - - cx.executor().run_until_parked(); - - trusted_worktrees.update(cx, |store, cx| { - store.trust(HashSet::from_iter([PathTrust::Workspace]), None, cx); - }); - - cx.executor().run_until_parked(); - task.await; - } - - #[gpui::test] - async fn test_wait_for_default_workspace_trust_resolves_on_directory_worktree_trust( - cx: &mut TestAppContext, - ) { - init_test(cx); - - let fs = FakeFs::new(cx.executor()); - fs.insert_tree(path!("/root"), json!({ "main.rs": "fn main() {}" })) - .await; - - let project = Project::test(fs, [path!("/root").as_ref()], cx).await; - let worktree_store = project.read_with(cx, |project, _| project.worktree_store()); - let worktree_id = worktree_store.read_with(cx, |store, cx| { - let worktree = store.worktrees().next().unwrap(); - assert!(!worktree.read(cx).is_single_file()); - worktree.read(cx).id() - }); - - let trusted_worktrees = init_trust_global(worktree_store, cx); - - let task = cx.update(|cx| wait_for_default_workspace_trust("test", cx)); - assert!( - task.is_some(), - "should return Some(Task) when not yet trusted" - ); - - let task = task.unwrap(); - - cx.executor().run_until_parked(); - - trusted_worktrees.update(cx, |store, cx| { - store.trust( - HashSet::from_iter([PathTrust::Worktree(worktree_id)]), - None, - cx, - ); - }); - - cx.executor().run_until_parked(); - task.await; - } - #[gpui::test] async fn test_trust_restrict_trust_cycle(cx: &mut TestAppContext) { init_test(cx); @@ -1820,36 +1355,11 @@ mod tests { let trusted_worktrees = init_trust_global(worktree_store, cx); let host_a: Option = None; - let host_b = Some(RemoteHostLocation { - user_name: Some("user".into()), - host_identifier: "remote-host".into(), - }); let can_trust_local = trusted_worktrees.update(cx, |store, cx| store.can_trust(local_worktree, cx)); assert!(!can_trust_local, "local worktree restricted on host_a"); - trusted_worktrees.update(cx, |store, cx| { - store.trust( - HashSet::from_iter([PathTrust::Workspace]), - host_b.clone(), - cx, - ); - }); - - let can_trust_workspace_a = trusted_worktrees.update(cx, |store, cx| { - store.can_trust_workspace(host_a.clone(), cx) - }); - assert!( - !can_trust_workspace_a, - "host_a workspace should still be restricted" - ); - - let can_trust_workspace_b = trusted_worktrees.update(cx, |store, cx| { - store.can_trust_workspace(host_b.clone(), cx) - }); - assert!(can_trust_workspace_b, "host_b workspace should be trusted"); - trusted_worktrees.update(cx, |store, cx| { store.trust( HashSet::from_iter([PathTrust::Worktree(local_worktree)]), @@ -1864,13 +1374,5 @@ mod tests { can_trust_local_after, "local worktree should be trusted on host_a" ); - - let can_trust_workspace_a_after = trusted_worktrees.update(cx, |store, cx| { - store.can_trust_workspace(host_a.clone(), cx) - }); - assert!( - can_trust_workspace_a_after, - "host_a workspace should be trusted after directory trust" - ); } } diff --git a/crates/project_benchmarks/src/main.rs b/crates/project_benchmarks/src/main.rs index 03c25bc464af06793e351f27588b023ec8eb3eb9..e4ddbb6cf2c7b6984df2533963bdf6bf88eacba0 100644 --- a/crates/project_benchmarks/src/main.rs +++ b/crates/project_benchmarks/src/main.rs @@ -62,7 +62,7 @@ fn main() -> Result<(), anyhow::Error> { let client = Client::production(cx); let http_client = FakeHttpClient::with_200_response(); let (_, rx) = watch::channel(None); - let node = NodeRuntime::new(http_client, None, rx, None); + let node = NodeRuntime::new(http_client, None, rx); let user_store = cx.new(|cx| UserStore::new(client.clone(), cx)); let registry = Arc::new(LanguageRegistry::new(cx.background_executor().clone())); let fs = Arc::new(RealFs::new(None, cx.background_executor().clone())); diff --git a/crates/proto/proto/worktree.proto b/crates/proto/proto/worktree.proto index 315aeb311e1e4284970dffa17bee4b0142373e92..5873cfc10c1c6af24520705c27781b916dfda3d0 100644 --- a/crates/proto/proto/worktree.proto +++ b/crates/proto/proto/worktree.proto @@ -166,14 +166,16 @@ message TrustWorktrees { message PathTrust { oneof content { - uint64 workspace = 1; uint64 worktree_id = 2; string abs_path = 3; } + + reserved 1; } message RestrictWorktrees { uint64 project_id = 1; - bool restrict_workspace = 2; repeated uint64 worktree_ids = 3; + + reserved 2; } diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs index 89d26d35c77e076e1e618669acb5e54dc8afdcca..c83cc6aa34402a082fe104d64a8cb47f460704b8 100644 --- a/crates/remote_server/src/headless_project.rs +++ b/crates/remote_server/src/headless_project.rs @@ -642,16 +642,13 @@ impl HeadlessProject { .update(|cx| TrustedWorktrees::try_get_global(cx))? .context("missing trusted worktrees")?; trusted_worktrees.update(&mut cx, |trusted_worktrees, cx| { - let mut restricted_paths = envelope + let restricted_paths = envelope .payload .worktree_ids .into_iter() .map(WorktreeId::from_proto) .map(PathTrust::Worktree) .collect::>(); - if envelope.payload.restrict_workspace { - restricted_paths.insert(PathTrust::Workspace); - } trusted_worktrees.restrict(restricted_paths, None, cx); })?; Ok(proto::Ack {}) diff --git a/crates/remote_server/src/unix.rs b/crates/remote_server/src/unix.rs index af603998171e19d4776d47479ff81aa08d26d258..449b8491ece2494dacf8bfb1fa89aeeb8f6a81ac 100644 --- a/crates/remote_server/src/unix.rs +++ b/crates/remote_server/src/unix.rs @@ -36,7 +36,6 @@ use smol::Async; use smol::channel::{Receiver, Sender}; use smol::io::AsyncReadExt; use smol::{net::unix::UnixListener, stream::StreamExt as _}; -use std::pin::Pin; use std::{ env, ffi::OsStr, @@ -453,13 +452,10 @@ pub fn execute_run( ) }; - let trust_task = trusted_worktrees::wait_for_default_workspace_trust("Node runtime", cx) - .map(|trust_task| Box::pin(trust_task) as Pin>); let node_runtime = NodeRuntime::new( http_client.clone(), Some(shell_env_loaded_rx), node_settings_rx, - trust_task, ); let mut languages = LanguageRegistry::new(cx.background_executor().clone()); diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index a992a9e1a20d1346a0c201afd72bb51327f00381..cf5bdf2ab0059f10f2fb44e2069c8c0baf24d72b 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -1919,7 +1919,6 @@ impl WorkspaceDb { pub(crate) async fn save_trusted_worktrees( &self, trusted_worktrees: HashMap, HashSet>, - trusted_workspaces: HashSet>, ) -> anyhow::Result<()> { use anyhow::Context as _; use db::sqlez::statement::Statement; @@ -1936,7 +1935,6 @@ impl WorkspaceDb { .into_iter() .map(move |abs_path| (Some(abs_path), host.clone())) }) - .chain(trusted_workspaces.into_iter().map(|host| (None, host))) .collect::>(); let mut first_worktree; let mut last_worktree = 0_usize; @@ -2001,7 +1999,7 @@ VALUES {placeholders};"# let trusted_worktrees = DB.trusted_worktrees()?; Ok(trusted_worktrees .into_iter() - .map(|(abs_path, user_name, host_name)| { + .filter_map(|(abs_path, user_name, host_name)| { let db_host = match (user_name, host_name) { (_, None) => None, (None, Some(host_name)) => Some(RemoteHostLocation { @@ -2014,21 +2012,17 @@ VALUES {placeholders};"# }), }; - match abs_path { - Some(abs_path) => { - if db_host != host { - (db_host, PathTrust::AbsPath(abs_path)) - } else if let Some(worktree_store) = &worktree_store { - find_worktree_in_store(worktree_store.read(cx), &abs_path, cx) - .map(PathTrust::Worktree) - .map(|trusted_worktree| (host.clone(), trusted_worktree)) - .unwrap_or_else(|| (db_host.clone(), PathTrust::AbsPath(abs_path))) - } else { - (db_host, PathTrust::AbsPath(abs_path)) - } - } - None => (db_host, PathTrust::Workspace), - } + let abs_path = abs_path?; + Some(if db_host != host { + (db_host, PathTrust::AbsPath(abs_path)) + } else if let Some(worktree_store) = &worktree_store { + find_worktree_in_store(worktree_store.read(cx), &abs_path, cx) + .map(PathTrust::Worktree) + .map(|trusted_worktree| (host.clone(), trusted_worktree)) + .unwrap_or_else(|| (db_host.clone(), PathTrust::AbsPath(abs_path))) + } else { + (db_host, PathTrust::AbsPath(abs_path)) + }) }) .fold(HashMap::default(), |mut acc, (remote_host, path_trust)| { acc.entry(remote_host) diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs index 1b5509d4d64e5b1377c9675fb49d2981e8173668..e3b9ab6e72481048d0f78eb07afb72af53810279 100644 --- a/crates/workspace/src/security_modal.rs +++ b/crates/workspace/src/security_modal.rs @@ -23,7 +23,7 @@ use ui::{ use crate::{DismissDecision, ModalView, ToggleWorktreeSecurity}; pub struct SecurityModal { - restricted_paths: HashMap, RestrictedPath>, + restricted_paths: HashMap, home_dir: Option, trust_parents: bool, worktree_store: WeakEntity, @@ -34,7 +34,7 @@ pub struct SecurityModal { #[derive(Debug, PartialEq, Eq)] struct RestrictedPath { - abs_path: Option>, + abs_path: Arc, is_file: bool, host: Option, } @@ -103,13 +103,11 @@ impl Render for SecurityModal { .child(Label::new(header_label)), ) .children(self.restricted_paths.values().map(|restricted_path| { - let abs_path = restricted_path.abs_path.as_ref().and_then(|abs_path| { - if restricted_path.is_file { - abs_path.parent() - } else { - Some(abs_path.as_ref()) - } - }); + let abs_path = if restricted_path.is_file { + restricted_path.abs_path.parent() + } else { + Some(restricted_path.abs_path.as_ref()) + }; let label = match abs_path { Some(abs_path) => match &restricted_path.host { @@ -254,7 +252,7 @@ impl SecurityModal { has_restricted_files |= restricted_path.is_file; !restricted_path.is_file }) - .filter_map(|restricted_path| restricted_path.abs_path.as_ref()?.parent()) + .filter_map(|restricted_path| restricted_path.abs_path.parent()) .collect::>(); match available_parents.len() { 0 => { @@ -289,19 +287,17 @@ impl SecurityModal { let mut paths_to_trust = self .restricted_paths .keys() - .map(|worktree_id| match worktree_id { - Some(worktree_id) => PathTrust::Worktree(*worktree_id), - None => PathTrust::Workspace, - }) + .copied() + .map(PathTrust::Worktree) .collect::>(); if self.trust_parents { paths_to_trust.extend(self.restricted_paths.values().filter_map( |restricted_paths| { if restricted_paths.is_file { - Some(PathTrust::Workspace) + None } else { let parent_abs_path = - restricted_paths.abs_path.as_ref()?.parent()?.to_owned(); + restricted_paths.abs_path.parent()?.to_owned(); Some(PathTrust::AbsPath(parent_abs_path)) } }, @@ -322,42 +318,22 @@ impl SecurityModal { pub fn refresh_restricted_paths(&mut self, cx: &mut Context) { if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { if let Some(worktree_store) = self.worktree_store.upgrade() { - let mut new_restricted_worktrees = trusted_worktrees + let new_restricted_worktrees = trusted_worktrees .read(cx) - .restricted_worktrees(worktree_store.read(cx), self.remote_host.clone(), cx) + .restricted_worktrees(worktree_store.read(cx), cx) .into_iter() - .filter_map(|restricted_path| { - let restricted_path = match restricted_path { - Some((worktree_id, abs_path)) => { - let worktree = - worktree_store.read(cx).worktree_for_id(worktree_id, cx)?; - ( - Some(worktree_id), - RestrictedPath { - abs_path: Some(abs_path), - is_file: worktree.read(cx).is_single_file(), - host: self.remote_host.clone(), - }, - ) - } - None => ( - None, - RestrictedPath { - abs_path: None, - is_file: false, - host: self.remote_host.clone(), - }, - ), - }; - Some(restricted_path) + .filter_map(|(worktree_id, abs_path)| { + let worktree = worktree_store.read(cx).worktree_for_id(worktree_id, cx)?; + Some(( + worktree_id, + RestrictedPath { + abs_path, + is_file: worktree.read(cx).is_single_file(), + host: self.remote_host.clone(), + }, + )) }) .collect::>(); - // Do not clutter the UI: - // * trusting regular local worktrees assumes the workspace is trusted either, on the same host. - // * trusting a workspace trusts all single-file worktrees on the same host. - if new_restricted_worktrees.len() > 1 { - new_restricted_worktrees.remove(&None); - } if self.restricted_paths != new_restricted_worktrees { self.trust_parents = false; diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 9baf2a2d6c2155f0c30221be1308d8296c0b62a0..411450fea7c085dcbae084a368d7379136108b18 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -1233,21 +1233,18 @@ impl Workspace { if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { cx.subscribe(&trusted_worktrees, |workspace, worktrees_store, e, cx| { if let TrustedWorktreesEvent::Trusted(..) = e { - let (new_trusted_workspaces, new_trusted_worktrees) = worktrees_store - .update(cx, |worktrees_store, cx| { - worktrees_store.trusted_paths_for_serialization(cx) - }); // Do not persist auto trusted worktrees if !ProjectSettings::get_global(cx).session.trust_all_worktrees { + let new_trusted_worktrees = + worktrees_store.update(cx, |worktrees_store, cx| { + worktrees_store.trusted_paths_for_serialization(cx) + }); let timeout = cx.background_executor().timer(SERIALIZATION_THROTTLE_TIME); workspace._schedule_serialize_worktree_trust = cx.background_spawn(async move { timeout.await; persistence::DB - .save_trusted_worktrees( - new_trusted_worktrees, - new_trusted_workspaces, - ) + .save_trusted_worktrees(new_trusted_worktrees) .await .log_err(); }); diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index f527872ad8c90c4db2782fde62dcbe6a5320e4d7..a827e33f00935bb02e4bc9f761d673ab12a32f14 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -36,7 +36,6 @@ use std::{ env, io::{self, IsTerminal}, path::{Path, PathBuf}, - pin::Pin, process, sync::{Arc, OnceLock}, time::Instant, @@ -484,14 +483,7 @@ pub fn main() { }) .detach(); - let trust_task = trusted_worktrees::wait_for_default_workspace_trust("Node runtime", cx) - .map(|trust_task| Box::pin(trust_task) as Pin>); - let node_runtime = NodeRuntime::new( - client.http_client(), - Some(shell_env_loaded_rx), - rx, - trust_task, - ); + let node_runtime = NodeRuntime::new(client.http_client(), Some(shell_env_loaded_rx), rx); debug_adapter_extension::init(extension_host_proxy.clone(), cx); languages::init(languages.clone(), fs.clone(), node_runtime.clone(), cx); diff --git a/docs/src/worktree-trust.md b/docs/src/worktree-trust.md index 158851117bfdc4d00746594d74e1e6dae0bb84dc..590f063a75ac5d77e60d50f03af4795d6ec2961f 100644 --- a/docs/src/worktree-trust.md +++ b/docs/src/worktree-trust.md @@ -4,11 +4,11 @@ A worktree in Zed is either a directory or a single file that Zed opens as a sta Zed opens a worktree every time `zed some/path` is invoked, on drag and dropping a file or directory into Zed, on opening user settings.json, etc. Every worktree opened may contain a `.zed/settings.json` file with extra configuration options that may require installing and spawning language servers or MCP servers. -Note that the Zed workspace itself may also perform user-configured MCP server installation and spawning, even if no worktrees are open. +In order to provide users the opportunity to make their own choices according to their unique threat model and risk tolerance, all worktrees will be started in Restricted mode, which prevents download and execution of any related items from `.zed/settings.json`. Until configured to trust the worktree(s), Zed will not perform any related untrusted actions and will wait for user confirmation. This gives users a chance to review and understand any pre-configured settings, MCP servers, or language servers associated with a project. -In order to provide users the opportunity to make their own choices according to their unique threat model and risk tolerance, the workspace and all worktrees will be started in Restricted mode, which prevents download and execution of any related items. Until configured to trust the workspace and/or worktrees, Zed will not perform any untrusted actions and will wait for user confirmation. This gives users a chance to review and understand any pre-configured settings, MCP servers, or language servers associated with a project. +Note that at this point, Zed trusts the tools it installs itself, hence global entities such as global MCP servers, language servers like prettier and copilot are still in installed and started as usual, independent of worktree trust. -If a worktree is not trusted, Zed will indicate this with an exclamation mark icon in the title bar and a message in the Agent panel. Clicking this icon or using `workspace::ToggleWorktreeSecurity` action will bring up the security modal that allows the user to trust the worktree. +If a worktree is not trusted, Zed will indicate this with an exclamation mark icon in the title bar. Clicking this icon or using `workspace::ToggleWorktreeSecurity` action will bring up the security modal that allows the user to trust the worktree. Trusting any worktree will persist this information between restarts. It's possible to clear all trusted worktrees with `workspace::ClearTrustedWorktrees` command. This command will restart Zed, to ensure no untrusted settings, language servers or MCP servers persist. @@ -25,7 +25,7 @@ Restricted Mode prevents: ## Configuring broad worktree trust -By default, Zed won't trust any new worktrees and users will be required to trust each new worktree. Though not recommended, users may elect to trust all worktrees and the current workspace for a given session by configuring the following setting: +By default, Zed won't trust any new worktrees and users will be required to trust each new worktree. Though not recommended, users may elect to trust all worktrees by configuring the following setting: ```json [settings] "session": { @@ -47,20 +47,12 @@ A typical scenario where a directory might be open and a single file is subseque Spawning a language server presents a risk should the language server experience a supply-chain attack; therefore, Zed restricts that by default. Each single file worktree requires a separate trust grant, unless the directory containing it is trusted or all worktrees are trusted. -- "workspace" - -Even an empty Zed workspace with no files or directories open presents a risk if new MCP servers are locally configured by the user without review. For instance, opening an Assistant Panel and creating a new external agent thread might require installing and running new user-configured [Model Context Protocol servers](./ai/mcp.md). By default, zed will restrict a new MCP server until the user elects to trust the local workspace. Users may also disable the entire Agent panel if preferred; see [AI Configuration](./ai/configuration.md) for more details. - -Workspace trust, permitted by trusting Zed with no worktrees open, allows locally configured resources to be downloaded and executed. Workspace trust is per host and also trusts all single file worktrees from the same host in order to permit all local user-configured MCP and language servers to start. - - "directory worktree" If a directory is open in Zed, it's a full worktree which may spawn multiple language servers associated with it or spawn MCP servers if contained in a project settings file.Therefore, each directory worktree requires a separate trust grant unless a parent directory worktree trust is granted (see below). -When a directory worktree is trusted, language and MCP servers are permitted to be downloaded and started, hence we also enable workspace trust for the host in question automatically when this occurs. +When a directory worktree is trusted, language and MCP servers are permitted to be downloaded and started, hence we also enable single file worktree trust for the host in question automatically when this occurs: this helps when opening single files when using language server features in the trusted directory worktree. - "parent directory worktree" To permit trust decisions for multiple directory worktrees at once, it's possible to trust all subdirectories of a given parent directory worktree opened in Zed by checking the appropriate checkbox. This will grant trust to all its subdirectories, including all current and potential directory worktrees. - -This also automatically enables workspace trust to permit the newly trusted resources to download and start. From c56eb46311ade023b21ac69ea33540f396878f19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Miguel=20Raz=20Guzm=C3=A1n=20Macedo?= Date: Wed, 17 Dec 2025 11:32:18 -0600 Subject: [PATCH 134/266] Add davidbarsky to community champion labelers (#45132) --- .github/workflows/community_champion_auto_labeler.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/community_champion_auto_labeler.yml b/.github/workflows/community_champion_auto_labeler.yml index 93f1d5602331bb76fe5d678098ab8c087b1f3d52..d73b38320731e0a2f9a52ff863de5095eddb7b6a 100644 --- a/.github/workflows/community_champion_auto_labeler.yml +++ b/.github/workflows/community_champion_auto_labeler.yml @@ -34,6 +34,7 @@ jobs: CharlesChen0823 chbk cppcoffee + davidbarsky davewa ddoemonn djsauble From 0fe60ec5325bd5dd1810d141096e8b3732d5358b Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 17 Dec 2025 10:41:43 -0700 Subject: [PATCH 135/266] Trigger auto-fix auto-matically (#44947) This updates our CI workflow to try to run the autofix.yml workflow if any of prettier, cargo fmt, or cargo clippy fail. Release Notes: - N/A --- .github/workflows/autofix_pr.yml | 3 +++ .github/workflows/release.yml | 6 ++++++ .github/workflows/run_tests.yml | 18 +++++++++++++++--- .../xtask/src/tasks/workflows/autofix_pr.rs | 6 ++++++ tooling/xtask/src/tasks/workflows/run_tests.rs | 8 +++++--- tooling/xtask/src/tasks/workflows/steps.rs | 10 ++++++++++ 6 files changed, 45 insertions(+), 6 deletions(-) diff --git a/.github/workflows/autofix_pr.yml b/.github/workflows/autofix_pr.yml index 762b86c446f4592e8fd76c8f5a00cf8cf8ab3f38..1591ba2a9a98b8587814d25858f4e0d78d9f7d34 100644 --- a/.github/workflows/autofix_pr.yml +++ b/.github/workflows/autofix_pr.yml @@ -123,3 +123,6 @@ jobs: GIT_AUTHOR_NAME: Zed Zippy GIT_AUTHOR_EMAIL: 234243425+zed-zippy[bot]@users.noreply.github.com GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} +concurrency: + group: ${{ github.workflow }}-${{ inputs.pr_number }} + cancel-in-progress: true diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 7afac285b5a34df2aadd04952400809059e12222..155b38666f4bd73e68e9ea326db9a6862288a1fe 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -74,6 +74,12 @@ jobs: - name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} + - name: steps::trigger_autofix + if: failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' + run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=true + shell: bash -euxo pipefail {0} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index 9584d7a0cb70469820bf40d76beb6154f2a53b1e..a9a46b7a797faae793c87601d306a2aea80e6592 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -77,6 +77,15 @@ jobs: - name: ./script/prettier run: ./script/prettier shell: bash -euxo pipefail {0} + - name: steps::cargo_fmt + run: cargo fmt --all -- --check + shell: bash -euxo pipefail {0} + - name: steps::trigger_autofix + if: failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' + run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=false + shell: bash -euxo pipefail {0} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: ./script/check-todos run: ./script/check-todos shell: bash -euxo pipefail {0} @@ -87,9 +96,6 @@ jobs: uses: crate-ci/typos@2d0ce569feab1f8752f1dde43cc2f2aa53236e06 with: config: ./typos.toml - - name: steps::cargo_fmt - run: cargo fmt --all -- --check - shell: bash -euxo pipefail {0} timeout-minutes: 60 run_tests_windows: needs: @@ -160,6 +166,12 @@ jobs: - name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} + - name: steps::trigger_autofix + if: failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' + run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=true + shell: bash -euxo pipefail {0} + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large diff --git a/tooling/xtask/src/tasks/workflows/autofix_pr.rs b/tooling/xtask/src/tasks/workflows/autofix_pr.rs index 44dd0f9ea9b840163767e15b973192e72b57f4a8..f4a8e0e2b09df93cc430f0931c3db3f9e67b07df 100644 --- a/tooling/xtask/src/tasks/workflows/autofix_pr.rs +++ b/tooling/xtask/src/tasks/workflows/autofix_pr.rs @@ -18,6 +18,12 @@ pub fn autofix_pr() -> Workflow { .add_input(pr_number.name, pr_number.input()) .add_input(run_clippy.name, run_clippy.input()), )) + .concurrency( + Concurrency::new(Expression::new(format!( + "${{{{ github.workflow }}}}-{pr_number}" + ))) + .cancel_in_progress(true), + ) .add_job(run_autofix.name.clone(), run_autofix.job) .add_job(commit_changes.name, commit_changes.job) } diff --git a/tooling/xtask/src/tasks/workflows/run_tests.rs b/tooling/xtask/src/tasks/workflows/run_tests.rs index 0bb3e152fb390e044ebac456fd3347707c66f612..13639fd6c4bf33fe090dcb9d5f3cafdf45a36e76 100644 --- a/tooling/xtask/src/tasks/workflows/run_tests.rs +++ b/tooling/xtask/src/tasks/workflows/run_tests.rs @@ -237,10 +237,11 @@ fn check_style() -> NamedJob { .add_step(steps::cache_rust_dependencies_namespace()) .add_step(steps::setup_pnpm()) .add_step(steps::script("./script/prettier")) + .add_step(steps::cargo_fmt()) + .add_step(steps::trigger_autofix(false)) .add_step(steps::script("./script/check-todos")) .add_step(steps::script("./script/check-keymaps")) - .add_step(check_for_typos()) - .add_step(steps::cargo_fmt()), + .add_step(check_for_typos()), ) } @@ -326,7 +327,8 @@ pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { .add_step(steps::setup_node()) .add_step(steps::clippy(platform)) .when(platform == Platform::Linux, |job| { - job.add_step(steps::cargo_install_nextest()) + job.add_step(steps::trigger_autofix(true)) + .add_step(steps::cargo_install_nextest()) }) .add_step(steps::clear_target_dir_if_large(platform)) .add_step(steps::cargo_nextest(platform)) diff --git a/tooling/xtask/src/tasks/workflows/steps.rs b/tooling/xtask/src/tasks/workflows/steps.rs index 7d55df2db433d6e6eae96a5ae62a0c033689d904..54873c011ce9d1fb7d4e7e0b734695c7c1a30fad 100644 --- a/tooling/xtask/src/tasks/workflows/steps.rs +++ b/tooling/xtask/src/tasks/workflows/steps.rs @@ -344,3 +344,13 @@ pub fn git_checkout(ref_name: &dyn std::fmt::Display) -> Step { "git fetch origin {ref_name} && git checkout {ref_name}" )) } + +pub fn trigger_autofix(run_clippy: bool) -> Step { + named::bash(format!( + "gh workflow run autofix_pr.yml -f pr_number=${{{{ github.event.pull_request.number }}}} -f run_clippy={run_clippy}" + )) + .if_condition(Expression::new( + "failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]'", + )) + .add_env(("GITHUB_TOKEN", vars::GITHUB_TOKEN)) +} From b22ccfaff5019ecf00ad33fa0569b77f5ebc09e0 Mon Sep 17 00:00:00 2001 From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com> Date: Wed, 17 Dec 2025 13:31:21 -0500 Subject: [PATCH 136/266] gpui: Fix macOS memory leaks (#45051) The below memory leaks were caused by failing to release reference counted resources. I confirmed using instruments that my changes stopped the leaks from occurring. - System prompts - Screen capturing - loading font families There were also two memory leaks I found from some of our dependencies that I made PRs to fix - https://github.com/RustAudio/coreaudio-rs/pull/147 - https://github.com/servo/core-foundation-rs/pull/746 Release Notes: - N/A --- crates/gpui/src/platform/mac/open_type.rs | 5 ++++ .../gpui/src/platform/mac/screen_capture.rs | 14 ++++++++-- crates/gpui/src/platform/mac/text_system.rs | 26 +++++++++++++++++-- crates/gpui/src/platform/mac/window.rs | 1 + 4 files changed, 42 insertions(+), 4 deletions(-) diff --git a/crates/gpui/src/platform/mac/open_type.rs b/crates/gpui/src/platform/mac/open_type.rs index 37a29559fdfbc284ffd1021cc6c2c6ed717ca228..ff501df15f671318548a3959bd6b966f97e051b1 100644 --- a/crates/gpui/src/platform/mac/open_type.rs +++ b/crates/gpui/src/platform/mac/open_type.rs @@ -52,6 +52,11 @@ pub fn apply_features_and_fallbacks( &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks, ); + + for value in &values { + CFRelease(*value as _); + } + let new_descriptor = CTFontDescriptorCreateWithAttributes(attrs); CFRelease(attrs as _); let new_descriptor = CTFontDescriptor::wrap_under_create_rule(new_descriptor); diff --git a/crates/gpui/src/platform/mac/screen_capture.rs b/crates/gpui/src/platform/mac/screen_capture.rs index 2f2c1eae335c8bcb366879661534c46dacfd47b4..4b80a87d32f45540c76790065514f29cc7f93b3f 100644 --- a/crates/gpui/src/platform/mac/screen_capture.rs +++ b/crates/gpui/src/platform/mac/screen_capture.rs @@ -110,13 +110,21 @@ impl ScreenCaptureSource for MacScreenCaptureSource { let _: id = msg_send![configuration, setHeight: meta.resolution.height.0 as i64]; let stream: id = msg_send![stream, initWithFilter:filter configuration:configuration delegate:delegate]; + // Stream contains filter, configuration, and delegate internally so we release them here + // to prevent a memory leak when steam is dropped + let _: () = msg_send![filter, release]; + let _: () = msg_send![configuration, release]; + let _: () = msg_send![delegate, release]; + let (mut tx, rx) = oneshot::channel(); let mut error: id = nil; let _: () = msg_send![stream, addStreamOutput:output type:SCStreamOutputTypeScreen sampleHandlerQueue:0 error:&mut error as *mut id]; if error != nil { let message: id = msg_send![error, localizedDescription]; - tx.send(Err(anyhow!("failed to add stream output {message:?}"))) + let _: () = msg_send![stream, release]; + let _: () = msg_send![output, release]; + tx.send(Err(anyhow!("failed to add stream output {message:?}"))) .ok(); return rx; } @@ -132,8 +140,10 @@ impl ScreenCaptureSource for MacScreenCaptureSource { }; Ok(Box::new(stream) as Box) } else { + let _: () = msg_send![stream, release]; + let _: () = msg_send![output, release]; let message: id = msg_send![error, localizedDescription]; - Err(anyhow!("failed to stop screen capture stream {message:?}")) + Err(anyhow!("failed to start screen capture stream {message:?}")) }; if let Some(tx) = tx.borrow_mut().take() { tx.send(result).ok(); diff --git a/crates/gpui/src/platform/mac/text_system.rs b/crates/gpui/src/platform/mac/text_system.rs index 3faf4e6491e6588bdb1341d5a8845171562fa8a0..8595582f4ad7e078f7cfb0140e249feb0a9740dc 100644 --- a/crates/gpui/src/platform/mac/text_system.rs +++ b/crates/gpui/src/platform/mac/text_system.rs @@ -8,6 +8,7 @@ use anyhow::anyhow; use cocoa::appkit::CGFloat; use collections::HashMap; use core_foundation::{ + array::{CFArray, CFArrayRef}, attributed_string::CFMutableAttributedString, base::{CFRange, TCFType}, number::CFNumber, @@ -21,8 +22,10 @@ use core_graphics::{ }; use core_text::{ font::CTFont, + font_collection::CTFontCollectionRef, font_descriptor::{ - kCTFontSlantTrait, kCTFontSymbolicTrait, kCTFontWeightTrait, kCTFontWidthTrait, + CTFontDescriptor, kCTFontSlantTrait, kCTFontSymbolicTrait, kCTFontWeightTrait, + kCTFontWidthTrait, }, line::CTLine, string_attributes::kCTFontAttributeName, @@ -97,7 +100,26 @@ impl PlatformTextSystem for MacTextSystem { fn all_font_names(&self) -> Vec { let mut names = Vec::new(); let collection = core_text::font_collection::create_for_all_families(); - let Some(descriptors) = collection.get_descriptors() else { + // NOTE: We intentionally avoid using `collection.get_descriptors()` here because + // it has a memory leak bug in core-text v21.0.0. The upstream code uses + // `wrap_under_get_rule` but `CTFontCollectionCreateMatchingFontDescriptors` + // follows the Create Rule (caller owns the result), so it should use + // `wrap_under_create_rule`. We call the function directly with correct memory management. + unsafe extern "C" { + fn CTFontCollectionCreateMatchingFontDescriptors( + collection: CTFontCollectionRef, + ) -> CFArrayRef; + } + let descriptors: Option> = unsafe { + let array_ref = + CTFontCollectionCreateMatchingFontDescriptors(collection.as_concrete_TypeRef()); + if array_ref.is_null() { + None + } else { + Some(CFArray::wrap_under_create_rule(array_ref)) + } + }; + let Some(descriptors) = descriptors else { return names; }; for descriptor in descriptors.into_iter() { diff --git a/crates/gpui/src/platform/mac/window.rs b/crates/gpui/src/platform/mac/window.rs index 19ad1777570da9494148e01161e156748cd9bcfc..14b0113c7cf44fa9574bfcca30b46fb988b5e380 100644 --- a/crates/gpui/src/platform/mac/window.rs +++ b/crates/gpui/src/platform/mac/window.rs @@ -1190,6 +1190,7 @@ impl PlatformWindow for MacWindow { let (done_tx, done_rx) = oneshot::channel(); let done_tx = Cell::new(Some(done_tx)); let block = ConcreteBlock::new(move |answer: NSInteger| { + let _: () = msg_send![alert, release]; if let Some(done_tx) = done_tx.take() { let _ = done_tx.send(answer.try_into().unwrap()); } From 8c7a04c6bf3c26082f0cb0501a3ddf180968dd55 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 17 Dec 2025 11:41:46 -0700 Subject: [PATCH 137/266] Autotrust new git worktrees (#45138) Follow-up of https://github.com/zed-industries/zed/pull/44887 - Inherit git worktree trust - Tidy up the security modal Release Notes: - N/A --------- Co-authored-by: Kirill Bulatov --- crates/git_ui/src/worktree_picker.rs | 41 ++++++++++++++++++--- crates/workspace/src/security_modal.rs | 51 +++++++++----------------- 2 files changed, 53 insertions(+), 39 deletions(-) diff --git a/crates/git_ui/src/worktree_picker.rs b/crates/git_ui/src/worktree_picker.rs index 875ae55eefae19e24aa26fe75f80d70f8316c82b..fef5e16c80ddd26ae6dd0b2a5c0ad1d8e5b21b2c 100644 --- a/crates/git_ui/src/worktree_picker.rs +++ b/crates/git_ui/src/worktree_picker.rs @@ -1,4 +1,5 @@ use anyhow::Context as _; +use collections::HashSet; use fuzzy::StringMatchCandidate; use git::repository::Worktree as GitWorktree; @@ -9,7 +10,11 @@ use gpui::{ actions, rems, }; use picker::{Picker, PickerDelegate, PickerEditorPosition}; -use project::{DirectoryLister, git_store::Repository}; +use project::{ + DirectoryLister, + git_store::Repository, + trusted_worktrees::{PathTrust, RemoteHostLocation, TrustedWorktrees}, +}; use recent_projects::{RemoteConnectionModal, connect}; use remote::{RemoteConnectionOptions, remote_client::ConnectionIdentifier}; use std::{path::PathBuf, sync::Arc}; @@ -219,7 +224,6 @@ impl WorktreeListDelegate { window: &mut Window, cx: &mut Context>, ) { - let workspace = self.workspace.clone(); let Some(repo) = self.repo.clone() else { return; }; @@ -247,6 +251,7 @@ impl WorktreeListDelegate { let branch = worktree_branch.to_string(); let window_handle = window.window_handle(); + let workspace = self.workspace.clone(); cx.spawn_in(window, async move |_, cx| { let Some(paths) = worktree_path.await? else { return anyhow::Ok(()); @@ -257,8 +262,32 @@ impl WorktreeListDelegate { repo.create_worktree(branch.clone(), path.clone(), commit) })? .await??; - - let final_path = path.join(branch); + let new_worktree_path = path.join(branch); + + workspace.update(cx, |workspace, cx| { + if let Some(trusted_worktrees) = TrustedWorktrees::try_get_global(cx) { + let repo_path = &repo.read(cx).snapshot().work_directory_abs_path; + let project = workspace.project(); + if let Some((parent_worktree, _)) = + project.read(cx).find_worktree(repo_path, cx) + { + trusted_worktrees.update(cx, |trusted_worktrees, cx| { + if trusted_worktrees.can_trust(parent_worktree.read(cx).id(), cx) { + trusted_worktrees.trust( + HashSet::from_iter([PathTrust::AbsPath( + new_worktree_path.clone(), + )]), + project + .read(cx) + .remote_connection_options(cx) + .map(RemoteHostLocation::from), + cx, + ); + } + }); + } + } + })?; let (connection_options, app_state, is_local) = workspace.update(cx, |workspace, cx| { @@ -274,7 +303,7 @@ impl WorktreeListDelegate { .update_in(cx, |workspace, window, cx| { workspace.open_workspace_for_paths( replace_current_window, - vec![final_path], + vec![new_worktree_path], window, cx, ) @@ -283,7 +312,7 @@ impl WorktreeListDelegate { } else if let Some(connection_options) = connection_options { open_remote_worktree( connection_options, - vec![final_path], + vec![new_worktree_path], app_state, window_handle, replace_current_window, diff --git a/crates/workspace/src/security_modal.rs b/crates/workspace/src/security_modal.rs index e3b9ab6e72481048d0f78eb07afb72af53810279..bb1482d7cce2a9849a78a9512598e389a6e5eea0 100644 --- a/crates/workspace/src/security_modal.rs +++ b/crates/workspace/src/security_modal.rs @@ -102,46 +102,31 @@ impl Render for SecurityModal { .child(Icon::new(IconName::Warning).color(Color::Warning)) .child(Label::new(header_label)), ) - .children(self.restricted_paths.values().map(|restricted_path| { + .children(self.restricted_paths.values().filter_map(|restricted_path| { let abs_path = if restricted_path.is_file { restricted_path.abs_path.parent() } else { Some(restricted_path.abs_path.as_ref()) - }; - - let label = match abs_path { - Some(abs_path) => match &restricted_path.host { - Some(remote_host) => match &remote_host.user_name { - Some(user_name) => format!( - "{} ({}@{})", - self.shorten_path(abs_path).display(), - user_name, - remote_host.host_identifier - ), - None => format!( - "{} ({})", - self.shorten_path(abs_path).display(), - remote_host.host_identifier - ), - }, - None => self.shorten_path(abs_path).display().to_string(), - }, - None => match &restricted_path.host { - Some(remote_host) => match &remote_host.user_name { - Some(user_name) => format!( - "Workspace trust ({}@{})", - user_name, remote_host.host_identifier - ), - None => { - format!("Workspace trust ({})", remote_host.host_identifier) - } - }, - None => "Workspace trust".to_string(), + }?; + let label = match &restricted_path.host { + Some(remote_host) => match &remote_host.user_name { + Some(user_name) => format!( + "{} ({}@{})", + self.shorten_path(abs_path).display(), + user_name, + remote_host.host_identifier + ), + None => format!( + "{} ({})", + self.shorten_path(abs_path).display(), + remote_host.host_identifier + ), }, + None => self.shorten_path(abs_path).display().to_string(), }; - h_flex() + Some(h_flex() .pl(IconSize::default().rems() + rems(0.5)) - .child(Label::new(label).color(Color::Muted)) + .child(Label::new(label).color(Color::Muted))) })), ) .child( From 847457df1bf27c1162433434afef53497f07a15b Mon Sep 17 00:00:00 2001 From: Mikayla Maki Date: Wed, 17 Dec 2025 10:49:39 -0800 Subject: [PATCH 138/266] Fix a bug where switching the disable AI flag would cause a panic (#45050) Also quiet some noisy logs Release Notes: - N/A --- crates/agent/src/history_store.rs | 13 +++++-------- crates/agent_ui/Cargo.toml | 2 +- crates/agent_ui_v2/Cargo.toml | 7 +++++++ crates/search/src/buffer_search.rs | 5 ++++- crates/workspace/src/dock.rs | 14 +++++--------- crates/workspace/src/workspace.rs | 20 ++++++++++++++++---- crates/zed/Cargo.toml | 4 ++++ crates/zed/src/zed.rs | 25 +++++++++++++++++++++++-- 8 files changed, 65 insertions(+), 25 deletions(-) diff --git a/crates/agent/src/history_store.rs b/crates/agent/src/history_store.rs index 5a1b923d139060ed7df679a69d96928d03559c9d..c455f73316e3fc7a641fa8a31ac0ad766a2ae584 100644 --- a/crates/agent/src/history_store.rs +++ b/crates/agent/src/history_store.rs @@ -216,14 +216,10 @@ impl HistoryStore { } pub fn reload(&self, cx: &mut Context) { - let database_future = ThreadsDatabase::connect(cx); + let database_connection = ThreadsDatabase::connect(cx); cx.spawn(async move |this, cx| { - let threads = database_future - .await - .map_err(|err| anyhow!(err))? - .list_threads() - .await?; - + let database = database_connection.await; + let threads = database.map_err(|err| anyhow!(err))?.list_threads().await?; this.update(cx, |this, cx| { if this.recently_opened_entries.len() < MAX_RECENTLY_OPENED_ENTRIES { for thread in threads @@ -344,7 +340,8 @@ impl HistoryStore { fn load_recently_opened_entries(cx: &AsyncApp) -> Task>> { cx.background_spawn(async move { if cfg!(any(feature = "test-support", test)) { - anyhow::bail!("history store does not persist in tests"); + log::warn!("history store does not persist in tests"); + return Ok(VecDeque::new()); } let json = KEY_VALUE_STORE .read_kvp(RECENTLY_OPENED_THREADS_KEY)? diff --git a/crates/agent_ui/Cargo.toml b/crates/agent_ui/Cargo.toml index 38580b4d2c61597718d9fb718a20e52e84222481..8a9633e578a85323f2a289bd83c169a1f5d7f272 100644 --- a/crates/agent_ui/Cargo.toml +++ b/crates/agent_ui/Cargo.toml @@ -13,7 +13,7 @@ path = "src/agent_ui.rs" doctest = false [features] -test-support = ["assistant_text_thread/test-support", "eval_utils", "gpui/test-support", "language/test-support", "reqwest_client", "workspace/test-support"] +test-support = ["assistant_text_thread/test-support", "eval_utils", "gpui/test-support", "language/test-support", "reqwest_client", "workspace/test-support", "agent/test-support"] unit-eval = [] [dependencies] diff --git a/crates/agent_ui_v2/Cargo.toml b/crates/agent_ui_v2/Cargo.toml index f24ef47471cdcfe0910cf36c5e220c5276d5f6ae..2b2cf337adf578432d594ce14f2f58e5911c45fb 100644 --- a/crates/agent_ui_v2/Cargo.toml +++ b/crates/agent_ui_v2/Cargo.toml @@ -12,6 +12,10 @@ workspace = true path = "src/agent_ui_v2.rs" doctest = false +[features] +test-support = ["agent/test-support"] + + [dependencies] agent.workspace = true agent_servers.workspace = true @@ -38,3 +42,6 @@ time_format.workspace = true ui.workspace = true util.workspace = true workspace.workspace = true + +[dev-dependencies] +agent = { workspace = true, features = ["test-support"] } diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs index 66641e91a882b0b994e16673e3c65a1d51f27650..12b283ab22937b7952d18d63b1378d2914211f9b 100644 --- a/crates/search/src/buffer_search.rs +++ b/crates/search/src/buffer_search.rs @@ -7,7 +7,6 @@ use crate::{ search_bar::{ActionButtonState, input_base_styles, render_action_button, render_text_input}, }; use any_vec::AnyVec; -use anyhow::Context as _; use collections::HashMap; use editor::{ DisplayPoint, Editor, EditorSettings, MultiBufferOffset, @@ -634,15 +633,19 @@ impl BufferSearchBar { .read(cx) .as_singleton() .expect("query editor should be backed by a singleton buffer"); + query_buffer .read(cx) .set_language_registry(languages.clone()); cx.spawn(async move |buffer_search_bar, cx| { + use anyhow::Context as _; + let regex_language = languages .language_for_name("regex") .await .context("loading regex language")?; + buffer_search_bar .update(cx, |buffer_search_bar, cx| { buffer_search_bar.regex_language = Some(regex_language); diff --git a/crates/workspace/src/dock.rs b/crates/workspace/src/dock.rs index b358cf7b53ff16bae3756499470a2a55211618a8..7f4b09df0f94fa421c399ed9d70163f7cc2ba203 100644 --- a/crates/workspace/src/dock.rs +++ b/crates/workspace/src/dock.rs @@ -1,5 +1,4 @@ use crate::persistence::model::DockData; -use crate::utility_pane::utility_slot_for_dock_position; use crate::{DraggedDock, Event, ModalLayer, Pane}; use crate::{Workspace, status_bar::StatusItemView}; use anyhow::Context as _; @@ -705,7 +704,7 @@ impl Dock { panel: &Entity, window: &mut Window, cx: &mut Context, - ) { + ) -> bool { if let Some(panel_ix) = self .panel_entries .iter() @@ -724,15 +723,12 @@ impl Dock { } } - let slot = utility_slot_for_dock_position(self.position); - if let Some(workspace) = self.workspace.upgrade() { - workspace.update(cx, |workspace, cx| { - workspace.clear_utility_pane_if_provider(slot, Entity::entity_id(panel), cx); - }); - } - self.panel_entries.remove(panel_ix); cx.notify(); + + true + } else { + false } } diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index 411450fea7c085dcbae084a368d7379136108b18..b636414250c0463eca019ad30321b19d67680fd3 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -135,7 +135,9 @@ pub use workspace_settings::{ use zed_actions::{Spawn, feedback::FileBugReport}; use crate::{ - item::ItemBufferKind, notifications::NotificationId, utility_pane::UTILITY_PANE_MIN_WIDTH, + item::ItemBufferKind, + notifications::NotificationId, + utility_pane::{UTILITY_PANE_MIN_WIDTH, utility_slot_for_dock_position}, }; use crate::{ persistence::{ @@ -986,6 +988,7 @@ impl AppState { #[cfg(any(test, feature = "test-support"))] pub fn test(cx: &mut App) -> Arc { + use fs::Fs; use node_runtime::NodeRuntime; use session::Session; use settings::SettingsStore; @@ -996,6 +999,7 @@ impl AppState { } let fs = fs::FakeFs::new(cx.background_executor().clone()); + ::set_global(fs.clone(), cx); let languages = Arc::new(LanguageRegistry::test(cx.background_executor().clone())); let clock = Arc::new(clock::FakeSystemClock::new()); let http_client = http_client::FakeHttpClient::with_404_response(); @@ -1890,10 +1894,18 @@ impl Workspace { window: &mut Window, cx: &mut Context, ) { + let mut found_in_dock = None; for dock in [&self.left_dock, &self.bottom_dock, &self.right_dock] { - dock.update(cx, |dock, cx| { - dock.remove_panel(panel, window, cx); - }) + let found = dock.update(cx, |dock, cx| dock.remove_panel(panel, window, cx)); + + if found { + found_in_dock = Some(dock.clone()); + } + } + if let Some(found_in_dock) = found_in_dock { + let position = found_in_dock.read(cx).position(); + let slot = utility_slot_for_dock_position(position); + self.clear_utility_pane_if_provider(slot, Entity::entity_id(panel), cx); } } diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index 955540843489ac21d79042854eb6fcebf5f64318..b5b33850da8da9035276c7752ad72da9bf0b55b9 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -195,6 +195,10 @@ terminal_view = { workspace = true, features = ["test-support"] } tree-sitter-md.workspace = true tree-sitter-rust.workspace = true workspace = { workspace = true, features = ["test-support"] } +agent_ui = { workspace = true, features = ["test-support"] } +agent_ui_v2 = { workspace = true, features = ["test-support"] } +search = { workspace = true, features = ["test-support"] } + [package.metadata.bundle-dev] icon = ["resources/app-icon-dev@2x.png", "resources/app-icon-dev.png"] diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs index f6218c97c31b98db76a2ae46b3f89876d426ac33..d088df00839814e32a9c246a3486ac5ad5ca4b9e 100644 --- a/crates/zed/src/zed.rs +++ b/crates/zed/src/zed.rs @@ -707,7 +707,6 @@ fn setup_or_teardown_ai_panel( .disable_ai || cfg!(test); let existing_panel = workspace.panel::

(cx); - match (disable_ai, existing_panel) { (false, None) => cx.spawn_in(window, async move |workspace, cx| { let panel = load_panel(workspace.clone(), cx.clone()).await?; @@ -2327,7 +2326,7 @@ mod tests { use project::{Project, ProjectPath}; use semver::Version; use serde_json::json; - use settings::{SettingsStore, watch_config_file}; + use settings::{SaturatingBool, SettingsStore, watch_config_file}; use std::{ path::{Path, PathBuf}, time::Duration, @@ -5171,6 +5170,28 @@ mod tests { ); } + #[gpui::test] + async fn test_disable_ai_crash(cx: &mut gpui::TestAppContext) { + let app_state = init_test(cx); + cx.update(init); + let project = Project::test(app_state.fs.clone(), [], cx).await; + let _window = cx.add_window(|window, cx| Workspace::test_new(project, window, cx)); + + cx.run_until_parked(); + + cx.update(|cx| { + SettingsStore::update_global(cx, |settings_store, cx| { + settings_store.update_user_settings(cx, |settings| { + settings.disable_ai = Some(SaturatingBool(true)); + }); + }); + }); + + cx.run_until_parked(); + + // If this panics, the test has failed + } + #[gpui::test] async fn test_prefer_focused_window(cx: &mut gpui::TestAppContext) { let app_state = init_test(cx); From 83ca2f9e88945df30659e5f76b75b3bac941b294 Mon Sep 17 00:00:00 2001 From: Xipeng Jin <56369076+xipeng-jin@users.noreply.github.com> Date: Wed, 17 Dec 2025 13:53:48 -0500 Subject: [PATCH 139/266] Add Vim-like Which-key Popup menu (#43618) Closes #10910 Follow up work continuing from the last PR https://github.com/zed-industries/zed/pull/42659. Add the UI element for displaying vim like which-key menu. https://github.com/user-attachments/assets/3dc5f0c9-5a2f-459e-a3db-859169aeba26 Release Notes: - Added a which-key like modal with a compact, single-column panel anchored to the bottom-right. You can enable with `{"which_key": {"enabled": true}}` in your settings. --------- Co-authored-by: Conrad Irwin Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com> --- Cargo.lock | 15 + Cargo.toml | 2 + assets/settings/default.json | 7 + crates/gpui/src/key_dispatch.rs | 11 + crates/gpui/src/keymap.rs | 35 +++ crates/gpui/src/window.rs | 7 + crates/settings/src/settings_content.rs | 16 ++ crates/settings/src/vscode_import.rs | 1 + crates/settings_ui/src/page_data.rs | 43 +++ crates/which_key/Cargo.toml | 23 ++ crates/which_key/LICENSE-GPL | 1 + crates/which_key/src/which_key.rs | 98 +++++++ crates/which_key/src/which_key_modal.rs | 308 +++++++++++++++++++++ crates/which_key/src/which_key_settings.rs | 18 ++ crates/workspace/src/modal_layer.rs | 16 +- crates/zed/Cargo.toml | 1 + crates/zed/src/main.rs | 1 + 17 files changed, 602 insertions(+), 1 deletion(-) create mode 100644 crates/which_key/Cargo.toml create mode 120000 crates/which_key/LICENSE-GPL create mode 100644 crates/which_key/src/which_key.rs create mode 100644 crates/which_key/src/which_key_modal.rs create mode 100644 crates/which_key/src/which_key_settings.rs diff --git a/Cargo.lock b/Cargo.lock index de9cb227c6cfb799099abf446c1bdee61ec85bff..146f0e19741610d3676d7781fa74982ff2e55918 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -19120,6 +19120,20 @@ dependencies = [ "winsafe", ] +[[package]] +name = "which_key" +version = "0.1.0" +dependencies = [ + "command_palette", + "gpui", + "serde", + "settings", + "theme", + "ui", + "util", + "workspace", +] + [[package]] name = "whoami" version = "1.6.1" @@ -20730,6 +20744,7 @@ dependencies = [ "watch", "web_search", "web_search_providers", + "which_key", "windows 0.61.3", "winresource", "workspace", diff --git a/Cargo.toml b/Cargo.toml index a8002e207d7ba9d3699832ac76be530e1979ead4..13bb4ceea133e16e8cf89461cd1fe7084d448eae 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -192,6 +192,7 @@ members = [ "crates/vercel", "crates/vim", "crates/vim_mode_setting", + "crates/which_key", "crates/watch", "crates/web_search", "crates/web_search_providers", @@ -415,6 +416,7 @@ util_macros = { path = "crates/util_macros" } vercel = { path = "crates/vercel" } vim = { path = "crates/vim" } vim_mode_setting = { path = "crates/vim_mode_setting" } +which_key = { path = "crates/which_key" } watch = { path = "crates/watch" } web_search = { path = "crates/web_search" } diff --git a/assets/settings/default.json b/assets/settings/default.json index a0e499934428b4bafcbe12b97b2e8fc4747a5f31..a0280b402a0d5c6b71aca296021cc7f43c222521 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -2152,6 +2152,13 @@ // The shape can be one of the following: "block", "bar", "underline", "hollow". "cursor_shape": {}, }, + // Which-key popup settings + "which_key": { + // Whether to show the which-key popup when holding down key combinations. + "enabled": false, + // Delay in milliseconds before showing the which-key popup. + "delay_ms": 1000, + }, // The server to connect to. If the environment variable // ZED_SERVER_URL is set, it will override this setting. "server_url": "https://zed.dev", diff --git a/crates/gpui/src/key_dispatch.rs b/crates/gpui/src/key_dispatch.rs index 85aa550fa96ca76e46f8d75ab84e91a7e9ba43cd..1b92b9fe3ffabdbeec4bc7450adc1439e8e223eb 100644 --- a/crates/gpui/src/key_dispatch.rs +++ b/crates/gpui/src/key_dispatch.rs @@ -462,6 +462,17 @@ impl DispatchTree { (bindings, partial, context_stack) } + /// Find the bindings that can follow the current input sequence. + pub fn possible_next_bindings_for_input( + &self, + input: &[Keystroke], + context_stack: &[KeyContext], + ) -> Vec { + self.keymap + .borrow() + .possible_next_bindings_for_input(input, context_stack) + } + /// dispatch_key processes the keystroke /// input should be set to the value of `pending` from the previous call to dispatch_key. /// This returns three instructions to the input handler: diff --git a/crates/gpui/src/keymap.rs b/crates/gpui/src/keymap.rs index 33d956917055942cce365e9069cbb007e202eaf2..d5398ff0447849ca5bfcdbbb5a838af0cbc22836 100644 --- a/crates/gpui/src/keymap.rs +++ b/crates/gpui/src/keymap.rs @@ -215,6 +215,41 @@ impl Keymap { Some(contexts.len()) } } + + /// Find the bindings that can follow the current input sequence. + pub fn possible_next_bindings_for_input( + &self, + input: &[Keystroke], + context_stack: &[KeyContext], + ) -> Vec { + let mut bindings = self + .bindings() + .enumerate() + .rev() + .filter_map(|(ix, binding)| { + let depth = self.binding_enabled(binding, context_stack)?; + let pending = binding.match_keystrokes(input); + match pending { + None => None, + Some(is_pending) => { + if !is_pending || is_no_action(&*binding.action) { + return None; + } + Some((depth, BindingIndex(ix), binding)) + } + } + }) + .collect::>(); + + bindings.sort_by(|(depth_a, ix_a, _), (depth_b, ix_b, _)| { + depth_b.cmp(depth_a).then(ix_b.cmp(ix_a)) + }); + + bindings + .into_iter() + .map(|(_, _, binding)| binding.clone()) + .collect::>() + } } #[cfg(test)] diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index dd20f71c22e388e0c739083d45941270ac8eac8e..840f2223fcc4a62b6e522f38b967a3fe4ad3209e 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -4450,6 +4450,13 @@ impl Window { dispatch_tree.highest_precedence_binding_for_action(action, &context_stack) } + /// Find the bindings that can follow the current input sequence for the current context stack. + pub fn possible_bindings_for_input(&self, input: &[Keystroke]) -> Vec { + self.rendered_frame + .dispatch_tree + .possible_next_bindings_for_input(input, &self.context_stack()) + } + fn context_stack_for_focus_handle( &self, focus_handle: &FocusHandle, diff --git a/crates/settings/src/settings_content.rs b/crates/settings/src/settings_content.rs index 3d7e6b5948b1db4d375814d6969ddabe95fc3e58..a00daaab1b9a93e1ec20b173dd6864849880d55e 100644 --- a/crates/settings/src/settings_content.rs +++ b/crates/settings/src/settings_content.rs @@ -158,6 +158,9 @@ pub struct SettingsContent { /// Default: false pub disable_ai: Option, + /// Settings for the which-key popup. + pub which_key: Option, + /// Settings related to Vim mode in Zed. pub vim: Option, } @@ -976,6 +979,19 @@ pub struct ReplSettingsContent { pub max_columns: Option, } +/// Settings for configuring the which-key popup behaviour. +#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema, MergeFrom)] +pub struct WhichKeySettingsContent { + /// Whether to show the which-key popup when holding down key combinations + /// + /// Default: false + pub enabled: Option, + /// Delay in milliseconds before showing the which-key popup. + /// + /// Default: 700 + pub delay_ms: Option, +} + #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize, JsonSchema)] /// An ExtendingVec in the settings can only accumulate new values. /// diff --git a/crates/settings/src/vscode_import.rs b/crates/settings/src/vscode_import.rs index 587850303f13649fcc4adf8cf4ddbb8dc7181dcb..d77754f611e8eb1746ee9061ce5b5e1dfdbdafdb 100644 --- a/crates/settings/src/vscode_import.rs +++ b/crates/settings/src/vscode_import.rs @@ -215,6 +215,7 @@ impl VsCodeSettings { vim: None, vim_mode: None, workspace: self.workspace_settings_content(), + which_key: None, } } diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs index 1d0603de3184ad9da874b428a94af37d8966e6a2..c8775bad42a9a8bd6aa5e57bafbb817b99619e68 100644 --- a/crates/settings_ui/src/page_data.rs +++ b/crates/settings_ui/src/page_data.rs @@ -1233,6 +1233,49 @@ pub(crate) fn settings_data(cx: &App) -> Vec { } }).collect(), }), + SettingsPageItem::SectionHeader("Which-key Menu"), + SettingsPageItem::SettingItem(SettingItem { + title: "Show Which-key Menu", + description: "Display the which-key menu with matching bindings while a multi-stroke binding is pending.", + field: Box::new(SettingField { + json_path: Some("which_key.enabled"), + pick: |settings_content| { + settings_content + .which_key + .as_ref() + .and_then(|settings| settings.enabled.as_ref()) + }, + write: |settings_content, value| { + settings_content + .which_key + .get_or_insert_default() + .enabled = value; + }, + }), + metadata: None, + files: USER, + }), + SettingsPageItem::SettingItem(SettingItem { + title: "Menu Delay", + description: "Delay in milliseconds before the which-key menu appears.", + field: Box::new(SettingField { + json_path: Some("which_key.delay_ms"), + pick: |settings_content| { + settings_content + .which_key + .as_ref() + .and_then(|settings| settings.delay_ms.as_ref()) + }, + write: |settings_content, value| { + settings_content + .which_key + .get_or_insert_default() + .delay_ms = value; + }, + }), + metadata: None, + files: USER, + }), SettingsPageItem::SectionHeader("Multibuffer"), SettingsPageItem::SettingItem(SettingItem { title: "Double Click In Multibuffer", diff --git a/crates/which_key/Cargo.toml b/crates/which_key/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..f53ba45dd71abc972ce23efb8871f485dfe47207 --- /dev/null +++ b/crates/which_key/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "which_key" +version = "0.1.0" +edition.workspace = true +publish.workspace = true +license = "GPL-3.0-or-later" + +[lints] +workspace = true + +[lib] +path = "src/which_key.rs" +doctest = false + +[dependencies] +command_palette.workspace = true +gpui.workspace = true +serde.workspace = true +settings.workspace = true +theme.workspace = true +ui.workspace = true +util.workspace = true +workspace.workspace = true diff --git a/crates/which_key/LICENSE-GPL b/crates/which_key/LICENSE-GPL new file mode 120000 index 0000000000000000000000000000000000000000..89e542f750cd3860a0598eff0dc34b56d7336dc4 --- /dev/null +++ b/crates/which_key/LICENSE-GPL @@ -0,0 +1 @@ +../../LICENSE-GPL \ No newline at end of file diff --git a/crates/which_key/src/which_key.rs b/crates/which_key/src/which_key.rs new file mode 100644 index 0000000000000000000000000000000000000000..70889c100f33020a3ceaa8af1ba8812d5e7d4adb --- /dev/null +++ b/crates/which_key/src/which_key.rs @@ -0,0 +1,98 @@ +//! Which-key support for Zed. + +mod which_key_modal; +mod which_key_settings; + +use gpui::{App, Keystroke}; +use settings::Settings; +use std::{sync::LazyLock, time::Duration}; +use util::ResultExt; +use which_key_modal::WhichKeyModal; +use which_key_settings::WhichKeySettings; +use workspace::Workspace; + +pub fn init(cx: &mut App) { + WhichKeySettings::register(cx); + + cx.observe_new(|_: &mut Workspace, window, cx| { + let Some(window) = window else { + return; + }; + let mut timer = None; + cx.observe_pending_input(window, move |workspace, window, cx| { + if window.pending_input_keystrokes().is_none() { + if let Some(modal) = workspace.active_modal::(cx) { + modal.update(cx, |modal, cx| modal.dismiss(cx)); + }; + timer.take(); + return; + } + + let which_key_settings = WhichKeySettings::get_global(cx); + if !which_key_settings.enabled { + return; + } + + let delay_ms = which_key_settings.delay_ms; + + timer.replace(cx.spawn_in(window, async move |workspace_handle, cx| { + cx.background_executor() + .timer(Duration::from_millis(delay_ms)) + .await; + workspace_handle + .update_in(cx, |workspace, window, cx| { + if workspace.active_modal::(cx).is_some() { + return; + }; + + workspace.toggle_modal(window, cx, |window, cx| { + WhichKeyModal::new(workspace_handle.clone(), window, cx) + }); + }) + .log_err(); + })); + }) + .detach(); + }) + .detach(); +} + +// Hard-coded list of keystrokes to filter out from which-key display +pub static FILTERED_KEYSTROKES: LazyLock>> = LazyLock::new(|| { + [ + // Modifiers on normal vim commands + "g h", + "g j", + "g k", + "g l", + "g $", + "g ^", + // Duplicate keys with "ctrl" held, e.g. "ctrl-w ctrl-a" is duplicate of "ctrl-w a" + "ctrl-w ctrl-a", + "ctrl-w ctrl-c", + "ctrl-w ctrl-h", + "ctrl-w ctrl-j", + "ctrl-w ctrl-k", + "ctrl-w ctrl-l", + "ctrl-w ctrl-n", + "ctrl-w ctrl-o", + "ctrl-w ctrl-p", + "ctrl-w ctrl-q", + "ctrl-w ctrl-s", + "ctrl-w ctrl-v", + "ctrl-w ctrl-w", + "ctrl-w ctrl-]", + "ctrl-w ctrl-shift-w", + "ctrl-w ctrl-g t", + "ctrl-w ctrl-g shift-t", + ] + .iter() + .filter_map(|s| { + let keystrokes: Result, _> = s + .split(' ') + .map(|keystroke_str| Keystroke::parse(keystroke_str)) + .collect(); + keystrokes.ok() + }) + .collect() +}); diff --git a/crates/which_key/src/which_key_modal.rs b/crates/which_key/src/which_key_modal.rs new file mode 100644 index 0000000000000000000000000000000000000000..238431b90a8eafdd0e085a3f109e8f812fbe709b --- /dev/null +++ b/crates/which_key/src/which_key_modal.rs @@ -0,0 +1,308 @@ +//! Modal implementation for the which-key display. + +use gpui::prelude::FluentBuilder; +use gpui::{ + App, Context, DismissEvent, EventEmitter, FocusHandle, Focusable, FontWeight, Keystroke, + ScrollHandle, Subscription, WeakEntity, Window, +}; +use settings::Settings; +use std::collections::HashMap; +use theme::ThemeSettings; +use ui::{ + Divider, DividerColor, DynamicSpacing, LabelSize, WithScrollbar, prelude::*, + text_for_keystrokes, +}; +use workspace::{ModalView, Workspace}; + +use crate::FILTERED_KEYSTROKES; + +pub struct WhichKeyModal { + _workspace: WeakEntity, + focus_handle: FocusHandle, + scroll_handle: ScrollHandle, + bindings: Vec<(SharedString, SharedString)>, + pending_keys: SharedString, + _pending_input_subscription: Subscription, + _focus_out_subscription: Subscription, +} + +impl WhichKeyModal { + pub fn new( + workspace: WeakEntity, + window: &mut Window, + cx: &mut Context, + ) -> Self { + // Keep focus where it currently is + let focus_handle = window.focused(cx).unwrap_or(cx.focus_handle()); + + let handle = cx.weak_entity(); + let mut this = Self { + _workspace: workspace, + focus_handle: focus_handle.clone(), + scroll_handle: ScrollHandle::new(), + bindings: Vec::new(), + pending_keys: SharedString::new_static(""), + _pending_input_subscription: cx.observe_pending_input( + window, + |this: &mut Self, window, cx| { + this.update_pending_keys(window, cx); + }, + ), + _focus_out_subscription: window.on_focus_out(&focus_handle, cx, move |_, _, cx| { + handle.update(cx, |_, cx| cx.emit(DismissEvent)).ok(); + }), + }; + this.update_pending_keys(window, cx); + this + } + + pub fn dismiss(&self, cx: &mut Context) { + cx.emit(DismissEvent) + } + + fn update_pending_keys(&mut self, window: &mut Window, cx: &mut Context) { + let Some(pending_keys) = window.pending_input_keystrokes() else { + cx.emit(DismissEvent); + return; + }; + let bindings = window.possible_bindings_for_input(pending_keys); + + let mut binding_data = bindings + .iter() + .map(|binding| { + // Map to keystrokes + ( + binding + .keystrokes() + .iter() + .map(|k| k.inner().to_owned()) + .collect::>(), + binding.action(), + ) + }) + .filter(|(keystrokes, _action)| { + // Check if this binding matches any filtered keystroke pattern + !FILTERED_KEYSTROKES.iter().any(|filtered| { + keystrokes.len() >= filtered.len() + && keystrokes[..filtered.len()] == filtered[..] + }) + }) + .map(|(keystrokes, action)| { + // Map to remaining keystrokes and action name + let remaining_keystrokes = keystrokes[pending_keys.len()..].to_vec(); + let action_name: SharedString = + command_palette::humanize_action_name(action.name()).into(); + (remaining_keystrokes, action_name) + }) + .collect(); + + binding_data = group_bindings(binding_data); + + // Sort bindings from shortest to longest, with groups last + // Using stable sort to preserve relative order of equal elements + binding_data.sort_by(|(keystrokes_a, action_a), (keystrokes_b, action_b)| { + // Groups (actions starting with "+") should go last + let is_group_a = action_a.starts_with('+'); + let is_group_b = action_b.starts_with('+'); + + // First, separate groups from non-groups + let group_cmp = is_group_a.cmp(&is_group_b); + if group_cmp != std::cmp::Ordering::Equal { + return group_cmp; + } + + // Then sort by keystroke count + let keystroke_cmp = keystrokes_a.len().cmp(&keystrokes_b.len()); + if keystroke_cmp != std::cmp::Ordering::Equal { + return keystroke_cmp; + } + + // Finally sort by text length, then lexicographically for full stability + let text_a = text_for_keystrokes(keystrokes_a, cx); + let text_b = text_for_keystrokes(keystrokes_b, cx); + let text_len_cmp = text_a.len().cmp(&text_b.len()); + if text_len_cmp != std::cmp::Ordering::Equal { + return text_len_cmp; + } + text_a.cmp(&text_b) + }); + binding_data.dedup(); + self.pending_keys = text_for_keystrokes(&pending_keys, cx).into(); + self.bindings = binding_data + .into_iter() + .map(|(keystrokes, action)| (text_for_keystrokes(&keystrokes, cx).into(), action)) + .collect(); + } +} + +impl Render for WhichKeyModal { + fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement { + let has_rows = !self.bindings.is_empty(); + let viewport_size = window.viewport_size(); + + let max_panel_width = px((f32::from(viewport_size.width) * 0.5).min(480.0)); + let max_content_height = px(f32::from(viewport_size.height) * 0.4); + + // Push above status bar when visible + let status_height = self + ._workspace + .upgrade() + .and_then(|workspace| { + workspace.read_with(cx, |workspace, cx| { + if workspace.status_bar_visible(cx) { + Some( + DynamicSpacing::Base04.px(cx) * 2.0 + + ThemeSettings::get_global(cx).ui_font_size(cx), + ) + } else { + None + } + }) + }) + .unwrap_or(px(0.)); + + let margin_bottom = px(16.); + let bottom_offset = margin_bottom + status_height; + + // Title section + let title_section = { + let mut column = v_flex().gap(px(0.)).child( + div() + .child( + Label::new(self.pending_keys.clone()) + .size(LabelSize::Default) + .weight(FontWeight::MEDIUM) + .color(Color::Accent), + ) + .mb(px(2.)), + ); + + if has_rows { + column = column.child( + div() + .child(Divider::horizontal().color(DividerColor::BorderFaded)) + .mb(px(2.)), + ); + } + + column + }; + + let content = h_flex() + .items_start() + .id("which-key-content") + .gap(px(8.)) + .overflow_y_scroll() + .track_scroll(&self.scroll_handle) + .h_full() + .max_h(max_content_height) + .child( + // Keystrokes column + v_flex() + .gap(px(4.)) + .flex_shrink_0() + .children(self.bindings.iter().map(|(keystrokes, _)| { + div() + .child( + Label::new(keystrokes.clone()) + .size(LabelSize::Default) + .color(Color::Accent), + ) + .text_align(gpui::TextAlign::Right) + })), + ) + .child( + // Actions column + v_flex() + .gap(px(4.)) + .flex_1() + .min_w_0() + .children(self.bindings.iter().map(|(_, action_name)| { + let is_group = action_name.starts_with('+'); + let label_color = if is_group { + Color::Success + } else { + Color::Default + }; + + div().child( + Label::new(action_name.clone()) + .size(LabelSize::Default) + .color(label_color) + .single_line() + .truncate(), + ) + })), + ); + + div() + .id("which-key-buffer-panel-scroll") + .occlude() + .absolute() + .bottom(bottom_offset) + .right(px(16.)) + .min_w(px(220.)) + .max_w(max_panel_width) + .elevation_3(cx) + .px(px(12.)) + .child(v_flex().child(title_section).when(has_rows, |el| { + el.child( + div() + .max_h(max_content_height) + .child(content) + .vertical_scrollbar_for(&self.scroll_handle, window, cx), + ) + })) + } +} + +impl EventEmitter for WhichKeyModal {} + +impl Focusable for WhichKeyModal { + fn focus_handle(&self, _cx: &App) -> gpui::FocusHandle { + self.focus_handle.clone() + } +} + +impl ModalView for WhichKeyModal { + fn render_bare(&self) -> bool { + true + } +} + +fn group_bindings( + binding_data: Vec<(Vec, SharedString)>, +) -> Vec<(Vec, SharedString)> { + let mut groups: HashMap, Vec<(Vec, SharedString)>> = + HashMap::new(); + + // Group bindings by their first keystroke + for (remaining_keystrokes, action_name) in binding_data { + let first_key = remaining_keystrokes.first().cloned(); + groups + .entry(first_key) + .or_default() + .push((remaining_keystrokes, action_name)); + } + + let mut result = Vec::new(); + + for (first_key, mut group_bindings) in groups { + // Remove duplicates within each group + group_bindings.dedup_by_key(|(keystrokes, _)| keystrokes.clone()); + + if let Some(first_key) = first_key + && group_bindings.len() > 1 + { + // This is a group - create a single entry with just the first keystroke + let first_keystroke = vec![first_key]; + let count = group_bindings.len(); + result.push((first_keystroke, format!("+{} keybinds", count).into())); + } else { + // Not a group or empty keystrokes - add all bindings as-is + result.append(&mut group_bindings); + } + } + + result +} diff --git a/crates/which_key/src/which_key_settings.rs b/crates/which_key/src/which_key_settings.rs new file mode 100644 index 0000000000000000000000000000000000000000..be19ab1521f4793305efca79b7026f79fd9064e2 --- /dev/null +++ b/crates/which_key/src/which_key_settings.rs @@ -0,0 +1,18 @@ +use settings::{RegisterSetting, Settings, SettingsContent, WhichKeySettingsContent}; + +#[derive(Debug, Clone, Copy, RegisterSetting)] +pub struct WhichKeySettings { + pub enabled: bool, + pub delay_ms: u64, +} + +impl Settings for WhichKeySettings { + fn from_settings(content: &SettingsContent) -> Self { + let which_key: &WhichKeySettingsContent = content.which_key.as_ref().unwrap(); + + Self { + enabled: which_key.enabled.unwrap(), + delay_ms: which_key.delay_ms.unwrap(), + } + } +} diff --git a/crates/workspace/src/modal_layer.rs b/crates/workspace/src/modal_layer.rs index 10b24497a28faf68ed0820211f0d8860da558786..db4d85752835299117dba7fc2aeb1833383a390a 100644 --- a/crates/workspace/src/modal_layer.rs +++ b/crates/workspace/src/modal_layer.rs @@ -22,12 +22,17 @@ pub trait ModalView: ManagedView { fn fade_out_background(&self) -> bool { false } + + fn render_bare(&self) -> bool { + false + } } trait ModalViewHandle { fn on_before_dismiss(&mut self, window: &mut Window, cx: &mut App) -> DismissDecision; fn view(&self) -> AnyView; fn fade_out_background(&self, cx: &mut App) -> bool; + fn render_bare(&self, cx: &mut App) -> bool; } impl ModalViewHandle for Entity { @@ -42,6 +47,10 @@ impl ModalViewHandle for Entity { fn fade_out_background(&self, cx: &mut App) -> bool { self.read(cx).fade_out_background() } + + fn render_bare(&self, cx: &mut App) -> bool { + self.read(cx).render_bare() + } } pub struct ActiveModal { @@ -167,9 +176,13 @@ impl ModalLayer { impl Render for ModalLayer { fn render(&mut self, _: &mut Window, cx: &mut Context) -> impl IntoElement { let Some(active_modal) = &self.active_modal else { - return div(); + return div().into_any_element(); }; + if active_modal.modal.render_bare(cx) { + return active_modal.modal.view().into_any_element(); + } + div() .absolute() .size_full() @@ -195,5 +208,6 @@ impl Render for ModalLayer { }), ), ) + .into_any_element() } } diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml index b5b33850da8da9035276c7752ad72da9bf0b55b9..fd160759f4440e2736d57cea62abb6bdb138ae72 100644 --- a/crates/zed/Cargo.toml +++ b/crates/zed/Cargo.toml @@ -163,6 +163,7 @@ vim_mode_setting.workspace = true watch.workspace = true web_search.workspace = true web_search_providers.workspace = true +which_key.workspace = true workspace.workspace = true zed_actions.workspace = true zed_env_vars.workspace = true diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs index a827e33f00935bb02e4bc9f761d673ab12a32f14..7008e491c5e2ade35fa96cafbd9d8969c008fa96 100644 --- a/crates/zed/src/main.rs +++ b/crates/zed/src/main.rs @@ -656,6 +656,7 @@ pub fn main() { inspector_ui::init(app_state.clone(), cx); json_schema_store::init(cx); miniprofiler_ui::init(*STARTUP_TIME.get().unwrap(), cx); + which_key::init(cx); cx.observe_global::({ let http = app_state.client.http_client(); From 27c5d39d285e56b6b77d751268690fcfe411d6b4 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Wed, 17 Dec 2025 13:56:15 -0500 Subject: [PATCH 140/266] Add Gemini 3 Flash (#45139) Add support for the new Gemini 3 Flash model Release Notes: - Added support for Gemini 3 Flash model --- crates/google_ai/src/google_ai.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rs index 3eff860e16f15fae76d8f9cb2523d2b91b611125..b6bba48c4b04608b502932787cfcdcd429276b5b 100644 --- a/crates/google_ai/src/google_ai.rs +++ b/crates/google_ai/src/google_ai.rs @@ -512,6 +512,8 @@ pub enum Model { Gemini25Pro, #[serde(rename = "gemini-3-pro-preview")] Gemini3Pro, + #[serde(rename = "gemini-3-flash-preview")] + Gemini3Flash, #[serde(rename = "custom")] Custom { name: String, @@ -534,6 +536,7 @@ impl Model { Self::Gemini25Flash => "gemini-2.5-flash", Self::Gemini25Pro => "gemini-2.5-pro", Self::Gemini3Pro => "gemini-3-pro-preview", + Self::Gemini3Flash => "gemini-3-flash-preview", Self::Custom { name, .. } => name, } } @@ -543,6 +546,7 @@ impl Model { Self::Gemini25Flash => "gemini-2.5-flash", Self::Gemini25Pro => "gemini-2.5-pro", Self::Gemini3Pro => "gemini-3-pro-preview", + Self::Gemini3Flash => "gemini-3-flash-preview", Self::Custom { name, .. } => name, } } @@ -553,6 +557,7 @@ impl Model { Self::Gemini25Flash => "Gemini 2.5 Flash", Self::Gemini25Pro => "Gemini 2.5 Pro", Self::Gemini3Pro => "Gemini 3 Pro", + Self::Gemini3Flash => "Gemini 3 Flash", Self::Custom { name, display_name, .. } => display_name.as_ref().unwrap_or(name), @@ -565,6 +570,7 @@ impl Model { Self::Gemini25Flash => 1_048_576, Self::Gemini25Pro => 1_048_576, Self::Gemini3Pro => 1_048_576, + Self::Gemini3Flash => 1_048_576, Self::Custom { max_tokens, .. } => *max_tokens, } } @@ -575,6 +581,7 @@ impl Model { Model::Gemini25Flash => Some(65_536), Model::Gemini25Pro => Some(65_536), Model::Gemini3Pro => Some(65_536), + Model::Gemini3Flash => Some(65_536), Model::Custom { .. } => None, } } @@ -599,6 +606,7 @@ impl Model { budget_tokens: None, } } + Self::Gemini3Flash => GoogleModelMode::Default, Self::Custom { mode, .. } => *mode, } } From fa529b2ad272881aa45c66242ad02934cb22d624 Mon Sep 17 00:00:00 2001 From: "Oleksii (Alexey) Orlenko" Date: Wed, 17 Dec 2025 20:00:37 +0100 Subject: [PATCH 141/266] agent_ui_v2: Fix broken LICENSE-GPL symlink pointing to itself (#45136) Fix broken LICENSE-GPL symlink that was pointing to itself instead of the LICENSE-GPL file in the root of the repo. It caused jujutsu to freak out and made it impossible to work with the repo using it without switching to raw git: ``` Internal error: Failed to check out commit 22d04a82b119882e7aed88fb422430367c4df5f9 Caused by: 1: Failed to validate path /Users/aqrln/git/zed/crates/agent_ui_v2/LICENSE-GPL 2: Too many levels of symbolic links (os error 62) ``` Release Notes: - N/A --- crates/agent_ui_v2/LICENSE-GPL | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/agent_ui_v2/LICENSE-GPL b/crates/agent_ui_v2/LICENSE-GPL index e0f9dbd5d63fef1630c297edc4ceba4790be6f02..89e542f750cd3860a0598eff0dc34b56d7336dc4 120000 --- a/crates/agent_ui_v2/LICENSE-GPL +++ b/crates/agent_ui_v2/LICENSE-GPL @@ -1 +1 @@ -LICENSE-GPL \ No newline at end of file +../../LICENSE-GPL \ No newline at end of file From 73f129a6858098b485ce2321e7141d30da815280 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Luis=20Coss=C3=ADo?= Date: Wed, 17 Dec 2025 16:40:15 -0300 Subject: [PATCH 142/266] git: New actions for git panel navigation (#43701) I could not find any related issue, but at least I want to use the git panel like this :) Being used to `lazygit`, this PR makes navigation of the git panel more similar to the CLI tool. Instead of selecting -> enter'ing for skimming each file, I just want to move between the files in the git panel and have the diff multibuffer advance to the appropriate file. This also adheres to the behavior of the outline panel, which I like better. If the multibuffer is not active, it behaves same as before (just selecting the file in the panel, nothing else). I did not modify existing `menu::Select*` actions in case anybody still prefers previous behavior. https://github.com/user-attachments/assets/2d1303d4-50c8-4500-ab3b-302eb7d4afda Release Notes: - Improved navigation of the git panel, by advancing the "Uncommitted Changes" multibuffer to the current selected file. To restore the old behavior, you can bind `up` and `down` to `menu::SelectPrevious` and `menu::SelectNext` under the `GitPanel` context in your keymap. Co-authored-by: Cole Miller --- assets/keymaps/default-linux.json | 4 +- assets/keymaps/default-macos.json | 8 +-- assets/keymaps/default-windows.json | 4 +- crates/git_ui/src/git_panel.rs | 80 ++++++++++++++++++++++++----- 4 files changed, 75 insertions(+), 21 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index f09ac0a812c3e875618c57da15bcf16e1f983d6e..ec21bc152edf969f57ac341e4b92f78c9e5da11a 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -905,8 +905,8 @@ "bindings": { "left": "git_panel::CollapseSelectedEntry", "right": "git_panel::ExpandSelectedEntry", - "up": "menu::SelectPrevious", - "down": "menu::SelectNext", + "up": "git_panel::PreviousEntry", + "down": "git_panel::NextEntry", "enter": "menu::Confirm", "alt-y": "git::StageFile", "alt-shift-y": "git::UnstageFile", diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index 1d489771febc770e300b63e265024ffca3d14a90..fd2605a6ad99177c887d6f804ec2ac70724f16f8 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -981,12 +981,12 @@ "context": "GitPanel && ChangesList", "use_key_equivalents": true, "bindings": { + "up": "git_panel::PreviousEntry", + "down": "git_panel::NextEntry", + "cmd-up": "git_panel::FirstEntry", + "cmd-down": "git_panel::LastEntry", "left": "git_panel::CollapseSelectedEntry", "right": "git_panel::ExpandSelectedEntry", - "up": "menu::SelectPrevious", - "down": "menu::SelectNext", - "cmd-up": "menu::SelectFirst", - "cmd-down": "menu::SelectLast", "enter": "menu::Confirm", "cmd-alt-y": "git::ToggleStaged", "space": "git::ToggleStaged", diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index 9154cc43afb86c287329229c6f0d699f59a82b36..4a700e2c9190a8ae23ed53edaa075703fa07b855 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -908,10 +908,10 @@ "context": "GitPanel && ChangesList", "use_key_equivalents": true, "bindings": { + "up": "git_panel::PreviousEntry", + "down": "git_panel::NextEntry", "left": "git_panel::CollapseSelectedEntry", "right": "git_panel::ExpandSelectedEntry", - "up": "menu::SelectPrevious", - "down": "menu::SelectNext", "enter": "menu::Confirm", "alt-y": "git::StageFile", "shift-alt-y": "git::UnstageFile", diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index cf73406b3851b46ad1a7d056d6cb335666b9ac65..90c9b92cf882f25f50cebab776fc328a22cda022 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -46,7 +46,7 @@ use language_model::{ ConfiguredModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role, ZED_CLOUD_PROVIDER_ID, }; -use menu::{Confirm, SecondaryConfirm, SelectFirst, SelectLast, SelectNext, SelectPrevious}; +use menu; use multi_buffer::ExcerptInfo; use notifications::status_toast::{StatusToast, ToastIcon}; use panel::{ @@ -93,6 +93,14 @@ actions!( FocusEditor, /// Focuses on the changes list. FocusChanges, + /// Select next git panel menu item, and show it in the diff view + NextEntry, + /// Select previous git panel menu item, and show it in the diff view + PreviousEntry, + /// Select first git panel menu item, and show it in the diff view + FirstEntry, + /// Select last git panel menu item, and show it in the diff view + LastEntry, /// Toggles automatic co-author suggestions. ToggleFillCoAuthors, /// Toggles sorting entries by path vs status. @@ -914,12 +922,12 @@ impl GitPanel { if let GitListEntry::Directory(dir_entry) = entry { if dir_entry.expanded { - self.select_next(&SelectNext, window, cx); + self.select_next(&menu::SelectNext, window, cx); } else { self.toggle_directory(&dir_entry.key, window, cx); } } else { - self.select_next(&SelectNext, window, cx); + self.select_next(&menu::SelectNext, window, cx); } } @@ -937,14 +945,19 @@ impl GitPanel { if dir_entry.expanded { self.toggle_directory(&dir_entry.key, window, cx); } else { - self.select_previous(&SelectPrevious, window, cx); + self.select_previous(&menu::SelectPrevious, window, cx); } } else { - self.select_previous(&SelectPrevious, window, cx); + self.select_previous(&menu::SelectPrevious, window, cx); } } - fn select_first(&mut self, _: &SelectFirst, _window: &mut Window, cx: &mut Context) { + fn select_first( + &mut self, + _: &menu::SelectFirst, + _window: &mut Window, + cx: &mut Context, + ) { let first_entry = match &self.view_mode { GitPanelViewMode::Flat => self .entries @@ -967,7 +980,7 @@ impl GitPanel { fn select_previous( &mut self, - _: &SelectPrevious, + _: &menu::SelectPrevious, _window: &mut Window, cx: &mut Context, ) { @@ -1016,7 +1029,7 @@ impl GitPanel { self.scroll_to_selected_entry(cx); } - fn select_next(&mut self, _: &SelectNext, _window: &mut Window, cx: &mut Context) { + fn select_next(&mut self, _: &menu::SelectNext, _window: &mut Window, cx: &mut Context) { let item_count = self.entries.len(); if item_count == 0 { return; @@ -1054,13 +1067,50 @@ impl GitPanel { self.scroll_to_selected_entry(cx); } - fn select_last(&mut self, _: &SelectLast, _window: &mut Window, cx: &mut Context) { + fn select_last(&mut self, _: &menu::SelectLast, _window: &mut Window, cx: &mut Context) { if self.entries.last().is_some() { self.selected_entry = Some(self.entries.len() - 1); self.scroll_to_selected_entry(cx); } } + /// Show diff view at selected entry, only if the diff view is open + fn move_diff_to_entry(&mut self, window: &mut Window, cx: &mut Context) { + maybe!({ + let workspace = self.workspace.upgrade()?; + + if let Some(project_diff) = workspace.read(cx).item_of_type::(cx) { + let entry = self.entries.get(self.selected_entry?)?.status_entry()?; + + project_diff.update(cx, |project_diff, cx| { + project_diff.move_to_entry(entry.clone(), window, cx); + }); + } + + Some(()) + }); + } + + fn first_entry(&mut self, _: &FirstEntry, window: &mut Window, cx: &mut Context) { + self.select_first(&menu::SelectFirst, window, cx); + self.move_diff_to_entry(window, cx); + } + + fn last_entry(&mut self, _: &LastEntry, window: &mut Window, cx: &mut Context) { + self.select_last(&menu::SelectLast, window, cx); + self.move_diff_to_entry(window, cx); + } + + fn next_entry(&mut self, _: &NextEntry, window: &mut Window, cx: &mut Context) { + self.select_next(&menu::SelectNext, window, cx); + self.move_diff_to_entry(window, cx); + } + + fn previous_entry(&mut self, _: &PreviousEntry, window: &mut Window, cx: &mut Context) { + self.select_previous(&menu::SelectPrevious, window, cx); + self.move_diff_to_entry(window, cx); + } + fn focus_editor(&mut self, _: &FocusEditor, window: &mut Window, cx: &mut Context) { self.commit_editor.update(cx, |editor, cx| { window.focus(&editor.focus_handle(cx), cx); @@ -1074,7 +1124,7 @@ impl GitPanel { .as_ref() .is_some_and(|active_repository| active_repository.read(cx).status_summary().count > 0); if have_entries && self.selected_entry.is_none() { - self.select_first(&SelectFirst, window, cx); + self.select_first(&menu::SelectFirst, window, cx); } } @@ -4726,8 +4776,8 @@ impl GitPanel { git::AddToGitignore.boxed_clone(), ) .separator() - .action("Open Diff", Confirm.boxed_clone()) - .action("Open File", SecondaryConfirm.boxed_clone()) + .action("Open Diff", menu::Confirm.boxed_clone()) + .action("Open File", menu::SecondaryConfirm.boxed_clone()) .separator() .action_disabled_when(is_created, "View File History", Box::new(git::FileHistory)) }); @@ -5390,6 +5440,10 @@ impl Render for GitPanel { .on_action(cx.listener(Self::select_next)) .on_action(cx.listener(Self::select_previous)) .on_action(cx.listener(Self::select_last)) + .on_action(cx.listener(Self::first_entry)) + .on_action(cx.listener(Self::next_entry)) + .on_action(cx.listener(Self::previous_entry)) + .on_action(cx.listener(Self::last_entry)) .on_action(cx.listener(Self::close_panel)) .on_action(cx.listener(Self::open_diff)) .on_action(cx.listener(Self::open_file)) @@ -6855,7 +6909,7 @@ mod tests { // the Project Diff's active path. panel.update_in(cx, |panel, window, cx| { panel.selected_entry = Some(1); - panel.open_diff(&Confirm, window, cx); + panel.open_diff(&menu::Confirm, window, cx); }); cx.run_until_parked(); From e8807e5764e370822fde859200279a7e963e1980 Mon Sep 17 00:00:00 2001 From: Xipeng Jin <56369076+xipeng-jin@users.noreply.github.com> Date: Wed, 17 Dec 2025 14:43:53 -0500 Subject: [PATCH 143/266] git: Fix tree view folders not opening when file inside is selected (#45137) Closes #44715 Release Notes: - Fixed git tree view folders don't open when file inside is selected --- crates/git_ui/src/git_panel.rs | 190 +++++++++++++++++++++++++++++++-- 1 file changed, 184 insertions(+), 6 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 90c9b92cf882f25f50cebab776fc328a22cda022..7216e1fc46e9d1240d23d8bd18202aa0963f846a 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -801,20 +801,63 @@ impl GitPanel { pub fn select_entry_by_path( &mut self, path: ProjectPath, - _: &mut Window, + window: &mut Window, cx: &mut Context, ) { let Some(git_repo) = self.active_repository.as_ref() else { return; }; - let Some(repo_path) = git_repo.read(cx).project_path_to_repo_path(&path, cx) else { - return; + + let (repo_path, section) = { + let repo = git_repo.read(cx); + let Some(repo_path) = repo.project_path_to_repo_path(&path, cx) else { + return; + }; + + let section = repo + .status_for_path(&repo_path) + .map(|status| status.status) + .map(|status| { + if repo.had_conflict_on_last_merge_head_change(&repo_path) { + Section::Conflict + } else if status.is_created() { + Section::New + } else { + Section::Tracked + } + }); + + (repo_path, section) }; + + let mut needs_rebuild = false; + if let (Some(section), Some(tree_state)) = (section, self.view_mode.tree_state_mut()) { + let mut current_dir = repo_path.parent(); + while let Some(dir) = current_dir { + let key = TreeKey { + section, + path: RepoPath::from_rel_path(dir), + }; + + if tree_state.expanded_dirs.get(&key) == Some(&false) { + tree_state.expanded_dirs.insert(key, true); + needs_rebuild = true; + } + + current_dir = dir.parent(); + } + } + + if needs_rebuild { + self.update_visible_entries(window, cx); + } + let Some(ix) = self.entry_by_path(&repo_path) else { return; }; + self.selected_entry = Some(ix); - cx.notify(); + self.scroll_to_selected_entry(cx); } fn serialization_key(workspace: &Workspace) -> Option { @@ -902,9 +945,22 @@ impl GitPanel { } fn scroll_to_selected_entry(&mut self, cx: &mut Context) { - if let Some(selected_entry) = self.selected_entry { + let Some(selected_entry) = self.selected_entry else { + cx.notify(); + return; + }; + + let visible_index = match &self.view_mode { + GitPanelViewMode::Flat => Some(selected_entry), + GitPanelViewMode::Tree(state) => state + .logical_indices + .iter() + .position(|&ix| ix == selected_entry), + }; + + if let Some(visible_index) = visible_index { self.scroll_handle - .scroll_to_item(selected_entry, ScrollStrategy::Center); + .scroll_to_item(visible_index, ScrollStrategy::Center); } cx.notify(); @@ -6925,6 +6981,128 @@ mod tests { }); } + #[gpui::test] + async fn test_tree_view_reveals_collapsed_parent_on_select_entry_by_path( + cx: &mut TestAppContext, + ) { + init_test(cx); + + let fs = FakeFs::new(cx.background_executor.clone()); + fs.insert_tree( + path!("/project"), + json!({ + ".git": {}, + "src": { + "a": { + "foo.rs": "fn foo() {}", + }, + "b": { + "bar.rs": "fn bar() {}", + }, + }, + }), + ) + .await; + + fs.set_status_for_repo( + path!("/project/.git").as_ref(), + &[ + ("src/a/foo.rs", StatusCode::Modified.worktree()), + ("src/b/bar.rs", StatusCode::Modified.worktree()), + ], + ); + + let project = Project::test(fs.clone(), [Path::new(path!("/project"))], cx).await; + let workspace = + cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx)); + let cx = &mut VisualTestContext::from_window(*workspace, cx); + + cx.read(|cx| { + project + .read(cx) + .worktrees(cx) + .next() + .unwrap() + .read(cx) + .as_local() + .unwrap() + .scan_complete() + }) + .await; + + cx.executor().run_until_parked(); + + cx.update(|_window, cx| { + SettingsStore::update_global(cx, |store, cx| { + store.update_user_settings(cx, |settings| { + settings.git_panel.get_or_insert_default().tree_view = Some(true); + }) + }); + }); + + let panel = workspace.update(cx, GitPanel::new).unwrap(); + + let handle = cx.update_window_entity(&panel, |panel, _, _| { + std::mem::replace(&mut panel.update_visible_entries_task, Task::ready(())) + }); + cx.executor().advance_clock(2 * UPDATE_DEBOUNCE); + handle.await; + + let src_key = panel.read_with(cx, |panel, _| { + panel + .entries + .iter() + .find_map(|entry| match entry { + GitListEntry::Directory(dir) if dir.key.path == repo_path("src") => { + Some(dir.key.clone()) + } + _ => None, + }) + .expect("src directory should exist in tree view") + }); + + panel.update_in(cx, |panel, window, cx| { + panel.toggle_directory(&src_key, window, cx); + }); + + panel.read_with(cx, |panel, _| { + let state = panel + .view_mode + .tree_state() + .expect("tree view state should exist"); + assert_eq!(state.expanded_dirs.get(&src_key).copied(), Some(false)); + }); + + let worktree_id = + cx.read(|cx| project.read(cx).worktrees(cx).next().unwrap().read(cx).id()); + let project_path = ProjectPath { + worktree_id, + path: RelPath::unix("src/a/foo.rs").unwrap().into_arc(), + }; + + panel.update_in(cx, |panel, window, cx| { + panel.select_entry_by_path(project_path, window, cx); + }); + + panel.read_with(cx, |panel, _| { + let state = panel + .view_mode + .tree_state() + .expect("tree view state should exist"); + assert_eq!(state.expanded_dirs.get(&src_key).copied(), Some(true)); + + let selected_ix = panel.selected_entry.expect("selection should be set"); + assert!(state.logical_indices.contains(&selected_ix)); + + let selected_entry = panel + .entries + .get(selected_ix) + .and_then(|entry| entry.status_entry()) + .expect("selected entry should be a status entry"); + assert_eq!(selected_entry.repo_path, repo_path("src/a/foo.rs")); + }); + } + fn assert_entry_paths(entries: &[GitListEntry], expected_paths: &[Option<&str>]) { assert_eq!(entries.len(), expected_paths.len()); for (entry, expected_path) in entries.iter().zip(expected_paths) { From 81463223d5cc887bac5a8b54f5b7000fd136f5fd Mon Sep 17 00:00:00 2001 From: Ichimura Tomoo Date: Thu, 18 Dec 2025 04:46:17 +0900 Subject: [PATCH 144/266] Support opening and saving files with legacy encodings (#44819) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary Addresses #16965 This PR adds support for **opening and saving** files with legacy encodings (non-UTF-8). Previously, Zed failed to open files encoded in Shift-JIS, EUC-JP, Big5, etc., displaying a "Could not open file" error screen. This PR implements automatic encoding detection upon opening and ensures the original encoding is preserved when saving. ## Implementation Details 1. **Worktree (Loading)**: * Updated `load_file` to use `chardetng` for automatic encoding detection. * Files are decoded to UTF-8 internal strings for editing, while preserving the detected `Encoding` metadata. 2. **Language / Buffer**: * Added an `encoding` field to the `Buffer` struct to store the detected encoding. 3. **Worktree (Saving)**: * Updated `write_file` to accept the stored encoding. * **Performance Optimization**: * **UTF-8 Path**: Uses the existing optimized `fs.save` (streaming chunks directly from Rope), ensuring no performance regression for the vast majority of files. * **Legacy Encoding Path**: Implemented a fallback that converts the Rope to a contiguous `String/Bytes` in memory, re-encodes it to the target format (e.g., Shift-JIS), and writes it to disk. * *Note*: This fallback involves memory allocation, but it is necessary to support legacy encodings without refactoring the `fs` crate's streaming interfaces. ## Changes - `crates/worktree`: - Add dependencies: `encoding_rs`, `chardetng`. - Update `load_file` to detect encoding and decode content. - Update `write_file` to handle re-encoding on save. - `crates/language`: Add `encoding` field and accessors to `Buffer`. - `crates/project`: Pass encoding information between Worktree and Buffer. - `crates/vim`: Update `:w` command to use the new `write_file` signature. ## Verification I validated this manually using a Rust script to generate test files with various encodings. **Results:** * ✅ **Success (Opened & Saved correctly):** * **Japanese:** `Shift-JIS` (CP932), `EUC-JP`, `ISO-2022-JP` * **Chinese:** `Big5` (Traditional), `GBK/GB2312` (Simplified) * **Western/Unicode:** `Windows-1252` (CP1252), `UTF-16LE`, `UTF-16BE` * ⚠️ **limitations (Detection accuracy):** * Some specific encodings like `KOI8-R` or generic `Latin1` (ISO-8859-1) may partially display replacement characters (`?`) depending on the file content length. This is a known limitation of the heuristic detection library (`chardetng`) rather than the saving logic. Release Notes: - Added support for opening and saving files with legacy encodings (Shift-JIS, Big5, etc.) --------- Co-authored-by: CrazyboyQCD <53971641+CrazyboyQCD@users.noreply.github.com> Co-authored-by: Conrad Irwin --- Cargo.lock | 39 ++++-- Cargo.toml | 2 + crates/editor/src/editor_tests.rs | 10 +- crates/language/Cargo.toml | 1 + crates/language/src/buffer.rs | 25 ++++ crates/project/Cargo.toml | 1 + crates/project/src/buffer_store.rs | 10 +- crates/project/src/project.rs | 12 +- crates/vim/src/command.rs | 6 +- crates/worktree/Cargo.toml | 2 + crates/worktree/src/worktree.rs | 104 +++++++++++++- crates/worktree/src/worktree_tests.rs | 191 +++++++++++++++++++++++++- 12 files changed, 373 insertions(+), 30 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 146f0e19741610d3676d7781fa74982ff2e55918..86b551b1895a0fd6747c35c3fcfe3859396665fa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2667,9 +2667,9 @@ dependencies = [ [[package]] name = "cap-fs-ext" -version = "3.4.5" +version = "3.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5528f85b1e134ae811704e41ef80930f56e795923f866813255bc342cc20654" +checksum = "e41cc18551193fe8fa6f15c1e3c799bc5ec9e2cfbfaa8ed46f37013e3e6c173c" dependencies = [ "cap-primitives", "cap-std", @@ -2679,9 +2679,9 @@ dependencies = [ [[package]] name = "cap-net-ext" -version = "3.4.5" +version = "3.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20a158160765c6a7d0d8c072a53d772e4cb243f38b04bfcf6b4939cfbe7482e7" +checksum = "9f83833816c66c986e913b22ac887cec216ea09301802054316fc5301809702c" dependencies = [ "cap-primitives", "cap-std", @@ -2691,9 +2691,9 @@ dependencies = [ [[package]] name = "cap-primitives" -version = "3.4.5" +version = "3.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6cf3aea8a5081171859ef57bc1606b1df6999df4f1110f8eef68b30098d1d3a" +checksum = "0a1e394ed14f39f8bc26f59d4c0c010dbe7f0a1b9bafff451b1f98b67c8af62a" dependencies = [ "ambient-authority", "fs-set-times", @@ -2709,9 +2709,9 @@ dependencies = [ [[package]] name = "cap-rand" -version = "3.4.5" +version = "3.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8144c22e24bbcf26ade86cb6501a0916c46b7e4787abdb0045a467eb1645a1d" +checksum = "0acb89ccf798a28683f00089d0630dfaceec087234eae0d308c05ddeaa941b40" dependencies = [ "ambient-authority", "rand 0.8.5", @@ -2719,9 +2719,9 @@ dependencies = [ [[package]] name = "cap-std" -version = "3.4.5" +version = "3.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6dc3090992a735d23219de5c204927163d922f42f575a0189b005c62d37549a" +checksum = "07c0355ca583dd58f176c3c12489d684163861ede3c9efa6fd8bba314c984189" dependencies = [ "cap-primitives", "io-extras", @@ -2731,9 +2731,9 @@ dependencies = [ [[package]] name = "cap-time-ext" -version = "3.4.5" +version = "3.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "def102506ce40c11710a9b16e614af0cde8e76ae51b1f48c04b8d79f4b671a80" +checksum = "491af520b8770085daa0466978c75db90368c71896523f2464214e38359b1a5b" dependencies = [ "ambient-authority", "cap-primitives", @@ -2896,6 +2896,17 @@ dependencies = [ "util", ] +[[package]] +name = "chardetng" +version = "0.1.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14b8f0b65b7b08ae3c8187e8d77174de20cb6777864c6b832d8ad365999cf1ea" +dependencies = [ + "cfg-if", + "encoding_rs", + "memchr", +] + [[package]] name = "chrono" version = "0.4.42" @@ -8797,6 +8808,7 @@ dependencies = [ "ctor", "diffy", "ec4rs", + "encoding_rs", "fs", "futures 0.3.31", "fuzzy", @@ -12465,6 +12477,7 @@ dependencies = [ "dap", "dap_adapters", "db", + "encoding_rs", "extension", "fancy-regex", "fs", @@ -20231,8 +20244,10 @@ version = "0.1.0" dependencies = [ "anyhow", "async-lock 2.8.0", + "chardetng", "clock", "collections", + "encoding_rs", "fs", "futures 0.3.31", "fuzzy", diff --git a/Cargo.toml b/Cargo.toml index 13bb4ceea133e16e8cf89461cd1fe7084d448eae..703a34b63af901886e861dba3177e58b19c223f0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -478,6 +478,7 @@ bytes = "1.0" cargo_metadata = "0.19" cargo_toml = "0.21" cfg-if = "1.0.3" +chardetng = "0.1" chrono = { version = "0.4", features = ["serde"] } ciborium = "0.2" circular-buffer = "1.0" @@ -501,6 +502,7 @@ dotenvy = "0.15.0" ec4rs = "1.1" emojis = "0.6.1" env_logger = "0.11" +encoding_rs = "0.8" exec = "0.3.1" fancy-regex = "0.16.0" fork = "0.4.0" diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 1b84197471bd9ad65dc0ac31bf42c6ddc5ee3bf5..48e59f7b7420473054214572a2908215f98ffded 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -69,7 +69,6 @@ use util::{ use workspace::{ CloseActiveItem, CloseAllItems, CloseOtherItems, MoveItemToPaneInDirection, NavigationEntry, OpenOptions, ViewId, - invalid_item_view::InvalidItemView, item::{FollowEvent, FollowableItem, Item, ItemHandle, SaveOptions}, register_project_item, }; @@ -27667,11 +27666,10 @@ async fn test_non_utf_8_opens(cx: &mut TestAppContext) { }) .await .unwrap(); - - assert_eq!( - handle.to_any_view().entity_type(), - TypeId::of::() - ); + // The test file content `vec![0xff, 0xfe, ...]` starts with a UTF-16 LE BOM. + // Previously, this fell back to `InvalidItemView` because it wasn't valid UTF-8. + // With auto-detection enabled, this is now recognized as UTF-16 and opens in the Editor. + assert_eq!(handle.to_any_view().entity_type(), TypeId::of::()); } #[gpui::test] diff --git a/crates/language/Cargo.toml b/crates/language/Cargo.toml index 3ba93476d2a9fa5371b9d146cfc0c5833a748842..06d41e729bfabbf4f7e050409d2675dd909941d6 100644 --- a/crates/language/Cargo.toml +++ b/crates/language/Cargo.toml @@ -32,6 +32,7 @@ async-trait.workspace = true clock.workspace = true collections.workspace = true ec4rs.workspace = true +encoding_rs.workspace = true fs.workspace = true futures.workspace = true fuzzy.workspace = true diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 39003773f83718c6c61d4cfda55b9528f7c6eb2a..abf4d9b10a761b9c0247145e8ddb0664127756d2 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -25,6 +25,7 @@ use anyhow::{Context as _, Result}; use clock::Lamport; pub use clock::ReplicaId; use collections::{HashMap, HashSet}; +use encoding_rs::Encoding; use fs::MTime; use futures::channel::oneshot; use gpui::{ @@ -131,6 +132,8 @@ pub struct Buffer { change_bits: Vec>>, _subscriptions: Vec, tree_sitter_data: Arc, + encoding: &'static Encoding, + has_bom: bool, } #[derive(Debug)] @@ -1100,6 +1103,8 @@ impl Buffer { has_conflict: false, change_bits: Default::default(), _subscriptions: Vec::new(), + encoding: encoding_rs::UTF_8, + has_bom: false, } } @@ -1383,6 +1388,26 @@ impl Buffer { self.saved_mtime } + /// Returns the character encoding of the buffer's file. + pub fn encoding(&self) -> &'static Encoding { + self.encoding + } + + /// Sets the character encoding of the buffer. + pub fn set_encoding(&mut self, encoding: &'static Encoding) { + self.encoding = encoding; + } + + /// Returns whether the buffer has a Byte Order Mark. + pub fn has_bom(&self) -> bool { + self.has_bom + } + + /// Sets whether the buffer has a Byte Order Mark. + pub fn set_has_bom(&mut self, has_bom: bool) { + self.has_bom = has_bom; + } + /// Assign a language to the buffer. pub fn set_language_async(&mut self, language: Option>, cx: &mut Context) { self.set_language_(language, cfg!(any(test, feature = "test-support")), cx); diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.toml index f39c368218511b6ddf560dda1198ef5c06bd0a2e..0d264f9e58363f5e8d8e23dff565d512f118a8d1 100644 --- a/crates/project/Cargo.toml +++ b/crates/project/Cargo.toml @@ -40,6 +40,7 @@ clock.workspace = true collections.workspace = true context_server.workspace = true dap.workspace = true +encoding_rs.workspace = true extension.workspace = true fancy-regex.workspace = true fs.workspace = true diff --git a/crates/project/src/buffer_store.rs b/crates/project/src/buffer_store.rs index aea2482c83edb952f3b0dba03a510085c7c4d3f6..22106fa368904d91a5c3da4338e1a79cef7f0fd0 100644 --- a/crates/project/src/buffer_store.rs +++ b/crates/project/src/buffer_store.rs @@ -376,6 +376,8 @@ impl LocalBufferStore { let text = buffer.as_rope().clone(); let line_ending = buffer.line_ending(); + let encoding = buffer.encoding(); + let has_bom = buffer.has_bom(); let version = buffer.version(); let buffer_id = buffer.remote_id(); let file = buffer.file().cloned(); @@ -387,7 +389,7 @@ impl LocalBufferStore { } let save = worktree.update(cx, |worktree, cx| { - worktree.write_file(path, text, line_ending, cx) + worktree.write_file(path, text, line_ending, encoding, has_bom, cx) }); cx.spawn(async move |this, cx| { @@ -630,7 +632,11 @@ impl LocalBufferStore { }) .await; cx.insert_entity(reservation, |_| { - Buffer::build(text_buffer, Some(loaded.file), Capability::ReadWrite) + let mut buffer = + Buffer::build(text_buffer, Some(loaded.file), Capability::ReadWrite); + buffer.set_encoding(loaded.encoding); + buffer.set_has_bom(loaded.has_bom); + buffer })? } Err(error) if is_not_found_error(&error) => cx.new(|cx| { diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs index 8b57413b22ac95a16e35a95d70a04b3ae49d4b31..5e31f2a90cf137f1e4d788952832e1eb2ee0ec35 100644 --- a/crates/project/src/project.rs +++ b/crates/project/src/project.rs @@ -65,6 +65,7 @@ use debugger::{ dap_store::{DapStore, DapStoreEvent}, session::Session, }; +use encoding_rs; pub use environment::ProjectEnvironment; #[cfg(test)] use futures::future::join_all; @@ -5461,13 +5462,22 @@ impl Project { .await .context("Failed to load settings file")?; + let has_bom = file.has_bom; + let new_text = cx.read_global::(|store, cx| { store.new_text_for_update(file.text, move |settings| update(settings, cx)) })?; worktree .update(cx, |worktree, cx| { let line_ending = text::LineEnding::detect(&new_text); - worktree.write_file(rel_path.clone(), new_text.into(), line_ending, cx) + worktree.write_file( + rel_path.clone(), + new_text.into(), + line_ending, + encoding_rs::UTF_8, + has_bom, + cx, + ) })? .await .context("Failed to write settings file")?; diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs index 5bf0fca041cf274f38c84031e35903c9e339cc24..205097130d152fe255feb02a449956124586d8e6 100644 --- a/crates/vim/src/command.rs +++ b/crates/vim/src/command.rs @@ -330,10 +330,12 @@ pub fn register(editor: &mut Editor, cx: &mut Context) { let Some(range) = range.buffer_range(vim, editor, window, cx).ok() else { return; }; - let Some((line_ending, text, whole_buffer)) = editor.buffer().update(cx, |multi, cx| { + let Some((line_ending, encoding, has_bom, text, whole_buffer)) = editor.buffer().update(cx, |multi, cx| { Some(multi.as_singleton()?.update(cx, |buffer, _| { ( buffer.line_ending(), + buffer.encoding(), + buffer.has_bom(), buffer.as_rope().slice_rows(range.start.0..range.end.0 + 1), range.start.0 == 0 && range.end.0 + 1 >= buffer.row_count(), ) @@ -429,7 +431,7 @@ pub fn register(editor: &mut Editor, cx: &mut Context) { return; }; worktree - .write_file(path.into_arc(), text.clone(), line_ending, cx) + .write_file(path.into_arc(), text.clone(), line_ending, encoding, has_bom, cx) .detach_and_prompt_err("Failed to write lines", window, cx, |_, _, _| None); }); }) diff --git a/crates/worktree/Cargo.toml b/crates/worktree/Cargo.toml index 6d132fbd2cb8c7a1282bffcea6577260a15c4572..e7d3ac34e1886bd76e0a0f5d23ea981b6626909a 100644 --- a/crates/worktree/Cargo.toml +++ b/crates/worktree/Cargo.toml @@ -25,8 +25,10 @@ test-support = [ [dependencies] anyhow.workspace = true async-lock.workspace = true +chardetng.workspace = true clock.workspace = true collections.workspace = true +encoding_rs.workspace = true fs.workspace = true futures.workspace = true fuzzy.workspace = true diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs index 6ec19493840da0b9de3eb55ac483488339ec5e8d..7145bccd514fbb5d6093efda765a826162c91260 100644 --- a/crates/worktree/src/worktree.rs +++ b/crates/worktree/src/worktree.rs @@ -5,8 +5,10 @@ mod worktree_tests; use ::ignore::gitignore::{Gitignore, GitignoreBuilder}; use anyhow::{Context as _, Result, anyhow}; +use chardetng::EncodingDetector; use clock::ReplicaId; use collections::{HashMap, HashSet, VecDeque}; +use encoding_rs::Encoding; use fs::{Fs, MTime, PathEvent, RemoveOptions, Watcher, copy_recursive, read_dir_items}; use futures::{ FutureExt as _, Stream, StreamExt, @@ -105,6 +107,8 @@ pub enum CreatedEntry { pub struct LoadedFile { pub file: Arc, pub text: String, + pub encoding: &'static Encoding, + pub has_bom: bool, } pub struct LoadedBinaryFile { @@ -741,10 +745,14 @@ impl Worktree { path: Arc, text: Rope, line_ending: LineEnding, + encoding: &'static Encoding, + has_bom: bool, cx: &Context, ) -> Task>> { match self { - Worktree::Local(this) => this.write_file(path, text, line_ending, cx), + Worktree::Local(this) => { + this.write_file(path, text, line_ending, encoding, has_bom, cx) + } Worktree::Remote(_) => { Task::ready(Err(anyhow!("remote worktree can't yet write files"))) } @@ -1351,7 +1359,9 @@ impl LocalWorktree { anyhow::bail!("File is too large to load"); } } - let text = fs.load(&abs_path).await?; + + let content = fs.load_bytes(&abs_path).await?; + let (text, encoding, has_bom) = decode_byte(content); let worktree = this.upgrade().context("worktree was dropped")?; let file = match entry.await? { @@ -1379,7 +1389,12 @@ impl LocalWorktree { } }; - Ok(LoadedFile { file, text }) + Ok(LoadedFile { + file, + text, + encoding, + has_bom, + }) }) } @@ -1462,6 +1477,8 @@ impl LocalWorktree { path: Arc, text: Rope, line_ending: LineEnding, + encoding: &'static Encoding, + has_bom: bool, cx: &Context, ) -> Task>> { let fs = self.fs.clone(); @@ -1471,7 +1488,49 @@ impl LocalWorktree { let write = cx.background_spawn({ let fs = fs.clone(); let abs_path = abs_path.clone(); - async move { fs.save(&abs_path, &text, line_ending).await } + async move { + let bom_bytes = if has_bom { + if encoding == encoding_rs::UTF_16LE { + vec![0xFF, 0xFE] + } else if encoding == encoding_rs::UTF_16BE { + vec![0xFE, 0xFF] + } else if encoding == encoding_rs::UTF_8 { + vec![0xEF, 0xBB, 0xBF] + } else { + vec![] + } + } else { + vec![] + }; + + // For UTF-8, use the optimized `fs.save` which writes Rope chunks directly to disk + // without allocating a contiguous string. + if encoding == encoding_rs::UTF_8 && !has_bom { + return fs.save(&abs_path, &text, line_ending).await; + } + // For legacy encodings (e.g. Shift-JIS), we fall back to converting the entire Rope + // to a String/Bytes in memory before writing. + // + // Note: This is inefficient for very large files compared to the streaming approach above, + // but supporting streaming writes for arbitrary encodings would require a significant + // refactor of the `fs` crate to expose a Writer interface. + let text_string = text.to_string(); + let normalized_text = match line_ending { + LineEnding::Unix => text_string, + LineEnding::Windows => text_string.replace('\n', "\r\n"), + }; + + let (cow, _, _) = encoding.encode(&normalized_text); + let bytes = if !bom_bytes.is_empty() { + let mut bytes = bom_bytes; + bytes.extend_from_slice(&cow); + bytes.into() + } else { + cow + }; + + fs.write(&abs_path, &bytes).await + } }); cx.spawn(async move |this, cx| { @@ -5782,3 +5841,40 @@ impl fs::Watcher for NullWatcher { Ok(()) } } + +fn decode_byte(bytes: Vec) -> (String, &'static Encoding, bool) { + // check BOM + if let Some((encoding, _bom_len)) = Encoding::for_bom(&bytes) { + let (cow, _) = encoding.decode_with_bom_removal(&bytes); + return (cow.into_owned(), encoding, true); + } + + fn detect_encoding(bytes: Vec) -> (String, &'static Encoding) { + let mut detector = EncodingDetector::new(); + detector.feed(&bytes, true); + + let encoding = detector.guess(None, true); // Use None for TLD hint to ensure neutral detection logic. + + let (cow, _, _) = encoding.decode(&bytes); + (cow.into_owned(), encoding) + } + + match String::from_utf8(bytes) { + Ok(text) => { + // ISO-2022-JP (and other ISO-2022 variants) consists entirely of 7-bit ASCII bytes, + // so it is valid UTF-8. However, it contains escape sequences starting with '\x1b'. + // If we find an escape character, we double-check the encoding to prevent + // displaying raw escape sequences instead of the correct characters. + if text.contains('\x1b') { + let (s, enc) = detect_encoding(text.into_bytes()); + (s, enc, false) + } else { + (text, encoding_rs::UTF_8, false) + } + } + Err(e) => { + let (s, enc) = detect_encoding(e.into_bytes()); + (s, enc, false) + } + } +} diff --git a/crates/worktree/src/worktree_tests.rs b/crates/worktree/src/worktree_tests.rs index 12f2863aab6c4b4376157f3499fa332051a4822f..094a6d52ea4168752578eab06cea511a57e65c10 100644 --- a/crates/worktree/src/worktree_tests.rs +++ b/crates/worktree/src/worktree_tests.rs @@ -1,5 +1,6 @@ use crate::{Entry, EntryKind, Event, PathChange, Worktree, WorktreeModelHandle}; -use anyhow::Result; +use anyhow::{Context as _, Result}; +use encoding_rs; use fs::{FakeFs, Fs, RealFs, RemoveOptions}; use git::{DOT_GIT, GITIGNORE, REPO_EXCLUDE}; use gpui::{AppContext as _, BackgroundExecutor, BorrowAppContext, Context, Task, TestAppContext}; @@ -19,6 +20,7 @@ use std::{ }; use util::{ ResultExt, path, + paths::PathStyle, rel_path::{RelPath, rel_path}, test::TempTree, }; @@ -723,6 +725,8 @@ async fn test_write_file(cx: &mut TestAppContext) { rel_path("tracked-dir/file.txt").into(), "hello".into(), Default::default(), + encoding_rs::UTF_8, + false, cx, ) }) @@ -734,6 +738,8 @@ async fn test_write_file(cx: &mut TestAppContext) { rel_path("ignored-dir/file.txt").into(), "world".into(), Default::default(), + encoding_rs::UTF_8, + false, cx, ) }) @@ -2035,8 +2041,14 @@ fn randomly_mutate_worktree( }) } else { log::info!("overwriting file {:?} ({})", &entry.path, entry.id.0); - let task = - worktree.write_file(entry.path.clone(), "".into(), Default::default(), cx); + let task = worktree.write_file( + entry.path.clone(), + "".into(), + Default::default(), + encoding_rs::UTF_8, + false, + cx, + ); cx.background_spawn(async move { task.await?; Ok(()) @@ -2552,3 +2564,176 @@ fn init_test(cx: &mut gpui::TestAppContext) { cx.set_global(settings_store); }); } + +#[gpui::test] +async fn test_load_file_encoding(cx: &mut TestAppContext) { + init_test(cx); + let test_cases: Vec<(&str, &[u8], &str)> = vec![ + ("utf8.txt", "こんにちは".as_bytes(), "こんにちは"), // "こんにちは" is Japanese "Hello" + ( + "sjis.txt", + &[0x82, 0xb1, 0x82, 0xf1, 0x82, 0xc9, 0x82, 0xbf, 0x82, 0xcd], + "こんにちは", + ), + ( + "eucjp.txt", + &[0xa4, 0xb3, 0xa4, 0xf3, 0xa4, 0xcb, 0xa4, 0xc1, 0xa4, 0xcf], + "こんにちは", + ), + ( + "iso2022jp.txt", + &[ + 0x1b, 0x24, 0x42, 0x24, 0x33, 0x24, 0x73, 0x24, 0x4b, 0x24, 0x41, 0x24, 0x4f, 0x1b, + 0x28, 0x42, + ], + "こんにちは", + ), + // Western Europe (Windows-1252) + // "Café" -> 0xE9 is 'é' in Windows-1252 (it is typically 0xC3 0xA9 in UTF-8) + ("win1252.txt", &[0x43, 0x61, 0x66, 0xe9], "Café"), + // Chinese Simplified (GBK) + // Note: We use a slightly longer string here because short byte sequences can be ambiguous + // in multi-byte encodings. Providing more context helps the heuristic detector guess correctly. + // Text: "今天天气不错" (Today's weather is not bad / nice) + // Bytes: + // 今: BD F1 + // 天: CC EC + // 天: CC EC + // 气: C6 F8 + // 不: B2 BB + // 错: B4 ED + ( + "gbk.txt", + &[ + 0xbd, 0xf1, 0xcc, 0xec, 0xcc, 0xec, 0xc6, 0xf8, 0xb2, 0xbb, 0xb4, 0xed, + ], + "今天天气不错", + ), + ( + "utf16le_bom.txt", + &[ + 0xFF, 0xFE, // BOM + 0x53, 0x30, // こ + 0x93, 0x30, // ん + 0x6B, 0x30, // に + 0x61, 0x30, // ち + 0x6F, 0x30, // は + ], + "こんにちは", + ), + ( + "utf8_bom.txt", + &[ + 0xEF, 0xBB, 0xBF, // UTF-8 BOM + 0xE3, 0x81, 0x93, // こ + 0xE3, 0x82, 0x93, // ん + 0xE3, 0x81, 0xAB, // に + 0xE3, 0x81, 0xA1, // ち + 0xE3, 0x81, 0xAF, // は + ], + "こんにちは", + ), + ]; + + let root_path = if cfg!(windows) { + Path::new("C:\\root") + } else { + Path::new("/root") + }; + + let fs = FakeFs::new(cx.background_executor.clone()); + + let mut files_json = serde_json::Map::new(); + for (name, _, _) in &test_cases { + files_json.insert(name.to_string(), serde_json::Value::String("".to_string())); + } + + for (name, bytes, _) in &test_cases { + let path = root_path.join(name); + fs.write(&path, bytes).await.unwrap(); + } + + let tree = Worktree::local( + root_path, + true, + fs, + Default::default(), + true, + &mut cx.to_async(), + ) + .await + .unwrap(); + + cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete()) + .await; + + for (name, _, expected) in test_cases { + let loaded = tree + .update(cx, |tree, cx| tree.load_file(rel_path(name), cx)) + .await + .with_context(|| format!("Failed to load {}", name)) + .unwrap(); + + assert_eq!( + loaded.text, expected, + "Encoding mismatch for file: {}", + name + ); + } +} + +#[gpui::test] +async fn test_write_file_encoding(cx: &mut gpui::TestAppContext) { + init_test(cx); + let fs = FakeFs::new(cx.executor()); + let root_path = if cfg!(windows) { + Path::new("C:\\root") + } else { + Path::new("/root") + }; + fs.create_dir(root_path).await.unwrap(); + let file_path = root_path.join("test.txt"); + + fs.insert_file(&file_path, "initial".into()).await; + + let worktree = Worktree::local( + root_path, + true, + fs.clone(), + Default::default(), + true, + &mut cx.to_async(), + ) + .await + .unwrap(); + + let path: Arc = Path::new("test.txt").into(); + let rel_path = RelPath::new(&path, PathStyle::local()).unwrap().into_arc(); + + let text = text::Rope::from("こんにちは"); + + let task = worktree.update(cx, |wt, cx| { + wt.write_file( + rel_path, + text, + text::LineEnding::Unix, + encoding_rs::SHIFT_JIS, + false, + cx, + ) + }); + + task.await.unwrap(); + + let bytes = fs.load_bytes(&file_path).await.unwrap(); + + let expected_bytes = vec![ + 0x82, 0xb1, // こ + 0x82, 0xf1, // ん + 0x82, 0xc9, // に + 0x82, 0xbf, // ち + 0x82, 0xcd, // は + ]; + + assert_eq!(bytes, expected_bytes, "Should be saved as Shift-JIS"); +} From 0d0a08203f37c152243502756b256cd5e3554f2b Mon Sep 17 00:00:00 2001 From: localcc Date: Wed, 17 Dec 2025 20:55:36 +0100 Subject: [PATCH 145/266] Fix windows path canonicalization (#45145) Closes #44962 Release Notes: - N/A --- crates/fs/src/fs.rs | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rs index e6f69a14593a0246ae8ccb4aa4673f4e1f5a1e8e..2cbbf61a21e145464e9dbec01ace3b5510709d0d 100644 --- a/crates/fs/src/fs.rs +++ b/crates/fs/src/fs.rs @@ -434,7 +434,18 @@ impl RealFs { for component in path.components() { match component { std::path::Component::Prefix(_) => { - let canonicalized = std::fs::canonicalize(component)?; + let component = component.as_os_str(); + let canonicalized = if component + .to_str() + .map(|e| e.ends_with("\\")) + .unwrap_or(false) + { + std::fs::canonicalize(component) + } else { + let mut component = component.to_os_string(); + component.push("\\"); + std::fs::canonicalize(component) + }?; let mut strip = PathBuf::new(); for component in canonicalized.components() { @@ -3394,6 +3405,26 @@ mod tests { assert_eq!(content, "Hello"); } + #[gpui::test] + #[cfg(target_os = "windows")] + async fn test_realfs_canonicalize(executor: BackgroundExecutor) { + use util::paths::SanitizedPath; + + let fs = RealFs { + bundled_git_binary_path: None, + executor, + next_job_id: Arc::new(AtomicUsize::new(0)), + job_event_subscribers: Arc::new(Mutex::new(Vec::new())), + }; + let temp_dir = TempDir::new().unwrap(); + let file = temp_dir.path().join("test (1).txt"); + let file = SanitizedPath::new(&file); + std::fs::write(&file, "test").unwrap(); + + let canonicalized = fs.canonicalize(file.as_path()).await; + assert!(canonicalized.is_ok()); + } + #[gpui::test] async fn test_rename(executor: BackgroundExecutor) { let fs = FakeFs::new(executor.clone()); From 9ad059d3be6bec09ae5a042e88dc6f720efd8ba5 Mon Sep 17 00:00:00 2001 From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com> Date: Wed, 17 Dec 2025 21:43:42 +0100 Subject: [PATCH 146/266] copilot: Add support for Next Edit Suggestion (#44486) This PR introduces support for Next Edit Suggestions while doing away with calling legacy endpoints. In the process we've also removed support for cycling completions, as NES will give us a single prediction, for the most part. Closes #30124 Release Notes: - Zed now supports Copilot's [Next Edit Suggestions](https://code.visualstudio.com/blogs/2025/02/12/next-edit-suggestions). --- crates/codestral/src/codestral.rs | 12 +- crates/copilot/src/copilot.rs | 170 +++---- .../src/copilot_edit_prediction_delegate.rs | 417 +++++++----------- crates/copilot/src/request.rs | 100 ++--- .../src/zed_edit_prediction_delegate.rs | 11 +- .../src/edit_prediction_types.rs | 26 -- crates/editor/src/edit_prediction_tests.rs | 18 - crates/editor/src/editor.rs | 56 --- crates/editor/src/element.rs | 2 - crates/language_tools/src/lsp_log_view.rs | 2 +- .../supermaven_edit_prediction_delegate.rs | 11 +- .../zed/src/zed/edit_prediction_registry.rs | 17 - 12 files changed, 259 insertions(+), 583 deletions(-) diff --git a/crates/codestral/src/codestral.rs b/crates/codestral/src/codestral.rs index 9bf0296ac357937cd1ad1470dba9a98864911de9..9cf2fab80b78ba06c6a2523013e2f73934f50052 100644 --- a/crates/codestral/src/codestral.rs +++ b/crates/codestral/src/codestral.rs @@ -1,6 +1,6 @@ use anyhow::{Context as _, Result}; use edit_prediction_context::{EditPredictionExcerpt, EditPredictionExcerptOptions}; -use edit_prediction_types::{Direction, EditPrediction, EditPredictionDelegate}; +use edit_prediction_types::{EditPrediction, EditPredictionDelegate}; use futures::AsyncReadExt; use gpui::{App, Context, Entity, Task}; use http_client::HttpClient; @@ -300,16 +300,6 @@ impl EditPredictionDelegate for CodestralEditPredictionDelegate { })); } - fn cycle( - &mut self, - _buffer: Entity, - _cursor_position: Anchor, - _direction: Direction, - _cx: &mut Context, - ) { - // Codestral doesn't support multiple completions, so cycling does nothing - } - fn accept(&mut self, _cx: &mut Context) { log::debug!("Codestral: Completion accepted"); self.pending_request = None; diff --git a/crates/copilot/src/copilot.rs b/crates/copilot/src/copilot.rs index f248fbdb43ec37b19ca951992df6a7ddbc4f7313..a6963296f5c0ce0395698d2952618123c103ff55 100644 --- a/crates/copilot/src/copilot.rs +++ b/crates/copilot/src/copilot.rs @@ -4,6 +4,7 @@ pub mod copilot_responses; pub mod request; mod sign_in; +use crate::request::NextEditSuggestions; use crate::sign_in::initiate_sign_out; use ::fs::Fs; use anyhow::{Context as _, Result, anyhow}; @@ -18,7 +19,7 @@ use http_client::HttpClient; use language::language_settings::CopilotSettings; use language::{ Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16, ToPointUtf16, - language_settings::{EditPredictionProvider, all_language_settings, language_settings}, + language_settings::{EditPredictionProvider, all_language_settings}, point_from_lsp, point_to_lsp, }; use lsp::{LanguageServer, LanguageServerBinary, LanguageServerId, LanguageServerName}; @@ -40,7 +41,7 @@ use std::{ sync::Arc, }; use sum_tree::Dimensions; -use util::{ResultExt, fs::remove_matching, rel_path::RelPath}; +use util::{ResultExt, fs::remove_matching}; use workspace::Workspace; pub use crate::copilot_edit_prediction_delegate::CopilotEditPredictionDelegate; @@ -315,6 +316,15 @@ struct GlobalCopilot(Entity); impl Global for GlobalCopilot {} +/// Copilot's NextEditSuggestion response, with coordinates converted to Anchors. +struct CopilotEditPrediction { + buffer: Entity, + range: Range, + text: String, + command: Option, + snapshot: BufferSnapshot, +} + impl Copilot { pub fn global(cx: &App) -> Option> { cx.try_global::() @@ -873,101 +883,19 @@ impl Copilot { } } - pub fn completions( - &mut self, - buffer: &Entity, - position: T, - cx: &mut Context, - ) -> Task>> - where - T: ToPointUtf16, - { - self.request_completions::(buffer, position, cx) - } - - pub fn completions_cycling( + pub(crate) fn completions( &mut self, buffer: &Entity, - position: T, + position: Anchor, cx: &mut Context, - ) -> Task>> - where - T: ToPointUtf16, - { - self.request_completions::(buffer, position, cx) - } - - pub fn accept_completion( - &mut self, - completion: &Completion, - cx: &mut Context, - ) -> Task> { - let server = match self.server.as_authenticated() { - Ok(server) => server, - Err(error) => return Task::ready(Err(error)), - }; - let request = - server - .lsp - .request::(request::NotifyAcceptedParams { - uuid: completion.uuid.clone(), - }); - cx.background_spawn(async move { - request - .await - .into_response() - .context("copilot: notify accepted")?; - Ok(()) - }) - } - - pub fn discard_completions( - &mut self, - completions: &[Completion], - cx: &mut Context, - ) -> Task> { - let server = match self.server.as_authenticated() { - Ok(server) => server, - Err(_) => return Task::ready(Ok(())), - }; - let request = - server - .lsp - .request::(request::NotifyRejectedParams { - uuids: completions - .iter() - .map(|completion| completion.uuid.clone()) - .collect(), - }); - cx.background_spawn(async move { - request - .await - .into_response() - .context("copilot: notify rejected")?; - Ok(()) - }) - } - - fn request_completions( - &mut self, - buffer: &Entity, - position: T, - cx: &mut Context, - ) -> Task>> - where - R: 'static - + lsp::request::Request< - Params = request::GetCompletionsParams, - Result = request::GetCompletionsResult, - >, - T: ToPointUtf16, - { + ) -> Task>> { self.register_buffer(buffer, cx); let server = match self.server.as_authenticated() { Ok(server) => server, Err(error) => return Task::ready(Err(error)), }; + let buffer_entity = buffer.clone(); let lsp = server.lsp.clone(); let registered_buffer = server .registered_buffers @@ -977,46 +905,31 @@ impl Copilot { let buffer = buffer.read(cx); let uri = registered_buffer.uri.clone(); let position = position.to_point_utf16(buffer); - let settings = language_settings( - buffer.language_at(position).map(|l| l.name()), - buffer.file(), - cx, - ); - let tab_size = settings.tab_size; - let hard_tabs = settings.hard_tabs; - let relative_path = buffer - .file() - .map_or(RelPath::empty().into(), |file| file.path().clone()); cx.background_spawn(async move { let (version, snapshot) = snapshot.await?; let result = lsp - .request::(request::GetCompletionsParams { - doc: request::GetCompletionsDocument { - uri, - tab_size: tab_size.into(), - indent_size: 1, - insert_spaces: !hard_tabs, - relative_path: relative_path.to_proto(), - position: point_to_lsp(position), - version: version.try_into().unwrap(), - }, + .request::(request::NextEditSuggestionsParams { + text_document: lsp::VersionedTextDocumentIdentifier { uri, version }, + position: point_to_lsp(position), }) .await .into_response() .context("copilot: get completions")?; let completions = result - .completions + .edits .into_iter() .map(|completion| { let start = snapshot .clip_point_utf16(point_from_lsp(completion.range.start), Bias::Left); let end = snapshot.clip_point_utf16(point_from_lsp(completion.range.end), Bias::Left); - Completion { - uuid: completion.uuid, + CopilotEditPrediction { + buffer: buffer_entity.clone(), range: snapshot.anchor_before(start)..snapshot.anchor_after(end), text: completion.text, + command: completion.command, + snapshot: snapshot.clone(), } }) .collect(); @@ -1024,6 +937,35 @@ impl Copilot { }) } + pub(crate) fn accept_completion( + &mut self, + completion: &CopilotEditPrediction, + cx: &mut Context, + ) -> Task> { + let server = match self.server.as_authenticated() { + Ok(server) => server, + Err(error) => return Task::ready(Err(error)), + }; + if let Some(command) = &completion.command { + let request = server + .lsp + .request::(lsp::ExecuteCommandParams { + command: command.command.clone(), + arguments: command.arguments.clone().unwrap_or_default(), + ..Default::default() + }); + cx.background_spawn(async move { + request + .await + .into_response() + .context("copilot: notify accepted")?; + Ok(()) + }) + } else { + Task::ready(Ok(())) + } + } + pub fn status(&self) -> Status { match &self.server { CopilotServer::Starting { task } => Status::Starting { task: task.clone() }, @@ -1260,7 +1202,11 @@ async fn get_copilot_lsp(fs: Arc, node_runtime: NodeRuntime) -> anyhow:: mod tests { use super::*; use gpui::TestAppContext; - use util::{path, paths::PathStyle, rel_path::rel_path}; + use util::{ + path, + paths::PathStyle, + rel_path::{RelPath, rel_path}, + }; #[gpui::test(iterations = 10)] async fn test_buffer_management(cx: &mut TestAppContext) { diff --git a/crates/copilot/src/copilot_edit_prediction_delegate.rs b/crates/copilot/src/copilot_edit_prediction_delegate.rs index bbda32e1102f096e96a41cbc59268f597b1629ba..514e135cb4c34f6a1f49687fcd413113f78f9eae 100644 --- a/crates/copilot/src/copilot_edit_prediction_delegate.rs +++ b/crates/copilot/src/copilot_edit_prediction_delegate.rs @@ -1,49 +1,29 @@ -use crate::{Completion, Copilot}; +use crate::{Copilot, CopilotEditPrediction}; use anyhow::Result; -use edit_prediction_types::{Direction, EditPrediction, EditPredictionDelegate}; -use gpui::{App, Context, Entity, EntityId, Task}; -use language::{Buffer, OffsetRangeExt, ToOffset, language_settings::AllLanguageSettings}; -use settings::Settings; -use std::{path::Path, time::Duration}; +use edit_prediction_types::{EditPrediction, EditPredictionDelegate, interpolate_edits}; +use gpui::{App, Context, Entity, Task}; +use language::{Anchor, Buffer, EditPreview, OffsetRangeExt}; +use std::{ops::Range, sync::Arc, time::Duration}; pub const COPILOT_DEBOUNCE_TIMEOUT: Duration = Duration::from_millis(75); pub struct CopilotEditPredictionDelegate { - cycled: bool, - buffer_id: Option, - completions: Vec, - active_completion_index: usize, - file_extension: Option, + completion: Option<(CopilotEditPrediction, EditPreview)>, pending_refresh: Option>>, - pending_cycling_refresh: Option>>, copilot: Entity, } impl CopilotEditPredictionDelegate { pub fn new(copilot: Entity) -> Self { Self { - cycled: false, - buffer_id: None, - completions: Vec::new(), - active_completion_index: 0, - file_extension: None, + completion: None, pending_refresh: None, - pending_cycling_refresh: None, copilot, } } - fn active_completion(&self) -> Option<&Completion> { - self.completions.get(self.active_completion_index) - } - - fn push_completion(&mut self, new_completion: Completion) { - for completion in &self.completions { - if completion.text == new_completion.text && completion.range == new_completion.range { - return; - } - } - self.completions.push(new_completion); + fn active_completion(&self) -> Option<&(CopilotEditPrediction, EditPreview)> { + self.completion.as_ref() } } @@ -64,12 +44,8 @@ impl EditPredictionDelegate for CopilotEditPredictionDelegate { true } - fn supports_jump_to_edit() -> bool { - false - } - fn is_refreshing(&self, _cx: &App) -> bool { - self.pending_refresh.is_some() && self.completions.is_empty() + self.pending_refresh.is_some() && self.completion.is_none() } fn is_enabled( @@ -102,160 +78,96 @@ impl EditPredictionDelegate for CopilotEditPredictionDelegate { })? .await?; - this.update(cx, |this, cx| { - if !completions.is_empty() { - this.cycled = false; + if let Some(mut completion) = completions.into_iter().next() + && let Some(trimmed_completion) = cx + .update(|cx| trim_completion(&completion, cx)) + .ok() + .flatten() + { + let preview = buffer + .update(cx, |this, cx| { + this.preview_edits(Arc::from(std::slice::from_ref(&trimmed_completion)), cx) + })? + .await; + this.update(cx, |this, cx| { this.pending_refresh = None; - this.pending_cycling_refresh = None; - this.completions.clear(); - this.active_completion_index = 0; - this.buffer_id = Some(buffer.entity_id()); - this.file_extension = buffer.read(cx).file().and_then(|file| { - Some( - Path::new(file.file_name(cx)) - .extension()? - .to_str()? - .to_string(), - ) - }); - - for completion in completions { - this.push_completion(completion); - } + completion.range = trimmed_completion.0; + completion.text = trimmed_completion.1.to_string(); + this.completion = Some((completion, preview)); + cx.notify(); - } - })?; + })?; + } Ok(()) })); } - fn cycle( - &mut self, - buffer: Entity, - cursor_position: language::Anchor, - direction: Direction, - cx: &mut Context, - ) { - if self.cycled { - match direction { - Direction::Prev => { - self.active_completion_index = if self.active_completion_index == 0 { - self.completions.len().saturating_sub(1) - } else { - self.active_completion_index - 1 - }; - } - Direction::Next => { - if self.completions.is_empty() { - self.active_completion_index = 0 - } else { - self.active_completion_index = - (self.active_completion_index + 1) % self.completions.len(); - } - } - } - - cx.notify(); - } else { - let copilot = self.copilot.clone(); - self.pending_cycling_refresh = Some(cx.spawn(async move |this, cx| { - let completions = copilot - .update(cx, |copilot, cx| { - copilot.completions_cycling(&buffer, cursor_position, cx) - })? - .await?; - - this.update(cx, |this, cx| { - this.cycled = true; - this.file_extension = buffer.read(cx).file().and_then(|file| { - Some( - Path::new(file.file_name(cx)) - .extension()? - .to_str()? - .to_string(), - ) - }); - for completion in completions { - this.push_completion(completion); - } - this.cycle(buffer, cursor_position, direction, cx); - })?; - - Ok(()) - })); - } - } - fn accept(&mut self, cx: &mut Context) { - if let Some(completion) = self.active_completion() { + if let Some((completion, _)) = self.active_completion() { self.copilot .update(cx, |copilot, cx| copilot.accept_completion(completion, cx)) .detach_and_log_err(cx); } } - fn discard(&mut self, cx: &mut Context) { - let settings = AllLanguageSettings::get_global(cx); - - let copilot_enabled = settings.show_edit_predictions(None, cx); - - if !copilot_enabled { - return; - } - - self.copilot - .update(cx, |copilot, cx| { - copilot.discard_completions(&self.completions, cx) - }) - .detach_and_log_err(cx); - } + fn discard(&mut self, _: &mut Context) {} fn suggest( &mut self, buffer: &Entity, - cursor_position: language::Anchor, + _: language::Anchor, cx: &mut Context, ) -> Option { let buffer_id = buffer.entity_id(); let buffer = buffer.read(cx); - let completion = self.active_completion()?; - if Some(buffer_id) != self.buffer_id + let (completion, edit_preview) = self.active_completion()?; + + if Some(buffer_id) != Some(completion.buffer.entity_id()) || !completion.range.start.is_valid(buffer) || !completion.range.end.is_valid(buffer) { return None; } + let edits = vec![( + completion.range.clone(), + Arc::from(completion.text.as_ref()), + )]; + let edits = interpolate_edits(&completion.snapshot, &buffer.snapshot(), &edits) + .filter(|edits| !edits.is_empty())?; + + Some(EditPrediction::Local { + id: None, + edits, + edit_preview: Some(edit_preview.clone()), + }) + } +} - let mut completion_range = completion.range.to_offset(buffer); - let prefix_len = common_prefix( - buffer.chars_for_range(completion_range.clone()), - completion.text.chars(), - ); - completion_range.start += prefix_len; - let suffix_len = common_prefix( - buffer.reversed_chars_for_range(completion_range.clone()), - completion.text[prefix_len..].chars().rev(), - ); - completion_range.end = completion_range.end.saturating_sub(suffix_len); - - if completion_range.is_empty() - && completion_range.start == cursor_position.to_offset(buffer) - { - let completion_text = &completion.text[prefix_len..completion.text.len() - suffix_len]; - if completion_text.trim().is_empty() { - None - } else { - let position = cursor_position.bias_right(buffer); - Some(EditPrediction::Local { - id: None, - edits: vec![(position..position, completion_text.into())], - edit_preview: None, - }) - } - } else { - None - } +fn trim_completion( + completion: &CopilotEditPrediction, + cx: &mut App, +) -> Option<(Range, Arc)> { + let buffer = completion.buffer.read(cx); + let mut completion_range = completion.range.to_offset(buffer); + let prefix_len = common_prefix( + buffer.chars_for_range(completion_range.clone()), + completion.text.chars(), + ); + completion_range.start += prefix_len; + let suffix_len = common_prefix( + buffer.reversed_chars_for_range(completion_range.clone()), + completion.text[prefix_len..].chars().rev(), + ); + completion_range.end = completion_range.end.saturating_sub(suffix_len); + let completion_text = &completion.text[prefix_len..completion.text.len() - suffix_len]; + if completion_text.trim().is_empty() { + None + } else { + let completion_range = + buffer.anchor_after(completion_range.start)..buffer.anchor_after(completion_range.end); + + Some((completion_range, Arc::from(completion_text))) } } @@ -282,6 +194,7 @@ mod tests { Point, language_settings::{CompletionSettingsContent, LspInsertMode, WordsCompletionMode}, }; + use lsp::Uri; use project::Project; use serde_json::json; use settings::{AllLanguageSettingsContent, SettingsStore}; @@ -337,12 +250,15 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "one.copilot1".into(), range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 4)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, window, cx| { @@ -383,12 +299,15 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "one.copilot1".into(), range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 4)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, _, cx| { @@ -412,12 +331,15 @@ mod tests { // After debouncing, new Copilot completions should be requested. handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "one.copilot2".into(), range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 5)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, window, cx| { @@ -479,45 +401,6 @@ mod tests { assert_eq!(editor.display_text(cx), "one.cop\ntwo\nthree\n"); assert_eq!(editor.text(cx), "one.cop\ntwo\nthree\n"); }); - - // Reset the editor to verify how suggestions behave when tabbing on leading indentation. - cx.update_editor(|editor, window, cx| { - editor.set_text("fn foo() {\n \n}", window, cx); - editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { - s.select_ranges([Point::new(1, 2)..Point::new(1, 2)]) - }); - }); - handle_copilot_completion_request( - &copilot_lsp, - vec![crate::request::Completion { - text: " let x = 4;".into(), - range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 2)), - ..Default::default() - }], - vec![], - ); - - cx.update_editor(|editor, window, cx| { - editor.next_edit_prediction(&Default::default(), window, cx) - }); - executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); - cx.update_editor(|editor, window, cx| { - assert!(editor.has_active_edit_prediction()); - assert_eq!(editor.display_text(cx), "fn foo() {\n let x = 4;\n}"); - assert_eq!(editor.text(cx), "fn foo() {\n \n}"); - - // Tabbing inside of leading whitespace inserts indentation without accepting the suggestion. - editor.tab(&Default::default(), window, cx); - assert!(editor.has_active_edit_prediction()); - assert_eq!(editor.text(cx), "fn foo() {\n \n}"); - assert_eq!(editor.display_text(cx), "fn foo() {\n let x = 4;\n}"); - - // Using AcceptEditPrediction again accepts the suggestion. - editor.accept_edit_prediction(&Default::default(), window, cx); - assert!(!editor.has_active_edit_prediction()); - assert_eq!(editor.text(cx), "fn foo() {\n let x = 4;\n}"); - assert_eq!(editor.display_text(cx), "fn foo() {\n let x = 4;\n}"); - }); } #[gpui::test(iterations = 10)] @@ -570,12 +453,15 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "one.copilot1".into(), range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 4)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, window, cx| { @@ -614,12 +500,15 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "one.123. copilot\n 456".into(), range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 4)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, window, cx| { @@ -686,15 +575,18 @@ mod tests { handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "two.foo()".into(), range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 2)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); cx.update_editor(|editor, window, cx| { - editor.next_edit_prediction(&Default::default(), window, cx) + editor.show_edit_prediction(&Default::default(), window, cx) }); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, window, cx| { @@ -703,15 +595,22 @@ mod tests { assert_eq!(editor.text(cx), "one\ntw\nthree\n"); editor.backspace(&Default::default(), window, cx); + }); + executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); + cx.run_until_parked(); + cx.update_editor(|editor, window, cx| { assert!(editor.has_active_edit_prediction()); assert_eq!(editor.display_text(cx), "one\ntwo.foo()\nthree\n"); assert_eq!(editor.text(cx), "one\nt\nthree\n"); editor.backspace(&Default::default(), window, cx); + }); + executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); + cx.run_until_parked(); + cx.update_editor(|editor, window, cx| { assert!(editor.has_active_edit_prediction()); assert_eq!(editor.display_text(cx), "one\ntwo.foo()\nthree\n"); assert_eq!(editor.text(cx), "one\n\nthree\n"); - // Deleting across the original suggestion range invalidates it. editor.backspace(&Default::default(), window, cx); assert!(!editor.has_active_edit_prediction()); @@ -765,19 +664,22 @@ mod tests { handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "b = 2 + a".into(), range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 5)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); _ = editor.update(cx, |editor, window, cx| { // Ensure copilot suggestions are shown for the first excerpt. editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| { s.select_ranges([Point::new(1, 5)..Point::new(1, 5)]) }); - editor.next_edit_prediction(&Default::default(), window, cx); + editor.show_edit_prediction(&Default::default(), window, cx); }); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); _ = editor.update(cx, |editor, _, cx| { @@ -791,12 +693,15 @@ mod tests { handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "d = 4 + c".into(), range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 6)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); _ = editor.update(cx, |editor, window, cx| { // Move to another excerpt, ensuring the suggestion gets cleared. @@ -873,15 +778,18 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "two.foo()".into(), range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 2)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); cx.update_editor(|editor, window, cx| { - editor.next_edit_prediction(&Default::default(), window, cx) + editor.show_edit_prediction(&Default::default(), window, cx) }); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, _, cx| { @@ -903,12 +811,15 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "two.foo()".into(), range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 3)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, _, cx| { @@ -930,12 +841,15 @@ mod tests { )); handle_copilot_completion_request( &copilot_lsp, - vec![crate::request::Completion { + vec![crate::request::NextEditSuggestion { text: "two.foo()".into(), range: lsp::Range::new(lsp::Position::new(1, 0), lsp::Position::new(1, 4)), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], - vec![], ); executor.advance_clock(COPILOT_DEBOUNCE_TIMEOUT); cx.update_editor(|editor, _, cx| { @@ -1011,16 +925,20 @@ mod tests { .unwrap(); let mut copilot_requests = copilot_lsp - .set_request_handler::( + .set_request_handler::( move |_params, _cx| async move { - Ok(crate::request::GetCompletionsResult { - completions: vec![crate::request::Completion { + Ok(crate::request::NextEditSuggestionsResult { + edits: vec![crate::request::NextEditSuggestion { text: "next line".into(), range: lsp::Range::new( lsp::Position::new(1, 0), lsp::Position::new(1, 0), ), - ..Default::default() + command: None, + text_document: lsp::VersionedTextDocumentIdentifier { + uri: Uri::from_file_path(path!("/root/dir/file.rs")).unwrap(), + version: 0, + }, }], }) }, @@ -1049,23 +967,14 @@ mod tests { fn handle_copilot_completion_request( lsp: &lsp::FakeLanguageServer, - completions: Vec, - completions_cycling: Vec, + completions: Vec, ) { - lsp.set_request_handler::(move |_params, _cx| { - let completions = completions.clone(); - async move { - Ok(crate::request::GetCompletionsResult { - completions: completions.clone(), - }) - } - }); - lsp.set_request_handler::( + lsp.set_request_handler::( move |_params, _cx| { - let completions_cycling = completions_cycling.clone(); + let completions = completions.clone(); async move { - Ok(crate::request::GetCompletionsResult { - completions: completions_cycling.clone(), + Ok(crate::request::NextEditSuggestionsResult { + edits: completions.clone(), }) } }, diff --git a/crates/copilot/src/request.rs b/crates/copilot/src/request.rs index 85d6254dc060824a9b2686e8f53090fccb39980e..2f97fb72a42904b1fefdd3999f680fca12559ecd 100644 --- a/crates/copilot/src/request.rs +++ b/crates/copilot/src/request.rs @@ -1,3 +1,4 @@ +use lsp::VersionedTextDocumentIdentifier; use serde::{Deserialize, Serialize}; pub enum CheckStatus {} @@ -88,72 +89,6 @@ impl lsp::request::Request for SignOut { const METHOD: &'static str = "signOut"; } -pub enum GetCompletions {} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GetCompletionsParams { - pub doc: GetCompletionsDocument, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GetCompletionsDocument { - pub tab_size: u32, - pub indent_size: u32, - pub insert_spaces: bool, - pub uri: lsp::Uri, - pub relative_path: String, - pub position: lsp::Position, - pub version: usize, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct GetCompletionsResult { - pub completions: Vec, -} - -#[derive(Clone, Debug, Default, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct Completion { - pub text: String, - pub position: lsp::Position, - pub uuid: String, - pub range: lsp::Range, - pub display_text: String, -} - -impl lsp::request::Request for GetCompletions { - type Params = GetCompletionsParams; - type Result = GetCompletionsResult; - const METHOD: &'static str = "getCompletions"; -} - -pub enum GetCompletionsCycling {} - -impl lsp::request::Request for GetCompletionsCycling { - type Params = GetCompletionsParams; - type Result = GetCompletionsResult; - const METHOD: &'static str = "getCompletionsCycling"; -} - -pub enum LogMessage {} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct LogMessageParams { - pub level: u8, - pub message: String, - pub metadata_str: String, - pub extra: Vec, -} - -impl lsp::notification::Notification for LogMessage { - type Params = LogMessageParams; - const METHOD: &'static str = "LogMessage"; -} - pub enum StatusNotification {} #[derive(Debug, Serialize, Deserialize)] @@ -223,3 +158,36 @@ impl lsp::request::Request for NotifyRejected { type Result = String; const METHOD: &'static str = "notifyRejected"; } + +#[derive(Debug, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct NextEditSuggestions; + +#[derive(Debug, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct NextEditSuggestionsParams { + pub(crate) text_document: VersionedTextDocumentIdentifier, + pub(crate) position: lsp::Position, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct NextEditSuggestion { + pub text: String, + pub text_document: VersionedTextDocumentIdentifier, + pub range: lsp::Range, + pub command: Option, +} + +#[derive(Debug, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct NextEditSuggestionsResult { + pub edits: Vec, +} + +impl lsp::request::Request for NextEditSuggestions { + type Params = NextEditSuggestionsParams; + type Result = NextEditSuggestionsResult; + + const METHOD: &'static str = "textDocument/copilotInlineEdit"; +} diff --git a/crates/edit_prediction/src/zed_edit_prediction_delegate.rs b/crates/edit_prediction/src/zed_edit_prediction_delegate.rs index 0a87ca661435de4d22e6f258c30ff406f0deecc2..289bcd76daab2b9a4b82db88b86285e6c7aca00d 100644 --- a/crates/edit_prediction/src/zed_edit_prediction_delegate.rs +++ b/crates/edit_prediction/src/zed_edit_prediction_delegate.rs @@ -2,7 +2,7 @@ use std::{cmp, sync::Arc}; use client::{Client, UserStore}; use cloud_llm_client::EditPredictionRejectReason; -use edit_prediction_types::{DataCollectionState, Direction, EditPredictionDelegate}; +use edit_prediction_types::{DataCollectionState, EditPredictionDelegate}; use gpui::{App, Entity, prelude::*}; use language::{Buffer, ToPoint as _}; use project::Project; @@ -139,15 +139,6 @@ impl EditPredictionDelegate for ZedEditPredictionDelegate { }); } - fn cycle( - &mut self, - _buffer: Entity, - _cursor_position: language::Anchor, - _direction: Direction, - _cx: &mut Context, - ) { - } - fn accept(&mut self, cx: &mut Context) { self.store.update(cx, |store, cx| { store.accept_current_prediction(&self.project, cx); diff --git a/crates/edit_prediction_types/src/edit_prediction_types.rs b/crates/edit_prediction_types/src/edit_prediction_types.rs index 945cfea4a168af4470d98ca844f311a79de9800a..5a37aba59923598b20becd91f07633e409b2bdb7 100644 --- a/crates/edit_prediction_types/src/edit_prediction_types.rs +++ b/crates/edit_prediction_types/src/edit_prediction_types.rs @@ -95,13 +95,6 @@ pub trait EditPredictionDelegate: 'static + Sized { debounce: bool, cx: &mut Context, ); - fn cycle( - &mut self, - buffer: Entity, - cursor_position: language::Anchor, - direction: Direction, - cx: &mut Context, - ); fn accept(&mut self, cx: &mut Context); fn discard(&mut self, cx: &mut Context); fn did_show(&mut self, _cx: &mut Context) {} @@ -136,13 +129,6 @@ pub trait EditPredictionDelegateHandle { debounce: bool, cx: &mut App, ); - fn cycle( - &self, - buffer: Entity, - cursor_position: language::Anchor, - direction: Direction, - cx: &mut App, - ); fn did_show(&self, cx: &mut App); fn accept(&self, cx: &mut App); fn discard(&self, cx: &mut App); @@ -215,18 +201,6 @@ where }) } - fn cycle( - &self, - buffer: Entity, - cursor_position: language::Anchor, - direction: Direction, - cx: &mut App, - ) { - self.update(cx, |this, cx| { - this.cycle(buffer, cursor_position, direction, cx) - }) - } - fn accept(&self, cx: &mut App) { self.update(cx, |this, cx| this.accept(cx)) } diff --git a/crates/editor/src/edit_prediction_tests.rs b/crates/editor/src/edit_prediction_tests.rs index bfce1532ce78699e1fb524fd594df1ba83c864a5..b5931cde42a4e2c0e21b2d1f68558879de9750b4 100644 --- a/crates/editor/src/edit_prediction_tests.rs +++ b/crates/editor/src/edit_prediction_tests.rs @@ -485,15 +485,6 @@ impl EditPredictionDelegate for FakeEditPredictionDelegate { ) { } - fn cycle( - &mut self, - _buffer: gpui::Entity, - _cursor_position: language::Anchor, - _direction: edit_prediction_types::Direction, - _cx: &mut gpui::Context, - ) { - } - fn accept(&mut self, _cx: &mut gpui::Context) {} fn discard(&mut self, _cx: &mut gpui::Context) {} @@ -561,15 +552,6 @@ impl EditPredictionDelegate for FakeNonZedEditPredictionDelegate { ) { } - fn cycle( - &mut self, - _buffer: gpui::Entity, - _cursor_position: language::Anchor, - _direction: edit_prediction_types::Direction, - _cx: &mut gpui::Context, - ) { - } - fn accept(&mut self, _cx: &mut gpui::Context) {} fn discard(&mut self, _cx: &mut gpui::Context) {} diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 7da06c3d8de91709cdcea8cbc923918464021079..83051ffb9ea1a5f5754b2af4d1cf42526cfd391e 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -7468,26 +7468,6 @@ impl Editor { .unwrap_or(false) } - fn cycle_edit_prediction( - &mut self, - direction: Direction, - window: &mut Window, - cx: &mut Context, - ) -> Option<()> { - let provider = self.edit_prediction_provider()?; - let cursor = self.selections.newest_anchor().head(); - let (buffer, cursor_buffer_position) = - self.buffer.read(cx).text_anchor_for_position(cursor, cx)?; - if self.edit_predictions_hidden_for_vim_mode || !self.should_show_edit_predictions() { - return None; - } - - provider.cycle(buffer, cursor_buffer_position, direction, cx); - self.update_visible_edit_prediction(window, cx); - - Some(()) - } - pub fn show_edit_prediction( &mut self, _: &ShowEditPrediction, @@ -7525,42 +7505,6 @@ impl Editor { .detach(); } - pub fn next_edit_prediction( - &mut self, - _: &NextEditPrediction, - window: &mut Window, - cx: &mut Context, - ) { - if self.has_active_edit_prediction() { - self.cycle_edit_prediction(Direction::Next, window, cx); - } else { - let is_copilot_disabled = self - .refresh_edit_prediction(false, true, window, cx) - .is_none(); - if is_copilot_disabled { - cx.propagate(); - } - } - } - - pub fn previous_edit_prediction( - &mut self, - _: &PreviousEditPrediction, - window: &mut Window, - cx: &mut Context, - ) { - if self.has_active_edit_prediction() { - self.cycle_edit_prediction(Direction::Prev, window, cx); - } else { - let is_copilot_disabled = self - .refresh_edit_prediction(false, true, window, cx) - .is_none(); - if is_copilot_disabled { - cx.propagate(); - } - } - } - pub fn accept_partial_edit_prediction( &mut self, granularity: EditPredictionGranularity, diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 85b32324a1c1cc7fb84162fb120e8ef0e4e8b599..9b6115daed700bf391ef6b076100702b99ecaabe 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -594,8 +594,6 @@ impl EditorElement { register_action(editor, window, Editor::show_signature_help); register_action(editor, window, Editor::signature_help_prev); register_action(editor, window, Editor::signature_help_next); - register_action(editor, window, Editor::next_edit_prediction); - register_action(editor, window, Editor::previous_edit_prediction); register_action(editor, window, Editor::show_edit_prediction); register_action(editor, window, Editor::context_menu_first); register_action(editor, window, Editor::context_menu_prev); diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs index 6fc061cd07edd9e22609ba698f27860b1b905765..e34bbb46d35d5a524c08369fcc991dfe81865127 100644 --- a/crates/language_tools/src/lsp_log_view.rs +++ b/crates/language_tools/src/lsp_log_view.rs @@ -125,7 +125,7 @@ pub fn init(on_headless_host: bool, cx: &mut App) { let server_id = server.server_id(); let weak_lsp_store = cx.weak_entity(); log_store.copilot_log_subscription = - Some(server.on_notification::( + Some(server.on_notification::( move |params, cx| { weak_lsp_store .update(cx, |lsp_store, cx| { diff --git a/crates/supermaven/src/supermaven_edit_prediction_delegate.rs b/crates/supermaven/src/supermaven_edit_prediction_delegate.rs index 578bc894f223fd458f510694194aebe633d7a6db..9563a0aa99f1760b5af214be28f25dbf1734c371 100644 --- a/crates/supermaven/src/supermaven_edit_prediction_delegate.rs +++ b/crates/supermaven/src/supermaven_edit_prediction_delegate.rs @@ -1,6 +1,6 @@ use crate::{Supermaven, SupermavenCompletionStateId}; use anyhow::Result; -use edit_prediction_types::{Direction, EditPrediction, EditPredictionDelegate}; +use edit_prediction_types::{EditPrediction, EditPredictionDelegate}; use futures::StreamExt as _; use gpui::{App, Context, Entity, EntityId, Task}; use language::{Anchor, Buffer, BufferSnapshot}; @@ -189,15 +189,6 @@ impl EditPredictionDelegate for SupermavenEditPredictionDelegate { })); } - fn cycle( - &mut self, - _buffer: Entity, - _cursor_position: Anchor, - _direction: Direction, - _cx: &mut Context, - ) { - } - fn accept(&mut self, _cx: &mut Context) { reset_completion_cache(self, _cx); } diff --git a/crates/zed/src/zed/edit_prediction_registry.rs b/crates/zed/src/zed/edit_prediction_registry.rs index 77a1f71596f9cf1d2f4e32137580d0e3648359f5..51327bfc9ab715a1b11aa3c639ffd60b6b0a0ea8 100644 --- a/crates/zed/src/zed/edit_prediction_registry.rs +++ b/crates/zed/src/zed/edit_prediction_registry.rs @@ -145,23 +145,6 @@ fn register_backward_compatible_actions(editor: &mut Editor, cx: &mut Context| { - editor.next_edit_prediction(&Default::default(), window, cx); - }, - )) - .detach(); - editor - .register_action(cx.listener( - |editor, - _: &copilot::PreviousSuggestion, - window: &mut Window, - cx: &mut Context| { - editor.previous_edit_prediction(&Default::default(), window, cx); - }, - )) - .detach(); } fn assign_edit_prediction_provider( From 8aab646aeca1b4698737fbd8d0efa29caf87ee8c Mon Sep 17 00:00:00 2001 From: Dave Waggoner Date: Wed, 17 Dec 2025 12:53:22 -0800 Subject: [PATCH 147/266] terminal: Improve regex hyperlink performance for long lines (#44721) Related to - #44407 This PR further improves performance for regex hyperlink finding by eliminating unnecessary regex matching. Currently, we repeatedly search for matches from the start of the line until the match contains the hovered point. This is only required to support custom regexes which match strings containing spaces, with multiple matches on a single line. This isn't actually a useful scenario, and is no longer supported. This PR changes to only search twice, the first match starting from the start of the line, and the hovered word (space-delimited). The most dramatic improvement is for long lines with many words. In addition to the above changes, this PR: - Adds test for the scenarios from #44407 and #44510 - Simplifies the logic added in #44407 Performance measurements For the scenario from #44407, this improves the perf test's iteration time from 1.22ms to 0.47ms. main: | Branch | Command | Iter/sec | Mean [ms] | SD [ms] | Iterations | Importance (weight) | |:---|:---|---:|---:|---:|---:|---:| | main | terminal_hyperlinks::tests::path::perf::pr_44407_hyperlink_benchmark | 819.64 | 937.60 | 2.20 | 768 | average (50) | | this PR | terminal_hyperlinks::tests::path::perf::pr_44407_hyperlink_benchmark | 2099.79 | 1463.20 | 7.20 | 3072 | average (50) | Release Notes: - terminal: Improve path hyperlink performance for long lines --- crates/terminal/src/terminal_hyperlinks.rs | 238 +++++++++++++++++---- 1 file changed, 195 insertions(+), 43 deletions(-) diff --git a/crates/terminal/src/terminal_hyperlinks.rs b/crates/terminal/src/terminal_hyperlinks.rs index 8ff33895251f707c8bc9a7894bd74b0bb323ae6c..4fe2baa2dc27f3a589efd9b7739262a6fec3fcb4 100644 --- a/crates/terminal/src/terminal_hyperlinks.rs +++ b/crates/terminal/src/terminal_hyperlinks.rs @@ -11,6 +11,7 @@ use alacritty_terminal::{ use log::{info, warn}; use regex::Regex; use std::{ + iter::{once, once_with}, ops::{Index, Range}, time::{Duration, Instant}, }; @@ -232,14 +233,17 @@ fn path_match( (line_end.line.0 - line_start.line.0 + 1) as usize * term.grid().columns(), ); let first_cell = &term.grid()[line_start]; + let mut prev_len = 0; line.push(first_cell.c); - let mut start_offset = 0; + let mut prev_char_is_space = first_cell.c == ' '; let mut hovered_point_byte_offset = None; + let mut hovered_word_start_offset = None; + let mut hovered_word_end_offset = None; - if !first_cell.flags.intersects(WIDE_CHAR_SPACERS) { - start_offset += first_cell.c.len_utf8(); - if line_start == hovered { - hovered_point_byte_offset = Some(0); + if line_start == hovered { + hovered_point_byte_offset = Some(0); + if first_cell.c != ' ' { + hovered_word_start_offset = Some(0); } } @@ -247,27 +251,44 @@ fn path_match( if cell.point > line_end { break; } - let is_spacer = cell.flags.intersects(WIDE_CHAR_SPACERS); - if cell.point == hovered { - debug_assert!(hovered_point_byte_offset.is_none()); - if start_offset > 0 && cell.flags.contains(Flags::WIDE_CHAR_SPACER) { - // If we hovered on a trailing spacer, back up to the end of the previous char's bytes. - start_offset -= 1; + + if !cell.flags.intersects(WIDE_CHAR_SPACERS) { + prev_len = line.len(); + match cell.c { + ' ' | '\t' => { + if hovered_point_byte_offset.is_some() && !prev_char_is_space { + if hovered_word_end_offset.is_none() { + hovered_word_end_offset = Some(line.len()); + } + } + line.push(' '); + prev_char_is_space = true; + } + c @ _ => { + if hovered_point_byte_offset.is_none() && prev_char_is_space { + hovered_word_start_offset = Some(line.len()); + } + line.push(c); + prev_char_is_space = false; + } } - hovered_point_byte_offset = Some(start_offset); - } else if cell.point < hovered && !is_spacer { - start_offset += cell.c.len_utf8(); } - if !is_spacer { - line.push(match cell.c { - '\t' => ' ', - c @ _ => c, - }); + if cell.point == hovered { + debug_assert!(hovered_point_byte_offset.is_none()); + hovered_point_byte_offset = Some(prev_len); } } let line = line.trim_ascii_end(); let hovered_point_byte_offset = hovered_point_byte_offset?; + let hovered_word_range = { + let word_start_offset = hovered_word_start_offset.unwrap_or(0); + (word_start_offset != 0) + .then_some(word_start_offset..hovered_word_end_offset.unwrap_or(line.len())) + }; + if line.len() <= hovered_point_byte_offset { + return None; + } let found_from_range = |path_range: Range, link_range: Range, position: Option<(u32, Option)>| { @@ -313,10 +334,27 @@ fn path_match( for regex in path_hyperlink_regexes { let mut path_found = false; - for captures in regex.captures_iter(&line) { + for (line_start_offset, captures) in once( + regex + .captures_iter(&line) + .next() + .map(|captures| (0, captures)), + ) + .chain(once_with(|| { + if let Some(hovered_word_range) = &hovered_word_range { + regex + .captures_iter(&line[hovered_word_range.clone()]) + .next() + .map(|captures| (hovered_word_range.start, captures)) + } else { + None + } + })) + .flatten() + { path_found = true; let match_range = captures.get(0).unwrap().range(); - let (path_range, line_column) = if let Some(path) = captures.name("path") { + let (mut path_range, line_column) = if let Some(path) = captures.name("path") { let parse = |name: &str| { captures .name(name) @@ -330,10 +368,15 @@ fn path_match( } else { (match_range.clone(), None) }; - let link_range = captures + let mut link_range = captures .name("link") .map_or_else(|| match_range.clone(), |link| link.range()); + path_range.start += line_start_offset; + path_range.end += line_start_offset; + link_range.start += line_start_offset; + link_range.end += line_start_offset; + if !link_range.contains(&hovered_point_byte_offset) { // No match, just skip. continue; @@ -638,9 +681,6 @@ mod tests { test_path!( "‹«🦀 multiple_👉same_line 🦀» 🚣«4» 🏛️«2»›: 🦀 multiple_same_line 🦀 🚣4 🏛️2:" ); - test_path!( - "🦀 multiple_same_line 🦀 🚣4 🏛️2 ‹«🦀 multiple_👉same_line 🦀» 🚣«4» 🏛️«2»›:" - ); // ls output (tab separated) test_path!( @@ -977,7 +1017,7 @@ mod tests { use crate::TerminalSettings; use alacritty_terminal::{ event::VoidListener, - grid::Dimensions, + grid::Scroll, index::{Column, Point as AlacPoint}, term::test::mock_term, term::{Term, search::Match}, @@ -986,14 +1026,20 @@ mod tests { use std::{cell::RefCell, rc::Rc}; use util_macros::perf; - fn build_test_term(line: &str) -> (Term, AlacPoint) { - let content = line.repeat(500); - let term = mock_term(&content); - let point = AlacPoint::new( - term.grid().bottommost_line() - 1, - Column(term.grid().last_column().0 / 2), - ); - + fn build_test_term( + line: &str, + repeat: usize, + hover_offset_column: usize, + ) -> (Term, AlacPoint) { + let content = line.repeat(repeat); + let mut term = mock_term(&content); + term.resize(TermSize { + columns: 1024, + screen_lines: 10, + }); + term.scroll_display(Scroll::Top); + let point = + AlacPoint::new(Line(term.topmost_line().0 + 3), Column(hover_offset_column)); (term, point) } @@ -1002,11 +1048,14 @@ mod tests { const LINE: &str = " Compiling terminal v0.1.0 (/Hyperlinks/Bench/Source/zed-hyperlinks/crates/terminal)\r\n"; thread_local! { static TEST_TERM_AND_POINT: (Term, AlacPoint) = - build_test_term(LINE); + build_test_term(LINE, 500, 50); } TEST_TERM_AND_POINT.with(|(term, point)| { - assert!( - find_from_grid_point_bench(term, *point).is_some(), + assert_eq!( + find_from_grid_point_bench(term, *point) + .map(|(path, ..)| path) + .unwrap_or_default(), + "/Hyperlinks/Bench/Source/zed-hyperlinks/crates/terminal", "Hyperlink should have been found" ); }); @@ -1017,11 +1066,14 @@ mod tests { const LINE: &str = " --> /Hyperlinks/Bench/Source/zed-hyperlinks/crates/terminal/terminal.rs:1000:42\r\n"; thread_local! { static TEST_TERM_AND_POINT: (Term, AlacPoint) = - build_test_term(LINE); + build_test_term(LINE, 500, 50); } TEST_TERM_AND_POINT.with(|(term, point)| { - assert!( - find_from_grid_point_bench(term, *point).is_some(), + assert_eq!( + find_from_grid_point_bench(term, *point) + .map(|(path, ..)| path) + .unwrap_or_default(), + "/Hyperlinks/Bench/Source/zed-hyperlinks/crates/terminal/terminal.rs:1000:42", "Hyperlink should have been found" ); }); @@ -1032,11 +1084,111 @@ mod tests { const LINE: &str = "Cargo.toml experiments notebooks rust-toolchain.toml tooling\r\n"; thread_local! { static TEST_TERM_AND_POINT: (Term, AlacPoint) = - build_test_term(LINE); + build_test_term(LINE, 500, 60); } TEST_TERM_AND_POINT.with(|(term, point)| { - assert!( - find_from_grid_point_bench(term, *point).is_some(), + assert_eq!( + find_from_grid_point_bench(term, *point) + .map(|(path, ..)| path) + .unwrap_or_default(), + "rust-toolchain.toml", + "Hyperlink should have been found" + ); + }); + } + + #[perf] + // https://github.com/zed-industries/zed/pull/44407 + pub fn pr_44407_hyperlink_benchmark() { + const LINE: &str = "-748, 706, 163, 222, -980, 949, 381, -568, 199, 501, 760, -821, 90, -451, 183, 867, -351, -810, -762, -109, 423, 84, 14, -77, -820, -345, 74, -791, 930, -618, -900, 862, -959, 289, -19, 471, -757, 793, 155, -554, 249, 830, 402, 732, -731, -866, -720, -703, -257, -439, 731, 872, -489, 676, -167, 613, -698, 415, -80, -453, -896, 333, -511, 621, -450, 624, -309, -575, 177, 141, 891, -104, -97, -367, -599, -675, 607, -225, -760, 552, -465, 804, 55, 282, 104, -929, -252,\ +-311, 900, 550, 599, -80, 774, 553, 837, -395, 541, 953, 154, -396, -596, -111, -802, -221, -337, -633, -73, -527, -82, -658, -264, 222, 375, 434, 204, -756, -703, 303, 239, -257, -365, -351, 904, 364, -743, -484, 655, -542, 446, 888, 632, -167, -260, 716, 150, 806, 723, 513, -118, -323, -683, 983, -564, 358, -16, -287, 277, -607, 87, 365, -1, 164, 401, 257, 369, -893, 145, -969, 375, -53, 541, -408, -865, 753, 258, 337, -886, 593, -378, -528, 191, 204, 566, -61, -621, 769, 524, -628, 6,\ +249, 896, -785, -776, 321, -681, 604, -740, 886, 426, -480, -983, 23, -247, 125, -666, 913, 842, -460, -797, -483, -58, -565, -587, -206, 197, 715, 764, -97, 457, -149, -226, 261, 194, -390, 431, 180, -778, 829, -657, -668, 397, 859, 152, -178, 677, -18, 687, -247, 96, 466, -572, 478, 622, -143, -25, -471, 265, 335, 957, 152, -951, -647, 670, 57, 152, -115, 206, 87, 629, -798, -125, -725, -31, 844, 398, -876, 44, 963, -211, 518, -8, -103, -999, 948, 823, 149, -803, 769, -236, -683, 527,\ +-108, -36, 18, -437, 687, -305, -526, 972, -965, 276, 420, -259, -379, -142, -747, 600, -578, 197, 673, 890, 324, -931, 755, -765, -422, 785, -369, -110, -505, 532, -208, -438, 713, 110, 853, 996, -360, 823, 289, -699, 629, -661, 560, -329, -323, 439, 571, -537, 644, -84, 25, -536, -161, 112, 169, -922, -537, -734, -423, 37, 451, -149, 408, 18, -672, 206, -784, 444, 593, -241, 502, -259, -798, -352, -658, 712, -675, -734, 627, -620, 64, -554, 999, -537, -160, -641, 464, 894, 29, 322, 566,\ +-510, -749, 982, 204, 967, -261, -986, -136, 251, -598, 995, -831, 891, 22, 761, -783, -415, 125, 470, -919, -97, -668, 85, 205, -175, -550, 502, 652, -468, 798, 775, -216, 89, -433, -24, -621, 877, -126, 951, 809, 782, 156, -618, -841, -463, 19, -723, -904, 550, 263, 991, -758, -114, 446, -731, -623, -634, 462, 48, 851, 333, -846, 480, 892, -966, -910, -436, 317, -711, -341, -294, 124, 238, -214, -281, 467, -950, -342, 913, -90, -388, -573, 740, -883, -451, 493, -500, 863, 930, 127, 530,\ +-810, 540, 541, -664, -951, -227, -420, -476, -581, -534, 549, 253, 984, -985, -84, -521, 538, 484, -440, 371, 784, -306, -850, 530, -133, 251, -799, 446, -170, -243, -674, 769, 646, 778, -680, -714, -442, 804, 901, -774, 69, 307, -293, 755, 443, 224, -918, -771, 723, 40, 132, 568, -847, -47, 844, 69, 986, -293, -459, 313, 155, 331, 69, 280, -637, 569, 104, -119, -988, 252, 857, -590, 810, -891, 484, 566, -934, -587, -290, 566, 587, 489, 870, 280, 454, -252, 613, -701, -278, 195, -198,\ +683, 533, -372, 707, -152, 371, 866, 609, -5, -372, -30, -694, 552, 192, 452, -663, 350, -985, 10, 884, 813, -592, -331, -470, 711, -941, 928, 379, -339, 220, 999, 376, 507, 179, 916, 84, 104, 392, 192, 299, -860, 218, -698, -919, -452, 37, 850, 5, -874, 287, 123, -746, -575, 776, -909, 118, 903, -275, 450, -996, -591, -920, -850, 453, -896, 73, 83, -535, -20, 287, -765, 442, 808, 45, 445, 202, 917, -208, 783, 790, -534, 373, -129, 556, -757, -69, 459, -163, -59, 265, -563, -889, 635,\ +-583, -261, -790, 799, 826, 953, 85, 619, 334, 842, 672, -869, -4, -833, 315, 942, -524, 579, 926, 628, -404, 128, -629, 161, 568, -117, -526, 223, -876, 906, 176, -549, -317, 381, 375, -801, -416, 647, 335, 253, -386, -375, -254, 635, 352, 317, 398, -422, 111, 201, 220, 554, -972, 853, 378, 956, 942, -857, -289, -333, -180, 488, -814, -42, -595, 721, 39, 644, 721, -242, -44, 643, -457, -419, 560, -863, 974, 458, 222, -882, 526, -243, -318, -343, -707, -401, 117, 677, -489, 546, -903,\ +-960, -881, -684, 125, -928, -995, -692, -773, 647, -718, -862, -814, 671, 664, -130, -856, -674, 653, 711, 194, -685, -160, 138, -27, -128, -671, -242, 526, 494, -674, 424, -921, -778, 313, -237, 332, 913, 252, 808, -936, 289, 755, 52, -139, 57, -19, -827, -775, -561, -14, 107, -84, 622, -303, -747, 258, -942, 290, 211, -919, -207, 797, 95, 794, -830, -181, -788, 757, 75, -946, -949, -988, 152, 340, 732, 886, -891, -642, -666, 321, -910, 841, 632, 298, 55, -349, 498, 287, -711, 97, 305,\ +-974, -987, 790, -64, 605, -583, -821, 345, 887, -861, 548, 894, 288, 452, 556, -448, 813, 420, 545, 967, 127, -947, 19, -314, -607, -513, -851, 254, -290, -938, -783, -93, 474, 368, -485, -935, -539, 81, 404, -283, 779, 345, -164, 53, 563, -771, 911, -323, 522, -998, 315, 415, 460, 58, -541, -878, -152, -886, 201, -446, -810, 549, -142, -575, -632, 521, 549, 209, -681, 998, 798, -611, -919, -708, -4, 677, -172, 588, 750, -435, 508, 609, 498, -535, -691, -738, 85, 615, 705, 169, 425,\ +-669, -491, -783, 73, -847, 228, -981, -812, -229, 950, -904, 175, -438, 632, -556, 910, 173, 576, -751, -53, -169, 635, 607, -944, -13, -84, 105, -644, 984, 935, 259, -445, 620, -405, 832, 167, 114, 209, -181, -944, -496, 693, -473, 137, 38, -873, -334, -353, -57, 397, 944, 698, 811, -401, 712, -667, 905, 276, -653, 368, -543, -349, 414, 287, 894, 935, 461, 55, 741, -623, -660, -773, 617, 834, 278, -121, 52, 495, -855, -440, -210, -99, 279, -661, 540, 934, 540, 784, 895, 268, -503, 513,\ +-484, -352, 528, 341, -451, 885, -71, 799, -195, -885, -585, -233, 92, 453, 994, 464, 694, 190, -561, -116, 675, -775, -236, 556, -110, -465, 77, -781, 507, -960, -410, 229, -632, 717, 597, 429, 358, -430, -692, -825, 576, 571, 758, -891, 528, -267, 190, -869, 132, -811, 796, 750, -596, -681, 870, 360, 969, 860, -412, -567, 694, -86, -498, 38, -178, -583, -778, 412, 842, -586, 722, -192, 350, 363, 81, -677, -163, 564, 543, 671, 110, 314, 739, -552, -224, -644, 922, 685, 134, 613, 793,\ +-363, -244, -284, -257, -561, 418, 988, 333, 110, -966, 790, 927, 536, -620, -309, -358, 895, -867, -796, -357, 308, -740, 287, -732, -363, -969, 658, 711, 511, 256, 590, -574, 815, -845, -84, 546, -581, -71, -334, -890, 652, -959, 320, -236, 445, -851, 825, -756, -4, 877, 308, 573, -117, 293, 686, -483, 391, 342, -550, -982, 713, 886, 552, 474, -673, 283, -591, -383, 988, 435, -131, 708, -326, -884, 87, 680, -818, -408, -486, 813, -307, -799, 23, -497, 802, -146, -100, 541, 7, -493, 577,\ +50, -270, 672, 834, 111, -788, 247, 337, 628, -33, -964, -519, 683, 54, -703, 633, -127, -448, 759, -975, 696, 2, -870, -760, 67, 696, 306, 750, 615, 155, -933, -568, 399, 795, 164, -460, 205, 439, -526, -691, 35, -136, -481, -63, 73, -598, 748, 133, 874, -29, 4, -73, 472, 389, 962, 231, -328, 240, 149, 959, 46, -207, 72, -514, -608, 0, -14, 32, 374, -478, -806, 919, -729, -286, 652, 109, 509, -879, -979, -865, 584, -92, -346, -992, 781, 401, 575, 993, -746, -33, 684, -683, 750, -105,\ +-425, -508, -627, 27, 770, -45, 338, 921, -139, -392, -933, 634, 563, 224, -780, 921, 991, 737, 22, 64, 414, -249, -687, 869, 50, 759, -97, 515, 20, -775, -332, 957, 138, -542, -835, 591, -819, 363, -715, -146, -950, -641, -35, -435, -407, -548, -984, 383, -216, -559, 853, 4, -410, -319, -831, -459, -628, -819, -324, 755, 696, -192, 238, -234, -724, -445, 915, 302, -708, 484, 224, -641, 25, -771, 528, -106, -744, -588, 913, -554, -515, -239, -843, -812, -171, 721, 543, -269, 440, 151,\ +996, -723, -557, -522, -280, -514, -593, 208, 715, 404, 353, 270, -483, -785, 318, -313, 798, 638, 764, 748, -929, -827, -318, -56, 389, -546, -958, -398, 463, -700, 461, 311, -787, -488, 877, 456, 166, 535, -995, -189, -715, 244, 40, 484, 212, -329, -351, 638, -69, -446, -292, 801, -822, 490, -486, -185, 790, 370, -340, 401, -656, 584, 561, -749, 269, -19, -294, -111, 975, 874, -73, 851, 231, -331, -684, 460, 765, -654, -76, 10, 733, 520, 521, 416, -958, -202, -186, -167, 175, 343, -50,\ +673, -763, -854, -977, -17, -853, -122, -25, 180, 149, 268, 874, -816, -745, 747, -303, -959, 390, 509, 18, -66, 275, -277, 9, 837, -124, 989, -542, -649, -845, 894, 926, 997, -847, -809, -579, -96, -372, 766, 238, -251, 503, 559, 276, -281, -102, -735, 815, 109, 175, -10, 128, 543, -558, -707, 949, 996, -422, -506, 252, 702, -930, 552, -961, 584, -79, -177, 341, -275, 503, -21, 677, -545, 8, -956, -795, -870, -254, 170, -502, -880, 106, 174, 459, 603, -600, -963, 164, -136, -641, -309,\ +-380, -707, -727, -10, 727, 952, 997, -731, -133, 269, 287, 855, 716, -650, 479, 299, -839, -308, -782, 769, 545, 663, -536, -115, 904, -986, -258, -562, 582, 664, 408, -525, -889, 471, -370, -534, -220, 310, 766, 931, -193, -897, -192, -74, -365, -256, -359, -328, 658, -691, -431, 406, 699, 425, 713, -584, -45, -588, 289, 658, -290, -880, -987, -444, 371, 904, -155, 81, -278, -708, -189, -78, 655, 342, -998, -647, -734, -218, 726, 619, 663, 744, 518, 60, -409, 561, -727, -961, -306,\ +-147, -550, 240, -218, -393, 267, 724, 791, -548, 480, 180, -631, 825, -170, 107, 227, -691, 905, -909, 359, 227, 287, 909, 632, -89, -522, 80, -429, 37, 561, -732, -474, 565, -798, -460, 188, 507, -511, -654, 212, -314, -376, -997, -114, -708, 512, -848, 781, 126, -956, -298, 354, -400, -121, 510, 445, 926, 27, -708, 676, 248, 834, 542, 236, -105, -153, 102, 128, 96, -348, -626, 598, 8, 978, -589, -461, -38, 381, -232, -817, 467, 356, -151, -460, 429, -408, 425, 618, -611, -247, 819,\ +963, -160, 1000, 141, -647, -875, 108, 790, -127, 463, -37, -195, -542, 12, 845, -384, 770, -129, 315, 826, -942, 430, 146, -170, -583, -903, -489, 497, -559, -401, -29, -129, -411, 166, 942, -646, -862, -404, 785, 777, -111, -481, -738, 490, 741, -398, 846, -178, -509, -661, 748, 297, -658, -567, 531, 427, -201, -41, -808, -668, 782, -860, -324, 249, 835, -234, 116, 542, -201, 328, 675, 480, -906, 188, 445, 63, -525, 811, 277, 133, 779, -680, 950, -477, -306, -64, 552, -890, -956, 169,\ +442, 44, -169, -243, -242, 423, -884, -757, -403, 739, -350, 383, 429, 153, -702, -725, 51, 310, 857, -56, 538, 46, -311, 132, -620, -297, -124, 534, 884, -629, -117, 506, -837, -100, -27, -381, -735, 262, 843, 703, 260, -457, 834, 469, 9, 950, 59, 127, -820, 518, 64, -783, 659, -608, -676, 802, 30, 589, 246, -369, 361, 347, 534, -376, 68, 941, 709, 264, 384, 481, 628, 199, -568, -342, -337, 853, -804, -858, -169, -270, 641, -344, 112, 530, -773, -349, -135, -367, -350, -756, -911, 180,\ +-660, 116, -478, -265, -581, 510, 520, -986, 935, 219, 522, 744, 47, -145, 917, 638, 301, 296, 858, -721, 511, -816, 328, 473, 441, 697, -260, -673, -379, 893, 458, 154, 86, 905, 590, 231, -717, -179, 79, 272, -439, -192, 178, -200, 51, 717, -256, -358, -626, -518, -314, -825, -325, 588, 675, -892, -798, 448, -518, 603, -23, 668, -655, 845, -314, 783, -347, -496, 921, 893, -163, -748, -906, 11, -143, -64, 300, 336, 882, 646, 533, 676, -98, -148, -607, -952, -481, -959, -874, 764, 537,\ +736, -347, 646, -843, 966, -916, -718, -391, -648, 740, 755, 919, -608, 388, -655, 68, 201, 675, -855, 7, -503, 881, 760, 669, 831, 721, -564, -445, 217, 331, 970, 521, 486, -254, 25, -259, 336, -831, 252, -995, 908, -412, -240, 123, -478, 366, 264, -504, -843, 632, -288, 896, 301, 423, 185, 318, 380, 457, -450, -162, -313, 673, -963, 570, 433, -548, 107, -39, -142, -98, -884, -3, 599, -486, -926, 923, -82, 686, 290, 99, -382, -789, 16, 495, 570, 284, 474, -504, -201, -178, -1, 592, 52,\ +827, -540, -151, -991, 130, 353, -420, -467, -661, 417, -690, 942, 936, 814, -566, -251, -298, 341, -139, 786, 129, 525, -861, 680, 955, -245, -50, 331, 412, -38, -66, 611, -558, 392, -629, -471, -68, -535, 744, 495, 87, 558, 695, 260, -308, 215, -464, 239, -50, 193, -540, 184, -8, -194, 148, 898, -557, -21, 884, 644, -785, -689, -281, -737, 267, 50, 206, 292, 265, 380, -511, 310, 53, 375, -497, -40, 312, -606, -395, 142, 422, 662, -584, 72, 144, 40, -679, -593, 581, 689, -829, 442, 822,\ +977, -832, -134, -248, -207, 248, 29, 259, 189, 592, -834, -866, 102, 0, 340, 25, -354, -239, 420, -730, -992, -925, -314, 420, 914, 607, -296, -415, -30, 813, 866, 153, -90, 150, -81, 636, -392, -222, -835, 482, -631, -962, -413, -727, 280, 686, -382, 157, -404, -511, -432, 455, 58, 108, -408, 290, -829, -252, 113, 550, -935, 925, 422, 38, 789, 361, 487, -460, -769, -963, -285, 206, -799, -488, -233, 416, 143, -456, 753, 520, 599, 621, -168, 178, -841, 51, 952, 374, 166, -300, -576, 844,\ +-656, 90, 780, 371, 730, -896, -895, -386, -662, 467, -61, 130, -362, -675, -113, 135, -761, -55, 408, 822, 675, -347, 725, 114, 952, -510, -972, 390, -413, -277, -52, 315, -80, 401, -712, 147, -202, 84, 214, -178, 970, -571, -210, 525, -887, -863, 504, 192, 837, -594, 203, -876, -209, 305, -826, 377, 103, -928, -803, -956, 949, -868, -547, 824, -994, 516, 93, -524, -866, -890, -988, -501, 15, -6, 413, -825, 304, -818, -223, 525, 176, 610, 828, 391, 940, 540, -831, 650, 438, 589, 941, 57,\ +523, 126, 221, 860, -282, -262, -226, 764, 743, -640, 390, 384, -434, 608, -983, 566, -446, 618, 456, -176, -278, 215, 871, -180, 444, -931, -200, -781, 404, 881, 780, -782, 517, -739, -548, -811, 201, -95, -249, -228, 491, -299, 700, 964, -550, 108, 334, -653, 245, -293, -552, 350, -685, -415, -818, 216, -194, -255, 295, 249, 408, 351, 287, 379, 682, 231, -693, 902, -902, 574, 937, -708, -402, -460, 827, -268, 791, 343, -780, -150, -738, 920, -430, -88, -361, -588, -727, -47, -297, 662,\ +-840, -637, -635, 916, -857, 938, 132, -553, 391, -522, 640, 626, 690, 833, 867, -555, 577, 226, 686, -44, 0, -965, 651, -1, 909, 595, -646, 740, -821, -648, -962, 927, -193, 159, 490, 594, -189, 707, -884, 759, -278, -160, -566, -340, 19, 862, -440, 445, -598, 341, 664, -311, 309, -159, 19, -672, 705, -646, 976, 247, 686, -830, -27, -667, 81, 399, -423, -567, 945, 38, 51, 740, 621, 204, -199, -908, -593, 424, 250, -561, 695, 9, 520, 878, 120, -109, 42, -375, -635, -711, -687, 383, -278,\ +36, 970, 925, 864, 836, 309, 117, 89, 654, -387, 346, -53, 617, -164, -624, 184, -45, 852, 498, -513, 794, -682, -576, 13, -147, 285, -776, -886, -96, 483, 994, -188, 346, -629, -848, 738, 51, 128, -898, -753, -906, 270, -203, -577, 48, -243, -210, 666, 353, 636, -954, 862, 560, -944, -877, -137, 440, -945, -316, 274, -211, -435, 615, -635, -468, 744, 948, -589, 525, 757, -191, -431, 42, 451, -160, -827, -991, 324, 697, 342, -610, 894, -787, -384, 872, 734, 878, 70, -260, 57, 397, -518,\ +629, -510, -94, 207, 214, -625, 106, -882, -575, 908, -650, 723, -154, 45, 108, -69, -565, 927, -68, -351, 707, -282, 429, -889, -596, 848, 578, -492, 41, -822, -992, 168, -286, -780, 970, 597, -293, -12, 367, 708, -415, 194, -86, -390, 224, 69, -368, -674, 1000, -672, 356, -202, -169, 826, 476, -285, 29, -448, 545, 186, 319, 67, 705, 412, 225, -212, -351, -391, -783, -9, 875, -59, -159, -123, -151, -296, 871, -638, 359, 909, -945, 345, -16, -562, -363, -183, -625, -115, -571, -329, 514,\ +99, 263, 463, -39, 597, -652, -349, 246, 77, -127, -563, -879, -30, 756, 777, -865, 675, -813, -501, 871, -406, -627, 834, -609, -205, -812, 643, -204, 291, -251, -184, -584, -541, 410, -573, -600, 908, -871, -687, 296, -713, -139, -778, -790, 347, -52, -400, 407, -653, 670, 39, -856, 904, 433, 392, 590, -271, -144, -863, 443, 353, 468, -544, 486, -930, 458, -596, -890, 163, 822, 768, 980, -783, -792, 126, 386, 367, -264, 603, -61, 728, 160, -4, -837, 832, 591, 436, 518, 796, -622, -867,\ +-669, -947, 253, 100, -792, 841, 413, 833, -249, -550, 282, -825, 936, -348, 898, -451, -283, 818, -237, 630, 216, -499, -637, -511, 767, -396, 221, 958, -586, -920, 401, -313, -580, -145, -270, 118, 497, 426, -975, 480, -445, -150, -721, -929, 439, -893, 902, 960, -525, -793, 924, 563, 683, -727, -86, 309, 432, -762, -345, 371, -617, 149, -215, -228, 505, 593, -20, -292, 704, -999, 149, -104, 819, -414, -443, 517, -599, -5, 145, -24, -993, -283, 904, 174, -112, -276, -860, 44, -257,\ +-931, -821, -667, 540, 421, 485, 531, 407, 833, 431, -415, 878, 503, -901, 639, -608, 896, 860, 927, 424, 113, -808, -323, 729, 382, -922, 548, -791, -379, 207, 203, 559, 537, 137, 999, -913, -240, 942, 249, 616, 775, -4, 915, 855, -987, -234, -384, 948, -310, -542, 125, -289, -599, 967, -492, -349, -552, 562, -926, 632, -164, 217, -165, -496, 847, 684, -884, 457, -748, -745, -38, 93, 961, 934, 588, 366, -130, 851, -803, -811, -211, 428, 183, -469, 888, 596, -475, -899, -681, 508, 184,\ +921, 863, -610, -416, -119, -966, -686, 210, 733, 715, -889, -925, -434, -566, -455, 596, -514, 983, 755, -194, -802, -313, 91, -541, 808, -834, 243, -377, 256, 966, -402, -773, -308, -605, 266, 866, 118, -425, -531, 498, 666, 813, -267, 830, 69, -869, -496, 735, 28, 488, -645, -493, -689, 170, -940, 532, 844, -658, -617, 408, -200, 764, -665, 568, 342, 621, 908, 471, 280, 859, 709, 898, 81, -547, 406, 514, -595, 43, -824, -696, -746, -429, -59, -263, -813, 233, 279, -125, 687, -418,\ +-530, 409, 614, 803, -407, 78, -676, -39, -887, -141, -292, 270, -343, 400, 907, 588, 668, 899, 973, 103, -101, -11, 397, -16, 165, 705, -410, -585, 316, 391, -346, -336, 957, -118, -538, -441, -845, 121, 591, -359, -188, -362, -208, 27, -925, -157, -495, -177, -580, 9, 531, -752, 94, 107, 820, 769, -500, 852, 617, 145, 355, 34, -463, -265, -709, -111, -855, -405, 560, 470, 3, -177, -164, -249, 450, 662, 841, -689, -509, 987, -33, 769, 234, -2, 203, 780, 744, -895, 497, -432, -406, -264,\ +-71, 124, 778, -897, 495, 127, -76, 52, -768, 205, 464, -992, 801, -83, -806, 545, -316, 146, 772, 786, 289, -936, 145, -30, -722, -455, 270, 444, 427, -482, 383, -861, 36, 630, -404, 83, 864, 743, -351, -846, 315, -837, 357, -195, 450, -715, 227, -942, 740, -519, 476, 716, 713, 169, 492, -112, -49, -931, 866, 95, -725, 198, -50, -17, -660, 356, -142, -781, 53, 431, 720, 143, -416, 446, -497, 490, -96, 157, 239, 487, -337, -224, -445, 813, 92, -22, 603, 424, 952, -632, -367, 898, -927,\ +884, -277, -187, -777, 537, -575, -313, 347, -33, 800, 672, -919, -541, 5, -270, -94, -265, -793, -183, -761, -516, -608, -218, 57, -889, -912, 508, 93, -90, 34, 530, 201, 999, -37, -186, -62, -980, 239, 902, 983, -287, -634, 524, -772, 470, -961, 32, 162, 315, -411, 400, -235, -283, -787, -703, 869, 792, 543, -274, 239, 733, -439, 306, 349, 579, -200, -201, -824, 384, -246, 133, -508, 770, -102, 957, -825, 740, 748, -376, 183, -426, 46, 668, -886, -43, -174, 672, -419, 390, 927, 1000,\ +318, 886, 47, 908, -540, -825, -5, 314, -999, 354, -603, 966, -633, -689, 985, 534, -290, 167, -652, -797, -612, -79, 488, 622, -464, -950, 595, 897, 704, -238, -395, 125, 831, -180, 226, -379, 310, 564, 56, -978, 895, -61, 686, -251, 434, -417, 161, -512, 752, 528, -589, -425, 66, -925, -157, 1000, 96, 256, -239, -784, -882, -464, -909, 663, -177, -678, -441, 669, -564, -201, -121, -743, 187, -107, -768, -682, 355, 161, 411, 984, -954, 166, -842, -755, 267, -709, 372, -699, -272, -850,\ +403, -839, 949, 622, -62, 51, 917, 70, 528, -558, -632, 832, 276, 61, -445, -195, 960, 846, -474, 764, 879, -411, 948, -62, -592, -123, -96, -551, -555, -724, 849, 250, -808, -732, 797, -839, -554, 306, -919, 888, 484, -728, 152, -122, -287, 16, -345, -396, -268, -963, -500, 433, 343, 418, -480, 828, 594, 821, -9, 933, -230, 707, -847, -610, -748, -234, 688, 935, 713, 865, -743, 293, -143, -20, 928, -906, -762, 528, 722, 412, -70, 622, -245, 539, -686, 730, -866, -705, 28, -916, -623,\ +-768, -614, -915, -123, -183, 680, -223, 515, -37, -235, -5, 260, 347, -239, -322, -861, -848, -936, 945, 721, -580, -639, 780, -153, -26, 685, 177, 587, 307, -915, 435, 658, 539, -229, -719, -171, -858, 162, 734, -539, -437, 246, 639, 765, -477, -342, -209, -284, -779, -414, -452, 914, 338, -83, 759, 567, 266, -485, 14, 225, 347, -432, -242, 997, -365, -764, 119, -641, -416, -388, -436, -388, -54, -649, -571, -920, -477, 714, -363, 836, 369, 702, 869, 503, -287, -679, 46, -666, -202,\ +-602, 71, -259, 967, 601, -571, -830, -993, -271, 281, -494, 482, -180, 572, 587, -651, -566, -448, -228, 511, -924, 832, -52, -712, 402, -644, -533, -865, 269, 965, 56, 675, 179, -338, -272, 614, 602, -283, 303, -70, 909, -942, 117, 839, 468, 813, -765, 884, -697, -813, 352, 374, -705, -295, 633, 211, -754, 597, -941, -142, -393, -469, -653, 688, 996, 911, 214, 431, 453, -141, 874, -81, -258, -735, -3, -110, -338, -929, -182, -306, -104, -840, -588, -759, -157, -801, 848, -698, 627, 914,\ +-33, -353, 425, 150, -798, 553, 934, -778, -196, -132, 808, 745, -894, 144, 213, 662, 273, -79, 454, -60, -467, 48, -15, -807, 69, -930, 749, 559, -867, -103, 258, -677, 750, -303, 846, -227, -936, 744, -770, 770, -434, 594, -477, 589, -612, 535, 357, -623, 683, 369, 905, 980, -410, -663, 762, -888, -563, -845, 843, 353, -491, 996, -255, -336, -132, 695, -823, 289, -143, 365, 916, 877, 245, -530, -848, -804, -118, -108, 847, 620, -355, 499, 881, 92, -640, 542, 38, 626, -260, -34, -378,\ +598, 890, 305, -118, 711, -385, 600, -570, 27, -129, -893, 354, 459, 374, 816, 470, 356, 661, 877, 735, -286, -780, 620, 943, -169, -888, 978, 441, -667, -399, 662, 249, 137, 598, -863, -453, 722, -815, -251, -995, -294, -707, 901, 763, 977, 137, 431, -994, 905, 593, 694, 444, -626, -816, 252, 282, 616, 841, 360, -932, 817, -908, 50, 394, -120, -786, -338, 499, -982, -95, -454, 838, -312, 320, -127, -653, 53, 16, 988, -968, -151, -369, -836, 293, -271, 483, 18, 724, -204, -965, 245, 310,\ +987, 552, -835, -912, -861, 254, 560, 124, 145, 798, 178, 476, 138, -311, 151, -907, -886, -592, 728, -43, -489, 873, -422, -439, -489, 375, -703, -459, 338, 418, -25, 332, -454, 730, -604, -800, 37, -172, -197, -568, -563, -332, 228, -182, 994, -123, 444, -567, 98, 78, 0, -504, -150, 88, -936, 199, -651, -776, 192, 46, 526, -727, -991, 534, -659, -738, 256, -894, 965, -76, 816, 435, -418, 800, 838, 67, -733, 570, 112, -514, -416\r\ +"; + thread_local! { + static TEST_TERM_AND_POINT: (Term, AlacPoint) = + build_test_term(&LINE, 5, 50); + } + TEST_TERM_AND_POINT.with(|(term, point)| { + assert_eq!( + find_from_grid_point_bench(term, *point) + .map(|(path, ..)| path) + .unwrap_or_default(), + "392", + "Hyperlink should have been found" + ); + }); + } + + #[perf] + // https://github.com/zed-industries/zed/issues/44510 + pub fn issue_44510_hyperlink_benchmark() { + const LINE: &str = "..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +..............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................\ +...............................................E.\r\ +"; + thread_local! { + static TEST_TERM_AND_POINT: (Term, AlacPoint) = + build_test_term(&LINE, 5, 50); + } + TEST_TERM_AND_POINT.with(|(term, point)| { + assert_eq!( + find_from_grid_point_bench(term, *point) + .map(|(path, ..)| path) + .unwrap_or_default(), + LINE.trim_end_matches(['.', '\r', '\n']), "Hyperlink should have been found" ); }); From 65f7412a0265552b06ce122655369d6cc7381dd6 Mon Sep 17 00:00:00 2001 From: Michael Benfield Date: Wed, 17 Dec 2025 13:02:03 -0800 Subject: [PATCH 148/266] A couple new inline assistant tests (#45049) Also adjust the code for streaming tool use to always use a rewrite_section; remove insert_here entirely. Release Notes: - N/A Co-authored-by: Max Brunsfeld --- assets/prompts/content_prompt_v2.hbs | 3 - crates/agent_ui/src/buffer_codegen.rs | 96 +++++++++++++++++++++++-- crates/agent_ui/src/inline_assistant.rs | 30 ++++++++ crates/prompt_store/src/prompts.rs | 28 +++----- 4 files changed, 130 insertions(+), 27 deletions(-) diff --git a/assets/prompts/content_prompt_v2.hbs b/assets/prompts/content_prompt_v2.hbs index 87376f49f12f0e27cc61e9f9747d9de6bfde43cb..826aada8c04863c21d756cf99beb64e582ed4906 100644 --- a/assets/prompts/content_prompt_v2.hbs +++ b/assets/prompts/content_prompt_v2.hbs @@ -14,7 +14,6 @@ The section you'll need to rewrite is marked with The context around the relevant section has been truncated (possibly in the middle of a line) for brevity. {{/if}} -{{#if rewrite_section}} And here's the section to rewrite based on that prompt again for reference: @@ -33,8 +32,6 @@ Below are the diagnostic errors visible to the user. If the user requests probl {{/each}} {{/if}} -{{/if}} - Only make changes that are necessary to fulfill the prompt, leave everything else as-is. All surrounding {{content_type}} will be preserved. Start at the indentation level in the original file in the rewritten {{content_type}}. diff --git a/crates/agent_ui/src/buffer_codegen.rs b/crates/agent_ui/src/buffer_codegen.rs index 87ce6d386b38f31a0d7b550aab00bb766ce75010..a296d4d20918fba6eb32bfcf7fcc657f9db2b3ac 100644 --- a/crates/agent_ui/src/buffer_codegen.rs +++ b/crates/agent_ui/src/buffer_codegen.rs @@ -75,6 +75,9 @@ pub struct BufferCodegen { session_id: Uuid, } +pub const REWRITE_SECTION_TOOL_NAME: &str = "rewrite_section"; +pub const FAILURE_MESSAGE_TOOL_NAME: &str = "failure_message"; + impl BufferCodegen { pub fn new( buffer: Entity, @@ -522,12 +525,12 @@ impl CodegenAlternative { let tools = vec![ LanguageModelRequestTool { - name: "rewrite_section".to_string(), + name: REWRITE_SECTION_TOOL_NAME.to_string(), description: "Replaces text in tags with your replacement_text.".to_string(), input_schema: language_model::tool_schema::root_schema_for::(tool_input_format).to_value(), }, LanguageModelRequestTool { - name: "failure_message".to_string(), + name: FAILURE_MESSAGE_TOOL_NAME.to_string(), description: "Use this tool to provide a message to the user when you're unable to complete a task.".to_string(), input_schema: language_model::tool_schema::root_schema_for::(tool_input_format).to_value(), }, @@ -1167,7 +1170,7 @@ impl CodegenAlternative { let process_tool_use = move |tool_use: LanguageModelToolUse| -> Option { let mut chars_read_so_far = chars_read_so_far.lock(); match tool_use.name.as_ref() { - "rewrite_section" => { + REWRITE_SECTION_TOOL_NAME => { let Ok(input) = serde_json::from_value::(tool_use.input) else { @@ -1180,7 +1183,7 @@ impl CodegenAlternative { description: None, }) } - "failure_message" => { + FAILURE_MESSAGE_TOOL_NAME => { let Ok(mut input) = serde_json::from_value::(tool_use.input) else { @@ -1493,7 +1496,10 @@ mod tests { use indoc::indoc; use language::{Buffer, Point}; use language_model::fake_provider::FakeLanguageModel; - use language_model::{LanguageModelRegistry, TokenUsage}; + use language_model::{ + LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelRegistry, + LanguageModelToolUse, StopReason, TokenUsage, + }; use languages::rust_lang; use rand::prelude::*; use settings::SettingsStore; @@ -1805,6 +1811,51 @@ mod tests { ); } + // When not streaming tool calls, we strip backticks as part of parsing the model's + // plain text response. This is a regression test for a bug where we stripped + // backticks incorrectly. + #[gpui::test] + async fn test_allows_model_to_output_backticks(cx: &mut TestAppContext) { + init_test(cx); + let text = "- Improved; `cmd+click` behavior. Now requires `cmd` to be pressed before the click starts or it doesn't run. ([#44579](https://github.com/zed-industries/zed/pull/44579); thanks [Zachiah](https://github.com/Zachiah))"; + let buffer = cx.new(|cx| Buffer::local("", cx)); + let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx)); + let range = buffer.read_with(cx, |buffer, cx| { + let snapshot = buffer.snapshot(cx); + snapshot.anchor_before(Point::new(0, 0))..snapshot.anchor_after(Point::new(0, 0)) + }); + let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap()); + let codegen = cx.new(|cx| { + CodegenAlternative::new( + buffer.clone(), + range.clone(), + true, + prompt_builder, + Uuid::new_v4(), + cx, + ) + }); + + let events_tx = simulate_tool_based_completion(&codegen, cx); + let chunk_len = text.find('`').unwrap(); + events_tx + .unbounded_send(rewrite_tool_use("tool_1", &text[..chunk_len], false)) + .unwrap(); + events_tx + .unbounded_send(rewrite_tool_use("tool_2", &text, true)) + .unwrap(); + events_tx + .unbounded_send(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)) + .unwrap(); + drop(events_tx); + cx.run_until_parked(); + + assert_eq!( + buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx).text()), + text + ); + } + #[gpui::test] async fn test_strip_invalid_spans_from_codeblock() { assert_chunks("Lorem ipsum dolor", "Lorem ipsum dolor").await; @@ -1870,4 +1921,39 @@ mod tests { }); chunks_tx } + + fn simulate_tool_based_completion( + codegen: &Entity, + cx: &mut TestAppContext, + ) -> mpsc::UnboundedSender { + let (events_tx, events_rx) = mpsc::unbounded(); + let model = Arc::new(FakeLanguageModel::default()); + codegen.update(cx, |codegen, cx| { + let completion_stream = Task::ready(Ok(events_rx.map(Ok).boxed() + as BoxStream< + 'static, + Result, + >)); + codegen.generation = codegen.handle_completion(model, completion_stream, cx); + }); + events_tx + } + + fn rewrite_tool_use( + id: &str, + replacement_text: &str, + is_complete: bool, + ) -> LanguageModelCompletionEvent { + let input = RewriteSectionInput { + replacement_text: replacement_text.into(), + }; + LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse { + id: id.into(), + name: REWRITE_SECTION_TOOL_NAME.into(), + raw_input: serde_json::to_string(&input).unwrap(), + input: serde_json::to_value(&input).unwrap(), + is_input_complete: is_complete, + thought_signature: None, + }) + } } diff --git a/crates/agent_ui/src/inline_assistant.rs b/crates/agent_ui/src/inline_assistant.rs index 052d8598a76d1044c6d97b5378041b5cd12e23b3..671579f9ef018b495b7993279a852595c78d3e02 100644 --- a/crates/agent_ui/src/inline_assistant.rs +++ b/crates/agent_ui/src/inline_assistant.rs @@ -2271,6 +2271,36 @@ pub mod evals { ); } + #[test] + #[cfg_attr(not(feature = "unit-eval"), ignore)] + fn eval_empty_buffer() { + run_eval( + 20, + 1.0, + "Write a Python hello, world program".to_string(), + "ˇ".to_string(), + |output| match output { + InlineAssistantOutput::Success { + full_buffer_text, .. + } => { + if full_buffer_text.is_empty() { + EvalOutput::failed("expected some output".to_string()) + } else { + EvalOutput::passed(format!("Produced {full_buffer_text}")) + } + } + o @ InlineAssistantOutput::Failure { .. } => EvalOutput::failed(format!( + "Assistant output does not match expected output: {:?}", + o + )), + o @ InlineAssistantOutput::Malformed { .. } => EvalOutput::failed(format!( + "Assistant output does not match expected output: {:?}", + o + )), + }, + ); + } + fn run_eval( iterations: usize, expected_pass_ratio: f32, diff --git a/crates/prompt_store/src/prompts.rs b/crates/prompt_store/src/prompts.rs index 674d4869e9825fd700dde3db510fbf68c6b4d5cc..6a845bb8dd394f8a1ff26a8a0e130156a2a158bd 100644 --- a/crates/prompt_store/src/prompts.rs +++ b/crates/prompt_store/src/prompts.rs @@ -112,7 +112,7 @@ pub struct ContentPromptContextV2 { pub language_name: Option, pub is_truncated: bool, pub document_content: String, - pub rewrite_section: Option, + pub rewrite_section: String, pub diagnostic_errors: Vec, } @@ -310,7 +310,6 @@ impl PromptBuilder { }; const MAX_CTX: usize = 50000; - let is_insert = range.is_empty(); let mut is_truncated = false; let before_range = 0..range.start; @@ -335,28 +334,19 @@ impl PromptBuilder { for chunk in buffer.text_for_range(truncated_before) { document_content.push_str(chunk); } - if is_insert { - document_content.push_str(""); - } else { - document_content.push_str("\n"); - for chunk in buffer.text_for_range(range.clone()) { - document_content.push_str(chunk); - } - document_content.push_str("\n"); + + document_content.push_str("\n"); + for chunk in buffer.text_for_range(range.clone()) { + document_content.push_str(chunk); } + document_content.push_str("\n"); + for chunk in buffer.text_for_range(truncated_after) { document_content.push_str(chunk); } - let rewrite_section = if !is_insert { - let mut section = String::new(); - for chunk in buffer.text_for_range(range.clone()) { - section.push_str(chunk); - } - Some(section) - } else { - None - }; + let rewrite_section: String = buffer.text_for_range(range.clone()).collect(); + let diagnostics = buffer.diagnostics_in_range::<_, Point>(range, false); let diagnostic_errors: Vec = diagnostics .map(|entry| { From 52c7447106320442be576f3d55a1410259da8046 Mon Sep 17 00:00:00 2001 From: Cameron Mcloughlin Date: Wed, 17 Dec 2025 21:53:12 +0000 Subject: [PATCH 149/266] gpui: Add Vietnamese chars to `LineWrapper::is_word_char` (#45160) --- crates/gpui/src/text_system/line_wrapper.rs | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/crates/gpui/src/text_system/line_wrapper.rs b/crates/gpui/src/text_system/line_wrapper.rs index 45159313b43c508029f2525234c80c6575d0f695..e4e18671a3d85c2f55abd8f8a61ec80833dabdf5 100644 --- a/crates/gpui/src/text_system/line_wrapper.rs +++ b/crates/gpui/src/text_system/line_wrapper.rs @@ -182,6 +182,11 @@ impl LineWrapper { // Cyrillic for Russian, Ukrainian, etc. // https://en.wikipedia.org/wiki/Cyrillic_script_in_Unicode matches!(c, '\u{0400}'..='\u{04FF}') || + + // Vietnamese (https://vietunicode.sourceforge.net/charset/) + matches!(c, '\u{1E00}'..='\u{1EFF}') || // Latin Extended Additional + matches!(c, '\u{0300}'..='\u{036F}') || // Combining Diacritical Marks + // Some other known special characters that should be treated as word characters, // e.g. `a-b`, `var_name`, `I'm`, '@mention`, `#hashtag`, `100%`, `3.1415`, // `2^3`, `a~b`, `a=1`, `Self::new`, etc. @@ -618,7 +623,12 @@ mod tests { #[track_caller] fn assert_word(word: &str) { for c in word.chars() { - assert!(LineWrapper::is_word_char(c), "assertion failed for '{}'", c); + assert!( + LineWrapper::is_word_char(c), + "assertion failed for '{}' (unicode 0x{:x})", + c, + c as u32 + ); } } @@ -661,6 +671,8 @@ mod tests { assert_word("ƀƁƂƃƄƅƆƇƈƉƊƋƌƍƎƏ"); // Cyrillic assert_word("АБВГДЕЖЗИЙКЛМНОП"); + // Vietnamese (https://github.com/zed-industries/zed/issues/23245) + assert_word("ThậmchíđếnkhithuachạychúngcònnhẫntâmgiếtnốtsốđôngtùchínhtrịởYênBáivàCaoBằng"); // non-word characters assert_not_word("你好"); From c4f8f2fbf4b68c6f39279fc99ef8ceea74891588 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 18 Dec 2025 00:22:37 +0200 Subject: [PATCH 150/266] Use less generic globs for JSONC to avoid overmatching (#45162) Otherwise, all *.json files under `zed` directory will be matched as JSONC, e.g `zed/crates/vim/test_data/test_a.json` which is not right. On top, `globset` considers that `zed/crates/vim/test_data/test_a.json` matches `**/zed/*.json` glob (!). Release Notes: - N/A --- assets/settings/default.json | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index a0280b402a0d5c6b71aca296021cc7f43c222521..e7df5ef0bf2d3bc805c79f79811d9929343544ef 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -1705,7 +1705,12 @@ // } // "file_types": { - "JSONC": ["**/.zed/**/*.json", "**/zed/**/*.json", "**/Zed/**/*.json", "**/.vscode/**/*.json", "tsconfig*.json"], + "JSONC": [ + "**/.zed/*.json", + "**/.vscode/**/*.json", + "**/{zed,Zed}/{settings,keymap,tasks,debug}.json", + "tsconfig*.json", + ], "Markdown": [".rules", ".cursorrules", ".windsurfrules", ".clinerules"], "Shell Script": [".env.*"], }, From 302a4bbdd0d30286b7688c4f2972e2f99d66999e Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Wed, 17 Dec 2025 19:28:27 -0300 Subject: [PATCH 151/266] git panel: Fix file path truncation and add some UI code clean up (#45161) This PR ensures truncation works for the file paths, which should set up the stage for when the new GPUI `truncation_start` method lands (https://github.com/zed-industries/zed/pull/45122) so that we can use for them. In the process of doing so and figuring it out why it wasn't working as well before, I noticed some opportunities to clean up some UI code: removing unnecessary styles, making the file easier to navigate given all of the different UI conditions, etc. Note: You might notice a subtle label flashing that comes with the label truncation and that's a standalone GPUI bug that's also visible in other surface areas of the app. I don't think it should block these changes here as it's something we should fix on its own... Release Notes: - N/A --- crates/git_ui/src/git_panel.rs | 307 +++++++++++++++------------------ 1 file changed, 135 insertions(+), 172 deletions(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 7216e1fc46e9d1240d23d8bd18202aa0963f846a..d392813d7602b19f04e66dd7c892cee40e8e243d 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -35,10 +35,9 @@ use git::{ }; use gpui::{ Action, AsyncApp, AsyncWindowContext, Bounds, ClickEvent, Corner, DismissEvent, Entity, - EventEmitter, FocusHandle, Focusable, KeyContext, ListHorizontalSizingBehavior, - ListSizingBehavior, MouseButton, MouseDownEvent, Point, PromptLevel, ScrollStrategy, - Subscription, Task, UniformListScrollHandle, WeakEntity, actions, anchored, deferred, point, - size, uniform_list, + EventEmitter, FocusHandle, Focusable, KeyContext, MouseButton, MouseDownEvent, Point, + PromptLevel, ScrollStrategy, Subscription, Task, UniformListScrollHandle, WeakEntity, actions, + anchored, deferred, point, size, uniform_list, }; use itertools::Itertools; use language::{Buffer, File}; @@ -212,8 +211,7 @@ const GIT_PANEL_KEY: &str = "GitPanel"; const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50); // TODO: We should revise this part. It seems the indentation width is not aligned with the one in project panel -const TREE_INDENT: f32 = 12.0; -const TREE_INDENT_GUIDE_OFFSET: f32 = 16.0; +const TREE_INDENT: f32 = 16.0; pub fn register(workspace: &mut Workspace) { workspace.register_action(|workspace, _: &ToggleFocus, window, cx| { @@ -4697,7 +4695,10 @@ impl GitPanel { }, ) .with_render_fn(cx.entity(), |_, params, _, _| { - let left_offset = px(TREE_INDENT_GUIDE_OFFSET); + // Magic number to align the tree item is 3 here + // because we're using 12px as the left-side padding + // and 3 makes the alignment work with the bounding box of the icon + let left_offset = px(TREE_INDENT + 3_f32); let indent_size = params.indent_size; let item_height = params.item_height; @@ -4725,10 +4726,6 @@ impl GitPanel { }) .size_full() .flex_grow() - .with_sizing_behavior(ListSizingBehavior::Auto) - .with_horizontal_sizing_behavior( - ListHorizontalSizingBehavior::Unconstrained, - ) .with_width_from_item(self.max_width_item_index) .track_scroll(&self.scroll_handle), ) @@ -4752,7 +4749,7 @@ impl GitPanel { } fn entry_label(&self, label: impl Into, color: Color) -> Label { - Label::new(label.into()).color(color).single_line() + Label::new(label.into()).color(color) } fn list_item_height(&self) -> Rems { @@ -4774,8 +4771,8 @@ impl GitPanel { .h(self.list_item_height()) .w_full() .items_end() - .px(rems(0.75)) // ~12px - .pb(rems(0.3125)) // ~ 5px + .px_3() + .pb_1() .child( Label::new(header.title()) .color(Color::Muted) @@ -4963,113 +4960,68 @@ impl GitPanel { let marked_bg_alpha = 0.12; let state_opacity_step = 0.04; + let info_color = cx.theme().status().info; + let base_bg = match (selected, marked) { - (true, true) => cx - .theme() - .status() - .info - .alpha(selected_bg_alpha + marked_bg_alpha), - (true, false) => cx.theme().status().info.alpha(selected_bg_alpha), - (false, true) => cx.theme().status().info.alpha(marked_bg_alpha), + (true, true) => info_color.alpha(selected_bg_alpha + marked_bg_alpha), + (true, false) => info_color.alpha(selected_bg_alpha), + (false, true) => info_color.alpha(marked_bg_alpha), _ => cx.theme().colors().ghost_element_background, }; - let hover_bg = if selected { - cx.theme() - .status() - .info - .alpha(selected_bg_alpha + state_opacity_step) - } else { - cx.theme().colors().ghost_element_hover - }; - - let active_bg = if selected { - cx.theme() - .status() - .info - .alpha(selected_bg_alpha + state_opacity_step * 2.0) + let (hover_bg, active_bg) = if selected { + ( + info_color.alpha(selected_bg_alpha + state_opacity_step), + info_color.alpha(selected_bg_alpha + state_opacity_step * 2.0), + ) } else { - cx.theme().colors().ghost_element_active + ( + cx.theme().colors().ghost_element_hover, + cx.theme().colors().ghost_element_active, + ) }; - let mut name_row = h_flex() - .items_center() - .gap_1() + let name_row = h_flex() + .min_w_0() .flex_1() - .pl(if tree_view { - px(depth as f32 * TREE_INDENT) - } else { - px(0.) - }) - .child(git_status_icon(status)); - - name_row = if tree_view { - name_row.child( - self.entry_label(display_name, label_color) - .when(status.is_deleted(), Label::strikethrough) - .truncate(), - ) - } else { - name_row.child(h_flex().items_center().flex_1().map(|this| { - self.path_formatted( - this, - entry.parent_dir(path_style), - path_color, - display_name, - label_color, - path_style, - git_path_style, - status.is_deleted(), - ) - })) - }; + .gap_1() + .child(git_status_icon(status)) + .map(|this| { + if tree_view { + this.pl(px(depth as f32 * TREE_INDENT)).child( + self.entry_label(display_name, label_color) + .when(status.is_deleted(), Label::strikethrough) + .truncate(), + ) + } else { + this.child(self.path_formatted( + entry.parent_dir(path_style), + path_color, + display_name, + label_color, + path_style, + git_path_style, + status.is_deleted(), + )) + } + }); h_flex() .id(id) .h(self.list_item_height()) .w_full() + .pl_3() + .pr_1() + .gap_1p5() .border_1() .border_r_2() .when(selected && self.focus_handle.is_focused(window), |el| { el.border_color(cx.theme().colors().panel_focused_border) }) - .px(rems(0.75)) // ~12px - .overflow_hidden() - .flex_none() - .gap_1p5() .bg(base_bg) - .hover(|this| this.bg(hover_bg)) - .active(|this| this.bg(active_bg)) - .on_click({ - cx.listener(move |this, event: &ClickEvent, window, cx| { - this.selected_entry = Some(ix); - cx.notify(); - if event.modifiers().secondary() { - this.open_file(&Default::default(), window, cx) - } else { - this.open_diff(&Default::default(), window, cx); - this.focus_handle.focus(window, cx); - } - }) - }) - .on_mouse_down( - MouseButton::Right, - move |event: &MouseDownEvent, window, cx| { - // why isn't this happening automatically? we are passing MouseButton::Right to `on_mouse_down`? - if event.button != MouseButton::Right { - return; - } - - let Some(this) = handle.upgrade() else { - return; - }; - this.update(cx, |this, cx| { - this.deploy_entry_context_menu(event.position, ix, window, cx); - }); - cx.stop_propagation(); - }, - ) - .child(name_row.overflow_x_hidden()) + .hover(|s| s.bg(hover_bg)) + .active(|s| s.bg(active_bg)) + .child(name_row) .child( div() .id(checkbox_wrapper_id) @@ -5119,6 +5071,35 @@ impl GitPanel { }), ), ) + .on_click({ + cx.listener(move |this, event: &ClickEvent, window, cx| { + this.selected_entry = Some(ix); + cx.notify(); + if event.modifiers().secondary() { + this.open_file(&Default::default(), window, cx) + } else { + this.open_diff(&Default::default(), window, cx); + this.focus_handle.focus(window, cx); + } + }) + }) + .on_mouse_down( + MouseButton::Right, + move |event: &MouseDownEvent, window, cx| { + // why isn't this happening automatically? we are passing MouseButton::Right to `on_mouse_down`? + if event.button != MouseButton::Right { + return; + } + + let Some(this) = handle.upgrade() else { + return; + }; + this.update(cx, |this, cx| { + this.deploy_entry_context_menu(event.position, ix, window, cx); + }); + cx.stop_propagation(); + }, + ) .into_any_element() } @@ -5143,29 +5124,23 @@ impl GitPanel { let selected_bg_alpha = 0.08; let state_opacity_step = 0.04; - let base_bg = if selected { - cx.theme().status().info.alpha(selected_bg_alpha) - } else { - cx.theme().colors().ghost_element_background - }; + let info_color = cx.theme().status().info; + let colors = cx.theme().colors(); - let hover_bg = if selected { - cx.theme() - .status() - .info - .alpha(selected_bg_alpha + state_opacity_step) + let (base_bg, hover_bg, active_bg) = if selected { + ( + info_color.alpha(selected_bg_alpha), + info_color.alpha(selected_bg_alpha + state_opacity_step), + info_color.alpha(selected_bg_alpha + state_opacity_step * 2.0), + ) } else { - cx.theme().colors().ghost_element_hover + ( + colors.ghost_element_background, + colors.ghost_element_hover, + colors.ghost_element_active, + ) }; - let active_bg = if selected { - cx.theme() - .status() - .info - .alpha(selected_bg_alpha + state_opacity_step * 2.0) - } else { - cx.theme().colors().ghost_element_active - }; let folder_icon = if entry.expanded { IconName::FolderOpen } else { @@ -5188,9 +5163,8 @@ impl GitPanel { }; let name_row = h_flex() - .items_center() + .min_w_0() .gap_1() - .flex_1() .pl(px(entry.depth as f32 * TREE_INDENT)) .child( Icon::new(folder_icon) @@ -5202,28 +5176,21 @@ impl GitPanel { h_flex() .id(id) .h(self.list_item_height()) + .min_w_0() .w_full() - .items_center() + .pl_3() + .pr_1() + .gap_1p5() + .justify_between() .border_1() .border_r_2() .when(selected && self.focus_handle.is_focused(window), |el| { el.border_color(cx.theme().colors().panel_focused_border) }) - .px(rems(0.75)) - .overflow_hidden() - .flex_none() - .gap_1p5() .bg(base_bg) - .hover(|this| this.bg(hover_bg)) - .active(|this| this.bg(active_bg)) - .on_click({ - let key = entry.key.clone(); - cx.listener(move |this, _event: &ClickEvent, window, cx| { - this.selected_entry = Some(ix); - this.toggle_directory(&key, window, cx); - }) - }) - .child(name_row.overflow_x_hidden()) + .hover(|s| s.bg(hover_bg)) + .active(|s| s.bg(active_bg)) + .child(name_row) .child( div() .id(checkbox_wrapper_id) @@ -5262,12 +5229,18 @@ impl GitPanel { }), ), ) + .on_click({ + let key = entry.key.clone(); + cx.listener(move |this, _event: &ClickEvent, window, cx| { + this.selected_entry = Some(ix); + this.toggle_directory(&key, window, cx); + }) + }) .into_any_element() } fn path_formatted( &self, - parent: Div, directory: Option, path_color: Color, file_name: String, @@ -5276,41 +5249,31 @@ impl GitPanel { git_path_style: GitPathStyle, strikethrough: bool, ) -> Div { - parent - .when(git_path_style == GitPathStyle::FileNameFirst, |this| { - this.child( - self.entry_label( - match directory.as_ref().is_none_or(|d| d.is_empty()) { - true => file_name.clone(), - false => format!("{file_name} "), - }, - label_color, - ) - .when(strikethrough, Label::strikethrough), - ) - }) - .when_some(directory, |this, dir| { - match ( - !dir.is_empty(), - git_path_style == GitPathStyle::FileNameFirst, - ) { - (true, true) => this.child( - self.entry_label(dir, path_color) - .when(strikethrough, Label::strikethrough), - ), - (true, false) => this.child( - self.entry_label( - format!("{dir}{}", path_style.primary_separator()), - path_color, - ) + let file_name_first = git_path_style == GitPathStyle::FileNameFirst; + let file_path_first = git_path_style == GitPathStyle::FilePathFirst; + + let file_name = format!("{} ", file_name); + + h_flex() + .min_w_0() + .overflow_hidden() + .when(file_path_first, |this| this.flex_row_reverse()) + .child( + div().flex_none().child( + self.entry_label(file_name, label_color) .when(strikethrough, Label::strikethrough), - ), - _ => this, - } - }) - .when(git_path_style == GitPathStyle::FilePathFirst, |this| { + ), + ) + .when_some(directory, |this, dir| { + let path_name = if file_name_first { + dir + } else { + format!("{dir}{}", path_style.primary_separator()) + }; + this.child( - self.entry_label(file_name, label_color) + self.entry_label(path_name, path_color) + .truncate() .when(strikethrough, Label::strikethrough), ) }) From 623e13761b02dd98443a7ada94b6a00ebffc46ee Mon Sep 17 00:00:00 2001 From: LoricAndre <57358788+LoricAndre@users.noreply.github.com> Date: Wed, 17 Dec 2025 23:31:12 +0100 Subject: [PATCH 152/266] git: Unify commit popups (#38749) Closes #26424 Supersedes #35328 Originally, `git::blame` uses its own `ParsedCommitMessage` as the source for the commit information, including the PR section. This changes unifies this with `git::repository` and `git_ui::git_panel` by moving this and some other commit-related structs to `git::commit` instead, and making both `git_ui::blame_ui` and `git_ui::git_panel` pull their information from these structs. Release notes : - (Let's Git Together) Fixed the commit tooltip in the git panel not showing information like avatars. --------- Co-authored-by: Cole Miller Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com> --- crates/editor/src/editor.rs | 6 +-- crates/editor/src/element.rs | 6 +-- crates/editor/src/git/blame.rs | 82 ++++++----------------------- crates/git/src/blame.rs | 11 +--- crates/git/src/commit.rs | 49 ++++++++++++++++- crates/git_ui/src/blame_ui.rs | 5 +- crates/git_ui/src/commit_tooltip.rs | 2 +- crates/git_ui/src/git_panel.rs | 20 ++++--- crates/project/src/git_store.rs | 5 ++ 9 files changed, 87 insertions(+), 99 deletions(-) diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs index 83051ffb9ea1a5f5754b2af4d1cf42526cfd391e..8560705802264dad55b87dbf21e1f9aa7625edf8 100644 --- a/crates/editor/src/editor.rs +++ b/crates/editor/src/editor.rs @@ -73,11 +73,7 @@ pub use multi_buffer::{ pub use split::SplittableEditor; pub use text::Bias; -use ::git::{ - Restore, - blame::{BlameEntry, ParsedCommitMessage}, - status::FileStatus, -}; +use ::git::{Restore, blame::BlameEntry, commit::ParsedCommitMessage, status::FileStatus}; use aho_corasick::{AhoCorasick, AhoCorasickBuilder, BuildError}; use anyhow::{Context as _, Result, anyhow, bail}; use blink_manager::BlinkManager; diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs index 9b6115daed700bf391ef6b076100702b99ecaabe..f7b6aa949e74dca9bee73419fa2b87899f9986fd 100644 --- a/crates/editor/src/element.rs +++ b/crates/editor/src/element.rs @@ -37,11 +37,7 @@ use crate::{ use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind}; use collections::{BTreeMap, HashMap}; use file_icons::FileIcons; -use git::{ - Oid, - blame::{BlameEntry, ParsedCommitMessage}, - status::FileStatus, -}; +use git::{Oid, blame::BlameEntry, commit::ParsedCommitMessage, status::FileStatus}; use gpui::{ Action, Along, AnyElement, App, AppContext, AvailableSpace, Axis as ScrollbarAxis, BorderStyle, Bounds, ClickEvent, ClipboardItem, ContentMask, Context, Corner, Corners, CursorStyle, diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rs index 031795ff2dbfceb96f950db18101b37fd3cdcf84..d1338c3cbd3540914b23a53410fd5c823e1285c8 100644 --- a/crates/editor/src/git/blame.rs +++ b/crates/editor/src/git/blame.rs @@ -3,9 +3,9 @@ use anyhow::{Context as _, Result}; use collections::HashMap; use git::{ - GitHostingProviderRegistry, GitRemote, Oid, - blame::{Blame, BlameEntry, ParsedCommitMessage}, - parse_git_remote_url, + GitHostingProviderRegistry, Oid, + blame::{Blame, BlameEntry}, + commit::ParsedCommitMessage, }; use gpui::{ AnyElement, App, AppContext as _, Context, Entity, Hsla, ScrollHandle, Subscription, Task, @@ -525,12 +525,7 @@ impl GitBlame { .git_store() .read(cx) .repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx) - .and_then(|(repo, _)| { - repo.read(cx) - .remote_upstream_url - .clone() - .or(repo.read(cx).remote_origin_url.clone()) - }); + .and_then(|(repo, _)| repo.read(cx).default_remote_url()); let blame_buffer = project .update(cx, |project, cx| project.blame_buffer(&buffer, None, cx)); Ok(async move { @@ -554,13 +549,19 @@ impl GitBlame { entries, snapshot.max_point().row, ); - let commit_details = parse_commit_messages( - messages, - remote_url, - provider_registry.clone(), - ) - .await; - + let commit_details = messages + .into_iter() + .map(|(oid, message)| { + let parsed_commit_message = + ParsedCommitMessage::parse( + oid.to_string(), + message, + remote_url.as_deref(), + Some(provider_registry.clone()), + ); + (oid, parsed_commit_message) + }) + .collect(); res.push(( id, snapshot, @@ -680,55 +681,6 @@ fn build_blame_entry_sum_tree(entries: Vec, max_row: u32) -> SumTree entries } -async fn parse_commit_messages( - messages: impl IntoIterator, - remote_url: Option, - provider_registry: Arc, -) -> HashMap { - let mut commit_details = HashMap::default(); - - let parsed_remote_url = remote_url - .as_deref() - .and_then(|remote_url| parse_git_remote_url(provider_registry, remote_url)); - - for (oid, message) in messages { - let permalink = if let Some((provider, git_remote)) = parsed_remote_url.as_ref() { - Some(provider.build_commit_permalink( - git_remote, - git::BuildCommitPermalinkParams { - sha: oid.to_string().as_str(), - }, - )) - } else { - None - }; - - let remote = parsed_remote_url - .as_ref() - .map(|(provider, remote)| GitRemote { - host: provider.clone(), - owner: remote.owner.clone().into(), - repo: remote.repo.clone().into(), - }); - - let pull_request = parsed_remote_url - .as_ref() - .and_then(|(provider, remote)| provider.extract_pull_request(remote, &message)); - - commit_details.insert( - oid, - ParsedCommitMessage { - message: message.into(), - permalink, - remote, - pull_request, - }, - ); - } - - commit_details -} - #[cfg(test)] mod tests { use super::*; diff --git a/crates/git/src/blame.rs b/crates/git/src/blame.rs index c3bbeff3f7d15d84b779f2ab92cb89799f63c4e8..d6011de98b8c69837d16bf2a2211fc7632726230 100644 --- a/crates/git/src/blame.rs +++ b/crates/git/src/blame.rs @@ -1,10 +1,9 @@ +use crate::Oid; use crate::commit::get_messages; use crate::repository::RepoPath; -use crate::{GitRemote, Oid}; use anyhow::{Context as _, Result}; use collections::{HashMap, HashSet}; use futures::AsyncWriteExt; -use gpui::SharedString; use serde::{Deserialize, Serialize}; use std::process::Stdio; use std::{ops::Range, path::Path}; @@ -21,14 +20,6 @@ pub struct Blame { pub messages: HashMap, } -#[derive(Clone, Debug, Default)] -pub struct ParsedCommitMessage { - pub message: SharedString, - pub permalink: Option, - pub pull_request: Option, - pub remote: Option, -} - impl Blame { pub async fn for_path( git_binary: &Path, diff --git a/crates/git/src/commit.rs b/crates/git/src/commit.rs index ece1d76b8ae9c9f40f27178da1ef13fe1a78e659..1b450a3dffb9e9956e5b43aa2797ae02f90e731c 100644 --- a/crates/git/src/commit.rs +++ b/crates/git/src/commit.rs @@ -1,7 +1,52 @@ -use crate::{Oid, status::StatusCode}; +use crate::{ + BuildCommitPermalinkParams, GitHostingProviderRegistry, GitRemote, Oid, parse_git_remote_url, + status::StatusCode, +}; use anyhow::{Context as _, Result}; use collections::HashMap; -use std::path::Path; +use gpui::SharedString; +use std::{path::Path, sync::Arc}; + +#[derive(Clone, Debug, Default)] +pub struct ParsedCommitMessage { + pub message: SharedString, + pub permalink: Option, + pub pull_request: Option, + pub remote: Option, +} + +impl ParsedCommitMessage { + pub fn parse( + sha: String, + message: String, + remote_url: Option<&str>, + provider_registry: Option>, + ) -> Self { + if let Some((hosting_provider, remote)) = provider_registry + .and_then(|reg| remote_url.and_then(|url| parse_git_remote_url(reg, url))) + { + let pull_request = hosting_provider.extract_pull_request(&remote, &message); + Self { + message: message.into(), + permalink: Some( + hosting_provider + .build_commit_permalink(&remote, BuildCommitPermalinkParams { sha: &sha }), + ), + pull_request, + remote: Some(GitRemote { + host: hosting_provider, + owner: remote.owner.into(), + repo: remote.repo.into(), + }), + } + } else { + Self { + message: message.into(), + ..Default::default() + } + } + } +} pub async fn get_messages(working_directory: &Path, shas: &[Oid]) -> Result> { if shas.is_empty() { diff --git a/crates/git_ui/src/blame_ui.rs b/crates/git_ui/src/blame_ui.rs index 09ab3229bc5b2b7814b89bbb914472407793a52d..d4d8750a18ee6efbd90a38722043450c6ec61358 100644 --- a/crates/git_ui/src/blame_ui.rs +++ b/crates/git_ui/src/blame_ui.rs @@ -3,10 +3,7 @@ use crate::{ commit_view::CommitView, }; use editor::{BlameRenderer, Editor, hover_markdown_style}; -use git::{ - blame::{BlameEntry, ParsedCommitMessage}, - repository::CommitSummary, -}; +use git::{blame::BlameEntry, commit::ParsedCommitMessage, repository::CommitSummary}; use gpui::{ ClipboardItem, Entity, Hsla, MouseButton, ScrollHandle, Subscription, TextStyle, TextStyleRefinement, UnderlineStyle, WeakEntity, prelude::*, diff --git a/crates/git_ui/src/commit_tooltip.rs b/crates/git_ui/src/commit_tooltip.rs index cf6512b0763e128633cfa65f934d8ed18cd6d022..d18770a704ff31d6dffd705baf44defaaf6d8d4a 100644 --- a/crates/git_ui/src/commit_tooltip.rs +++ b/crates/git_ui/src/commit_tooltip.rs @@ -3,7 +3,7 @@ use editor::hover_markdown_style; use futures::Future; use git::blame::BlameEntry; use git::repository::CommitSummary; -use git::{GitRemote, blame::ParsedCommitMessage}; +use git::{GitRemote, commit::ParsedCommitMessage}; use gpui::{ App, Asset, ClipboardItem, Element, Entity, MouseButton, ParentElement, Render, ScrollHandle, StatefulInteractiveElement, WeakEntity, prelude::*, diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index d392813d7602b19f04e66dd7c892cee40e8e243d..84c6e9b301d77845f115514eb2a9339fcb813701 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -20,7 +20,7 @@ use editor::{ actions::ExpandAllDiffHunks, }; use futures::StreamExt as _; -use git::blame::ParsedCommitMessage; +use git::commit::ParsedCommitMessage; use git::repository::{ Branch, CommitDetails, CommitOptions, CommitSummary, DiffType, FetchOptions, GitCommitter, PushOptions, Remote, RemoteCommandOutput, ResetMode, Upstream, UpstreamTracking, @@ -30,8 +30,8 @@ use git::stash::GitStash; use git::status::StageStatus; use git::{Amend, Signoff, ToggleStaged, repository::RepoPath, status::FileStatus}; use git::{ - ExpandCommitEditor, RestoreTrackedFiles, StageAll, StashAll, StashApply, StashPop, - TrashUntrackedFiles, UnstageAll, + ExpandCommitEditor, GitHostingProviderRegistry, RestoreTrackedFiles, StageAll, StashAll, + StashApply, StashPop, TrashUntrackedFiles, UnstageAll, }; use gpui::{ Action, AsyncApp, AsyncWindowContext, Bounds, ClickEvent, Corner, DismissEvent, Entity, @@ -5613,6 +5613,7 @@ impl GitPanelMessageTooltip { window: &mut Window, cx: &mut App, ) -> Entity { + let remote_url = repository.read(cx).default_remote_url(); cx.new(|cx| { cx.spawn_in(window, async move |this, cx| { let (details, workspace) = git_panel.update(cx, |git_panel, cx| { @@ -5622,16 +5623,21 @@ impl GitPanelMessageTooltip { ) })?; let details = details.await?; + let provider_registry = cx + .update(|_, app| GitHostingProviderRegistry::default_global(app)) + .ok(); let commit_details = crate::commit_tooltip::CommitDetails { sha: details.sha.clone(), author_name: details.author_name.clone(), author_email: details.author_email.clone(), commit_time: OffsetDateTime::from_unix_timestamp(details.commit_timestamp)?, - message: Some(ParsedCommitMessage { - message: details.message, - ..Default::default() - }), + message: Some(ParsedCommitMessage::parse( + details.sha.to_string(), + details.message.to_string(), + remote_url.as_deref(), + provider_registry, + )), }; this.update(cx, |this: &mut GitPanelMessageTooltip, cx| { diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index a414a03320a2defa4c9dbd4b6193a131e761d2c7..6eff10ddba1c986ef8c310084b08d2d398b52c5d 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -5948,6 +5948,11 @@ impl Repository { self.pending_ops.edit(edits, ()); ids } + pub fn default_remote_url(&self) -> Option { + self.remote_upstream_url + .clone() + .or(self.remote_origin_url.clone()) + } } fn get_permalink_in_rust_registry_src( From f2d29f47906c588c4ae2ba2d7e58e4ec83074b99 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 17 Dec 2025 15:32:28 -0700 Subject: [PATCH 153/266] Auto-release preview as Zippy (#45163) I think we're not triggering the after-release workflow because of github's loop detection when you use the default GITHUB_TOKEN Closes #ISSUE Release Notes: - N/A --- .github/workflows/autofix_pr.yml | 2 +- .github/workflows/cherry_pick.yml | 2 +- .github/workflows/release.yml | 8 +++++++- tooling/xtask/src/tasks/workflows/autofix_pr.rs | 15 +-------------- .../xtask/src/tasks/workflows/cherry_pick.rs | 17 ++--------------- tooling/xtask/src/tasks/workflows/release.rs | 5 ++++- tooling/xtask/src/tasks/workflows/steps.rs | 13 +++++++++++++ 7 files changed, 29 insertions(+), 33 deletions(-) diff --git a/.github/workflows/autofix_pr.yml b/.github/workflows/autofix_pr.yml index 1591ba2a9a98b8587814d25858f4e0d78d9f7d34..d3688a722aa107efb3dfb95351404f43c9aece65 100644 --- a/.github/workflows/autofix_pr.yml +++ b/.github/workflows/autofix_pr.yml @@ -90,7 +90,7 @@ jobs: runs-on: namespace-profile-2x4-ubuntu-2404 steps: - id: get-app-token - name: autofix_pr::commit_changes::authenticate_as_zippy + name: steps::authenticate_as_zippy uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 with: app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} diff --git a/.github/workflows/cherry_pick.yml b/.github/workflows/cherry_pick.yml index bc01aae17e7141a2359b162c3de94c1aec7b765c..d4dee5154f2209521f3e9d183c05c118e8861521 100644 --- a/.github/workflows/cherry_pick.yml +++ b/.github/workflows/cherry_pick.yml @@ -30,7 +30,7 @@ jobs: with: clean: false - id: get-app-token - name: cherry_pick::run_cherry_pick::authenticate_as_zippy + name: steps::authenticate_as_zippy uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 with: app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 155b38666f4bd73e68e9ea326db9a6862288a1fe..8cc63340902fb061c66e5896308f2cad9c31f947 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -478,11 +478,17 @@ jobs: if: startsWith(github.ref, 'refs/tags/v') && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre') runs-on: namespace-profile-2x4-ubuntu-2404 steps: + - id: get-app-token + name: steps::authenticate_as_zippy + uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 + with: + app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} + private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }} - name: gh release edit "$GITHUB_REF_NAME" --repo=zed-industries/zed --draft=false run: gh release edit "$GITHUB_REF_NAME" --repo=zed-industries/zed --draft=false shell: bash -euxo pipefail {0} env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} notify_on_failure: needs: - upload_release_assets diff --git a/tooling/xtask/src/tasks/workflows/autofix_pr.rs b/tooling/xtask/src/tasks/workflows/autofix_pr.rs index f4a8e0e2b09df93cc430f0931c3db3f9e67b07df..ab59e735225dfb4f9658960a35a992553642b4c2 100644 --- a/tooling/xtask/src/tasks/workflows/autofix_pr.rs +++ b/tooling/xtask/src/tasks/workflows/autofix_pr.rs @@ -109,19 +109,6 @@ fn run_autofix(pr_number: &WorkflowInput, run_clippy: &WorkflowInput) -> NamedJo } fn commit_changes(pr_number: &WorkflowInput, autofix_job: &NamedJob) -> NamedJob { - fn authenticate_as_zippy() -> (Step, StepOutput) { - let step = named::uses( - "actions", - "create-github-app-token", - "bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1", - ) - .add_with(("app-id", vars::ZED_ZIPPY_APP_ID)) - .add_with(("private-key", vars::ZED_ZIPPY_APP_PRIVATE_KEY)) - .id("get-app-token"); - let output = StepOutput::new(&step, "token"); - (step, output) - } - fn checkout_pr(pr_number: &WorkflowInput, token: &StepOutput) -> Step { named::bash(&format!("gh pr checkout {pr_number}")).add_env(("GITHUB_TOKEN", token)) } @@ -148,7 +135,7 @@ fn commit_changes(pr_number: &WorkflowInput, autofix_job: &NamedJob) -> NamedJob .add_env(("GITHUB_TOKEN", token)) } - let (authenticate, token) = authenticate_as_zippy(); + let (authenticate, token) = steps::authenticate_as_zippy(); named::job( Job::default() diff --git a/tooling/xtask/src/tasks/workflows/cherry_pick.rs b/tooling/xtask/src/tasks/workflows/cherry_pick.rs index 105bf74c4194a46ad4ca62991fae3a945eea150d..eaa786837f84ebf4d4f7e1a579db0c7b4dcc5040 100644 --- a/tooling/xtask/src/tasks/workflows/cherry_pick.rs +++ b/tooling/xtask/src/tasks/workflows/cherry_pick.rs @@ -3,7 +3,7 @@ use gh_workflow::*; use crate::tasks::workflows::{ runners, steps::{self, NamedJob, named}, - vars::{self, StepOutput, WorkflowInput}, + vars::{StepOutput, WorkflowInput}, }; pub fn cherry_pick() -> Workflow { @@ -29,19 +29,6 @@ fn run_cherry_pick( commit: &WorkflowInput, channel: &WorkflowInput, ) -> NamedJob { - fn authenticate_as_zippy() -> (Step, StepOutput) { - let step = named::uses( - "actions", - "create-github-app-token", - "bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1", - ) // v2 - .add_with(("app-id", vars::ZED_ZIPPY_APP_ID)) - .add_with(("private-key", vars::ZED_ZIPPY_APP_PRIVATE_KEY)) - .id("get-app-token"); - let output = StepOutput::new(&step, "token"); - (step, output) - } - fn cherry_pick( branch: &WorkflowInput, commit: &WorkflowInput, @@ -54,7 +41,7 @@ fn run_cherry_pick( .add_env(("GITHUB_TOKEN", token)) } - let (authenticate, token) = authenticate_as_zippy(); + let (authenticate, token) = steps::authenticate_as_zippy(); named::job( Job::default() diff --git a/tooling/xtask/src/tasks/workflows/release.rs b/tooling/xtask/src/tasks/workflows/release.rs index e06a71340192c036d442d65d9572e52ed2983cae..80fb075f7f6445b1a6a078d9defba2018a406851 100644 --- a/tooling/xtask/src/tasks/workflows/release.rs +++ b/tooling/xtask/src/tasks/workflows/release.rs @@ -97,17 +97,20 @@ pub(crate) fn create_sentry_release() -> Step { } fn auto_release_preview(deps: &[&NamedJob; 1]) -> NamedJob { + let (authenticate, token) = steps::authenticate_as_zippy(); + named::job( dependant_job(deps) .runs_on(runners::LINUX_SMALL) .cond(Expression::new(indoc::indoc!( r#"startsWith(github.ref, 'refs/tags/v') && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre')"# ))) + .add_step(authenticate) .add_step( steps::script( r#"gh release edit "$GITHUB_REF_NAME" --repo=zed-industries/zed --draft=false"#, ) - .add_env(("GITHUB_TOKEN", vars::GITHUB_TOKEN)), + .add_env(("GITHUB_TOKEN", &token)), ) ) } diff --git a/tooling/xtask/src/tasks/workflows/steps.rs b/tooling/xtask/src/tasks/workflows/steps.rs index 54873c011ce9d1fb7d4e7e0b734695c7c1a30fad..5ff7c0cae3c3740fa89abd84d049f9f76e7d721b 100644 --- a/tooling/xtask/src/tasks/workflows/steps.rs +++ b/tooling/xtask/src/tasks/workflows/steps.rs @@ -354,3 +354,16 @@ pub fn trigger_autofix(run_clippy: bool) -> Step { )) .add_env(("GITHUB_TOKEN", vars::GITHUB_TOKEN)) } + +pub fn authenticate_as_zippy() -> (Step, StepOutput) { + let step = named::uses( + "actions", + "create-github-app-token", + "bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1", + ) + .add_with(("app-id", vars::ZED_ZIPPY_APP_ID)) + .add_with(("private-key", vars::ZED_ZIPPY_APP_PRIVATE_KEY)) + .id("get-app-token"); + let output = StepOutput::new(&step, "token"); + (step, output) +} From 25e1e2ecdd131291dcb791d5841ed012cd219040 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Wed, 17 Dec 2025 16:42:18 -0600 Subject: [PATCH 154/266] Don't trigger autosave on focus change in modals (#45166) Closes #28732 Release Notes: - Opening the command palette or other modals no longer triggers auto-save with the `{ "autosave": "on_focus_change" }` setting. This reduces the chance of unwanted format changes when executing actions, and fixes a race condition with `:w` in Vim mode --- crates/workspace/src/item.rs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs index 4bde632ce720dad792d19677c60ab62fd51d3637..1570c125fa33135631d8181359ad34bb7802ec5f 100644 --- a/crates/workspace/src/item.rs +++ b/crates/workspace/src/item.rs @@ -886,8 +886,12 @@ impl ItemHandle for Entity { // Only trigger autosave if focus has truly left the item. // If focus is still within the item's hierarchy (e.g., moved to a context menu), // don't trigger autosave to avoid unwanted formatting and cursor jumps. + // Also skip autosave if focus moved to a modal (e.g., command palette), + // since the user is still interacting with the workspace. let focus_handle = item.item_focus_handle(cx); - if !focus_handle.contains_focused(window, cx) { + if !focus_handle.contains_focused(window, cx) + && !workspace.has_active_modal(window, cx) + { Pane::autosave_item(&item, workspace.project.clone(), window, cx) .detach_and_log_err(cx); } From f00cb371f4894ec06e1b72bf253e534a7b96499e Mon Sep 17 00:00:00 2001 From: Nathan Sobo Date: Wed, 17 Dec 2025 15:42:31 -0700 Subject: [PATCH 155/266] macOS: Bundle placeholder Document.icns so Finder can display Zed file icons (#44833) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Generated by AI. `DocumentTypes.plist` declares `CFBundleTypeIconFile` as `Document` for Zed’s document types, but the macOS bundle did not include `Contents/Resources/Document.icns`, causing Finder to fall back to generic icons. This PR: - Adds `crates/zed/resources/Document.icns` as a placeholder document icon (currently derived from the app icon). - Updates `script/bundle-mac` to copy it into the `.app` at `Contents/Resources/Document.icns` during bundling. - Adds `script/verify-macos-document-icon` for one-command validation. ## How to test (CLI) 1. Build a debug bundle: - `./script/bundle-mac -d aarch64-apple-darwin` 2. Verify the bundle contains the referenced icon: - `./script/verify-macos-document-icon "target/aarch64-apple-darwin/debug/bundle/osx/Zed Dev.app"` ## Optional visual validation in Finder - Pick a file (e.g. `.rs`), Get Info → Open with: Zed Dev → Change All... - Restart Finder: `killall Finder` (or log out/in) @JosephTLyons — would you mind running the steps above and confirming Finder shows Zed’s icon for source files after "Change All" + Finder restart? @danilo-leal — this PR ships a placeholder `Document.icns`. When the real document icon is ready, replace `crates/zed/resources/Document.icns` and the bundling script will include it automatically. Closes #44403. Release Notes: - TODO --------- Co-authored-by: Matt Miller --- crates/zed/resources/Document.icns | Bin 0 -> 1118811 bytes script/bundle-mac | 11 ++++ script/verify-macos-document-icon | 81 +++++++++++++++++++++++++++++ 3 files changed, 92 insertions(+) create mode 100644 crates/zed/resources/Document.icns create mode 100755 script/verify-macos-document-icon diff --git a/crates/zed/resources/Document.icns b/crates/zed/resources/Document.icns new file mode 100644 index 0000000000000000000000000000000000000000..5d0185c81a32c214f213f12243aeab01e32830e1 GIT binary patch literal 1118811 zcmZs>1CS`e(j`2$@7T6&+qP}nwr$(CZF}z6wzc=Y|BF91cDK5!^JG> zFtT+5Kt$5AFk+zpCzSvI0AMWT@$q4y!l3?PWK(AkdrNyp{C^nWf27<$Y5q?|wJ3CXP-P zcDDEov>f#Gv<$zB05JbN0Rn)6fB*pgY6JY?=NA{3|KIzs4gfOX|I-Te|Fi=C-`045 z|GX|lM5KQql6J$i_7LSId_a+w4;3BHUEP!V)0X7GW06=GE#nUyxWAUs)b4;RdP3Vuf_T3}|MH`gfFtUNs$qXb zQcyN}27F!P@nun|qer&Cr$8l{6}VG{WgF;c4*`NMPCHT1|Y&JlO2m-1E#G`s-_#b zo72EK+*@H2<^veuKcx|%Yf0f_Dg+*%-TzX-kcns-^yg;{sIz*#iPE4Bs7DD=x&+8g zSjXb(pFrWDG@~v>d1mZUTrk>MPRcs%tR!cj1ZltvAN)luaV{cS zGjeoQMjVGHSG%^N{OF=tl&s`I9`;Qg2(OfJWnx4WAVKy7@D_hr#^cKo1&PQ| z;bJzpP{v+ONMu5E9}aU6q*46-RYkmB)#=xkS1&7#2}t^`*Zq{VB@){6fFc=n85lyP z2sN|UpMQTY?=K9`*XNVO{S&?6qX=VU&FC5qc_o4_QBc^s80G6d4jn7`LMYcsr$ucj z;c&ZB(Qj2ZGicvhj^F_32?mztRBrUPRgE3-gYPBl>xrVo zx+50(7uRQ2jOQ-~VZ!1f;I@d*8#@lJ8ruEb*ZOnXz5OGxU^{lo(YR2AVp}lk+HROS{(n;3a{lwEn4$xMs9VHu4?>ntA<>#1a|CzN z;KH%9-R~D|&AZ91UVwjLFU8Y)$P4+I;Hz@Li8KO z6h)RllX{CRdw*~+zXX+DfJx?j44%%WOBJ&j#VOpyr#ld``RdQi`pWbeI#8XdY(W3RBYe95|Xt(OA-UI5f;AF&-mW55Nf!EWN~xapi;-3-@0_Ej|g8YR9-+HKOPi)Q> zZuM+y(Q$7G=Y;T>rG4{V<0A>Mz)4?IqX*YTpeK^JvES2zz17}#D@oKJ;iT+IMf@zh zIb)~%d%&ihxyxtIf4GD&H8OO+i?kxHj6gSqvgF^;>GSiT>Ln$y#Zxp=bjT%Nka^YC zv3A4M^8cH}3qT-xkIf28r%F!eG6#)z0w#;3LS{A&^kSqiQPpA0hJ+`J> z;|>R)z-Zm9cL{Tuk58gUD`t}mRqf8iN+*MYn#_NJApu7S6)FF_uL3GXm9!U2Kq~S{ zN&7=GO8J#lEXa$GTRw_sbqt3L4NrGS2Mi*?;03`dgt69z_53V?69s-(e`69!b~24k zr^nlF{*=I}0%(XWi*Gq?0I}_udF!nN70I@x;WyG6cMqc?@c(~-GMD{Rcw=~m%Lfcf zBnTv+5GU@`@nR6AXZ3XD8*^D0vp}yuXX0FDi>+X$W;d z%h5Ky?ql}^fePR}LI49&YS8kkD&}zrts?2h--<4xl#OPQq0C;DbJQ!vy}ZuPmXiI}`RW4ykseS8XzuqY!;#VQg~ zQ8_t=I6XBJY)Ct~CFx$4C_kzjF3RFgAr|v

+DFC-AcA8Zgt;D0Du3d{l}QQvVrS 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

C#R)_wP80*@F-mGH}5C;>kzefn8m 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

;b<*BtIk|r@Wt{)+gZ@df5a^M*MQj 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�M}tA>?tDS@3weDjUFigFPk*V?OajF53(_|AWVM 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

M_@`w|A=UL;haXHu&f$D3lyJqE(;W@-#G9t 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 z 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

bE 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

>Oy$*z>16ABKCKYW5;|7@|dV)a4K8 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 ALjV8( literal 0 HcmV?d00001 diff --git a/script/bundle-mac b/script/bundle-mac index c6c925f073600336f4aa3114a732609481ade26e..93ea07b162612d27784dbd0eb54598b0aa2252c3 100755 --- a/script/bundle-mac +++ b/script/bundle-mac @@ -106,6 +106,17 @@ mv Cargo.toml.backup Cargo.toml popd echo "Bundled ${app_path}" +# DocumentTypes.plist references CFBundleTypeIconFile "Document", so the bundle must contain Document.icns. +# We use the app icon as a placeholder document icon for now. +document_icon_source="crates/zed/resources/Document.icns" +document_icon_target="${app_path}/Contents/Resources/Document.icns" +if [[ -f "${document_icon_source}" ]]; then + mkdir -p "$(dirname "${document_icon_target}")" + cp "${document_icon_source}" "${document_icon_target}" +else + echo "cargo::warning=Missing ${document_icon_source}; macOS document icons may not appear in Finder." +fi + if [[ -n "${MACOS_CERTIFICATE:-}" && -n "${MACOS_CERTIFICATE_PASSWORD:-}" && -n "${APPLE_NOTARIZATION_KEY:-}" && -n "${APPLE_NOTARIZATION_KEY_ID:-}" && -n "${APPLE_NOTARIZATION_ISSUER_ID:-}" ]]; then can_code_sign=true diff --git a/script/verify-macos-document-icon b/script/verify-macos-document-icon new file mode 100755 index 0000000000000000000000000000000000000000..de2581c9df764ee2019740048381d6d66dc3499d --- /dev/null +++ b/script/verify-macos-document-icon @@ -0,0 +1,81 @@ +#!/usr/bin/env bash +set -euo pipefail + +usage() { + cat <<'USAGE' +Usage: + script/verify-macos-document-icon /path/to/Zed.app + +Verifies that the given macOS app bundle's Info.plist references a document icon +named "Document" and that the corresponding icon file exists in the bundle. + +Specifically checks: + - CFBundleDocumentTypes[*].CFBundleTypeIconFile includes "Document" + - Contents/Resources/Document.icns exists + +Exit codes: + 0 - success + 1 - verification failed + 2 - invalid usage / missing prerequisites +USAGE +} + +fail() { + echo "error: $*" >&2 + exit 1 +} + +if [[ $# -ne 1 ]]; then + usage >&2 + exit 2 +fi + +app_path="$1" + +if [[ ! -d "${app_path}" ]]; then + fail "app bundle not found: ${app_path}" +fi + +info_plist="${app_path}/Contents/Info.plist" +if [[ ! -f "${info_plist}" ]]; then + fail "missing Info.plist: ${info_plist}" +fi + +if ! command -v plutil >/dev/null 2>&1; then + fail "plutil not found (required on macOS to read Info.plist)" +fi + +# Convert to JSON for robust parsing. plutil outputs JSON to stdout in this mode. +info_json="$(plutil -convert json -o - "${info_plist}")" + +# Check that CFBundleDocumentTypes exists and that at least one entry references "Document". +# We use Python for JSON parsing; macOS ships with Python 3 on many setups, but not all. +# If python3 isn't available, fall back to a simpler grep-based check. +has_document_icon_ref="false" +if command -v python3 >/dev/null 2>&1; then + has_document_icon_ref="$(python3 -c "import json,sys; d=json.load(sys.stdin); types=d.get('CFBundleDocumentTypes', []); vals=[t.get('CFBundleTypeIconFile') for t in types if isinstance(t, dict)]; print('true' if 'Document' in vals else 'false')" <<<"${info_json}")" +else + # This is a best-effort fallback. It may produce false negatives if the JSON formatting differs. + if echo "${info_json}" | grep -q '"CFBundleTypeIconFile"[[:space:]]*:[[:space:]]*"Document"'; then + has_document_icon_ref="true" + fi +fi + +if [[ "${has_document_icon_ref}" != "true" ]]; then + echo "Verification failed for: ${app_path}" >&2 + echo "Expected Info.plist to reference CFBundleTypeIconFile \"Document\" in CFBundleDocumentTypes." >&2 + echo "Tip: This bundle may be missing DocumentTypes.plist extensions or may have different icon naming." >&2 + exit 1 +fi + +document_icon_path="${app_path}/Contents/Resources/Document.icns" +if [[ ! -f "${document_icon_path}" ]]; then + echo "Verification failed for: ${app_path}" >&2 + echo "Expected document icon to exist: ${document_icon_path}" >&2 + echo "Tip: The bundle script should copy crates/zed/resources/Document.icns into Contents/Resources/Document.icns." >&2 + exit 1 +fi + +echo "OK: ${app_path}" +echo " - Info.plist references CFBundleTypeIconFile \"Document\"" +echo " - Found ${document_icon_path}" From f9b69aeff0f043810b7b98c6242663db76611341 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Wed, 17 Dec 2025 16:44:25 -0600 Subject: [PATCH 156/266] Fix Wayland platform resize resulting in non-interactive window (#45153) Closes #40361 Release Notes: - Linux(Wayland): Fixed an issue where the settings window would not respond to user interaction until resized --- .../gpui/src/platform/linux/wayland/window.rs | 23 +++++++++++++++---- 1 file changed, 18 insertions(+), 5 deletions(-) diff --git a/crates/gpui/src/platform/linux/wayland/window.rs b/crates/gpui/src/platform/linux/wayland/window.rs index 3334ae28a31927b2150e79fc513855fa699c55ba..8cc47c3c139708c3cc278c6146411a4383cc0004 100644 --- a/crates/gpui/src/platform/linux/wayland/window.rs +++ b/crates/gpui/src/platform/linux/wayland/window.rs @@ -1025,13 +1025,26 @@ impl PlatformWindow for WaylandWindow { fn resize(&mut self, size: Size) { let state = self.borrow(); let state_ptr = self.0.clone(); - let dp_size = size.to_device_pixels(self.scale_factor()); + + // Keep window geometry consistent with configure handling. On Wayland, window geometry is + // surface-local: resizing should not attempt to translate the window; the compositor + // controls placement. We also account for client-side decoration insets and tiling. + let window_geometry = inset_by_tiling( + Bounds { + origin: Point::default(), + size, + }, + state.inset(), + state.tiling, + ) + .map(|v| v.0 as i32) + .map_size(|v| if v <= 0 { 1 } else { v }); state.surface_state.set_geometry( - state.bounds.origin.x.0 as i32, - state.bounds.origin.y.0 as i32, - dp_size.width.0, - dp_size.height.0, + window_geometry.origin.x, + window_geometry.origin.y, + window_geometry.size.width, + window_geometry.size.height, ); state From cec46079fea8577c4b7bb6ad1f0e6f9a63bb7f2c Mon Sep 17 00:00:00 2001 From: Mayank Verma Date: Thu, 18 Dec 2025 04:22:10 +0530 Subject: [PATCH 157/266] git_ui: Preserve newlines in commit messages (#45167) Closes #44982 Release Notes: - Fixed Git panel to preserve newlines in commit messages --- crates/git_ui/src/git_panel.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 84c6e9b301d77845f115514eb2a9339fcb813701..4e94a811510ee07707bf729040d41fc8b1eb922c 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -15,6 +15,7 @@ use askpass::AskPassDelegate; use cloud_llm_client::CompletionIntent; use collections::{BTreeMap, HashMap, HashSet}; use db::kvp::KEY_VALUE_STORE; +use editor::RewrapOptions; use editor::{ Direction, Editor, EditorElement, EditorMode, MultiBuffer, MultiBufferOffset, actions::ExpandAllDiffHunks, @@ -2180,7 +2181,13 @@ impl GitPanel { let editor = cx.new(|cx| Editor::for_buffer(buffer, None, window, cx)); let wrapped_message = editor.update(cx, |editor, cx| { editor.select_all(&Default::default(), window, cx); - editor.rewrap(&Default::default(), window, cx); + editor.rewrap_impl( + RewrapOptions { + override_language_settings: false, + preserve_existing_whitespace: true, + }, + cx, + ); editor.text(cx) }); if wrapped_message.trim().is_empty() { From 0c9992c5e9f40bac63b8a11b047b7792b6b23155 Mon Sep 17 00:00:00 2001 From: Kingsword Date: Thu, 18 Dec 2025 07:42:47 +0800 Subject: [PATCH 158/266] terminal: Forward Ctrl+V when clipboard contains images (#42258) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When running Codex CLI, Claude Code, or other TUI agents in Zed’s terminal, pasting images wasn’t supported — Zed treated all clipboard content as plain text and simply pushed it into the PTY, so the agent never saw the image data. This change makes terminal pastes behave like they do in a native terminal: if the clipboard contains an image, Zed now emits a raw Ctrl+V to the PTY so the agent can read the system clipboard itself. Release Notes: - Fixed terminal-launched Codex/Claude sessions by forwarding Ctrl+V for clipboard images so agents can attach them --- crates/terminal_view/src/terminal_view.rs | 28 +++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/crates/terminal_view/src/terminal_view.rs b/crates/terminal_view/src/terminal_view.rs index 54808934ba7b098a695a8b104a048a379966e6f1..e7e60ff4b31dfbdd16b7de8841285d81fc311fc5 100644 --- a/crates/terminal_view/src/terminal_view.rs +++ b/crates/terminal_view/src/terminal_view.rs @@ -8,8 +8,8 @@ mod terminal_slash_command; use assistant_slash_command::SlashCommandRegistry; use editor::{EditorSettings, actions::SelectAll, blink_manager::BlinkManager}; use gpui::{ - Action, AnyElement, App, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, - KeyContext, KeyDownEvent, Keystroke, MouseButton, MouseDownEvent, Pixels, Render, + Action, AnyElement, App, ClipboardEntry, DismissEvent, Entity, EventEmitter, FocusHandle, + Focusable, KeyContext, KeyDownEvent, Keystroke, MouseButton, MouseDownEvent, Pixels, Render, ScrollWheelEvent, Styled, Subscription, Task, WeakEntity, actions, anchored, deferred, div, }; use persistence::TERMINAL_DB; @@ -687,12 +687,32 @@ impl TerminalView { ///Attempt to paste the clipboard into the terminal fn paste(&mut self, _: &Paste, _: &mut Window, cx: &mut Context) { - if let Some(clipboard_string) = cx.read_from_clipboard().and_then(|item| item.text()) { + let Some(clipboard) = cx.read_from_clipboard() else { + return; + }; + + if clipboard.entries().iter().any(|entry| match entry { + ClipboardEntry::Image(image) => !image.bytes.is_empty(), + _ => false, + }) { + self.forward_ctrl_v(cx); + return; + } + + if let Some(text) = clipboard.text() { self.terminal - .update(cx, |terminal, _cx| terminal.paste(&clipboard_string)); + .update(cx, |terminal, _cx| terminal.paste(&text)); } } + /// Emits a raw Ctrl+V so TUI agents can read the OS clipboard directly + /// and attach images using their native workflows. + fn forward_ctrl_v(&self, cx: &mut Context) { + self.terminal.update(cx, |term, _| { + term.input(vec![0x16]); + }); + } + fn send_text(&mut self, text: &SendText, _: &mut Window, cx: &mut Context) { self.clear_bell(cx); self.terminal.update(cx, |term, _| { From aff93f2f6c10e10d460197e9ac1f4e7d3a841e66 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 17 Dec 2025 17:05:35 -0700 Subject: [PATCH 159/266] More permissions for autofix (#45170) Release Notes: - N/A --- .github/workflows/release.yml | 17 +++--- .github/workflows/release_nightly.yml | 3 +- .github/workflows/run_tests.yml | 41 ++++++++----- .../xtask/src/tasks/workflows/run_tests.rs | 58 +++++++++++++++++-- tooling/xtask/src/tasks/workflows/steps.rs | 16 ++--- 5 files changed, 92 insertions(+), 43 deletions(-) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 8cc63340902fb061c66e5896308f2cad9c31f947..5b2ecf70294ad383944205b300f0d9d1e137b2f6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -26,7 +26,8 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - name: steps::clear_target_dir_if_large @@ -71,15 +72,10 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - - name: steps::trigger_autofix - if: failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' - run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=true - shell: bash -euxo pipefail {0} - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large @@ -93,6 +89,8 @@ jobs: run: | rm -rf ./../.cargo shell: bash -euxo pipefail {0} + outputs: + clippy_failed: ${{ steps.clippy.outcome == 'failure' }} timeout-minutes: 60 run_tests_windows: if: (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions') @@ -111,7 +109,8 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy.ps1 shell: pwsh - name: steps::clear_target_dir_if_large diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml index d76244175accc3e816cbd7d5dc322d2529a0a236..906420ad9b15d50578be7d682c6086cc64c9f6e1 100644 --- a/.github/workflows/release_nightly.yml +++ b/.github/workflows/release_nightly.yml @@ -44,7 +44,8 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy.ps1 shell: pwsh - name: steps::clear_target_dir_if_large diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index a9a46b7a797faae793c87601d306a2aea80e6592..d18341b4e09a4a48b61d29609a091570b359c30f 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -80,12 +80,6 @@ jobs: - name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} - - name: steps::trigger_autofix - if: failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' - run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=false - shell: bash -euxo pipefail {0} - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: ./script/check-todos run: ./script/check-todos shell: bash -euxo pipefail {0} @@ -116,7 +110,8 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy.ps1 shell: pwsh - name: steps::clear_target_dir_if_large @@ -163,15 +158,10 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - - name: steps::trigger_autofix - if: failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' - run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=true - shell: bash -euxo pipefail {0} - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large @@ -185,6 +175,8 @@ jobs: run: | rm -rf ./../.cargo shell: bash -euxo pipefail {0} + outputs: + clippy_failed: ${{ steps.clippy.outcome == 'failure' }} timeout-minutes: 60 run_tests_mac: needs: @@ -205,7 +197,8 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - name: steps::clippy + - id: clippy + name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - name: steps::clear_target_dir_if_large @@ -585,6 +578,24 @@ jobs: exit $EXIT_CODE shell: bash -euxo pipefail {0} + call_autofix: + needs: + - check_style + - run_tests_linux + if: (needs.check_style.result == 'failure' || needs.run_tests_linux.outputs.clippy_failed == 'true') && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' + runs-on: namespace-profile-2x4-ubuntu-2404 + steps: + - id: get-app-token + name: steps::authenticate_as_zippy + uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 + with: + app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} + private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }} + - name: run_tests::call_autofix::dispatch_autofix + run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=${{ needs.run_tests_linux.outputs.clippy_failed == 'true' }} + shell: bash -euxo pipefail {0} + env: + GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} concurrency: group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.ref_name == 'main' && github.sha || 'anysha' }} cancel-in-progress: true diff --git a/tooling/xtask/src/tasks/workflows/run_tests.rs b/tooling/xtask/src/tasks/workflows/run_tests.rs index 13639fd6c4bf33fe090dcb9d5f3cafdf45a36e76..1bc4b72176ad94c30399bc15a1152b20b200606a 100644 --- a/tooling/xtask/src/tasks/workflows/run_tests.rs +++ b/tooling/xtask/src/tasks/workflows/run_tests.rs @@ -45,11 +45,15 @@ pub(crate) fn run_tests() -> Workflow { &should_run_tests, ]); + let check_style = check_style(); + let run_tests_linux = run_platform_tests(Platform::Linux); + let call_autofix = call_autofix(&check_style, &run_tests_linux); + let mut jobs = vec![ orchestrate, - check_style(), + check_style, should_run_tests.guard(run_platform_tests(Platform::Windows)), - should_run_tests.guard(run_platform_tests(Platform::Linux)), + should_run_tests.guard(run_tests_linux), should_run_tests.guard(run_platform_tests(Platform::Mac)), should_run_tests.guard(doctests()), should_run_tests.guard(check_workspace_binaries()), @@ -106,6 +110,7 @@ pub(crate) fn run_tests() -> Workflow { workflow }) .add_job(tests_pass.name, tests_pass.job) + .add_job(call_autofix.name, call_autofix.job) } // Generates a bash script that checks changed files against regex patterns @@ -238,13 +243,44 @@ fn check_style() -> NamedJob { .add_step(steps::setup_pnpm()) .add_step(steps::script("./script/prettier")) .add_step(steps::cargo_fmt()) - .add_step(steps::trigger_autofix(false)) .add_step(steps::script("./script/check-todos")) .add_step(steps::script("./script/check-keymaps")) .add_step(check_for_typos()), ) } +fn call_autofix(check_style: &NamedJob, run_tests_linux: &NamedJob) -> NamedJob { + fn dispatch_autofix(run_tests_linux_name: &str) -> Step { + let clippy_failed_expr = format!( + "needs.{}.outputs.{} == 'true'", + run_tests_linux_name, CLIPPY_FAILED_OUTPUT + ); + named::bash(format!( + "gh workflow run autofix_pr.yml -f pr_number=${{{{ github.event.pull_request.number }}}} -f run_clippy=${{{{ {} }}}}", + clippy_failed_expr + )) + .add_env(("GITHUB_TOKEN", "${{ steps.get-app-token.outputs.token }}")) + } + + let clippy_failed_expr = format!( + "needs.{}.outputs.{} == 'true'", + run_tests_linux.name, CLIPPY_FAILED_OUTPUT + ); + let (authenticate, _token) = steps::authenticate_as_zippy(); + + let job = Job::default() + .runs_on(runners::LINUX_SMALL) + .cond(Expression::new(format!( + "(needs.{}.result == 'failure' || {}) && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]'", + check_style.name, clippy_failed_expr + ))) + .needs(vec![check_style.name.clone(), run_tests_linux.name.clone()]) + .add_step(authenticate) + .add_step(dispatch_autofix(&run_tests_linux.name)); + + named::job(job) +} + fn check_dependencies() -> NamedJob { fn install_cargo_machete() -> Step { named::uses( @@ -305,6 +341,8 @@ fn check_workspace_binaries() -> NamedJob { ) } +pub const CLIPPY_FAILED_OUTPUT: &str = "clippy_failed"; + pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { let runner = match platform { Platform::Windows => runners::WINDOWS_DEFAULT, @@ -327,12 +365,20 @@ pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { .add_step(steps::setup_node()) .add_step(steps::clippy(platform)) .when(platform == Platform::Linux, |job| { - job.add_step(steps::trigger_autofix(true)) - .add_step(steps::cargo_install_nextest()) + job.add_step(steps::cargo_install_nextest()) }) .add_step(steps::clear_target_dir_if_large(platform)) .add_step(steps::cargo_nextest(platform)) - .add_step(steps::cleanup_cargo_config(platform)), + .add_step(steps::cleanup_cargo_config(platform)) + .when(platform == Platform::Linux, |job| { + job.outputs([( + CLIPPY_FAILED_OUTPUT.to_owned(), + format!( + "${{{{ steps.{}.outcome == 'failure' }}}}", + steps::CLIPPY_STEP_ID + ), + )]) + }), } } diff --git a/tooling/xtask/src/tasks/workflows/steps.rs b/tooling/xtask/src/tasks/workflows/steps.rs index 5ff7c0cae3c3740fa89abd84d049f9f76e7d721b..3ef7f8fd975d515b061b4ca2e9a37501bfd66e31 100644 --- a/tooling/xtask/src/tasks/workflows/steps.rs +++ b/tooling/xtask/src/tasks/workflows/steps.rs @@ -101,10 +101,12 @@ pub fn clear_target_dir_if_large(platform: Platform) -> Step { } } +pub const CLIPPY_STEP_ID: &str = "clippy"; + pub fn clippy(platform: Platform) -> Step { match platform { - Platform::Windows => named::pwsh("./script/clippy.ps1"), - _ => named::bash("./script/clippy"), + Platform::Windows => named::pwsh("./script/clippy.ps1").id(CLIPPY_STEP_ID), + _ => named::bash("./script/clippy").id(CLIPPY_STEP_ID), } } @@ -345,16 +347,6 @@ pub fn git_checkout(ref_name: &dyn std::fmt::Display) -> Step { )) } -pub fn trigger_autofix(run_clippy: bool) -> Step { - named::bash(format!( - "gh workflow run autofix_pr.yml -f pr_number=${{{{ github.event.pull_request.number }}}} -f run_clippy={run_clippy}" - )) - .if_condition(Expression::new( - "failure() && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]'", - )) - .add_env(("GITHUB_TOKEN", vars::GITHUB_TOKEN)) -} - pub fn authenticate_as_zippy() -> (Step, StepOutput) { let step = named::uses( "actions", From 843a35a1a9e7d67a1bdff973faa6c75a811934ca Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Wed, 17 Dec 2025 16:25:07 -0800 Subject: [PATCH 160/266] extension api: Make server id types constructible, to ease writing tests (#45174) Currently, extensions cannot have tests that call methods like `label_for_symbol` and `label_for_completion`, because those methods take a `LanguageServerId`, and that type is opaque, and cannot be constructed outside of the `zed_extension_api` crate. This PR makes it possible to construct those types from strings, so that it's more straightforward to write unit tests for these LSP adapter methods. Release Notes: - N/A --- crates/extension_api/src/extension_api.rs | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/crates/extension_api/src/extension_api.rs b/crates/extension_api/src/extension_api.rs index 9418623224289f795fed061acbfc6035a4cc5cdf..acd1cba47b0150b85ddec8baafa8b5f341460a39 100644 --- a/crates/extension_api/src/extension_api.rs +++ b/crates/extension_api/src/extension_api.rs @@ -331,7 +331,6 @@ static mut EXTENSION: Option> = None; pub static ZED_API_VERSION: [u8; 6] = *include_bytes!(concat!(env!("OUT_DIR"), "/version_bytes")); mod wit { - wit_bindgen::generate!({ skip: ["init-extension"], path: "./wit/since_v0.8.0", @@ -524,6 +523,12 @@ impl wit::Guest for Component { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)] pub struct LanguageServerId(String); +impl LanguageServerId { + pub fn new(value: String) -> Self { + Self(value) + } +} + impl AsRef for LanguageServerId { fn as_ref(&self) -> &str { &self.0 @@ -540,6 +545,12 @@ impl fmt::Display for LanguageServerId { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)] pub struct ContextServerId(String); +impl ContextServerId { + pub fn new(value: String) -> Self { + Self(value) + } +} + impl AsRef for ContextServerId { fn as_ref(&self) -> &str { &self.0 From 9073a2666c953a96f02b82b3539c04709726f7ab Mon Sep 17 00:00:00 2001 From: Cole Miller Date: Wed, 17 Dec 2025 19:28:09 -0500 Subject: [PATCH 161/266] Revert "git: Mark entries as pending when staging a files making the staged highlighting more "optimistic"" (#45175) Reverts zed-industries/zed#43434 This caused a regression because the additional pending hunks don't get cleared. --- crates/project/src/git_store.rs | 81 --------------------------------- 1 file changed, 81 deletions(-) diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs index 6eff10ddba1c986ef8c310084b08d2d398b52c5d..85ff38ab67f873d8197729de9577075951676597 100644 --- a/crates/project/src/git_store.rs +++ b/crates/project/src/git_store.rs @@ -1672,59 +1672,6 @@ impl GitStore { } } - fn mark_entries_pending_by_project_paths( - &mut self, - project_paths: &[ProjectPath], - stage: bool, - cx: &mut Context, - ) { - let buffer_store = &self.buffer_store; - - for project_path in project_paths { - let Some(buffer) = buffer_store.read(cx).get_by_path(project_path) else { - continue; - }; - - let buffer_id = buffer.read(cx).remote_id(); - let Some(diff_state) = self.diffs.get(&buffer_id) else { - continue; - }; - - diff_state.update(cx, |diff_state, cx| { - let Some(uncommitted_diff) = diff_state.uncommitted_diff() else { - return; - }; - - let buffer_snapshot = buffer.read(cx).text_snapshot(); - let file_exists = buffer - .read(cx) - .file() - .is_some_and(|file| file.disk_state().exists()); - - let all_hunks: Vec<_> = uncommitted_diff - .read(cx) - .hunks_intersecting_range( - text::Anchor::MIN..text::Anchor::MAX, - &buffer_snapshot, - cx, - ) - .collect(); - - if !all_hunks.is_empty() { - uncommitted_diff.update(cx, |diff, cx| { - diff.stage_or_unstage_hunks( - stage, - &all_hunks, - &buffer_snapshot, - file_exists, - cx, - ); - }); - } - }); - } - } - pub fn git_clone( &self, repo: String, @@ -4253,28 +4200,6 @@ impl Repository { save_futures } - fn mark_entries_pending_for_stage( - &self, - entries: &[RepoPath], - stage: bool, - cx: &mut Context, - ) { - let Some(git_store) = self.git_store() else { - return; - }; - - let mut project_paths = Vec::new(); - for repo_path in entries { - if let Some(project_path) = self.repo_path_to_project_path(repo_path, cx) { - project_paths.push(project_path); - } - } - - git_store.update(cx, move |git_store, cx| { - git_store.mark_entries_pending_by_project_paths(&project_paths, stage, cx); - }); - } - pub fn stage_entries( &mut self, entries: Vec, @@ -4283,9 +4208,6 @@ impl Repository { if entries.is_empty() { return Task::ready(Ok(())); } - - self.mark_entries_pending_for_stage(&entries, true, cx); - let id = self.id; let save_tasks = self.save_buffers(&entries, cx); let paths = entries @@ -4351,9 +4273,6 @@ impl Repository { if entries.is_empty() { return Task::ready(Ok(())); } - - self.mark_entries_pending_for_stage(&entries, false, cx); - let id = self.id; let save_tasks = self.save_buffers(&entries, cx); let paths = entries From 07538ff08e04094ceb04e99221474cf5870f3c2c Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Wed, 17 Dec 2025 18:32:46 -0600 Subject: [PATCH 162/266] Make sweep and mercury API tokens use `cx.global` instead of `OnceLock` (#45176) Closes #ISSUE Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/edit_prediction/src/mercury.rs | 19 ++++++++++++------- crates/edit_prediction/src/sweep_ai.rs | 19 ++++++++++++------- 2 files changed, 24 insertions(+), 14 deletions(-) diff --git a/crates/edit_prediction/src/mercury.rs b/crates/edit_prediction/src/mercury.rs index b47bd2ad0374eba33e7b8db726c2fa13c0519465..8186fc5d8c609468be04c117eabac11c6c015efd 100644 --- a/crates/edit_prediction/src/mercury.rs +++ b/crates/edit_prediction/src/mercury.rs @@ -6,7 +6,7 @@ use crate::{ use anyhow::{Context as _, Result}; use futures::AsyncReadExt as _; use gpui::{ - App, AppContext as _, Entity, SharedString, Task, + App, AppContext as _, Entity, Global, SharedString, Task, http_client::{self, AsyncBody, Method}, }; use language::{OffsetRangeExt as _, ToOffset, ToPoint as _}; @@ -300,14 +300,19 @@ pub const MERCURY_CREDENTIALS_URL: SharedString = SharedString::new_static("https://api.inceptionlabs.ai/v1/edit/completions"); pub const MERCURY_CREDENTIALS_USERNAME: &str = "mercury-api-token"; pub static MERCURY_TOKEN_ENV_VAR: std::sync::LazyLock = env_var!("MERCURY_AI_TOKEN"); -pub static MERCURY_API_KEY: std::sync::OnceLock> = std::sync::OnceLock::new(); + +struct GlobalMercuryApiKey(Entity); + +impl Global for GlobalMercuryApiKey {} pub fn mercury_api_token(cx: &mut App) -> Entity { - MERCURY_API_KEY - .get_or_init(|| { - cx.new(|_| ApiKeyState::new(MERCURY_CREDENTIALS_URL, MERCURY_TOKEN_ENV_VAR.clone())) - }) - .clone() + if let Some(global) = cx.try_global::() { + return global.0.clone(); + } + let entity = + cx.new(|_| ApiKeyState::new(MERCURY_CREDENTIALS_URL, MERCURY_TOKEN_ENV_VAR.clone())); + cx.set_global(GlobalMercuryApiKey(entity.clone())); + entity } pub fn load_mercury_api_token(cx: &mut App) -> Task> { diff --git a/crates/edit_prediction/src/sweep_ai.rs b/crates/edit_prediction/src/sweep_ai.rs index 2ed24cd8ef728383ec800acbb2ab7c7b99f07c06..71f28c9213c3440a9267dab7d5a5416dc219f2f3 100644 --- a/crates/edit_prediction/src/sweep_ai.rs +++ b/crates/edit_prediction/src/sweep_ai.rs @@ -1,7 +1,7 @@ use anyhow::Result; use futures::AsyncReadExt as _; use gpui::{ - App, AppContext as _, Entity, SharedString, Task, + App, AppContext as _, Entity, Global, SharedString, Task, http_client::{self, AsyncBody, Method}, }; use language::{Point, ToOffset as _}; @@ -272,14 +272,19 @@ pub const SWEEP_CREDENTIALS_URL: SharedString = SharedString::new_static("https://autocomplete.sweep.dev"); pub const SWEEP_CREDENTIALS_USERNAME: &str = "sweep-api-token"; pub static SWEEP_AI_TOKEN_ENV_VAR: std::sync::LazyLock = env_var!("SWEEP_AI_TOKEN"); -pub static SWEEP_API_KEY: std::sync::OnceLock> = std::sync::OnceLock::new(); + +struct GlobalSweepApiKey(Entity); + +impl Global for GlobalSweepApiKey {} pub fn sweep_api_token(cx: &mut App) -> Entity { - SWEEP_API_KEY - .get_or_init(|| { - cx.new(|_| ApiKeyState::new(SWEEP_CREDENTIALS_URL, SWEEP_AI_TOKEN_ENV_VAR.clone())) - }) - .clone() + if let Some(global) = cx.try_global::() { + return global.0.clone(); + } + let entity = + cx.new(|_| ApiKeyState::new(SWEEP_CREDENTIALS_URL, SWEEP_AI_TOKEN_ENV_VAR.clone())); + cx.set_global(GlobalSweepApiKey(entity.clone())); + entity } pub fn load_sweep_api_token(cx: &mut App) -> Task> { From 05108c50fd1a25714feff391ad719065dd83a589 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Torstein=20S=C3=B8rnes?= Date: Thu, 18 Dec 2025 01:34:31 +0100 Subject: [PATCH 163/266] agent_ui: Make tool call raw input visible (#45097) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Screenshot 2025-12-17 at 9  28@2x Release Notes: - agent: Made tool calls' raw input visible in the agent UI. --------- Co-authored-by: Danilo Leal --- crates/acp_thread/src/acp_thread.rs | 9 +++++++++ crates/agent_ui/src/acp/thread_view.rs | 27 ++++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/crates/acp_thread/src/acp_thread.rs b/crates/acp_thread/src/acp_thread.rs index 2ec6347fd4aa088d7ae2cc8f5a7b6cef37d3b202..a994cc8e57e4456ec57092b2257269b104af74c7 100644 --- a/crates/acp_thread/src/acp_thread.rs +++ b/crates/acp_thread/src/acp_thread.rs @@ -192,6 +192,7 @@ pub struct ToolCall { pub locations: Vec, pub resolved_locations: Vec>, pub raw_input: Option, + pub raw_input_markdown: Option>, pub raw_output: Option, } @@ -222,6 +223,11 @@ impl ToolCall { } } + let raw_input_markdown = tool_call + .raw_input + .as_ref() + .and_then(|input| markdown_for_raw_output(input, &language_registry, cx)); + let result = Self { id: tool_call.tool_call_id, label: cx @@ -232,6 +238,7 @@ impl ToolCall { resolved_locations: Vec::default(), status, raw_input: tool_call.raw_input, + raw_input_markdown, raw_output: tool_call.raw_output, }; Ok(result) @@ -307,6 +314,7 @@ impl ToolCall { } if let Some(raw_input) = raw_input { + self.raw_input_markdown = markdown_for_raw_output(&raw_input, &language_registry, cx); self.raw_input = Some(raw_input); } @@ -1355,6 +1363,7 @@ impl AcpThread { locations: Vec::new(), resolved_locations: Vec::new(), raw_input: None, + raw_input_markdown: None, raw_output: None, }; self.push_entry(AgentThreadEntry::ToolCall(failed_tool_call), cx); diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 9e9af499727ad8478fa5fc1d46dc3b3bf8e20a71..bf2dfa613871f07a3af25953ec54491d9f353c6f 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -2440,6 +2440,12 @@ impl AcpThreadView { let is_collapsible = !tool_call.content.is_empty() && !needs_confirmation; let is_open = needs_confirmation || self.expanded_tool_calls.contains(&tool_call.id); + let input_output_header = |label: SharedString| { + Label::new(label) + .size(LabelSize::XSmall) + .color(Color::Muted) + .buffer_font(cx) + }; let tool_output_display = if is_open { @@ -2481,7 +2487,25 @@ impl AcpThreadView { | ToolCallStatus::Completed | ToolCallStatus::Failed | ToolCallStatus::Canceled => v_flex() + .mt_1p5() .w_full() + .child( + v_flex() + .ml(rems(0.4)) + .px_3p5() + .pb_1() + .gap_1() + .border_l_1() + .border_color(self.tool_card_border_color(cx)) + .child(input_output_header("Raw Input".into())) + .children(tool_call.raw_input_markdown.clone().map(|input| { + self.render_markdown( + input, + default_markdown_style(false, false, window, cx), + ) + })) + .child(input_output_header("Output:".into())), + ) .children(tool_call.content.iter().enumerate().map( |(content_ix, content)| { div().child(self.render_tool_call_content( @@ -2580,7 +2604,7 @@ impl AcpThreadView { .gap_px() .when(is_collapsible, |this| { this.child( - Disclosure::new(("expand", entry_ix), is_open) + Disclosure::new(("expand-output", entry_ix), is_open) .opened_icon(IconName::ChevronUp) .closed_icon(IconName::ChevronDown) .visible_on_hover(&card_header_id) @@ -2766,7 +2790,6 @@ impl AcpThreadView { let button_id = SharedString::from(format!("tool_output-{:?}", tool_call_id)); v_flex() - .mt_1p5() .gap_2() .when(!card_layout, |this| { this.ml(rems(0.4)) From 77cdef35966549ee61e101af10d33ece3be40d84 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Wed, 17 Dec 2025 18:04:12 -0700 Subject: [PATCH 164/266] Attempt to fix the autofix auto scheduler (#45178) Release Notes: - N/A --- .github/workflows/extension_tests.yml | 3 +- .github/workflows/release.yml | 7 ++++- .github/workflows/release_nightly.yml | 3 +- .github/workflows/run_tests.yml | 22 +++++++++++--- .../xtask/src/tasks/workflows/run_tests.rs | 29 +++++++++++++++---- tooling/xtask/src/tasks/workflows/steps.rs | 29 ++++++++++++++++++- 6 files changed, 79 insertions(+), 14 deletions(-) diff --git a/.github/workflows/extension_tests.yml b/.github/workflows/extension_tests.yml index 9f0917e388c74cffed8f342f7504bc111e6f5147..7a7fff9b97d694c1b02dd426f5d59301fe2be81e 100644 --- a/.github/workflows/extension_tests.yml +++ b/.github/workflows/extension_tests.yml @@ -61,7 +61,8 @@ jobs: uses: namespacelabs/nscloud-cache-action@v1 with: cache: rust - - name: steps::cargo_fmt + - id: cargo_fmt + name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} - name: extension_tests::run_clippy diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 5b2ecf70294ad383944205b300f0d9d1e137b2f6..317d5a8df37a62887ce4ddcdd67c8d77b48d56d6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -76,6 +76,11 @@ jobs: name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} + - id: record_clippy_failure + name: steps::record_clippy_failure + if: always() + run: echo "failed=${{ steps.clippy.outcome == 'failure' }}" >> "$GITHUB_OUTPUT" + shell: bash -euxo pipefail {0} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large @@ -90,7 +95,7 @@ jobs: rm -rf ./../.cargo shell: bash -euxo pipefail {0} outputs: - clippy_failed: ${{ steps.clippy.outcome == 'failure' }} + clippy_failed: ${{ steps.record_clippy_failure.outputs.failed == 'true' }} timeout-minutes: 60 run_tests_windows: if: (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions') diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml index 906420ad9b15d50578be7d682c6086cc64c9f6e1..b23e4b7518a672c0d586ea5ba437db5cf8f94bb6 100644 --- a/.github/workflows/release_nightly.yml +++ b/.github/workflows/release_nightly.yml @@ -20,7 +20,8 @@ jobs: with: clean: false fetch-depth: 0 - - name: steps::cargo_fmt + - id: cargo_fmt + name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} - name: ./script/clippy diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index d18341b4e09a4a48b61d29609a091570b359c30f..fac3221d63a080fa53b7ba1c5b7249e6a405c73c 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -74,12 +74,19 @@ jobs: uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 with: version: '9' - - name: ./script/prettier + - id: prettier + name: steps::prettier run: ./script/prettier shell: bash -euxo pipefail {0} - - name: steps::cargo_fmt + - id: cargo_fmt + name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} + - id: record_style_failure + name: steps::record_style_failure + if: always() + run: echo "failed=${{ steps.prettier.outcome == 'failure' || steps.cargo_fmt.outcome == 'failure' }}" >> "$GITHUB_OUTPUT" + shell: bash -euxo pipefail {0} - name: ./script/check-todos run: ./script/check-todos shell: bash -euxo pipefail {0} @@ -90,6 +97,8 @@ jobs: uses: crate-ci/typos@2d0ce569feab1f8752f1dde43cc2f2aa53236e06 with: config: ./typos.toml + outputs: + style_failed: ${{ steps.record_style_failure.outputs.failed == 'true' }} timeout-minutes: 60 run_tests_windows: needs: @@ -162,6 +171,11 @@ jobs: name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} + - id: record_clippy_failure + name: steps::record_clippy_failure + if: always() + run: echo "failed=${{ steps.clippy.outcome == 'failure' }}" >> "$GITHUB_OUTPUT" + shell: bash -euxo pipefail {0} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large @@ -176,7 +190,7 @@ jobs: rm -rf ./../.cargo shell: bash -euxo pipefail {0} outputs: - clippy_failed: ${{ steps.clippy.outcome == 'failure' }} + clippy_failed: ${{ steps.record_clippy_failure.outputs.failed == 'true' }} timeout-minutes: 60 run_tests_mac: needs: @@ -582,7 +596,7 @@ jobs: needs: - check_style - run_tests_linux - if: (needs.check_style.result == 'failure' || needs.run_tests_linux.outputs.clippy_failed == 'true') && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' + if: always() && (needs.check_style.outputs.style_failed == 'true' || needs.run_tests_linux.outputs.clippy_failed == 'true') && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' runs-on: namespace-profile-2x4-ubuntu-2404 steps: - id: get-app-token diff --git a/tooling/xtask/src/tasks/workflows/run_tests.rs b/tooling/xtask/src/tasks/workflows/run_tests.rs index 1bc4b72176ad94c30399bc15a1152b20b200606a..d0caab82b057f21735b7f828c8917a358dd548b2 100644 --- a/tooling/xtask/src/tasks/workflows/run_tests.rs +++ b/tooling/xtask/src/tasks/workflows/run_tests.rs @@ -226,6 +226,8 @@ pub fn tests_pass(jobs: &[NamedJob]) -> NamedJob { named::job(job) } +pub const STYLE_FAILED_OUTPUT: &str = "style_failed"; + fn check_style() -> NamedJob { fn check_for_typos() -> Step { named::uses( @@ -241,11 +243,19 @@ fn check_style() -> NamedJob { .add_step(steps::checkout_repo()) .add_step(steps::cache_rust_dependencies_namespace()) .add_step(steps::setup_pnpm()) - .add_step(steps::script("./script/prettier")) + .add_step(steps::prettier()) .add_step(steps::cargo_fmt()) + .add_step(steps::record_style_failure()) .add_step(steps::script("./script/check-todos")) .add_step(steps::script("./script/check-keymaps")) - .add_step(check_for_typos()), + .add_step(check_for_typos()) + .outputs([( + STYLE_FAILED_OUTPUT.to_owned(), + format!( + "${{{{ steps.{}.outputs.failed == 'true' }}}}", + steps::RECORD_STYLE_FAILURE_STEP_ID + ), + )]), ) } @@ -262,6 +272,10 @@ fn call_autofix(check_style: &NamedJob, run_tests_linux: &NamedJob) -> NamedJob .add_env(("GITHUB_TOKEN", "${{ steps.get-app-token.outputs.token }}")) } + let style_failed_expr = format!( + "needs.{}.outputs.{} == 'true'", + check_style.name, STYLE_FAILED_OUTPUT + ); let clippy_failed_expr = format!( "needs.{}.outputs.{} == 'true'", run_tests_linux.name, CLIPPY_FAILED_OUTPUT @@ -271,8 +285,8 @@ fn call_autofix(check_style: &NamedJob, run_tests_linux: &NamedJob) -> NamedJob let job = Job::default() .runs_on(runners::LINUX_SMALL) .cond(Expression::new(format!( - "(needs.{}.result == 'failure' || {}) && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]'", - check_style.name, clippy_failed_expr + "always() && ({} || {}) && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]'", + style_failed_expr, clippy_failed_expr ))) .needs(vec![check_style.name.clone(), run_tests_linux.name.clone()]) .add_step(authenticate) @@ -364,6 +378,9 @@ pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { ) .add_step(steps::setup_node()) .add_step(steps::clippy(platform)) + .when(platform == Platform::Linux, |job| { + job.add_step(steps::record_clippy_failure()) + }) .when(platform == Platform::Linux, |job| { job.add_step(steps::cargo_install_nextest()) }) @@ -374,8 +391,8 @@ pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { job.outputs([( CLIPPY_FAILED_OUTPUT.to_owned(), format!( - "${{{{ steps.{}.outcome == 'failure' }}}}", - steps::CLIPPY_STEP_ID + "${{{{ steps.{}.outputs.failed == 'true' }}}}", + steps::RECORD_CLIPPY_FAILURE_STEP_ID ), )]) }), diff --git a/tooling/xtask/src/tasks/workflows/steps.rs b/tooling/xtask/src/tasks/workflows/steps.rs index 3ef7f8fd975d515b061b4ca2e9a37501bfd66e31..eaa51dc35205f51e7fe3a56668ed0679e92999f0 100644 --- a/tooling/xtask/src/tasks/workflows/steps.rs +++ b/tooling/xtask/src/tasks/workflows/steps.rs @@ -54,8 +54,25 @@ pub fn setup_sentry() -> Step { .add_with(("token", vars::SENTRY_AUTH_TOKEN)) } +pub const PRETTIER_STEP_ID: &str = "prettier"; +pub const CARGO_FMT_STEP_ID: &str = "cargo_fmt"; +pub const RECORD_STYLE_FAILURE_STEP_ID: &str = "record_style_failure"; + +pub fn prettier() -> Step { + named::bash("./script/prettier").id(PRETTIER_STEP_ID) +} + pub fn cargo_fmt() -> Step { - named::bash("cargo fmt --all -- --check") + named::bash("cargo fmt --all -- --check").id(CARGO_FMT_STEP_ID) +} + +pub fn record_style_failure() -> Step { + named::bash(format!( + "echo \"failed=${{{{ steps.{}.outcome == 'failure' || steps.{}.outcome == 'failure' }}}}\" >> \"$GITHUB_OUTPUT\"", + PRETTIER_STEP_ID, CARGO_FMT_STEP_ID + )) + .id(RECORD_STYLE_FAILURE_STEP_ID) + .if_condition(Expression::new("always()")) } pub fn cargo_install_nextest() -> Step { @@ -102,6 +119,7 @@ pub fn clear_target_dir_if_large(platform: Platform) -> Step { } pub const CLIPPY_STEP_ID: &str = "clippy"; +pub const RECORD_CLIPPY_FAILURE_STEP_ID: &str = "record_clippy_failure"; pub fn clippy(platform: Platform) -> Step { match platform { @@ -110,6 +128,15 @@ pub fn clippy(platform: Platform) -> Step { } } +pub fn record_clippy_failure() -> Step { + named::bash(format!( + "echo \"failed=${{{{ steps.{}.outcome == 'failure' }}}}\" >> \"$GITHUB_OUTPUT\"", + CLIPPY_STEP_ID + )) + .id(RECORD_CLIPPY_FAILURE_STEP_ID) + .if_condition(Expression::new("always()")) +} + pub fn cache_rust_dependencies_namespace() -> Step { named::uses("namespacelabs", "nscloud-cache-action", "v1").add_with(("cache", "rust")) } From ea37057814d00fefae32e4309c1b0e50d1be4295 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 18 Dec 2025 03:56:12 +0200 Subject: [PATCH 165/266] Restore generic modal closing on mouse click (#45183) Was removed in https://github.com/zed-industries/zed/pull/44887/changes#diff-1de872be76a27a9d574a0b0acec4581797446e60743d23b3e7a5f15088fa7e61 Release Notes: - (Preview only) Fixed certain modals not being dismissed on mouse click outside --- crates/workspace/src/modal_layer.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/workspace/src/modal_layer.rs b/crates/workspace/src/modal_layer.rs index db4d85752835299117dba7fc2aeb1833383a390a..58667e7ffa8ad4fe5a22d293e4fc4aa71015a3bd 100644 --- a/crates/workspace/src/modal_layer.rs +++ b/crates/workspace/src/modal_layer.rs @@ -193,6 +193,12 @@ impl Render for ModalLayer { background.fade_out(0.2); this.bg(background) }) + .on_mouse_down( + MouseButton::Left, + cx.listener(|this, _, window, cx| { + this.hide_modal(window, cx); + }), + ) .child( v_flex() .h(px(0.0)) From 225a2a8a2045abadfa5a5d0eb330afd4244fc93c Mon Sep 17 00:00:00 2001 From: Xiaobo Liu Date: Thu, 18 Dec 2025 10:12:40 +0800 Subject: [PATCH 166/266] google_ai: Refactor token count methods in Google AI (#45184) The change simplifies the `max_token_count` and `max_output_tokens` methods by grouping Gemini models with identical token limits. Release Notes: - N/A --- crates/google_ai/src/google_ai.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/crates/google_ai/src/google_ai.rs b/crates/google_ai/src/google_ai.rs index b6bba48c4b04608b502932787cfcdcd429276b5b..a7d82c584b208cec33075d65a53a74c963ec05b5 100644 --- a/crates/google_ai/src/google_ai.rs +++ b/crates/google_ai/src/google_ai.rs @@ -566,22 +566,22 @@ impl Model { pub fn max_token_count(&self) -> u64 { match self { - Self::Gemini25FlashLite => 1_048_576, - Self::Gemini25Flash => 1_048_576, - Self::Gemini25Pro => 1_048_576, - Self::Gemini3Pro => 1_048_576, - Self::Gemini3Flash => 1_048_576, + Self::Gemini25FlashLite + | Self::Gemini25Flash + | Self::Gemini25Pro + | Self::Gemini3Pro + | Self::Gemini3Flash => 1_048_576, Self::Custom { max_tokens, .. } => *max_tokens, } } pub fn max_output_tokens(&self) -> Option { match self { - Model::Gemini25FlashLite => Some(65_536), - Model::Gemini25Flash => Some(65_536), - Model::Gemini25Pro => Some(65_536), - Model::Gemini3Pro => Some(65_536), - Model::Gemini3Flash => Some(65_536), + Model::Gemini25FlashLite + | Model::Gemini25Flash + | Model::Gemini25Pro + | Model::Gemini3Pro + | Model::Gemini3Flash => Some(65_536), Model::Custom { .. } => None, } } From 184001b33b5ed035d82e52f9de922289e1cd4d61 Mon Sep 17 00:00:00 2001 From: Kunall Banerjee Date: Wed, 17 Dec 2025 21:13:59 -0500 Subject: [PATCH 167/266] docs: Add note about conflicting global macOS shortcut (#45186) This is already noted in our `default-macos.json`, but was never surfaced in our docs for some reason. A user noted their LSP completions were not working because they were not aware of the conflicting global shortcut. Ref: https://github.com/zed-industries/zed/issues/44970#issuecomment-3664118523 Release Notes: - N/A --- docs/src/completions.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/src/completions.md b/docs/src/completions.md index ff96ede7503cd461bbd3d7b4afdedcaa2f36a2e5..7b35ec2d09d91a7ba7dc5ae4b968157e0184227f 100644 --- a/docs/src/completions.md +++ b/docs/src/completions.md @@ -15,6 +15,10 @@ When there is an appropriate language server available, Zed will provide complet You can manually trigger completions with `ctrl-space` or by triggering the `editor::ShowCompletions` action from the command palette. +> Note: Using `ctrl-space` in Zed requires disabling the macOS global shortcut. +> Open **System Settings** > **Keyboard** > **Keyboard Shortcut**s > +> **Input Sources** and uncheck **Select the previous input source**. + For more information, see: - [Configuring Supported Languages](./configuring-languages.md) From 0f7f5401388e0525f2bc6bb666b702edf2dedfe1 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 18 Dec 2025 04:37:26 +0200 Subject: [PATCH 168/266] Always invalidate tree-sitter data on buffer reparse end (#45187) Also do not eagerly invalidate this data on buffer reparse start Closes https://github.com/zed-industries/zed/issues/45182 Release Notes: - Fixed bracket colorization not applied on initial file open --- crates/language/src/buffer.rs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index abf4d9b10a761b9c0247145e8ddb0664127756d2..b40fdfc97347b9ac2bf1fe0862c102aa017b483e 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -1697,9 +1697,6 @@ impl Buffer { /// for the same buffer, we only initiate a new parse if we are not already /// parsing in the background. pub fn reparse(&mut self, cx: &mut Context, may_block: bool) { - if self.text.version() != *self.tree_sitter_data.version() { - self.invalidate_tree_sitter_data(self.text.snapshot()); - } if self.reparse.is_some() { return; } @@ -1801,9 +1798,7 @@ impl Buffer { self.syntax_map.lock().did_parse(syntax_snapshot); self.request_autoindent(cx); self.parse_status.0.send(ParseStatus::Idle).unwrap(); - if self.text.version() != *self.tree_sitter_data.version() { - self.invalidate_tree_sitter_data(self.text.snapshot()); - } + self.invalidate_tree_sitter_data(self.text.snapshot()); cx.emit(BufferEvent::Reparsed); cx.notify(); } From cdc5cc348f2d61fdcef8eb69bdde101d5e041156 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 18 Dec 2025 11:32:35 +0200 Subject: [PATCH 169/266] Return back the eager snapshot update (#45210) Based on https://github.com/zed-industries/zed/pull/45187#discussion_r2630140112 Release Notes: - N/A Co-authored-by: Lukas Wirth --- crates/language/src/buffer.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index b40fdfc97347b9ac2bf1fe0862c102aa017b483e..99e0c8d4ebdad709eea0e9ab6dbdf9d889d54ec5 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -1697,6 +1697,9 @@ impl Buffer { /// for the same buffer, we only initiate a new parse if we are not already /// parsing in the background. pub fn reparse(&mut self, cx: &mut Context, may_block: bool) { + if self.text.version() != *self.tree_sitter_data.version() { + self.invalidate_tree_sitter_data(self.text.snapshot()); + } if self.reparse.is_some() { return; } From df48294caad7dd14600cc0bf27dd1b9e79814539 Mon Sep 17 00:00:00 2001 From: Oleksii Orlenko Date: Thu, 18 Dec 2025 10:48:45 +0100 Subject: [PATCH 170/266] agent_ui: Remove unnecessary Arc allocation (#45172) Follow up to https://github.com/zed-industries/zed/pull/44297. Initial implementation in ce884443f1c38ca8da9edf9fbbb8e7fd579452cb used `Arc` to store the reference to the hash map inside the iterator while keeping the lifetime static. The code was later simplified in 5151b22e2ea37fb457cf4f88b88fe4f315306074 to build the list eagerly but the Arc was forgotten, although it became unnecessary. cc @bennetbo Release Notes: - N/A --- crates/agent_ui/src/acp/model_selector.rs | 30 +++++++++++------------ 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs index cff5334a00472fd6f49abcb17897b4ed3c9f590e..f3c07250de3cefc798b97d9ffad444489d153219 100644 --- a/crates/agent_ui/src/acp/model_selector.rs +++ b/crates/agent_ui/src/acp/model_selector.rs @@ -221,7 +221,7 @@ impl PickerDelegate for AcpModelPickerDelegate { cx: &mut Context>, ) -> Task<()> { let favorites = if self.selector.supports_favorites() { - Arc::new(AgentSettings::get_global(cx).favorite_model_ids()) + AgentSettings::get_global(cx).favorite_model_ids() } else { Default::default() }; @@ -242,7 +242,7 @@ impl PickerDelegate for AcpModelPickerDelegate { this.update_in(cx, |this, window, cx| { this.delegate.filtered_entries = - info_list_to_picker_entries(filtered_models, favorites); + info_list_to_picker_entries(filtered_models, &favorites); // Finds the currently selected model in the list let new_index = this .delegate @@ -406,7 +406,7 @@ impl PickerDelegate for AcpModelPickerDelegate { fn info_list_to_picker_entries( model_list: AgentModelList, - favorites: Arc>, + favorites: &HashSet, ) -> Vec { let mut entries = Vec::new(); @@ -572,13 +572,11 @@ mod tests { } } - fn create_favorites(models: Vec<&str>) -> Arc> { - Arc::new( - models - .into_iter() - .map(|m| ModelId::new(m.to_string())) - .collect(), - ) + fn create_favorites(models: Vec<&str>) -> HashSet { + models + .into_iter() + .map(|m| ModelId::new(m.to_string())) + .collect() } fn get_entry_model_ids(entries: &[AcpModelPickerEntry]) -> Vec<&str> { @@ -609,7 +607,7 @@ mod tests { ]); let favorites = create_favorites(vec!["zed/gemini"]); - let entries = info_list_to_picker_entries(models, favorites); + let entries = info_list_to_picker_entries(models, &favorites); assert!(matches!( entries.first(), @@ -625,7 +623,7 @@ mod tests { let models = create_model_list(vec![("zed", vec!["zed/claude", "zed/gemini"])]); let favorites = create_favorites(vec![]); - let entries = info_list_to_picker_entries(models, favorites); + let entries = info_list_to_picker_entries(models, &favorites); assert!(matches!( entries.first(), @@ -641,7 +639,7 @@ mod tests { ]); let favorites = create_favorites(vec!["zed/claude"]); - let entries = info_list_to_picker_entries(models, favorites); + let entries = info_list_to_picker_entries(models, &favorites); for entry in &entries { if let AcpModelPickerEntry::Model(info, is_favorite) = entry { @@ -662,7 +660,7 @@ mod tests { ]); let favorites = create_favorites(vec!["zed/gemini", "openai/gpt-5"]); - let entries = info_list_to_picker_entries(models, favorites); + let entries = info_list_to_picker_entries(models, &favorites); let model_ids = get_entry_model_ids(&entries); assert_eq!(model_ids[0], "zed/gemini"); @@ -683,7 +681,7 @@ mod tests { let favorites = create_favorites(vec!["zed/claude"]); - let entries = info_list_to_picker_entries(models, favorites); + let entries = info_list_to_picker_entries(models, &favorites); let labels = get_entry_labels(&entries); assert_eq!( @@ -723,7 +721,7 @@ mod tests { ]); let favorites = create_favorites(vec!["zed/gemini"]); - let entries = info_list_to_picker_entries(models, favorites); + let entries = info_list_to_picker_entries(models, &favorites); assert!(matches!( entries.first(), From 4b34adedd25c38432650e7bec547cb86e9a61388 Mon Sep 17 00:00:00 2001 From: Guilherme do Amaral Alves Date: Thu, 18 Dec 2025 06:49:32 -0300 Subject: [PATCH 171/266] Update Mistral models context length to their recommended values (#45194) I noticed some of mistral models context lenghts were outdated, they were updated accordingly to mistral documentation. The following models had their context lenght changed: [mistral-large-latest](https://docs.mistral.ai/models/mistral-large-3-25-12) [magistral-medium-latest](https://docs.mistral.ai/models/magistral-medium-1-2-25-09) [magistral-small-latest](https://docs.mistral.ai/models/magistral-small-1-2-25-09) [devstral-medium-latest](https://docs.mistral.ai/models/devstral-2-25-12) [devstral-small-latest](https://docs.mistral.ai/models/devstral-small-2-25-12) --- crates/mistral/src/mistral.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/crates/mistral/src/mistral.rs b/crates/mistral/src/mistral.rs index eca4743d0442b9ca169ac966f78af0112565fcbc..2fa8a2cedaee01daa1452ade35b20c440055b7fc 100644 --- a/crates/mistral/src/mistral.rs +++ b/crates/mistral/src/mistral.rs @@ -155,15 +155,15 @@ impl Model { pub fn max_token_count(&self) -> u64 { match self { Self::CodestralLatest => 256000, - Self::MistralLargeLatest => 131000, + Self::MistralLargeLatest => 256000, Self::MistralMediumLatest => 128000, Self::MistralSmallLatest => 32000, - Self::MagistralMediumLatest => 40000, - Self::MagistralSmallLatest => 40000, + Self::MagistralMediumLatest => 128000, + Self::MagistralSmallLatest => 128000, Self::OpenMistralNemo => 131000, Self::OpenCodestralMamba => 256000, - Self::DevstralMediumLatest => 128000, - Self::DevstralSmallLatest => 262144, + Self::DevstralMediumLatest => 256000, + Self::DevstralSmallLatest => 256000, Self::Pixtral12BLatest => 128000, Self::PixtralLargeLatest => 128000, Self::Custom { max_tokens, .. } => *max_tokens, From f1ca2f9f3177d32d2b07fd5e62e6a8db28c5ddf9 Mon Sep 17 00:00:00 2001 From: MostlyK <135974627+MostlyKIGuess@users.noreply.github.com> Date: Thu, 18 Dec 2025 15:27:21 +0530 Subject: [PATCH 172/266] workspace: Fix new projects opening with default window size (#45204) Previously, when opening a new project (one that was never opened before), the window bounds restoration logic would fall through to GPUI's default window sizing instead of using the last known window bounds. This change consolidates the window bounds restoration logic so that both empty workspaces and new projects use the stored default window bounds, making the behavior consistent: any new window will use the last resized window's size and position. Closes #45092 Release Notes: - Fixed new files and projects opening with default window size instead of the last used window size. --- crates/workspace/src/workspace.rs | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index b636414250c0463eca019ad30321b19d67680fd3..a412b74600158f83d250da021a9f06b627ea98ac 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -1748,26 +1748,18 @@ impl Workspace { window } else { let window_bounds_override = window_bounds_env_override(); - let is_empty_workspace = project_paths.is_empty(); let (window_bounds, display) = if let Some(bounds) = window_bounds_override { (Some(WindowBounds::Windowed(bounds)), None) - } else if let Some(workspace) = serialized_workspace.as_ref() { + } else if let Some(workspace) = serialized_workspace.as_ref() + && let Some(display) = workspace.display + && let Some(bounds) = workspace.window_bounds.as_ref() + { // Reopening an existing workspace - restore its saved bounds - if let (Some(display), Some(bounds)) = - (workspace.display, workspace.window_bounds.as_ref()) - { - (Some(bounds.0), Some(display)) - } else { - (None, None) - } - } else if is_empty_workspace { - // Empty workspace - try to restore the last known no-project window bounds - if let Some((display, bounds)) = persistence::read_default_window_bounds() { - (Some(bounds), Some(display)) - } else { - (None, None) - } + (Some(bounds.0), Some(display)) + } else if let Some((display, bounds)) = persistence::read_default_window_bounds() { + // New or empty workspace - use the last known window bounds + (Some(bounds), Some(display)) } else { // New window - let GPUI's default_bounds() handle cascading (None, None) From b2a0b78ecebf854babb5d3c554c663aa11873953 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Thu, 18 Dec 2025 11:25:06 +0100 Subject: [PATCH 173/266] acp: Change default for gemini back to managed version (#45218) It seems we unintentionally changed the default behavior of if we use the gemini on the path in #40663 Changing this back so by default we use a managed version of the CLI so we can better control min versions and the like, but still allow people to override if they need to. Release Notes: - N/A --- crates/project/src/agent_server_store.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/project/src/agent_server_store.rs b/crates/project/src/agent_server_store.rs index 287b25935676e2d5a09e92285a6cc94b81e52e13..1443e4d877d4e288fb379a02fee8a351075d8db8 100644 --- a/crates/project/src/agent_server_store.rs +++ b/crates/project/src/agent_server_store.rs @@ -460,7 +460,7 @@ impl AgentServerStore { .gemini .as_ref() .and_then(|settings| settings.ignore_system_version) - .unwrap_or(false), + .unwrap_or(true), }), ); self.external_agents.insert( From 54f360ace17c25044a569fa43dd633933f2fac8e Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 18 Dec 2025 12:42:37 +0200 Subject: [PATCH 174/266] Add a test to ensure we invalidate brackets not only on edits (#45219) Follow-up of https://github.com/zed-industries/zed/pull/45187 Release Notes: - N/A --- crates/editor/src/bracket_colorization.rs | 55 +++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/crates/editor/src/bracket_colorization.rs b/crates/editor/src/bracket_colorization.rs index 4879c5e9ce703227d3c03f4d3373512769b1515c..ee7e785ed30a14bce53bb777b67bdf69a9cecd07 100644 --- a/crates/editor/src/bracket_colorization.rs +++ b/crates/editor/src/bracket_colorization.rs @@ -348,6 +348,61 @@ where ); } + #[gpui::test] + async fn test_bracket_colorization_after_language_swap(cx: &mut gpui::TestAppContext) { + init_test(cx, |language_settings| { + language_settings.defaults.colorize_brackets = Some(true); + }); + + let language_registry = Arc::new(language::LanguageRegistry::test(cx.executor())); + language_registry.add(markdown_lang()); + language_registry.add(rust_lang()); + + let mut cx = EditorTestContext::new(cx).await; + cx.update_buffer(|buffer, cx| { + buffer.set_language_registry(language_registry.clone()); + buffer.set_language(Some(markdown_lang()), cx); + }); + + cx.set_state(indoc! {r#" + fn main() { + let v: Vec = vec![]; + } + "#}); + cx.executor().advance_clock(Duration::from_millis(100)); + cx.executor().run_until_parked(); + + assert_eq!( + r#"fn main«1()1» «1{ + let v: Vec = vec!«2[]2»; +}1» + +1 hsla(207.80, 16.20%, 69.19%, 1.00) +2 hsla(29.00, 54.00%, 65.88%, 1.00) +"#, + &bracket_colors_markup(&mut cx), + "Markdown does not colorize <> brackets" + ); + + cx.update_buffer(|buffer, cx| { + buffer.set_language(Some(rust_lang()), cx); + }); + cx.executor().advance_clock(Duration::from_millis(100)); + cx.executor().run_until_parked(); + + assert_eq!( + r#"fn main«1()1» «1{ + let v: Vec«22» = vec!«2[]2»; +}1» + +1 hsla(207.80, 16.20%, 69.19%, 1.00) +2 hsla(29.00, 54.00%, 65.88%, 1.00) +"#, + &bracket_colors_markup(&mut cx), + "After switching to Rust, <> brackets are now colorized" + ); + } + #[gpui::test] async fn test_bracket_colorization_when_editing(cx: &mut gpui::TestAppContext) { init_test(cx, |language_settings| { From 9a69d89f88d459628dac25d1f016e8096b12fb6b Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Thu, 18 Dec 2025 11:47:36 +0100 Subject: [PATCH 175/266] thread_view: Remove unused acp auth method (#45221) This was from an early iteration and this code path isn't used anymore Release Notes: - N/A --- crates/agent_ui/src/acp/thread_view.rs | 38 -------------------------- 1 file changed, 38 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index bf2dfa613871f07a3af25953ec54491d9f353c6f..6371c31aecb780d72cc89b22308b7cc631883de2 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -1663,44 +1663,6 @@ impl AcpThreadView { }); return; } - } else if method.0.as_ref() == "anthropic-api-key" { - let registry = LanguageModelRegistry::global(cx); - let provider = registry - .read(cx) - .provider(&language_model::ANTHROPIC_PROVIDER_ID) - .unwrap(); - let this = cx.weak_entity(); - let agent = self.agent.clone(); - let connection = connection.clone(); - window.defer(cx, move |window, cx| { - if !provider.is_authenticated(cx) { - Self::handle_auth_required( - this, - AuthRequired { - description: Some("ANTHROPIC_API_KEY must be set".to_owned()), - provider_id: Some(language_model::ANTHROPIC_PROVIDER_ID), - }, - agent, - connection, - window, - cx, - ); - } else { - this.update(cx, |this, cx| { - this.thread_state = Self::initial_state( - agent, - None, - this.workspace.clone(), - this.project.clone(), - true, - window, - cx, - ) - }) - .ok(); - } - }); - return; } else if method.0.as_ref() == "vertex-ai" && std::env::var("GOOGLE_API_KEY").is_err() && (std::env::var("GOOGLE_CLOUD_PROJECT").is_err() From 4f878221333403caac0862560c9df36a680ad14e Mon Sep 17 00:00:00 2001 From: shibang Date: Fri, 19 Dec 2025 00:03:42 +1300 Subject: [PATCH 176/266] gpui: Persist window bounds and display when detaching a workspace session (#45201) Closes #41246 #45092 Release Notes: - N/A **Root Cause**: Empty local workspaces returned `DetachFromSession` from `serialize_workspace_location()`, and the `DetachFromSession` handler only cleared the session_id **without saving window bounds**. **Fix Applied**: Modified the `DetachFromSession` handler to save window bounds via `set_window_open_status()`: ```rust WorkspaceLocation::DetachFromSession => { let window_bounds = SerializedWindowBounds(window.window_bounds()); let display = window.display(cx).and_then(|d| d.uuid().ok()); window.spawn(cx, async move |_| { persistence::DB .set_window_open_status(database_id, window_bounds, display.unwrap_or_default()) .await.log_err(); persistence::DB.set_session_id(database_id, None).await.log_err(); }) } ``` **Recording**: https://github.com/user-attachments/assets/2b6564d4-4e1b-40fe-943b-147296340aa7 --- crates/workspace/src/persistence.rs | 49 +++++++++++++++++++++++++++++ crates/workspace/src/workspace.rs | 24 ++++++++++---- 2 files changed, 67 insertions(+), 6 deletions(-) diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs index cf5bdf2ab0059f10f2fb44e2069c8c0baf24d72b..094d03494e726677dc43235d96fc62c076673bf5 100644 --- a/crates/workspace/src/persistence.rs +++ b/crates/workspace/src/persistence.rs @@ -3296,4 +3296,53 @@ mod tests { assert_eq!(workspace.center_group, new_workspace.center_group); } + + #[gpui::test] + async fn test_empty_workspace_window_bounds() { + zlog::init_test(); + + let db = WorkspaceDb::open_test_db("test_empty_workspace_window_bounds").await; + let id = db.next_id().await.unwrap(); + + // Create a workspace with empty paths (empty workspace) + let empty_paths: &[&str] = &[]; + let display_uuid = Uuid::new_v4(); + let window_bounds = SerializedWindowBounds(WindowBounds::Windowed(Bounds { + origin: point(px(100.0), px(200.0)), + size: size(px(800.0), px(600.0)), + })); + + let workspace = SerializedWorkspace { + id, + paths: PathList::new(empty_paths), + location: SerializedWorkspaceLocation::Local, + center_group: Default::default(), + window_bounds: None, + display: None, + docks: Default::default(), + breakpoints: Default::default(), + centered_layout: false, + session_id: None, + window_id: None, + user_toolchains: Default::default(), + }; + + // Save the workspace (this creates the record with empty paths) + db.save_workspace(workspace.clone()).await; + + // Save window bounds separately (as the actual code does via set_window_open_status) + db.set_window_open_status(id, window_bounds, display_uuid) + .await + .unwrap(); + + // Retrieve it using empty paths + let retrieved = db.workspace_for_roots(empty_paths).unwrap(); + + // Verify window bounds were persisted + assert_eq!(retrieved.id, id); + assert!(retrieved.window_bounds.is_some()); + assert_eq!(retrieved.window_bounds.unwrap().0, window_bounds.0); + assert!(retrieved.display.is_some()); + assert_eq!(retrieved.display.unwrap(), display_uuid); + } } diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs index a412b74600158f83d250da021a9f06b627ea98ac..0c5c9ffa5d0bfb1f70ce6a861b0209f321222fc0 100644 --- a/crates/workspace/src/workspace.rs +++ b/crates/workspace/src/workspace.rs @@ -5665,12 +5665,24 @@ impl Workspace { 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::DetachFromSession => { + let window_bounds = SerializedWindowBounds(window.window_bounds()); + let display = window.display(cx).and_then(|d| d.uuid().ok()); + window.spawn(cx, async move |_| { + persistence::DB + .set_window_open_status( + database_id, + window_bounds, + display.unwrap_or_default(), + ) + .await + .log_err(); + persistence::DB + .set_session_id(database_id, None) + .await + .log_err(); + }) + } WorkspaceLocation::None => Task::ready(()), } } From 469da2fd07b6f0f239d6fa4cba9bb3724a3a56b0 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Thu, 18 Dec 2025 12:23:11 +0100 Subject: [PATCH 177/266] gpui: Fix Windows credential lookup returning error instead of `None` when credentials don't exist (#45228) This spams the log with amazon bedrock otherwise Release Notes: - N/A *or* Added/Fixed/Improved ... --- crates/gpui/src/platform/windows/platform.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/gpui/src/platform/windows/platform.rs b/crates/gpui/src/platform/windows/platform.rs index af0cb89ecc94da70cc42c8d4c397aeb2a811d6fb..0e0fdd56c54d56587c09bca14f16dd8e5aef389d 100644 --- a/crates/gpui/src/platform/windows/platform.rs +++ b/crates/gpui/src/platform/windows/platform.rs @@ -659,7 +659,7 @@ impl Platform for WindowsPlatform { if let Err(err) = result { // ERROR_NOT_FOUND means the credential doesn't exist. // Return Ok(None) to match macOS and Linux behavior. - if err.code().0 == ERROR_NOT_FOUND.0 as i32 { + if err.code() == ERROR_NOT_FOUND.to_hresult() { return Ok(None); } return Err(err.into()); From 69fe27f45e123631c6debd36dda28d0ba68f6e0a Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Thu, 18 Dec 2025 13:29:41 +0200 Subject: [PATCH 178/266] Keep tab stop-less snippets in completion list (#45227) Closes https://github.com/zed-industries/zed/issues/45083 cc @agu-z Release Notes: - Fixed certain rust-analyzer snippets not shown --- crates/languages/src/rust.rs | 40 ++++++++++++++++++++++++++++++++++-- 1 file changed, 38 insertions(+), 2 deletions(-) diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs index c10f76b079bf093e71b5444934196940e7b26d6c..80bc48908b0894f251d6631b67cb4a19658454bd 100644 --- a/crates/languages/src/rust.rs +++ b/crates/languages/src/rust.rs @@ -355,7 +355,7 @@ impl LspAdapter for RustLspAdapter { | lsp::CompletionTextEdit::Edit(lsp::TextEdit { new_text, .. }), ) = completion.text_edit.as_ref() && let Ok(mut snippet) = snippet::Snippet::parse(new_text) - && !snippet.tabstops.is_empty() + && snippet.tabstops.len() > 1 { label = String::new(); @@ -421,7 +421,9 @@ impl LspAdapter for RustLspAdapter { 0..label.rfind('(').unwrap_or(completion.label.len()), highlight_id, )); - } else if detail_left.is_none() { + } else if detail_left.is_none() + && kind != Some(lsp::CompletionItemKind::SNIPPET) + { return None; } } @@ -1597,6 +1599,40 @@ mod tests { )) ); + // Postfix completion without actual tabstops (only implicit final $0) + // The label should use completion.label so it can be filtered by "ref" + let ref_completion = adapter + .label_for_completion( + &lsp::CompletionItem { + kind: Some(lsp::CompletionItemKind::SNIPPET), + label: "ref".to_string(), + filter_text: Some("ref".to_string()), + label_details: Some(CompletionItemLabelDetails { + detail: None, + description: Some("&expr".to_string()), + }), + detail: Some("&expr".to_string()), + insert_text_format: Some(lsp::InsertTextFormat::SNIPPET), + text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit { + range: lsp::Range::default(), + new_text: "&String::new()".to_string(), + })), + ..Default::default() + }, + &language, + ) + .await; + assert!( + ref_completion.is_some(), + "ref postfix completion should have a label" + ); + let ref_label = ref_completion.unwrap(); + let filter_text = &ref_label.text[ref_label.filter_range.clone()]; + assert!( + filter_text.contains("ref"), + "filter range text '{filter_text}' should contain 'ref' for filtering to work", + ); + // Test for correct range calculation with mixed empty and non-empty tabstops.(See https://github.com/zed-industries/zed/issues/44825) let res = adapter .label_for_completion( From bb1198e7d60de7510dcd10c400f5ae205835da5c Mon Sep 17 00:00:00 2001 From: Henry Chu Date: Thu, 18 Dec 2025 19:54:34 +0800 Subject: [PATCH 179/266] languages: Allow using locally installed `ty` for Python (#45193) Release Notes: - Allow using locally installed `ty` for Python --- crates/languages/src/python.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs index 77d4be6f49a4928731d39d2154cbe4f0e38024ef..a06b1efe649b93ef56a35c40bd0d35cd1bc7ca9c 100644 --- a/crates/languages/src/python.rs +++ b/crates/languages/src/python.rs @@ -295,6 +295,23 @@ impl LspInstaller for TyLspAdapter { }) } + async fn check_if_user_installed( + &self, + delegate: &dyn LspAdapterDelegate, + _: Option, + _: &AsyncApp, + ) -> Option { + let Some(ty_bin) = delegate.which(Self::SERVER_NAME.as_ref()).await else { + return None; + }; + let env = delegate.shell_env().await; + Some(LanguageServerBinary { + path: ty_bin, + env: Some(env), + arguments: vec!["server".into()], + }) + } + async fn fetch_server_binary( &self, latest_version: Self::BinaryVersion, From 5488a19221aa487d81020fcbb93efcf42b52e6fa Mon Sep 17 00:00:00 2001 From: rabsef-bicrym <52549148+rabsef-bicrym@users.noreply.github.com> Date: Thu, 18 Dec 2025 04:11:14 -0800 Subject: [PATCH 180/266] terminal: Respect RevealStrategy::NoFocus and Never focus settings (#45180) Closes #45179 ## Summary Fixes the focus behavior when creating terminals with `RevealStrategy::NoFocus` or `RevealStrategy::Never`. Previously, terminals would still receive focus if the terminal pane already had focus, contradicting the documented behavior. ## Changes - **`add_terminal_task()`**: Changed focus logic to only focus when `RevealStrategy::Always` - **`add_terminal_shell()`**: Same fix The fix changes: ```rust // Before let focus = pane.has_focus(window, cx) || matches!(reveal_strategy, RevealStrategy::Always); // After let focus = matches!(reveal_strategy, RevealStrategy::Always); ``` ## Impact This affects: - Vim users running `:!command` (uses `NoFocus`) - Debugger terminal spawning (uses `NoFocus`) - Any programmatic terminal creation requesting background behavior Release Notes: - Fixed terminal focus behavior to respect `RevealStrategy::NoFocus` and `RevealStrategy::Never` settings when the terminal pane already has focus. --- crates/terminal_view/src/terminal_panel.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs index 85c6b81f406597e097cabc27408d3df70aad6395..a00e544f97836078ab8d96f2e90d36893cac27ca 100644 --- a/crates/terminal_view/src/terminal_panel.rs +++ b/crates/terminal_view/src/terminal_panel.rs @@ -790,8 +790,7 @@ impl TerminalPanel { } pane.update(cx, |pane, cx| { - let focus = pane.has_focus(window, cx) - || matches!(reveal_strategy, RevealStrategy::Always); + let focus = matches!(reveal_strategy, RevealStrategy::Always); pane.add_item(terminal_view, true, focus, None, window, cx); }); @@ -853,8 +852,7 @@ impl TerminalPanel { } pane.update(cx, |pane, cx| { - let focus = pane.has_focus(window, cx) - || matches!(reveal_strategy, RevealStrategy::Always); + let focus = matches!(reveal_strategy, RevealStrategy::Always); pane.add_item(terminal_view, true, focus, None, window, cx); }); From 0180f3e72ab95cd2be1d96927a67faa616dcd137 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Thu, 18 Dec 2025 13:47:34 +0100 Subject: [PATCH 181/266] deepseek: Fix for max output tokens blocking completions (#45236) They count the requested max_output_tokens against the prompt total. Seems like a bug on their end as most other providers don't do this, but now we just default to None for the main models and let the API use its default behavior which works just fine. Closes: #45134 Release Notes: - deepseek: Fix issue with Deepseek API that was causing the token limit to be reached sooner than necessary --- crates/deepseek/src/deepseek.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/crates/deepseek/src/deepseek.rs b/crates/deepseek/src/deepseek.rs index e978aa08048bfa4c7b7b203ce6b405ba8a0a7d0c..636258a5a132ce79cb5d15b1aaa25d6e4d3af643 100644 --- a/crates/deepseek/src/deepseek.rs +++ b/crates/deepseek/src/deepseek.rs @@ -103,8 +103,9 @@ impl Model { pub fn max_output_tokens(&self) -> Option { match self { - Self::Chat => Some(8_192), - Self::Reasoner => Some(64_000), + // Their API treats this max against the context window, which means we hit the limit a lot + // Using the default value of None in the API instead + Self::Chat | Self::Reasoner => None, Self::Custom { max_output_tokens, .. } => *max_output_tokens, From cebbf77491faa05f04e9939450e718405fdad93a Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Thu, 18 Dec 2025 14:05:20 +0100 Subject: [PATCH 182/266] gpui(windows): Fix clicks to inactive windows not dispatching to the clicked window (#45237) Release Notes: - Fixed an issue on windows where clicking buttons on windows in the background would not register as being clicked on that window --- crates/gpui/src/platform/windows/events.rs | 5 +++++ crates/gpui/src/window.rs | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/gpui/src/platform/windows/events.rs b/crates/gpui/src/platform/windows/events.rs index e6fa6006eb95ec45f1634cb72ef63e2f622455a7..f224a1bf3c47dc1a61c5e0216f5d7825cfc72533 100644 --- a/crates/gpui/src/platform/windows/events.rs +++ b/crates/gpui/src/platform/windows/events.rs @@ -40,6 +40,11 @@ impl WindowsWindowInner { lparam: LPARAM, ) -> LRESULT { let handled = match msg { + // eagerly activate the window, so calls to `active_window` will work correctly + WM_MOUSEACTIVATE => { + unsafe { SetActiveWindow(handle).log_err() }; + None + } WM_ACTIVATE => self.handle_activate_msg(wparam), WM_CREATE => self.handle_create_msg(handle), WM_MOVE => self.handle_move_msg(handle, lparam), diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs index 840f2223fcc4a62b6e522f38b967a3fe4ad3209e..2ccd7edac86bced89048cbe5dbf196d8fbcf95f3 100644 --- a/crates/gpui/src/window.rs +++ b/crates/gpui/src/window.rs @@ -4966,7 +4966,7 @@ impl From> for AnyWindowHandle { } /// A handle to a window with any root view type, which can be downcast to a window with a specific root view type. -#[derive(Copy, Clone, PartialEq, Eq, Hash)] +#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] pub struct AnyWindowHandle { pub(crate) id: WindowId, state_type: TypeId, From abb199c85e466222b00d476b8a837fa4c3b3bee1 Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Thu, 18 Dec 2025 15:03:11 +0100 Subject: [PATCH 183/266] thread_view: Clearer authentication states (#45230) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes #44717 Sometimes, we show the user the agent's auth methods because we got an AuthRequired error. However, there are also several ways a user can choose to re-enter the authentication flow even though they are still logged in. This has caused some confusion with several users, where after logging in, they type /login again to see if anything changed, and they saw an "Authentication Required" warning. So, I made a distinction in the UI if we go to this flow from a concrete error, or if not, made the language less error-like to help avoid confusion. | Before | After | |--------|--------| | Screenshot 2025-12-18 at 10  54@2x | Screenshot 2025-12-18 at 10  53@2x | Release Notes: - N/A --------- Co-authored-by: Danilo Leal Co-authored-by: Miguel Raz Guzmán Macedo --- crates/agent_ui/src/acp/thread_view.rs | 277 ++++++++++++------------- crates/ui/src/components/callout.rs | 2 +- 2 files changed, 130 insertions(+), 149 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 6371c31aecb780d72cc89b22308b7cc631883de2..fe6a3a3087066946a2973067d4439b63de60bdf0 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -34,7 +34,7 @@ use language::Buffer; use language_model::LanguageModelRegistry; use markdown::{HeadingLevelStyles, Markdown, MarkdownElement, MarkdownStyle}; -use project::{Project, ProjectEntryId}; +use project::{AgentServerStore, ExternalAgentServerName, Project, ProjectEntryId}; use prompt_store::{PromptId, PromptStore}; use rope::Point; use settings::{NotifyWhenAgentWaiting, Settings as _, SettingsStore}; @@ -260,6 +260,7 @@ impl ThreadFeedbackState { pub struct AcpThreadView { agent: Rc, + agent_server_store: Entity, workspace: WeakEntity, project: Entity, thread_state: ThreadState, @@ -406,6 +407,7 @@ impl AcpThreadView { Self { agent: agent.clone(), + agent_server_store, workspace: workspace.clone(), project: project.clone(), entry_view_state, @@ -737,7 +739,7 @@ impl AcpThreadView { cx: &mut App, ) { let agent_name = agent.name(); - let (configuration_view, subscription) = if let Some(provider_id) = err.provider_id { + let (configuration_view, subscription) = if let Some(provider_id) = &err.provider_id { let registry = LanguageModelRegistry::global(cx); let sub = window.subscribe(®istry, cx, { @@ -779,7 +781,6 @@ impl AcpThreadView { configuration_view, description: err .description - .clone() .map(|desc| cx.new(|cx| Markdown::new(desc.into(), None, None, cx))), _subscription: subscription, }; @@ -1088,10 +1089,7 @@ impl AcpThreadView { window.defer(cx, |window, cx| { Self::handle_auth_required( this, - AuthRequired { - description: None, - provider_id: None, - }, + AuthRequired::new(), agent, connection, window, @@ -3485,138 +3483,119 @@ impl AcpThreadView { pending_auth_method: Option<&acp::AuthMethodId>, window: &mut Window, cx: &Context, - ) -> Div { - let show_description = - configuration_view.is_none() && description.is_none() && pending_auth_method.is_none(); - + ) -> impl IntoElement { let auth_methods = connection.auth_methods(); - v_flex().flex_1().size_full().justify_end().child( - v_flex() - .p_2() - .pr_3() - .w_full() - .gap_1() - .border_t_1() - .border_color(cx.theme().colors().border) - .bg(cx.theme().status().warning.opacity(0.04)) - .child( - h_flex() - .gap_1p5() - .child( - Icon::new(IconName::Warning) - .color(Color::Warning) - .size(IconSize::Small), - ) - .child(Label::new("Authentication Required").size(LabelSize::Small)), - ) - .children(description.map(|desc| { - div().text_ui(cx).child(self.render_markdown( - desc.clone(), - default_markdown_style(false, false, window, cx), - )) - })) - .children( - configuration_view - .cloned() - .map(|view| div().w_full().child(view)), - ) - .when(show_description, |el| { - el.child( - Label::new(format!( - "You are not currently authenticated with {}.{}", - self.agent.name(), - if auth_methods.len() > 1 { - " Please choose one of the following options:" - } else { - "" - } - )) - .size(LabelSize::Small) - .color(Color::Muted) - .mb_1() - .ml_5(), - ) - }) - .when_some(pending_auth_method, |el, _| { - el.child( - h_flex() - .py_4() - .w_full() - .justify_center() - .gap_1() - .child( - Icon::new(IconName::ArrowCircle) - .size(IconSize::Small) - .color(Color::Muted) - .with_rotate_animation(2), - ) - .child(Label::new("Authenticating…").size(LabelSize::Small)), - ) - }) - .when(!auth_methods.is_empty(), |this| { - this.child( - h_flex() - .justify_end() - .flex_wrap() - .gap_1() - .when(!show_description, |this| { - this.border_t_1() - .mt_1() - .pt_2() - .border_color(cx.theme().colors().border.opacity(0.8)) + let agent_display_name = self + .agent_server_store + .read(cx) + .agent_display_name(&ExternalAgentServerName(self.agent.name())) + .unwrap_or_else(|| self.agent.name()); + + let show_fallback_description = auth_methods.len() > 1 + && configuration_view.is_none() + && description.is_none() + && pending_auth_method.is_none(); + + let auth_buttons = || { + h_flex().justify_end().flex_wrap().gap_1().children( + connection + .auth_methods() + .iter() + .enumerate() + .rev() + .map(|(ix, method)| { + let (method_id, name) = if self.project.read(cx).is_via_remote_server() + && method.id.0.as_ref() == "oauth-personal" + && method.name == "Log in with Google" + { + ("spawn-gemini-cli".into(), "Log in with Gemini CLI".into()) + } else { + (method.id.0.clone(), method.name.clone()) + }; + + let agent_telemetry_id = connection.telemetry_id(); + + Button::new(method_id.clone(), name) + .label_size(LabelSize::Small) + .map(|this| { + if ix == 0 { + this.style(ButtonStyle::Tinted(TintColor::Accent)) + } else { + this.style(ButtonStyle::Outlined) + } }) - .children(connection.auth_methods().iter().enumerate().rev().map( - |(ix, method)| { - let (method_id, name) = if self - .project - .read(cx) - .is_via_remote_server() - && method.id.0.as_ref() == "oauth-personal" - && method.name == "Log in with Google" - { - ("spawn-gemini-cli".into(), "Log in with Gemini CLI".into()) - } else { - (method.id.0.clone(), method.name.clone()) - }; + .when_some(method.description.clone(), |this, description| { + this.tooltip(Tooltip::text(description)) + }) + .on_click({ + cx.listener(move |this, _, window, cx| { + telemetry::event!( + "Authenticate Agent Started", + agent = agent_telemetry_id, + method = method_id + ); - let agent_telemetry_id = connection.telemetry_id(); + this.authenticate( + acp::AuthMethodId::new(method_id.clone()), + window, + cx, + ) + }) + }) + }), + ) + }; - Button::new(method_id.clone(), name) - .label_size(LabelSize::Small) - .map(|this| { - if ix == 0 { - this.style(ButtonStyle::Tinted(TintColor::Warning)) - } else { - this.style(ButtonStyle::Outlined) - } - }) - .when_some( - method.description.clone(), - |this, description| { - this.tooltip(Tooltip::text(description)) - }, - ) - .on_click({ - cx.listener(move |this, _, window, cx| { - telemetry::event!( - "Authenticate Agent Started", - agent = agent_telemetry_id, - method = method_id - ); - - this.authenticate( - acp::AuthMethodId::new(method_id.clone()), - window, - cx, - ) - }) - }) - }, - )), - ) - }), - ) + if pending_auth_method.is_some() { + return Callout::new() + .icon(IconName::Info) + .title(format!("Authenticating to {}…", agent_display_name)) + .actions_slot( + Icon::new(IconName::ArrowCircle) + .size(IconSize::Small) + .color(Color::Muted) + .with_rotate_animation(2) + .into_any_element(), + ) + .into_any_element(); + } + + Callout::new() + .icon(IconName::Info) + .title(format!("Authenticate to {}", agent_display_name)) + .when(auth_methods.len() == 1, |this| { + this.actions_slot(auth_buttons()) + }) + .description_slot( + v_flex() + .text_ui(cx) + .map(|this| { + if show_fallback_description { + this.child( + Label::new("Choose one of the following authentication options:") + .size(LabelSize::Small) + .color(Color::Muted), + ) + } else { + this.children( + configuration_view + .cloned() + .map(|view| div().w_full().child(view)), + ) + .children(description.map(|desc| { + self.render_markdown( + desc.clone(), + default_markdown_style(false, false, window, cx), + ) + })) + } + }) + .when(auth_methods.len() > 1, |this| { + this.gap_1().child(auth_buttons()) + }), + ) + .into_any_element() } fn render_load_error( @@ -5865,10 +5844,6 @@ impl AcpThreadView { }; let connection = thread.read(cx).connection().clone(); - let err = AuthRequired { - description: None, - provider_id: None, - }; this.clear_thread_error(cx); if let Some(message) = this.in_flight_prompt.take() { this.message_editor.update(cx, |editor, cx| { @@ -5877,7 +5852,14 @@ impl AcpThreadView { } let this = cx.weak_entity(); window.defer(cx, |window, cx| { - Self::handle_auth_required(this, err, agent, connection, window, cx); + Self::handle_auth_required( + this, + AuthRequired::new(), + agent, + connection, + window, + cx, + ); }) } })) @@ -5890,14 +5872,10 @@ impl AcpThreadView { }; let connection = thread.read(cx).connection().clone(); - let err = AuthRequired { - description: None, - provider_id: None, - }; self.clear_thread_error(cx); let this = cx.weak_entity(); window.defer(cx, |window, cx| { - Self::handle_auth_required(this, err, agent, connection, window, cx); + Self::handle_auth_required(this, AuthRequired::new(), agent, connection, window, cx); }) } @@ -6000,16 +5978,19 @@ impl Render for AcpThreadView { configuration_view, pending_auth_method, .. - } => self - .render_auth_required_state( + } => v_flex() + .flex_1() + .size_full() + .justify_end() + .child(self.render_auth_required_state( connection, description.as_ref(), configuration_view.as_ref(), pending_auth_method.as_ref(), window, cx, - ) - .into_any(), + )) + .into_any_element(), ThreadState::Loading { .. } => v_flex() .flex_1() .child(self.render_recent_history(cx)) diff --git a/crates/ui/src/components/callout.rs b/crates/ui/src/components/callout.rs index 4eb849d7f640aca78b70645f5f93301281ca6627..de95e5db2bcee2e7acbadf5570de09d9cdedbf4d 100644 --- a/crates/ui/src/components/callout.rs +++ b/crates/ui/src/components/callout.rs @@ -121,7 +121,7 @@ impl RenderOnce for Callout { Severity::Info => ( IconName::Info, Color::Muted, - cx.theme().colors().panel_background.opacity(0.), + cx.theme().status().info_background.opacity(0.1), ), Severity::Success => ( IconName::Check, From 61dd6a8f318556d1e84963ff186ca63e582f9ff7 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 18 Dec 2025 11:34:10 -0300 Subject: [PATCH 184/266] agent_ui: Add some fixes to tool calling display (#45252) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Follow up to https://github.com/zed-industries/zed/pull/45097 — not showing raw inputs for edit and terminal calls - Removing the display of empty Markdown if the model outputs it Release Notes: - N/A --------- Co-authored-by: Agus Zubiaga Co-authored-by: Ben Brandt --- crates/agent_ui/src/acp/thread_view.rs | 123 +++++++++++++++---------- 1 file changed, 72 insertions(+), 51 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index fe6a3a3087066946a2973067d4439b63de60bdf0..ed61141b0ab824b81731953db7b5a32b90d0539b 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -2113,6 +2113,7 @@ impl AcpThreadView { chunks, indented: _, }) => { + let mut is_blank = true; let is_last = entry_ix + 1 == total_entries; let style = default_markdown_style(false, false, window, cx); @@ -2122,36 +2123,55 @@ impl AcpThreadView { .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() + block.markdown().and_then(|md| { + let this_is_blank = md.read(cx).source().trim().is_empty(); + is_blank = is_blank && this_is_blank; + if this_is_blank { + return None; + } + + Some( + self.render_markdown(md.clone(), style.clone()) + .into_any_element(), + ) }) } AssistantMessageChunk::Thought { block } => { - block.markdown().map(|md| { - self.render_thinking_block( - entry_ix, - chunk_ix, - md.clone(), - window, - cx, + block.markdown().and_then(|md| { + let this_is_blank = md.read(cx).source().trim().is_empty(); + is_blank = is_blank && this_is_blank; + if this_is_blank { + return None; + } + + Some( + self.render_thinking_block( + entry_ix, + chunk_ix, + md.clone(), + window, + cx, + ) + .into_any_element(), ) - .into_any_element() }) } }, )) .into_any(); - v_flex() - .px_5() - .py_1p5() - .when(is_first_indented, |this| this.pt_0p5()) - .when(is_last, |this| this.pb_4()) - .w_full() - .text_ui(cx) - .child(message_body) - .into_any() + if is_blank { + Empty.into_any() + } else { + v_flex() + .px_5() + .py_1p5() + .when(is_last, |this| this.pb_4()) + .w_full() + .text_ui(cx) + .child(message_body) + .into_any() + } } AgentThreadEntry::ToolCall(tool_call) => { let has_terminals = tool_call.terminals().next().is_some(); @@ -2183,7 +2203,7 @@ impl AcpThreadView { div() .relative() .w_full() - .pl(rems_from_px(20.0)) + .pl_5() .bg(cx.theme().colors().panel_background.opacity(0.2)) .child( div() @@ -2447,25 +2467,25 @@ impl AcpThreadView { | ToolCallStatus::Completed | ToolCallStatus::Failed | ToolCallStatus::Canceled => v_flex() - .mt_1p5() - .w_full() - .child( - v_flex() - .ml(rems(0.4)) - .px_3p5() - .pb_1() - .gap_1() - .border_l_1() - .border_color(self.tool_card_border_color(cx)) - .child(input_output_header("Raw Input".into())) - .children(tool_call.raw_input_markdown.clone().map(|input| { - self.render_markdown( - input, - default_markdown_style(false, false, window, cx), - ) - })) - .child(input_output_header("Output:".into())), - ) + .when(!is_edit && !is_terminal_tool, |this| { + this.mt_1p5().w_full().child( + v_flex() + .ml(rems(0.4)) + .px_3p5() + .pb_1() + .gap_1() + .border_l_1() + .border_color(self.tool_card_border_color(cx)) + .child(input_output_header("Raw Input:".into())) + .children(tool_call.raw_input_markdown.clone().map(|input| { + self.render_markdown( + input, + default_markdown_style(false, false, window, cx), + ) + })) + .child(input_output_header("Output:".into())), + ) + }) .children(tool_call.content.iter().enumerate().map( |(content_ix, content)| { div().child(self.render_tool_call_content( @@ -2751,18 +2771,19 @@ impl AcpThreadView { v_flex() .gap_2() - .when(!card_layout, |this| { - this.ml(rems(0.4)) - .px_3p5() - .border_l_1() - .border_color(self.tool_card_border_color(cx)) - }) - .when(card_layout, |this| { - this.px_2().pb_2().when(context_ix > 0, |this| { - this.border_t_1() - .pt_2() + .map(|this| { + if card_layout { + this.when(context_ix > 0, |this| { + this.pt_2() + .border_t_1() + .border_color(self.tool_card_border_color(cx)) + }) + } else { + this.ml(rems(0.4)) + .px_3p5() + .border_l_1() .border_color(self.tool_card_border_color(cx)) - }) + } }) .text_xs() .text_color(cx.theme().colors().text_muted) From f9462da2f7cdd0bfdb0feb95ae983fe695bb0a86 Mon Sep 17 00:00:00 2001 From: "Ahmed M. Ammar" Date: Thu, 18 Dec 2025 16:34:33 +0200 Subject: [PATCH 185/266] terminal: Fix pane re-entrancy panic when splitting terminal tabs (#45231) ## Summary Fix panic "cannot update workspace::pane::Pane while it is already being updated" when dragging terminal tabs to split the pane. ## Problem When dragging a terminal tab to create a split, the app panics due to re-entrancy: the drop handler calls `terminal_panel.center.split()` synchronously, which invokes `mark_positions()` that tries to update all panes in the group. When the pane being updated is part of the terminal panel's center group, this causes a re-entrancy panic. ## Solution Defer the split operation using `cx.spawn_in()`, similar to how `move_item` was already deferred in the same handler. This ensures the split (and subsequent `mark_positions()` call) runs after the current pane update completes. ## Test plan - Open terminal panel - Create a terminal tab - Drag the terminal tab to split the pane - Verify no panic occurs and split works correctly --- crates/terminal_view/src/terminal_panel.rs | 109 +++++++++++---------- 1 file changed, 56 insertions(+), 53 deletions(-) diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs index a00e544f97836078ab8d96f2e90d36893cac27ca..ed43d94e9d3d7c08c1ff4570e08726310360cd93 100644 --- a/crates/terminal_view/src/terminal_panel.rs +++ b/crates/terminal_view/src/terminal_panel.rs @@ -1169,64 +1169,67 @@ pub fn new_terminal_pane( let source = tab.pane.clone(); let item_id_to_move = item.item_id(); - let Ok(new_split_pane) = pane - .drag_split_direction() - .map(|split_direction| { - drop_closure_terminal_panel.update(cx, |terminal_panel, cx| { - let is_zoomed = if terminal_panel.active_pane == this_pane { - pane.is_zoomed() - } else { - terminal_panel.active_pane.read(cx).is_zoomed() - }; - let new_pane = new_terminal_pane( - workspace.clone(), - project.clone(), - is_zoomed, - window, - cx, - ); - terminal_panel.apply_tab_bar_buttons(&new_pane, cx); - terminal_panel.center.split( - &this_pane, - &new_pane, - split_direction, - cx, - )?; - anyhow::Ok(new_pane) - }) - }) - .transpose() - else { - return ControlFlow::Break(()); + // If no split direction, let the regular pane drop handler take care of it + let Some(split_direction) = pane.drag_split_direction() else { + return ControlFlow::Continue(()); }; - match new_split_pane.transpose() { - // Source pane may be the one currently updated, so defer the move. - Ok(Some(new_pane)) => cx - .spawn_in(window, async move |_, cx| { - cx.update(|window, cx| { - move_item( - &source, + // Gather data synchronously before deferring + let is_zoomed = drop_closure_terminal_panel + .upgrade() + .map(|terminal_panel| { + let terminal_panel = terminal_panel.read(cx); + if terminal_panel.active_pane == this_pane { + pane.is_zoomed() + } else { + terminal_panel.active_pane.read(cx).is_zoomed() + } + }) + .unwrap_or(false); + + let workspace = workspace.clone(); + let terminal_panel = drop_closure_terminal_panel.clone(); + + // Defer the split operation to avoid re-entrancy panic. + // The pane may be the one currently being updated, so we cannot + // call mark_positions (via split) synchronously. + cx.spawn_in(window, async move |_, cx| { + cx.update(|window, cx| { + let Ok(new_pane) = + terminal_panel.update(cx, |terminal_panel, cx| { + let new_pane = new_terminal_pane( + workspace, project, is_zoomed, window, cx, + ); + terminal_panel.apply_tab_bar_buttons(&new_pane, cx); + terminal_panel.center.split( + &this_pane, &new_pane, - item_id_to_move, - new_pane.read(cx).active_item_index(), - true, - window, + split_direction, cx, - ); + )?; + anyhow::Ok(new_pane) }) - .ok(); - }) - .detach(), - // If we drop into existing pane or current pane, - // regular pane drop handler will take care of it, - // using the right tab index for the operation. - Ok(None) => return ControlFlow::Continue(()), - err @ Err(_) => { - err.log_err(); - return ControlFlow::Break(()); - } - }; + else { + return; + }; + + let Some(new_pane) = new_pane.log_err() else { + return; + }; + + move_item( + &source, + &new_pane, + item_id_to_move, + new_pane.read(cx).active_item_index(), + true, + window, + cx, + ); + }) + .ok(); + }) + .detach(); } else if let Some(project_path) = item.project_path(cx) && let Some(entry_path) = project.read(cx).absolute_path(&project_path, cx) { From 7a783a91cccba2a74061c07c25001ca621db81cf Mon Sep 17 00:00:00 2001 From: Ben Brandt Date: Thu, 18 Dec 2025 16:01:20 +0100 Subject: [PATCH 186/266] acp: Update to agent-client-protocol rust sdk v0.9.2 (#45255) Release Notes: - N/A --- Cargo.lock | 8 ++++---- Cargo.toml | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 86b551b1895a0fd6747c35c3fcfe3859396665fa..7364a68b2a68fe44a42d24443dd723aa3c87e135 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -226,9 +226,9 @@ dependencies = [ [[package]] name = "agent-client-protocol" -version = "0.9.0" +version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2ffe7d502c1e451aafc5aff655000f84d09c9af681354ac0012527009b1af13" +checksum = "d3e527d7dfe0f334313d42d1d9318f0a79665f6f21c440d0798f230a77a7ed6c" dependencies = [ "agent-client-protocol-schema", "anyhow", @@ -243,9 +243,9 @@ dependencies = [ [[package]] name = "agent-client-protocol-schema" -version = "0.10.0" +version = "0.10.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8af81cc2d5c3f9c04f73db452efd058333735ba9d51c2cf7ef33c9fee038e7e6" +checksum = "6903a00e8ac822f9bacac59a1932754d7387c72ebb7c9c7439ad021505591da4" dependencies = [ "anyhow", "derive_more 2.0.1", diff --git a/Cargo.toml b/Cargo.toml index 703a34b63af901886e861dba3177e58b19c223f0..825dc79e08978d8ccd03cea93883f698986ee12f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -438,7 +438,7 @@ ztracing_macro = { path = "crates/ztracing_macro" } # External crates # -agent-client-protocol = { version = "=0.9.0", features = ["unstable"] } +agent-client-protocol = { version = "=0.9.2", features = ["unstable"] } aho-corasick = "1.1" alacritty_terminal = "0.25.1-rc1" any_vec = "0.14" From 886de8f54bb8fae99a7c6215802d1714c30d4bb7 Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Thu, 18 Dec 2025 16:38:47 +0100 Subject: [PATCH 187/266] agent_ui: Improve UX when pasting code into message editor (#45254) Follow up to #42982 Release Notes: - agent: Allow pasting code without formatting via ctrl/cmd-shift-v. - agent: Fixed an issue where pasting a single line of code would always insert an @mention --- assets/keymaps/default-linux.json | 3 + assets/keymaps/default-macos.json | 3 + assets/keymaps/default-windows.json | 3 + crates/agent_ui/src/acp/message_editor.rs | 243 +++++++++++----------- crates/agent_ui/src/text_thread_editor.rs | 171 ++++++++------- crates/zed_actions/src/lib.rs | 2 + 6 files changed, 234 insertions(+), 191 deletions(-) diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json index ec21bc152edf969f57ac341e4b92f78c9e5da11a..465c7d86aeaff23bdebe65792304ac2963edaaa7 100644 --- a/assets/keymaps/default-linux.json +++ b/assets/keymaps/default-linux.json @@ -227,6 +227,7 @@ "ctrl-g": "search::SelectNextMatch", "ctrl-shift-g": "search::SelectPreviousMatch", "ctrl-k l": "agent::OpenRulesLibrary", + "ctrl-shift-v": "agent::PasteRaw", }, }, { @@ -293,6 +294,7 @@ "shift-ctrl-r": "agent::OpenAgentDiff", "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", + "ctrl-shift-v": "agent::PasteRaw", }, }, { @@ -304,6 +306,7 @@ "shift-ctrl-r": "agent::OpenAgentDiff", "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", + "ctrl-shift-v": "agent::PasteRaw", }, }, { diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json index fd2605a6ad99177c887d6f804ec2ac70724f16f8..7ff00c41d5d6108b2a0b9fa0de85c511fab1f6e0 100644 --- a/assets/keymaps/default-macos.json +++ b/assets/keymaps/default-macos.json @@ -267,6 +267,7 @@ "cmd-shift-g": "search::SelectPreviousMatch", "cmd-k l": "agent::OpenRulesLibrary", "alt-tab": "agent::CycleFavoriteModels", + "cmd-shift-v": "agent::PasteRaw", }, }, { @@ -335,6 +336,7 @@ "shift-ctrl-r": "agent::OpenAgentDiff", "cmd-shift-y": "agent::KeepAll", "cmd-shift-n": "agent::RejectAll", + "cmd-shift-v": "agent::PasteRaw", }, }, { @@ -347,6 +349,7 @@ "shift-ctrl-r": "agent::OpenAgentDiff", "cmd-shift-y": "agent::KeepAll", "cmd-shift-n": "agent::RejectAll", + "cmd-shift-v": "agent::PasteRaw", }, }, { diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json index 4a700e2c9190a8ae23ed53edaa075703fa07b855..445933c950cbc9ef72eb2cca90ab8115471f1e6f 100644 --- a/assets/keymaps/default-windows.json +++ b/assets/keymaps/default-windows.json @@ -227,6 +227,7 @@ "ctrl-g": "search::SelectNextMatch", "ctrl-shift-g": "search::SelectPreviousMatch", "ctrl-k l": "agent::OpenRulesLibrary", + "ctrl-shift-v": "agent::PasteRaw", }, }, { @@ -296,6 +297,7 @@ "ctrl-shift-r": "agent::OpenAgentDiff", "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", + "ctrl-shift-v": "agent::PasteRaw", }, }, { @@ -308,6 +310,7 @@ "ctrl-shift-r": "agent::OpenAgentDiff", "ctrl-shift-y": "agent::KeepAll", "ctrl-shift-n": "agent::RejectAll", + "ctrl-shift-v": "agent::PasteRaw", }, }, { diff --git a/crates/agent_ui/src/acp/message_editor.rs b/crates/agent_ui/src/acp/message_editor.rs index 308230a24c6d2ba7fb0c3995b886e9e924d8e1b7..6bed82accf876aaaba0668d366216c3a965ad8cb 100644 --- a/crates/agent_ui/src/acp/message_editor.rs +++ b/crates/agent_ui/src/acp/message_editor.rs @@ -34,7 +34,7 @@ use theme::ThemeSettings; use ui::prelude::*; use util::{ResultExt, debug_panic}; use workspace::{CollaboratorId, Workspace}; -use zed_actions::agent::Chat; +use zed_actions::agent::{Chat, PasteRaw}; pub struct MessageEditor { mention_set: Entity, @@ -543,6 +543,9 @@ impl MessageEditor { } fn paste(&mut self, _: &Paste, window: &mut Window, cx: &mut Context) { + let Some(workspace) = self.workspace.upgrade() else { + return; + }; let editor_clipboard_selections = cx .read_from_clipboard() .and_then(|item| item.entries().first().cloned()) @@ -553,133 +556,127 @@ impl MessageEditor { _ => None, }); - let has_file_context = editor_clipboard_selections - .as_ref() - .is_some_and(|selections| { - selections - .iter() - .any(|sel| sel.file_path.is_some() && sel.line_range.is_some()) - }); + // Insert creases for pasted clipboard selections that: + // 1. Contain exactly one selection + // 2. Have an associated file path + // 3. Span multiple lines (not single-line selections) + // 4. Belong to a file that exists in the current project + let should_insert_creases = util::maybe!({ + let selections = editor_clipboard_selections.as_ref()?; + if selections.len() > 1 { + return Some(false); + } + let selection = selections.first()?; + let file_path = selection.file_path.as_ref()?; + let line_range = selection.line_range.as_ref()?; - if has_file_context { - if let Some((workspace, selections)) = - self.workspace.upgrade().zip(editor_clipboard_selections) - { - let Some(first_selection) = selections.first() else { - return; - }; - if let Some(file_path) = &first_selection.file_path { - // In case someone pastes selections from another window - // with a different project, we don't want to insert the - // crease (containing the absolute path) since the agent - // cannot access files outside the project. - let is_in_project = workspace - .read(cx) - .project() - .read(cx) - .project_path_for_absolute_path(file_path, cx) - .is_some(); - if !is_in_project { - return; - } - } + if line_range.start() == line_range.end() { + return Some(false); + } - cx.stop_propagation(); - let insertion_target = self - .editor + Some( + workspace .read(cx) - .selections - .newest_anchor() - .start - .text_anchor; - - let project = workspace.read(cx).project().clone(); - for selection in selections { - if let (Some(file_path), Some(line_range)) = - (selection.file_path, selection.line_range) - { - let crease_text = - acp_thread::selection_name(Some(file_path.as_ref()), &line_range); + .project() + .read(cx) + .project_path_for_absolute_path(file_path, cx) + .is_some(), + ) + }) + .unwrap_or(false); - let mention_uri = MentionUri::Selection { - abs_path: Some(file_path.clone()), - line_range: line_range.clone(), - }; + if should_insert_creases && let Some(selections) = editor_clipboard_selections { + cx.stop_propagation(); + let insertion_target = self + .editor + .read(cx) + .selections + .newest_anchor() + .start + .text_anchor; + + let project = workspace.read(cx).project().clone(); + for selection in selections { + if let (Some(file_path), Some(line_range)) = + (selection.file_path, selection.line_range) + { + let crease_text = + acp_thread::selection_name(Some(file_path.as_ref()), &line_range); - let mention_text = mention_uri.as_link().to_string(); - let (excerpt_id, text_anchor, content_len) = - self.editor.update(cx, |editor, cx| { - let buffer = editor.buffer().read(cx); - let snapshot = buffer.snapshot(cx); - let (excerpt_id, _, buffer_snapshot) = - snapshot.as_singleton().unwrap(); - let text_anchor = insertion_target.bias_left(&buffer_snapshot); - - editor.insert(&mention_text, window, cx); - editor.insert(" ", window, cx); - - (*excerpt_id, text_anchor, mention_text.len()) - }); - - let Some((crease_id, tx)) = insert_crease_for_mention( - excerpt_id, - text_anchor, - content_len, - crease_text.into(), - mention_uri.icon_path(cx), - None, - self.editor.clone(), - window, - cx, - ) else { - continue; - }; - drop(tx); - - let mention_task = cx - .spawn({ - let project = project.clone(); - async move |_, cx| { - let project_path = project - .update(cx, |project, cx| { - project.project_path_for_absolute_path(&file_path, cx) - }) - .map_err(|e| e.to_string())? - .ok_or_else(|| "project path not found".to_string())?; - - let buffer = project - .update(cx, |project, cx| { - project.open_buffer(project_path, cx) - }) - .map_err(|e| e.to_string())? - .await - .map_err(|e| e.to_string())?; - - buffer - .update(cx, |buffer, cx| { - let start = Point::new(*line_range.start(), 0) - .min(buffer.max_point()); - let end = Point::new(*line_range.end() + 1, 0) - .min(buffer.max_point()); - let content = - buffer.text_for_range(start..end).collect(); - Mention::Text { - content, - tracked_buffers: vec![cx.entity()], - } - }) - .map_err(|e| e.to_string()) - } - }) - .shared(); + let mention_uri = MentionUri::Selection { + abs_path: Some(file_path.clone()), + line_range: line_range.clone(), + }; + + let mention_text = mention_uri.as_link().to_string(); + let (excerpt_id, text_anchor, content_len) = + self.editor.update(cx, |editor, cx| { + let buffer = editor.buffer().read(cx); + let snapshot = buffer.snapshot(cx); + let (excerpt_id, _, buffer_snapshot) = snapshot.as_singleton().unwrap(); + let text_anchor = insertion_target.bias_left(&buffer_snapshot); + + editor.insert(&mention_text, window, cx); + editor.insert(" ", window, cx); - self.mention_set.update(cx, |mention_set, _cx| { - mention_set.insert_mention(crease_id, mention_uri.clone(), mention_task) + (*excerpt_id, text_anchor, mention_text.len()) }); - } + + let Some((crease_id, tx)) = insert_crease_for_mention( + excerpt_id, + text_anchor, + content_len, + crease_text.into(), + mention_uri.icon_path(cx), + None, + self.editor.clone(), + window, + cx, + ) else { + continue; + }; + drop(tx); + + let mention_task = cx + .spawn({ + let project = project.clone(); + async move |_, cx| { + let project_path = project + .update(cx, |project, cx| { + project.project_path_for_absolute_path(&file_path, cx) + }) + .map_err(|e| e.to_string())? + .ok_or_else(|| "project path not found".to_string())?; + + let buffer = project + .update(cx, |project, cx| project.open_buffer(project_path, cx)) + .map_err(|e| e.to_string())? + .await + .map_err(|e| e.to_string())?; + + buffer + .update(cx, |buffer, cx| { + let start = Point::new(*line_range.start(), 0) + .min(buffer.max_point()); + let end = Point::new(*line_range.end() + 1, 0) + .min(buffer.max_point()); + let content = buffer.text_for_range(start..end).collect(); + Mention::Text { + content, + tracked_buffers: vec![cx.entity()], + } + }) + .map_err(|e| e.to_string()) + } + }) + .shared(); + + self.mention_set.update(cx, |mention_set, _cx| { + mention_set.insert_mention(crease_id, mention_uri.clone(), mention_task) + }); } - return; } + return; } if self.prompt_capabilities.borrow().image @@ -690,6 +687,13 @@ impl MessageEditor { } } + fn paste_raw(&mut self, _: &PasteRaw, window: &mut Window, cx: &mut Context) { + let editor = self.editor.clone(); + window.defer(cx, move |window, cx| { + editor.update(cx, |editor, cx| editor.paste(&Paste, window, cx)); + }); + } + pub fn insert_dragged_files( &mut self, paths: Vec, @@ -967,6 +971,7 @@ impl Render for MessageEditor { .on_action(cx.listener(Self::chat)) .on_action(cx.listener(Self::chat_with_follow)) .on_action(cx.listener(Self::cancel)) + .on_action(cx.listener(Self::paste_raw)) .capture_action(cx.listener(Self::paste)) .flex_1() .child({ diff --git a/crates/agent_ui/src/text_thread_editor.rs b/crates/agent_ui/src/text_thread_editor.rs index b26ee44ce53503f3f9b9e77b27a22c0bc39d6473..16d12cf261d3bbb8eb0b879394fedc1cc96e046c 100644 --- a/crates/agent_ui/src/text_thread_editor.rs +++ b/crates/agent_ui/src/text_thread_editor.rs @@ -71,7 +71,7 @@ use workspace::{ pane, searchable::{SearchEvent, SearchableItem}, }; -use zed_actions::agent::{AddSelectionToThread, ToggleModelSelector}; +use zed_actions::agent::{AddSelectionToThread, PasteRaw, ToggleModelSelector}; use crate::CycleFavoriteModels; @@ -1698,6 +1698,9 @@ impl TextThreadEditor { window: &mut Window, cx: &mut Context, ) { + let Some(workspace) = self.workspace.upgrade() else { + return; + }; let editor_clipboard_selections = cx .read_from_clipboard() .and_then(|item| item.entries().first().cloned()) @@ -1708,84 +1711,101 @@ impl TextThreadEditor { _ => None, }); - let has_file_context = editor_clipboard_selections - .as_ref() - .is_some_and(|selections| { - selections - .iter() - .any(|sel| sel.file_path.is_some() && sel.line_range.is_some()) - }); - - if has_file_context { - if let Some(clipboard_item) = cx.read_from_clipboard() { - if let Some(ClipboardEntry::String(clipboard_text)) = - clipboard_item.entries().first() - { - if let Some(selections) = editor_clipboard_selections { - cx.stop_propagation(); - - let text = clipboard_text.text(); - self.editor.update(cx, |editor, cx| { - let mut current_offset = 0; - let weak_editor = cx.entity().downgrade(); - - for selection in selections { - if let (Some(file_path), Some(line_range)) = - (selection.file_path, selection.line_range) - { - let selected_text = - &text[current_offset..current_offset + selection.len]; - let fence = assistant_slash_commands::codeblock_fence_for_path( - file_path.to_str(), - Some(line_range.clone()), - ); - let formatted_text = format!("{fence}{selected_text}\n```"); - - let insert_point = editor - .selections - .newest::(&editor.display_snapshot(cx)) - .head(); - let start_row = MultiBufferRow(insert_point.row); - - editor.insert(&formatted_text, window, cx); + // Insert creases for pasted clipboard selections that: + // 1. Contain exactly one selection + // 2. Have an associated file path + // 3. Span multiple lines (not single-line selections) + // 4. Belong to a file that exists in the current project + let should_insert_creases = util::maybe!({ + let selections = editor_clipboard_selections.as_ref()?; + if selections.len() > 1 { + return Some(false); + } + let selection = selections.first()?; + let file_path = selection.file_path.as_ref()?; + let line_range = selection.line_range.as_ref()?; - let snapshot = editor.buffer().read(cx).snapshot(cx); - let anchor_before = snapshot.anchor_after(insert_point); - let anchor_after = editor - .selections - .newest_anchor() - .head() - .bias_left(&snapshot); + if line_range.start() == line_range.end() { + return Some(false); + } - editor.insert("\n", window, cx); + Some( + workspace + .read(cx) + .project() + .read(cx) + .project_path_for_absolute_path(file_path, cx) + .is_some(), + ) + }) + .unwrap_or(false); - let crease_text = acp_thread::selection_name( - Some(file_path.as_ref()), - &line_range, - ); + if should_insert_creases && let Some(clipboard_item) = cx.read_from_clipboard() { + if let Some(ClipboardEntry::String(clipboard_text)) = clipboard_item.entries().first() { + if let Some(selections) = editor_clipboard_selections { + cx.stop_propagation(); - let fold_placeholder = quote_selection_fold_placeholder( - crease_text, - weak_editor.clone(), - ); - let crease = Crease::inline( - anchor_before..anchor_after, - fold_placeholder, - render_quote_selection_output_toggle, - |_, _, _, _| Empty.into_any(), - ); - editor.insert_creases(vec![crease], cx); - editor.fold_at(start_row, window, cx); + let text = clipboard_text.text(); + self.editor.update(cx, |editor, cx| { + let mut current_offset = 0; + let weak_editor = cx.entity().downgrade(); - current_offset += selection.len; - if !selection.is_entire_line && current_offset < text.len() { - current_offset += 1; - } + for selection in selections { + if let (Some(file_path), Some(line_range)) = + (selection.file_path, selection.line_range) + { + let selected_text = + &text[current_offset..current_offset + selection.len]; + let fence = assistant_slash_commands::codeblock_fence_for_path( + file_path.to_str(), + Some(line_range.clone()), + ); + let formatted_text = format!("{fence}{selected_text}\n```"); + + let insert_point = editor + .selections + .newest::(&editor.display_snapshot(cx)) + .head(); + let start_row = MultiBufferRow(insert_point.row); + + editor.insert(&formatted_text, window, cx); + + let snapshot = editor.buffer().read(cx).snapshot(cx); + let anchor_before = snapshot.anchor_after(insert_point); + let anchor_after = editor + .selections + .newest_anchor() + .head() + .bias_left(&snapshot); + + editor.insert("\n", window, cx); + + let crease_text = acp_thread::selection_name( + Some(file_path.as_ref()), + &line_range, + ); + + let fold_placeholder = quote_selection_fold_placeholder( + crease_text, + weak_editor.clone(), + ); + let crease = Crease::inline( + anchor_before..anchor_after, + fold_placeholder, + render_quote_selection_output_toggle, + |_, _, _, _| Empty.into_any(), + ); + editor.insert_creases(vec![crease], cx); + editor.fold_at(start_row, window, cx); + + current_offset += selection.len; + if !selection.is_entire_line && current_offset < text.len() { + current_offset += 1; } } - }); - return; - } + } + }); + return; } } } @@ -1944,6 +1964,12 @@ impl TextThreadEditor { } } + fn paste_raw(&mut self, _: &PasteRaw, window: &mut Window, cx: &mut Context) { + self.editor.update(cx, |editor, cx| { + editor.paste(&editor::actions::Paste, window, cx); + }); + } + fn update_image_blocks(&mut self, cx: &mut Context) { self.editor.update(cx, |editor, cx| { let buffer = editor.buffer().read(cx).snapshot(cx); @@ -2627,6 +2653,7 @@ impl Render for TextThreadEditor { .capture_action(cx.listener(TextThreadEditor::copy)) .capture_action(cx.listener(TextThreadEditor::cut)) .capture_action(cx.listener(TextThreadEditor::paste)) + .on_action(cx.listener(TextThreadEditor::paste_raw)) .capture_action(cx.listener(TextThreadEditor::cycle_message_role)) .capture_action(cx.listener(TextThreadEditor::confirm_command)) .on_action(cx.listener(TextThreadEditor::assist)) diff --git a/crates/zed_actions/src/lib.rs b/crates/zed_actions/src/lib.rs index 458ca10ecdf8915eef3ee69c6334b1a14cc0c219..85b6d4d37d06d5f1c229fc852dd5bad117bbd9d7 100644 --- a/crates/zed_actions/src/lib.rs +++ b/crates/zed_actions/src/lib.rs @@ -354,6 +354,8 @@ pub mod agent { ResetAgentZoom, /// Toggles the utility/agent pane open/closed state. ToggleAgentPane, + /// Pastes clipboard content without any formatting. + PasteRaw, ] ); } From bd2b0de231e2f76c963a08f3f98f5932ad1b3f13 Mon Sep 17 00:00:00 2001 From: Alvaro Parker <64918109+AlvaroParker@users.noreply.github.com> Date: Thu, 18 Dec 2025 12:45:06 -0300 Subject: [PATCH 188/266] gpui: Add modal dialog window kind (#40291) Closes #ISSUE A [modal dialog](https://en.wikipedia.org/wiki/Modal_window) window is a window that demands the user's immediate attention and blocks interaction with other parts of the application until it's closed. - On Windows this is done by disabling the parent window when the dialog window is created and re-enabling the parent window when closed. - On Wayland this is done using the [`XdgDialog`](https://wayland.app/protocols/xdg-dialog-v1) protocol, which hints to the compositor that the dialog should be modal. While compositors like GNOME and KDE block parent interaction automatically, the XDG specification does not guarantee this behavior, compositors may deliver events to the parent window unfiltered. Since the specification explicitly requires clients to implement event filtering logic themselves, this PR implements client-side blocking in GPUI to ensure consistent modal behavior across all Wayland compositors, including those like Hyprland that don't block parent interaction. - On X11 this is done by enabling the application window property [`_NET_WM_STATE_MODAL`](https://specifications.freedesktop.org/wm/latest/ar01s05.html#id-1.6.8) state. I'm unable to implement this on MacOS as I lack the experience and the hardware to test it. If anyone is interested on implementing this let me know. |Window|Linux (wayland)| Linux (x11) |MacOS| |-|-|-|-| ||| N/A | | TODO: - [x] Block parent interaction client-side on X11 Release Notes: - Added modal dialog window kind on GPUI --------- Co-authored-by: Jason Lee Co-authored-by: Anthony Eid Co-authored-by: Anthony Eid --- Cargo.lock | 24 ++--- crates/gpui/Cargo.toml | 8 +- crates/gpui/examples/window.rs | 65 +++++++++++++- crates/gpui/src/platform.rs | 4 + .../gpui/src/platform/linux/wayland/client.rs | 79 ++++++++++++++--- .../gpui/src/platform/linux/wayland/window.rs | 83 +++++++++++++++-- crates/gpui/src/platform/linux/x11/client.rs | 53 +++++++++-- crates/gpui/src/platform/linux/x11/window.rs | 88 +++++++++++++++++-- crates/gpui/src/platform/mac/window.rs | 51 +++++++++-- crates/gpui/src/platform/windows/events.rs | 8 ++ crates/gpui/src/platform/windows/window.rs | 28 +++++- 11 files changed, 425 insertions(+), 66 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7364a68b2a68fe44a42d24443dd723aa3c87e135..1ec640d49c2135d35442f0bf23047be7991427eb 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -793,7 +793,7 @@ dependencies = [ "url", "wayland-backend", "wayland-client", - "wayland-protocols 0.32.9", + "wayland-protocols", "zbus", ] @@ -7370,7 +7370,7 @@ dependencies = [ "wayland-backend", "wayland-client", "wayland-cursor", - "wayland-protocols 0.31.2", + "wayland-protocols", "wayland-protocols-plasma", "wayland-protocols-wlr", "windows 0.61.3", @@ -18927,18 +18927,6 @@ dependencies = [ "xcursor", ] -[[package]] -name = "wayland-protocols" -version = "0.31.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f81f365b8b4a97f422ac0e8737c438024b5951734506b0e1d775c73030561f4" -dependencies = [ - "bitflags 2.9.4", - "wayland-backend", - "wayland-client", - "wayland-scanner", -] - [[package]] name = "wayland-protocols" version = "0.32.9" @@ -18953,14 +18941,14 @@ dependencies = [ [[package]] name = "wayland-protocols-plasma" -version = "0.2.0" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "23803551115ff9ea9bce586860c5c5a971e360825a0309264102a9495a5ff479" +checksum = "a07a14257c077ab3279987c4f8bb987851bf57081b93710381daea94f2c2c032" dependencies = [ "bitflags 2.9.4", "wayland-backend", "wayland-client", - "wayland-protocols 0.31.2", + "wayland-protocols", "wayland-scanner", ] @@ -18973,7 +18961,7 @@ dependencies = [ "bitflags 2.9.4", "wayland-backend", "wayland-client", - "wayland-protocols 0.32.9", + "wayland-protocols", "wayland-scanner", ] diff --git a/crates/gpui/Cargo.toml b/crates/gpui/Cargo.toml index da7e660a0171f38b8dd61de1c9323773ded2589b..40376f476b6d80f6b5170840f295a71acdfebb7d 100644 --- a/crates/gpui/Cargo.toml +++ b/crates/gpui/Cargo.toml @@ -198,14 +198,14 @@ wayland-backend = { version = "0.3.3", features = [ "client_system", "dlopen", ], optional = true } -wayland-client = { version = "0.31.2", optional = true } -wayland-cursor = { version = "0.31.1", optional = true } -wayland-protocols = { version = "0.31.2", features = [ +wayland-client = { version = "0.31.11", optional = true } +wayland-cursor = { version = "0.31.11", optional = true } +wayland-protocols = { version = "0.32.9", features = [ "client", "staging", "unstable", ], optional = true } -wayland-protocols-plasma = { version = "0.2.0", features = [ +wayland-protocols-plasma = { version = "0.3.9", features = [ "client", ], optional = true } wayland-protocols-wlr = { version = "0.3.9", features = [ diff --git a/crates/gpui/examples/window.rs b/crates/gpui/examples/window.rs index 06003c4663ee5711283a85684c25b9f5d8c5b743..3f41f3d55f240e688965ac8248ac3d5b4ef40401 100644 --- a/crates/gpui/examples/window.rs +++ b/crates/gpui/examples/window.rs @@ -5,6 +5,7 @@ use gpui::{ struct SubWindow { custom_titlebar: bool, + is_dialog: bool, } fn button(text: &str, on_click: impl Fn(&mut Window, &mut App) + 'static) -> impl IntoElement { @@ -23,7 +24,10 @@ fn button(text: &str, on_click: impl Fn(&mut Window, &mut App) + 'static) -> imp } impl Render for SubWindow { - fn render(&mut self, _window: &mut Window, _: &mut Context) -> impl IntoElement { + fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { + let window_bounds = + WindowBounds::Windowed(Bounds::centered(None, size(px(250.0), px(200.0)), cx)); + div() .flex() .flex_col() @@ -52,8 +56,28 @@ impl Render for SubWindow { .child( div() .p_8() + .flex() + .flex_col() .gap_2() .child("SubWindow") + .when(self.is_dialog, |div| { + div.child(button("Open Nested Dialog", move |_, cx| { + cx.open_window( + WindowOptions { + window_bounds: Some(window_bounds), + kind: WindowKind::Dialog, + ..Default::default() + }, + |_, cx| { + cx.new(|_| SubWindow { + custom_titlebar: false, + is_dialog: true, + }) + }, + ) + .unwrap(); + })) + }) .child(button("Close", |window, _| { window.remove_window(); })), @@ -86,6 +110,7 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: false, + is_dialog: false, }) }, ) @@ -101,6 +126,39 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: false, + is_dialog: false, + }) + }, + ) + .unwrap(); + })) + .child(button("Floating", move |_, cx| { + cx.open_window( + WindowOptions { + window_bounds: Some(window_bounds), + kind: WindowKind::Floating, + ..Default::default() + }, + |_, cx| { + cx.new(|_| SubWindow { + custom_titlebar: false, + is_dialog: false, + }) + }, + ) + .unwrap(); + })) + .child(button("Dialog", move |_, cx| { + cx.open_window( + WindowOptions { + window_bounds: Some(window_bounds), + kind: WindowKind::Dialog, + ..Default::default() + }, + |_, cx| { + cx.new(|_| SubWindow { + custom_titlebar: false, + is_dialog: true, }) }, ) @@ -116,6 +174,7 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: true, + is_dialog: false, }) }, ) @@ -131,6 +190,7 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: false, + is_dialog: false, }) }, ) @@ -147,6 +207,7 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: false, + is_dialog: false, }) }, ) @@ -162,6 +223,7 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: false, + is_dialog: false, }) }, ) @@ -177,6 +239,7 @@ impl Render for WindowDemo { |_, cx| { cx.new(|_| SubWindow { custom_titlebar: false, + is_dialog: false, }) }, ) diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs index f120e075fea7f9336e2f6e10c51611d8ba03564d..22f4c46921132a7b8badfb7afd4fd38058c638b4 100644 --- a/crates/gpui/src/platform.rs +++ b/crates/gpui/src/platform.rs @@ -1348,6 +1348,10 @@ pub enum WindowKind { /// docks, notifications or wallpapers. #[cfg(all(target_os = "linux", feature = "wayland"))] LayerShell(layer_shell::LayerShellOptions), + + /// A window that appears on top of its parent window and blocks interaction with it + /// until the modal window is closed + Dialog, } /// The appearance of the window, as defined by the operating system. diff --git a/crates/gpui/src/platform/linux/wayland/client.rs b/crates/gpui/src/platform/linux/wayland/client.rs index 0e7bf8fbf8880baf5876027e6e764d7411932577..b6bfbec0679f9413fceef2bb37e7bd304371707e 100644 --- a/crates/gpui/src/platform/linux/wayland/client.rs +++ b/crates/gpui/src/platform/linux/wayland/client.rs @@ -36,12 +36,6 @@ use wayland_client::{ wl_shm_pool, wl_surface, }, }; -use wayland_protocols::wp::cursor_shape::v1::client::{ - wp_cursor_shape_device_v1, wp_cursor_shape_manager_v1, -}; -use wayland_protocols::wp::fractional_scale::v1::client::{ - wp_fractional_scale_manager_v1, wp_fractional_scale_v1, -}; use wayland_protocols::wp::primary_selection::zv1::client::zwp_primary_selection_offer_v1::{ self, ZwpPrimarySelectionOfferV1, }; @@ -61,6 +55,14 @@ use wayland_protocols::xdg::decoration::zv1::client::{ zxdg_decoration_manager_v1, zxdg_toplevel_decoration_v1, }; use wayland_protocols::xdg::shell::client::{xdg_surface, xdg_toplevel, xdg_wm_base}; +use wayland_protocols::{ + wp::cursor_shape::v1::client::{wp_cursor_shape_device_v1, wp_cursor_shape_manager_v1}, + xdg::dialog::v1::client::xdg_wm_dialog_v1::{self, XdgWmDialogV1}, +}; +use wayland_protocols::{ + wp::fractional_scale::v1::client::{wp_fractional_scale_manager_v1, wp_fractional_scale_v1}, + xdg::dialog::v1::client::xdg_dialog_v1::XdgDialogV1, +}; use wayland_protocols_plasma::blur::client::{org_kde_kwin_blur, org_kde_kwin_blur_manager}; use wayland_protocols_wlr::layer_shell::v1::client::{zwlr_layer_shell_v1, zwlr_layer_surface_v1}; use xkbcommon::xkb::ffi::XKB_KEYMAP_FORMAT_TEXT_V1; @@ -122,6 +124,7 @@ pub struct Globals { pub layer_shell: Option, pub blur_manager: Option, pub text_input_manager: Option, + pub dialog: Option, pub executor: ForegroundExecutor, } @@ -132,6 +135,7 @@ impl Globals { qh: QueueHandle, seat: wl_seat::WlSeat, ) -> Self { + let dialog_v = XdgWmDialogV1::interface().version; Globals { activation: globals.bind(&qh, 1..=1, ()).ok(), compositor: globals @@ -160,6 +164,7 @@ impl Globals { layer_shell: globals.bind(&qh, 1..=5, ()).ok(), blur_manager: globals.bind(&qh, 1..=1, ()).ok(), text_input_manager: globals.bind(&qh, 1..=1, ()).ok(), + dialog: globals.bind(&qh, dialog_v..=dialog_v, ()).ok(), executor, qh, } @@ -729,10 +734,7 @@ impl LinuxClient for WaylandClient { ) -> anyhow::Result> { let mut state = self.0.borrow_mut(); - let parent = state - .keyboard_focused_window - .as_ref() - .and_then(|w| w.toplevel()); + let parent = state.keyboard_focused_window.clone(); let (window, surface_id) = WaylandWindow::new( handle, @@ -751,7 +753,12 @@ impl LinuxClient for WaylandClient { fn set_cursor_style(&self, style: CursorStyle) { let mut state = self.0.borrow_mut(); - let need_update = state.cursor_style != Some(style); + let need_update = state.cursor_style != Some(style) + && (state.mouse_focused_window.is_none() + || state + .mouse_focused_window + .as_ref() + .is_some_and(|w| !w.is_blocked())); if need_update { let serial = state.serial_tracker.get(SerialKind::MouseEnter); @@ -1011,7 +1018,7 @@ impl Dispatch for WaylandClientStatePtr { } } -fn get_window( +pub(crate) fn get_window( mut state: &mut RefMut, surface_id: &ObjectId, ) -> Option { @@ -1654,6 +1661,30 @@ impl Dispatch for WaylandClientStatePtr { state.mouse_location = Some(point(px(surface_x as f32), px(surface_y as f32))); if let Some(window) = state.mouse_focused_window.clone() { + if window.is_blocked() { + let default_style = CursorStyle::Arrow; + if state.cursor_style != Some(default_style) { + let serial = state.serial_tracker.get(SerialKind::MouseEnter); + state.cursor_style = Some(default_style); + + if let Some(cursor_shape_device) = &state.cursor_shape_device { + cursor_shape_device.set_shape(serial, default_style.to_shape()); + } else { + // cursor-shape-v1 isn't supported, set the cursor using a surface. + let wl_pointer = state + .wl_pointer + .clone() + .expect("window is focused by pointer"); + let scale = window.primary_output_scale(); + state.cursor.set_icon( + &wl_pointer, + serial, + default_style.to_icon_names(), + scale, + ); + } + } + } if state .keyboard_focused_window .as_ref() @@ -2225,3 +2256,27 @@ impl Dispatch } } } + +impl Dispatch for WaylandClientStatePtr { + fn event( + _: &mut Self, + _: &XdgWmDialogV1, + _: ::Event, + _: &(), + _: &Connection, + _: &QueueHandle, + ) { + } +} + +impl Dispatch for WaylandClientStatePtr { + fn event( + _state: &mut Self, + _proxy: &XdgDialogV1, + _event: ::Event, + _data: &(), + _conn: &Connection, + _qhandle: &QueueHandle, + ) { + } +} diff --git a/crates/gpui/src/platform/linux/wayland/window.rs b/crates/gpui/src/platform/linux/wayland/window.rs index 8cc47c3c139708c3cc278c6146411a4383cc0004..6b4dad3b3917d025a80594b5ece63c26bbadde69 100644 --- a/crates/gpui/src/platform/linux/wayland/window.rs +++ b/crates/gpui/src/platform/linux/wayland/window.rs @@ -7,7 +7,7 @@ use std::{ }; use blade_graphics as gpu; -use collections::HashMap; +use collections::{FxHashSet, HashMap}; use futures::channel::oneshot::Receiver; use raw_window_handle as rwh; @@ -20,7 +20,7 @@ use wayland_protocols::xdg::shell::client::xdg_surface; use wayland_protocols::xdg::shell::client::xdg_toplevel::{self}; use wayland_protocols::{ wp::fractional_scale::v1::client::wp_fractional_scale_v1, - xdg::shell::client::xdg_toplevel::XdgToplevel, + xdg::dialog::v1::client::xdg_dialog_v1::XdgDialogV1, }; use wayland_protocols_plasma::blur::client::org_kde_kwin_blur; use wayland_protocols_wlr::layer_shell::v1::client::zwlr_layer_surface_v1; @@ -29,7 +29,7 @@ use crate::{ AnyWindowHandle, Bounds, Decorations, Globals, GpuSpecs, Modifiers, Output, Pixels, PlatformDisplay, PlatformInput, Point, PromptButton, PromptLevel, RequestFrameOptions, ResizeEdge, Size, Tiling, WaylandClientStatePtr, WindowAppearance, WindowBackgroundAppearance, - WindowBounds, WindowControlArea, WindowControls, WindowDecorations, WindowParams, + WindowBounds, WindowControlArea, WindowControls, WindowDecorations, WindowParams, get_window, layer_shell::LayerShellNotSupportedError, px, size, }; use crate::{ @@ -87,6 +87,8 @@ struct InProgressConfigure { pub struct WaylandWindowState { surface_state: WaylandSurfaceState, acknowledged_first_configure: bool, + parent: Option, + children: FxHashSet, pub surface: wl_surface::WlSurface, app_id: Option, appearance: WindowAppearance, @@ -126,7 +128,7 @@ impl WaylandSurfaceState { surface: &wl_surface::WlSurface, globals: &Globals, params: &WindowParams, - parent: Option, + parent: Option, ) -> anyhow::Result { // For layer_shell windows, create a layer surface instead of an xdg surface if let WindowKind::LayerShell(options) = ¶ms.kind { @@ -178,10 +180,28 @@ impl WaylandSurfaceState { .get_xdg_surface(&surface, &globals.qh, surface.id()); let toplevel = xdg_surface.get_toplevel(&globals.qh, surface.id()); - if params.kind == WindowKind::Floating { - toplevel.set_parent(parent.as_ref()); + let xdg_parent = parent.as_ref().and_then(|w| w.toplevel()); + + if params.kind == WindowKind::Floating || params.kind == WindowKind::Dialog { + toplevel.set_parent(xdg_parent.as_ref()); } + let dialog = if params.kind == WindowKind::Dialog { + let dialog = globals.dialog.as_ref().map(|dialog| { + let xdg_dialog = dialog.get_xdg_dialog(&toplevel, &globals.qh, ()); + xdg_dialog.set_modal(); + xdg_dialog + }); + + if let Some(parent) = parent.as_ref() { + parent.add_child(surface.id()); + } + + dialog + } else { + None + }; + if let Some(size) = params.window_min_size { toplevel.set_min_size(size.width.0 as i32, size.height.0 as i32); } @@ -198,6 +218,7 @@ impl WaylandSurfaceState { xdg_surface, toplevel, decoration, + dialog, })) } } @@ -206,6 +227,7 @@ pub struct WaylandXdgSurfaceState { xdg_surface: xdg_surface::XdgSurface, toplevel: xdg_toplevel::XdgToplevel, decoration: Option, + dialog: Option, } pub struct WaylandLayerSurfaceState { @@ -258,7 +280,13 @@ impl WaylandSurfaceState { xdg_surface, toplevel, decoration: _decoration, + dialog, }) => { + // drop the dialog before toplevel so compositor can explicitly unapply it's effects + if let Some(dialog) = dialog { + dialog.destroy(); + } + // The role object (toplevel) must always be destroyed before the xdg_surface. // See https://wayland.app/protocols/xdg-shell#xdg_surface:request:destroy toplevel.destroy(); @@ -288,6 +316,7 @@ impl WaylandWindowState { globals: Globals, gpu_context: &BladeContext, options: WindowParams, + parent: Option, ) -> anyhow::Result { let renderer = { let raw_window = RawWindow { @@ -319,6 +348,8 @@ impl WaylandWindowState { Ok(Self { surface_state, acknowledged_first_configure: false, + parent, + children: FxHashSet::default(), surface, app_id: None, blur: None, @@ -391,6 +422,10 @@ impl Drop for WaylandWindow { fn drop(&mut self) { let mut state = self.0.state.borrow_mut(); let surface_id = state.surface.id(); + if let Some(parent) = state.parent.as_ref() { + parent.state.borrow_mut().children.remove(&surface_id); + } + let client = state.client.clone(); state.renderer.destroy(); @@ -448,10 +483,10 @@ impl WaylandWindow { client: WaylandClientStatePtr, params: WindowParams, appearance: WindowAppearance, - parent: Option, + parent: Option, ) -> anyhow::Result<(Self, ObjectId)> { let surface = globals.compositor.create_surface(&globals.qh, ()); - let surface_state = WaylandSurfaceState::new(&surface, &globals, ¶ms, parent)?; + let surface_state = WaylandSurfaceState::new(&surface, &globals, ¶ms, parent.clone())?; if let Some(fractional_scale_manager) = globals.fractional_scale_manager.as_ref() { fractional_scale_manager.get_fractional_scale(&surface, &globals.qh, surface.id()); @@ -473,6 +508,7 @@ impl WaylandWindow { globals, gpu_context, params, + parent, )?)), callbacks: Rc::new(RefCell::new(Callbacks::default())), }); @@ -501,6 +537,16 @@ impl WaylandWindowStatePtr { Rc::ptr_eq(&self.state, &other.state) } + pub fn add_child(&self, child: ObjectId) { + let mut state = self.state.borrow_mut(); + state.children.insert(child); + } + + pub fn is_blocked(&self) -> bool { + let state = self.state.borrow(); + !state.children.is_empty() + } + pub fn frame(&self) { let mut state = self.state.borrow_mut(); state.surface.frame(&state.globals.qh, state.surface.id()); @@ -818,6 +864,9 @@ impl WaylandWindowStatePtr { } pub fn handle_ime(&self, ime: ImeInput) { + if self.is_blocked() { + return; + } let mut state = self.state.borrow_mut(); if let Some(mut input_handler) = state.input_handler.take() { drop(state); @@ -894,6 +943,21 @@ impl WaylandWindowStatePtr { } pub fn close(&self) { + let state = self.state.borrow(); + let client = state.client.get_client(); + #[allow(clippy::mutable_key_type)] + let children = state.children.clone(); + drop(state); + + for child in children { + let mut client_state = client.borrow_mut(); + let window = get_window(&mut client_state, &child); + drop(client_state); + + if let Some(child) = window { + child.close(); + } + } let mut callbacks = self.callbacks.borrow_mut(); if let Some(fun) = callbacks.close.take() { fun() @@ -901,6 +965,9 @@ impl WaylandWindowStatePtr { } pub fn handle_input(&self, input: PlatformInput) { + if self.is_blocked() { + return; + } if let Some(ref mut fun) = self.callbacks.borrow_mut().input && !fun(input.clone()).propagate { diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs index 5e9089b09809a7ec1b8b257427b0a670adc0f123..7feec41d433158325592d566f83a6063f7a7196e 100644 --- a/crates/gpui/src/platform/linux/x11/client.rs +++ b/crates/gpui/src/platform/linux/x11/client.rs @@ -222,7 +222,7 @@ pub struct X11ClientState { pub struct X11ClientStatePtr(pub Weak>); impl X11ClientStatePtr { - fn get_client(&self) -> Option { + pub fn get_client(&self) -> Option { self.0.upgrade().map(X11Client) } @@ -752,7 +752,7 @@ impl X11Client { } } - fn get_window(&self, win: xproto::Window) -> Option { + pub(crate) fn get_window(&self, win: xproto::Window) -> Option { let state = self.0.borrow(); state .windows @@ -789,12 +789,12 @@ impl X11Client { let [atom, arg1, arg2, arg3, arg4] = event.data.as_data32(); let mut state = self.0.borrow_mut(); - if atom == state.atoms.WM_DELETE_WINDOW { + if atom == state.atoms.WM_DELETE_WINDOW && window.should_close() { // window "x" button clicked by user - if window.should_close() { - // Rest of the close logic is handled in drop_window() - window.close(); - } + // Rest of the close logic is handled in drop_window() + drop(state); + window.close(); + state = self.0.borrow_mut(); } else if atom == state.atoms._NET_WM_SYNC_REQUEST { window.state.borrow_mut().last_sync_counter = Some(x11rb::protocol::sync::Int64 { @@ -1216,6 +1216,33 @@ impl X11Client { Event::XinputMotion(event) => { let window = self.get_window(event.event)?; let mut state = self.0.borrow_mut(); + if window.is_blocked() { + // We want to set the cursor to the default arrow + // when the window is blocked + let style = CursorStyle::Arrow; + + let current_style = state + .cursor_styles + .get(&window.x_window) + .unwrap_or(&CursorStyle::Arrow); + if *current_style != style + && let Some(cursor) = state.get_cursor_icon(style) + { + state.cursor_styles.insert(window.x_window, style); + check_reply( + || "Failed to set cursor style", + state.xcb_connection.change_window_attributes( + window.x_window, + &ChangeWindowAttributesAux { + cursor: Some(cursor), + ..Default::default() + }, + ), + ) + .log_err(); + state.xcb_connection.flush().log_err(); + }; + } let pressed_button = pressed_button_from_mask(event.button_mask[0]); let position = point( px(event.event_x as f32 / u16::MAX as f32 / state.scale_factor), @@ -1489,7 +1516,7 @@ impl LinuxClient for X11Client { let parent_window = state .keyboard_focused_window .and_then(|focused_window| state.windows.get(&focused_window)) - .map(|window| window.window.x_window); + .map(|w| w.window.clone()); let x_window = state .xcb_connection .generate_id() @@ -1544,7 +1571,15 @@ impl LinuxClient for X11Client { .cursor_styles .get(&focused_window) .unwrap_or(&CursorStyle::Arrow); - if *current_style == style { + + let window = state + .mouse_focused_window + .and_then(|w| state.windows.get(&w)); + + let should_change = *current_style != style + && (window.is_none() || window.is_some_and(|w| !w.is_blocked())); + + if !should_change { return; } diff --git a/crates/gpui/src/platform/linux/x11/window.rs b/crates/gpui/src/platform/linux/x11/window.rs index fe197a670177689ce776b6b55d439483c43921e0..1986ff6cce6b1930bdc3527eced5f2d5b8f45117 100644 --- a/crates/gpui/src/platform/linux/x11/window.rs +++ b/crates/gpui/src/platform/linux/x11/window.rs @@ -11,6 +11,7 @@ use crate::{ }; use blade_graphics as gpu; +use collections::FxHashSet; use raw_window_handle as rwh; use util::{ResultExt, maybe}; use x11rb::{ @@ -74,6 +75,7 @@ x11rb::atom_manager! { _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_NOTIFICATION, _NET_WM_WINDOW_TYPE_DIALOG, + _NET_WM_STATE_MODAL, _NET_WM_SYNC, _NET_SUPPORTED, _MOTIF_WM_HINTS, @@ -249,6 +251,8 @@ pub struct Callbacks { pub struct X11WindowState { pub destroyed: bool, + parent: Option, + children: FxHashSet, client: X11ClientStatePtr, executor: ForegroundExecutor, atoms: XcbAtoms, @@ -394,7 +398,7 @@ impl X11WindowState { atoms: &XcbAtoms, scale_factor: f32, appearance: WindowAppearance, - parent_window: Option, + parent_window: Option, ) -> anyhow::Result { let x_screen_index = params .display_id @@ -546,8 +550,8 @@ impl X11WindowState { )?; } - if params.kind == WindowKind::Floating { - if let Some(parent_window) = parent_window { + if params.kind == WindowKind::Floating || params.kind == WindowKind::Dialog { + if let Some(parent_window) = parent_window.as_ref().map(|w| w.x_window) { // WM_TRANSIENT_FOR hint indicating the main application window. For floating windows, we set // a parent window (WM_TRANSIENT_FOR) such that the window manager knows where to // place the floating window in relation to the main window. @@ -563,11 +567,23 @@ impl X11WindowState { ), )?; } + } + + let parent = if params.kind == WindowKind::Dialog + && let Some(parent) = parent_window + { + parent.add_child(x_window); + + Some(parent) + } else { + None + }; + if params.kind == WindowKind::Dialog { // _NET_WM_WINDOW_TYPE_DIALOG indicates that this is a dialog (floating) window // https://specifications.freedesktop.org/wm-spec/1.4/ar01s05.html check_reply( - || "X11 ChangeProperty32 setting window type for floating window failed.", + || "X11 ChangeProperty32 setting window type for dialog window failed.", xcb.change_property32( xproto::PropMode::REPLACE, x_window, @@ -576,6 +592,20 @@ impl X11WindowState { &[atoms._NET_WM_WINDOW_TYPE_DIALOG], ), )?; + + // We set the modal state for dialog windows, so that the window manager + // can handle it appropriately (e.g., prevent interaction with the parent window + // while the dialog is open). + check_reply( + || "X11 ChangeProperty32 setting modal state for dialog window failed.", + xcb.change_property32( + xproto::PropMode::REPLACE, + x_window, + atoms._NET_WM_STATE, + xproto::AtomEnum::ATOM, + &[atoms._NET_WM_STATE_MODAL], + ), + )?; } check_reply( @@ -667,6 +697,8 @@ impl X11WindowState { let display = Rc::new(X11Display::new(xcb, scale_factor, x_screen_index)?); Ok(Self { + parent, + children: FxHashSet::default(), client, executor, display, @@ -720,6 +752,11 @@ pub(crate) struct X11Window(pub X11WindowStatePtr); impl Drop for X11Window { fn drop(&mut self) { let mut state = self.0.state.borrow_mut(); + + if let Some(parent) = state.parent.as_ref() { + parent.state.borrow_mut().children.remove(&self.0.x_window); + } + state.renderer.destroy(); let destroy_x_window = maybe!({ @@ -734,8 +771,6 @@ impl Drop for X11Window { .log_err(); if destroy_x_window.is_some() { - // Mark window as destroyed so that we can filter out when X11 events - // for it still come in. state.destroyed = true; let this_ptr = self.0.clone(); @@ -773,7 +808,7 @@ impl X11Window { atoms: &XcbAtoms, scale_factor: f32, appearance: WindowAppearance, - parent_window: Option, + parent_window: Option, ) -> anyhow::Result { let ptr = X11WindowStatePtr { state: Rc::new(RefCell::new(X11WindowState::new( @@ -979,7 +1014,31 @@ impl X11WindowStatePtr { Ok(()) } + pub fn add_child(&self, child: xproto::Window) { + let mut state = self.state.borrow_mut(); + state.children.insert(child); + } + + pub fn is_blocked(&self) -> bool { + let state = self.state.borrow(); + !state.children.is_empty() + } + pub fn close(&self) { + let state = self.state.borrow(); + let client = state.client.clone(); + #[allow(clippy::mutable_key_type)] + let children = state.children.clone(); + drop(state); + + if let Some(client) = client.get_client() { + for child in children { + if let Some(child_window) = client.get_window(child) { + child_window.close(); + } + } + } + let mut callbacks = self.callbacks.borrow_mut(); if let Some(fun) = callbacks.close.take() { fun() @@ -994,6 +1053,9 @@ impl X11WindowStatePtr { } pub fn handle_input(&self, input: PlatformInput) { + if self.is_blocked() { + return; + } if let Some(ref mut fun) = self.callbacks.borrow_mut().input && !fun(input.clone()).propagate { @@ -1016,6 +1078,9 @@ impl X11WindowStatePtr { } pub fn handle_ime_commit(&self, text: String) { + if self.is_blocked() { + return; + } let mut state = self.state.borrow_mut(); if let Some(mut input_handler) = state.input_handler.take() { drop(state); @@ -1026,6 +1091,9 @@ impl X11WindowStatePtr { } pub fn handle_ime_preedit(&self, text: String) { + if self.is_blocked() { + return; + } let mut state = self.state.borrow_mut(); if let Some(mut input_handler) = state.input_handler.take() { drop(state); @@ -1036,6 +1104,9 @@ impl X11WindowStatePtr { } pub fn handle_ime_unmark(&self) { + if self.is_blocked() { + return; + } let mut state = self.state.borrow_mut(); if let Some(mut input_handler) = state.input_handler.take() { drop(state); @@ -1046,6 +1117,9 @@ impl X11WindowStatePtr { } pub fn handle_ime_delete(&self) { + if self.is_blocked() { + return; + } let mut state = self.state.borrow_mut(); if let Some(mut input_handler) = state.input_handler.take() { drop(state); diff --git a/crates/gpui/src/platform/mac/window.rs b/crates/gpui/src/platform/mac/window.rs index 14b0113c7cf44fa9574bfcca30b46fb988b5e380..f843fcd943523dc9a1c228cea1c4dcdf63c76097 100644 --- a/crates/gpui/src/platform/mac/window.rs +++ b/crates/gpui/src/platform/mac/window.rs @@ -62,9 +62,12 @@ static mut BLURRED_VIEW_CLASS: *const Class = ptr::null(); #[allow(non_upper_case_globals)] const NSWindowStyleMaskNonactivatingPanel: NSWindowStyleMask = NSWindowStyleMask::from_bits_retain(1 << 7); +// WindowLevel const value ref: https://docs.rs/core-graphics2/0.4.1/src/core_graphics2/window_level.rs.html #[allow(non_upper_case_globals)] const NSNormalWindowLevel: NSInteger = 0; #[allow(non_upper_case_globals)] +const NSFloatingWindowLevel: NSInteger = 3; +#[allow(non_upper_case_globals)] const NSPopUpWindowLevel: NSInteger = 101; #[allow(non_upper_case_globals)] const NSTrackingMouseEnteredAndExited: NSUInteger = 0x01; @@ -423,6 +426,8 @@ struct MacWindowState { select_previous_tab_callback: Option>, toggle_tab_bar_callback: Option>, activated_least_once: bool, + // The parent window if this window is a sheet (Dialog kind) + sheet_parent: Option, } impl MacWindowState { @@ -622,11 +627,16 @@ impl MacWindow { } let native_window: id = match kind { - WindowKind::Normal | WindowKind::Floating => msg_send![WINDOW_CLASS, alloc], + WindowKind::Normal => { + msg_send![WINDOW_CLASS, alloc] + } WindowKind::PopUp => { style_mask |= NSWindowStyleMaskNonactivatingPanel; msg_send![PANEL_CLASS, alloc] } + WindowKind::Floating | WindowKind::Dialog => { + msg_send![PANEL_CLASS, alloc] + } }; let display = display_id @@ -729,6 +739,7 @@ impl MacWindow { select_previous_tab_callback: None, toggle_tab_bar_callback: None, activated_least_once: false, + sheet_parent: None, }))); (*native_window).set_ivar( @@ -779,9 +790,18 @@ impl MacWindow { content_view.addSubview_(native_view.autorelease()); native_window.makeFirstResponder_(native_view); + let app: id = NSApplication::sharedApplication(nil); + let main_window: id = msg_send![app, mainWindow]; + let mut sheet_parent = None; + match kind { WindowKind::Normal | WindowKind::Floating => { - native_window.setLevel_(NSNormalWindowLevel); + if kind == WindowKind::Floating { + // Let the window float keep above normal windows. + native_window.setLevel_(NSFloatingWindowLevel); + } else { + native_window.setLevel_(NSNormalWindowLevel); + } native_window.setAcceptsMouseMovedEvents_(YES); if let Some(tabbing_identifier) = tabbing_identifier { @@ -816,10 +836,23 @@ impl MacWindow { NSWindowCollectionBehavior::NSWindowCollectionBehaviorFullScreenAuxiliary ); } + WindowKind::Dialog => { + if !main_window.is_null() { + let parent = { + let active_sheet: id = msg_send![main_window, attachedSheet]; + if active_sheet.is_null() { + main_window + } else { + active_sheet + } + }; + let _: () = + msg_send![parent, beginSheet: native_window completionHandler: nil]; + sheet_parent = Some(parent); + } + } } - let app = NSApplication::sharedApplication(nil); - let main_window: id = msg_send![app, mainWindow]; if allows_automatic_window_tabbing && !main_window.is_null() && main_window != native_window @@ -861,7 +894,11 @@ impl MacWindow { // the window position might be incorrect if the main screen (the screen that contains the window that has focus) // is different from the primary screen. NSWindow::setFrameTopLeftPoint_(native_window, window_rect.origin); - window.0.lock().move_traffic_light(); + { + let mut window_state = window.0.lock(); + window_state.move_traffic_light(); + window_state.sheet_parent = sheet_parent; + } pool.drain(); @@ -938,6 +975,7 @@ impl Drop for MacWindow { let mut this = self.0.lock(); this.renderer.destroy(); let window = this.native_window; + let sheet_parent = this.sheet_parent.take(); this.display_link.take(); unsafe { this.native_window.setDelegate_(nil); @@ -946,6 +984,9 @@ impl Drop for MacWindow { this.executor .spawn(async move { unsafe { + if let Some(parent) = sheet_parent { + let _: () = msg_send![parent, endSheet: window]; + } window.close(); window.autorelease(); } diff --git a/crates/gpui/src/platform/windows/events.rs b/crates/gpui/src/platform/windows/events.rs index f224a1bf3c47dc1a61c5e0216f5d7825cfc72533..1f0a4a0d28c2b266fb8588e4ce54251be010a78d 100644 --- a/crates/gpui/src/platform/windows/events.rs +++ b/crates/gpui/src/platform/windows/events.rs @@ -270,6 +270,14 @@ impl WindowsWindowInner { fn handle_destroy_msg(&self, handle: HWND) -> Option { let callback = { self.state.callbacks.close.take() }; + // Re-enable parent window if this was a modal dialog + if let Some(parent_hwnd) = self.parent_hwnd { + unsafe { + let _ = EnableWindow(parent_hwnd, true); + let _ = SetForegroundWindow(parent_hwnd); + } + } + if let Some(callback) = callback { callback(); } diff --git a/crates/gpui/src/platform/windows/window.rs b/crates/gpui/src/platform/windows/window.rs index 7ef92b4150e69424b68e9417dda377aa7f2e9cc0..3fcc29ad7864f8e45d27638bef489ffbf03788b2 100644 --- a/crates/gpui/src/platform/windows/window.rs +++ b/crates/gpui/src/platform/windows/window.rs @@ -83,6 +83,7 @@ pub(crate) struct WindowsWindowInner { pub(crate) validation_number: usize, pub(crate) main_receiver: flume::Receiver, pub(crate) platform_window_handle: HWND, + pub(crate) parent_hwnd: Option, } impl WindowsWindowState { @@ -241,6 +242,7 @@ impl WindowsWindowInner { main_receiver: context.main_receiver.clone(), platform_window_handle: context.platform_window_handle, system_settings: WindowsSystemSettings::new(context.display), + parent_hwnd: context.parent_hwnd, })) } @@ -368,6 +370,7 @@ struct WindowCreateContext { disable_direct_composition: bool, directx_devices: DirectXDevices, invalidate_devices: Arc, + parent_hwnd: Option, } impl WindowsWindow { @@ -390,6 +393,20 @@ impl WindowsWindow { invalidate_devices, } = creation_info; register_window_class(icon); + let parent_hwnd = if params.kind == WindowKind::Dialog { + let parent_window = unsafe { GetActiveWindow() }; + if parent_window.is_invalid() { + None + } else { + // Disable the parent window to make this dialog modal + unsafe { + EnableWindow(parent_window, false).as_bool(); + }; + Some(parent_window) + } + } else { + None + }; let hide_title_bar = params .titlebar .as_ref() @@ -416,8 +433,14 @@ impl WindowsWindow { if params.is_minimizable { dwstyle |= WS_MINIMIZEBOX; } + let dwexstyle = if params.kind == WindowKind::Dialog { + dwstyle |= WS_POPUP | WS_CAPTION; + WS_EX_DLGMODALFRAME + } else { + WS_EX_APPWINDOW + }; - (WS_EX_APPWINDOW, dwstyle) + (dwexstyle, dwstyle) }; if !disable_direct_composition { dwexstyle |= WS_EX_NOREDIRECTIONBITMAP; @@ -449,6 +472,7 @@ impl WindowsWindow { disable_direct_composition, directx_devices, invalidate_devices, + parent_hwnd, }; let creation_result = unsafe { CreateWindowExW( @@ -460,7 +484,7 @@ impl WindowsWindow { CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, - None, + parent_hwnd, None, Some(hinstance.into()), Some(&context as *const _ as *const _), From 2d071b0cb64e8368a4d0f7b4fa4cf0f4cf187fae Mon Sep 17 00:00:00 2001 From: Sean Hagstrom Date: Thu, 18 Dec 2025 07:45:55 -0800 Subject: [PATCH 189/266] editor: Fix git-hunk toggling for adjacent hunks (#43187) Closes #42934 Release Notes: - Fix toggling adjacent git-diff hunks based on the reported behaviour in #42934 --------- Co-authored-by: Jakub Konka --- crates/editor/src/editor_tests.rs | 90 +++++++++++++++++++++++++ crates/multi_buffer/src/multi_buffer.rs | 5 +- 2 files changed, 92 insertions(+), 3 deletions(-) diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs index 48e59f7b7420473054214572a2908215f98ffded..c0112c5eda406c9cb3b3b9d004d20853b710f6e1 100644 --- a/crates/editor/src/editor_tests.rs +++ b/crates/editor/src/editor_tests.rs @@ -20880,6 +20880,36 @@ async fn test_toggling_adjacent_diff_hunks(cx: &mut TestAppContext) { .to_string(), ); + cx.update_editor(|editor, window, cx| { + editor.move_up(&MoveUp, window, cx); + editor.toggle_selected_diff_hunks(&Default::default(), window, cx); + }); + cx.assert_state_with_diff( + indoc! { " + ˇone + - two + three + five + "} + .to_string(), + ); + + cx.update_editor(|editor, window, cx| { + editor.move_down(&MoveDown, window, cx); + editor.move_down(&MoveDown, window, cx); + editor.toggle_selected_diff_hunks(&Default::default(), window, cx); + }); + cx.assert_state_with_diff( + indoc! { " + one + - two + ˇthree + - four + five + "} + .to_string(), + ); + cx.set_state(indoc! { " one ˇTWO @@ -20919,6 +20949,66 @@ async fn test_toggling_adjacent_diff_hunks(cx: &mut TestAppContext) { ); } +#[gpui::test] +async fn test_toggling_adjacent_diff_hunks_2( + executor: BackgroundExecutor, + cx: &mut TestAppContext, +) { + init_test(cx, |_| {}); + + let mut cx = EditorTestContext::new(cx).await; + + let diff_base = r#" + lineA + lineB + lineC + lineD + "# + .unindent(); + + cx.set_state( + &r#" + ˇlineA1 + lineB + lineD + "# + .unindent(), + ); + cx.set_head_text(&diff_base); + executor.run_until_parked(); + + cx.update_editor(|editor, window, cx| { + editor.toggle_selected_diff_hunks(&ToggleSelectedDiffHunks, window, cx); + }); + executor.run_until_parked(); + cx.assert_state_with_diff( + r#" + - lineA + + ˇlineA1 + lineB + lineD + "# + .unindent(), + ); + + cx.update_editor(|editor, window, cx| { + editor.move_down(&MoveDown, window, cx); + editor.move_right(&MoveRight, window, cx); + editor.toggle_selected_diff_hunks(&ToggleSelectedDiffHunks, window, cx); + }); + executor.run_until_parked(); + cx.assert_state_with_diff( + r#" + - lineA + + lineA1 + lˇineB + - lineC + lineD + "# + .unindent(), + ); +} + #[gpui::test] async fn test_edits_around_expanded_deletion_hunks( executor: BackgroundExecutor, diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs index 5b343ecc5791c0f6f5f8a6d734cb79fc8226a8fa..0c0e87b60a7b8950f7461228c929503d516791e0 100644 --- a/crates/multi_buffer/src/multi_buffer.rs +++ b/crates/multi_buffer/src/multi_buffer.rs @@ -2610,9 +2610,8 @@ impl MultiBuffer { for range in ranges { let range = range.to_point(&snapshot); let start = snapshot.point_to_offset(Point::new(range.start.row, 0)); - let end = snapshot.point_to_offset(Point::new(range.end.row + 1, 0)); - let start = start.saturating_sub_usize(1); - let end = snapshot.len().min(end + 1usize); + let end = (snapshot.point_to_offset(Point::new(range.end.row + 1, 0)) + 1usize) + .min(snapshot.len()); cursor.seek(&start, Bias::Right); while let Some(item) = cursor.item() { if *cursor.start() >= end { From 7a62f01ea5b38e8db04fb1bed6fcb02ca01cc2d7 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 18 Dec 2025 13:08:46 -0300 Subject: [PATCH 190/266] agent_ui: Use display name for the message editor placeholder (#45264) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Follow up to a regression that happened when we introduced agent servers that made everywhere displaying agent names use the extension name instead of the display name. This has been since fixed in other places and this PR now updates the agent panel's message editor, too: | Before | After | |--------|--------| | Screenshot 2025-12-18 at 12  54 2@2x | Screenshot 2025-12-18 at 12  54@2x | Release Notes: - N/A --- crates/agent_ui/src/acp/thread_view.rs | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index ed61141b0ab824b81731953db7b5a32b90d0539b..8364fd8c0f4d8fd55df8f2e74e990e603029db78 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -338,7 +338,13 @@ impl AcpThreadView { let prompt_capabilities = Rc::new(RefCell::new(acp::PromptCapabilities::default())); let available_commands = Rc::new(RefCell::new(vec![])); - let placeholder = placeholder_text(agent.name().as_ref(), false); + let agent_server_store = project.read(cx).agent_server_store().clone(); + let agent_display_name = agent_server_store + .read(cx) + .agent_display_name(&ExternalAgentServerName(agent.name())) + .unwrap_or_else(|| agent.name()); + + let placeholder = placeholder_text(agent_display_name.as_ref(), false); let message_editor = cx.new(|cx| { let mut editor = MessageEditor::new( @@ -377,7 +383,6 @@ impl AcpThreadView { ) }); - let agent_server_store = project.read(cx).agent_server_store().clone(); let subscriptions = [ cx.observe_global_in::(window, Self::agent_ui_font_size_changed), cx.observe_global_in::(window, Self::agent_ui_font_size_changed), @@ -1498,7 +1503,13 @@ impl AcpThreadView { let has_commands = !available_commands.is_empty(); self.available_commands.replace(available_commands); - let new_placeholder = placeholder_text(self.agent.name().as_ref(), has_commands); + let agent_display_name = self + .agent_server_store + .read(cx) + .agent_display_name(&ExternalAgentServerName(self.agent.name())) + .unwrap_or_else(|| self.agent.name()); + + let new_placeholder = placeholder_text(agent_display_name.as_ref(), has_commands); self.message_editor.update(cx, |editor, cx| { editor.set_placeholder_text(&new_placeholder, window, cx); From f937c1931fe382ad08f0d96b529f8a0428166d7c Mon Sep 17 00:00:00 2001 From: Bennet Bo Fenner Date: Thu, 18 Dec 2025 17:21:41 +0100 Subject: [PATCH 191/266] rules_library: Only store built-in prompts when they are customized (#45112) Follow up to #45004 Release Notes: - N/A --- Cargo.lock | 2 + crates/agent/src/agent.rs | 2 +- crates/agent_ui/src/completion_provider.rs | 2 +- crates/git_ui/src/git_panel.rs | 13 +- crates/prompt_store/Cargo.toml | 5 + crates/prompt_store/src/prompt_store.rs | 257 ++++++++++++++++++--- crates/rules_library/src/rules_library.rs | 47 +--- 7 files changed, 249 insertions(+), 79 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1ec640d49c2135d35442f0bf23047be7991427eb..0d83b2b9b912ab112d9b38fd1ef1d5ff21f9049c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12648,6 +12648,8 @@ dependencies = [ "paths", "rope", "serde", + "strum 0.27.2", + "tempfile", "text", "util", "uuid", diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index 5e16f74682ef95a4e990ed5a124a0d6031acfb0e..43ed3b90f3556eb24e45440a7fe0038e7a1b9535 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -426,7 +426,7 @@ impl NativeAgent { .into_iter() .flat_map(|(contents, prompt_metadata)| match contents { Ok(contents) => Some(UserRulesContext { - uuid: prompt_metadata.id.user_id()?, + uuid: prompt_metadata.id.as_user()?, title: prompt_metadata.title.map(|title| title.to_string()), contents, }), diff --git a/crates/agent_ui/src/completion_provider.rs b/crates/agent_ui/src/completion_provider.rs index 206a2b3282b5471e8d5e8d18788519c3853dca55..a7b955b81ef3a7edccca98f15fa73bb40787a2c9 100644 --- a/crates/agent_ui/src/completion_provider.rs +++ b/crates/agent_ui/src/completion_provider.rs @@ -1586,7 +1586,7 @@ pub(crate) fn search_rules( None } else { Some(RulesContextEntry { - prompt_id: metadata.id.user_id()?, + prompt_id: metadata.id.as_user()?, title: metadata.title?, }) } diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs index 4e94a811510ee07707bf729040d41fc8b1eb922c..0f967e68d1fab829fb37b626c23ecfebe69fb5dd 100644 --- a/crates/git_ui/src/git_panel.rs +++ b/crates/git_ui/src/git_panel.rs @@ -58,7 +58,7 @@ use project::{ git_store::{GitStoreEvent, Repository, RepositoryEvent, RepositoryId, pending_op}, project_settings::{GitPathStyle, ProjectSettings}, }; -use prompt_store::{PromptId, PromptStore, RULES_FILE_NAMES}; +use prompt_store::{BuiltInPrompt, PromptId, PromptStore, RULES_FILE_NAMES}; use serde::{Deserialize, Serialize}; use settings::{Settings, SettingsStore, StatusStyle}; use std::future::Future; @@ -2579,25 +2579,26 @@ impl GitPanel { is_using_legacy_zed_pro: bool, cx: &mut AsyncApp, ) -> String { - const DEFAULT_PROMPT: &str = include_str!("commit_message_prompt.txt"); - // Remove this once we stop supporting legacy Zed Pro // In legacy Zed Pro, Git commit summary generation did not count as a // prompt. If the user changes the prompt, our classification will fail, // meaning that users will be charged for generating commit messages. if is_using_legacy_zed_pro { - return DEFAULT_PROMPT.to_string(); + return BuiltInPrompt::CommitMessage.default_content().to_string(); } let load = async { let store = cx.update(|cx| PromptStore::global(cx)).ok()?.await.ok()?; store - .update(cx, |s, cx| s.load(PromptId::CommitMessage, cx)) + .update(cx, |s, cx| { + s.load(PromptId::BuiltIn(BuiltInPrompt::CommitMessage), cx) + }) .ok()? .await .ok() }; - load.await.unwrap_or_else(|| DEFAULT_PROMPT.to_string()) + load.await + .unwrap_or_else(|| BuiltInPrompt::CommitMessage.default_content().to_string()) } /// Generates a commit message using an LLM. diff --git a/crates/prompt_store/Cargo.toml b/crates/prompt_store/Cargo.toml index 13bacbfad3bf2b5deb4a20af866f37dad47288ff..a7df9d13ee82da62838175029b9bdfd7c9375508 100644 --- a/crates/prompt_store/Cargo.toml +++ b/crates/prompt_store/Cargo.toml @@ -28,6 +28,11 @@ parking_lot.workspace = true paths.workspace = true rope.workspace = true serde.workspace = true +strum.workspace = true text.workspace = true util.workspace = true uuid.workspace = true + +[dev-dependencies] +gpui = { workspace = true, features = ["test-support"] } +tempfile.workspace = true diff --git a/crates/prompt_store/src/prompt_store.rs b/crates/prompt_store/src/prompt_store.rs index 7823f7a6957caf282f4ad7f1d6f884971364518e..2c45410c2aa172c8a4f7118a914cacca69ea7ca8 100644 --- a/crates/prompt_store/src/prompt_store.rs +++ b/crates/prompt_store/src/prompt_store.rs @@ -1,6 +1,6 @@ mod prompts; -use anyhow::{Context as _, Result, anyhow}; +use anyhow::{Result, anyhow}; use chrono::{DateTime, Utc}; use collections::HashMap; use futures::FutureExt as _; @@ -23,6 +23,7 @@ use std::{ path::PathBuf, sync::{Arc, atomic::AtomicBool}, }; +use strum::{EnumIter, IntoEnumIterator as _}; use text::LineEnding; use util::ResultExt; use uuid::Uuid; @@ -51,11 +52,51 @@ pub struct PromptMetadata { pub saved_at: DateTime, } +impl PromptMetadata { + fn builtin(builtin: BuiltInPrompt) -> Self { + Self { + id: PromptId::BuiltIn(builtin), + title: Some(builtin.title().into()), + default: false, + saved_at: DateTime::default(), + } + } +} + +/// Built-in prompts that have default content and can be customized by users. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, EnumIter)] +pub enum BuiltInPrompt { + CommitMessage, +} + +impl BuiltInPrompt { + pub fn title(&self) -> &'static str { + match self { + Self::CommitMessage => "Commit message", + } + } + + /// Returns the default content for this built-in prompt. + pub fn default_content(&self) -> &'static str { + match self { + Self::CommitMessage => include_str!("../../git_ui/src/commit_message_prompt.txt"), + } + } +} + +impl std::fmt::Display for BuiltInPrompt { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::CommitMessage => write!(f, "Commit message"), + } + } +} + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] #[serde(tag = "kind")] pub enum PromptId { User { uuid: UserPromptId }, - CommitMessage, + BuiltIn(BuiltInPrompt), } impl PromptId { @@ -63,31 +104,37 @@ impl PromptId { UserPromptId::new().into() } - pub fn user_id(&self) -> Option { + pub fn as_user(&self) -> Option { match self { Self::User { uuid } => Some(*uuid), - _ => None, + Self::BuiltIn { .. } => None, } } - pub fn is_built_in(&self) -> bool { + pub fn as_built_in(&self) -> Option { match self { - Self::User { .. } => false, - Self::CommitMessage => true, + Self::User { .. } => None, + Self::BuiltIn(builtin) => Some(*builtin), } } + pub fn is_built_in(&self) -> bool { + matches!(self, Self::BuiltIn { .. }) + } + pub fn can_edit(&self) -> bool { match self { - Self::User { .. } | Self::CommitMessage => true, + Self::User { .. } => true, + Self::BuiltIn(builtin) => match builtin { + BuiltInPrompt::CommitMessage => true, + }, } } +} - pub fn default_content(&self) -> Option<&'static str> { - match self { - Self::User { .. } => None, - Self::CommitMessage => Some(include_str!("../../git_ui/src/commit_message_prompt.txt")), - } +impl From for PromptId { + fn from(builtin: BuiltInPrompt) -> Self { + PromptId::BuiltIn(builtin) } } @@ -117,7 +164,7 @@ impl std::fmt::Display for PromptId { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { PromptId::User { uuid } => write!(f, "{}", uuid.0), - PromptId::CommitMessage => write!(f, "Commit message"), + PromptId::BuiltIn(builtin) => write!(f, "{}", builtin), } } } @@ -150,6 +197,16 @@ impl MetadataCache { cache.metadata.push(metadata.clone()); cache.metadata_by_id.insert(prompt_id, metadata); } + + // Insert all the built-in prompts that were not customized by the user + for builtin in BuiltInPrompt::iter() { + let builtin_id = PromptId::BuiltIn(builtin); + if !cache.metadata_by_id.contains_key(&builtin_id) { + let metadata = PromptMetadata::builtin(builtin); + cache.metadata.push(metadata.clone()); + cache.metadata_by_id.insert(builtin_id, metadata); + } + } cache.sort(); Ok(cache) } @@ -198,10 +255,6 @@ impl PromptStore { let mut txn = db_env.write_txn()?; let metadata = db_env.create_database(&mut txn, Some("metadata.v2"))?; let bodies = db_env.create_database(&mut txn, Some("bodies.v2"))?; - - metadata.delete(&mut txn, &PromptId::CommitMessage)?; - bodies.delete(&mut txn, &PromptId::CommitMessage)?; - txn.commit()?; Self::upgrade_dbs(&db_env, metadata, bodies).log_err(); @@ -294,7 +347,16 @@ impl PromptStore { let bodies = self.bodies; cx.background_spawn(async move { let txn = env.read_txn()?; - let mut prompt = bodies.get(&txn, &id)?.context("prompt not found")?.into(); + let mut prompt: String = match bodies.get(&txn, &id)? { + Some(body) => body.into(), + None => { + if let Some(built_in) = id.as_built_in() { + built_in.default_content().into() + } else { + anyhow::bail!("prompt not found") + } + } + }; LineEnding::normalize(&mut prompt); Ok(prompt) }) @@ -339,11 +401,6 @@ impl PromptStore { }) } - /// Returns the number of prompts in the store. - pub fn prompt_count(&self) -> usize { - self.metadata_cache.read().metadata.len() - } - pub fn metadata(&self, id: PromptId) -> Option { self.metadata_cache.read().metadata_by_id.get(&id).cloned() } @@ -412,23 +469,38 @@ impl PromptStore { return Task::ready(Err(anyhow!("this prompt cannot be edited"))); } - let prompt_metadata = PromptMetadata { - id, - title, - default, - saved_at: Utc::now(), + let body = body.to_string(); + let is_default_content = id + .as_built_in() + .is_some_and(|builtin| body.trim() == builtin.default_content().trim()); + + let metadata = if let Some(builtin) = id.as_built_in() { + PromptMetadata::builtin(builtin) + } else { + PromptMetadata { + id, + title, + default, + saved_at: Utc::now(), + } }; - self.metadata_cache.write().insert(prompt_metadata.clone()); + + self.metadata_cache.write().insert(metadata.clone()); let db_connection = self.env.clone(); let bodies = self.bodies; - let metadata = self.metadata; + let metadata_db = self.metadata; let task = cx.background_spawn(async move { let mut txn = db_connection.write_txn()?; - metadata.put(&mut txn, &id, &prompt_metadata)?; - bodies.put(&mut txn, &id, &body.to_string())?; + if is_default_content { + metadata_db.delete(&mut txn, &id)?; + bodies.delete(&mut txn, &id)?; + } else { + metadata_db.put(&mut txn, &id, &metadata)?; + bodies.put(&mut txn, &id, &body)?; + } txn.commit()?; @@ -490,3 +562,122 @@ impl PromptStore { pub struct GlobalPromptStore(Shared, Arc>>>); impl Global for GlobalPromptStore {} + +#[cfg(test)] +mod tests { + use super::*; + use gpui::TestAppContext; + + #[gpui::test] + async fn test_built_in_prompt_load_save(cx: &mut TestAppContext) { + cx.executor().allow_parking(); + + let temp_dir = tempfile::tempdir().unwrap(); + let db_path = temp_dir.path().join("prompts-db"); + + let store = cx.update(|cx| PromptStore::new(db_path, cx)).await.unwrap(); + let store = cx.new(|_cx| store); + + let commit_message_id = PromptId::BuiltIn(BuiltInPrompt::CommitMessage); + + let loaded_content = store + .update(cx, |store, cx| store.load(commit_message_id, cx)) + .await + .unwrap(); + + let mut expected_content = BuiltInPrompt::CommitMessage.default_content().to_string(); + LineEnding::normalize(&mut expected_content); + assert_eq!( + loaded_content.trim(), + expected_content.trim(), + "Loading a built-in prompt not in DB should return default content" + ); + + let metadata = store.read_with(cx, |store, _| store.metadata(commit_message_id)); + assert!( + metadata.is_some(), + "Built-in prompt should always have metadata" + ); + assert!( + store.read_with(cx, |store, _| { + store + .metadata_cache + .read() + .metadata_by_id + .contains_key(&commit_message_id) + }), + "Built-in prompt should always be in cache" + ); + + let custom_content = "Custom commit message prompt"; + store + .update(cx, |store, cx| { + store.save( + commit_message_id, + Some("Commit message".into()), + false, + Rope::from(custom_content), + cx, + ) + }) + .await + .unwrap(); + + let loaded_custom = store + .update(cx, |store, cx| store.load(commit_message_id, cx)) + .await + .unwrap(); + assert_eq!( + loaded_custom.trim(), + custom_content.trim(), + "Custom content should be loaded after saving" + ); + + assert!( + store + .read_with(cx, |store, _| store.metadata(commit_message_id)) + .is_some(), + "Built-in prompt should have metadata after customization" + ); + + store + .update(cx, |store, cx| { + store.save( + commit_message_id, + Some("Commit message".into()), + false, + Rope::from(BuiltInPrompt::CommitMessage.default_content()), + cx, + ) + }) + .await + .unwrap(); + + let metadata_after_reset = + store.read_with(cx, |store, _| store.metadata(commit_message_id)); + assert!( + metadata_after_reset.is_some(), + "Built-in prompt should still have metadata after reset" + ); + assert_eq!( + metadata_after_reset + .as_ref() + .and_then(|m| m.title.as_ref().map(|t| t.as_ref())), + Some("Commit message"), + "Built-in prompt should have default title after reset" + ); + + let loaded_after_reset = store + .update(cx, |store, cx| store.load(commit_message_id, cx)) + .await + .unwrap(); + let mut expected_content_after_reset = + BuiltInPrompt::CommitMessage.default_content().to_string(); + LineEnding::normalize(&mut expected_content_after_reset); + assert_eq!( + loaded_after_reset.trim(), + expected_content_after_reset.trim(), + "After saving default content, load should return default" + ); + } +} diff --git a/crates/rules_library/src/rules_library.rs b/crates/rules_library/src/rules_library.rs index 642d6b64f79ed0f52b9cdb7feee900cf87af83cc..fc6af46782f26615aa0f5faeb7062ca03181ab9b 100644 --- a/crates/rules_library/src/rules_library.rs +++ b/crates/rules_library/src/rules_library.rs @@ -3,9 +3,9 @@ use collections::{HashMap, HashSet}; use editor::{CompletionProvider, SelectionEffects}; use editor::{CurrentLineHighlight, Editor, EditorElement, EditorEvent, EditorStyle, actions::Tab}; use gpui::{ - Action, App, Bounds, DEFAULT_ADDITIONAL_WINDOW_SIZE, Entity, EventEmitter, Focusable, - PromptLevel, Subscription, Task, TextStyle, TitlebarOptions, WindowBounds, WindowHandle, - WindowOptions, actions, point, size, transparent_black, + App, Bounds, DEFAULT_ADDITIONAL_WINDOW_SIZE, Entity, EventEmitter, Focusable, PromptLevel, + Subscription, Task, TextStyle, TitlebarOptions, WindowBounds, WindowHandle, WindowOptions, + actions, point, size, transparent_black, }; use language::{Buffer, LanguageRegistry, language_settings::SoftWrap}; use language_model::{ @@ -21,7 +21,7 @@ use std::sync::atomic::AtomicBool; use std::time::Duration; use theme::ThemeSettings; use title_bar::platform_title_bar::PlatformTitleBar; -use ui::{Divider, KeyBinding, ListItem, ListItemSpacing, ListSubHeader, Tooltip, prelude::*}; +use ui::{Divider, ListItem, ListItemSpacing, ListSubHeader, Tooltip, prelude::*}; use util::{ResultExt, TryFutureExt}; use workspace::{Workspace, WorkspaceSettings, client_side_decorations}; use zed_actions::assistant::InlineAssist; @@ -206,13 +206,8 @@ impl PickerDelegate for RulePickerDelegate { self.filtered_entries.len() } - fn no_matches_text(&self, _window: &mut Window, cx: &mut App) -> Option { - let text = if self.store.read(cx).prompt_count() == 0 { - "No rules.".into() - } else { - "No rules found matching your search.".into() - }; - Some(text) + fn no_matches_text(&self, _window: &mut Window, _cx: &mut App) -> Option { + Some("No rules found matching your search.".into()) } fn selected_index(&self) -> usize { @@ -680,13 +675,13 @@ impl RulesLibrary { window: &mut Window, cx: &mut Context, ) { - let Some(default_content) = prompt_id.default_content() else { + let Some(built_in) = prompt_id.as_built_in() else { return; }; if let Some(rule_editor) = self.rule_editors.get(&prompt_id) { rule_editor.body_editor.update(cx, |editor, cx| { - editor.set_text(default_content, window, cx); + editor.set_text(built_in.default_content(), window, cx); }); } } @@ -1428,31 +1423,7 @@ impl Render for RulesLibrary { this.border_t_1().border_color(cx.theme().colors().border) }) .child(self.render_rule_list(cx)) - .map(|el| { - if self.store.read(cx).prompt_count() == 0 { - el.child( - v_flex() - .h_full() - .flex_1() - .items_center() - .justify_center() - .border_l_1() - .border_color(cx.theme().colors().border) - .bg(cx.theme().colors().editor_background) - .child( - Button::new("create-rule", "New Rule") - .style(ButtonStyle::Outlined) - .key_binding(KeyBinding::for_action(&NewRule, cx)) - .on_click(|_, window, cx| { - window - .dispatch_action(NewRule.boxed_clone(), cx) - }), - ), - ) - } else { - el.child(self.render_active_rule(cx)) - } - }), + .child(self.render_active_rule(cx)), ), window, cx, From 2a713c546b80cfc1dcf678953336f3758d1b152b Mon Sep 17 00:00:00 2001 From: tidely <43219534+tidely@users.noreply.github.com> Date: Thu, 18 Dec 2025 18:24:38 +0200 Subject: [PATCH 192/266] gpui: Small tab group performance improvements (#41885) Closes #ISSUE Removes a few eager container clones and iterations. Added a todo to `get_prev_tab_group_window` and `get_next_tab_group_window`. They seem to use `HashMap::keys()` for choosing the previous tab group, however `.keys()` returns an arbitrary order, so I'm not sure if previous actually means anything here. Conrad seems to have worked on this part previously, maybe he has some insights. That can possibly be a follow-up PR, but I'd be willing to work on it here as well since the other changes are so simple. Release Notes: - N/A --- crates/gpui/src/app.rs | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-) diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs index 7bd0daf56a466666b8cf5ae70f6b7cb5597a0d10..75600a9ee1b440a092a89456cbe8fbabe6fdccfa 100644 --- a/crates/gpui/src/app.rs +++ b/crates/gpui/src/app.rs @@ -316,6 +316,7 @@ impl SystemWindowTabController { .find_map(|(group, tabs)| tabs.iter().find(|tab| tab.id == id).map(|_| group)); let current_group = current_group?; + // TODO: `.keys()` returns arbitrary order, what does "next" mean? let mut group_ids: Vec<_> = controller.tab_groups.keys().collect(); let idx = group_ids.iter().position(|g| *g == current_group)?; let next_idx = (idx + 1) % group_ids.len(); @@ -340,6 +341,7 @@ impl SystemWindowTabController { .find_map(|(group, tabs)| tabs.iter().find(|tab| tab.id == id).map(|_| group)); let current_group = current_group?; + // TODO: `.keys()` returns arbitrary order, what does "previous" mean? let mut group_ids: Vec<_> = controller.tab_groups.keys().collect(); let idx = group_ids.iter().position(|g| *g == current_group)?; let prev_idx = if idx == 0 { @@ -361,12 +363,9 @@ impl SystemWindowTabController { /// Get all tabs in the same window. pub fn tabs(&self, id: WindowId) -> Option<&Vec> { - let tab_group = self - .tab_groups - .iter() - .find_map(|(group, tabs)| tabs.iter().find(|tab| tab.id == id).map(|_| *group))?; - - self.tab_groups.get(&tab_group) + self.tab_groups + .values() + .find(|tabs| tabs.iter().any(|tab| tab.id == id)) } /// Initialize the visibility of the system window tab controller. @@ -441,7 +440,7 @@ impl SystemWindowTabController { /// Insert a tab into a tab group. pub fn add_tab(cx: &mut App, id: WindowId, tabs: Vec) { let mut controller = cx.global_mut::(); - let Some(tab) = tabs.clone().into_iter().find(|tab| tab.id == id) else { + let Some(tab) = tabs.iter().find(|tab| tab.id == id).cloned() else { return; }; @@ -504,16 +503,14 @@ impl SystemWindowTabController { return; }; + let initial_tabs_len = initial_tabs.len(); let mut all_tabs = initial_tabs.clone(); - for tabs in controller.tab_groups.values() { - all_tabs.extend( - tabs.iter() - .filter(|tab| !initial_tabs.contains(tab)) - .cloned(), - ); + + for (_, mut tabs) in controller.tab_groups.drain() { + tabs.retain(|tab| !all_tabs[..initial_tabs_len].contains(tab)); + all_tabs.extend(tabs); } - controller.tab_groups.clear(); controller.tab_groups.insert(0, all_tabs); } From a85c508f69491b60b49340229390fdd5be6e42ed Mon Sep 17 00:00:00 2001 From: Jakub Konka Date: Thu, 18 Dec 2025 17:26:20 +0100 Subject: [PATCH 193/266] Fix self-referential symbolic link (#45265) Release Notes: - N/A --- crates/eval_utils/LICENSE-GPL | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/eval_utils/LICENSE-GPL b/crates/eval_utils/LICENSE-GPL index e0f9dbd5d63fef1630c297edc4ceba4790be6f02..89e542f750cd3860a0598eff0dc34b56d7336dc4 120000 --- a/crates/eval_utils/LICENSE-GPL +++ b/crates/eval_utils/LICENSE-GPL @@ -1 +1 @@ -LICENSE-GPL \ No newline at end of file +../../LICENSE-GPL \ No newline at end of file From 098adf3bdd9b875b8dcf360888d1aa0068265005 Mon Sep 17 00:00:00 2001 From: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> Date: Thu, 18 Dec 2025 17:29:25 +0100 Subject: [PATCH 194/266] gpui: Enable direct-to-display optimization for metal (#44334) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit When profiling Zed with Instruments, a warning appears indicating that surfaces cannot be pushed directly to the display as they are non-opaque. This happens because the metal layer is currently marked as non-opaque by default, even though the window itself is not transparent. image Metal on macOS can bypass compositing and present frames directly to the display when several conditions are met. One of those conditions is that the backing layer must be declared opaque. Apple’s documentation notes that marking layers as opaque allows the system to avoid unnecessary compositing work, reducing GPU load and improving frame pacing Ref: https://developer.apple.com/documentation/metal/managing-your-game-window-for-metal-in-macos This PR updates the Metal renderer to mark the layer as opaque whenever the window does not use transparency. This makes Zed eligible for macOS’s direct-to-display optimization in scenarios where the system can apply it. Release Notes: - gpui: Mark metal layers opaque for non-transparent windows to allow direct-to-display when supported --------- Signed-off-by: Marco Mihai Condrache <52580954+marcocondrache@users.noreply.github.com> --- crates/gpui/src/platform/mac/metal_renderer.rs | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/crates/gpui/src/platform/mac/metal_renderer.rs b/crates/gpui/src/platform/mac/metal_renderer.rs index 550041a0ccb4cd39bc7a86317d9540e806af2a28..66f54e5ba0c66a508f9db73d5ad8f84cb52d0d69 100644 --- a/crates/gpui/src/platform/mac/metal_renderer.rs +++ b/crates/gpui/src/platform/mac/metal_renderer.rs @@ -46,9 +46,9 @@ pub unsafe fn new_renderer( _native_window: *mut c_void, _native_view: *mut c_void, _bounds: crate::Size, - _transparent: bool, + transparent: bool, ) -> Renderer { - MetalRenderer::new(context) + MetalRenderer::new(context, transparent) } pub(crate) struct InstanceBufferPool { @@ -128,7 +128,7 @@ pub struct PathRasterizationVertex { } impl MetalRenderer { - pub fn new(instance_buffer_pool: Arc>) -> Self { + pub fn new(instance_buffer_pool: Arc>, transparent: bool) -> Self { // Prefer low‐power integrated GPUs on Intel Mac. On Apple // Silicon, there is only ever one GPU, so this is equivalent to // `metal::Device::system_default()`. @@ -152,8 +152,13 @@ impl MetalRenderer { let layer = metal::MetalLayer::new(); layer.set_device(&device); layer.set_pixel_format(MTLPixelFormat::BGRA8Unorm); - layer.set_opaque(false); + // Support direct-to-display rendering if the window is not transparent + // https://developer.apple.com/documentation/metal/managing-your-game-window-for-metal-in-macos + layer.set_opaque(!transparent); layer.set_maximum_drawable_count(3); + // We already present at display sync with the display link + // This allows to use direct-to-display even in window mode + layer.set_display_sync_enabled(false); unsafe { let _: () = msg_send![&*layer, setAllowsNextDrawableTimeout: NO]; let _: () = msg_send![&*layer, setNeedsDisplayOnBoundsChange: YES]; @@ -352,8 +357,8 @@ impl MetalRenderer { } } - pub fn update_transparency(&self, _transparent: bool) { - // todo(mac)? + pub fn update_transparency(&self, transparent: bool) { + self.layer.set_opaque(!transparent); } pub fn destroy(&self) { From e10b9b70efafa8d2ede3175528eaf7f3c44b06b4 Mon Sep 17 00:00:00 2001 From: Leo Date: Fri, 19 Dec 2025 00:45:26 +0800 Subject: [PATCH 195/266] git: Add global git integration enable/disable setting (#43326) Closes #13304 Release Notes: - Add global `git status` and `git diff` on/off in one place instead of control everywhere We can first review to ensure this change meets both `Zed` and user requirements, as well as code rules. Currently, we only support user-level settings. We can wait for this PR: https://github.com/zed-industries/zed/pull/43173 to be merged, then modify it to support both user and project levels. --- assets/settings/default.json | 8 ++ crates/editor/src/editor_settings.rs | 3 +- .../src/outline_panel_settings.rs | 8 +- crates/project/src/project_settings.rs | 23 +++++ .../src/project_panel_settings.rs | 8 +- .../settings/src/settings_content/project.rs | 24 +++++ crates/settings_ui/src/page_data.rs | 96 +++++++++++++++++++ crates/workspace/src/item.rs | 8 +- 8 files changed, 174 insertions(+), 4 deletions(-) diff --git a/assets/settings/default.json b/assets/settings/default.json index e7df5ef0bf2d3bc805c79f79811d9929343544ef..154fe2d6e34e6573e95e7ffedbb46df8bbf10634 100644 --- a/assets/settings/default.json +++ b/assets/settings/default.json @@ -1321,6 +1321,14 @@ "hidden_files": ["**/.*"], // Git gutter behavior configuration. "git": { + // Global switch to enable or disable all git integration features. + // If set to true, disables all git integration features. + // If set to false, individual git integration features below will be independently enabled or disabled. + "disable_git": false, + // Whether to enable git status tracking. + "enable_status": true, + // Whether to enable git diff display. + "enable_diff": true, // Control whether the git gutter is shown. May take 2 values: // 1. Show the gutter // "git_gutter": "tracked_files" diff --git a/crates/editor/src/editor_settings.rs b/crates/editor/src/editor_settings.rs index e1984311d4eb0ba9d989f77a707b22698b00c750..464157202f4821c8f05af479d2eff9f441a961ef 100644 --- a/crates/editor/src/editor_settings.rs +++ b/crates/editor/src/editor_settings.rs @@ -215,7 +215,8 @@ impl Settings for EditorSettings { }, scrollbar: Scrollbar { show: scrollbar.show.map(Into::into).unwrap(), - git_diff: scrollbar.git_diff.unwrap(), + git_diff: scrollbar.git_diff.unwrap() + && content.git.unwrap().enabled.unwrap().is_git_diff_enabled(), selected_text: scrollbar.selected_text.unwrap(), selected_symbol: scrollbar.selected_symbol.unwrap(), search_results: scrollbar.search_results.unwrap(), diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rs index b2b1a6fe685c18853087d3eb04edeef2ceebd89f..bf73aebecc194baca0156c9cdb850ed89627e001 100644 --- a/crates/outline_panel/src/outline_panel_settings.rs +++ b/crates/outline_panel/src/outline_panel_settings.rs @@ -50,7 +50,13 @@ impl Settings for OutlinePanelSettings { dock: panel.dock.unwrap(), file_icons: panel.file_icons.unwrap(), folder_icons: panel.folder_icons.unwrap(), - git_status: panel.git_status.unwrap(), + git_status: panel.git_status.unwrap() + && content + .git + .unwrap() + .enabled + .unwrap() + .is_git_status_enabled(), indent_size: panel.indent_size.unwrap(), indent_guides: IndentGuidesSettings { show: panel.indent_guides.unwrap().show.unwrap(), diff --git a/crates/project/src/project_settings.rs b/crates/project/src/project_settings.rs index 6d95411681d5d350271e7071b752f27d0807f60d..633f2bbd3b40139f6355e109211d665cfd0c1e5f 100644 --- a/crates/project/src/project_settings.rs +++ b/crates/project/src/project_settings.rs @@ -332,6 +332,10 @@ impl GoToDiagnosticSeverityFilter { #[derive(Copy, Clone, Debug)] pub struct GitSettings { + /// Whether or not git integration is enabled. + /// + /// Default: true + pub enabled: GitEnabledSettings, /// Whether or not to show the git gutter. /// /// Default: tracked_files @@ -361,6 +365,18 @@ pub struct GitSettings { pub path_style: GitPathStyle, } +#[derive(Clone, Copy, Debug)] +pub struct GitEnabledSettings { + /// Whether git integration is enabled for showing git status. + /// + /// Default: true + pub status: bool, + /// Whether git integration is enabled for showing diffs. + /// + /// Default: true + pub diff: bool, +} + #[derive(Clone, Copy, Debug, PartialEq, Default)] pub enum GitPathStyle { #[default] @@ -502,7 +518,14 @@ impl Settings for ProjectSettings { let inline_diagnostics = diagnostics.inline.as_ref().unwrap(); let git = content.git.as_ref().unwrap(); + let git_enabled = { + GitEnabledSettings { + status: git.enabled.as_ref().unwrap().is_git_status_enabled(), + diff: git.enabled.as_ref().unwrap().is_git_diff_enabled(), + } + }; let git_settings = GitSettings { + enabled: git_enabled, git_gutter: git.git_gutter.unwrap(), gutter_debounce: git.gutter_debounce.unwrap_or_default(), inline_blame: { diff --git a/crates/project_panel/src/project_panel_settings.rs b/crates/project_panel/src/project_panel_settings.rs index b0316270340203177278edebaececd0d86e39869..5d498da0f9d519bc25d738bcf9368c394bbdabfd 100644 --- a/crates/project_panel/src/project_panel_settings.rs +++ b/crates/project_panel/src/project_panel_settings.rs @@ -92,7 +92,13 @@ impl Settings for ProjectPanelSettings { entry_spacing: project_panel.entry_spacing.unwrap(), file_icons: project_panel.file_icons.unwrap(), folder_icons: project_panel.folder_icons.unwrap(), - git_status: project_panel.git_status.unwrap(), + git_status: project_panel.git_status.unwrap() + && content + .git + .unwrap() + .enabled + .unwrap() + .is_git_status_enabled(), indent_size: project_panel.indent_size.unwrap(), indent_guides: IndentGuidesSettings { show: project_panel.indent_guides.unwrap().show.unwrap(), diff --git a/crates/settings/src/settings_content/project.rs b/crates/settings/src/settings_content/project.rs index a5e15153832c425134e129cba1984b3b5886aa56..8e2d864149c9ecb6ca38ca73ef58205f588dc07b 100644 --- a/crates/settings/src/settings_content/project.rs +++ b/crates/settings/src/settings_content/project.rs @@ -288,6 +288,11 @@ impl std::fmt::Debug for ContextServerCommand { #[with_fallible_options] #[derive(Copy, Clone, Debug, PartialEq, Default, Serialize, Deserialize, JsonSchema, MergeFrom)] pub struct GitSettings { + /// Whether or not to enable git integration. + /// + /// Default: true + #[serde(flatten)] + pub enabled: Option, /// Whether or not to show the git gutter. /// /// Default: tracked_files @@ -317,6 +322,25 @@ pub struct GitSettings { pub path_style: Option, } +#[with_fallible_options] +#[derive(Clone, Copy, Debug, PartialEq, Default, Serialize, Deserialize, JsonSchema, MergeFrom)] +#[serde(rename_all = "snake_case")] +pub struct GitEnabledSettings { + pub disable_git: Option, + pub enable_status: Option, + pub enable_diff: Option, +} + +impl GitEnabledSettings { + pub fn is_git_status_enabled(&self) -> bool { + !self.disable_git.unwrap_or(false) && self.enable_status.unwrap_or(true) + } + + pub fn is_git_diff_enabled(&self) -> bool { + !self.disable_git.unwrap_or(false) && self.enable_diff.unwrap_or(true) + } +} + #[derive( Clone, Copy, diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rs index c8775bad42a9a8bd6aa5e57bafbb817b99619e68..ca2e23252a4483b365c7c42cfd086105d757a097 100644 --- a/crates/settings_ui/src/page_data.rs +++ b/crates/settings_ui/src/page_data.rs @@ -5519,6 +5519,102 @@ pub(crate) fn settings_data(cx: &App) -> Vec { SettingsPage { title: "Version Control", items: vec![ + SettingsPageItem::SectionHeader("Git Integration"), + SettingsPageItem::DynamicItem(DynamicItem { + discriminant: SettingItem { + files: USER, + title: "Disable Git Integration", + description: "Disable all Git integration features in Zed.", + field: Box::new(SettingField:: { + json_path: Some("git.disable_git"), + pick: |settings_content| { + settings_content + .git + .as_ref()? + .enabled + .as_ref()? + .disable_git + .as_ref() + }, + write: |settings_content, value| { + settings_content + .git + .get_or_insert_default() + .enabled + .get_or_insert_default() + .disable_git = value; + }, + }), + metadata: None, + }, + pick_discriminant: |settings_content| { + let disabled = settings_content + .git + .as_ref()? + .enabled + .as_ref()? + .disable_git + .unwrap_or(false); + Some(if disabled { 0 } else { 1 }) + }, + fields: vec![ + vec![], + vec![ + SettingItem { + files: USER, + title: "Enable Git Status", + description: "Show Git status information in the editor.", + field: Box::new(SettingField:: { + json_path: Some("git.enable_status"), + pick: |settings_content| { + settings_content + .git + .as_ref()? + .enabled + .as_ref()? + .enable_status + .as_ref() + }, + write: |settings_content, value| { + settings_content + .git + .get_or_insert_default() + .enabled + .get_or_insert_default() + .enable_status = value; + }, + }), + metadata: None, + }, + SettingItem { + files: USER, + title: "Enable Git Diff", + description: "Show Git diff information in the editor.", + field: Box::new(SettingField:: { + json_path: Some("git.enable_diff"), + pick: |settings_content| { + settings_content + .git + .as_ref()? + .enabled + .as_ref()? + .enable_diff + .as_ref() + }, + write: |settings_content, value| { + settings_content + .git + .get_or_insert_default() + .enabled + .get_or_insert_default() + .enable_diff = value; + }, + }), + metadata: None, + }, + ], + ], + }), SettingsPageItem::SectionHeader("Git Gutter"), SettingsPageItem::SettingItem(SettingItem { title: "Visibility", diff --git a/crates/workspace/src/item.rs b/crates/workspace/src/item.rs index 1570c125fa33135631d8181359ad34bb7802ec5f..6e415c23454388bc7931ff9d5e499924d6b8f55d 100644 --- a/crates/workspace/src/item.rs +++ b/crates/workspace/src/item.rs @@ -76,7 +76,13 @@ impl Settings for ItemSettings { fn from_settings(content: &settings::SettingsContent) -> Self { let tabs = content.tabs.as_ref().unwrap(); Self { - git_status: tabs.git_status.unwrap(), + git_status: tabs.git_status.unwrap() + && content + .git + .unwrap() + .enabled + .unwrap() + .is_git_status_enabled(), close_position: tabs.close_position.unwrap(), activate_on_close: tabs.activate_on_close.unwrap(), file_icons: tabs.file_icons.unwrap(), From f58278aaf41d0ae347fe947a9d5b052a89eea9d9 Mon Sep 17 00:00:00 2001 From: Emmanuel Amoah <42612171+emamoah@users.noreply.github.com> Date: Thu, 18 Dec 2025 17:03:46 +0000 Subject: [PATCH 196/266] glossary: Fix grammar and typo (#45267) Fixes grammar and a typo in `Picker` description. Release Notes: - N/A --- docs/src/development/glossary.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/src/development/glossary.md b/docs/src/development/glossary.md index 34172ec9a590fdae537ff78920e1fadda2c331fa..0e0f984e214fe1a46e0aff790ab5e85bb46a8674 100644 --- a/docs/src/development/glossary.md +++ b/docs/src/development/glossary.md @@ -73,7 +73,7 @@ h_flex() - `Window`: A struct in zed representing a zed window in your desktop environment (see image below). There can be multiple if you have multiple zed instances open. Mostly passed around for rendering. - `Modal`: A UI element that floats on top of the rest of the UI -- `Picker`: A struct representing a list of items in floating on top of the UI (Modal). You can select an item and confirm. What happens on select or confirm is determined by the picker's delegate. (The 'Model' in the image below is a picker.) +- `Picker`: A struct representing a list of items floating on top of the UI (Modal). You can select an item and confirm. What happens on select or confirm is determined by the picker's delegate. (The 'Modal' in the image below is a picker.) - `PickerDelegate`: A trait used to specialize behavior for a `Picker`. The `Picker` stores the `PickerDelegate` in the field delegate. - `Center`: The middle of the zed window, the center is split into multiple `Pane`s. In the codebase this is a field on the `Workspace` struct. (see image below). - `Pane`: An area in the `Center` where we can place items, such as an editor, multi-buffer or terminal (see image below). From 334ca218577b59b0ad55afb28531c66c964c2f89 Mon Sep 17 00:00:00 2001 From: Gaauwe Rombouts Date: Thu, 18 Dec 2025 18:05:53 +0100 Subject: [PATCH 197/266] Truncate code actions with a long label and show full label aside (#45268) Closes #43355 Fixes the issue were code actions with long labels would get cut off without being able to see the full description. We now properly truncate those labels with an ellipsis and show the full description in an aside. Release Notes: - Added ellipsis to truncated code actions and an aside showing the full action description. --- crates/editor/src/code_context_menus.rs | 151 ++++++++++---------- crates/gpui/src/text_system/line_wrapper.rs | 45 ++++-- 2 files changed, 106 insertions(+), 90 deletions(-) diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs index d255effdb72a003014dff0805fa34a23d11c8c81..2336a38fa7767fa6184608066f69d3b0520234ff 100644 --- a/crates/editor/src/code_context_menus.rs +++ b/crates/editor/src/code_context_menus.rs @@ -51,6 +51,8 @@ pub const MENU_ASIDE_MIN_WIDTH: Pixels = px(260.); pub const MENU_ASIDE_MAX_WIDTH: Pixels = px(500.); pub const COMPLETION_MENU_MIN_WIDTH: Pixels = px(280.); pub const COMPLETION_MENU_MAX_WIDTH: Pixels = px(540.); +pub const CODE_ACTION_MENU_MIN_WIDTH: Pixels = px(220.); +pub const CODE_ACTION_MENU_MAX_WIDTH: Pixels = px(540.); // Constants for the markdown cache. The purpose of this cache is to reduce flickering due to // documentation not yet being parsed. @@ -179,7 +181,7 @@ impl CodeContextMenu { ) -> Option { match self { CodeContextMenu::Completions(menu) => menu.render_aside(max_size, window, cx), - CodeContextMenu::CodeActions(_) => None, + CodeContextMenu::CodeActions(menu) => menu.render_aside(max_size, window, cx), } } @@ -1419,26 +1421,6 @@ pub enum CodeActionsItem { } impl CodeActionsItem { - fn as_task(&self) -> Option<&ResolvedTask> { - let Self::Task(_, task) = self else { - return None; - }; - Some(task) - } - - fn as_code_action(&self) -> Option<&CodeAction> { - let Self::CodeAction { action, .. } = self else { - return None; - }; - Some(action) - } - fn as_debug_scenario(&self) -> Option<&DebugScenario> { - let Self::DebugScenario(scenario) = self else { - return None; - }; - Some(scenario) - } - pub fn label(&self) -> String { match self { Self::CodeAction { action, .. } => action.lsp_action.title().to_owned(), @@ -1446,6 +1428,14 @@ impl CodeActionsItem { Self::DebugScenario(scenario) => scenario.label.to_string(), } } + + pub fn menu_label(&self) -> String { + match self { + Self::CodeAction { action, .. } => action.lsp_action.title().replace("\n", ""), + Self::Task(_, task) => task.resolved_label.replace("\n", ""), + Self::DebugScenario(scenario) => format!("debug: {}", scenario.label), + } + } } pub struct CodeActionsMenu { @@ -1555,60 +1545,33 @@ impl CodeActionsMenu { let item_ix = range.start + ix; let selected = item_ix == selected_item; let colors = cx.theme().colors(); - div().min_w(px(220.)).max_w(px(540.)).child( - ListItem::new(item_ix) - .inset(true) - .toggle_state(selected) - .when_some(action.as_code_action(), |this, action| { - this.child( - h_flex() - .overflow_hidden() - .when(is_quick_action_bar, |this| this.text_ui(cx)) - .child( - // TASK: It would be good to make lsp_action.title a SharedString to avoid allocating here. - action.lsp_action.title().replace("\n", ""), - ) - .when(selected, |this| { - this.text_color(colors.text_accent) - }), - ) - }) - .when_some(action.as_task(), |this, task| { - this.child( - h_flex() - .overflow_hidden() - .when(is_quick_action_bar, |this| this.text_ui(cx)) - .child(task.resolved_label.replace("\n", "")) - .when(selected, |this| { - this.text_color(colors.text_accent) - }), - ) - }) - .when_some(action.as_debug_scenario(), |this, scenario| { - this.child( - h_flex() - .overflow_hidden() - .when(is_quick_action_bar, |this| this.text_ui(cx)) - .child("debug: ") - .child(scenario.label.clone()) - .when(selected, |this| { - this.text_color(colors.text_accent) - }), - ) - }) - .on_click(cx.listener(move |editor, _, window, cx| { - cx.stop_propagation(); - if let Some(task) = editor.confirm_code_action( - &ConfirmCodeAction { - item_ix: Some(item_ix), - }, - window, - cx, - ) { - task.detach_and_log_err(cx) - } - })), - ) + + ListItem::new(item_ix) + .inset(true) + .toggle_state(selected) + .overflow_x() + .child( + div() + .min_w(CODE_ACTION_MENU_MIN_WIDTH) + .max_w(CODE_ACTION_MENU_MAX_WIDTH) + .overflow_hidden() + .text_ellipsis() + .when(is_quick_action_bar, |this| this.text_ui(cx)) + .when(selected, |this| this.text_color(colors.text_accent)) + .child(action.menu_label()), + ) + .on_click(cx.listener(move |editor, _, window, cx| { + cx.stop_propagation(); + if let Some(task) = editor.confirm_code_action( + &ConfirmCodeAction { + item_ix: Some(item_ix), + }, + window, + cx, + ) { + task.detach_and_log_err(cx) + } + })) }) .collect() }), @@ -1635,4 +1598,42 @@ impl CodeActionsMenu { Popover::new().child(list).into_any_element() } + + fn render_aside( + &mut self, + max_size: Size, + window: &mut Window, + _cx: &mut Context, + ) -> Option { + let Some(action) = self.actions.get(self.selected_item) else { + return None; + }; + + let label = action.menu_label(); + let text_system = window.text_system(); + let mut line_wrapper = text_system.line_wrapper( + window.text_style().font(), + window.text_style().font_size.to_pixels(window.rem_size()), + ); + let is_truncated = + line_wrapper.should_truncate_line(&label, CODE_ACTION_MENU_MAX_WIDTH, "…"); + + if is_truncated.is_none() { + return None; + } + + Some( + Popover::new() + .child( + div() + .child(label) + .id("code_actions_menu_extended") + .px(MENU_ASIDE_X_PADDING / 2.) + .max_w(max_size.width) + .max_h(max_size.height) + .occlude(), + ) + .into_any_element(), + ) + } } diff --git a/crates/gpui/src/text_system/line_wrapper.rs b/crates/gpui/src/text_system/line_wrapper.rs index e4e18671a3d85c2f55abd8f8a61ec80833dabdf5..95cd55d04443c6b2c351bf8533ccb57d49e8dcd9 100644 --- a/crates/gpui/src/text_system/line_wrapper.rs +++ b/crates/gpui/src/text_system/line_wrapper.rs @@ -128,22 +128,21 @@ impl LineWrapper { }) } - /// Truncate a line of text to the given width with this wrapper's font and font size. - pub fn truncate_line<'a>( + /// Determines if a line should be truncated based on its width. + pub fn should_truncate_line( &mut self, - line: SharedString, + line: &str, truncate_width: Pixels, truncation_suffix: &str, - runs: &'a [TextRun], - ) -> (SharedString, Cow<'a, [TextRun]>) { + ) -> Option { let mut width = px(0.); - let mut suffix_width = truncation_suffix + let suffix_width = truncation_suffix .chars() .map(|c| self.width_for_char(c)) .fold(px(0.0), |a, x| a + x); - let mut char_indices = line.char_indices(); let mut truncate_ix = 0; - for (ix, c) in char_indices { + + for (ix, c) in line.char_indices() { if width + suffix_width < truncate_width { truncate_ix = ix; } @@ -152,16 +151,32 @@ impl LineWrapper { width += char_width; if width.floor() > truncate_width { - let result = - SharedString::from(format!("{}{}", &line[..truncate_ix], truncation_suffix)); - let mut runs = runs.to_vec(); - update_runs_after_truncation(&result, truncation_suffix, &mut runs); - - return (result, Cow::Owned(runs)); + return Some(truncate_ix); } } - (line, Cow::Borrowed(runs)) + None + } + + /// Truncate a line of text to the given width with this wrapper's font and font size. + pub fn truncate_line<'a>( + &mut self, + line: SharedString, + truncate_width: Pixels, + truncation_suffix: &str, + runs: &'a [TextRun], + ) -> (SharedString, Cow<'a, [TextRun]>) { + if let Some(truncate_ix) = + self.should_truncate_line(&line, truncate_width, truncation_suffix) + { + let result = + SharedString::from(format!("{}{}", &line[..truncate_ix], truncation_suffix)); + let mut runs = runs.to_vec(); + update_runs_after_truncation(&result, truncation_suffix, &mut runs); + (result, Cow::Owned(runs)) + } else { + (line, Cow::Borrowed(runs)) + } } /// Any character in this list should be treated as a word character, From 1b6d588413460823a6dcfb53319c25ea2e8a1641 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Thu, 18 Dec 2025 13:42:28 -0500 Subject: [PATCH 198/266] danger: Deny conventional commits in PR titles (#45283) This PR upgrades `danger-plugin-pr-hygiene` to v0.7.0 so that we can have Danger deny conventional commits in PR titles. Release Notes: - N/A --- script/danger/dangerfile.ts | 3 +++ script/danger/package.json | 2 +- script/danger/pnpm-lock.yaml | 10 +++++----- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/script/danger/dangerfile.ts b/script/danger/dangerfile.ts index 88dc5c5e71c640a83315ac5f1b14c216763023fd..7151985021f3fdfb75c01c6e2f8c964fa51d3740 100644 --- a/script/danger/dangerfile.ts +++ b/script/danger/dangerfile.ts @@ -6,6 +6,9 @@ prHygiene({ rules: { // Don't enable this rule just yet, as it can have false positives. useImperativeMood: "off", + noConventionalCommits: { + bannedTypes: ["feat", "fix", "style", "refactor", "perf", "test", "chore", "build", "revert"], + }, }, }); diff --git a/script/danger/package.json b/script/danger/package.json index eaa1035e89c97da8ef2089e97eb638d649ee6877..74862c142468c1297a1d4aad8dcc468b6ddf5798 100644 --- a/script/danger/package.json +++ b/script/danger/package.json @@ -8,6 +8,6 @@ }, "devDependencies": { "danger": "13.0.4", - "danger-plugin-pr-hygiene": "0.6.1" + "danger-plugin-pr-hygiene": "0.7.0" } } diff --git a/script/danger/pnpm-lock.yaml b/script/danger/pnpm-lock.yaml index fd6b3f66acb627d57520e4ca928cc8ce2793b4b9..942d027cc80bf5d81ffa8b5bf739963430e939a3 100644 --- a/script/danger/pnpm-lock.yaml +++ b/script/danger/pnpm-lock.yaml @@ -12,8 +12,8 @@ importers: specifier: 13.0.4 version: 13.0.4 danger-plugin-pr-hygiene: - specifier: 0.6.1 - version: 0.6.1 + specifier: 0.7.0 + version: 0.7.0 packages: @@ -134,8 +134,8 @@ packages: core-js@3.45.1: resolution: {integrity: sha512-L4NPsJlCfZsPeXukyzHFlg/i7IIVwHSItR0wg0FLNqYClJ4MQYTYLbC7EkjKYRLZF2iof2MUgN0EGy7MdQFChg==} - danger-plugin-pr-hygiene@0.6.1: - resolution: {integrity: sha512-nb+iUQvirE3BlKXI1WoOND6sujyGzHar590mJm5tt4RLi65HXFaU5hqONxgDoWFujJNHYnXse9yaZdxnxEi4QA==} + danger-plugin-pr-hygiene@0.7.0: + resolution: {integrity: sha512-YDWhEodP0fg/t9YO3SxufWS9j1Rcxbig+1flTlUlojBDFiKQyVmaj8PIvnJxJItjHWTlNKI9wMSRq5vUql6zyA==} danger@13.0.4: resolution: {integrity: sha512-IAdQ5nSJyIs4zKj6AN35ixt2B0Ce3WZUm3IFe/CMnL/Op7wV7IGg4D348U0EKNaNPP58QgXbdSk9pM+IXP1QXg==} @@ -573,7 +573,7 @@ snapshots: core-js@3.45.1: {} - danger-plugin-pr-hygiene@0.6.1: {} + danger-plugin-pr-hygiene@0.7.0: {} danger@13.0.4: dependencies: From 413f4ea49c993ed531c32a4743c07850dda2f63f Mon Sep 17 00:00:00 2001 From: Peter Tripp Date: Thu, 18 Dec 2025 14:05:14 -0500 Subject: [PATCH 199/266] Redact environment variables from language server spawn errors (#44783) Redact environment variables from zed logs when lsp fails to spawn. Release Notes: - N/A --- crates/project/src/lsp_store.rs | 8 ++++++-- crates/util/src/redact.rs | 34 +++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 2 deletions(-) diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 6696ec8c4c280199a55d098ab63a321f126eea5e..5093b6977a1bffe82339ede00d2e6e4b4b14b4c1 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -128,6 +128,7 @@ use util::{ ConnectionResult, ResultExt as _, debug_panic, defer, maybe, merge_json_value_into, paths::{PathStyle, SanitizedPath}, post_inc, + redact::redact_command, rel_path::RelPath, }; @@ -577,9 +578,12 @@ impl LocalLspStore { }, }, ); - log::error!("Failed to start language server {server_name:?}: {err:?}"); + log::error!( + "Failed to start language server {server_name:?}: {}", + redact_command(&format!("{err:?}")) + ); if !log.is_empty() { - log::error!("server stderr: {log}"); + log::error!("server stderr: {}", redact_command(&log)); } None } diff --git a/crates/util/src/redact.rs b/crates/util/src/redact.rs index 6b297dfb58bb0b4537d4032d8f9cf4db845f9d78..ad11f7618b1cf57c27e7367845cf66e9d0e6bd0b 100644 --- a/crates/util/src/redact.rs +++ b/crates/util/src/redact.rs @@ -1,3 +1,9 @@ +use std::sync::LazyLock; + +static REDACT_REGEX: LazyLock = LazyLock::new(|| { + regex::Regex::new(r#"([A-Z_][A-Z0-9_]*)=("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+)"#).unwrap() +}); + /// Whether a given environment variable name should have its value redacted pub fn should_redact(env_var_name: &str) -> bool { const REDACTED_SUFFIXES: &[&str] = &[ @@ -13,3 +19,31 @@ pub fn should_redact(env_var_name: &str) -> bool { .iter() .any(|suffix| env_var_name.ends_with(suffix)) } + +/// Redact a string which could include a command with environment variables +pub fn redact_command(command: &str) -> String { + REDACT_REGEX + .replace_all(command, |caps: ®ex::Captures| { + let var_name = &caps[1]; + let value = &caps[2]; + if should_redact(var_name) { + format!(r#"{}="[REDACTED]""#, var_name) + } else { + format!("{}={}", var_name, value) + } + }) + .to_string() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_redact_string_with_multiple_env_vars() { + let input = r#"failed to spawn command cd "/code/something" && ANTHROPIC_API_KEY="sk-ant-api03-WOOOO" COMMAND_MODE="unix2003" GEMINI_API_KEY="AIGEMINIFACE" HOME="/Users/foo""#; + let result = redact_command(input); + let expected = r#"failed to spawn command cd "/code/something" && ANTHROPIC_API_KEY="[REDACTED]" COMMAND_MODE="unix2003" GEMINI_API_KEY="[REDACTED]" HOME="/Users/foo""#; + assert_eq!(result, expected); + } +} From d2bbfbb3bf80b322adff20a28e71477455730054 Mon Sep 17 00:00:00 2001 From: Julia Ryan Date: Thu, 18 Dec 2025 11:09:40 -0800 Subject: [PATCH 200/266] lsp: Broadcast our capability for `MessageActionItem`s (#45047) Closes #37902 Release Notes: - Enable LSP Message action items for more language servers. These are interactive prompts, often for things like downloading build inputs for a project. --- crates/lsp/src/lsp.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index 9ff6e245c49d771c162ca55fa98bbd7ca37d7bd0..faa094153d4a26fb1a2b96360f2691989e81aad9 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -882,7 +882,9 @@ impl LanguageServer { window: Some(WindowClientCapabilities { work_done_progress: Some(true), show_message: Some(ShowMessageRequestClientCapabilities { - message_action_item: None, + message_action_item: Some(MessageActionItemCapabilities { + additional_properties_support: Some(true), + }), }), ..WindowClientCapabilities::default() }), From af589ff25fa817a58cfffddaf0b5dcfb965dd3f9 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 18 Dec 2025 17:49:17 -0300 Subject: [PATCH 201/266] agent_ui: Simplify timestamp display (#45296) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This PR simplifies how we display thread timestamps in the agent panel's history view. For threads that are older-than-yesterday, we just show how many days ago that thread was had in. Hovering over the thread item shows you both the title and the full date, if needed (time and date). Screenshot 2025-12-18 at 5  24@2x Release Notes: - N/A --- crates/agent_ui/src/acp/thread_history.rs | 24 ++++++++++++++++++++--- crates/agent_ui_v2/src/thread_history.rs | 24 ++++++++++++++++++++--- 2 files changed, 42 insertions(+), 6 deletions(-) diff --git a/crates/agent_ui/src/acp/thread_history.rs b/crates/agent_ui/src/acp/thread_history.rs index 1aa89b35d34c8c0543a56014fee7766b6de66eb2..a885e52a05e342dbcd81d28a970560b3047ef9c0 100644 --- a/crates/agent_ui/src/acp/thread_history.rs +++ b/crates/agent_ui/src/acp/thread_history.rs @@ -1,7 +1,7 @@ use crate::acp::AcpThreadView; use crate::{AgentPanel, RemoveHistory, RemoveSelectedThread}; use agent::{HistoryEntry, HistoryStore}; -use chrono::{Datelike as _, Local, NaiveDate, TimeDelta}; +use chrono::{Datelike as _, Local, NaiveDate, TimeDelta, Utc}; use editor::{Editor, EditorEvent}; use fuzzy::StringMatchCandidate; use gpui::{ @@ -402,7 +402,22 @@ impl AcpThreadHistory { let selected = ix == self.selected_index; let hovered = Some(ix) == self.hovered_index; let timestamp = entry.updated_at().timestamp(); - let thread_timestamp = format.format_timestamp(timestamp, self.local_timezone); + + let display_text = match format { + EntryTimeFormat::DateAndTime => { + let entry_time = entry.updated_at(); + let now = Utc::now(); + let duration = now.signed_duration_since(entry_time); + let days = duration.num_days(); + + format!("{}d", days) + } + EntryTimeFormat::TimeOnly => format.format_timestamp(timestamp, self.local_timezone), + }; + + let title = entry.title().clone(); + let full_date = + EntryTimeFormat::DateAndTime.format_timestamp(timestamp, self.local_timezone); h_flex() .w_full() @@ -423,11 +438,14 @@ impl AcpThreadHistory { .truncate(), ) .child( - Label::new(thread_timestamp) + Label::new(display_text) .color(Color::Muted) .size(LabelSize::XSmall), ), ) + .tooltip(move |_, cx| { + Tooltip::with_meta(title.clone(), None, full_date.clone(), cx) + }) .on_hover(cx.listener(move |this, is_hovered, _window, cx| { if *is_hovered { this.hovered_index = Some(ix); diff --git a/crates/agent_ui_v2/src/thread_history.rs b/crates/agent_ui_v2/src/thread_history.rs index 8f6626814902a9489536439e90041437a527e151..0e379a24fc3047e6a686046ea16a94ef25efb52c 100644 --- a/crates/agent_ui_v2/src/thread_history.rs +++ b/crates/agent_ui_v2/src/thread_history.rs @@ -1,5 +1,5 @@ use agent::{HistoryEntry, HistoryStore}; -use chrono::{Datelike as _, Local, NaiveDate, TimeDelta}; +use chrono::{Datelike as _, Local, NaiveDate, TimeDelta, Utc}; use editor::{Editor, EditorEvent}; use fuzzy::StringMatchCandidate; use gpui::{ @@ -411,7 +411,22 @@ impl AcpThreadHistory { let selected = ix == self.selected_index; let hovered = Some(ix) == self.hovered_index; let timestamp = entry.updated_at().timestamp(); - let thread_timestamp = format.format_timestamp(timestamp, self.local_timezone); + + let display_text = match format { + EntryTimeFormat::DateAndTime => { + let entry_time = entry.updated_at(); + let now = Utc::now(); + let duration = now.signed_duration_since(entry_time); + let days = duration.num_days(); + + format!("{}d", days) + } + EntryTimeFormat::TimeOnly => format.format_timestamp(timestamp, self.local_timezone), + }; + + let title = entry.title().clone(); + let full_date = + EntryTimeFormat::DateAndTime.format_timestamp(timestamp, self.local_timezone); h_flex() .w_full() @@ -432,11 +447,14 @@ impl AcpThreadHistory { .truncate(), ) .child( - Label::new(thread_timestamp) + Label::new(display_text) .color(Color::Muted) .size(LabelSize::XSmall), ), ) + .tooltip(move |_, cx| { + Tooltip::with_meta(title.clone(), None, full_date.clone(), cx) + }) .on_hover(cx.listener(move |this, is_hovered, _window, cx| { if *is_hovered { this.hovered_index = Some(ix); From 8516d81e132d969651e453c6423314fac59961e0 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 18 Dec 2025 16:32:59 -0500 Subject: [PATCH 202/266] Fix display name for Ollama models (#45287) Closes #43646 Release Notes: - Fixed display name for Ollama models --- crates/language_models/src/provider/ollama.rs | 137 ++++++++++++++---- 1 file changed, 110 insertions(+), 27 deletions(-) diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index c5a8bf41711563110cbcb5d81698b7029b04a713..860d635b6ac704c2762023c463432bebae08d4a5 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -249,33 +249,7 @@ impl LanguageModelProvider for OllamaLanguageModelProvider { } // Override with available models from settings - for setting_model in &OllamaLanguageModelProvider::settings(cx).available_models { - let setting_base = setting_model.name.split(':').next().unwrap(); - if let Some(model) = models - .values_mut() - .find(|m| m.name.split(':').next().unwrap() == setting_base) - { - model.max_tokens = setting_model.max_tokens; - model.display_name = setting_model.display_name.clone(); - model.keep_alive = setting_model.keep_alive.clone(); - model.supports_tools = setting_model.supports_tools; - model.supports_vision = setting_model.supports_images; - model.supports_thinking = setting_model.supports_thinking; - } else { - models.insert( - setting_model.name.clone(), - ollama::Model { - name: setting_model.name.clone(), - display_name: setting_model.display_name.clone(), - max_tokens: setting_model.max_tokens, - keep_alive: setting_model.keep_alive.clone(), - supports_tools: setting_model.supports_tools, - supports_vision: setting_model.supports_images, - supports_thinking: setting_model.supports_thinking, - }, - ); - } - } + merge_settings_into_models(&mut models, &settings.available_models); let mut models = models .into_values() @@ -921,6 +895,35 @@ impl Render for ConfigurationView { } } +fn merge_settings_into_models( + models: &mut HashMap, + available_models: &[AvailableModel], +) { + for setting_model in available_models { + if let Some(model) = models.get_mut(&setting_model.name) { + model.max_tokens = setting_model.max_tokens; + model.display_name = setting_model.display_name.clone(); + model.keep_alive = setting_model.keep_alive.clone(); + model.supports_tools = setting_model.supports_tools; + model.supports_vision = setting_model.supports_images; + model.supports_thinking = setting_model.supports_thinking; + } else { + models.insert( + setting_model.name.clone(), + ollama::Model { + name: setting_model.name.clone(), + display_name: setting_model.display_name.clone(), + max_tokens: setting_model.max_tokens, + keep_alive: setting_model.keep_alive.clone(), + supports_tools: setting_model.supports_tools, + supports_vision: setting_model.supports_images, + supports_thinking: setting_model.supports_thinking, + }, + ); + } + } +} + fn tool_into_ollama(tool: LanguageModelRequestTool) -> ollama::OllamaTool { ollama::OllamaTool::Function { function: OllamaFunctionTool { @@ -930,3 +933,83 @@ fn tool_into_ollama(tool: LanguageModelRequestTool) -> ollama::OllamaTool { }, } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_merge_settings_preserves_display_names_for_similar_models() { + // Regression test for https://github.com/zed-industries/zed/issues/43646 + // When multiple models share the same base name (e.g., qwen2.5-coder:1.5b and qwen2.5-coder:3b), + // each model should get its own display_name from settings, not a random one. + + let mut models: HashMap = HashMap::new(); + models.insert( + "qwen2.5-coder:1.5b".to_string(), + ollama::Model { + name: "qwen2.5-coder:1.5b".to_string(), + display_name: None, + max_tokens: 4096, + keep_alive: None, + supports_tools: None, + supports_vision: None, + supports_thinking: None, + }, + ); + models.insert( + "qwen2.5-coder:3b".to_string(), + ollama::Model { + name: "qwen2.5-coder:3b".to_string(), + display_name: None, + max_tokens: 4096, + keep_alive: None, + supports_tools: None, + supports_vision: None, + supports_thinking: None, + }, + ); + + let available_models = vec![ + AvailableModel { + name: "qwen2.5-coder:1.5b".to_string(), + display_name: Some("QWEN2.5 Coder 1.5B".to_string()), + max_tokens: 5000, + keep_alive: None, + supports_tools: Some(true), + supports_images: None, + supports_thinking: None, + }, + AvailableModel { + name: "qwen2.5-coder:3b".to_string(), + display_name: Some("QWEN2.5 Coder 3B".to_string()), + max_tokens: 6000, + keep_alive: None, + supports_tools: Some(true), + supports_images: None, + supports_thinking: None, + }, + ]; + + merge_settings_into_models(&mut models, &available_models); + + let model_1_5b = models + .get("qwen2.5-coder:1.5b") + .expect("1.5b model missing"); + let model_3b = models.get("qwen2.5-coder:3b").expect("3b model missing"); + + assert_eq!( + model_1_5b.display_name, + Some("QWEN2.5 Coder 1.5B".to_string()), + "1.5b model should have its own display_name" + ); + assert_eq!(model_1_5b.max_tokens, 5000); + + assert_eq!( + model_3b.display_name, + Some("QWEN2.5 Coder 3B".to_string()), + "3b model should have its own display_name" + ); + assert_eq!(model_3b.max_tokens, 6000); + } +} From ca90b8555dc1ff1315ded1438664cff07338ad8b Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Thu, 18 Dec 2025 16:42:28 -0500 Subject: [PATCH 203/266] docs: Remove local collaboration docs (#45301) This PR removes the docs for running Collab locally, as they are outdated and don't reflect the current state of affairs. Release Notes: - N/A --- README.md | 1 - docs/src/SUMMARY.md | 1 - docs/src/development.md | 4 - docs/src/development/linux.md | 4 - docs/src/development/local-collaboration.md | 207 -------------------- docs/src/development/macos.md | 4 - docs/src/development/windows.md | 4 - 7 files changed, 225 deletions(-) delete mode 100644 docs/src/development/local-collaboration.md diff --git a/README.md b/README.md index d3a5fd20526e5eae6826241dce2bb94e8533ecb3..866762c8c9139666993c2e29d9682966106c516b 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,6 @@ Other platforms are not yet available: - [Building Zed for macOS](./docs/src/development/macos.md) - [Building Zed for Linux](./docs/src/development/linux.md) - [Building Zed for Windows](./docs/src/development/windows.md) -- [Running Collaboration Locally](./docs/src/development/local-collaboration.md) ### Contributing diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index 1f9c5750ea76b35a2f7f5464b7b6684401108d2b..a82ddac990c4379df03db2b4bdcd8272eb8715e9 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -177,7 +177,6 @@ - [Linux](./development/linux.md) - [Windows](./development/windows.md) - [FreeBSD](./development/freebsd.md) - - [Local Collaboration](./development/local-collaboration.md) - [Using Debuggers](./development/debuggers.md) - [Performance](./performance.md) - [Glossary](./development/glossary.md) diff --git a/docs/src/development.md b/docs/src/development.md index 31bb245ac42f80c830a0faba405323d1097e3f51..8f341dbb1506d4a6fa6c3ffa21960191ec5ecfcf 100644 --- a/docs/src/development.md +++ b/docs/src/development.md @@ -6,10 +6,6 @@ See the platform-specific instructions for building Zed from source: - [Linux](./development/linux.md) - [Windows](./development/windows.md) -If you'd like to develop collaboration features, additionally see: - -- [Local Collaboration](./development/local-collaboration.md) - ## Keychain access Zed stores secrets in the system keychain. diff --git a/docs/src/development/linux.md b/docs/src/development/linux.md index df3b840fa17a547efd4324f3bdaa119b8ade8738..3269d4b4dd51b224ab2b0cf7cfe15333232d0915 100644 --- a/docs/src/development/linux.md +++ b/docs/src/development/linux.md @@ -16,10 +16,6 @@ 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 (optional) {#backend-dependencies} - -If you are looking to develop Zed collaboration features using a local collaboration server, please see: [Local Collaboration](./local-collaboration.md) docs. - ### Linkers {#linker} On Linux, Rust's default linker is [LLVM's `lld`](https://blog.rust-lang.org/2025/09/18/Rust-1.90.0/). Alternative linkers, especially [Wild](https://github.com/davidlattimore/wild) and [Mold](https://github.com/rui314/mold) can significantly improve clean and incremental build time. diff --git a/docs/src/development/local-collaboration.md b/docs/src/development/local-collaboration.md deleted file mode 100644 index 393c6f0bbf797cf9aa86d297633734444bdfb328..0000000000000000000000000000000000000000 --- a/docs/src/development/local-collaboration.md +++ /dev/null @@ -1,207 +0,0 @@ -# Local Collaboration - -1. Ensure you have access to our cloud infrastructure. If you don't have access, you can't collaborate locally at this time. - -2. Make sure you've installed Zed's dependencies for your platform: - -- [macOS](#macos) -- [Linux](#linux) -- [Windows](#backend-windows) - -Note that `collab` can be compiled only with MSVC toolchain on Windows - -3. Clone down our cloud repository and follow the instructions in the cloud README - -4. Setup the local database for your platform: - -- [macOS & Linux](#database-unix) -- [Windows](#database-windows) - -5. Run collab: - -- [macOS & Linux](#run-collab-unix) -- [Windows](#run-collab-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 # 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. - -### On macOS and Linux {#database-unix} - -```sh -script/bootstrap -``` - -This script will set up the `zed` Postgres database, and populate it with some users. It requires internet access, because it fetches some users from the GitHub API. - -The script will seed the database with various content defined by: - -```sh -cat crates/collab/seed.default.json -``` - -To use a different set of admin users, you can create your own version of that json file and export the `SEED_PATH` environment variable. Note that the usernames listed in the admins list currently must correspond to valid GitHub users. - -```json [settings] -{ - "admins": ["admin1", "admin2"], - "channels": ["zed"] -} -``` - -### On Windows {#database-windows} - -```powershell -.\script\bootstrap.ps1 -``` - -## Testing collaborative features locally - -### On macOS and Linux {#run-collab-unix} - -Ensure that Postgres is configured and running, then run Zed's collaboration server and the `livekit` dev server: - -```sh -foreman start -# OR -docker compose up -``` - -Alternatively, if you're not testing voice and screenshare, you can just run `collab` and `cloud`, and not the `livekit` dev server: - -```sh -cargo run -p collab -- serve all -``` - -```sh -cd ../cloud; cargo make dev -``` - -In a new terminal, run two or more instances of Zed. - -```sh -script/zed-local -3 -``` - -This script starts one to four instances of Zed, depending on the `-2`, `-3` or `-4` flags. Each instance will be connected to the local `collab` server, signed in as a different user from `.admins.json` or `.admins.default.json`. - -### On Windows {#run-collab-windows} - -Since `foreman` is not available on Windows, you can run the following commands in separate terminals: - -```powershell -cargo run --package=collab -- serve all -``` - -If you have added the `livekit-server` binary to your `PATH`, you can run: - -```powershell -livekit-server --dev -``` - -Otherwise, - -```powershell -.\path\to\livekit-serve.exe --dev -``` - -You'll also need to start the cloud server: - -```powershell -cd ..\cloud; cargo make dev -``` - -In a new terminal, run two or more instances of Zed. - -```powershell -node .\script\zed-local -2 -``` - -Note that this requires `node.exe` to be in your `PATH`. - -## Running a local collab server - -> [!NOTE] -> Because of recent changes to our authentication system, Zed will not be able to authenticate itself with, and therefore use, a local collab server. - -If you want to run your own version of the zed collaboration service, you can, but note that this is still under development, and there is no support for authentication nor extensions. - -Configuration is done through environment variables. By default it will read the configuration from [`.env.toml`](https://github.com/zed-industries/zed/blob/main/crates/collab/.env.toml) and you should use that as a guide for setting this up. - -By default Zed assumes that the DATABASE_URL is a Postgres database, but you can make it use Sqlite by compiling with `--features sqlite` and using a sqlite DATABASE_URL with `?mode=rwc`. - -To authenticate you must first configure the server by creating a seed.json file that contains at a minimum your github handle. This will be used to create the user on demand. - -```json [settings] -{ - "admins": ["nathansobo"] -} -``` - -By default the collab server will seed the database when first creating it, but if you want to add more users you can explicitly reseed them with `SEED_PATH=./seed.json cargo run -p collab seed` - -Then when running the zed client you must specify two environment variables, `ZED_ADMIN_API_TOKEN` (which should match the value of `API_TOKEN` in .env.toml) and `ZED_IMPERSONATE` (which should match one of the users in your seed.json) diff --git a/docs/src/development/macos.md b/docs/src/development/macos.md index 9c99e5f8da62594c774e109e15f914788f51793d..9e2908dd6e393acd8d3903d86743dcbc4e9ae9eb 100644 --- a/docs/src/development/macos.md +++ b/docs/src/development/macos.md @@ -31,10 +31,6 @@ 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 collaboration 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/). diff --git a/docs/src/development/windows.md b/docs/src/development/windows.md index 17382e0bee5b97c2ffc2d74794cf3881a3cb98a1..509f30a05b45175f7e66026aec5b5d433b928e4d 100644 --- a/docs/src/development/windows.md +++ b/docs/src/development/windows.md @@ -66,10 +66,6 @@ The list can be obtained as follows: - Click on `More` in the `Installed` tab - Click on `Export configuration` -### Backend Dependencies (optional) {#backend-dependencies} - -If you are looking to develop Zed collaboration features using a local collaboration server, please see: [Local Collaboration](./local-collaboration.md) docs. - ### Notes You should modify the `pg_hba.conf` file in the `data` directory to use `trust` instead of `scram-sha-256` for the `host` method. Otherwise, the connection will fail with the error `password authentication failed`. The `pg_hba.conf` file typically locates at `C:\Program Files\PostgreSQL\17\data\pg_hba.conf`. After the modification, the file should look like this: From 0d74f982a5928e37d46ac5fc78232339ec85bc91 Mon Sep 17 00:00:00 2001 From: Marshall Bowers Date: Thu, 18 Dec 2025 16:52:34 -0500 Subject: [PATCH 204/266] danger: Upgrade `danger-plugin-pr-hygiene` to v0.7.1 (#45303) This PR upgrades `danger-plugin-pr-hygiene` to v0.7.1. Release Notes: - N/A --- script/danger/package.json | 2 +- script/danger/pnpm-lock.yaml | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/script/danger/package.json b/script/danger/package.json index 74862c142468c1297a1d4aad8dcc468b6ddf5798..be44da6233a1c5ee87f8445e13953031497acfa5 100644 --- a/script/danger/package.json +++ b/script/danger/package.json @@ -8,6 +8,6 @@ }, "devDependencies": { "danger": "13.0.4", - "danger-plugin-pr-hygiene": "0.7.0" + "danger-plugin-pr-hygiene": "0.7.1" } } diff --git a/script/danger/pnpm-lock.yaml b/script/danger/pnpm-lock.yaml index 942d027cc80bf5d81ffa8b5bf739963430e939a3..eea293cfed78fcf43ed926484b2f13b5b9c74843 100644 --- a/script/danger/pnpm-lock.yaml +++ b/script/danger/pnpm-lock.yaml @@ -12,8 +12,8 @@ importers: specifier: 13.0.4 version: 13.0.4 danger-plugin-pr-hygiene: - specifier: 0.7.0 - version: 0.7.0 + specifier: 0.7.1 + version: 0.7.1 packages: @@ -134,8 +134,8 @@ packages: core-js@3.45.1: resolution: {integrity: sha512-L4NPsJlCfZsPeXukyzHFlg/i7IIVwHSItR0wg0FLNqYClJ4MQYTYLbC7EkjKYRLZF2iof2MUgN0EGy7MdQFChg==} - danger-plugin-pr-hygiene@0.7.0: - resolution: {integrity: sha512-YDWhEodP0fg/t9YO3SxufWS9j1Rcxbig+1flTlUlojBDFiKQyVmaj8PIvnJxJItjHWTlNKI9wMSRq5vUql6zyA==} + danger-plugin-pr-hygiene@0.7.1: + resolution: {integrity: sha512-ll070nNaL3OeO2nooYWflPE/CRKLeq8GiH2C68u5zM3gW4gepH89GhVv0sYNNGLx4cYwa1zZ/TuiYYhC49z06Q==} danger@13.0.4: resolution: {integrity: sha512-IAdQ5nSJyIs4zKj6AN35ixt2B0Ce3WZUm3IFe/CMnL/Op7wV7IGg4D348U0EKNaNPP58QgXbdSk9pM+IXP1QXg==} @@ -573,7 +573,7 @@ snapshots: core-js@3.45.1: {} - danger-plugin-pr-hygiene@0.7.0: {} + danger-plugin-pr-hygiene@0.7.1: {} danger@13.0.4: dependencies: From 88f90c12ed1cf689c237661a7a870b57be203149 Mon Sep 17 00:00:00 2001 From: "Joseph T. Lyons" Date: Thu, 18 Dec 2025 16:59:21 -0500 Subject: [PATCH 205/266] Add language server version in a tooltip on language server hover (#45302) I wanted a way to make it easy to figure out which version of a language server Zed is running. Now, you get a tooltip when hovering on a language server in the Language Servers popover. SCR-20251218-ovln This PR also fixes a bug. We had existing code to open a tooltip on these language server entrees and display the language server message, which was never fully wired up for `CustomEntry`s. Now, in this PR, we will show show either version, message, or both, in the documentation aside, depending on what the server has given us. Mostly done with Droid (using GPT-5.2), with manual review and multiple follow ups to guide it into using existing patterns in the codebase, when it did something abnormal. Release Notes: - Added language server version in a tooltip on language server hover --------- Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com> --- crates/language_tools/src/lsp_button.rs | 32 ++++++++++- crates/language_tools/src/lsp_log_view.rs | 9 +++ crates/lsp/src/lsp.rs | 8 +++ crates/project/src/lsp_store.rs | 4 ++ crates/ui/src/components/context_menu.rs | 68 ++++++++++++++--------- 5 files changed, 93 insertions(+), 28 deletions(-) diff --git a/crates/language_tools/src/lsp_button.rs b/crates/language_tools/src/lsp_button.rs index 335381c6f79d950498a0f0c1d330cb21c681f32e..7775586bf19539e13adc6b9df6d92914be6b7f21 100644 --- a/crates/language_tools/src/lsp_button.rs +++ b/crates/language_tools/src/lsp_button.rs @@ -127,6 +127,16 @@ impl LanguageServerState { return menu; }; + let server_versions = self + .lsp_store + .update(cx, |lsp_store, _| { + lsp_store + .language_server_statuses() + .map(|(server_id, status)| (server_id, status.server_version.clone())) + .collect::>() + }) + .unwrap_or_default(); + let mut first_button_encountered = false; for item in &self.items { if let LspMenuItem::ToggleServersButton { restart } = item { @@ -254,6 +264,22 @@ impl LanguageServerState { }; let server_name = server_info.name.clone(); + let server_version = server_versions + .get(&server_info.id) + .and_then(|version| version.clone()); + + let tooltip_text = match (&server_version, &message) { + (None, None) => None, + (Some(version), None) => { + Some(SharedString::from(format!("Version: {}", version.as_ref()))) + } + (None, Some(message)) => Some(message.clone()), + (Some(version), Some(message)) => Some(SharedString::from(format!( + "Version: {}\n\n{}", + version.as_ref(), + message.as_ref() + ))), + }; menu = menu.item(ContextMenuItem::custom_entry( move |_, _| { h_flex() @@ -355,11 +381,11 @@ impl LanguageServerState { } } }, - message.map(|server_message| { + tooltip_text.map(|tooltip_text| { DocumentationAside::new( DocumentationSide::Right, - DocumentationEdge::Bottom, - Rc::new(move |_| Label::new(server_message.clone()).into_any_element()), + DocumentationEdge::Top, + Rc::new(move |_| Label::new(tooltip_text.clone()).into_any_element()), ) }), )); diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs index e34bbb46d35d5a524c08369fcc991dfe81865127..2b2575912ae4543d2bf3cbd0c6b667ace7c82e91 100644 --- a/crates/language_tools/src/lsp_log_view.rs +++ b/crates/language_tools/src/lsp_log_view.rs @@ -330,6 +330,8 @@ impl LspLogView { let server_info = format!( "* Server: {NAME} (id {ID}) +* Version: {VERSION} + * Binary: {BINARY} * Registered workspace folders: @@ -340,6 +342,12 @@ impl LspLogView { * Configuration: {CONFIGURATION}", NAME = info.status.name, ID = info.id, + VERSION = info + .status + .server_version + .as_ref() + .map(|version| version.as_ref()) + .unwrap_or("Unknown"), BINARY = info .status .binary @@ -1334,6 +1342,7 @@ impl ServerInfo { capabilities: server.capabilities(), status: LanguageServerStatus { name: server.name(), + server_version: server.version(), pending_work: Default::default(), has_pending_diagnostic_updates: false, progress_tokens: Default::default(), diff --git a/crates/lsp/src/lsp.rs b/crates/lsp/src/lsp.rs index faa094153d4a26fb1a2b96360f2691989e81aad9..36938f62a3048b87dd890ca6e7ca8fc2499689e4 100644 --- a/crates/lsp/src/lsp.rs +++ b/crates/lsp/src/lsp.rs @@ -89,6 +89,7 @@ pub struct LanguageServer { outbound_tx: channel::Sender, notification_tx: channel::Sender, name: LanguageServerName, + version: Option, process_name: Arc, binary: LanguageServerBinary, capabilities: RwLock, @@ -501,6 +502,7 @@ impl LanguageServer { response_handlers, io_handlers, name: server_name, + version: None, process_name: binary .path .file_name() @@ -925,6 +927,7 @@ impl LanguageServer { ) })?; if let Some(info) = response.server_info { + self.version = info.version.map(SharedString::from); self.process_name = info.name.into(); } self.capabilities = RwLock::new(response.capabilities); @@ -1155,6 +1158,11 @@ impl LanguageServer { self.name.clone() } + /// Get the version of the running language server. + pub fn version(&self) -> Option { + self.version.clone() + } + pub fn process_name(&self) -> &str { &self.process_name } diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs index 5093b6977a1bffe82339ede00d2e6e4b4b14b4c1..7e8624daad628fd653326647537eb51dad208a02 100644 --- a/crates/project/src/lsp_store.rs +++ b/crates/project/src/lsp_store.rs @@ -3864,6 +3864,7 @@ pub enum LspStoreEvent { #[derive(Clone, Debug, Serialize)] pub struct LanguageServerStatus { pub name: LanguageServerName, + pub server_version: Option, pub pending_work: BTreeMap, pub has_pending_diagnostic_updates: bool, pub progress_tokens: HashSet, @@ -8354,6 +8355,7 @@ impl LspStore { server_id, LanguageServerStatus { name, + server_version: None, pending_work: Default::default(), has_pending_diagnostic_updates: false, progress_tokens: Default::default(), @@ -9389,6 +9391,7 @@ impl LspStore { server_id, LanguageServerStatus { name: server_name.clone(), + server_version: None, pending_work: Default::default(), has_pending_diagnostic_updates: false, progress_tokens: Default::default(), @@ -11419,6 +11422,7 @@ impl LspStore { server_id, LanguageServerStatus { name: language_server.name(), + server_version: language_server.version(), pending_work: Default::default(), has_pending_diagnostic_updates: false, progress_tokens: Default::default(), diff --git a/crates/ui/src/components/context_menu.rs b/crates/ui/src/components/context_menu.rs index 756a2a9364193d6f1cdace8ed8c92cecf401a864..7e5e9032c9d4b0521f972b47d90d24cd502faf7b 100644 --- a/crates/ui/src/components/context_menu.rs +++ b/crates/ui/src/components/context_menu.rs @@ -893,39 +893,57 @@ impl ContextMenu { entry_render, handler, selectable, + documentation_aside, .. } => { let handler = handler.clone(); let menu = cx.entity().downgrade(); let selectable = *selectable; - ListItem::new(ix) - .inset(true) - .toggle_state(if selectable { - Some(ix) == self.selected_index - } else { - false + + div() + .id(("context-menu-child", ix)) + .when_some(documentation_aside.clone(), |this, documentation_aside| { + this.occlude() + .on_hover(cx.listener(move |menu, hovered, _, cx| { + if *hovered { + menu.documentation_aside = Some((ix, documentation_aside.clone())); + } else if matches!(menu.documentation_aside, Some((id, _)) if id == ix) + { + menu.documentation_aside = None; + } + cx.notify(); + })) }) - .selectable(selectable) - .when(selectable, |item| { - item.on_click({ - let context = self.action_context.clone(); - let keep_open_on_confirm = self.keep_open_on_confirm; - move |_, window, cx| { - handler(context.as_ref(), window, cx); - menu.update(cx, |menu, cx| { - menu.clicked = true; - - if keep_open_on_confirm { - menu.rebuild(window, cx); - } else { - cx.emit(DismissEvent); + .child( + ListItem::new(ix) + .inset(true) + .toggle_state(if selectable { + Some(ix) == self.selected_index + } else { + false + }) + .selectable(selectable) + .when(selectable, |item| { + item.on_click({ + let context = self.action_context.clone(); + let keep_open_on_confirm = self.keep_open_on_confirm; + move |_, window, cx| { + handler(context.as_ref(), window, cx); + menu.update(cx, |menu, cx| { + menu.clicked = true; + + if keep_open_on_confirm { + menu.rebuild(window, cx); + } else { + cx.emit(DismissEvent); + } + }) + .ok(); } }) - .ok(); - } - }) - }) - .child(entry_render(window, cx)) + }) + .child(entry_render(window, cx)), + ) .into_any_element() } } From 6055b45ee19ab61ff3b00498872ef6f31e748f37 Mon Sep 17 00:00:00 2001 From: Richard Feldman Date: Thu, 18 Dec 2025 17:05:04 -0500 Subject: [PATCH 206/266] Add support for provider extensions (but no extensions yet) (#45277) This adds support for provider extensions but doesn't actually add any yet. Release Notes: - N/A --- Cargo.lock | 2 + crates/acp_thread/src/connection.rs | 11 +- crates/agent/src/agent.rs | 15 +- crates/agent_ui/src/acp/model_selector.rs | 8 +- .../src/acp/model_selector_popover.rs | 13 +- crates/agent_ui/src/agent_configuration.rs | 16 +- crates/agent_ui/src/agent_model_selector.rs | 12 +- crates/agent_ui/src/agent_panel.rs | 2 +- crates/agent_ui/src/agent_ui.rs | 3 +- .../agent_ui/src/language_model_selector.rs | 19 +- crates/agent_ui/src/text_thread_editor.rs | 20 +- .../src/ui/model_selector_components.rs | 23 ++- .../src/agent_api_keys_onboarding.rs | 20 +- .../src/agent_panel_onboarding_content.rs | 21 +- crates/extension/src/extension_host_proxy.rs | 48 +++++ crates/extension/src/extension_manifest.rs | 14 ++ .../extension_compilation_benchmark.rs | 1 + .../extension_host/src/capability_granter.rs | 1 + .../src/extension_store_test.rs | 3 + crates/language_model/src/language_model.rs | 21 +- crates/language_model/src/registry.rs | 195 +++++++++++++++++- crates/language_models/Cargo.toml | 2 + crates/language_models/src/extension.rs | 67 ++++++ crates/language_models/src/language_models.rs | 53 +++++ .../language_models/src/provider/anthropic.rs | 6 +- .../language_models/src/provider/bedrock.rs | 6 +- crates/language_models/src/provider/cloud.rs | 6 +- .../src/provider/copilot_chat.rs | 16 +- .../language_models/src/provider/deepseek.rs | 6 +- crates/language_models/src/provider/google.rs | 6 +- .../language_models/src/provider/lmstudio.rs | 6 +- .../language_models/src/provider/mistral.rs | 6 +- crates/language_models/src/provider/ollama.rs | 6 +- .../language_models/src/provider/open_ai.rs | 6 +- .../src/provider/open_ai_compatible.rs | 6 +- .../src/provider/open_router.rs | 6 +- crates/language_models/src/provider/vercel.rs | 6 +- crates/language_models/src/provider/x_ai.rs | 6 +- crates/ui/src/components/icon.rs | 22 +- 39 files changed, 585 insertions(+), 121 deletions(-) create mode 100644 crates/language_models/src/extension.rs diff --git a/Cargo.lock b/Cargo.lock index 0d83b2b9b912ab112d9b38fd1ef1d5ff21f9049c..1bb39f2bdf8c5745b3e5c0e5ad1200be34ec6ab0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8932,6 +8932,8 @@ dependencies = [ "credentials_provider", "deepseek", "editor", + "extension", + "extension_host", "fs", "futures 0.3.31", "google_ai", diff --git a/crates/acp_thread/src/connection.rs b/crates/acp_thread/src/connection.rs index a670ba601159ec323ad2c88695c30bf4aeae4118..598d0428174eb2fc124739a18ddeff1098521cb7 100644 --- a/crates/acp_thread/src/connection.rs +++ b/crates/acp_thread/src/connection.rs @@ -210,12 +210,21 @@ pub trait AgentModelSelector: 'static { } } +/// Icon for a model in the model selector. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum AgentModelIcon { + /// A built-in icon from Zed's icon set. + Named(IconName), + /// Path to a custom SVG icon file. + Path(SharedString), +} + #[derive(Debug, Clone, PartialEq, Eq)] pub struct AgentModelInfo { pub id: acp::ModelId, pub name: SharedString, pub description: Option, - pub icon: Option, + pub icon: Option, } impl From for AgentModelInfo { diff --git a/crates/agent/src/agent.rs b/crates/agent/src/agent.rs index 43ed3b90f3556eb24e45440a7fe0038e7a1b9535..4baa7f4ea4004d2137b5cddb255346fa91523091 100644 --- a/crates/agent/src/agent.rs +++ b/crates/agent/src/agent.rs @@ -30,7 +30,7 @@ use futures::{StreamExt, future}; use gpui::{ App, AppContext, AsyncApp, Context, Entity, SharedString, Subscription, Task, WeakEntity, }; -use language_model::{LanguageModel, LanguageModelProvider, LanguageModelRegistry}; +use language_model::{IconOrSvg, LanguageModel, LanguageModelProvider, LanguageModelRegistry}; use project::{Project, ProjectItem, ProjectPath, Worktree}; use prompt_store::{ ProjectContext, PromptStore, RULES_FILE_NAMES, RulesFileContext, UserRulesContext, @@ -93,7 +93,7 @@ impl LanguageModels { fn refresh_list(&mut self, cx: &App) { let providers = LanguageModelRegistry::global(cx) .read(cx) - .providers() + .visible_providers() .into_iter() .filter(|provider| provider.is_authenticated(cx)) .collect::>(); @@ -153,7 +153,10 @@ impl LanguageModels { id: Self::model_id(model), name: model.name().0, description: None, - icon: Some(provider.icon()), + icon: Some(match provider.icon() { + IconOrSvg::Svg(path) => acp_thread::AgentModelIcon::Path(path), + IconOrSvg::Icon(name) => acp_thread::AgentModelIcon::Named(name), + }), } } @@ -164,7 +167,7 @@ impl LanguageModels { fn authenticate_all_language_model_providers(cx: &mut App) -> Task<()> { let authenticate_all_providers = LanguageModelRegistry::global(cx) .read(cx) - .providers() + .visible_providers() .iter() .map(|provider| (provider.id(), provider.name(), provider.authenticate(cx))) .collect::>(); @@ -1630,7 +1633,9 @@ mod internal_tests { id: acp::ModelId::new("fake/fake"), name: "Fake".into(), description: None, - icon: Some(ui::IconName::ZedAssistant), + icon: Some(acp_thread::AgentModelIcon::Named( + ui::IconName::ZedAssistant + )), }] )]) ); diff --git a/crates/agent_ui/src/acp/model_selector.rs b/crates/agent_ui/src/acp/model_selector.rs index f3c07250de3cefc798b97d9ffad444489d153219..903d5fe425d99389aae0e2a8028d9a31b986fbb3 100644 --- a/crates/agent_ui/src/acp/model_selector.rs +++ b/crates/agent_ui/src/acp/model_selector.rs @@ -1,6 +1,6 @@ use std::{cmp::Reverse, rc::Rc, sync::Arc}; -use acp_thread::{AgentModelInfo, AgentModelList, AgentModelSelector}; +use acp_thread::{AgentModelIcon, AgentModelInfo, AgentModelList, AgentModelSelector}; use agent_client_protocol::ModelId; use agent_servers::AgentServer; use agent_settings::AgentSettings; @@ -350,7 +350,11 @@ impl PickerDelegate for AcpModelPickerDelegate { }) .child( ModelSelectorListItem::new(ix, model_info.name.clone()) - .when_some(model_info.icon, |this, icon| this.icon(icon)) + .map(|this| match &model_info.icon { + Some(AgentModelIcon::Path(path)) => this.icon_path(path.clone()), + Some(AgentModelIcon::Named(icon)) => this.icon(*icon), + None => this, + }) .is_selected(is_selected) .is_focused(selected) .when(supports_favorites, |this| { diff --git a/crates/agent_ui/src/acp/model_selector_popover.rs b/crates/agent_ui/src/acp/model_selector_popover.rs index d6709081863c9545fba4c6e2304f195e77b013df..a15c01445dd8e9845f6744e795ed90a1ede6c7fc 100644 --- a/crates/agent_ui/src/acp/model_selector_popover.rs +++ b/crates/agent_ui/src/acp/model_selector_popover.rs @@ -1,7 +1,7 @@ use std::rc::Rc; use std::sync::Arc; -use acp_thread::{AgentModelInfo, AgentModelSelector}; +use acp_thread::{AgentModelIcon, AgentModelInfo, AgentModelSelector}; use agent_servers::AgentServer; use agent_settings::AgentSettings; use fs::Fs; @@ -70,7 +70,7 @@ impl Render for AcpModelSelectorPopover { .map(|model| model.name.clone()) .unwrap_or_else(|| SharedString::from("Select a Model")); - let model_icon = model.as_ref().and_then(|model| model.icon); + let model_icon = model.as_ref().and_then(|model| model.icon.clone()); let focus_handle = self.focus_handle.clone(); @@ -125,7 +125,14 @@ impl Render for AcpModelSelectorPopover { ButtonLike::new("active-model") .selected_style(ButtonStyle::Tinted(TintColor::Accent)) .when_some(model_icon, |this, icon| { - this.child(Icon::new(icon).color(color).size(IconSize::XSmall)) + this.child( + match icon { + AgentModelIcon::Path(path) => Icon::from_external_svg(path), + AgentModelIcon::Named(icon_name) => Icon::new(icon_name), + } + .color(color) + .size(IconSize::XSmall), + ) }) .child( Label::new(model_name) diff --git a/crates/agent_ui/src/agent_configuration.rs b/crates/agent_ui/src/agent_configuration.rs index 24f019c605d1b167e62a6e68dfc1f3ed07c73f1c..562976453d963db65f9033536e528000de2b510f 100644 --- a/crates/agent_ui/src/agent_configuration.rs +++ b/crates/agent_ui/src/agent_configuration.rs @@ -22,7 +22,8 @@ use gpui::{ }; use language::LanguageRegistry; use language_model::{ - LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID, + IconOrSvg, LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry, + ZED_CLOUD_PROVIDER_ID, }; use language_models::AllLanguageModelSettings; use notifications::status_toast::{StatusToast, ToastIcon}; @@ -117,7 +118,7 @@ impl AgentConfiguration { } fn build_provider_configuration_views(&mut self, window: &mut Window, cx: &mut Context) { - let providers = LanguageModelRegistry::read_global(cx).providers(); + let providers = LanguageModelRegistry::read_global(cx).visible_providers(); for provider in providers { self.add_provider_configuration_view(&provider, window, cx); } @@ -261,9 +262,12 @@ impl AgentConfiguration { .w_full() .gap_1p5() .child( - Icon::new(provider.icon()) - .size(IconSize::Small) - .color(Color::Muted), + match provider.icon() { + IconOrSvg::Svg(path) => Icon::from_external_svg(path), + IconOrSvg::Icon(name) => Icon::new(name), + } + .size(IconSize::Small) + .color(Color::Muted), ) .child( h_flex() @@ -416,7 +420,7 @@ impl AgentConfiguration { &mut self, cx: &mut Context, ) -> impl IntoElement { - let providers = LanguageModelRegistry::read_global(cx).providers(); + let providers = LanguageModelRegistry::read_global(cx).visible_providers(); let popover_menu = PopoverMenu::new("add-provider-popover") .trigger( diff --git a/crates/agent_ui/src/agent_model_selector.rs b/crates/agent_ui/src/agent_model_selector.rs index ac57ed575d9d1b6de2c53d3e0e4a91b4bd16ab1a..45cefbf2b9f8d4b1639a9849f2ee2e4468e530b1 100644 --- a/crates/agent_ui/src/agent_model_selector.rs +++ b/crates/agent_ui/src/agent_model_selector.rs @@ -4,6 +4,7 @@ use crate::{ }; use fs::Fs; use gpui::{Entity, FocusHandle, SharedString}; +use language_model::IconOrSvg; use picker::popover_menu::PickerPopoverMenu; use settings::update_settings_file; use std::sync::Arc; @@ -103,7 +104,14 @@ impl Render for AgentModelSelector { self.selector.clone(), ButtonLike::new("active-model") .when_some(provider_icon, |this, icon| { - this.child(Icon::new(icon).color(color).size(IconSize::XSmall)) + this.child( + match icon { + IconOrSvg::Svg(path) => Icon::from_external_svg(path), + IconOrSvg::Icon(name) => Icon::new(name), + } + .color(color) + .size(IconSize::XSmall), + ) }) .selected_style(ButtonStyle::Tinted(TintColor::Accent)) .child( @@ -115,7 +123,7 @@ impl Render for AgentModelSelector { .child( Icon::new(IconName::ChevronDown) .color(color) - .size(IconSize::Small), + .size(IconSize::XSmall), ), move |_window, cx| { Tooltip::for_action_in("Change Model", &ToggleModelSelector, &focus_handle, cx) diff --git a/crates/agent_ui/src/agent_panel.rs b/crates/agent_ui/src/agent_panel.rs index 294cd8b4888950f6ea92d6bea1eba78c3d6d6de2..a050f75120cd73949251c09c8424314e3616c705 100644 --- a/crates/agent_ui/src/agent_panel.rs +++ b/crates/agent_ui/src/agent_panel.rs @@ -2428,7 +2428,7 @@ impl AgentPanel { let history_is_empty = self.history_store.read(cx).is_empty(cx); let has_configured_non_zed_providers = LanguageModelRegistry::read_global(cx) - .providers() + .visible_providers() .iter() .any(|provider| { provider.is_authenticated(cx) diff --git a/crates/agent_ui/src/agent_ui.rs b/crates/agent_ui/src/agent_ui.rs index 02cb7e59948b10274302bd8cd6f74f1accbd30a3..401b506b302d9c2a86a36ddce0fc72df075f4c18 100644 --- a/crates/agent_ui/src/agent_ui.rs +++ b/crates/agent_ui/src/agent_ui.rs @@ -348,7 +348,8 @@ fn init_language_model_settings(cx: &mut App) { |_, event: &language_model::Event, cx| match event { language_model::Event::ProviderStateChanged(_) | language_model::Event::AddedProvider(_) - | language_model::Event::RemovedProvider(_) => { + | language_model::Event::RemovedProvider(_) + | language_model::Event::ProvidersChanged => { update_active_language_model_from_settings(cx); } _ => {} diff --git a/crates/agent_ui/src/language_model_selector.rs b/crates/agent_ui/src/language_model_selector.rs index 77c8c95255908dc54639ad7ac6c55f1e8b8151f0..704e340ace35f33f757ab7708f96ffc940a8eb91 100644 --- a/crates/agent_ui/src/language_model_selector.rs +++ b/crates/agent_ui/src/language_model_selector.rs @@ -7,8 +7,8 @@ use gpui::{ Action, AnyElement, App, BackgroundExecutor, DismissEvent, FocusHandle, Subscription, Task, }; use language_model::{ - AuthenticateError, ConfiguredModel, LanguageModel, LanguageModelId, LanguageModelProvider, - LanguageModelProviderId, LanguageModelRegistry, + AuthenticateError, ConfiguredModel, IconOrSvg, LanguageModel, LanguageModelId, + LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry, }; use ordered_float::OrderedFloat; use picker::{Picker, PickerDelegate}; @@ -55,7 +55,7 @@ pub fn language_model_selector( fn all_models(cx: &App) -> GroupedModels { let lm_registry = LanguageModelRegistry::global(cx).read(cx); - let providers = lm_registry.providers(); + let providers = lm_registry.visible_providers(); let mut favorites_index = FavoritesIndex::default(); @@ -94,7 +94,7 @@ type FavoritesIndex = HashMap> #[derive(Clone)] struct ModelInfo { model: Arc, - icon: IconName, + icon: IconOrSvg, is_favorite: bool, } @@ -203,7 +203,7 @@ impl LanguageModelPickerDelegate { fn authenticate_all_providers(cx: &mut App) -> Task<()> { let authenticate_all_providers = LanguageModelRegistry::global(cx) .read(cx) - .providers() + .visible_providers() .iter() .map(|provider| (provider.id(), provider.name(), provider.authenticate(cx))) .collect::>(); @@ -474,7 +474,7 @@ impl PickerDelegate for LanguageModelPickerDelegate { let configured_providers = language_model_registry .read(cx) - .providers() + .visible_providers() .into_iter() .filter(|provider| provider.is_authenticated(cx)) .collect::>(); @@ -566,7 +566,10 @@ impl PickerDelegate for LanguageModelPickerDelegate { Some( ModelSelectorListItem::new(ix, model_info.model.name().0) - .icon(model_info.icon) + .map(|this| match &model_info.icon { + IconOrSvg::Icon(icon_name) => this.icon(*icon_name), + IconOrSvg::Svg(icon_path) => this.icon_path(icon_path.clone()), + }) .is_selected(is_selected) .is_focused(selected) .is_favorite(is_favorite) @@ -702,7 +705,7 @@ mod tests { .any(|(fav_provider, fav_name)| *fav_provider == provider && *fav_name == name); ModelInfo { model: Arc::new(TestLanguageModel::new(name, provider)), - icon: IconName::Ai, + icon: IconOrSvg::Icon(IconName::Ai), is_favorite, } }) diff --git a/crates/agent_ui/src/text_thread_editor.rs b/crates/agent_ui/src/text_thread_editor.rs index 16d12cf261d3bbb8eb0b879394fedc1cc96e046c..514f45528427af89eeccf85512abf850a7a1be05 100644 --- a/crates/agent_ui/src/text_thread_editor.rs +++ b/crates/agent_ui/src/text_thread_editor.rs @@ -33,7 +33,8 @@ use language::{ language_settings::{SoftWrap, all_language_settings}, }; use language_model::{ - ConfigurationError, LanguageModelExt, LanguageModelImage, LanguageModelRegistry, Role, + ConfigurationError, IconOrSvg, LanguageModelExt, LanguageModelImage, LanguageModelRegistry, + Role, }; use multi_buffer::MultiBufferRow; use picker::{Picker, popover_menu::PickerPopoverMenu}; @@ -2231,10 +2232,10 @@ impl TextThreadEditor { .default_model() .map(|default| default.provider); - let provider_icon = match active_provider { - Some(provider) => provider.icon(), - None => IconName::Ai, - }; + let provider_icon = active_provider + .as_ref() + .map(|p| p.icon()) + .unwrap_or(IconOrSvg::Icon(IconName::Ai)); let focus_handle = self.editor().focus_handle(cx); @@ -2244,6 +2245,13 @@ impl TextThreadEditor { (Color::Muted, IconName::ChevronDown) }; + let provider_icon_element = match provider_icon { + IconOrSvg::Svg(path) => Icon::from_external_svg(path), + IconOrSvg::Icon(name) => Icon::new(name), + } + .color(color) + .size(IconSize::XSmall); + let tooltip = Tooltip::element({ move |_, cx| { let focus_handle = focus_handle.clone(); @@ -2291,7 +2299,7 @@ impl TextThreadEditor { .child( h_flex() .gap_0p5() - .child(Icon::new(provider_icon).color(color).size(IconSize::XSmall)) + .child(provider_icon_element) .child( Label::new(model_name) .color(color) diff --git a/crates/agent_ui/src/ui/model_selector_components.rs b/crates/agent_ui/src/ui/model_selector_components.rs index 061b4f58288798696b068a091fb392c033906627..beb0c13d761aa9e7e41c2ac4e35a8cfcc7e8d869 100644 --- a/crates/agent_ui/src/ui/model_selector_components.rs +++ b/crates/agent_ui/src/ui/model_selector_components.rs @@ -1,6 +1,11 @@ use gpui::{Action, FocusHandle, prelude::*}; use ui::{ElevationIndex, KeyBinding, ListItem, ListItemSpacing, Tooltip, prelude::*}; +enum ModelIcon { + Name(IconName), + Path(SharedString), +} + #[derive(IntoElement)] pub struct ModelSelectorHeader { title: SharedString, @@ -39,7 +44,7 @@ impl RenderOnce for ModelSelectorHeader { pub struct ModelSelectorListItem { index: usize, title: SharedString, - icon: Option, + icon: Option, is_selected: bool, is_focused: bool, is_favorite: bool, @@ -60,7 +65,12 @@ impl ModelSelectorListItem { } pub fn icon(mut self, icon: IconName) -> Self { - self.icon = Some(icon); + self.icon = Some(ModelIcon::Name(icon)); + self + } + + pub fn icon_path(mut self, path: SharedString) -> Self { + self.icon = Some(ModelIcon::Path(path)); self } @@ -105,9 +115,12 @@ impl RenderOnce for ModelSelectorListItem { .gap_1p5() .when_some(self.icon, |this, icon| { this.child( - Icon::new(icon) - .color(model_icon_color) - .size(IconSize::Small), + match icon { + ModelIcon::Name(icon_name) => Icon::new(icon_name), + ModelIcon::Path(icon_path) => Icon::from_external_svg(icon_path), + } + .color(model_icon_color) + .size(IconSize::Small), ) }) .child(Label::new(self.title).truncate()), diff --git a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs index fadc4222ae44f3dbad862fd9479b89321dbd3016..47197ec2331b97dd4d7561d9f14c91c7f91c9fa0 100644 --- a/crates/ai_onboarding/src/agent_api_keys_onboarding.rs +++ b/crates/ai_onboarding/src/agent_api_keys_onboarding.rs @@ -1,9 +1,9 @@ use gpui::{Action, IntoElement, ParentElement, RenderOnce, point}; -use language_model::{LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID}; +use language_model::{IconOrSvg, LanguageModelRegistry, ZED_CLOUD_PROVIDER_ID}; use ui::{Divider, List, ListBulletItem, prelude::*}; pub struct ApiKeysWithProviders { - configured_providers: Vec<(IconName, SharedString)>, + configured_providers: Vec<(IconOrSvg, SharedString)>, } impl ApiKeysWithProviders { @@ -13,7 +13,8 @@ impl ApiKeysWithProviders { |this: &mut Self, _registry, event: &language_model::Event, cx| match event { language_model::Event::ProviderStateChanged(_) | language_model::Event::AddedProvider(_) - | language_model::Event::RemovedProvider(_) => { + | language_model::Event::RemovedProvider(_) + | language_model::Event::ProvidersChanged => { this.configured_providers = Self::compute_configured_providers(cx) } _ => {} @@ -26,9 +27,9 @@ impl ApiKeysWithProviders { } } - fn compute_configured_providers(cx: &App) -> Vec<(IconName, SharedString)> { + fn compute_configured_providers(cx: &App) -> Vec<(IconOrSvg, SharedString)> { LanguageModelRegistry::read_global(cx) - .providers() + .visible_providers() .iter() .filter(|provider| { provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID @@ -47,7 +48,14 @@ impl Render for ApiKeysWithProviders { .map(|(icon, name)| { h_flex() .gap_1p5() - .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted)) + .child( + match icon { + IconOrSvg::Icon(icon_name) => Icon::new(icon_name), + IconOrSvg::Svg(icon_path) => Icon::from_external_svg(icon_path), + } + .size(IconSize::XSmall) + .color(Color::Muted), + ) .child(Label::new(name)) }); div() diff --git a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs index 3c8ffc1663e0660829698b5449a006de5b3c6009..c2756927136449d649996ec3b4b87471114aca38 100644 --- a/crates/ai_onboarding/src/agent_panel_onboarding_content.rs +++ b/crates/ai_onboarding/src/agent_panel_onboarding_content.rs @@ -11,7 +11,7 @@ use crate::{AgentPanelOnboardingCard, ApiKeysWithoutProviders, ZedAiOnboarding}; pub struct AgentPanelOnboarding { user_store: Entity, client: Arc, - configured_providers: Vec<(IconName, SharedString)>, + has_configured_providers: bool, continue_with_zed_ai: Arc, } @@ -27,8 +27,9 @@ impl AgentPanelOnboarding { |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) + | language_model::Event::RemovedProvider(_) + | language_model::Event::ProvidersChanged => { + this.has_configured_providers = Self::has_configured_providers(cx) } _ => {} }, @@ -38,20 +39,16 @@ impl AgentPanelOnboarding { Self { user_store, client, - configured_providers: Self::compute_available_providers(cx), + has_configured_providers: Self::has_configured_providers(cx), continue_with_zed_ai: Arc::new(continue_with_zed_ai), } } - fn compute_available_providers(cx: &App) -> Vec<(IconName, SharedString)> { + fn has_configured_providers(cx: &App) -> bool { LanguageModelRegistry::read_global(cx) - .providers() + .visible_providers() .iter() - .filter(|provider| { - provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID - }) - .map(|provider| (provider.icon(), provider.name().0)) - .collect() + .any(|provider| provider.is_authenticated(cx) && provider.id() != ZED_CLOUD_PROVIDER_ID) } } @@ -81,7 +78,7 @@ impl Render for AgentPanelOnboarding { }), ) .map(|this| { - if enrolled_in_trial || is_pro_user || !self.configured_providers.is_empty() { + if enrolled_in_trial || is_pro_user || self.has_configured_providers { this } else { this.child(ApiKeysWithoutProviders::new()) diff --git a/crates/extension/src/extension_host_proxy.rs b/crates/extension/src/extension_host_proxy.rs index 6a24e3ba3f496bd0f0b89d61e9125b29ecae0204..b445878389015d4b3b8c3e25a0d103586462fd86 100644 --- a/crates/extension/src/extension_host_proxy.rs +++ b/crates/extension/src/extension_host_proxy.rs @@ -19,6 +19,9 @@ impl Global for GlobalExtensionHostProxy {} /// /// This object implements each of the individual proxy types so that their /// methods can be called directly on it. +/// Registration function for language model providers. +pub type LanguageModelProviderRegistration = Box; + #[derive(Default)] pub struct ExtensionHostProxy { theme_proxy: RwLock>>, @@ -29,6 +32,7 @@ pub struct ExtensionHostProxy { slash_command_proxy: RwLock>>, context_server_proxy: RwLock>>, debug_adapter_provider_proxy: RwLock>>, + language_model_provider_proxy: RwLock>>, } impl ExtensionHostProxy { @@ -54,6 +58,7 @@ impl ExtensionHostProxy { slash_command_proxy: RwLock::default(), context_server_proxy: RwLock::default(), debug_adapter_provider_proxy: RwLock::default(), + language_model_provider_proxy: RwLock::default(), } } @@ -90,6 +95,15 @@ impl ExtensionHostProxy { .write() .replace(Arc::new(proxy)); } + + pub fn register_language_model_provider_proxy( + &self, + proxy: impl ExtensionLanguageModelProviderProxy, + ) { + self.language_model_provider_proxy + .write() + .replace(Arc::new(proxy)); + } } pub trait ExtensionThemeProxy: Send + Sync + 'static { @@ -446,3 +460,37 @@ impl ExtensionDebugAdapterProviderProxy for ExtensionHostProxy { proxy.unregister_debug_locator(locator_name) } } + +pub trait ExtensionLanguageModelProviderProxy: Send + Sync + 'static { + fn register_language_model_provider( + &self, + provider_id: Arc, + register_fn: LanguageModelProviderRegistration, + cx: &mut App, + ); + + fn unregister_language_model_provider(&self, provider_id: Arc, cx: &mut App); +} + +impl ExtensionLanguageModelProviderProxy for ExtensionHostProxy { + fn register_language_model_provider( + &self, + provider_id: Arc, + register_fn: LanguageModelProviderRegistration, + cx: &mut App, + ) { + let Some(proxy) = self.language_model_provider_proxy.read().clone() else { + return; + }; + + proxy.register_language_model_provider(provider_id, register_fn, cx) + } + + fn unregister_language_model_provider(&self, provider_id: Arc, cx: &mut App) { + let Some(proxy) = self.language_model_provider_proxy.read().clone() else { + return; + }; + + proxy.unregister_language_model_provider(provider_id, cx) + } +} diff --git a/crates/extension/src/extension_manifest.rs b/crates/extension/src/extension_manifest.rs index 4ecdd378ca86dbee263e439e13fa4776dab9e316..39b629db30d0d1cee3374dafc317bdeb0f368146 100644 --- a/crates/extension/src/extension_manifest.rs +++ b/crates/extension/src/extension_manifest.rs @@ -93,6 +93,8 @@ pub struct ExtensionManifest { pub debug_adapters: BTreeMap, DebugAdapterManifestEntry>, #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] pub debug_locators: BTreeMap, DebugLocatorManifestEntry>, + #[serde(default, skip_serializing_if = "BTreeMap::is_empty")] + pub language_model_providers: BTreeMap, LanguageModelProviderManifestEntry>, } impl ExtensionManifest { @@ -288,6 +290,16 @@ pub struct DebugAdapterManifestEntry { #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)] pub struct DebugLocatorManifestEntry {} +/// Manifest entry for a language model provider. +#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)] +pub struct LanguageModelProviderManifestEntry { + /// Display name for the provider. + pub name: String, + /// Path to an SVG icon file relative to the extension root (e.g., "icons/provider.svg"). + #[serde(default)] + pub icon: Option, +} + impl ExtensionManifest { pub async fn load(fs: Arc, extension_dir: &Path) -> Result { let extension_name = extension_dir @@ -358,6 +370,7 @@ fn manifest_from_old_manifest( capabilities: Vec::new(), debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: Default::default(), } } @@ -391,6 +404,7 @@ mod tests { capabilities: vec![], debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: BTreeMap::default(), } } diff --git a/crates/extension_host/benches/extension_compilation_benchmark.rs b/crates/extension_host/benches/extension_compilation_benchmark.rs index a28f617dc36e5cba3ad36d7ab6477e7a665dd5c4..605b98c67071155d8444639ef7043b9c8901161d 100644 --- a/crates/extension_host/benches/extension_compilation_benchmark.rs +++ b/crates/extension_host/benches/extension_compilation_benchmark.rs @@ -148,6 +148,7 @@ fn manifest() -> ExtensionManifest { )], debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: BTreeMap::default(), } } diff --git a/crates/extension_host/src/capability_granter.rs b/crates/extension_host/src/capability_granter.rs index 9f27b5e480bc3c22faefe67cd49a06af21614096..6278deef0a7d41e40d4444ddbe992f007cd5e53e 100644 --- a/crates/extension_host/src/capability_granter.rs +++ b/crates/extension_host/src/capability_granter.rs @@ -113,6 +113,7 @@ mod tests { capabilities: vec![], debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: BTreeMap::default(), } } diff --git a/crates/extension_host/src/extension_store_test.rs b/crates/extension_host/src/extension_store_test.rs index 54b090347ffad3ffed444827f5cb60c120d25ad7..c17484f26a06b3392cdbcd8f3c1578eb43c7b213 100644 --- a/crates/extension_host/src/extension_store_test.rs +++ b/crates/extension_host/src/extension_store_test.rs @@ -165,6 +165,7 @@ async fn test_extension_store(cx: &mut TestAppContext) { capabilities: Vec::new(), debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: BTreeMap::default(), }), dev: false, }, @@ -196,6 +197,7 @@ async fn test_extension_store(cx: &mut TestAppContext) { capabilities: Vec::new(), debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: BTreeMap::default(), }), dev: false, }, @@ -376,6 +378,7 @@ async fn test_extension_store(cx: &mut TestAppContext) { capabilities: Vec::new(), debug_adapters: Default::default(), debug_locators: Default::default(), + language_model_providers: BTreeMap::default(), }), dev: false, }, diff --git a/crates/language_model/src/language_model.rs b/crates/language_model/src/language_model.rs index 09d44b5b408324936af00a2a5e4f1deb4f351434..56a970404419ec6042c463d26c2844eb0904f829 100644 --- a/crates/language_model/src/language_model.rs +++ b/crates/language_model/src/language_model.rs @@ -797,11 +797,26 @@ pub enum AuthenticateError { Other(#[from] anyhow::Error), } +/// Either a built-in icon name or a path to an external SVG. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum IconOrSvg { + /// A built-in icon from Zed's icon set. + Icon(IconName), + /// Path to a custom SVG icon file. + Svg(SharedString), +} + +impl Default for IconOrSvg { + fn default() -> Self { + Self::Icon(IconName::ZedAssistant) + } +} + pub trait LanguageModelProvider: 'static { fn id(&self) -> LanguageModelProviderId; fn name(&self) -> LanguageModelProviderName; - fn icon(&self) -> IconName { - IconName::ZedAssistant + fn icon(&self) -> IconOrSvg { + IconOrSvg::default() } fn default_model(&self, cx: &App) -> Option>; fn default_fast_model(&self, cx: &App) -> Option>; @@ -820,7 +835,7 @@ pub trait LanguageModelProvider: 'static { fn reset_credentials(&self, cx: &mut App) -> Task>; } -#[derive(Default, Clone)] +#[derive(Default, Clone, PartialEq, Eq)] pub enum ConfigurationViewTargetAgent { #[default] ZedAgent, diff --git a/crates/language_model/src/registry.rs b/crates/language_model/src/registry.rs index 27b8309810962981d3c0ec78e6e67dfdfba122bf..cf7718f7b102010cc0c8a981a0425583436176b7 100644 --- a/crates/language_model/src/registry.rs +++ b/crates/language_model/src/registry.rs @@ -2,12 +2,16 @@ use crate::{ LanguageModel, LanguageModelId, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderState, }; -use collections::BTreeMap; +use collections::{BTreeMap, HashSet}; use gpui::{App, Context, Entity, EventEmitter, Global, prelude::*}; use std::{str::FromStr, sync::Arc}; use thiserror::Error; use util::maybe; +/// Function type for checking if a built-in provider should be hidden. +/// Returns Some(extension_id) if the provider should be hidden when that extension is installed. +pub type BuiltinProviderHidingFn = Box Option<&'static str> + Send + Sync>; + pub fn init(cx: &mut App) { let registry = cx.new(|_cx| LanguageModelRegistry::default()); cx.set_global(GlobalLanguageModelRegistry(registry)); @@ -48,6 +52,11 @@ pub struct LanguageModelRegistry { thread_summary_model: Option, providers: BTreeMap>, inline_alternatives: Vec>, + /// Set of installed extension IDs that provide language models. + /// Used to determine which built-in providers should be hidden. + installed_llm_extension_ids: HashSet>, + /// Function to check if a built-in provider should be hidden by an extension. + builtin_provider_hiding_fn: Option, } #[derive(Debug)] @@ -104,6 +113,8 @@ pub enum Event { ProviderStateChanged(LanguageModelProviderId), AddedProvider(LanguageModelProviderId), RemovedProvider(LanguageModelProviderId), + /// Emitted when provider visibility changes due to extension install/uninstall. + ProvidersChanged, } impl EventEmitter for LanguageModelRegistry {} @@ -183,6 +194,60 @@ impl LanguageModelRegistry { providers } + /// Returns providers, filtering out hidden built-in providers. + pub fn visible_providers(&self) -> Vec> { + self.providers() + .into_iter() + .filter(|p| !self.should_hide_provider(&p.id())) + .collect() + } + + /// Sets the function used to check if a built-in provider should be hidden. + pub fn set_builtin_provider_hiding_fn(&mut self, hiding_fn: BuiltinProviderHidingFn) { + self.builtin_provider_hiding_fn = Some(hiding_fn); + } + + /// Called when an extension is installed/loaded. + /// If the extension provides language models, track it so we can hide the corresponding built-in. + pub fn extension_installed(&mut self, extension_id: Arc, cx: &mut Context) { + if self.installed_llm_extension_ids.insert(extension_id) { + cx.emit(Event::ProvidersChanged); + cx.notify(); + } + } + + /// Called when an extension is uninstalled/unloaded. + pub fn extension_uninstalled(&mut self, extension_id: &str, cx: &mut Context) { + if self.installed_llm_extension_ids.remove(extension_id) { + cx.emit(Event::ProvidersChanged); + cx.notify(); + } + } + + /// Sync the set of installed LLM extension IDs. + pub fn sync_installed_llm_extensions( + &mut self, + extension_ids: HashSet>, + cx: &mut Context, + ) { + if extension_ids != self.installed_llm_extension_ids { + self.installed_llm_extension_ids = extension_ids; + cx.emit(Event::ProvidersChanged); + cx.notify(); + } + } + + /// Returns true if a provider should be hidden from the UI. + /// Built-in providers are hidden when their corresponding extension is installed. + pub fn should_hide_provider(&self, provider_id: &LanguageModelProviderId) -> bool { + if let Some(ref hiding_fn) = self.builtin_provider_hiding_fn { + if let Some(extension_id) = hiding_fn(&provider_id.0) { + return self.installed_llm_extension_ids.contains(extension_id); + } + } + false + } + pub fn configuration_error( &self, model: Option, @@ -416,4 +481,132 @@ mod tests { let providers = registry.read(cx).providers(); assert!(providers.is_empty()); } + + #[gpui::test] + fn test_provider_hiding_on_extension_install(cx: &mut App) { + let registry = cx.new(|_| LanguageModelRegistry::default()); + + let provider = Arc::new(FakeLanguageModelProvider::default()); + let provider_id = provider.id(); + + registry.update(cx, |registry, cx| { + registry.register_provider(provider.clone(), cx); + + registry.set_builtin_provider_hiding_fn(Box::new(|id| { + if id == "fake" { + Some("fake-extension") + } else { + None + } + })); + }); + + let visible = registry.read(cx).visible_providers(); + assert_eq!(visible.len(), 1); + assert_eq!(visible[0].id(), provider_id); + + registry.update(cx, |registry, cx| { + registry.extension_installed("fake-extension".into(), cx); + }); + + let visible = registry.read(cx).visible_providers(); + assert!(visible.is_empty()); + + let all = registry.read(cx).providers(); + assert_eq!(all.len(), 1); + } + + #[gpui::test] + fn test_provider_unhiding_on_extension_uninstall(cx: &mut App) { + let registry = cx.new(|_| LanguageModelRegistry::default()); + + let provider = Arc::new(FakeLanguageModelProvider::default()); + let provider_id = provider.id(); + + registry.update(cx, |registry, cx| { + registry.register_provider(provider.clone(), cx); + + registry.set_builtin_provider_hiding_fn(Box::new(|id| { + if id == "fake" { + Some("fake-extension") + } else { + None + } + })); + + registry.extension_installed("fake-extension".into(), cx); + }); + + let visible = registry.read(cx).visible_providers(); + assert!(visible.is_empty()); + + registry.update(cx, |registry, cx| { + registry.extension_uninstalled("fake-extension", cx); + }); + + let visible = registry.read(cx).visible_providers(); + assert_eq!(visible.len(), 1); + assert_eq!(visible[0].id(), provider_id); + } + + #[gpui::test] + fn test_should_hide_provider(cx: &mut App) { + let registry = cx.new(|_| LanguageModelRegistry::default()); + + registry.update(cx, |registry, cx| { + registry.set_builtin_provider_hiding_fn(Box::new(|id| { + if id == "anthropic" { + Some("anthropic") + } else if id == "openai" { + Some("openai") + } else { + None + } + })); + + registry.extension_installed("anthropic".into(), cx); + }); + + let registry_read = registry.read(cx); + + assert!(registry_read.should_hide_provider(&LanguageModelProviderId("anthropic".into()))); + + assert!(!registry_read.should_hide_provider(&LanguageModelProviderId("openai".into()))); + + assert!(!registry_read.should_hide_provider(&LanguageModelProviderId("unknown".into()))); + } + + #[gpui::test] + fn test_sync_installed_llm_extensions(cx: &mut App) { + let registry = cx.new(|_| LanguageModelRegistry::default()); + + let provider = Arc::new(FakeLanguageModelProvider::default()); + + registry.update(cx, |registry, cx| { + registry.register_provider(provider.clone(), cx); + + registry.set_builtin_provider_hiding_fn(Box::new(|id| { + if id == "fake" { + Some("fake-extension") + } else { + None + } + })); + }); + + let mut extension_ids = HashSet::default(); + extension_ids.insert(Arc::from("fake-extension")); + + registry.update(cx, |registry, cx| { + registry.sync_installed_llm_extensions(extension_ids, cx); + }); + + assert!(registry.read(cx).visible_providers().is_empty()); + + registry.update(cx, |registry, cx| { + registry.sync_installed_llm_extensions(HashSet::default(), cx); + }); + + assert_eq!(registry.read(cx).visible_providers().len(), 1); + } } diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml index 5531e698ab7fccae736e800f38b16e35bcd35ac4..1bec5d94d2bb35f91305c6c77a9e85ed8579e1af 100644 --- a/crates/language_models/Cargo.toml +++ b/crates/language_models/Cargo.toml @@ -28,6 +28,8 @@ convert_case.workspace = true copilot.workspace = true credentials_provider.workspace = true deepseek = { workspace = true, features = ["schemars"] } +extension.workspace = true +extension_host.workspace = true fs.workspace = true futures.workspace = true google_ai = { workspace = true, features = ["schemars"] } diff --git a/crates/language_models/src/extension.rs b/crates/language_models/src/extension.rs new file mode 100644 index 0000000000000000000000000000000000000000..e0b46ab5e1d667fb61449a654769ecf7c221e720 --- /dev/null +++ b/crates/language_models/src/extension.rs @@ -0,0 +1,67 @@ +use collections::HashMap; +use extension::{ + ExtensionHostProxy, ExtensionLanguageModelProviderProxy, LanguageModelProviderRegistration, +}; +use gpui::{App, Entity}; +use language_model::{LanguageModelProviderId, LanguageModelRegistry}; +use std::sync::{Arc, LazyLock}; + +/// Maps built-in provider IDs to their corresponding extension IDs. +/// When an extension with this ID is installed, the built-in provider should be hidden. +static BUILTIN_TO_EXTENSION_MAP: LazyLock> = + LazyLock::new(|| { + let mut map = HashMap::default(); + map.insert("anthropic", "anthropic"); + map.insert("openai", "openai"); + map.insert("google", "google-ai"); + map.insert("openrouter", "openrouter"); + map.insert("copilot_chat", "copilot-chat"); + map + }); + +/// Returns the extension ID that should hide the given built-in provider. +pub fn extension_for_builtin_provider(provider_id: &str) -> Option<&'static str> { + BUILTIN_TO_EXTENSION_MAP.get(provider_id).copied() +} + +/// Proxy that registers extension language model providers with the LanguageModelRegistry. +pub struct LanguageModelProviderRegistryProxy { + registry: Entity, +} + +impl LanguageModelProviderRegistryProxy { + pub fn new(registry: Entity) -> Self { + Self { registry } + } +} + +impl ExtensionLanguageModelProviderProxy for LanguageModelProviderRegistryProxy { + fn register_language_model_provider( + &self, + _provider_id: Arc, + register_fn: LanguageModelProviderRegistration, + cx: &mut App, + ) { + register_fn(cx); + } + + fn unregister_language_model_provider(&self, provider_id: Arc, cx: &mut App) { + self.registry.update(cx, |registry, cx| { + registry.unregister_provider(LanguageModelProviderId::from(provider_id), cx); + }); + } +} + +/// Initialize the extension language model provider proxy. +/// This must be called BEFORE extension_host::init to ensure the proxy is available +/// when extensions try to register their language model providers. +pub fn init_proxy(cx: &mut App) { + let proxy = ExtensionHostProxy::default_global(cx); + let registry = LanguageModelRegistry::global(cx); + + registry.update(cx, |registry, _cx| { + registry.set_builtin_provider_hiding_fn(Box::new(extension_for_builtin_provider)); + }); + + proxy.register_language_model_provider_proxy(LanguageModelProviderRegistryProxy::new(registry)); +} diff --git a/crates/language_models/src/language_models.rs b/crates/language_models/src/language_models.rs index 1038f5e233e0a5970b0e8bd969a65f6f0e2a7550..37d4ca5ddd4e5c1e7a0202c88c012d18b018cd4f 100644 --- a/crates/language_models/src/language_models.rs +++ b/crates/language_models/src/language_models.rs @@ -7,9 +7,12 @@ use gpui::{App, Context, Entity}; use language_model::{LanguageModelProviderId, LanguageModelRegistry}; use provider::deepseek::DeepSeekLanguageModelProvider; +pub mod extension; pub mod provider; mod settings; +pub use crate::extension::init_proxy as init_extension_proxy; + use crate::provider::anthropic::AnthropicLanguageModelProvider; use crate::provider::bedrock::BedrockLanguageModelProvider; use crate::provider::cloud::CloudLanguageModelProvider; @@ -31,6 +34,56 @@ pub fn init(user_store: Entity, client: Arc, cx: &mut App) { register_language_model_providers(registry, user_store, client.clone(), cx); }); + // Subscribe to extension store events to track LLM extension installations + if let Some(extension_store) = extension_host::ExtensionStore::try_global(cx) { + cx.subscribe(&extension_store, { + let registry = registry.clone(); + move |extension_store, event, cx| match event { + extension_host::Event::ExtensionInstalled(extension_id) => { + if let Some(manifest) = extension_store + .read(cx) + .extension_manifest_for_id(extension_id) + { + if !manifest.language_model_providers.is_empty() { + registry.update(cx, |registry, cx| { + registry.extension_installed(extension_id.clone(), cx); + }); + } + } + } + extension_host::Event::ExtensionUninstalled(extension_id) => { + registry.update(cx, |registry, cx| { + registry.extension_uninstalled(extension_id, cx); + }); + } + extension_host::Event::ExtensionsUpdated => { + let mut new_ids = HashSet::default(); + for (extension_id, entry) in extension_store.read(cx).installed_extensions() { + if !entry.manifest.language_model_providers.is_empty() { + new_ids.insert(extension_id.clone()); + } + } + registry.update(cx, |registry, cx| { + registry.sync_installed_llm_extensions(new_ids, cx); + }); + } + _ => {} + } + }) + .detach(); + + // Initialize with currently installed extensions + registry.update(cx, |registry, cx| { + let mut initial_ids = HashSet::default(); + for (extension_id, entry) in extension_store.read(cx).installed_extensions() { + if !entry.manifest.language_model_providers.is_empty() { + initial_ids.insert(extension_id.clone()); + } + } + registry.sync_installed_llm_extensions(initial_ids, cx); + }); + } + let mut openai_compatible_providers = AllLanguageModelSettings::get_global(cx) .openai_compatible .keys() diff --git a/crates/language_models/src/provider/anthropic.rs b/crates/language_models/src/provider/anthropic.rs index d8c972399c33922386bfba4236e1369d03d338dc..598834f85c496cd54ddd956089715cac64420202 100644 --- a/crates/language_models/src/provider/anthropic.rs +++ b/crates/language_models/src/provider/anthropic.rs @@ -8,7 +8,7 @@ use futures::{FutureExt, Stream, StreamExt, future, future::BoxFuture, stream::B use gpui::{AnyView, App, AsyncApp, Context, Entity, Task}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, ConfigurationViewTargetAgent, EnvVar, LanguageModel, + ApiKeyState, AuthenticateError, ConfigurationViewTargetAgent, EnvVar, IconOrSvg, LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, @@ -125,8 +125,8 @@ impl LanguageModelProvider for AnthropicLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiAnthropic + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiAnthropic) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/bedrock.rs b/crates/language_models/src/provider/bedrock.rs index 286f9ec1a4bf67c22868cf83e00e7b46e0737ba8..62237fbf376a0739fd2518bda44f51149b3457df 100644 --- a/crates/language_models/src/provider/bedrock.rs +++ b/crates/language_models/src/provider/bedrock.rs @@ -30,7 +30,7 @@ use gpui::{ use gpui_tokio::Tokio; use http_client::HttpClient; use language_model::{ - AuthenticateError, EnvVar, LanguageModel, LanguageModelCacheConfiguration, + AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, @@ -426,8 +426,8 @@ impl LanguageModelProvider for BedrockLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiBedrock + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiBedrock) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/cloud.rs b/crates/language_models/src/provider/cloud.rs index def1cef84d3166d08dcc7638ca5a29cabbd149c5..65a42740eb9a8aff830d7544ed5aa972c6697d88 100644 --- a/crates/language_models/src/provider/cloud.rs +++ b/crates/language_models/src/provider/cloud.rs @@ -19,7 +19,7 @@ use gpui::{AnyElement, AnyView, App, AsyncApp, Context, Entity, Subscription, Ta use http_client::http::{HeaderMap, HeaderValue}; use http_client::{AsyncBody, HttpClient, HttpRequestExt, Method, Response, StatusCode}; use language_model::{ - AuthenticateError, LanguageModel, LanguageModelCacheConfiguration, + AuthenticateError, IconOrSvg, LanguageModel, LanguageModelCacheConfiguration, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, @@ -304,8 +304,8 @@ impl LanguageModelProvider for CloudLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiZed + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiZed) } fn default_model(&self, cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/copilot_chat.rs b/crates/language_models/src/provider/copilot_chat.rs index 70198b337e467e1618192e781d3e3be305fea9c5..68eaab1dbed33a8d983de6a919b75dc809410a70 100644 --- a/crates/language_models/src/provider/copilot_chat.rs +++ b/crates/language_models/src/provider/copilot_chat.rs @@ -18,12 +18,12 @@ use gpui::{AnyView, App, AsyncApp, Entity, Subscription, Task}; use http_client::StatusCode; use language::language_settings::all_language_settings; use language_model::{ - AuthenticateError, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, - LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, - LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, - LanguageModelRequestMessage, LanguageModelToolChoice, LanguageModelToolResultContent, - LanguageModelToolSchemaFormat, LanguageModelToolUse, MessageContent, RateLimiter, Role, - StopReason, TokenUsage, + AuthenticateError, IconOrSvg, LanguageModel, LanguageModelCompletionError, + LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, + LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, + LanguageModelRequest, LanguageModelRequestMessage, LanguageModelToolChoice, + LanguageModelToolResultContent, LanguageModelToolSchemaFormat, LanguageModelToolUse, + MessageContent, RateLimiter, Role, StopReason, TokenUsage, }; use settings::SettingsStore; use ui::prelude::*; @@ -104,8 +104,8 @@ impl LanguageModelProvider for CopilotChatLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::Copilot + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::Copilot) } fn default_model(&self, cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/deepseek.rs b/crates/language_models/src/provider/deepseek.rs index b00a5d82f5665a5c87c662d1af84fbeb9ac07ebb..b3264b869195aa34d7083cd31992d8c220d20349 100644 --- a/crates/language_models/src/provider/deepseek.rs +++ b/crates/language_models/src/provider/deepseek.rs @@ -7,7 +7,7 @@ use futures::{FutureExt, StreamExt, future, future::BoxFuture, stream::BoxStream use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, @@ -127,8 +127,8 @@ impl LanguageModelProvider for DeepSeekLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiDeepSeek + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiDeepSeek) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/google.rs b/crates/language_models/src/provider/google.rs index 989b99061b6d0f4c6680f08616c55946138ae0fe..7d567d60f405c7880cb6494f6d2ff604d7f53ac2 100644 --- a/crates/language_models/src/provider/google.rs +++ b/crates/language_models/src/provider/google.rs @@ -14,7 +14,7 @@ use language_model::{ LanguageModelToolUse, LanguageModelToolUseId, MessageContent, StopReason, }; use language_model::{ - LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, + IconOrSvg, LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role, }; @@ -164,8 +164,8 @@ impl LanguageModelProvider for GoogleLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiGoogle + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiGoogle) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/lmstudio.rs b/crates/language_models/src/provider/lmstudio.rs index 94f99f10afc8928fb7fbc8526ab46e7dca37a5ce..237b64ac7d0ed728b057f6b553ad2a2a1ebae1db 100644 --- a/crates/language_models/src/provider/lmstudio.rs +++ b/crates/language_models/src/provider/lmstudio.rs @@ -10,7 +10,7 @@ use language_model::{ StopReason, TokenUsage, }; use language_model::{ - LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, + IconOrSvg, LanguageModel, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, RateLimiter, Role, }; @@ -175,8 +175,8 @@ impl LanguageModelProvider for LmStudioLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiLmStudio + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiLmStudio) } fn default_model(&self, _: &App) -> Option> { diff --git a/crates/language_models/src/provider/mistral.rs b/crates/language_models/src/provider/mistral.rs index 64f3999e3aa96b2611e265a6eaf5df8063332c2a..0b8af405ade8fc00c0d1e2e57ba115560d94a71d 100644 --- a/crates/language_models/src/provider/mistral.rs +++ b/crates/language_models/src/provider/mistral.rs @@ -5,7 +5,7 @@ use futures::{FutureExt, Stream, StreamExt, future, future::BoxFuture, stream::B use gpui::{AnyView, App, AsyncApp, Context, Entity, Global, SharedString, Task, Window}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, @@ -176,8 +176,8 @@ impl LanguageModelProvider for MistralLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiMistral + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiMistral) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/ollama.rs b/crates/language_models/src/provider/ollama.rs index 860d635b6ac704c2762023c463432bebae08d4a5..f5d8820e710ea6c9f89de6da5a7aae2f204c6470 100644 --- a/crates/language_models/src/provider/ollama.rs +++ b/crates/language_models/src/provider/ollama.rs @@ -5,7 +5,7 @@ use futures::{Stream, TryFutureExt, stream}; use gpui::{AnyView, App, AsyncApp, Context, CursorStyle, Entity, Task}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelRequestTool, LanguageModelToolChoice, LanguageModelToolUse, @@ -221,8 +221,8 @@ impl LanguageModelProvider for OllamaLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiOllama + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiOllama) } fn default_model(&self, _: &App) -> Option> { diff --git a/crates/language_models/src/provider/open_ai.rs b/crates/language_models/src/provider/open_ai.rs index afaffba3e53eb2496f9fae795d69b9e9c9f57249..905d2b37862eebf57c7fb56a540b388338cfd065 100644 --- a/crates/language_models/src/provider/open_ai.rs +++ b/crates/language_models/src/provider/open_ai.rs @@ -5,7 +5,7 @@ use futures::{FutureExt, StreamExt, future, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, @@ -122,8 +122,8 @@ impl LanguageModelProvider for OpenAiLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiOpenAi + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiOpenAi) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/open_ai_compatible.rs b/crates/language_models/src/provider/open_ai_compatible.rs index e6e7a9984da3d48b9e3c0f9571b8e916359fba03..f95f567739d76670d3cfa7b835bbfaf34ddef92f 100644 --- a/crates/language_models/src/provider/open_ai_compatible.rs +++ b/crates/language_models/src/provider/open_ai_compatible.rs @@ -4,7 +4,7 @@ use futures::{FutureExt, StreamExt, future, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolSchemaFormat, RateLimiter, @@ -133,8 +133,8 @@ impl LanguageModelProvider for OpenAiCompatibleLanguageModelProvider { self.name.clone() } - fn icon(&self) -> IconName { - IconName::AiOpenAiCompat + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiOpenAiCompat) } fn default_model(&self, cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/open_router.rs b/crates/language_models/src/provider/open_router.rs index ad2e90d9dd5f4ece7e2582a867da50f6962c981c..48d68ddebff7e0c9bbe39dbca696dd2ffcf62605 100644 --- a/crates/language_models/src/provider/open_router.rs +++ b/crates/language_models/src/provider/open_router.rs @@ -4,7 +4,7 @@ use futures::{FutureExt, Stream, StreamExt, future, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolResultContent, @@ -180,8 +180,8 @@ impl LanguageModelProvider for OpenRouterLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiOpenRouter + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiOpenRouter) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/vercel.rs b/crates/language_models/src/provider/vercel.rs index 4dfe848df80123dc4c37d27b81f76db359e076f9..e2e692eafff94c56d481dfc2bd96dbfa7adda262 100644 --- a/crates/language_models/src/provider/vercel.rs +++ b/crates/language_models/src/provider/vercel.rs @@ -4,7 +4,7 @@ use futures::{FutureExt, StreamExt, future, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, SharedString, Task, Window}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, RateLimiter, Role, env_var, @@ -117,8 +117,8 @@ impl LanguageModelProvider for VercelLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiVZero + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiVZero) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/language_models/src/provider/x_ai.rs b/crates/language_models/src/provider/x_ai.rs index 19c50d71cf4e483b68d48c8b982a975f3091ff46..f0aa0e71a83ae1a201d76a33f63ca0aadc6936a9 100644 --- a/crates/language_models/src/provider/x_ai.rs +++ b/crates/language_models/src/provider/x_ai.rs @@ -4,7 +4,7 @@ use futures::{FutureExt, StreamExt, future, future::BoxFuture}; use gpui::{AnyView, App, AsyncApp, Context, Entity, Task, Window}; use http_client::HttpClient; use language_model::{ - ApiKeyState, AuthenticateError, EnvVar, LanguageModel, LanguageModelCompletionError, + ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState, LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolSchemaFormat, RateLimiter, @@ -118,8 +118,8 @@ impl LanguageModelProvider for XAiLanguageModelProvider { PROVIDER_NAME } - fn icon(&self) -> IconName { - IconName::AiXAi + fn icon(&self) -> IconOrSvg { + IconOrSvg::Icon(IconName::AiXAi) } fn default_model(&self, _cx: &App) -> Option> { diff --git a/crates/ui/src/components/icon.rs b/crates/ui/src/components/icon.rs index 1c8e36ec18d6184b38eb6772e8f5a13be181ae00..9d2c7ae3b515744125879f4a2c0e0d3e9a4fb841 100644 --- a/crates/ui/src/components/icon.rs +++ b/crates/ui/src/components/icon.rs @@ -126,17 +126,6 @@ enum IconSource { ExternalSvg(SharedString), } -impl IconSource { - fn from_path(path: impl Into) -> Self { - let path = path.into(); - if path.starts_with("icons/") { - Self::Embedded(path) - } else { - Self::External(Arc::from(PathBuf::from(path.as_ref()))) - } - } -} - #[derive(IntoElement, RegisterComponent)] pub struct Icon { source: IconSource, @@ -155,9 +144,18 @@ impl Icon { } } + /// Create an icon from a path. Uses a heuristic to determine if it's embedded or external: + /// - Paths starting with "icons/" are treated as embedded SVGs + /// - Other paths are treated as external raster images (from icon themes) pub fn from_path(path: impl Into) -> Self { + let path = path.into(); + let source = if path.starts_with("icons/") { + IconSource::Embedded(path) + } else { + IconSource::External(Arc::from(PathBuf::from(path.as_ref()))) + }; Self { - source: IconSource::from_path(path), + source, color: Color::default(), size: IconSize::default().rems(), transformation: Transformation::default(), From 6976208e21436e88a4a5a094b440d41c482c5c84 Mon Sep 17 00:00:00 2001 From: Conrad Irwin Date: Thu, 18 Dec 2025 15:23:09 -0700 Subject: [PATCH 207/266] Move autofix stuff to zippy (#45304) Although I wanted to avoid the dependency, it's hard to get github to do what we want. Release Notes: - N/A --- .github/workflows/extension_tests.yml | 3 +- .github/workflows/release.yml | 16 +--- .github/workflows/release_nightly.yml | 6 +- .github/workflows/run_tests.yml | 47 ++---------- .../xtask/src/tasks/workflows/run_tests.rs | 73 +------------------ tooling/xtask/src/tasks/workflows/steps.rs | 33 +-------- 6 files changed, 19 insertions(+), 159 deletions(-) diff --git a/.github/workflows/extension_tests.yml b/.github/workflows/extension_tests.yml index 7a7fff9b97d694c1b02dd426f5d59301fe2be81e..9f0917e388c74cffed8f342f7504bc111e6f5147 100644 --- a/.github/workflows/extension_tests.yml +++ b/.github/workflows/extension_tests.yml @@ -61,8 +61,7 @@ jobs: uses: namespacelabs/nscloud-cache-action@v1 with: cache: rust - - id: cargo_fmt - name: steps::cargo_fmt + - name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} - name: extension_tests::run_clippy diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 317d5a8df37a62887ce4ddcdd67c8d77b48d56d6..ffc2554a55e00a5bdb7bd1ee0bfeebd5667755d5 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -26,8 +26,7 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - name: steps::clear_target_dir_if_large @@ -72,15 +71,9 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - - id: record_clippy_failure - name: steps::record_clippy_failure - if: always() - run: echo "failed=${{ steps.clippy.outcome == 'failure' }}" >> "$GITHUB_OUTPUT" - shell: bash -euxo pipefail {0} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large @@ -94,8 +87,6 @@ jobs: run: | rm -rf ./../.cargo shell: bash -euxo pipefail {0} - outputs: - clippy_failed: ${{ steps.record_clippy_failure.outputs.failed == 'true' }} timeout-minutes: 60 run_tests_windows: if: (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions') @@ -114,8 +105,7 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy.ps1 shell: pwsh - name: steps::clear_target_dir_if_large diff --git a/.github/workflows/release_nightly.yml b/.github/workflows/release_nightly.yml index b23e4b7518a672c0d586ea5ba437db5cf8f94bb6..d76244175accc3e816cbd7d5dc322d2529a0a236 100644 --- a/.github/workflows/release_nightly.yml +++ b/.github/workflows/release_nightly.yml @@ -20,8 +20,7 @@ jobs: with: clean: false fetch-depth: 0 - - id: cargo_fmt - name: steps::cargo_fmt + - name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} - name: ./script/clippy @@ -45,8 +44,7 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy.ps1 shell: pwsh - name: steps::clear_target_dir_if_large diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index fac3221d63a080fa53b7ba1c5b7249e6a405c73c..256bb2916a56485c06c2ebc4de8724151d622c4f 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -74,19 +74,12 @@ jobs: uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 with: version: '9' - - id: prettier - name: steps::prettier + - name: steps::prettier run: ./script/prettier shell: bash -euxo pipefail {0} - - id: cargo_fmt - name: steps::cargo_fmt + - name: steps::cargo_fmt run: cargo fmt --all -- --check shell: bash -euxo pipefail {0} - - id: record_style_failure - name: steps::record_style_failure - if: always() - run: echo "failed=${{ steps.prettier.outcome == 'failure' || steps.cargo_fmt.outcome == 'failure' }}" >> "$GITHUB_OUTPUT" - shell: bash -euxo pipefail {0} - name: ./script/check-todos run: ./script/check-todos shell: bash -euxo pipefail {0} @@ -97,8 +90,6 @@ jobs: uses: crate-ci/typos@2d0ce569feab1f8752f1dde43cc2f2aa53236e06 with: config: ./typos.toml - outputs: - style_failed: ${{ steps.record_style_failure.outputs.failed == 'true' }} timeout-minutes: 60 run_tests_windows: needs: @@ -119,8 +110,7 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy.ps1 shell: pwsh - name: steps::clear_target_dir_if_large @@ -167,15 +157,9 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - - id: record_clippy_failure - name: steps::record_clippy_failure - if: always() - run: echo "failed=${{ steps.clippy.outcome == 'failure' }}" >> "$GITHUB_OUTPUT" - shell: bash -euxo pipefail {0} - name: steps::cargo_install_nextest uses: taiki-e/install-action@nextest - name: steps::clear_target_dir_if_large @@ -189,8 +173,6 @@ jobs: run: | rm -rf ./../.cargo shell: bash -euxo pipefail {0} - outputs: - clippy_failed: ${{ steps.record_clippy_failure.outputs.failed == 'true' }} timeout-minutes: 60 run_tests_mac: needs: @@ -211,8 +193,7 @@ jobs: uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 with: node-version: '20' - - id: clippy - name: steps::clippy + - name: steps::clippy run: ./script/clippy shell: bash -euxo pipefail {0} - name: steps::clear_target_dir_if_large @@ -592,24 +573,6 @@ jobs: exit $EXIT_CODE shell: bash -euxo pipefail {0} - call_autofix: - needs: - - check_style - - run_tests_linux - if: always() && (needs.check_style.outputs.style_failed == 'true' || needs.run_tests_linux.outputs.clippy_failed == 'true') && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]' - runs-on: namespace-profile-2x4-ubuntu-2404 - steps: - - id: get-app-token - name: steps::authenticate_as_zippy - uses: actions/create-github-app-token@bef1eaf1c0ac2b148ee2a0a74c65fbe6db0631f1 - with: - app-id: ${{ secrets.ZED_ZIPPY_APP_ID }} - private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }} - - name: run_tests::call_autofix::dispatch_autofix - run: gh workflow run autofix_pr.yml -f pr_number=${{ github.event.pull_request.number }} -f run_clippy=${{ needs.run_tests_linux.outputs.clippy_failed == 'true' }} - shell: bash -euxo pipefail {0} - env: - GITHUB_TOKEN: ${{ steps.get-app-token.outputs.token }} concurrency: group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.ref_name == 'main' && github.sha || 'anysha' }} cancel-in-progress: true diff --git a/tooling/xtask/src/tasks/workflows/run_tests.rs b/tooling/xtask/src/tasks/workflows/run_tests.rs index d0caab82b057f21735b7f828c8917a358dd548b2..f726f48740eb7819fbbd3fed369e5e4e89c526c9 100644 --- a/tooling/xtask/src/tasks/workflows/run_tests.rs +++ b/tooling/xtask/src/tasks/workflows/run_tests.rs @@ -45,15 +45,11 @@ pub(crate) fn run_tests() -> Workflow { &should_run_tests, ]); - let check_style = check_style(); - let run_tests_linux = run_platform_tests(Platform::Linux); - let call_autofix = call_autofix(&check_style, &run_tests_linux); - let mut jobs = vec![ orchestrate, - check_style, + check_style(), should_run_tests.guard(run_platform_tests(Platform::Windows)), - should_run_tests.guard(run_tests_linux), + should_run_tests.guard(run_platform_tests(Platform::Linux)), should_run_tests.guard(run_platform_tests(Platform::Mac)), should_run_tests.guard(doctests()), should_run_tests.guard(check_workspace_binaries()), @@ -110,7 +106,6 @@ pub(crate) fn run_tests() -> Workflow { workflow }) .add_job(tests_pass.name, tests_pass.job) - .add_job(call_autofix.name, call_autofix.job) } // Generates a bash script that checks changed files against regex patterns @@ -226,8 +221,6 @@ pub fn tests_pass(jobs: &[NamedJob]) -> NamedJob { named::job(job) } -pub const STYLE_FAILED_OUTPUT: &str = "style_failed"; - fn check_style() -> NamedJob { fn check_for_typos() -> Step { named::uses( @@ -245,56 +238,12 @@ fn check_style() -> NamedJob { .add_step(steps::setup_pnpm()) .add_step(steps::prettier()) .add_step(steps::cargo_fmt()) - .add_step(steps::record_style_failure()) .add_step(steps::script("./script/check-todos")) .add_step(steps::script("./script/check-keymaps")) - .add_step(check_for_typos()) - .outputs([( - STYLE_FAILED_OUTPUT.to_owned(), - format!( - "${{{{ steps.{}.outputs.failed == 'true' }}}}", - steps::RECORD_STYLE_FAILURE_STEP_ID - ), - )]), + .add_step(check_for_typos()), ) } -fn call_autofix(check_style: &NamedJob, run_tests_linux: &NamedJob) -> NamedJob { - fn dispatch_autofix(run_tests_linux_name: &str) -> Step { - let clippy_failed_expr = format!( - "needs.{}.outputs.{} == 'true'", - run_tests_linux_name, CLIPPY_FAILED_OUTPUT - ); - named::bash(format!( - "gh workflow run autofix_pr.yml -f pr_number=${{{{ github.event.pull_request.number }}}} -f run_clippy=${{{{ {} }}}}", - clippy_failed_expr - )) - .add_env(("GITHUB_TOKEN", "${{ steps.get-app-token.outputs.token }}")) - } - - let style_failed_expr = format!( - "needs.{}.outputs.{} == 'true'", - check_style.name, STYLE_FAILED_OUTPUT - ); - let clippy_failed_expr = format!( - "needs.{}.outputs.{} == 'true'", - run_tests_linux.name, CLIPPY_FAILED_OUTPUT - ); - let (authenticate, _token) = steps::authenticate_as_zippy(); - - let job = Job::default() - .runs_on(runners::LINUX_SMALL) - .cond(Expression::new(format!( - "always() && ({} || {}) && github.event_name == 'pull_request' && github.actor != 'zed-zippy[bot]'", - style_failed_expr, clippy_failed_expr - ))) - .needs(vec![check_style.name.clone(), run_tests_linux.name.clone()]) - .add_step(authenticate) - .add_step(dispatch_autofix(&run_tests_linux.name)); - - named::job(job) -} - fn check_dependencies() -> NamedJob { fn install_cargo_machete() -> Step { named::uses( @@ -355,8 +304,6 @@ fn check_workspace_binaries() -> NamedJob { ) } -pub const CLIPPY_FAILED_OUTPUT: &str = "clippy_failed"; - pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { let runner = match platform { Platform::Windows => runners::WINDOWS_DEFAULT, @@ -378,24 +325,12 @@ pub(crate) fn run_platform_tests(platform: Platform) -> NamedJob { ) .add_step(steps::setup_node()) .add_step(steps::clippy(platform)) - .when(platform == Platform::Linux, |job| { - job.add_step(steps::record_clippy_failure()) - }) .when(platform == Platform::Linux, |job| { job.add_step(steps::cargo_install_nextest()) }) .add_step(steps::clear_target_dir_if_large(platform)) .add_step(steps::cargo_nextest(platform)) - .add_step(steps::cleanup_cargo_config(platform)) - .when(platform == Platform::Linux, |job| { - job.outputs([( - CLIPPY_FAILED_OUTPUT.to_owned(), - format!( - "${{{{ steps.{}.outputs.failed == 'true' }}}}", - steps::RECORD_CLIPPY_FAILURE_STEP_ID - ), - )]) - }), + .add_step(steps::cleanup_cargo_config(platform)), } } diff --git a/tooling/xtask/src/tasks/workflows/steps.rs b/tooling/xtask/src/tasks/workflows/steps.rs index eaa51dc35205f51e7fe3a56668ed0679e92999f0..a0b071cd6c31654b42adddbba47dd24c60da7df2 100644 --- a/tooling/xtask/src/tasks/workflows/steps.rs +++ b/tooling/xtask/src/tasks/workflows/steps.rs @@ -54,25 +54,12 @@ pub fn setup_sentry() -> Step { .add_with(("token", vars::SENTRY_AUTH_TOKEN)) } -pub const PRETTIER_STEP_ID: &str = "prettier"; -pub const CARGO_FMT_STEP_ID: &str = "cargo_fmt"; -pub const RECORD_STYLE_FAILURE_STEP_ID: &str = "record_style_failure"; - pub fn prettier() -> Step { - named::bash("./script/prettier").id(PRETTIER_STEP_ID) + named::bash("./script/prettier") } pub fn cargo_fmt() -> Step { - named::bash("cargo fmt --all -- --check").id(CARGO_FMT_STEP_ID) -} - -pub fn record_style_failure() -> Step { - named::bash(format!( - "echo \"failed=${{{{ steps.{}.outcome == 'failure' || steps.{}.outcome == 'failure' }}}}\" >> \"$GITHUB_OUTPUT\"", - PRETTIER_STEP_ID, CARGO_FMT_STEP_ID - )) - .id(RECORD_STYLE_FAILURE_STEP_ID) - .if_condition(Expression::new("always()")) + named::bash("cargo fmt --all -- --check") } pub fn cargo_install_nextest() -> Step { @@ -118,25 +105,13 @@ pub fn clear_target_dir_if_large(platform: Platform) -> Step { } } -pub const CLIPPY_STEP_ID: &str = "clippy"; -pub const RECORD_CLIPPY_FAILURE_STEP_ID: &str = "record_clippy_failure"; - pub fn clippy(platform: Platform) -> Step { match platform { - Platform::Windows => named::pwsh("./script/clippy.ps1").id(CLIPPY_STEP_ID), - _ => named::bash("./script/clippy").id(CLIPPY_STEP_ID), + Platform::Windows => named::pwsh("./script/clippy.ps1"), + _ => named::bash("./script/clippy"), } } -pub fn record_clippy_failure() -> Step { - named::bash(format!( - "echo \"failed=${{{{ steps.{}.outcome == 'failure' }}}}\" >> \"$GITHUB_OUTPUT\"", - CLIPPY_STEP_ID - )) - .id(RECORD_CLIPPY_FAILURE_STEP_ID) - .if_condition(Expression::new("always()")) -} - pub fn cache_rust_dependencies_namespace() -> Step { named::uses("namespacelabs", "nscloud-cache-action", "v1").add_with(("cache", "rust")) } From e0ff995e2d5673af67af275187271776b57436d7 Mon Sep 17 00:00:00 2001 From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com> Date: Thu, 18 Dec 2025 22:18:41 -0300 Subject: [PATCH 208/266] agent ui: Make some UI elements more consistent (#45319) - Both the mode, profile, and model selectors have the option to cycle through its options with a keybinding. In the tooltip that shows it, in some of them the "Cycle Through..." label was at the top, and in others at the bottom. Now it's all at the bottom. - We used different language in different places for "going to a file". The tool call edit card's header said "_Jump_ to File" while the edit files list said "_Go_ to File". Now it's both "Go to File". Release Notes: - N/A --- crates/agent_ui/src/acp/mode_selector.rs | 14 +++++++------- crates/agent_ui/src/acp/thread_view.rs | 2 +- crates/agent_ui/src/profile_selector.rs | 6 +++--- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/crates/agent_ui/src/acp/mode_selector.rs b/crates/agent_ui/src/acp/mode_selector.rs index 1f50ce74321d393ba6c7f5083bd889bc3dc2c0e1..22af75a6e96edc4f597819e04e2e84b80ba0417a 100644 --- a/crates/agent_ui/src/acp/mode_selector.rs +++ b/crates/agent_ui/src/acp/mode_selector.rs @@ -188,25 +188,25 @@ impl Render for ModeSelector { .gap_1() .child( h_flex() - .pb_1() .gap_2() .justify_between() - .border_b_1() - .border_color(cx.theme().colors().border_variant) - .child(Label::new("Cycle Through Modes")) + .child(Label::new("Toggle Mode Menu")) .child(KeyBinding::for_action_in( - &CycleModeSelector, + &ToggleProfileSelector, &focus_handle, cx, )), ) .child( h_flex() + .pb_1() .gap_2() .justify_between() - .child(Label::new("Toggle Mode Menu")) + .border_b_1() + .border_color(cx.theme().colors().border_variant) + .child(Label::new("Cycle Through Modes")) .child(KeyBinding::for_action_in( - &ToggleProfileSelector, + &CycleModeSelector, &focus_handle, cx, )), diff --git a/crates/agent_ui/src/acp/thread_view.rs b/crates/agent_ui/src/acp/thread_view.rs index 8364fd8c0f4d8fd55df8f2e74e990e603029db78..32b2de2c0d850676bf7a6a80ee88950d62aa24e0 100644 --- a/crates/agent_ui/src/acp/thread_view.rs +++ b/crates/agent_ui/src/acp/thread_view.rs @@ -2718,7 +2718,7 @@ impl AcpThreadView { ..default_markdown_style(false, true, window, cx) }, )) - .tooltip(Tooltip::text("Jump to File")) + .tooltip(Tooltip::text("Go to File")) .on_click(cx.listener(move |this, _, window, cx| { this.open_tool_call_location(entry_ix, 0, window, cx); })) diff --git a/crates/agent_ui/src/profile_selector.rs b/crates/agent_ui/src/profile_selector.rs index ac08070fcefa92854b51bc8a66d4d388d08e087d..327d2c67e2d5e87e67935ecdfa7fb6cd41acbcb5 100644 --- a/crates/agent_ui/src/profile_selector.rs +++ b/crates/agent_ui/src/profile_selector.rs @@ -191,6 +191,9 @@ impl Render for ProfileSelector { let container = || h_flex().gap_1().justify_between(); v_flex() .gap_1() + .child(container().child(Label::new("Toggle Profile Menu")).child( + KeyBinding::for_action_in(&ToggleProfileSelector, &focus_handle, cx), + )) .child( container() .pb_1() @@ -203,9 +206,6 @@ impl Render for ProfileSelector { cx, )), ) - .child(container().child(Label::new("Toggle Profile Menu")).child( - KeyBinding::for_action_in(&ToggleProfileSelector, &focus_handle, cx), - )) .into_any() } }), From 435d4c5f2415f569d192ee27bf8d6ed5157360f6 Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Thu, 18 Dec 2025 20:56:47 -0600 Subject: [PATCH 209/266] vim: Make `vaf` include const for arrow functions in JS/TS/TSX (#45327) Closes #24264 Release Notes: - N/A *or* Added/Fixed/Improved ... --- .../src/test/editor_lsp_test_context.rs | 86 ++++ crates/language/src/buffer_tests.rs | 98 +++++ crates/language/src/syntax_map.rs | 61 ++- .../languages/src/javascript/textobjects.scm | 38 +- crates/languages/src/tsx/textobjects.scm | 38 +- .../languages/src/typescript/textobjects.scm | 39 +- crates/vim/src/object.rs | 386 ++++++++++++++++++ crates/vim/src/visual.rs | 16 +- 8 files changed, 742 insertions(+), 20 deletions(-) diff --git a/crates/editor/src/test/editor_lsp_test_context.rs b/crates/editor/src/test/editor_lsp_test_context.rs index 7c4c0e48d36dbb9f74a1c835c63fa2b91c5681d9..3e7c47c2ac5efeedde51f180bcfcb424aec31c86 100644 --- a/crates/editor/src/test/editor_lsp_test_context.rs +++ b/crates/editor/src/test/editor_lsp_test_context.rs @@ -205,6 +205,49 @@ impl EditorLspTestContext { (_ "{" "}" @end) @indent (_ "(" ")" @end) @indent "#})), + text_objects: Some(Cow::from(indoc! {r#" + (function_declaration + body: (_ + "{" + (_)* @function.inside + "}")) @function.around + + (method_definition + body: (_ + "{" + (_)* @function.inside + "}")) @function.around + + ; Arrow function in variable declaration - capture the full declaration + ([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + ]) @function.around + + ([ + (lexical_declaration + (variable_declarator + value: (arrow_function))) + (variable_declaration + (variable_declarator + value: (arrow_function))) + ]) @function.around + + ; Catch-all for arrow functions in other contexts (callbacks, etc.) + ((arrow_function) @function.around (#not-has-parent? @function.around variable_declarator)) + "#})), ..Default::default() }) .expect("Could not parse queries"); @@ -276,6 +319,49 @@ impl EditorLspTestContext { (jsx_opening_element) @start (jsx_closing_element)? @end) @indent "#})), + text_objects: Some(Cow::from(indoc! {r#" + (function_declaration + body: (_ + "{" + (_)* @function.inside + "}")) @function.around + + (method_definition + body: (_ + "{" + (_)* @function.inside + "}")) @function.around + + ; Arrow function in variable declaration - capture the full declaration + ([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + ]) @function.around + + ([ + (lexical_declaration + (variable_declarator + value: (arrow_function))) + (variable_declaration + (variable_declarator + value: (arrow_function))) + ]) @function.around + + ; Catch-all for arrow functions in other contexts (callbacks, etc.) + ((arrow_function) @function.around (#not-has-parent? @function.around variable_declarator)) + "#})), ..Default::default() }) .expect("Could not parse queries"); diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rs index 54e2ef4065460547f4a3f86db7d3a3986dff65eb..2c2d93c8239f0f3fcb1de0956de2d3400f13e96b 100644 --- a/crates/language/src/buffer_tests.rs +++ b/crates/language/src/buffer_tests.rs @@ -1141,6 +1141,104 @@ fn test_text_objects(cx: &mut App) { ) } +#[gpui::test] +fn test_text_objects_with_has_parent_predicate(cx: &mut App) { + use std::borrow::Cow; + + // Create a language with a custom text_objects query that uses #has-parent? + // This query only matches closure_expression when it's inside a call_expression + let language = Language::new( + LanguageConfig { + name: "Rust".into(), + matcher: LanguageMatcher { + path_suffixes: vec!["rs".to_string()], + ..Default::default() + }, + ..Default::default() + }, + Some(tree_sitter_rust::LANGUAGE.into()), + ) + .with_queries(LanguageQueries { + text_objects: Some(Cow::from(indoc! {r#" + ; Only match closures that are arguments to function calls + (closure_expression) @function.around + (#has-parent? @function.around arguments) + "#})), + ..Default::default() + }) + .expect("Could not parse queries"); + + let (text, ranges) = marked_text_ranges( + indoc! {r#" + fn main() { + let standalone = |x| x + 1; + let result = foo(|y| y * ˇ2); + }"# + }, + false, + ); + + let buffer = cx.new(|cx| Buffer::local(text.clone(), cx).with_language(Arc::new(language), cx)); + let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot()); + + let matches = snapshot + .text_object_ranges(ranges[0].clone(), TreeSitterOptions::default()) + .map(|(range, text_object)| (&text[range], text_object)) + .collect::>(); + + // Should only match the closure inside foo(), not the standalone closure + assert_eq!(matches, &[("|y| y * 2", TextObject::AroundFunction),]); +} + +#[gpui::test] +fn test_text_objects_with_not_has_parent_predicate(cx: &mut App) { + use std::borrow::Cow; + + // Create a language with a custom text_objects query that uses #not-has-parent? + // This query only matches closure_expression when it's NOT inside a call_expression + let language = Language::new( + LanguageConfig { + name: "Rust".into(), + matcher: LanguageMatcher { + path_suffixes: vec!["rs".to_string()], + ..Default::default() + }, + ..Default::default() + }, + Some(tree_sitter_rust::LANGUAGE.into()), + ) + .with_queries(LanguageQueries { + text_objects: Some(Cow::from(indoc! {r#" + ; Only match closures that are NOT arguments to function calls + (closure_expression) @function.around + (#not-has-parent? @function.around arguments) + "#})), + ..Default::default() + }) + .expect("Could not parse queries"); + + let (text, ranges) = marked_text_ranges( + indoc! {r#" + fn main() { + let standalone = |x| x +ˇ 1; + let result = foo(|y| y * 2); + }"# + }, + false, + ); + + let buffer = cx.new(|cx| Buffer::local(text.clone(), cx).with_language(Arc::new(language), cx)); + let snapshot = buffer.update(cx, |buffer, _| buffer.snapshot()); + + let matches = snapshot + .text_object_ranges(ranges[0].clone(), TreeSitterOptions::default()) + .map(|(range, text_object)| (&text[range], text_object)) + .collect::>(); + + // Should only match the standalone closure, not the one inside foo() + assert_eq!(matches, &[("|x| x + 1", TextObject::AroundFunction),]); +} + #[gpui::test] fn test_enclosing_bracket_ranges(cx: &mut App) { #[track_caller] diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs index 77e90c4ca89d0b6e5b8cb0a604175ec9a97e719e..db4ab4f459c35a98752bef1eb5be558084b5c906 100644 --- a/crates/language/src/syntax_map.rs +++ b/crates/language/src/syntax_map.rs @@ -19,7 +19,10 @@ use std::{ use streaming_iterator::StreamingIterator; use sum_tree::{Bias, Dimensions, SeekTarget, SumTree}; use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point, Rope, ToOffset, ToPoint}; -use tree_sitter::{Node, Query, QueryCapture, QueryCaptures, QueryCursor, QueryMatches, Tree}; +use tree_sitter::{ + Node, Query, QueryCapture, QueryCaptures, QueryCursor, QueryMatch, QueryMatches, + QueryPredicateArg, Tree, +}; pub const MAX_BYTES_TO_QUERY: usize = 16 * 1024; @@ -82,6 +85,7 @@ struct SyntaxMapMatchesLayer<'a> { next_captures: Vec>, has_next: bool, matches: QueryMatches<'a, 'a, TextProvider<'a>, &'a [u8]>, + query: &'a Query, grammar_index: usize, _query_cursor: QueryCursorHandle, } @@ -1163,6 +1167,7 @@ impl<'a> SyntaxMapMatches<'a> { depth: layer.depth, grammar_index, matches, + query, next_pattern_index: 0, next_captures: Vec::new(), has_next: false, @@ -1260,13 +1265,20 @@ impl SyntaxMapCapturesLayer<'_> { impl SyntaxMapMatchesLayer<'_> { fn advance(&mut self) { - if let Some(mat) = self.matches.next() { - self.next_captures.clear(); - self.next_captures.extend_from_slice(mat.captures); - self.next_pattern_index = mat.pattern_index; - self.has_next = true; - } else { - self.has_next = false; + loop { + if let Some(mat) = self.matches.next() { + if !satisfies_custom_predicates(self.query, mat) { + continue; + } + self.next_captures.clear(); + self.next_captures.extend_from_slice(mat.captures); + self.next_pattern_index = mat.pattern_index; + self.has_next = true; + return; + } else { + self.has_next = false; + return; + } } } @@ -1295,6 +1307,39 @@ impl<'a> Iterator for SyntaxMapCaptures<'a> { } } +fn satisfies_custom_predicates(query: &Query, mat: &QueryMatch) -> bool { + for predicate in query.general_predicates(mat.pattern_index) { + let satisfied = match predicate.operator.as_ref() { + "has-parent?" => has_parent(&predicate.args, mat), + "not-has-parent?" => !has_parent(&predicate.args, mat), + _ => true, + }; + if !satisfied { + return false; + } + } + true +} + +fn has_parent(args: &[QueryPredicateArg], mat: &QueryMatch) -> bool { + let ( + Some(QueryPredicateArg::Capture(capture_ix)), + Some(QueryPredicateArg::String(parent_kind)), + ) = (args.first(), args.get(1)) + else { + return false; + }; + + let Some(capture) = mat.captures.iter().find(|c| c.index == *capture_ix) else { + return false; + }; + + capture + .node + .parent() + .is_some_and(|p| p.kind() == parent_kind.as_ref()) +} + fn join_ranges( a: impl Iterator>, b: impl Iterator>, diff --git a/crates/languages/src/javascript/textobjects.scm b/crates/languages/src/javascript/textobjects.scm index 1a273ddb5000ba920868272bb4ac31d270095442..eace658e6b9847bcc651deedad2bc27cbfbf6975 100644 --- a/crates/languages/src/javascript/textobjects.scm +++ b/crates/languages/src/javascript/textobjects.scm @@ -18,13 +18,47 @@ (_)* @function.inside "}")) @function.around -(arrow_function +((arrow_function body: (statement_block "{" (_)* @function.inside "}")) @function.around + (#not-has-parent? @function.around variable_declarator)) -(arrow_function) @function.around +; Arrow function in variable declaration - capture the full declaration +([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) +]) @function.around + +; Arrow function in variable declaration (captures body for expression-bodied arrows) +([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (_) @function.inside))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (_) @function.inside))) +]) @function.around + +; Catch-all for arrow functions in other contexts (callbacks, etc.) +((arrow_function + body: (_) @function.inside) @function.around + (#not-has-parent? @function.around variable_declarator)) (generator_function body: (_ diff --git a/crates/languages/src/tsx/textobjects.scm b/crates/languages/src/tsx/textobjects.scm index 836fed35ba1c1093b84e48a8da19d89177a69944..628a921f3ac9ea04ff59654d72caf73cebbc9071 100644 --- a/crates/languages/src/tsx/textobjects.scm +++ b/crates/languages/src/tsx/textobjects.scm @@ -18,13 +18,47 @@ (_)* @function.inside "}")) @function.around -(arrow_function +((arrow_function body: (statement_block "{" (_)* @function.inside "}")) @function.around + (#not-has-parent? @function.around variable_declarator)) -(arrow_function) @function.around +; Arrow function in variable declaration - capture the full declaration +([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) +]) @function.around + +; Arrow function in variable declaration (expression body fallback) +([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (_) @function.inside))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (_) @function.inside))) +]) @function.around + +; Catch-all for arrow functions in other contexts (callbacks, etc.) +((arrow_function + body: (_) @function.inside) @function.around + (#not-has-parent? @function.around variable_declarator)) (function_signature) @function.around (generator_function diff --git a/crates/languages/src/typescript/textobjects.scm b/crates/languages/src/typescript/textobjects.scm index 836fed35ba1c1093b84e48a8da19d89177a69944..96289f058cd7b605a8f5b4c8966e3c372022d065 100644 --- a/crates/languages/src/typescript/textobjects.scm +++ b/crates/languages/src/typescript/textobjects.scm @@ -18,13 +18,48 @@ (_)* @function.inside "}")) @function.around -(arrow_function +((arrow_function body: (statement_block "{" (_)* @function.inside "}")) @function.around + (#not-has-parent? @function.around variable_declarator)) -(arrow_function) @function.around +; Arrow function in variable declaration - capture the full declaration +([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (statement_block + "{" + (_)* @function.inside + "}")))) +]) @function.around + +; Arrow function in variable declaration - capture body as @function.inside +; (for statement blocks, the more specific pattern above captures just the contents) +([ + (lexical_declaration + (variable_declarator + value: (arrow_function + body: (_) @function.inside))) + (variable_declaration + (variable_declarator + value: (arrow_function + body: (_) @function.inside))) +]) @function.around + +; Catch-all for arrow functions in other contexts (callbacks, etc.) +((arrow_function + body: (_) @function.inside) @function.around + (#not-has-parent? @function.around variable_declarator)) (function_signature) @function.around (generator_function diff --git a/crates/vim/src/object.rs b/crates/vim/src/object.rs index 02150332405c6d5ea4d5dd78f477348be968fddf..e9a2f4fc63d31f78a9a7abce8aac785b56eb1fd4 100644 --- a/crates/vim/src/object.rs +++ b/crates/vim/src/object.rs @@ -3407,4 +3407,390 @@ mod test { .assert_eq(" ˇf = (x: unknown) => {"); cx.shared_clipboard().await.assert_eq("const "); } + + #[gpui::test] + async fn test_arrow_function_text_object(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new_typescript(cx).await; + + cx.set_state( + indoc! {" + const foo = () => { + return ˇ1; + }; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «const foo = () => { + return 1; + };ˇ» + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + arr.map(() => { + return ˇ1; + }); + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + arr.map(«() => { + return 1; + }ˇ»); + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + const foo = () => { + return ˇ1; + }; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v i f"); + cx.assert_state( + indoc! {" + const foo = () => { + «return 1;ˇ» + }; + "}, + Mode::Visual, + ); + + cx.set_state( + indoc! {" + (() => { + console.log(ˇ1); + })(); + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + («() => { + console.log(1); + }ˇ»)(); + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + const foo = () => { + return ˇ1; + }; + export { foo }; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «const foo = () => { + return 1; + };ˇ» + export { foo }; + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + let bar = () => { + return ˇ2; + }; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «let bar = () => { + return 2; + };ˇ» + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + var baz = () => { + return ˇ3; + }; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «var baz = () => { + return 3; + };ˇ» + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + const add = (a, b) => a + ˇb; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «const add = (a, b) => a + b;ˇ» + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + const add = ˇ(a, b) => a + b; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «const add = (a, b) => a + b;ˇ» + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + const add = (a, b) => a + bˇ; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «const add = (a, b) => a + b;ˇ» + "}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {" + const add = (a, b) =ˇ> a + b; + "}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {" + «const add = (a, b) => a + b;ˇ» + "}, + Mode::VisualLine, + ); + } + + #[gpui::test] + async fn test_arrow_function_in_jsx(cx: &mut gpui::TestAppContext) { + let mut cx = VimTestContext::new_tsx(cx).await; + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
{ + alert("Hello world!"); + console.log(ˇ"clicked"); + }}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
{ + alert("Hello world!"); + console.log("clicked"); + }ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clickˇed")}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked")ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked")}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked")ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked"ˇ)}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked")ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked")}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
console.log("clicked")ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
{ + console.log("cliˇcked"); + }}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
{ + console.log("clicked"); + }ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + + cx.set_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
fˇoo()}>Hello world!
+
+ ); + }; + "#}, + Mode::Normal, + ); + cx.simulate_keystrokes("v a f"); + cx.assert_state( + indoc! {r#" + export const MyComponent = () => { + return ( +
+
foo()ˇ»}>Hello world!
+
+ ); + }; + "#}, + Mode::VisualLine, + ); + } } diff --git a/crates/vim/src/visual.rs b/crates/vim/src/visual.rs index 3c6f237435e3924a907e059ed1a878641c287e7e..5667190bb7239ee3e534a5556d96452a7c68b1ef 100644 --- a/crates/vim/src/visual.rs +++ b/crates/vim/src/visual.rs @@ -522,12 +522,16 @@ impl Vim { selection.start = original_point.to_display_point(map) } } else { - selection.end = movement::saturating_right( - map, - original_point.to_display_point(map), - ); - if original_point.column > 0 { - selection.reversed = true + let original_display_point = + original_point.to_display_point(map); + if selection.end <= original_display_point { + selection.end = movement::saturating_right( + map, + original_display_point, + ); + if original_point.column > 0 { + selection.reversed = true + } } } } From 3f67c5220d3834817e84c454c29a8f92f2688c1d Mon Sep 17 00:00:00 2001 From: Ben Kunkle Date: Thu, 18 Dec 2025 20:59:05 -0600 Subject: [PATCH 210/266] Remove `zed` dependency from `docs_preprocessor` (#45130) Closes #ISSUE Uses the existing `--dump-all-actions` arg on the Zed binary to generate an asset of all of our actions so that the `docs_preprocessor` can injest it, rather than depending on the Zed crate itself to collect all action names Release Notes: - N/A *or* Added/Fixed/Improved ... --------- Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com> --- .github/workflows/run_tests.yml | 3 + .gitignore | 1 + Cargo.lock | 3 - crates/docs_preprocessor/Cargo.toml | 5 +- crates/docs_preprocessor/src/main.rs | 88 +++++++++++-------- crates/title_bar/src/application_menu.rs | 20 ++--- crates/zed/Cargo.toml | 4 - crates/zed/src/main.rs | 13 +-- crates/zed/src/zed-main.rs | 8 -- crates/zed/src/zed.rs | 1 - script/generate-action-metadata | 10 +++ .../xtask/src/tasks/workflows/run_tests.rs | 1 + 12 files changed, 83 insertions(+), 74 deletions(-) delete mode 100644 crates/zed/src/zed-main.rs create mode 100755 script/generate-action-metadata diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index 256bb2916a56485c06c2ebc4de8724151d622c4f..47a84574e7c33fb8a40a90c67cd4f7dadb356978 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -353,6 +353,9 @@ jobs: - name: steps::download_wasi_sdk run: ./script/download-wasi-sdk shell: bash -euxo pipefail {0} + - name: ./script/generate-action-metadata + run: ./script/generate-action-metadata + shell: bash -euxo pipefail {0} - name: run_tests::check_docs::install_mdbook uses: peaceiris/actions-mdbook@ee69d230fe19748b7abf22df32acaa93833fad08 with: diff --git a/.gitignore b/.gitignore index 54faaf1374299ee8f97925a95a93b375c349d707..c71417c32bff76af9d4c9c67661556e1625c9d15 100644 --- a/.gitignore +++ b/.gitignore @@ -36,6 +36,7 @@ DerivedData/ Packages xcuserdata/ +crates/docs_preprocessor/actions.json # Don't commit any secrets to the repo. .env diff --git a/Cargo.lock b/Cargo.lock index 1bb39f2bdf8c5745b3e5c0e5ad1200be34ec6ab0..3f7077e721e934cd6cb05af0cdaefef75602b429 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5021,8 +5021,6 @@ name = "docs_preprocessor" version = "0.1.0" dependencies = [ "anyhow", - "command_palette", - "gpui", "mdbook", "regex", "serde", @@ -5031,7 +5029,6 @@ dependencies = [ "task", "theme", "util", - "zed", "zlog", ] diff --git a/crates/docs_preprocessor/Cargo.toml b/crates/docs_preprocessor/Cargo.toml index e71f9ae3f3f6fcff790db27fb1e377f0d1c20e40..07da23899956822f7577118ae85b6338b4cefae7 100644 --- a/crates/docs_preprocessor/Cargo.toml +++ b/crates/docs_preprocessor/Cargo.toml @@ -7,8 +7,6 @@ license = "GPL-3.0-or-later" [dependencies] anyhow.workspace = true -command_palette.workspace = true -gpui.workspace = true # We are specifically pinning this version of mdbook, as later versions introduce issues with double-nested subdirectories. # Ask @maxdeviant about this before bumping. mdbook = "= 0.4.40" @@ -17,7 +15,6 @@ serde.workspace = true serde_json.workspace = true settings.workspace = true util.workspace = true -zed.workspace = true zlog.workspace = true task.workspace = true theme.workspace = true @@ -27,4 +24,4 @@ workspace = true [[bin]] name = "docs_preprocessor" -path = "src/main.rs" +path = "src/main.rs" \ No newline at end of file diff --git a/crates/docs_preprocessor/src/main.rs b/crates/docs_preprocessor/src/main.rs index b614a8251139413f4b316937db1d4e3c0d551df6..d90dcc10db9fbd8d27a968094ea8d733a79b7e80 100644 --- a/crates/docs_preprocessor/src/main.rs +++ b/crates/docs_preprocessor/src/main.rs @@ -22,16 +22,13 @@ static KEYMAP_WINDOWS: LazyLock = LazyLock::new(|| { load_keymap("keymaps/default-windows.json").expect("Failed to load Windows keymap") }); -static ALL_ACTIONS: LazyLock> = LazyLock::new(dump_all_gpui_actions); +static ALL_ACTIONS: LazyLock> = LazyLock::new(load_all_actions); const FRONT_MATTER_COMMENT: &str = ""; fn main() -> Result<()> { zlog::init(); zlog::init_output_stderr(); - // call a zed:: function so everything in `zed` crate is linked and - // all actions in the actual app are registered - zed::stdout_is_a_pty(); let args = std::env::args().skip(1).collect::>(); match args.get(0).map(String::as_str) { @@ -72,8 +69,8 @@ enum PreprocessorError { impl PreprocessorError { fn new_for_not_found_action(action_name: String) -> Self { for action in &*ALL_ACTIONS { - for alias in action.deprecated_aliases { - if alias == &action_name { + for alias in &action.deprecated_aliases { + if alias == action_name.as_str() { return PreprocessorError::DeprecatedActionUsed { used: action_name, should_be: action.name.to_string(), @@ -214,7 +211,7 @@ fn template_and_validate_keybindings(book: &mut Book, errors: &mut HashSet{}", name); }; format!("{}", &action.human_name) }) @@ -257,11 +256,19 @@ fn template_and_validate_actions(book: &mut Book, errors: &mut HashSet Option<&ActionDef> { ALL_ACTIONS - .binary_search_by(|action| action.name.cmp(name)) + .binary_search_by(|action| action.name.as_str().cmp(name)) .ok() .map(|index| &ALL_ACTIONS[index]) } +fn actions_available() -> bool { + !ALL_ACTIONS.is_empty() +} + +fn is_missing_action(name: &str) -> bool { + actions_available() && find_action_by_name(name).is_none() +} + fn find_binding(os: &str, action: &str) -> Option { let keymap = match os { "macos" => &KEYMAP_MACOS, @@ -384,18 +391,13 @@ fn template_and_validate_json_snippets(book: &mut Book, errors: &mut HashSet
, _>>()
-                            .context("Failed to parse keystroke")?;
+                    for (_keystrokes, action) in section.bindings() {
                         if let Some((action_name, _)) = settings::KeymapFile::parse_action(action)
                             .map_err(|err| anyhow::format_err!(err))
                             .context("Failed to parse action")?
                         {
                             anyhow::ensure!(
-                                find_action_by_name(action_name).is_some(),
+                                !is_missing_action(action_name),
                                 "Action not found: {}",
                                 action_name
                             );
@@ -491,27 +493,35 @@ where
     });
 }
 
-#[derive(Debug, serde::Serialize)]
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
 struct ActionDef {
-    name: &'static str,
+    name: String,
     human_name: String,
-    deprecated_aliases: &'static [&'static str],
-    docs: Option<&'static str>,
+    deprecated_aliases: Vec,
+    #[serde(rename = "documentation")]
+    docs: Option,
 }
 
-fn dump_all_gpui_actions() -> Vec {
-    let mut actions = gpui::generate_list_of_all_registered_actions()
-        .map(|action| ActionDef {
-            name: action.name,
-            human_name: command_palette::humanize_action_name(action.name),
-            deprecated_aliases: action.deprecated_aliases,
-            docs: action.documentation,
-        })
-        .collect::>();
-
-    actions.sort_by_key(|a| a.name);
-
-    actions
+fn load_all_actions() -> Vec {
+    let asset_path = concat!(env!("CARGO_MANIFEST_DIR"), "/actions.json");
+    match std::fs::read_to_string(asset_path) {
+        Ok(content) => {
+            let mut actions: Vec =
+                serde_json::from_str(&content).expect("Failed to parse actions.json");
+            actions.sort_by(|a, b| a.name.cmp(&b.name));
+            actions
+        }
+        Err(err) => {
+            if std::env::var("CI").is_ok() {
+                panic!("actions.json not found at {}: {}", asset_path, err);
+            }
+            eprintln!(
+                "Warning: actions.json not found, action validation will be skipped: {}",
+                err
+            );
+            Vec::new()
+        }
+    }
 }
 
 fn handle_postprocessing() -> Result<()> {
@@ -647,7 +657,7 @@ fn generate_big_table_of_actions() -> String {
     let mut output = String::new();
 
     let mut actions_sorted = actions.iter().collect::>();
-    actions_sorted.sort_by_key(|a| a.name);
+    actions_sorted.sort_by_key(|a| a.name.as_str());
 
     // Start the definition list with custom styling for better spacing
     output.push_str("
\n");
@@ -664,7 +674,7 @@ fn generate_big_table_of_actions() -> String {
         output.push_str("
\n");
 
         // Add the description, escaping HTML if needed
-        if let Some(description) = action.docs {
+        if let Some(description) = action.docs.as_ref() {
             output.push_str(
                 &description
                     .replace("&", "&")
@@ -674,7 +684,7 @@ fn generate_big_table_of_actions() -> String {
             output.push_str("
\n");
         }
         output.push_str("Keymap Name: ");
-        output.push_str(action.name);
+        output.push_str(&action.name);
         output.push_str("
\n");
         if !action.deprecated_aliases.is_empty() {
             output.push_str("Deprecated Alias(es): ");
diff --git a/crates/title_bar/src/application_menu.rs b/crates/title_bar/src/application_menu.rs
index 817b73c45ecd2df4a76e9a67f425b2b459c0c026..579e4dadbd590981a4aee15019bbe73e2bb28d5c 100644
--- a/crates/title_bar/src/application_menu.rs
+++ b/crates/title_bar/src/application_menu.rs
@@ -1,12 +1,7 @@
-use gpui::{Entity, OwnedMenu, OwnedMenuItem};
+use gpui::{Action, Entity, OwnedMenu, OwnedMenuItem, actions};
 use settings::Settings;
 
-#[cfg(not(target_os = "macos"))]
-use gpui::{Action, actions};
-
-#[cfg(not(target_os = "macos"))]
 use schemars::JsonSchema;
-#[cfg(not(target_os = "macos"))]
 use serde::Deserialize;
 
 use smallvec::SmallVec;
@@ -14,18 +9,23 @@ use ui::{ContextMenu, PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*};
 
 use crate::title_bar_settings::TitleBarSettings;
 
-#[cfg(not(target_os = "macos"))]
 actions!(
     app_menu,
     [
-        /// Navigates to the menu item on the right.
+        /// Activates the menu on the right in the client-side application menu.
+        ///
+        /// Does not apply to platform menu bars (e.g. on macOS).
         ActivateMenuRight,
-        /// Navigates to the menu item on the left.
+        /// Activates the menu on the left in the client-side application menu.
+        ///
+        /// Does not apply to platform menu bars (e.g. on macOS).
         ActivateMenuLeft
     ]
 );
 
-#[cfg(not(target_os = "macos"))]
+/// Opens the named menu in the client-side application menu.
+///
+/// Does not apply to platform menu bars (e.g. on macOS).
 #[derive(Clone, Deserialize, JsonSchema, PartialEq, Default, Action)]
 #[action(namespace = app_menu)]
 pub struct OpenApplicationMenu(String);
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index fd160759f4440e2736d57cea62abb6bdb138ae72..80eca20e00309bb8d22552287a1c39cb9891307d 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -15,10 +15,6 @@ tracy = ["ztracing/tracy"]
 
 [[bin]]
 name = "zed"
-path = "src/zed-main.rs"
-
-[lib]
-name = "zed"
 path = "src/main.rs"
 
 [dependencies]
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 7008e491c5e2ade35fa96cafbd9d8969c008fa96..312d16f0cd674a6dda81176863a859f3b763c2c0 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -1,3 +1,6 @@
+// Disable command line from opening on release mode
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
 mod reliability;
 mod zed;
 
@@ -163,9 +166,9 @@ fn fail_to_open_window(e: anyhow::Error, _cx: &mut App) {
         .detach();
     }
 }
-pub static STARTUP_TIME: OnceLock = OnceLock::new();
+static STARTUP_TIME: OnceLock = OnceLock::new();
 
-pub fn main() {
+fn main() {
     STARTUP_TIME.get_or_init(|| Instant::now());
 
     #[cfg(unix)]
@@ -1301,7 +1304,7 @@ fn init_paths() -> HashMap> {
     })
 }
 
-pub fn stdout_is_a_pty() -> bool {
+fn stdout_is_a_pty() -> bool {
     std::env::var(FORCE_CLI_MODE_ENV_VAR_NAME).ok().is_none() && io::stdout().is_terminal()
 }
 
@@ -1547,14 +1550,14 @@ fn dump_all_gpui_actions() {
     struct ActionDef {
         name: &'static str,
         human_name: String,
-        aliases: &'static [&'static str],
+        deprecated_aliases: &'static [&'static str],
         documentation: Option<&'static str>,
     }
     let mut actions = gpui::generate_list_of_all_registered_actions()
         .map(|action| ActionDef {
             name: action.name,
             human_name: command_palette::humanize_action_name(action.name),
-            aliases: action.deprecated_aliases,
+            deprecated_aliases: action.deprecated_aliases,
             documentation: action.documentation,
         })
         .collect::>();
diff --git a/crates/zed/src/zed-main.rs b/crates/zed/src/zed-main.rs
deleted file mode 100644
index 6c49c197dda01e97828c3662aa09ecf57804dfbc..0000000000000000000000000000000000000000
--- a/crates/zed/src/zed-main.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-// Disable command line from opening on release mode
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
-
-pub fn main() {
-    // separated out so that the file containing the main function can be imported by other crates,
-    // while having all gpui resources that are registered in main (primarily actions) initialized
-    zed::main();
-}
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index d088df00839814e32a9c246a3486ac5ad5ca4b9e..3441cb88d96b06dfdbb65a58553d2c58f435d157 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -4780,7 +4780,6 @@ mod tests {
                 "activity_indicator",
                 "agent",
                 "agents",
-                #[cfg(not(target_os = "macos"))]
                 "app_menu",
                 "assistant",
                 "assistant2",
diff --git a/script/generate-action-metadata b/script/generate-action-metadata
new file mode 100755
index 0000000000000000000000000000000000000000..146b1f0d78ef92c47322a70dccf0e9e1f3f530d3
--- /dev/null
+++ b/script/generate-action-metadata
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+echo "Generating action metadata..."
+cargo run -p zed -- --dump-all-actions > crates/docs_preprocessor/actions.json
+
+echo "Generated crates/docs_preprocessor/actions.json with $(grep -c '"name":' crates/docs_preprocessor/actions.json) actions"
diff --git a/tooling/xtask/src/tasks/workflows/run_tests.rs b/tooling/xtask/src/tasks/workflows/run_tests.rs
index f726f48740eb7819fbbd3fed369e5e4e89c526c9..aceb575b647e7ea0b2d8a74da9fbc153767d149d 100644
--- a/tooling/xtask/src/tasks/workflows/run_tests.rs
+++ b/tooling/xtask/src/tasks/workflows/run_tests.rs
@@ -448,6 +448,7 @@ fn check_docs() -> NamedJob {
                 lychee_link_check("./docs/src/**/*"), // check markdown links
             )
             .map(steps::install_linux_dependencies)
+            .add_step(steps::script("./script/generate-action-metadata"))
             .add_step(install_mdbook())
             .add_step(build_docs())
             .add_step(

From 63c4406137916175ab23a2e65978f3bf508d122c Mon Sep 17 00:00:00 2001
From: Alvaro Parker <64918109+AlvaroParker@users.noreply.github.com>
Date: Fri, 19 Dec 2025 00:21:46 -0300
Subject: [PATCH 211/266] git: Add git clone open listener (#41669)

---
 crates/git_ui/src/clone.rs          | 155 ++++++++++++++++++++++++++++
 crates/git_ui/src/git_panel.rs      |  92 ++---------------
 crates/git_ui/src/git_ui.rs         |   1 +
 crates/zed/src/main.rs              |  39 +++++++
 crates/zed/src/zed/open_listener.rs | 102 ++++++++++++++++++
 5 files changed, 304 insertions(+), 85 deletions(-)
 create mode 100644 crates/git_ui/src/clone.rs

diff --git a/crates/git_ui/src/clone.rs b/crates/git_ui/src/clone.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a6767d33304d3f20b7a5e78340f62c89ebe3ae58
--- /dev/null
+++ b/crates/git_ui/src/clone.rs
@@ -0,0 +1,155 @@
+use gpui::{App, Context, WeakEntity, Window};
+use notifications::status_toast::{StatusToast, ToastIcon};
+use std::sync::Arc;
+use ui::{Color, IconName, SharedString};
+use util::ResultExt;
+use workspace::{self, Workspace};
+
+pub fn clone_and_open(
+    repo_url: SharedString,
+    workspace: WeakEntity,
+    window: &mut Window,
+    cx: &mut App,
+    on_success: Arc<
+        dyn Fn(&mut Workspace, &mut Window, &mut Context) + Send + Sync + 'static,
+    >,
+) {
+    let destination_prompt = cx.prompt_for_paths(gpui::PathPromptOptions {
+        files: false,
+        directories: true,
+        multiple: false,
+        prompt: Some("Select as Repository Destination".into()),
+    });
+
+    window
+        .spawn(cx, async move |cx| {
+            let mut paths = destination_prompt.await.ok()?.ok()??;
+            let mut destination_dir = paths.pop()?;
+
+            let repo_name = repo_url
+                .split('/')
+                .next_back()
+                .map(|name| name.strip_suffix(".git").unwrap_or(name))
+                .unwrap_or("repository")
+                .to_owned();
+
+            let clone_task = workspace
+                .update(cx, |workspace, cx| {
+                    let fs = workspace.app_state().fs.clone();
+                    let destination_dir = destination_dir.clone();
+                    let repo_url = repo_url.clone();
+                    cx.spawn(async move |_workspace, _cx| {
+                        fs.git_clone(&repo_url, destination_dir.as_path()).await
+                    })
+                })
+                .ok()?;
+
+            if let Err(error) = clone_task.await {
+                workspace
+                    .update(cx, |workspace, cx| {
+                        let toast = StatusToast::new(error.to_string(), cx, |this, _| {
+                            this.icon(ToastIcon::new(IconName::XCircle).color(Color::Error))
+                                .dismiss_button(true)
+                        });
+                        workspace.toggle_status_toast(toast, cx);
+                    })
+                    .log_err();
+                return None;
+            }
+
+            let has_worktrees = workspace
+                .read_with(cx, |workspace, cx| {
+                    workspace.project().read(cx).worktrees(cx).next().is_some()
+                })
+                .ok()?;
+
+            let prompt_answer = if has_worktrees {
+                cx.update(|window, cx| {
+                    window.prompt(
+                        gpui::PromptLevel::Info,
+                        &format!("Git Clone: {}", repo_name),
+                        None,
+                        &["Add repo to project", "Open repo in new project"],
+                        cx,
+                    )
+                })
+                .ok()?
+                .await
+                .ok()?
+            } else {
+                // Don't ask if project is empty
+                0
+            };
+
+            destination_dir.push(&repo_name);
+
+            match prompt_answer {
+                0 => {
+                    workspace
+                        .update_in(cx, |workspace, window, cx| {
+                            let create_task = workspace.project().update(cx, |project, cx| {
+                                project.create_worktree(destination_dir.as_path(), true, cx)
+                            });
+
+                            let workspace_weak = cx.weak_entity();
+                            let on_success = on_success.clone();
+                            cx.spawn_in(window, async move |_window, cx| {
+                                if create_task.await.log_err().is_some() {
+                                    workspace_weak
+                                        .update_in(cx, |workspace, window, cx| {
+                                            (on_success)(workspace, window, cx);
+                                        })
+                                        .ok();
+                                }
+                            })
+                            .detach();
+                        })
+                        .ok()?;
+                }
+                1 => {
+                    workspace
+                        .update(cx, move |workspace, cx| {
+                            let app_state = workspace.app_state().clone();
+                            let destination_path = destination_dir.clone();
+                            let on_success = on_success.clone();
+
+                            workspace::open_new(
+                                Default::default(),
+                                app_state,
+                                cx,
+                                move |workspace, window, cx| {
+                                    cx.activate(true);
+
+                                    let create_task =
+                                        workspace.project().update(cx, |project, cx| {
+                                            project.create_worktree(
+                                                destination_path.as_path(),
+                                                true,
+                                                cx,
+                                            )
+                                        });
+
+                                    let workspace_weak = cx.weak_entity();
+                                    cx.spawn_in(window, async move |_window, cx| {
+                                        if create_task.await.log_err().is_some() {
+                                            workspace_weak
+                                                .update_in(cx, |workspace, window, cx| {
+                                                    (on_success)(workspace, window, cx);
+                                                })
+                                                .ok();
+                                        }
+                                    })
+                                    .detach();
+                                },
+                            )
+                            .detach();
+                        })
+                        .ok();
+                }
+                _ => {}
+            }
+
+            Some(())
+        })
+        .detach();
+}
diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 0f967e68d1fab829fb37b626c23ecfebe69fb5dd..532f9a099a823796706be48ed14cc7da820c5d8b 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -2849,93 +2849,15 @@ impl GitPanel {
     }
 
     pub(crate) fn git_clone(&mut self, repo: String, window: &mut Window, cx: &mut Context) {
-        let path = cx.prompt_for_paths(gpui::PathPromptOptions {
-            files: false,
-            directories: true,
-            multiple: false,
-            prompt: Some("Select as Repository Destination".into()),
-        });
-
         let workspace = self.workspace.clone();
 
-        cx.spawn_in(window, async move |this, cx| {
-            let mut paths = path.await.ok()?.ok()??;
-            let mut path = paths.pop()?;
-            let repo_name = repo.split("/").last()?.strip_suffix(".git")?.to_owned();
-
-            let fs = this.read_with(cx, |this, _| this.fs.clone()).ok()?;
-
-            let prompt_answer = match fs.git_clone(&repo, path.as_path()).await {
-                Ok(_) => cx.update(|window, cx| {
-                    window.prompt(
-                        PromptLevel::Info,
-                        &format!("Git Clone: {}", repo_name),
-                        None,
-                        &["Add repo to project", "Open repo in new project"],
-                        cx,
-                    )
-                }),
-                Err(e) => {
-                    this.update(cx, |this: &mut GitPanel, cx| {
-                        let toast = StatusToast::new(e.to_string(), cx, |this, _| {
-                            this.icon(ToastIcon::new(IconName::XCircle).color(Color::Error))
-                                .dismiss_button(true)
-                        });
-
-                        this.workspace
-                            .update(cx, |workspace, cx| {
-                                workspace.toggle_status_toast(toast, cx);
-                            })
-                            .ok();
-                    })
-                    .ok()?;
-
-                    return None;
-                }
-            }
-            .ok()?;
-
-            path.push(repo_name);
-            match prompt_answer.await.ok()? {
-                0 => {
-                    workspace
-                        .update(cx, |workspace, cx| {
-                            workspace
-                                .project()
-                                .update(cx, |project, cx| {
-                                    project.create_worktree(path.as_path(), true, cx)
-                                })
-                                .detach();
-                        })
-                        .ok();
-                }
-                1 => {
-                    workspace
-                        .update(cx, move |workspace, cx| {
-                            workspace::open_new(
-                                Default::default(),
-                                workspace.app_state().clone(),
-                                cx,
-                                move |workspace, _, cx| {
-                                    cx.activate(true);
-                                    workspace
-                                        .project()
-                                        .update(cx, |project, cx| {
-                                            project.create_worktree(&path, true, cx)
-                                        })
-                                        .detach();
-                                },
-                            )
-                            .detach();
-                        })
-                        .ok();
-                }
-                _ => {}
-            }
-
-            Some(())
-        })
-        .detach();
+        crate::clone::clone_and_open(
+            repo.into(),
+            workspace,
+            window,
+            cx,
+            Arc::new(|_workspace: &mut workspace::Workspace, _window, _cx| {}),
+        );
     }
 
     pub(crate) fn git_init(&mut self, window: &mut Window, cx: &mut Context) {
diff --git a/crates/git_ui/src/git_ui.rs b/crates/git_ui/src/git_ui.rs
index 5f50e4ef8029d8f57cd159bc7da68b668b628f48..053c41bf10c5d97f9f5326fd17d6b5bf91297a03 100644
--- a/crates/git_ui/src/git_ui.rs
+++ b/crates/git_ui/src/git_ui.rs
@@ -10,6 +10,7 @@ use ui::{
 };
 
 mod blame_ui;
+pub mod clone;
 
 use git::{
     repository::{Branch, Upstream, UpstreamTracking, UpstreamTrackingStatus},
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 312d16f0cd674a6dda81176863a859f3b763c2c0..03e02bb0107d736c07eb3fc9626856943f8d80a6 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -18,11 +18,13 @@ use extension::ExtensionHostProxy;
 use fs::{Fs, RealFs};
 use futures::{StreamExt, channel::oneshot, future};
 use git::GitHostingProviderRegistry;
+use git_ui::clone::clone_and_open;
 use gpui::{App, AppContext, Application, AsyncApp, Focusable as _, QuitMode, UpdateGlobal as _};
 
 use gpui_tokio::Tokio;
 use language::LanguageRegistry;
 use onboarding::{FIRST_OPEN, show_onboarding_view};
+use project_panel::ProjectPanel;
 use prompt_store::PromptBuilder;
 use remote::RemoteConnectionOptions;
 use reqwest_client::ReqwestClient;
@@ -36,10 +38,12 @@ use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
 use session::{AppSession, Session};
 use settings::{BaseKeymap, Settings, SettingsStore, watch_config_file};
 use std::{
+    cell::RefCell,
     env,
     io::{self, IsTerminal},
     path::{Path, PathBuf},
     process,
+    rc::Rc,
     sync::{Arc, OnceLock},
     time::Instant,
 };
@@ -896,6 +900,41 @@ fn handle_open_request(request: OpenRequest, app_state: Arc, cx: &mut
                 })
                 .detach_and_log_err(cx);
             }
+            OpenRequestKind::GitClone { repo_url } => {
+                workspace::with_active_or_new_workspace(cx, |_workspace, window, cx| {
+                    if window.is_window_active() {
+                        clone_and_open(
+                            repo_url,
+                            cx.weak_entity(),
+                            window,
+                            cx,
+                            Arc::new(|workspace: &mut workspace::Workspace, window, cx| {
+                                workspace.focus_panel::(window, cx);
+                            }),
+                        );
+                        return;
+                    }
+
+                    let subscription = Rc::new(RefCell::new(None));
+                    subscription.replace(Some(cx.observe_in(&cx.entity(), window, {
+                        let subscription = subscription.clone();
+                        let repo_url = repo_url;
+                        move |_, workspace_entity, window, cx| {
+                            if window.is_window_active() && subscription.take().is_some() {
+                                clone_and_open(
+                                    repo_url.clone(),
+                                    workspace_entity.downgrade(),
+                                    window,
+                                    cx,
+                                    Arc::new(|workspace: &mut workspace::Workspace, window, cx| {
+                                        workspace.focus_panel::(window, cx);
+                                    }),
+                                );
+                            }
+                        }
+                    })));
+                });
+            }
             OpenRequestKind::GitCommit { sha } => {
                 cx.spawn(async move |cx| {
                     let paths_with_position =
diff --git a/crates/zed/src/zed/open_listener.rs b/crates/zed/src/zed/open_listener.rs
index d61de0a291f3d3e7869225c0e07424cc3523f69b..842f98520133c70f711d84d3f490bec1ec59e16f 100644
--- a/crates/zed/src/zed/open_listener.rs
+++ b/crates/zed/src/zed/open_listener.rs
@@ -25,6 +25,7 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::thread;
 use std::time::Duration;
+use ui::SharedString;
 use util::ResultExt;
 use util::paths::PathWithPosition;
 use workspace::PathList;
@@ -58,6 +59,9 @@ pub enum OpenRequestKind {
         /// `None` opens settings without navigating to a specific path.
         setting_path: Option,
     },
+    GitClone {
+        repo_url: SharedString,
+    },
     GitCommit {
         sha: String,
     },
@@ -113,6 +117,8 @@ impl OpenRequest {
                 this.kind = Some(OpenRequestKind::Setting {
                     setting_path: Some(setting_path.to_string()),
                 });
+            } else if let Some(clone_path) = url.strip_prefix("zed://git/clone") {
+                this.parse_git_clone_url(clone_path)?
             } else if let Some(commit_path) = url.strip_prefix("zed://git/commit/") {
                 this.parse_git_commit_url(commit_path)?
             } else if url.starts_with("ssh://") {
@@ -143,6 +149,26 @@ impl OpenRequest {
         }
     }
 
+    fn parse_git_clone_url(&mut self, clone_path: &str) -> Result<()> {
+        // Format: /?repo= or ?repo=
+        let clone_path = clone_path.strip_prefix('/').unwrap_or(clone_path);
+
+        let query = clone_path
+            .strip_prefix('?')
+            .context("invalid git clone url: missing query string")?;
+
+        let repo_url = url::form_urlencoded::parse(query.as_bytes())
+            .find_map(|(key, value)| (key == "repo").then_some(value))
+            .filter(|s| !s.is_empty())
+            .context("invalid git clone url: missing repo query parameter")?
+            .to_string()
+            .into();
+
+        self.kind = Some(OpenRequestKind::GitClone { repo_url });
+
+        Ok(())
+    }
+
     fn parse_git_commit_url(&mut self, commit_path: &str) -> Result<()> {
         // Format: ?repo=
         let (sha, query) = commit_path
@@ -1087,4 +1113,80 @@ mod tests {
 
         assert!(!errored_reuse);
     }
+
+    #[gpui::test]
+    fn test_parse_git_clone_url(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+
+        let request = cx.update(|cx| {
+            OpenRequest::parse(
+                RawOpenRequest {
+                    urls: vec![
+                        "zed://git/clone/?repo=https://github.com/zed-industries/zed.git".into(),
+                    ],
+                    ..Default::default()
+                },
+                cx,
+            )
+            .unwrap()
+        });
+
+        match request.kind {
+            Some(OpenRequestKind::GitClone { repo_url }) => {
+                assert_eq!(repo_url, "https://github.com/zed-industries/zed.git");
+            }
+            _ => panic!("Expected GitClone kind"),
+        }
+    }
+
+    #[gpui::test]
+    fn test_parse_git_clone_url_without_slash(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+
+        let request = cx.update(|cx| {
+            OpenRequest::parse(
+                RawOpenRequest {
+                    urls: vec![
+                        "zed://git/clone?repo=https://github.com/zed-industries/zed.git".into(),
+                    ],
+                    ..Default::default()
+                },
+                cx,
+            )
+            .unwrap()
+        });
+
+        match request.kind {
+            Some(OpenRequestKind::GitClone { repo_url }) => {
+                assert_eq!(repo_url, "https://github.com/zed-industries/zed.git");
+            }
+            _ => panic!("Expected GitClone kind"),
+        }
+    }
+
+    #[gpui::test]
+    fn test_parse_git_clone_url_with_encoding(cx: &mut TestAppContext) {
+        let _app_state = init_test(cx);
+
+        let request = cx.update(|cx| {
+            OpenRequest::parse(
+                RawOpenRequest {
+                    urls: vec![
+                        "zed://git/clone/?repo=https%3A%2F%2Fgithub.com%2Fzed-industries%2Fzed.git"
+                            .into(),
+                    ],
+                    ..Default::default()
+                },
+                cx,
+            )
+            .unwrap()
+        });
+
+        match request.kind {
+            Some(OpenRequestKind::GitClone { repo_url }) => {
+                assert_eq!(repo_url, "https://github.com/zed-industries/zed.git");
+            }
+            _ => panic!("Expected GitClone kind"),
+        }
+    }
 }

From 05ce34eea4687ce1006df499bbbdff9527a8e41e Mon Sep 17 00:00:00 2001
From: Ben Kunkle 
Date: Thu, 18 Dec 2025 21:40:27 -0600
Subject: [PATCH 212/266] ci: Fix docs build post #45130 (#45330)

Closes #ISSUE

Release Notes:

- N/A *or* Added/Fixed/Improved ...
---
 .github/actions/build_docs/action.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/.github/actions/build_docs/action.yml b/.github/actions/build_docs/action.yml
index d2e62d5b22ee49c7dcb9b42085a648098fbdb6bb..1ff271f73ff6b800ec3a94615f31c35a7729bb47 100644
--- a/.github/actions/build_docs/action.yml
+++ b/.github/actions/build_docs/action.yml
@@ -19,6 +19,18 @@ runs:
       shell: bash -euxo pipefail {0}
       run: ./script/linux
 
+    - name: Install mold linker
+      shell: bash -euxo pipefail {0}
+      run: ./script/install-mold
+
+    - name: Download WASI SDK
+      shell: bash -euxo pipefail {0}
+      run: ./script/download-wasi-sdk
+
+    - name: Generate action metadata
+      shell: bash -euxo pipefail {0}
+      run: ./script/generate-action-metadata
+
     - name: Check for broken links (in MD)
       uses: lycheeverse/lychee-action@82202e5e9c2f4ef1a55a3d02563e1cb6041e5332 # v2.4.1
       with:

From 0531035b86a7a035b1b661c62cc9436a2e1b5394 Mon Sep 17 00:00:00 2001
From: Ryan Steil <183886708+ryansteil@users.noreply.github.com>
Date: Thu, 18 Dec 2025 22:47:40 -0600
Subject: [PATCH 213/266] docs: Fix link to Anthropic prompt engineering
 resource (#45329)

---
 docs/src/ai/rules.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/src/ai/rules.md b/docs/src/ai/rules.md
index 4169920425e66eb41a895deb60da3a198d74df08..972bbc94e82937502739cf585cc8f60dbcda8808 100644
--- a/docs/src/ai/rules.md
+++ b/docs/src/ai/rules.md
@@ -46,7 +46,7 @@ Having a series of rules files specifically tailored to prompt engineering can a
 
 Here are a couple of helpful resources for writing better rules:
 
-- [Anthropic: Prompt Engineering](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview)
+- [Anthropic: Prompt Engineering](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/overview)
 - [OpenAI: Prompt Engineering](https://platform.openai.com/docs/guides/prompt-engineering)
 
 ### Editing the Default Rules {#default-rules}

From e052127e1c31ce6b8286fc931aaee2217b62ada1 Mon Sep 17 00:00:00 2001
From: rabsef-bicrym <52549148+rabsef-bicrym@users.noreply.github.com>
Date: Thu, 18 Dec 2025 22:33:59 -0800
Subject: [PATCH 214/266] terminal: Prevent scrollbar arithmetic underflow
 panic (#45282)

## Summary

Fixes arithmetic underflow panics in `terminal_scrollbar.rs` by
converting unsafe subtractions to `saturating_sub`.

Closes #45281

## Problem

Two locations perform raw subtraction on `usize` values that panic when
underflow occurs:

- `offset()`: `state.total_lines - state.viewport_lines -
state.display_offset`
- `set_offset()`: `state.total_lines - state.viewport_lines`

This happens when `total_lines < viewport_lines + display_offset`, which
can occur during terminal creation, with small window sizes, or when
display state becomes stale.

## Solution

Replace the two unsafe subtractions with `saturating_sub`, which returns
0 on underflow instead of panicking.

Also standardizes the existing `checked_sub().unwrap_or(0)` in
`max_offset()` to `saturating_sub` for consistency across the file.

## Changes

- N/A
---
 crates/terminal_view/src/terminal_scrollbar.rs | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/crates/terminal_view/src/terminal_scrollbar.rs b/crates/terminal_view/src/terminal_scrollbar.rs
index 871bb602306cccc92b8cffe62c4912c42b7a87e2..82ca0b4097dad1be899879b0241aed50d8e60bfa 100644
--- a/crates/terminal_view/src/terminal_scrollbar.rs
+++ b/crates/terminal_view/src/terminal_scrollbar.rs
@@ -50,28 +50,24 @@ impl ScrollableHandle for TerminalScrollHandle {
         let state = self.state.borrow();
         size(
             Pixels::ZERO,
-            state
-                .total_lines
-                .checked_sub(state.viewport_lines)
-                .unwrap_or(0) as f32
-                * state.line_height,
+            state.total_lines.saturating_sub(state.viewport_lines) as f32 * state.line_height,
         )
     }
 
     fn offset(&self) -> Point {
         let state = self.state.borrow();
-        let scroll_offset = state.total_lines - state.viewport_lines - state.display_offset;
-        Point::new(
-            Pixels::ZERO,
-            -(scroll_offset as f32 * self.state.borrow().line_height),
-        )
+        let scroll_offset = state
+            .total_lines
+            .saturating_sub(state.viewport_lines)
+            .saturating_sub(state.display_offset);
+        Point::new(Pixels::ZERO, -(scroll_offset as f32 * state.line_height))
     }
 
     fn set_offset(&self, point: Point) {
         let state = self.state.borrow();
         let offset_delta = (point.y / state.line_height).round() as i32;
 
-        let max_offset = state.total_lines - state.viewport_lines;
+        let max_offset = state.total_lines.saturating_sub(state.viewport_lines);
         let display_offset = (max_offset as i32 + offset_delta).clamp(0, max_offset as i32);
 
         self.future_display_offset

From e44529ed7ba3da10f796a5d37d494a5ef883e17a Mon Sep 17 00:00:00 2001
From: Mustaque Ahmed 
Date: Fri, 19 Dec 2025 13:54:30 +0530
Subject: [PATCH 215/266] Hide inline overlays when context menu is open
 (#45266)

Closes #23367

**Summary**
- Prevents inline diagnostics, code actions, blame annotations, and
hover popovers from overlapping with the right-click context menu by
checking for `mouse_context_menu` presence before rendering these UI
elements.

PS: Same behaviour is present in other editors like VS Code.


**Screen recording**


https://github.com/user-attachments/assets/8290412b-0f86-4985-8c70-13440686e530



Release Notes:

- N/A *or* Added/Fixed/Improved ...
---
 crates/editor/src/element.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index f7b6aa949e74dca9bee73419fa2b87899f9986fd..4c3b44335bcad10be4303d545a8d2ad505938098 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -5417,6 +5417,12 @@ impl EditorElement {
                 .max(MIN_POPOVER_LINE_HEIGHT * line_height), // Apply minimum height of 4 lines
         );
 
+        // Don't show hover popovers when context menu is open to avoid overlap
+        let has_context_menu = self.editor.read(cx).mouse_context_menu.is_some();
+        if has_context_menu {
+            return;
+        }
+
         let hover_popovers = self.editor.update(cx, |editor, cx| {
             editor.hover_state.render(
                 snapshot,

From 596826f74113d0db2d2f6794ca1c7d2275da5b96 Mon Sep 17 00:00:00 2001
From: Mayank Verma 
Date: Fri, 19 Dec 2025 14:13:35 +0530
Subject: [PATCH 216/266] editor: Strip trailing newlines from completion
 documentation (#45342)

Closes #45337

Release Notes:

- Fixed broken completion menu layout caused by trailing newlines in ty
documentation



  

    Before
    After
  

  

    
before
    
    
after
    
  



---
 crates/editor/src/code_context_menus.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs
index 2336a38fa7767fa6184608066f69d3b0520234ff..96739defc506414f573e2454dc31f9c32d8e4adf 100644
--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -893,7 +893,7 @@ impl CompletionsMenu {
                                     None
                                 } else {
                                     Some(
-                                        Label::new(text.clone())
+                                        Label::new(text.trim().to_string())
                                             .ml_4()
                                             .size(LabelSize::Small)
                                             .color(Color::Muted),

From 6d776c3157a33b947406215e298997b7ea159a1a Mon Sep 17 00:00:00 2001
From: prayansh_chhablani <135210710+prayanshchh@users.noreply.github.com>
Date: Fri, 19 Dec 2025 14:41:36 +0530
Subject: [PATCH 217/266] project: Sanitize single-line completions from
 trailing newlines (#44965)

Closes #43991
trim documentation string to prevent completion overlap


previous
[Screencast from 2025-12-16
14-55-58.webm](https://github.com/user-attachments/assets/d7674d82-63b0-4a85-a90f-b5c5091e4a82)
after change
[Screencast from 2025-12-16
14-50-05.webm](https://github.com/user-attachments/assets/109c22b5-3fff-49c8-a2ec-b1af467d6320)
Release Notes:

- Fixed an issue where completions in the completion menu would span
multiple lines.
---
 crates/project/src/lsp_store.rs | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 7e8624daad628fd653326647537eb51dad208a02..5841be02b2db80b2fa15667833b8a3d3eec4ec11 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -13776,7 +13776,7 @@ impl From for CompletionDocumentation {
         match docs {
             lsp::Documentation::String(text) => {
                 if text.lines().count() <= 1 {
-                    CompletionDocumentation::SingleLine(text.into())
+                    CompletionDocumentation::SingleLine(text.trim().to_string().into())
                 } else {
                     CompletionDocumentation::MultiLinePlainText(text.into())
                 }
@@ -14368,4 +14368,22 @@ mod tests {
             )
         );
     }
+
+    #[test]
+    fn test_trailing_newline_in_completion_documentation() {
+        let doc = lsp::Documentation::String(
+            "Inappropriate argument value (of correct type).\n".to_string(),
+        );
+        let completion_doc: CompletionDocumentation = doc.into();
+        assert!(
+            matches!(completion_doc, CompletionDocumentation::SingleLine(s) if s == "Inappropriate argument value (of correct type).")
+        );
+
+        let doc = lsp::Documentation::String("  some value  \n".to_string());
+        let completion_doc: CompletionDocumentation = doc.into();
+        assert!(matches!(
+            completion_doc,
+            CompletionDocumentation::SingleLine(s) if s == "some value"
+        ));
+    }
 }

From f2495a6f98524f589b384db91d938c96c3c7819e Mon Sep 17 00:00:00 2001
From: Korbin de Man <113640462+korbindeman@users.noreply.github.com>
Date: Fri, 19 Dec 2025 11:12:01 +0100
Subject: [PATCH 218/266] Add Restore File action in project_panel for git
 modified files (#42490)

Co-authored-by: cameron 
---
 Cargo.lock                                |   1 +
 crates/project_panel/Cargo.toml           |   1 +
 crates/project_panel/src/project_panel.rs | 115 ++++++++++++++++++++++
 3 files changed, 117 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 3f7077e721e934cd6cb05af0cdaefef75602b429..4beb6c11f427fb86b5586c2833c50b7cd5b9dd01 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12570,6 +12570,7 @@ dependencies = [
  "gpui",
  "language",
  "menu",
+ "notifications",
  "pretty_assertions",
  "project",
  "rayon",
diff --git a/crates/project_panel/Cargo.toml b/crates/project_panel/Cargo.toml
index 2c47efd0b0e2490bbfd6125069fa5ca1438ffb51..0385c3789e923da95a1eca7a5a469bad00020639 100644
--- a/crates/project_panel/Cargo.toml
+++ b/crates/project_panel/Cargo.toml
@@ -45,6 +45,7 @@ workspace.workspace = true
 language.workspace = true
 zed_actions.workspace = true
 telemetry.workspace = true
+notifications.workspace = true
 
 [dev-dependencies]
 client = { workspace = true, features = ["test-support"] }
diff --git a/crates/project_panel/src/project_panel.rs b/crates/project_panel/src/project_panel.rs
index 00aba96ef428eea643e8868e513ab9c3aaa1b910..43f63d90789a65bce54814f3adbc6f1d53235568 100644
--- a/crates/project_panel/src/project_panel.rs
+++ b/crates/project_panel/src/project_panel.rs
@@ -29,6 +29,7 @@ use gpui::{
 };
 use language::DiagnosticSeverity;
 use menu::{Confirm, SelectFirst, SelectLast, SelectNext, SelectPrevious};
+use notifications::status_toast::{StatusToast, ToastIcon};
 use project::{
     Entry, EntryKind, Fs, GitEntry, GitEntryRef, GitTraversal, Project, ProjectEntryId,
     ProjectPath, Worktree, WorktreeId,
@@ -1140,6 +1141,12 @@ impl ProjectPanel {
                                 "Copy Relative Path",
                                 Box::new(zed_actions::workspace::CopyRelativePath),
                             )
+                            .when(!is_dir && self.has_git_changes(entry_id), |menu| {
+                                menu.separator().action(
+                                    "Restore File",
+                                    Box::new(git::RestoreFile { skip_prompt: false }),
+                                )
+                            })
                             .when(has_git_repo, |menu| {
                                 menu.separator()
                                     .action("View File History", Box::new(git::FileHistory))
@@ -1180,6 +1187,19 @@ impl ProjectPanel {
         cx.notify();
     }
 
+    fn has_git_changes(&self, entry_id: ProjectEntryId) -> bool {
+        for visible in &self.state.visible_entries {
+            if let Some(git_entry) = visible.entries.iter().find(|e| e.id == entry_id) {
+                let total_modified =
+                    git_entry.git_summary.index.modified + git_entry.git_summary.worktree.modified;
+                let total_deleted =
+                    git_entry.git_summary.index.deleted + git_entry.git_summary.worktree.deleted;
+                return total_modified > 0 || total_deleted > 0;
+            }
+        }
+        false
+    }
+
     fn is_unfoldable(&self, entry: &Entry, worktree: &Worktree) -> bool {
         if !entry.is_dir() || self.state.unfolded_dir_ids.contains(&entry.id) {
             return false;
@@ -2041,6 +2061,100 @@ impl ProjectPanel {
         self.remove(false, action.skip_prompt, window, cx);
     }
 
+    fn restore_file(
+        &mut self,
+        action: &git::RestoreFile,
+        window: &mut Window,
+        cx: &mut Context,
+    ) {
+        maybe!({
+            let selection = self.state.selection?;
+            let project = self.project.read(cx);
+
+            let (_worktree, entry) = self.selected_sub_entry(cx)?;
+            if entry.is_dir() {
+                return None;
+            }
+
+            let project_path = project.path_for_entry(selection.entry_id, cx)?;
+
+            let git_store = project.git_store();
+            let (repository, repo_path) = git_store
+                .read(cx)
+                .repository_and_path_for_project_path(&project_path, cx)?;
+
+            let snapshot = repository.read(cx).snapshot();
+            let status = snapshot.status_for_path(&repo_path)?;
+            if !status.status.is_modified() && !status.status.is_deleted() {
+                return None;
+            }
+
+            let file_name = entry.path.file_name()?.to_string();
+
+            let answer = if !action.skip_prompt {
+                let prompt = format!("Discard changes to {}?", file_name);
+                Some(window.prompt(PromptLevel::Info, &prompt, None, &["Restore", "Cancel"], cx))
+            } else {
+                None
+            };
+
+            cx.spawn_in(window, async move |panel, cx| {
+                if let Some(answer) = answer
+                    && answer.await != Ok(0)
+                {
+                    return anyhow::Ok(());
+                }
+
+                let task = panel.update(cx, |_panel, cx| {
+                    repository.update(cx, |repo, cx| {
+                        repo.checkout_files("HEAD", vec![repo_path], cx)
+                    })
+                })?;
+
+                if let Err(e) = task.await {
+                    panel
+                        .update(cx, |panel, cx| {
+                            let message = format!("Failed to restore {}: {}", file_name, e);
+                            let toast = StatusToast::new(message, cx, |this, _| {
+                                this.icon(ToastIcon::new(IconName::XCircle).color(Color::Error))
+                                    .dismiss_button(true)
+                            });
+                            panel
+                                .workspace
+                                .update(cx, |workspace, cx| {
+                                    workspace.toggle_status_toast(toast, cx);
+                                })
+                                .ok();
+                        })
+                        .ok();
+                }
+
+                panel
+                    .update(cx, |panel, cx| {
+                        panel.project.update(cx, |project, cx| {
+                            if let Some(buffer_id) = project
+                                .buffer_store()
+                                .read(cx)
+                                .buffer_id_for_project_path(&project_path)
+                            {
+                                if let Some(buffer) = project.buffer_for_id(*buffer_id, cx) {
+                                    buffer.update(cx, |buffer, cx| {
+                                        let _ = buffer.reload(cx);
+                                    });
+                                }
+                            }
+                        })
+                    })
+                    .ok();
+
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
+
+            Some(())
+        });
+    }
+
     fn remove(
         &mut self,
         trash: bool,
@@ -5631,6 +5745,7 @@ impl Render for ProjectPanel {
                         .on_action(cx.listener(Self::copy))
                         .on_action(cx.listener(Self::paste))
                         .on_action(cx.listener(Self::duplicate))
+                        .on_action(cx.listener(Self::restore_file))
                         .when(!project.is_remote(), |el| {
                             el.on_action(cx.listener(Self::trash))
                         })

From 7ee56e1a18c8bc557aa7f050a516419861f3a32e Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Fri, 19 Dec 2025 11:18:36 +0100
Subject: [PATCH 219/266] chore: Add worktree_benchmarks to cargo workspace
 (#45344)

Idk why it was missing, but

Release Notes:

- N/A
---
 Cargo.lock                             | 10 ++++++++++
 Cargo.toml                             |  1 +
 crates/worktree_benchmarks/src/main.rs |  4 ++--
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4beb6c11f427fb86b5586c2833c50b7cd5b9dd01..f9acd6989be8734b6c5b528435fccea62d10f027 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -20265,6 +20265,16 @@ dependencies = [
  "zlog",
 ]
 
+[[package]]
+name = "worktree_benchmarks"
+version = "0.1.0"
+dependencies = [
+ "fs",
+ "gpui",
+ "settings",
+ "worktree",
+]
+
 [[package]]
 name = "writeable"
 version = "0.6.1"
diff --git a/Cargo.toml b/Cargo.toml
index 825dc79e08978d8ccd03cea93883f698986ee12f..b507e8824484ea670619b5225fef9cfd41c81d4c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -198,6 +198,7 @@ members = [
     "crates/web_search_providers",
     "crates/workspace",
     "crates/worktree",
+    "crates/worktree_benchmarks",
     "crates/x_ai",
     "crates/zed",
     "crates/zed_actions",
diff --git a/crates/worktree_benchmarks/src/main.rs b/crates/worktree_benchmarks/src/main.rs
index 00f268b75fc5f1e7d6033ec46f3718ea39cdccda..c1b76f9e3c483ec6c989cc255a11c5320d4b49f7 100644
--- a/crates/worktree_benchmarks/src/main.rs
+++ b/crates/worktree_benchmarks/src/main.rs
@@ -5,8 +5,7 @@ use std::{
 
 use fs::RealFs;
 use gpui::Application;
-use settings::Settings;
-use worktree::{Worktree, WorktreeSettings};
+use worktree::Worktree;
 
 fn main() {
     let Some(worktree_root_path) = std::env::args().nth(1) else {
@@ -27,6 +26,7 @@ fn main() {
                 true,
                 fs,
                 Arc::new(AtomicUsize::new(0)),
+                true,
                 cx,
             )
             .await

From 3104482c6c7c06c02be7d63927487c64695ea290 Mon Sep 17 00:00:00 2001
From: Angelo Verlain <37999241+vixalien@users.noreply.github.com>
Date: Fri, 19 Dec 2025 12:34:40 +0200
Subject: [PATCH 220/266] languages: Detect `.bst` files as YAML (#45015)

These files are used by the BuildStream build project:
https://buildstream.build/index.html


Release Notes:

- Added recognition for .bst files as yaml.
---
 crates/languages/src/yaml/config.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/languages/src/yaml/config.toml b/crates/languages/src/yaml/config.toml
index 51e8e1224a40904e0dfbb0204eb531e6b2664825..9a07a560b06766ac00dd73b6210023c4cddd491d 100644
--- a/crates/languages/src/yaml/config.toml
+++ b/crates/languages/src/yaml/config.toml
@@ -1,6 +1,6 @@
 name = "YAML"
 grammar = "yaml"
-path_suffixes = ["yml", "yaml", "pixi.lock", "clang-format", "clangd"]
+path_suffixes = ["yml", "yaml", "pixi.lock", "clang-format", "clangd", "bst"]
 line_comments = ["# "]
 autoclose_before = ",]}"
 brackets = [

From 1ac170e663339e05457261959bcb0870961d127b Mon Sep 17 00:00:00 2001
From: Lena <241371603+zelenenka@users.noreply.github.com>
Date: Fri, 19 Dec 2025 12:46:20 +0100
Subject: [PATCH 221/266] Upgrade stalebot and make testing it easier (#45350)

- adjust wording for the upcoming simplified process
- upgrade to the github action version that has a fix for configuring issue types the bot should look at
- add two inputs for the manual runs of stalebot that help testing it in a safe and controlled manner

Release Notes:

- N/A
---
 .../community_close_stale_issues.yml          | 23 ++++++++++++++-----
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/community_close_stale_issues.yml b/.github/workflows/community_close_stale_issues.yml
index 14c1a0a08338ee513a8269094b41ee404beef726..113e5ed131d1443c5481ff2966fac6a234561a20 100644
--- a/.github/workflows/community_close_stale_issues.yml
+++ b/.github/workflows/community_close_stale_issues.yml
@@ -3,27 +3,38 @@ on:
   schedule:
     - cron: "0 8 31 DEC *"
   workflow_dispatch:
+    inputs:
+      debug-only:
+        description: "Run in dry-run mode (no changes made)"
+        type: boolean
+        default: false
+      operations-per-run:
+        description: "Max number of issues to process (default: 1000)"
+        type: number
+        default: 1000
 
 jobs:
   stale:
     if: github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9
+      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           stale-issue-message: >
-            Hi there! 👋
-
-            We're working to clean up our issue tracker by closing older bugs that might not be relevant anymore. If you are able to reproduce this issue in the latest version of Zed, please let us know by commenting on this issue, and it will be kept open. If you can't reproduce it, feel free to close the issue yourself. Otherwise, it will close automatically in 14 days.
+            Hi there!
+            Zed development moves fast and a significant number of bugs become outdated.
+            If you can reproduce this bug on the latest stable Zed, please let us know by leaving a comment with the Zed version.
+            If the bug doesn't appear for you anymore, feel free to close the issue yourself; otherwise, the bot will close it in a couple of weeks.
 
             Thanks for your help!
-          close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, please open a new issue with a link to this issue."
+          close-issue-message: "This issue was closed due to inactivity. If you're still experiencing this problem, please leave a comment with your Zed version so that we can reopen the issue."
           days-before-stale: 60
           days-before-close: 14
           only-issue-types: "Bug,Crash"
-          operations-per-run: 1000
+          operations-per-run: ${{ inputs.operations-per-run || 1000 }}
           ascending: true
           enable-statistics: true
+          debug-only: ${{ inputs.debug-only }}
           stale-issue-label: "stale"
           exempt-issue-labels: "never stale"

From 95ae388c0ce8ae4a0b8d149ace3ecba1ea417491 Mon Sep 17 00:00:00 2001
From: Agus Zubiaga 
Date: Fri, 19 Dec 2025 09:19:04 -0300
Subject: [PATCH 222/266] Fix title bar spacing when building on the macOS
 Tahoe SDK (#45351)

The size and spacing around the traffic light buttons changes after
macOS SDK 26. Our official builds aren't using this SDK yet, but dev
builds sometimes are and the official will in the future.





Before
After





CleanShot 2025-12-19 at 08 58 53@2x


CleanShot 2025-12-19 at 08 57 02@2x






CleanShot 2025-12-19 at 08 59 40@2x


CleanShot 2025-12-19 at 09 01 17@2x






Release Notes:

- N/A
---
 crates/title_bar/build.rs                     | 28 +++++++++
 .../title_bar/src/platforms/platform_mac.rs   | 14 +++--
 crates/title_bar/src/title_bar.rs             | 58 ++++++++++---------
 3 files changed, 68 insertions(+), 32 deletions(-)
 create mode 100644 crates/title_bar/build.rs

diff --git a/crates/title_bar/build.rs b/crates/title_bar/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ef70268ad3127baf113824348cb3e8685392a52b
--- /dev/null
+++ b/crates/title_bar/build.rs
@@ -0,0 +1,28 @@
+#![allow(clippy::disallowed_methods, reason = "build scripts are exempt")]
+
+fn main() {
+    println!("cargo::rustc-check-cfg=cfg(macos_sdk_26)");
+
+    #[cfg(target_os = "macos")]
+    {
+        use std::process::Command;
+
+        let output = Command::new("xcrun")
+            .args(["--sdk", "macosx", "--show-sdk-version"])
+            .output()
+            .unwrap();
+
+        let sdk_version = String::from_utf8(output.stdout).unwrap();
+        let major_version: Option = sdk_version
+            .trim()
+            .split('.')
+            .next()
+            .and_then(|v| v.parse().ok());
+
+        if let Some(major) = major_version
+            && major >= 26
+        {
+            println!("cargo:rustc-cfg=macos_sdk_26");
+        }
+    }
+}
diff --git a/crates/title_bar/src/platforms/platform_mac.rs b/crates/title_bar/src/platforms/platform_mac.rs
index c7becde6c1af48bf37e06c0d2dcf991ad3c9f19f..5e8e4e5087054e59f66527915ae97e352a9ff525 100644
--- a/crates/title_bar/src/platforms/platform_mac.rs
+++ b/crates/title_bar/src/platforms/platform_mac.rs
@@ -1,6 +1,10 @@
-/// Use pixels here instead of a rem-based size because the macOS traffic
-/// lights are a static size, and don't scale with the rest of the UI.
-///
-/// Magic number: There is one extra pixel of padding on the left side due to
-/// the 1px border around the window on macOS apps.
+// Use pixels here instead of a rem-based size because the macOS traffic
+// lights are a static size, and don't scale with the rest of the UI.
+//
+// Magic number: There is one extra pixel of padding on the left side due to
+// the 1px border around the window on macOS apps.
+#[cfg(macos_sdk_26)]
+pub const TRAFFIC_LIGHT_PADDING: f32 = 78.;
+
+#[cfg(not(macos_sdk_26))]
 pub const TRAFFIC_LIGHT_PADDING: f32 = 71.;
diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index 23572677919509d859a141cb09cce8f5822697ef..d7759b0df8019eed2ad59b73bcaffaa3ffcfb866 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -447,34 +447,38 @@ impl TitleBar {
             return None;
         }
 
-        Some(
-            Button::new("restricted_mode_trigger", "Restricted Mode")
-                .style(ButtonStyle::Tinted(TintColor::Warning))
-                .label_size(LabelSize::Small)
-                .color(Color::Warning)
-                .icon(IconName::Warning)
-                .icon_color(Color::Warning)
-                .icon_size(IconSize::Small)
-                .icon_position(IconPosition::Start)
-                .tooltip(|_, cx| {
-                    Tooltip::with_meta(
-                        "You're in Restricted Mode",
-                        Some(&ToggleWorktreeSecurity),
-                        "Mark this project as trusted and unlock all features",
-                        cx,
-                    )
-                })
-                .on_click({
-                    cx.listener(move |this, _, window, cx| {
-                        this.workspace
-                            .update(cx, |workspace, cx| {
-                                workspace.show_worktree_trust_security_modal(true, window, cx)
-                            })
-                            .log_err();
-                    })
+        let button = Button::new("restricted_mode_trigger", "Restricted Mode")
+            .style(ButtonStyle::Tinted(TintColor::Warning))
+            .label_size(LabelSize::Small)
+            .color(Color::Warning)
+            .icon(IconName::Warning)
+            .icon_color(Color::Warning)
+            .icon_size(IconSize::Small)
+            .icon_position(IconPosition::Start)
+            .tooltip(|_, cx| {
+                Tooltip::with_meta(
+                    "You're in Restricted Mode",
+                    Some(&ToggleWorktreeSecurity),
+                    "Mark this project as trusted and unlock all features",
+                    cx,
+                )
+            })
+            .on_click({
+                cx.listener(move |this, _, window, cx| {
+                    this.workspace
+                        .update(cx, |workspace, cx| {
+                            workspace.show_worktree_trust_security_modal(true, window, cx)
+                        })
+                        .log_err();
                 })
-                .into_any_element(),
-        )
+            });
+
+        if cfg!(macos_sdk_26) {
+            // Make up for Tahoe's traffic light buttons having less spacing around them
+            Some(div().child(button).ml_0p5().into_any_element())
+        } else {
+            Some(button.into_any_element())
+        }
     }
 
     pub fn render_project_host(&self, cx: &mut Context) -> Option {

From b9aef75f2df4ae8fa1707d348b4d588c3784526b Mon Sep 17 00:00:00 2001
From: Lena <241371603+zelenenka@users.noreply.github.com>
Date: Fri, 19 Dec 2025 13:41:03 +0100
Subject: [PATCH 223/266] Turn on the fixed stalebot (#45355)

It will run weekly and it promised not to touch issues of the wrong
types anymore.

Release Notes:

- N/A
---
 .github/workflows/community_close_stale_issues.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/community_close_stale_issues.yml b/.github/workflows/community_close_stale_issues.yml
index 113e5ed131d1443c5481ff2966fac6a234561a20..6347b713257f49c02f981774faa0d0359e05e4d3 100644
--- a/.github/workflows/community_close_stale_issues.yml
+++ b/.github/workflows/community_close_stale_issues.yml
@@ -1,7 +1,7 @@
 name: "Close Stale Issues"
 on:
   schedule:
-    - cron: "0 8 31 DEC *"
+    - cron: "0 2 * * 5"
   workflow_dispatch:
     inputs:
       debug-only:

From 1dc5de4592ebf0ec51ba77bbd41c495aee67184e Mon Sep 17 00:00:00 2001
From: Jakub Konka 
Date: Fri, 19 Dec 2025 13:54:30 +0100
Subject: [PATCH 224/266] workspace: Auto-switch git context when focus changed
 (#45354)

Closes #44955

Release Notes:

- Fixed workspace incorrectly automatically switching Git
repository/branch context in multi-repository projects when repo/branch
switched manually from the Git panel.
---
 crates/workspace/src/workspace.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 0c5c9ffa5d0bfb1f70ce6a861b0209f321222fc0..139fa88359c574e1565ed778fdfbd5fa1c8f7944 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -4223,7 +4223,7 @@ impl Workspace {
         cx: &mut Context,
     ) {
         self.active_pane = pane.clone();
-        self.active_item_path_changed(window, cx);
+        self.active_item_path_changed(true, window, cx);
         self.last_active_center_pane = Some(pane.downgrade());
     }
 
@@ -4280,7 +4280,7 @@ impl Workspace {
                 }
                 serialize_workspace = *focus_changed || pane != self.active_pane();
                 if pane == self.active_pane() {
-                    self.active_item_path_changed(window, cx);
+                    self.active_item_path_changed(*focus_changed, window, cx);
                     self.update_active_view_for_followers(window, cx);
                 } else if *local {
                     self.set_active_pane(pane, window, cx);
@@ -4296,7 +4296,7 @@ impl Workspace {
             }
             pane::Event::ChangeItemTitle => {
                 if *pane == self.active_pane {
-                    self.active_item_path_changed(window, cx);
+                    self.active_item_path_changed(false, window, cx);
                 }
                 serialize_workspace = false;
             }
@@ -4465,7 +4465,7 @@ impl Workspace {
 
             cx.notify();
         } else {
-            self.active_item_path_changed(window, cx);
+            self.active_item_path_changed(true, window, cx);
         }
         cx.emit(Event::PaneRemoved);
     }
@@ -4719,14 +4719,19 @@ impl Workspace {
         self.follower_states.contains_key(&id.into())
     }
 
-    fn active_item_path_changed(&mut self, window: &mut Window, cx: &mut Context) {
+    fn active_item_path_changed(
+        &mut self,
+        focus_changed: bool,
+        window: &mut Window,
+        cx: &mut Context,
+    ) {
         cx.emit(Event::ActiveItemChanged);
         let active_entry = self.active_project_path(cx);
         self.project.update(cx, |project, cx| {
             project.set_active_path(active_entry.clone(), cx)
         });
 
-        if let Some(project_path) = &active_entry {
+        if focus_changed && let Some(project_path) = &active_entry {
             let git_store_entity = self.project.read(cx).git_store().clone();
             git_store_entity.update(cx, |git_store, cx| {
                 git_store.set_active_repo_for_path(project_path, cx);

From 69f6eeaa3ae821c43b7bf0dfc241c2792573b338 Mon Sep 17 00:00:00 2001
From: Piotr Osiewicz <24362066+osiewicz@users.noreply.github.com>
Date: Fri, 19 Dec 2025 14:06:15 +0100
Subject: [PATCH 225/266] toolchains: Fix persistence by not relying on
 unstable worktree id (#45357)

Closes #42268
We've migrated user selections when a given workspace has a single
worktree (as then we could determine what the target worktree is).

Release Notes:

- python: Fixed selected virtual environments not being
persisted/deserialized correctly within long-running Zed sessions (where
multiple different projects might've been opened). This is a breaking
change for users of multi-worktree projects - your selected toolchain
for those projects will be reset.

Co-authored-by: Dino 
---
 crates/language/src/toolchain.rs              |  7 +-
 crates/project/src/project.rs                 |  7 +-
 crates/project/src/toolchain_store.rs         | 26 +++++-
 crates/project/src/x.py                       |  1 +
 .../src/active_toolchain.rs                   |  9 ++-
 .../src/toolchain_selector.rs                 | 43 +++++++---
 crates/workspace/src/persistence.rs           | 81 ++++++++++++++-----
 crates/workspace/src/workspace.rs             | 31 ++++++-
 8 files changed, 165 insertions(+), 40 deletions(-)
 create mode 100644 crates/project/src/x.py

diff --git a/crates/language/src/toolchain.rs b/crates/language/src/toolchain.rs
index 5717ffb5143e38bce736c354b43febc86e321f32..815ece30a1ed46ae65ec4af2ba64501ff3489718 100644
--- a/crates/language/src/toolchain.rs
+++ b/crates/language/src/toolchain.rs
@@ -4,7 +4,10 @@
 //! which is a set of tools used to interact with the projects written in said language.
 //! For example, a Python project can have an associated virtual environment; a Rust project can have a toolchain override.
 
-use std::{path::PathBuf, sync::Arc};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 use async_trait::async_trait;
 use collections::HashMap;
@@ -36,7 +39,7 @@ pub struct Toolchain {
 /// - Only in the subproject they're currently in.
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
 pub enum ToolchainScope {
-    Subproject(WorktreeId, Arc),
+    Subproject(Arc, Arc),
     Project,
     /// Available in all projects on this box. It wouldn't make sense to show suggestions across machines.
     Global,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 5e31f2a90cf137f1e4d788952832e1eb2ee0ec35..25a19788fdb464f5f289ef3bc3513f21743e3a9a 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -1330,7 +1330,12 @@ impl Project {
             cx.subscribe(&buffer_store, Self::on_buffer_store_event)
                 .detach();
             let toolchain_store = cx.new(|cx| {
-                ToolchainStore::remote(REMOTE_SERVER_PROJECT_ID, remote.read(cx).proto_client(), cx)
+                ToolchainStore::remote(
+                    REMOTE_SERVER_PROJECT_ID,
+                    worktree_store.clone(),
+                    remote.read(cx).proto_client(),
+                    cx,
+                )
             });
             let task_store = cx.new(|cx| {
                 TaskStore::remote(
diff --git a/crates/project/src/toolchain_store.rs b/crates/project/src/toolchain_store.rs
index 21b74bd784d1d9af12fe43e3fe82051afc103b0d..7afc70827f85e1a1bafcad436409936876fd3b45 100644
--- a/crates/project/src/toolchain_store.rs
+++ b/crates/project/src/toolchain_store.rs
@@ -32,6 +32,7 @@ use crate::{
 pub struct ToolchainStore {
     mode: ToolchainStoreInner,
     user_toolchains: BTreeMap>,
+    worktree_store: Entity,
     _sub: Subscription,
 }
 
@@ -66,7 +67,7 @@ impl ToolchainStore {
     ) -> Self {
         let entity = cx.new(|_| LocalToolchainStore {
             languages,
-            worktree_store,
+            worktree_store: worktree_store.clone(),
             project_environment,
             active_toolchains: Default::default(),
             manifest_tree,
@@ -77,12 +78,18 @@ impl ToolchainStore {
         });
         Self {
             mode: ToolchainStoreInner::Local(entity),
+            worktree_store,
             user_toolchains: Default::default(),
             _sub,
         }
     }
 
-    pub(super) fn remote(project_id: u64, client: AnyProtoClient, cx: &mut Context) -> Self {
+    pub(super) fn remote(
+        project_id: u64,
+        worktree_store: Entity,
+        client: AnyProtoClient,
+        cx: &mut Context,
+    ) -> Self {
         let entity = cx.new(|_| RemoteToolchainStore { client, project_id });
         let _sub = cx.subscribe(&entity, |_, _, e: &ToolchainStoreEvent, cx| {
             cx.emit(e.clone())
@@ -90,6 +97,7 @@ impl ToolchainStore {
         Self {
             mode: ToolchainStoreInner::Remote(entity),
             user_toolchains: Default::default(),
+            worktree_store,
             _sub,
         }
     }
@@ -165,12 +173,22 @@ impl ToolchainStore {
         language_name: LanguageName,
         cx: &mut Context,
     ) -> Task> {
+        let Some(worktree) = self
+            .worktree_store
+            .read(cx)
+            .worktree_for_id(path.worktree_id, cx)
+        else {
+            return Task::ready(None);
+        };
+        let target_root_path = worktree.read_with(cx, |this, _| this.abs_path());
+
         let user_toolchains = self
             .user_toolchains
             .iter()
             .filter(|(scope, _)| {
-                if let ToolchainScope::Subproject(worktree_id, relative_path) = scope {
-                    path.worktree_id == *worktree_id && relative_path.starts_with(&path.path)
+                if let ToolchainScope::Subproject(subproject_root_path, relative_path) = scope {
+                    target_root_path == *subproject_root_path
+                        && relative_path.starts_with(&path.path)
                 } else {
                     true
                 }
diff --git a/crates/project/src/x.py b/crates/project/src/x.py
new file mode 100644
index 0000000000000000000000000000000000000000..58947a58a41bcc2e2f8c2046b5e1c8c38c0fbbb8
--- /dev/null
+++ b/crates/project/src/x.py
@@ -0,0 +1 @@
+Gliwice makerspace
\ No newline at end of file
diff --git a/crates/toolchain_selector/src/active_toolchain.rs b/crates/toolchain_selector/src/active_toolchain.rs
index 03c152e3fd3df0c62ab2f5c7e4a4746875ac955a..06f7d1cdf3e27f43bdb5013038b943b9e5193680 100644
--- a/crates/toolchain_selector/src/active_toolchain.rs
+++ b/crates/toolchain_selector/src/active_toolchain.rs
@@ -198,10 +198,17 @@ impl ActiveToolchain {
                     .or_else(|| toolchains.toolchains.first())
                     .cloned();
                 if let Some(toolchain) = &default_choice {
+                    let worktree_root_path = project
+                        .read_with(cx, |this, cx| {
+                            this.worktree_for_id(worktree_id, cx)
+                                .map(|worktree| worktree.read(cx).abs_path())
+                        })
+                        .ok()
+                        .flatten()?;
                     workspace::WORKSPACE_DB
                         .set_toolchain(
                             workspace_id,
-                            worktree_id,
+                            worktree_root_path,
                             relative_path.clone(),
                             toolchain.clone(),
                         )
diff --git a/crates/toolchain_selector/src/toolchain_selector.rs b/crates/toolchain_selector/src/toolchain_selector.rs
index f7262c248f15f0f68fcd7a903ee01cac6b22d0af..36ef2b960a8abfe684628cea465b68e6eab5e463 100644
--- a/crates/toolchain_selector/src/toolchain_selector.rs
+++ b/crates/toolchain_selector/src/toolchain_selector.rs
@@ -1,6 +1,7 @@
 mod active_toolchain;
 
 pub use active_toolchain::ActiveToolchain;
+use anyhow::Context as _;
 use convert_case::Casing as _;
 use editor::Editor;
 use file_finder::OpenPathDelegate;
@@ -62,6 +63,7 @@ struct AddToolchainState {
     language_name: LanguageName,
     root_path: ProjectPath,
     weak: WeakEntity,
+    worktree_root_path: Arc,
 }
 
 struct ScopePickerState {
@@ -99,12 +101,17 @@ impl AddToolchainState {
         root_path: ProjectPath,
         window: &mut Window,
         cx: &mut Context,
-    ) -> Entity {
+    ) -> anyhow::Result> {
         let weak = cx.weak_entity();
-
-        cx.new(|cx| {
+        let worktree_root_path = project
+            .read(cx)
+            .worktree_for_id(root_path.worktree_id, cx)
+            .map(|worktree| worktree.read(cx).abs_path())
+            .context("Could not find worktree")?;
+        Ok(cx.new(|cx| {
             let (lister, rx) = Self::create_path_browser_delegate(project.clone(), cx);
             let picker = cx.new(|cx| Picker::uniform_list(lister, window, cx));
+
             Self {
                 state: AddState::Path {
                     _subscription: cx.subscribe(&picker, |_, _, _: &DismissEvent, cx| {
@@ -118,8 +125,9 @@ impl AddToolchainState {
                 language_name,
                 root_path,
                 weak,
+                worktree_root_path,
             }
-        })
+        }))
     }
 
     fn create_path_browser_delegate(
@@ -237,7 +245,15 @@ impl AddToolchainState {
                 // Suggest a default scope based on the applicability.
                 let scope = if let Some(project_path) = resolved_toolchain_path {
                     if !root_path.path.as_ref().is_empty() && project_path.starts_with(&root_path) {
-                        ToolchainScope::Subproject(root_path.worktree_id, root_path.path)
+                        let worktree_root_path = project
+                            .read_with(cx, |this, cx| {
+                                this.worktree_for_id(root_path.worktree_id, cx)
+                                    .map(|worktree| worktree.read(cx).abs_path())
+                            })
+                            .ok()
+                            .flatten()
+                            .context("Could not find a worktree with a given worktree ID")?;
+                        ToolchainScope::Subproject(worktree_root_path, root_path.path)
                     } else {
                         ToolchainScope::Project
                     }
@@ -400,7 +416,7 @@ impl Render for AddToolchainState {
                         ToolchainScope::Global,
                         ToolchainScope::Project,
                         ToolchainScope::Subproject(
-                            self.root_path.worktree_id,
+                            self.worktree_root_path.clone(),
                             self.root_path.path.clone(),
                         ),
                     ];
@@ -693,7 +709,7 @@ impl ToolchainSelector {
         cx: &mut Context,
     ) {
         if matches!(self.state, State::Search(_)) {
-            self.state = State::AddToolchain(AddToolchainState::new(
+            let Ok(state) = AddToolchainState::new(
                 self.project.clone(),
                 self.language_name.clone(),
                 ProjectPath {
@@ -702,7 +718,10 @@ impl ToolchainSelector {
                 },
                 window,
                 cx,
-            ));
+            ) else {
+                return;
+            };
+            self.state = State::AddToolchain(state);
             self.state.focus_handle(cx).focus(window, cx);
             cx.notify();
         }
@@ -899,11 +918,17 @@ impl PickerDelegate for ToolchainSelectorDelegate {
             {
                 let workspace = self.workspace.clone();
                 let worktree_id = self.worktree_id;
+                let worktree_abs_path_root = self.worktree_abs_path_root.clone();
                 let path = self.relative_path.clone();
                 let relative_path = self.relative_path.clone();
                 cx.spawn_in(window, async move |_, cx| {
                     workspace::WORKSPACE_DB
-                        .set_toolchain(workspace_id, worktree_id, relative_path, toolchain.clone())
+                        .set_toolchain(
+                            workspace_id,
+                            worktree_abs_path_root,
+                            relative_path,
+                            toolchain.clone(),
+                        )
                         .await
                         .log_err();
                     workspace
diff --git a/crates/workspace/src/persistence.rs b/crates/workspace/src/persistence.rs
index 094d03494e726677dc43235d96fc62c076673bf5..8d20339ec952020416e4b8d5846bf44f5f8e9b98 100644
--- a/crates/workspace/src/persistence.rs
+++ b/crates/workspace/src/persistence.rs
@@ -24,7 +24,6 @@ use project::{
 };
 
 use language::{LanguageName, Toolchain, ToolchainScope};
-use project::WorktreeId;
 use remote::{
     DockerConnectionOptions, RemoteConnectionOptions, SshConnectionOptions, WslConnectionOptions,
 };
@@ -845,6 +844,44 @@ impl Domain for WorkspaceDb {
                 host_name TEXT
             ) STRICT;
         ),
+        sql!(CREATE TABLE toolchains2 (
+            workspace_id INTEGER,
+            worktree_root_path TEXT NOT NULL,
+            language_name TEXT NOT NULL,
+            name TEXT NOT NULL,
+            path TEXT NOT NULL,
+            raw_json TEXT NOT NULL,
+            relative_worktree_path TEXT NOT NULL,
+            PRIMARY KEY (workspace_id, worktree_root_path, language_name, relative_worktree_path)) STRICT;
+            INSERT OR REPLACE INTO toolchains2
+                // The `instr(paths, '\n') = 0` part allows us to find all
+                // workspaces that have a single worktree, as `\n` is used as a
+                // separator when serializing the workspace paths, so if no `\n` is
+                // found, we know we have a single worktree.
+                SELECT toolchains.workspace_id, paths, language_name, name, path, raw_json, relative_worktree_path FROM toolchains INNER JOIN workspaces ON toolchains.workspace_id = workspaces.workspace_id AND instr(paths, '\n') = 0;
+            DROP TABLE toolchains;
+            ALTER TABLE toolchains2 RENAME TO toolchains;
+        ),
+        sql!(CREATE TABLE user_toolchains2 (
+            remote_connection_id INTEGER,
+            workspace_id INTEGER NOT NULL,
+            worktree_root_path TEXT NOT NULL,
+            relative_worktree_path TEXT NOT NULL,
+            language_name TEXT NOT NULL,
+            name TEXT NOT NULL,
+            path TEXT NOT NULL,
+            raw_json TEXT NOT NULL,
+
+            PRIMARY KEY (workspace_id, worktree_root_path, relative_worktree_path, language_name, name, path, raw_json)) STRICT;
+            INSERT OR REPLACE INTO user_toolchains2
+                // The `instr(paths, '\n') = 0` part allows us to find all
+                // workspaces that have a single worktree, as `\n` is used as a
+                // separator when serializing the workspace paths, so if no `\n` is
+                // found, we know we have a single worktree.
+                SELECT user_toolchains.remote_connection_id, user_toolchains.workspace_id, paths, relative_worktree_path, language_name, name, path, raw_json  FROM user_toolchains INNER JOIN workspaces ON user_toolchains.workspace_id = workspaces.workspace_id AND instr(paths, '\n') = 0;
+            DROP TABLE user_toolchains;
+            ALTER TABLE user_toolchains2 RENAME TO user_toolchains;
+        ),
     ];
 
     // Allow recovering from bad migration that was initially shipped to nightly
@@ -1030,11 +1067,11 @@ impl WorkspaceDb {
         workspace_id: WorkspaceId,
         remote_connection_id: Option,
     ) -> BTreeMap> {
-        type RowKind = (WorkspaceId, u64, String, String, String, String, String);
+        type RowKind = (WorkspaceId, String, String, String, String, String, String);
 
         let toolchains: Vec = self
             .select_bound(sql! {
-                SELECT workspace_id, worktree_id, relative_worktree_path,
+                SELECT workspace_id, worktree_root_path, relative_worktree_path,
                 language_name, name, path, raw_json
                 FROM user_toolchains WHERE remote_connection_id IS ?1 AND (
                       workspace_id IN (0, ?2)
@@ -1048,7 +1085,7 @@ impl WorkspaceDb {
 
         for (
             _workspace_id,
-            worktree_id,
+            worktree_root_path,
             relative_worktree_path,
             language_name,
             name,
@@ -1058,22 +1095,24 @@ impl WorkspaceDb {
         {
             // INTEGER's that are primary keys (like workspace ids, remote connection ids and such) start at 1, so we're safe to
             let scope = if _workspace_id == WorkspaceId(0) {
-                debug_assert_eq!(worktree_id, u64::MAX);
+                debug_assert_eq!(worktree_root_path, String::default());
                 debug_assert_eq!(relative_worktree_path, String::default());
                 ToolchainScope::Global
             } else {
                 debug_assert_eq!(workspace_id, _workspace_id);
                 debug_assert_eq!(
-                    worktree_id == u64::MAX,
+                    worktree_root_path == String::default(),
                     relative_worktree_path == String::default()
                 );
 
                 let Some(relative_path) = RelPath::unix(&relative_worktree_path).log_err() else {
                     continue;
                 };
-                if worktree_id != u64::MAX && relative_worktree_path != String::default() {
+                if worktree_root_path != String::default()
+                    && relative_worktree_path != String::default()
+                {
                     ToolchainScope::Subproject(
-                        WorktreeId::from_usize(worktree_id as usize),
+                        Arc::from(worktree_root_path.as_ref()),
                         relative_path.into(),
                     )
                 } else {
@@ -1159,13 +1198,13 @@ impl WorkspaceDb {
 
                 for (scope, toolchains) in workspace.user_toolchains {
                     for toolchain in toolchains {
-                        let query = sql!(INSERT OR REPLACE INTO user_toolchains(remote_connection_id, workspace_id, worktree_id, relative_worktree_path, language_name, name, path, raw_json) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8));
-                        let (workspace_id, worktree_id, relative_worktree_path) = match scope {
-                            ToolchainScope::Subproject(worktree_id, ref path) => (Some(workspace.id), Some(worktree_id), Some(path.as_unix_str().to_owned())),
+                        let query = sql!(INSERT OR REPLACE INTO user_toolchains(remote_connection_id, workspace_id, worktree_root_path, relative_worktree_path, language_name, name, path, raw_json) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8));
+                        let (workspace_id, worktree_root_path, relative_worktree_path) = match scope {
+                            ToolchainScope::Subproject(ref worktree_root_path, ref path) => (Some(workspace.id), Some(worktree_root_path.to_string_lossy().into_owned()), Some(path.as_unix_str().to_owned())),
                             ToolchainScope::Project => (Some(workspace.id), None, None),
                             ToolchainScope::Global => (None, None, None),
                         };
-                        let args = (remote_connection_id, workspace_id.unwrap_or(WorkspaceId(0)), worktree_id.map_or(usize::MAX,|id| id.to_usize()), relative_worktree_path.unwrap_or_default(),
+                        let args = (remote_connection_id, workspace_id.unwrap_or(WorkspaceId(0)), worktree_root_path.unwrap_or_default(), relative_worktree_path.unwrap_or_default(),
                         toolchain.language_name.as_ref().to_owned(), toolchain.name.to_string(), toolchain.path.to_string(), toolchain.as_json.to_string());
                         if let Err(err) = conn.exec_bound(query)?(args) {
                             log::error!("{err}");
@@ -1844,24 +1883,24 @@ impl WorkspaceDb {
     pub(crate) async fn toolchains(
         &self,
         workspace_id: WorkspaceId,
-    ) -> Result)>> {
+    ) -> Result, Arc)>> {
         self.write(move |this| {
             let mut select = this
                 .select_bound(sql!(
                     SELECT
-                        name, path, worktree_id, relative_worktree_path, language_name, raw_json
+                        name, path, worktree_root_path, relative_worktree_path, language_name, raw_json
                     FROM toolchains
                     WHERE workspace_id = ?
                 ))
                 .context("select toolchains")?;
 
-            let toolchain: Vec<(String, String, u64, String, String, String)> =
+            let toolchain: Vec<(String, String, String, String, String, String)> =
                 select(workspace_id)?;
 
             Ok(toolchain
                 .into_iter()
                 .filter_map(
-                    |(name, path, worktree_id, relative_worktree_path, language, json)| {
+                    |(name, path, worktree_root_path, relative_worktree_path, language, json)| {
                         Some((
                             Toolchain {
                                 name: name.into(),
@@ -1869,7 +1908,7 @@ impl WorkspaceDb {
                                 language_name: LanguageName::new(&language),
                                 as_json: serde_json::Value::from_str(&json).ok()?,
                             },
-                            WorktreeId::from_proto(worktree_id),
+                           Arc::from(worktree_root_path.as_ref()),
                             RelPath::from_proto(&relative_worktree_path).log_err()?,
                         ))
                     },
@@ -1882,18 +1921,18 @@ impl WorkspaceDb {
     pub async fn set_toolchain(
         &self,
         workspace_id: WorkspaceId,
-        worktree_id: WorktreeId,
+        worktree_root_path: Arc,
         relative_worktree_path: Arc,
         toolchain: Toolchain,
     ) -> Result<()> {
         log::debug!(
-            "Setting toolchain for workspace, worktree: {worktree_id:?}, relative path: {relative_worktree_path:?}, toolchain: {}",
+            "Setting toolchain for workspace, worktree: {worktree_root_path:?}, relative path: {relative_worktree_path:?}, toolchain: {}",
             toolchain.name
         );
         self.write(move |conn| {
             let mut insert = conn
                 .exec_bound(sql!(
-                    INSERT INTO toolchains(workspace_id, worktree_id, relative_worktree_path, language_name, name, path, raw_json) VALUES (?, ?, ?, ?, ?,  ?, ?)
+                    INSERT INTO toolchains(workspace_id, worktree_root_path, relative_worktree_path, language_name, name, path, raw_json) VALUES (?, ?, ?, ?, ?,  ?, ?)
                     ON CONFLICT DO
                     UPDATE SET
                         name = ?5,
@@ -1904,7 +1943,7 @@ impl WorkspaceDb {
 
             insert((
                 workspace_id,
-                worktree_id.to_usize(),
+                worktree_root_path.to_string_lossy().into_owned(),
                 relative_worktree_path.as_unix_str(),
                 toolchain.language_name.as_ref(),
                 toolchain.name.as_ref(),
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 139fa88359c574e1565ed778fdfbd5fa1c8f7944..53b0cc0623fa4b3ce7de5f1d8e3fd2262210a09a 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1697,8 +1697,22 @@ impl Workspace {
 
             let toolchains = DB.toolchains(workspace_id).await?;
 
-            for (toolchain, worktree_id, path) in toolchains {
+            for (toolchain, worktree_path, path) in toolchains {
                 let toolchain_path = PathBuf::from(toolchain.path.clone().to_string());
+                let Some(worktree_id) = project_handle.read_with(cx, |this, cx| {
+                    this.find_worktree(&worktree_path, cx)
+                        .and_then(|(worktree, rel_path)| {
+                            if rel_path.is_empty() {
+                                Some(worktree.read(cx).id())
+                            } else {
+                                None
+                            }
+                        })
+                })?
+                else {
+                    // We did not find a worktree with a given path, but that's whatever.
+                    continue;
+                };
                 if !app_state.fs.is_file(toolchain_path.as_path()).await {
                     continue;
                 }
@@ -8217,9 +8231,22 @@ async fn open_remote_project_inner(
     cx: &mut AsyncApp,
 ) -> Result>>> {
     let toolchains = DB.toolchains(workspace_id).await?;
-    for (toolchain, worktree_id, path) in toolchains {
+    for (toolchain, worktree_path, path) in toolchains {
         project
             .update(cx, |this, cx| {
+                let Some(worktree_id) =
+                    this.find_worktree(&worktree_path, cx)
+                        .and_then(|(worktree, rel_path)| {
+                            if rel_path.is_empty() {
+                                Some(worktree.read(cx).id())
+                            } else {
+                                None
+                            }
+                        })
+                else {
+                    return Task::ready(None);
+                };
+
                 this.activate_toolchain(ProjectPath { worktree_id, path }, toolchain, cx)
             })?
             .await;

From 62d36b22fd1c497ae586f89f21b7a80ea6d8091a Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 19 Dec 2025 10:25:19 -0300
Subject: [PATCH 226/266] gpui: Add `text_ellipsis_start` method (#45122)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This PR is an additive change introducing the `truncate_start` method to
labels, which gives us the ability to add an ellipsis at the beginning
of the text as opposed to the regular `truncate`. This will be generally
used for truncating file paths, where the end is typically more relevant
than the beginning, but given it's a general method, there's the
possibility to be used anywhere else, too.

Screenshot 2025-12-17 at 12  35@2x

Release Notes:

- N/A

---------

Co-authored-by: Lukas Wirth 
---
 crates/editor/src/code_context_menus.rs      |   8 +-
 crates/gpui/src/elements/text.rs             |  14 +-
 crates/gpui/src/style.rs                     |   8 +-
 crates/gpui/src/styled.rs                    |  10 +-
 crates/gpui/src/text_system/line_wrapper.rs  | 228 ++++++++++++++++---
 crates/ui/src/components/label/label.rs      |   9 +-
 crates/ui/src/components/label/label_like.rs |  13 +-
 7 files changed, 248 insertions(+), 42 deletions(-)

diff --git a/crates/editor/src/code_context_menus.rs b/crates/editor/src/code_context_menus.rs
index 96739defc506414f573e2454dc31f9c32d8e4adf..e5520be88e34307220126ebafdba6c6371a5db12 100644
--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -1615,8 +1615,12 @@ impl CodeActionsMenu {
             window.text_style().font(),
             window.text_style().font_size.to_pixels(window.rem_size()),
         );
-        let is_truncated =
-            line_wrapper.should_truncate_line(&label, CODE_ACTION_MENU_MAX_WIDTH, "…");
+        let is_truncated = line_wrapper.should_truncate_line(
+            &label,
+            CODE_ACTION_MENU_MAX_WIDTH,
+            "…",
+            gpui::TruncateFrom::End,
+        );
 
         if is_truncated.is_none() {
             return None;
diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs
index 1b1bfd778c7bc746c67551eb31cf70f60b1485ea..942a0a326526431dc65f389e9cff67bac252d571 100644
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -2,8 +2,8 @@ use crate::{
     ActiveTooltip, AnyView, App, Bounds, DispatchPhase, Element, ElementId, GlobalElementId,
     HighlightStyle, Hitbox, HitboxBehavior, InspectorElementId, IntoElement, LayoutId,
     MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels, Point, SharedString, Size, TextOverflow,
-    TextRun, TextStyle, TooltipId, WhiteSpace, Window, WrappedLine, WrappedLineLayout,
-    register_tooltip_mouse_handlers, set_tooltip_on_window,
+    TextRun, TextStyle, TooltipId, TruncateFrom, WhiteSpace, Window, WrappedLine,
+    WrappedLineLayout, register_tooltip_mouse_handlers, set_tooltip_on_window,
 };
 use anyhow::Context as _;
 use itertools::Itertools;
@@ -354,7 +354,7 @@ impl TextLayout {
                     None
                 };
 
-                let (truncate_width, truncation_suffix) =
+                let (truncate_width, truncation_affix, truncate_from) =
                     if let Some(text_overflow) = text_style.text_overflow.clone() {
                         let width = known_dimensions.width.or(match available_space.width {
                             crate::AvailableSpace::Definite(x) => match text_style.line_clamp {
@@ -365,10 +365,11 @@ impl TextLayout {
                         });
 
                         match text_overflow {
-                            TextOverflow::Truncate(s) => (width, s),
+                            TextOverflow::Truncate(s) => (width, s, TruncateFrom::End),
+                            TextOverflow::TruncateStart(s) => (width, s, TruncateFrom::Start),
                         }
                     } else {
-                        (None, "".into())
+                        (None, "".into(), TruncateFrom::End)
                     };
 
                 if let Some(text_layout) = element_state.0.borrow().as_ref()
@@ -383,8 +384,9 @@ impl TextLayout {
                     line_wrapper.truncate_line(
                         text.clone(),
                         truncate_width,
-                        &truncation_suffix,
+                        &truncation_affix,
                         &runs,
+                        truncate_from,
                     )
                 } else {
                     (text.clone(), Cow::Borrowed(&*runs))
diff --git a/crates/gpui/src/style.rs b/crates/gpui/src/style.rs
index 4d6e6f490d81d967692a3e9d8316af75a7a4d306..7481b8001e5752599b90625450d7adb0c66ea2ca 100644
--- a/crates/gpui/src/style.rs
+++ b/crates/gpui/src/style.rs
@@ -334,9 +334,13 @@ pub enum WhiteSpace {
 /// How to truncate text that overflows the width of the element
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 pub enum TextOverflow {
-    /// Truncate the text when it doesn't fit, and represent this truncation by displaying the
-    /// provided string.
+    /// Truncate the text at the end when it doesn't fit, and represent this truncation by
+    /// displaying the provided string (e.g., "very long te…").
     Truncate(SharedString),
+    /// Truncate the text at the start when it doesn't fit, and represent this truncation by
+    /// displaying the provided string at the beginning (e.g., "…ong text here").
+    /// Typically more adequate for file paths where the end is more important than the beginning.
+    TruncateStart(SharedString),
 }
 
 /// How to align text within the element
diff --git a/crates/gpui/src/styled.rs b/crates/gpui/src/styled.rs
index e8088a84d7fc141d0a320988c6399afe2b93ce07..c5eef0d4496edea4d30c665c82dc0a9f00bb83be 100644
--- a/crates/gpui/src/styled.rs
+++ b/crates/gpui/src/styled.rs
@@ -75,13 +75,21 @@ pub trait Styled: Sized {
         self
     }
 
-    /// Sets the truncate overflowing text with an ellipsis (…) if needed.
+    /// Sets the truncate overflowing text with an ellipsis (…) at the end if needed.
     /// [Docs](https://tailwindcss.com/docs/text-overflow#ellipsis)
     fn text_ellipsis(mut self) -> Self {
         self.text_style().text_overflow = Some(TextOverflow::Truncate(ELLIPSIS));
         self
     }
 
+    /// Sets the truncate overflowing text with an ellipsis (…) at the start if needed.
+    /// Typically more adequate for file paths where the end is more important than the beginning.
+    /// Note: This doesn't exist in Tailwind CSS.
+    fn text_ellipsis_start(mut self) -> Self {
+        self.text_style().text_overflow = Some(TextOverflow::TruncateStart(ELLIPSIS));
+        self
+    }
+
     /// Sets the text overflow behavior of the element.
     fn text_overflow(mut self, overflow: TextOverflow) -> Self {
         self.text_style().text_overflow = Some(overflow);
diff --git a/crates/gpui/src/text_system/line_wrapper.rs b/crates/gpui/src/text_system/line_wrapper.rs
index 95cd55d04443c6b2c351bf8533ccb57d49e8dcd9..457316f353a48fa112de1736b2b7eaa2d4c72313 100644
--- a/crates/gpui/src/text_system/line_wrapper.rs
+++ b/crates/gpui/src/text_system/line_wrapper.rs
@@ -2,6 +2,15 @@ use crate::{FontId, FontRun, Pixels, PlatformTextSystem, SharedString, TextRun,
 use collections::HashMap;
 use std::{borrow::Cow, iter, sync::Arc};
 
+/// Determines whether to truncate text from the start or end.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum TruncateFrom {
+    /// Truncate text from the start.
+    Start,
+    /// Truncate text from the end.
+    End,
+}
+
 /// The GPUI line wrapper, used to wrap lines of text to a given width.
 pub struct LineWrapper {
     platform_text_system: Arc,
@@ -129,29 +138,50 @@ impl LineWrapper {
     }
 
     /// Determines if a line should be truncated based on its width.
+    ///
+    /// Returns the truncation index in `line`.
     pub fn should_truncate_line(
         &mut self,
         line: &str,
         truncate_width: Pixels,
-        truncation_suffix: &str,
+        truncation_affix: &str,
+        truncate_from: TruncateFrom,
     ) -> Option {
         let mut width = px(0.);
-        let suffix_width = truncation_suffix
+        let suffix_width = truncation_affix
             .chars()
             .map(|c| self.width_for_char(c))
             .fold(px(0.0), |a, x| a + x);
         let mut truncate_ix = 0;
 
-        for (ix, c) in line.char_indices() {
-            if width + suffix_width < truncate_width {
-                truncate_ix = ix;
+        match truncate_from {
+            TruncateFrom::Start => {
+                for (ix, c) in line.char_indices().rev() {
+                    if width + suffix_width < truncate_width {
+                        truncate_ix = ix;
+                    }
+
+                    let char_width = self.width_for_char(c);
+                    width += char_width;
+
+                    if width.floor() > truncate_width {
+                        return Some(truncate_ix);
+                    }
+                }
             }
+            TruncateFrom::End => {
+                for (ix, c) in line.char_indices() {
+                    if width + suffix_width < truncate_width {
+                        truncate_ix = ix;
+                    }
 
-            let char_width = self.width_for_char(c);
-            width += char_width;
+                    let char_width = self.width_for_char(c);
+                    width += char_width;
 
-            if width.floor() > truncate_width {
-                return Some(truncate_ix);
+                    if width.floor() > truncate_width {
+                        return Some(truncate_ix);
+                    }
+                }
             }
         }
 
@@ -163,16 +193,23 @@ impl LineWrapper {
         &mut self,
         line: SharedString,
         truncate_width: Pixels,
-        truncation_suffix: &str,
+        truncation_affix: &str,
         runs: &'a [TextRun],
+        truncate_from: TruncateFrom,
     ) -> (SharedString, Cow<'a, [TextRun]>) {
         if let Some(truncate_ix) =
-            self.should_truncate_line(&line, truncate_width, truncation_suffix)
+            self.should_truncate_line(&line, truncate_width, truncation_affix, truncate_from)
         {
-            let result =
-                SharedString::from(format!("{}{}", &line[..truncate_ix], truncation_suffix));
+            let result = match truncate_from {
+                TruncateFrom::Start => {
+                    SharedString::from(format!("{truncation_affix}{}", &line[truncate_ix + 1..]))
+                }
+                TruncateFrom::End => {
+                    SharedString::from(format!("{}{truncation_affix}", &line[..truncate_ix]))
+                }
+            };
             let mut runs = runs.to_vec();
-            update_runs_after_truncation(&result, truncation_suffix, &mut runs);
+            update_runs_after_truncation(&result, truncation_affix, &mut runs, truncate_from);
             (result, Cow::Owned(runs))
         } else {
             (line, Cow::Borrowed(runs))
@@ -245,15 +282,35 @@ impl LineWrapper {
     }
 }
 
-fn update_runs_after_truncation(result: &str, ellipsis: &str, runs: &mut Vec) {
+fn update_runs_after_truncation(
+    result: &str,
+    ellipsis: &str,
+    runs: &mut Vec,
+    truncate_from: TruncateFrom,
+) {
     let mut truncate_at = result.len() - ellipsis.len();
-    for (run_index, run) in runs.iter_mut().enumerate() {
-        if run.len <= truncate_at {
-            truncate_at -= run.len;
-        } else {
-            run.len = truncate_at + ellipsis.len();
-            runs.truncate(run_index + 1);
-            break;
+    match truncate_from {
+        TruncateFrom::Start => {
+            for (run_index, run) in runs.iter_mut().enumerate().rev() {
+                if run.len <= truncate_at {
+                    truncate_at -= run.len;
+                } else {
+                    run.len = truncate_at + ellipsis.len();
+                    runs.splice(..run_index, std::iter::empty());
+                    break;
+                }
+            }
+        }
+        TruncateFrom::End => {
+            for (run_index, run) in runs.iter_mut().enumerate() {
+                if run.len <= truncate_at {
+                    truncate_at -= run.len;
+                } else {
+                    run.len = truncate_at + ellipsis.len();
+                    runs.truncate(run_index + 1);
+                    break;
+                }
+            }
         }
     }
 }
@@ -503,7 +560,7 @@ mod tests {
     }
 
     #[test]
-    fn test_truncate_line() {
+    fn test_truncate_line_end() {
         let mut wrapper = build_wrapper();
 
         fn perform_test(
@@ -514,8 +571,13 @@ mod tests {
         ) {
             let dummy_run_lens = vec![text.len()];
             let dummy_runs = generate_test_runs(&dummy_run_lens);
-            let (result, dummy_runs) =
-                wrapper.truncate_line(text.into(), px(220.), ellipsis, &dummy_runs);
+            let (result, dummy_runs) = wrapper.truncate_line(
+                text.into(),
+                px(220.),
+                ellipsis,
+                &dummy_runs,
+                TruncateFrom::End,
+            );
             assert_eq!(result, expected);
             assert_eq!(dummy_runs.first().unwrap().len, result.len());
         }
@@ -541,7 +603,50 @@ mod tests {
     }
 
     #[test]
-    fn test_truncate_multiple_runs() {
+    fn test_truncate_line_start() {
+        let mut wrapper = build_wrapper();
+
+        fn perform_test(
+            wrapper: &mut LineWrapper,
+            text: &'static str,
+            expected: &'static str,
+            ellipsis: &str,
+        ) {
+            let dummy_run_lens = vec![text.len()];
+            let dummy_runs = generate_test_runs(&dummy_run_lens);
+            let (result, dummy_runs) = wrapper.truncate_line(
+                text.into(),
+                px(220.),
+                ellipsis,
+                &dummy_runs,
+                TruncateFrom::Start,
+            );
+            assert_eq!(result, expected);
+            assert_eq!(dummy_runs.first().unwrap().len, result.len());
+        }
+
+        perform_test(
+            &mut wrapper,
+            "aaaa bbbb cccc ddddd eeee fff gg",
+            "cccc ddddd eeee fff gg",
+            "",
+        );
+        perform_test(
+            &mut wrapper,
+            "aaaa bbbb cccc ddddd eeee fff gg",
+            "…ccc ddddd eeee fff gg",
+            "…",
+        );
+        perform_test(
+            &mut wrapper,
+            "aaaa bbbb cccc ddddd eeee fff gg",
+            "......dddd eeee fff gg",
+            "......",
+        );
+    }
+
+    #[test]
+    fn test_truncate_multiple_runs_end() {
         let mut wrapper = build_wrapper();
 
         fn perform_test(
@@ -554,7 +659,7 @@ mod tests {
         ) {
             let dummy_runs = generate_test_runs(run_lens);
             let (result, dummy_runs) =
-                wrapper.truncate_line(text.into(), line_width, "…", &dummy_runs);
+                wrapper.truncate_line(text.into(), line_width, "…", &dummy_runs, TruncateFrom::End);
             assert_eq!(result, expected);
             for (run, result_len) in dummy_runs.iter().zip(result_run_len) {
                 assert_eq!(run.len, *result_len);
@@ -600,10 +705,75 @@ mod tests {
     }
 
     #[test]
-    fn test_update_run_after_truncation() {
+    fn test_truncate_multiple_runs_start() {
+        let mut wrapper = build_wrapper();
+
+        #[track_caller]
+        fn perform_test(
+            wrapper: &mut LineWrapper,
+            text: &'static str,
+            expected: &str,
+            run_lens: &[usize],
+            result_run_len: &[usize],
+            line_width: Pixels,
+        ) {
+            let dummy_runs = generate_test_runs(run_lens);
+            let (result, dummy_runs) = wrapper.truncate_line(
+                text.into(),
+                line_width,
+                "…",
+                &dummy_runs,
+                TruncateFrom::Start,
+            );
+            assert_eq!(result, expected);
+            for (run, result_len) in dummy_runs.iter().zip(result_run_len) {
+                assert_eq!(run.len, *result_len);
+            }
+        }
+        // Case 0: Normal
+        // Text: abcdefghijkl
+        // Runs: Run0 { len: 12, ... }
+        //
+        // Truncate res: …ijkl (truncate_at = 9)
+        // Run res: Run0 { string: …ijkl, len: 7, ... }
+        perform_test(&mut wrapper, "abcdefghijkl", "…ijkl", &[12], &[7], px(50.));
+        // Case 1: Drop some runs
+        // Text: abcdefghijkl
+        // Runs: Run0 { len: 4, ... }, Run1 { len: 4, ... }, Run2 { len: 4, ... }
+        //
+        // Truncate res: …ghijkl (truncate_at = 7)
+        // Runs res: Run0 { string: …gh, len: 5, ... }, Run1 { string: ijkl, len:
+        // 4, ... }
+        perform_test(
+            &mut wrapper,
+            "abcdefghijkl",
+            "…ghijkl",
+            &[4, 4, 4],
+            &[5, 4],
+            px(70.),
+        );
+        // Case 2: Truncate at start of some run
+        // Text: abcdefghijkl
+        // Runs: Run0 { len: 4, ... }, Run1 { len: 4, ... }, Run2 { len: 4, ... }
+        //
+        // Truncate res: abcdefgh… (truncate_at = 3)
+        // Runs res: Run0 { string: …, len: 3, ... }, Run1 { string: efgh, len:
+        // 4, ... }, Run2 { string: ijkl, len: 4, ... }
+        perform_test(
+            &mut wrapper,
+            "abcdefghijkl",
+            "…efghijkl",
+            &[4, 4, 4],
+            &[3, 4, 4],
+            px(90.),
+        );
+    }
+
+    #[test]
+    fn test_update_run_after_truncation_end() {
         fn perform_test(result: &str, run_lens: &[usize], result_run_lens: &[usize]) {
             let mut dummy_runs = generate_test_runs(run_lens);
-            update_runs_after_truncation(result, "…", &mut dummy_runs);
+            update_runs_after_truncation(result, "…", &mut dummy_runs, TruncateFrom::End);
             for (run, result_len) in dummy_runs.iter().zip(result_run_lens) {
                 assert_eq!(run.len, *result_len);
             }
diff --git a/crates/ui/src/components/label/label.rs b/crates/ui/src/components/label/label.rs
index 49e2de94a1f86196c10e41879797b02070517e65..d0f50c00336eb971621e2da7bbaf53cf09569caa 100644
--- a/crates/ui/src/components/label/label.rs
+++ b/crates/ui/src/components/label/label.rs
@@ -56,6 +56,12 @@ impl Label {
     pub fn set_text(&mut self, text: impl Into) {
         self.label = text.into();
     }
+
+    /// Truncates the label from the start, keeping the end visible.
+    pub fn truncate_start(mut self) -> Self {
+        self.base = self.base.truncate_start();
+        self
+    }
 }
 
 // Style methods.
@@ -256,7 +262,8 @@ impl Component for Label {
                         "Special Cases",
                         vec![
                             single_example("Single Line", Label::new("Line 1\nLine 2\nLine 3").single_line().into_any_element()),
-                            single_example("Text Ellipsis", div().max_w_24().child(Label::new("This is a very long file name that should be truncated: very_long_file_name_with_many_words.rs").truncate()).into_any_element()),
+                            single_example("Regular Truncation", div().max_w_24().child(Label::new("This is a very long file name that should be truncated: very_long_file_name_with_many_words.rs").truncate()).into_any_element()),
+                            single_example("Start Truncation", div().max_w_24().child(Label::new("zed/crates/ui/src/components/label/truncate/label/label.rs").truncate_start()).into_any_element()),
                         ],
                     ),
                 ])
diff --git a/crates/ui/src/components/label/label_like.rs b/crates/ui/src/components/label/label_like.rs
index 31fb7bfd88f1343ac6145c86f228bdcbd6a22e10..10d54845dabf371b8da6fed5ebbcd2b8d82ea711 100644
--- a/crates/ui/src/components/label/label_like.rs
+++ b/crates/ui/src/components/label/label_like.rs
@@ -88,6 +88,7 @@ pub struct LabelLike {
     underline: bool,
     single_line: bool,
     truncate: bool,
+    truncate_start: bool,
 }
 
 impl Default for LabelLike {
@@ -113,6 +114,7 @@ impl LabelLike {
             underline: false,
             single_line: false,
             truncate: false,
+            truncate_start: false,
         }
     }
 }
@@ -126,6 +128,12 @@ impl LabelLike {
     gpui::margin_style_methods!({
         visibility: pub
     });
+
+    /// Truncates overflowing text with an ellipsis (`…`) at the start if needed.
+    pub fn truncate_start(mut self) -> Self {
+        self.truncate_start = true;
+        self
+    }
 }
 
 impl LabelCommon for LabelLike {
@@ -169,7 +177,7 @@ impl LabelCommon for LabelLike {
         self
     }
 
-    /// Truncates overflowing text with an ellipsis (`…`) if needed.
+    /// Truncates overflowing text with an ellipsis (`…`) at the end if needed.
     fn truncate(mut self) -> Self {
         self.truncate = true;
         self
@@ -235,6 +243,9 @@ impl RenderOnce for LabelLike {
             .when(self.truncate, |this| {
                 this.overflow_x_hidden().text_ellipsis()
             })
+            .when(self.truncate_start, |this| {
+                this.overflow_x_hidden().text_ellipsis_start()
+            })
             .text_color(color)
             .font_weight(
                 self.weight

From 4e0471cf663b88f38246440f5ae06ca4828225d8 Mon Sep 17 00:00:00 2001
From: ozzy <109994179+ddoemonn@users.noreply.github.com>
Date: Fri, 19 Dec 2025 16:50:35 +0300
Subject: [PATCH 227/266] git panel: Truncate file paths from the left (#43462)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

https://github.com/user-attachments/assets/758e1ec9-6c34-4e13-b605-cf00c18ca16f

Release Notes:

- Improved: Git panel now truncates long file paths from the left,
showing "…path/filename" when space is limited, keeping filenames always
visible.

@cole-miller @mattermill

---------

Co-authored-by: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Co-authored-by: Danilo Leal 
---
 crates/git_ui/src/git_panel.rs               | 2 +-
 crates/ui/src/components/label/label_like.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/git_ui/src/git_panel.rs b/crates/git_ui/src/git_panel.rs
index 532f9a099a823796706be48ed14cc7da820c5d8b..1323ee014f76ebde42b8dff436b2abed851d13f0 100644
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -5203,7 +5203,7 @@ impl GitPanel {
 
                 this.child(
                     self.entry_label(path_name, path_color)
-                        .truncate()
+                        .truncate_start()
                         .when(strikethrough, Label::strikethrough),
                 )
             })
diff --git a/crates/ui/src/components/label/label_like.rs b/crates/ui/src/components/label/label_like.rs
index 10d54845dabf371b8da6fed5ebbcd2b8d82ea711..f6e7a1b893d54fff425618d5c604f591144a7385 100644
--- a/crates/ui/src/components/label/label_like.rs
+++ b/crates/ui/src/components/label/label_like.rs
@@ -56,7 +56,7 @@ pub trait LabelCommon {
     /// Sets the alpha property of the label, overwriting the alpha value of the color.
     fn alpha(self, alpha: f32) -> Self;
 
-    /// Truncates overflowing text with an ellipsis (`…`) if needed.
+    /// Truncates overflowing text with an ellipsis (`…`) at the end if needed.
     fn truncate(self) -> Self;
 
     /// Sets the label to render as a single line.

From ae44c3c8811472dfb105932eaf4e24a2f2853a4e Mon Sep 17 00:00:00 2001
From: Cole Miller 
Date: Fri, 19 Dec 2025 09:39:58 -0500
Subject: [PATCH 228/266] Fix extra terminal being created when a task replaces
 a terminal in the center pane (#45317)

Closes https://github.com/zed-industries/zed/issues/21144

Release Notes:

- Fixed spawned tasks creating an extra terminal in the dock in some
cases.
---
 crates/terminal_view/src/terminal_panel.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/terminal_view/src/terminal_panel.rs b/crates/terminal_view/src/terminal_panel.rs
index ed43d94e9d3d7c08c1ff4570e08726310360cd93..738a0b4502642423377bdf69b49d26250536761f 100644
--- a/crates/terminal_view/src/terminal_panel.rs
+++ b/crates/terminal_view/src/terminal_panel.rs
@@ -939,7 +939,6 @@ impl TerminalPanel {
         cx: &mut Context,
     ) -> Task>> {
         let reveal = spawn_task.reveal;
-        let reveal_target = spawn_task.reveal_target;
         let task_workspace = self.workspace.clone();
         cx.spawn_in(window, async move |terminal_panel, cx| {
             let project = terminal_panel.update(cx, |this, cx| {
@@ -955,6 +954,14 @@ impl TerminalPanel {
                 terminal_to_replace.set_terminal(new_terminal.clone(), window, cx);
             })?;
 
+            let reveal_target = terminal_panel.update(cx, |panel, _| {
+                if panel.center.panes().iter().any(|p| **p == task_pane) {
+                    RevealTarget::Dock
+                } else {
+                    RevealTarget::Center
+                }
+            })?;
+
             match reveal {
                 RevealStrategy::Always => match reveal_target {
                     RevealTarget::Center => {

From 7427924405dabda02cca87c24143f2d5f27eb433 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Yara=20=F0=9F=8F=B3=EF=B8=8F=E2=80=8D=E2=9A=A7=EF=B8=8F?=
 
Date: Fri, 19 Dec 2025 16:03:35 +0100
Subject: [PATCH 229/266] adjusted scheduler prioritization algorithm (#45367)

This fixes a number of issues where zed depends on the order of polling which changed when switching scheduler. We have adjusted the algorithm so it matches the previous order while keeping the prioritization feature.

Release Notes:
- N/A
---
 crates/gpui/src/queue.rs | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/crates/gpui/src/queue.rs b/crates/gpui/src/queue.rs
index 9e9da710977ee80df1853791918eebe5e7f01096..1ecec183c6c58a86e305343f7bcd1056cda7a581 100644
--- a/crates/gpui/src/queue.rs
+++ b/crates/gpui/src/queue.rs
@@ -1,4 +1,5 @@
 use std::{
+    collections::VecDeque,
     fmt,
     iter::FusedIterator,
     sync::{Arc, atomic::AtomicUsize},
@@ -9,9 +10,9 @@ use rand::{Rng, SeedableRng, rngs::SmallRng};
 use crate::Priority;
 
 struct PriorityQueues {
-    high_priority: Vec,
-    medium_priority: Vec,
-    low_priority: Vec,
+    high_priority: VecDeque,
+    medium_priority: VecDeque,
+    low_priority: VecDeque,
 }
 
 impl PriorityQueues {
@@ -42,9 +43,9 @@ impl PriorityQueueState {
         let mut queues = self.queues.lock();
         match priority {
             Priority::Realtime(_) => unreachable!(),
-            Priority::High => queues.high_priority.push(item),
-            Priority::Medium => queues.medium_priority.push(item),
-            Priority::Low => queues.low_priority.push(item),
+            Priority::High => queues.high_priority.push_back(item),
+            Priority::Medium => queues.medium_priority.push_back(item),
+            Priority::Low => queues.low_priority.push_back(item),
         };
         self.condvar.notify_one();
         Ok(())
@@ -141,9 +142,9 @@ impl PriorityQueueReceiver {
     pub(crate) fn new() -> (PriorityQueueSender, Self) {
         let state = PriorityQueueState {
             queues: parking_lot::Mutex::new(PriorityQueues {
-                high_priority: Vec::new(),
-                medium_priority: Vec::new(),
-                low_priority: Vec::new(),
+                high_priority: VecDeque::new(),
+                medium_priority: VecDeque::new(),
+                low_priority: VecDeque::new(),
             }),
             condvar: parking_lot::Condvar::new(),
             receiver_count: AtomicUsize::new(1),
@@ -226,7 +227,7 @@ impl PriorityQueueReceiver {
         if !queues.high_priority.is_empty() {
             let flip = self.rand.random_ratio(P::High.probability(), mass);
             if flip {
-                return Ok(queues.high_priority.pop());
+                return Ok(queues.high_priority.pop_front());
             }
             mass -= P::High.probability();
         }
@@ -234,7 +235,7 @@ impl PriorityQueueReceiver {
         if !queues.medium_priority.is_empty() {
             let flip = self.rand.random_ratio(P::Medium.probability(), mass);
             if flip {
-                return Ok(queues.medium_priority.pop());
+                return Ok(queues.medium_priority.pop_front());
             }
             mass -= P::Medium.probability();
         }
@@ -242,7 +243,7 @@ impl PriorityQueueReceiver {
         if !queues.low_priority.is_empty() {
             let flip = self.rand.random_ratio(P::Low.probability(), mass);
             if flip {
-                return Ok(queues.low_priority.pop());
+                return Ok(queues.low_priority.pop_front());
             }
         }
 

From b603372f44a60f8ed98ae95b36094582ead47b89 Mon Sep 17 00:00:00 2001
From: Antonio Scandurra 
Date: Fri, 19 Dec 2025 16:06:28 +0100
Subject: [PATCH 230/266] Reduce GPU usage by activating VRR optimization only
 during high-rate input (#45369)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes #29073

This PR reduces unnecessary GPU usage by being more selective about when
we present frames to prevent display underclocking (VRR optimization).

## Problem

Previously, we would keep presenting frames for 1 second after *any*
input event, regardless of whether it triggered a re-render. This caused
unnecessary GPU work when the user was idle or during low-frequency
interactions.

## Solution

1. **Only track input that triggers re-renders**: We now only record
input timestamps when the input actually causes the window to become
dirty, rather than on every input event.

2. **Rate-based activation**: The VRR optimization now only activates
when input arrives at a high rate (≥ 60fps over the last 100ms). This
means casual mouse movements or occasional keystrokes won't trigger
continuous frame presentation.

3. **Sustained optimization**: Once high-rate input is detected (e.g.,
during scrolling or dragging), we sustain frame presentation for 1
second to prevent display underclocking, even if input briefly pauses.

## Implementation

Added `InputRateTracker` which:
- Tracks input timestamps in a 100ms sliding window
- Activates when the window contains ≥ 6 events (60fps × 0.1s)
- Extends a `sustain_until` timestamp by 1 second each time high rate is
detected

Release Notes:

- Reduced GPU usage when idle by only presenting frames during bursts of
high-frequency input.
---
 crates/gpui/src/window.rs | 70 +++++++++++++++++++++++++++++++++------
 1 file changed, 59 insertions(+), 11 deletions(-)

diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs
index 2ccd7edac86bced89048cbe5dbf196d8fbcf95f3..8df421feb968677be0abbb642a7127871881bcf3 100644
--- a/crates/gpui/src/window.rs
+++ b/crates/gpui/src/window.rs
@@ -876,7 +876,9 @@ pub struct Window {
     active: Rc>,
     hovered: Rc>,
     pub(crate) needs_present: Rc>,
-    pub(crate) last_input_timestamp: Rc>,
+    /// Tracks recent input event timestamps to determine if input is arriving at a high rate.
+    /// Used to selectively enable VRR optimization only when input rate exceeds 60fps.
+    pub(crate) input_rate_tracker: Rc>,
     last_input_modality: InputModality,
     pub(crate) refreshing: bool,
     pub(crate) activation_observers: SubscriberSet<(), AnyObserver>,
@@ -897,6 +899,51 @@ struct ModifierState {
     saw_keystroke: bool,
 }
 
+/// Tracks input event timestamps to determine if input is arriving at a high rate.
+/// Used for selective VRR (Variable Refresh Rate) optimization.
+#[derive(Clone, Debug)]
+pub(crate) struct InputRateTracker {
+    timestamps: Vec,
+    window: Duration,
+    inputs_per_second: u32,
+    sustain_until: Instant,
+    sustain_duration: Duration,
+}
+
+impl Default for InputRateTracker {
+    fn default() -> Self {
+        Self {
+            timestamps: Vec::new(),
+            window: Duration::from_millis(100),
+            inputs_per_second: 60,
+            sustain_until: Instant::now(),
+            sustain_duration: Duration::from_secs(1),
+        }
+    }
+}
+
+impl InputRateTracker {
+    pub fn record_input(&mut self) {
+        let now = Instant::now();
+        self.timestamps.push(now);
+        self.prune_old_timestamps(now);
+
+        let min_events = self.inputs_per_second as u128 * self.window.as_millis() / 1000;
+        if self.timestamps.len() as u128 >= min_events {
+            self.sustain_until = now + self.sustain_duration;
+        }
+    }
+
+    pub fn is_high_rate(&self) -> bool {
+        Instant::now() < self.sustain_until
+    }
+
+    fn prune_old_timestamps(&mut self, now: Instant) {
+        self.timestamps
+            .retain(|&t| now.duration_since(t) <= self.window);
+    }
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum DrawPhase {
     None,
@@ -1047,7 +1094,7 @@ impl Window {
         let hovered = Rc::new(Cell::new(platform_window.is_hovered()));
         let needs_present = Rc::new(Cell::new(false));
         let next_frame_callbacks: Rc>> = Default::default();
-        let last_input_timestamp = Rc::new(Cell::new(Instant::now()));
+        let input_rate_tracker = Rc::new(RefCell::new(InputRateTracker::default()));
 
         platform_window
             .request_decorations(window_decorations.unwrap_or(WindowDecorations::Server));
@@ -1075,7 +1122,7 @@ impl Window {
             let active = active.clone();
             let needs_present = needs_present.clone();
             let next_frame_callbacks = next_frame_callbacks.clone();
-            let last_input_timestamp = last_input_timestamp.clone();
+            let input_rate_tracker = input_rate_tracker.clone();
             move |request_frame_options| {
                 let next_frame_callbacks = next_frame_callbacks.take();
                 if !next_frame_callbacks.is_empty() {
@@ -1088,12 +1135,12 @@ impl Window {
                         .log_err();
                 }
 
-                // Keep presenting the current scene for 1 extra second since the
-                // last input to prevent the display from underclocking the refresh rate.
+                // Keep presenting if input was recently arriving at a high rate (>= 60fps).
+                // Once high-rate input is detected, we sustain presentation for 1 second
+                // to prevent display underclocking during active input.
                 let needs_present = request_frame_options.require_presentation
                     || needs_present.get()
-                    || (active.get()
-                        && last_input_timestamp.get().elapsed() < Duration::from_secs(1));
+                    || (active.get() && input_rate_tracker.borrow_mut().is_high_rate());
 
                 if invalidator.is_dirty() || request_frame_options.force_render {
                     measure("frame duration", || {
@@ -1101,7 +1148,6 @@ impl Window {
                             .update(&mut cx, |_, window, cx| {
                                 let arena_clear_needed = window.draw(cx);
                                 window.present();
-                                // drop the arena elements after present to reduce latency
                                 arena_clear_needed.clear();
                             })
                             .log_err();
@@ -1299,7 +1345,7 @@ impl Window {
             active,
             hovered,
             needs_present,
-            last_input_timestamp,
+            input_rate_tracker,
             last_input_modality: InputModality::Mouse,
             refreshing: false,
             activation_observers: SubscriberSet::new(),
@@ -3691,8 +3737,6 @@ impl Window {
     /// Dispatch a mouse or keyboard event on the window.
     #[profiling::function]
     pub fn dispatch_event(&mut self, event: PlatformInput, cx: &mut App) -> DispatchEventResult {
-        self.last_input_timestamp.set(Instant::now());
-
         // Track whether this input was keyboard-based for focus-visible styling
         self.last_input_modality = match &event {
             PlatformInput::KeyDown(_) | PlatformInput::ModifiersChanged(_) => {
@@ -3793,6 +3837,10 @@ impl Window {
             self.dispatch_key_event(any_key_event, cx);
         }
 
+        if self.invalidator.is_dirty() {
+            self.input_rate_tracker.borrow_mut().record_input();
+        }
+
         DispatchEventResult {
             propagate: cx.propagate_event,
             default_prevented: self.default_prevented,

From 8001877df2104f86ee236f9c813e2405346e716f Mon Sep 17 00:00:00 2001
From: AidanV <84053180+AidanV@users.noreply.github.com>
Date: Fri, 19 Dec 2025 10:31:16 -0500
Subject: [PATCH 231/266] vim: Add `:r[ead] [name]` command (#45332)

This adds the following Vim commands:
- `:r[ead] [name]`
- `:{range}r[ead] [name]`

The most important parts of this feature are outlined
[here](https://vimhelp.org/insert.txt.html#%3Ar).

The only intentional difference between this and Vim is that Vim only
allows `:read` (no filename) for buffers with a file attached. I am
allowing it for all buffers because I think that could be useful.

Release Notes:

- vim: Added the [`:r[ead] [name]` Vim
command](https://vimhelp.org/insert.txt.html#:read)

---------

Co-authored-by: Ben Kunkle 
---
 crates/vim/src/command.rs | 200 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 200 insertions(+)

diff --git a/crates/vim/src/command.rs b/crates/vim/src/command.rs
index 205097130d152fe255feb02a449956124586d8e6..2228c23f02beb954bdb26b2b36f078249e423d7d 100644
--- a/crates/vim/src/command.rs
+++ b/crates/vim/src/command.rs
@@ -230,6 +230,14 @@ struct VimEdit {
     pub filename: String,
 }
 
+/// Pastes the specified file's contents.
+#[derive(Clone, PartialEq, Action)]
+#[action(namespace = vim, no_json, no_register)]
+struct VimRead {
+    pub range: Option,
+    pub filename: String,
+}
+
 #[derive(Clone, PartialEq, Action)]
 #[action(namespace = vim, no_json, no_register)]
 struct VimNorm {
@@ -643,6 +651,107 @@ pub fn register(editor: &mut Editor, cx: &mut Context) {
         });
     });
 
+    Vim::action(editor, cx, |vim, action: &VimRead, window, cx| {
+        vim.update_editor(cx, |vim, editor, cx| {
+            let snapshot = editor.buffer().read(cx).snapshot(cx);
+            let end = if let Some(range) = action.range.clone() {
+                let Some(multi_range) = range.buffer_range(vim, editor, window, cx).log_err()
+                else {
+                    return;
+                };
+
+                match &range.start {
+                    // inserting text above the first line uses the command ":0r {name}"
+                    Position::Line { row: 0, offset: 0 } if range.end.is_none() => {
+                        snapshot.clip_point(Point::new(0, 0), Bias::Right)
+                    }
+                    _ => snapshot.clip_point(Point::new(multi_range.end.0 + 1, 0), Bias::Right),
+                }
+            } else {
+                let end_row = editor
+                    .selections
+                    .newest::(&editor.display_snapshot(cx))
+                    .range()
+                    .end
+                    .row;
+                snapshot.clip_point(Point::new(end_row + 1, 0), Bias::Right)
+            };
+            let is_end_of_file = end == snapshot.max_point();
+            let edit_range = snapshot.anchor_before(end)..snapshot.anchor_before(end);
+
+            let mut text = if is_end_of_file {
+                String::from('\n')
+            } else {
+                String::new()
+            };
+
+            let mut task = None;
+            if action.filename.is_empty() {
+                text.push_str(
+                    &editor
+                        .buffer()
+                        .read(cx)
+                        .as_singleton()
+                        .map(|buffer| buffer.read(cx).text())
+                        .unwrap_or_default(),
+                );
+            } else {
+                if let Some(project) = editor.project().cloned() {
+                    project.update(cx, |project, cx| {
+                        let Some(worktree) = project.visible_worktrees(cx).next() else {
+                            return;
+                        };
+                        let path_style = worktree.read(cx).path_style();
+                        let Some(path) =
+                            RelPath::new(Path::new(&action.filename), path_style).log_err()
+                        else {
+                            return;
+                        };
+                        task =
+                            Some(worktree.update(cx, |worktree, cx| worktree.load_file(&path, cx)));
+                    });
+                } else {
+                    return;
+                }
+            };
+
+            cx.spawn_in(window, async move |editor, cx| {
+                if let Some(task) = task {
+                    text.push_str(
+                        &task
+                            .await
+                            .log_err()
+                            .map(|loaded_file| loaded_file.text)
+                            .unwrap_or_default(),
+                    );
+                }
+
+                if !text.is_empty() && !is_end_of_file {
+                    text.push('\n');
+                }
+
+                let _ = editor.update_in(cx, |editor, window, cx| {
+                    editor.transact(window, cx, |editor, window, cx| {
+                        editor.edit([(edit_range.clone(), text)], cx);
+                        let snapshot = editor.buffer().read(cx).snapshot(cx);
+                        editor.change_selections(Default::default(), window, cx, |s| {
+                            let point = if is_end_of_file {
+                                Point::new(
+                                    edit_range.start.to_point(&snapshot).row.saturating_add(1),
+                                    0,
+                                )
+                            } else {
+                                Point::new(edit_range.start.to_point(&snapshot).row, 0)
+                            };
+                            s.select_ranges([point..point]);
+                        })
+                    });
+                });
+            })
+            .detach();
+        });
+    });
+
     Vim::action(editor, cx, |vim, action: &VimNorm, window, cx| {
         let keystrokes = action
             .command
@@ -1338,6 +1447,27 @@ fn generate_commands(_: &App) -> Vec {
         VimCommand::new(("e", "dit"), editor::actions::ReloadFile)
             .bang(editor::actions::ReloadFile)
             .filename(|_, filename| Some(VimEdit { filename }.boxed_clone())),
+        VimCommand::new(
+            ("r", "ead"),
+            VimRead {
+                range: None,
+                filename: "".into(),
+            },
+        )
+        .filename(|_, filename| {
+            Some(
+                VimRead {
+                    range: None,
+                    filename,
+                }
+                .boxed_clone(),
+            )
+        })
+        .range(|action, range| {
+            let mut action: VimRead = action.as_any().downcast_ref::().unwrap().clone();
+            action.range.replace(range.clone());
+            Some(Box::new(action))
+        }),
         VimCommand::new(("sp", "lit"), workspace::SplitHorizontal).filename(|_, filename| {
             Some(
                 VimSplit {
@@ -2575,6 +2705,76 @@ mod test {
         assert_eq!(fs.load(path).await.unwrap().replace("\r\n", "\n"), "@@\n");
     }
 
+    #[gpui::test]
+    async fn test_command_read(cx: &mut TestAppContext) {
+        let mut cx = VimTestContext::new(cx, true).await;
+
+        let fs = cx.workspace(|workspace, _, cx| workspace.project().read(cx).fs().clone());
+        let path = Path::new(path!("/root/dir/other.rs"));
+        fs.as_fake().insert_file(path, "1\n2\n3".into()).await;
+
+        cx.workspace(|workspace, _, cx| {
+            assert_active_item(workspace, path!("/root/dir/file.rs"), "", cx);
+        });
+
+        // File without trailing newline
+        cx.set_state("one\ntwo\nthreeˇ", Mode::Normal);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\ntwo\nthree\nˇ1\n2\n3", Mode::Normal);
+
+        cx.set_state("oneˇ\ntwo\nthree", Mode::Normal);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\nˇ1\n2\n3\ntwo\nthree", Mode::Normal);
+
+        cx.set_state("one\nˇtwo\nthree", Mode::Normal);
+        cx.simulate_keystrokes(": 0 r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("ˇ1\n2\n3\none\ntwo\nthree", Mode::Normal);
+
+        cx.set_state("one\n«ˇtwo\nthree\nfour»\nfive", Mode::Visual);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.run_until_parked();
+        cx.assert_state("one\ntwo\nthree\nfour\nˇ1\n2\n3\nfive", Mode::Normal);
+
+        // Empty filename
+        cx.set_state("oneˇ\ntwo\nthree", Mode::Normal);
+        cx.simulate_keystrokes(": r");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\nˇone\ntwo\nthree\ntwo\nthree", Mode::Normal);
+
+        // File with trailing newline
+        fs.as_fake().insert_file(path, "1\n2\n3\n".into()).await;
+        cx.set_state("one\ntwo\nthreeˇ", Mode::Normal);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\ntwo\nthree\nˇ1\n2\n3\n", Mode::Normal);
+
+        cx.set_state("oneˇ\ntwo\nthree", Mode::Normal);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\nˇ1\n2\n3\n\ntwo\nthree", Mode::Normal);
+
+        cx.set_state("one\n«ˇtwo\nthree\nfour»\nfive", Mode::Visual);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\ntwo\nthree\nfour\nˇ1\n2\n3\n\nfive", Mode::Normal);
+
+        cx.set_state("«one\ntwo\nthreeˇ»", Mode::Visual);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\ntwo\nthree\nˇ1\n2\n3\n", Mode::Normal);
+
+        // Empty file
+        fs.as_fake().insert_file(path, "".into()).await;
+        cx.set_state("ˇone\ntwo\nthree", Mode::Normal);
+        cx.simulate_keystrokes(": r space d i r / o t h e r . r s");
+        cx.simulate_keystrokes("enter");
+        cx.assert_state("one\nˇtwo\nthree", Mode::Normal);
+    }
+
     #[gpui::test]
     async fn test_command_quit(cx: &mut TestAppContext) {
         let mut cx = VimTestContext::new(cx, true).await;

From a7d43063d45d616573b26733778fb7af0fbbbf4b Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 19 Dec 2025 13:01:48 -0300
Subject: [PATCH 232/266] workspace: Make title bar pickers render nearby the
 trigger when mouse-triggered (#45361)

From Zed's title bar, you can click on buttons to open three modal
pickers: remote projects, projects, and branches. All of these pickers
use the modal layer, which by default, renders them centered on the UI.
However, a UX issue we've been bothered by is that when you _click_ to
open them, they show up just way too far from where your mouse likely is
(nearby the trigger you just clicked). So, this PR introduces a
`ModalPlacement` enum to the modal layer, so that we can pick between
the "centered" and "anchored" options to render the picker. This way, we
can make the pickers use anchored positioning when triggered through a
mouse click and use the default centered positioning when triggered
through the keybinding.

One thing to note is that the anchored positioning here is not as
polished as regular popovers/dropdowns, because it simply uses the x and
y coordinates of the click to place the picker as opposed to using
GPUI's `Corner` enum, thus making them more connected to their triggers.
I chose to do it this way for now because it's a simpler and more
contained change, given it wouldn't require a tighter connection at the
code level between trigger and picker. But maybe we will want to do that
in the near future because we can bake in some other related behaviors
like automatically hiding the button trigger tooltip if the picker is
open and changing its text color to communicate which button triggered
the open picker.


https://github.com/user-attachments/assets/30d9c26a-24de-4702-8b7d-018b397f77e1

Release Notes:

- Improved the UX of title bar modal pickers (remote projects, projects,
and branches) by making them open closer to the trigger when triggering
them with the mouse.
---
 crates/title_bar/src/title_bar.rs   | 272 +++++++++++++++++-----------
 crates/workspace/src/modal_layer.rs |  77 ++++++--
 crates/workspace/src/workspace.rs   |  17 +-
 3 files changed, 240 insertions(+), 126 deletions(-)

diff --git a/crates/title_bar/src/title_bar.rs b/crates/title_bar/src/title_bar.rs
index d7759b0df8019eed2ad59b73bcaffaa3ffcfb866..9b75d35eccafa3c30f23329d9c0ee890ed2b2405 100644
--- a/crates/title_bar/src/title_bar.rs
+++ b/crates/title_bar/src/title_bar.rs
@@ -166,11 +166,11 @@ impl Render for TitleBar {
                                 .when(title_bar_settings.show_project_items, |title_bar| {
                                     title_bar
                                         .children(self.render_restricted_mode(cx))
-                                        .children(self.render_project_host(cx))
-                                        .child(self.render_project_name(cx))
+                                        .children(self.render_project_host(window, cx))
+                                        .child(self.render_project_name(window, cx))
                                 })
                                 .when(title_bar_settings.show_branch_name, |title_bar| {
-                                    title_bar.children(self.render_project_repo(cx))
+                                    title_bar.children(self.render_project_repo(window, cx))
                                 })
                         })
                 })
@@ -350,7 +350,14 @@ impl TitleBar {
             .next()
     }
 
-    fn render_remote_project_connection(&self, cx: &mut Context) -> Option {
+    fn render_remote_project_connection(
+        &self,
+        window: &mut Window,
+        cx: &mut Context,
+    ) -> Option {
+        let workspace = self.workspace.clone();
+        let is_picker_open = self.is_picker_open(window, cx);
+
         let options = self.project.read(cx).remote_connection_options(cx)?;
         let host: SharedString = options.display_name().into();
 
@@ -395,7 +402,7 @@ impl TitleBar {
         let meta = SharedString::from(meta);
 
         Some(
-            ButtonLike::new("ssh-server-icon")
+            ButtonLike::new("remote_project")
                 .child(
                     h_flex()
                         .gap_2()
@@ -410,26 +417,35 @@ impl TitleBar {
                         )
                         .child(Label::new(nickname).size(LabelSize::Small).truncate()),
                 )
-                .tooltip(move |_window, cx| {
-                    Tooltip::with_meta(
-                        tooltip_title,
-                        Some(&OpenRemote {
-                            from_existing_connection: false,
-                            create_new_window: false,
-                        }),
-                        meta.clone(),
-                        cx,
-                    )
+                .when(!is_picker_open, |this| {
+                    this.tooltip(move |_window, cx| {
+                        Tooltip::with_meta(
+                            tooltip_title,
+                            Some(&OpenRemote {
+                                from_existing_connection: false,
+                                create_new_window: false,
+                            }),
+                            meta.clone(),
+                            cx,
+                        )
+                    })
                 })
-                .on_click(|_, window, cx| {
-                    window.dispatch_action(
-                        OpenRemote {
-                            from_existing_connection: false,
-                            create_new_window: false,
-                        }
-                        .boxed_clone(),
-                        cx,
-                    );
+                .on_click(move |event, window, cx| {
+                    let position = event.position();
+                    let _ = workspace.update(cx, |this, cx| {
+                        this.set_next_modal_placement(workspace::ModalPlacement::Anchored {
+                            position,
+                        });
+
+                        window.dispatch_action(
+                            OpenRemote {
+                                from_existing_connection: false,
+                                create_new_window: false,
+                            }
+                            .boxed_clone(),
+                            cx,
+                        );
+                    });
                 })
                 .into_any_element(),
         )
@@ -481,9 +497,13 @@ impl TitleBar {
         }
     }
 
-    pub fn render_project_host(&self, cx: &mut Context) -> Option {
+    pub fn render_project_host(
+        &self,
+        window: &mut Window,
+        cx: &mut Context,
+    ) -> Option {
         if self.project.read(cx).is_via_remote_server() {
-            return self.render_remote_project_connection(cx);
+            return self.render_remote_project_connection(window, cx);
         }
 
         if self.project.read(cx).is_disconnected(cx) {
@@ -491,7 +511,6 @@ impl TitleBar {
                 Button::new("disconnected", "Disconnected")
                     .disabled(true)
                     .color(Color::Disabled)
-                    .style(ButtonStyle::Subtle)
                     .label_size(LabelSize::Small)
                     .into_any_element(),
             );
@@ -504,15 +523,19 @@ impl TitleBar {
             .read(cx)
             .participant_indices()
             .get(&host_user.id)?;
+
         Some(
             Button::new("project_owner_trigger", host_user.github_login.clone())
                 .color(Color::Player(participant_index.0))
-                .style(ButtonStyle::Subtle)
                 .label_size(LabelSize::Small)
-                .tooltip(Tooltip::text(format!(
-                    "{} is sharing this project. Click to follow.",
-                    host_user.github_login
-                )))
+                .tooltip(move |_, cx| {
+                    let tooltip_title = format!(
+                        "{} is sharing this project. Click to follow.",
+                        host_user.github_login
+                    );
+
+                    Tooltip::with_meta(tooltip_title, None, "Click to Follow", cx)
+                })
                 .on_click({
                     let host_peer_id = host.peer_id;
                     cx.listener(move |this, _, window, cx| {
@@ -527,7 +550,14 @@ impl TitleBar {
         )
     }
 
-    pub fn render_project_name(&self, cx: &mut Context) -> impl IntoElement {
+    pub fn render_project_name(
+        &self,
+        window: &mut Window,
+        cx: &mut Context,
+    ) -> impl IntoElement {
+        let workspace = self.workspace.clone();
+        let is_picker_open = self.is_picker_open(window, cx);
+
         let name = self.project_name(cx);
         let is_project_selected = name.is_some();
         let name = if let Some(name) = name {
@@ -537,19 +567,25 @@ impl TitleBar {
         };
 
         Button::new("project_name_trigger", name)
-            .when(!is_project_selected, |b| b.color(Color::Muted))
-            .style(ButtonStyle::Subtle)
             .label_size(LabelSize::Small)
-            .tooltip(move |_window, cx| {
-                Tooltip::for_action(
-                    "Recent Projects",
-                    &zed_actions::OpenRecent {
-                        create_new_window: false,
-                    },
-                    cx,
-                )
+            .when(!is_project_selected, |s| s.color(Color::Muted))
+            .when(!is_picker_open, |this| {
+                this.tooltip(move |_window, cx| {
+                    Tooltip::for_action(
+                        "Recent Projects",
+                        &zed_actions::OpenRecent {
+                            create_new_window: false,
+                        },
+                        cx,
+                    )
+                })
             })
-            .on_click(cx.listener(move |_, _, window, cx| {
+            .on_click(move |event, window, cx| {
+                let position = event.position();
+                let _ = workspace.update(cx, |this, _cx| {
+                    this.set_next_modal_placement(workspace::ModalPlacement::Anchored { position })
+                });
+
                 window.dispatch_action(
                     OpenRecent {
                         create_new_window: false,
@@ -557,84 +593,102 @@ impl TitleBar {
                     .boxed_clone(),
                     cx,
                 );
-            }))
+            })
     }
 
-    pub fn render_project_repo(&self, cx: &mut Context) -> Option {
-        let settings = TitleBarSettings::get_global(cx);
+    pub fn render_project_repo(
+        &self,
+        window: &mut Window,
+        cx: &mut Context,
+    ) -> Option {
         let repository = self.project.read(cx).active_repository(cx)?;
         let repository_count = self.project.read(cx).repositories(cx).len();
         let workspace = self.workspace.upgrade()?;
-        let repo = repository.read(cx);
-        let branch_name = repo
-            .branch
-            .as_ref()
-            .map(|branch| branch.name())
-            .map(|name| util::truncate_and_trailoff(name, MAX_BRANCH_NAME_LENGTH))
-            .or_else(|| {
-                repo.head_commit.as_ref().map(|commit| {
-                    commit
-                        .sha
-                        .chars()
-                        .take(MAX_SHORT_SHA_LENGTH)
-                        .collect::()
-                })
-            })?;
-        let project_name = self.project_name(cx);
-        let repo_name = repo
-            .work_directory_abs_path
-            .file_name()
-            .and_then(|name| name.to_str())
-            .map(SharedString::new);
-        let show_repo_name =
-            repository_count > 1 && repo.branch.is_some() && repo_name != project_name;
-        let branch_name = if let Some(repo_name) = repo_name.filter(|_| show_repo_name) {
-            format!("{repo_name}/{branch_name}")
-        } else {
-            branch_name
+
+        let (branch_name, icon_info) = {
+            let repo = repository.read(cx);
+            let branch_name = repo
+                .branch
+                .as_ref()
+                .map(|branch| branch.name())
+                .map(|name| util::truncate_and_trailoff(name, MAX_BRANCH_NAME_LENGTH))
+                .or_else(|| {
+                    repo.head_commit.as_ref().map(|commit| {
+                        commit
+                            .sha
+                            .chars()
+                            .take(MAX_SHORT_SHA_LENGTH)
+                            .collect::()
+                    })
+                });
+
+            let branch_name = branch_name?;
+
+            let project_name = self.project_name(cx);
+            let repo_name = repo
+                .work_directory_abs_path
+                .file_name()
+                .and_then(|name| name.to_str())
+                .map(SharedString::new);
+            let show_repo_name =
+                repository_count > 1 && repo.branch.is_some() && repo_name != project_name;
+            let branch_name = if let Some(repo_name) = repo_name.filter(|_| show_repo_name) {
+                format!("{repo_name}/{branch_name}")
+            } else {
+                branch_name
+            };
+
+            let status = repo.status_summary();
+            let tracked = status.index + status.worktree;
+            let icon_info = if status.conflict > 0 {
+                (IconName::Warning, Color::VersionControlConflict)
+            } else if tracked.modified > 0 {
+                (IconName::SquareDot, Color::VersionControlModified)
+            } else if tracked.added > 0 || status.untracked > 0 {
+                (IconName::SquarePlus, Color::VersionControlAdded)
+            } else if tracked.deleted > 0 {
+                (IconName::SquareMinus, Color::VersionControlDeleted)
+            } else {
+                (IconName::GitBranch, Color::Muted)
+            };
+
+            (branch_name, icon_info)
         };
 
+        let is_picker_open = self.is_picker_open(window, cx);
+        let settings = TitleBarSettings::get_global(cx);
+
         Some(
             Button::new("project_branch_trigger", branch_name)
-                .color(Color::Muted)
-                .style(ButtonStyle::Subtle)
                 .label_size(LabelSize::Small)
-                .tooltip(move |_window, cx| {
-                    Tooltip::with_meta(
-                        "Recent Branches",
-                        Some(&zed_actions::git::Branch),
-                        "Local branches only",
-                        cx,
-                    )
-                })
-                .on_click(move |_, window, cx| {
-                    let _ = workspace.update(cx, |this, cx| {
-                        window.focus(&this.active_pane().focus_handle(cx), cx);
-                        window.dispatch_action(zed_actions::git::Branch.boxed_clone(), cx);
-                    });
+                .color(Color::Muted)
+                .when(!is_picker_open, |this| {
+                    this.tooltip(move |_window, cx| {
+                        Tooltip::with_meta(
+                            "Recent Branches",
+                            Some(&zed_actions::git::Branch),
+                            "Local branches only",
+                            cx,
+                        )
+                    })
                 })
                 .when(settings.show_branch_icon, |branch_button| {
-                    let (icon, icon_color) = {
-                        let status = repo.status_summary();
-                        let tracked = status.index + status.worktree;
-                        if status.conflict > 0 {
-                            (IconName::Warning, Color::VersionControlConflict)
-                        } else if tracked.modified > 0 {
-                            (IconName::SquareDot, Color::VersionControlModified)
-                        } else if tracked.added > 0 || status.untracked > 0 {
-                            (IconName::SquarePlus, Color::VersionControlAdded)
-                        } else if tracked.deleted > 0 {
-                            (IconName::SquareMinus, Color::VersionControlDeleted)
-                        } else {
-                            (IconName::GitBranch, Color::Muted)
-                        }
-                    };
-
+                    let (icon, icon_color) = icon_info;
                     branch_button
                         .icon(icon)
                         .icon_position(IconPosition::Start)
                         .icon_color(icon_color)
                         .icon_size(IconSize::Indicator)
+                })
+                .on_click(move |event, window, cx| {
+                    let position = event.position();
+                    let _ = workspace.update(cx, |this, cx| {
+                        this.set_next_modal_placement(workspace::ModalPlacement::Anchored {
+                            position,
+                        });
+                        window.focus(&this.active_pane().focus_handle(cx), cx);
+                        window.dispatch_action(zed_actions::git::Branch.boxed_clone(), cx);
+                    });
                 }),
         )
     }
@@ -726,7 +780,7 @@ impl TitleBar {
 
     pub fn render_sign_in_button(&mut self, _: &mut Context) -> Button {
         let client = self.client.clone();
-        Button::new("sign_in", "Sign in")
+        Button::new("sign_in", "Sign In")
             .label_size(LabelSize::Small)
             .on_click(move |_, window, cx| {
                 let client = client.clone();
@@ -848,4 +902,10 @@ impl TitleBar {
             })
             .anchor(gpui::Corner::TopRight)
     }
+
+    fn is_picker_open(&self, window: &mut Window, cx: &mut Context) -> bool {
+        self.workspace
+            .update(cx, |workspace, cx| workspace.has_active_modal(window, cx))
+            .unwrap_or(false)
+    }
 }
diff --git a/crates/workspace/src/modal_layer.rs b/crates/workspace/src/modal_layer.rs
index 58667e7ffa8ad4fe5a22d293e4fc4aa71015a3bd..4087e1a398ac2b89257fea6b4dce53278d0872a8 100644
--- a/crates/workspace/src/modal_layer.rs
+++ b/crates/workspace/src/modal_layer.rs
@@ -1,9 +1,18 @@
 use gpui::{
     AnyView, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable as _, ManagedView,
-    MouseButton, Subscription,
+    MouseButton, Pixels, Point, Subscription,
 };
 use ui::prelude::*;
 
+#[derive(Debug, Clone, Copy, Default)]
+pub enum ModalPlacement {
+    #[default]
+    Centered,
+    Anchored {
+        position: Point,
+    },
+}
+
 #[derive(Debug)]
 pub enum DismissDecision {
     Dismiss(bool),
@@ -58,6 +67,7 @@ pub struct ActiveModal {
     _subscriptions: [Subscription; 2],
     previous_focus_handle: Option,
     focus_handle: FocusHandle,
+    placement: ModalPlacement,
 }
 
 pub struct ModalLayer {
@@ -87,6 +97,19 @@ impl ModalLayer {
     where
         V: ModalView,
         B: FnOnce(&mut Window, &mut Context) -> V,
+    {
+        self.toggle_modal_with_placement(window, cx, ModalPlacement::Centered, build_view);
+    }
+
+    pub fn toggle_modal_with_placement(
+        &mut self,
+        window: &mut Window,
+        cx: &mut Context,
+        placement: ModalPlacement,
+        build_view: B,
+    ) where
+        V: ModalView,
+        B: FnOnce(&mut Window, &mut Context) -> V,
     {
         if let Some(active_modal) = &self.active_modal {
             let is_close = active_modal.modal.view().downcast::().is_ok();
@@ -96,12 +119,17 @@ impl ModalLayer {
             }
         }
         let new_modal = cx.new(|cx| build_view(window, cx));
-        self.show_modal(new_modal, window, cx);
+        self.show_modal(new_modal, placement, window, cx);
         cx.emit(ModalOpenedEvent);
     }
 
-    fn show_modal(&mut self, new_modal: Entity, window: &mut Window, cx: &mut Context)
-    where
+    fn show_modal(
+        &mut self,
+        new_modal: Entity,
+        placement: ModalPlacement,
+        window: &mut Window,
+        cx: &mut Context,
+    ) where
         V: ModalView,
     {
         let focus_handle = cx.focus_handle();
@@ -123,6 +151,7 @@ impl ModalLayer {
             ],
             previous_focus_handle: window.focused(cx),
             focus_handle,
+            placement,
         });
         cx.defer_in(window, move |_, window, cx| {
             window.focus(&new_modal.focus_handle(cx), cx);
@@ -183,6 +212,30 @@ impl Render for ModalLayer {
             return active_modal.modal.view().into_any_element();
         }
 
+        let content = h_flex()
+            .occlude()
+            .child(active_modal.modal.view())
+            .on_mouse_down(MouseButton::Left, |_, _, cx| {
+                cx.stop_propagation();
+            });
+
+        let positioned = match active_modal.placement {
+            ModalPlacement::Centered => v_flex()
+                .h(px(0.0))
+                .top_20()
+                .items_center()
+                .track_focus(&active_modal.focus_handle)
+                .child(content)
+                .into_any_element(),
+            ModalPlacement::Anchored { position } => div()
+                .absolute()
+                .left(position.x)
+                .top(position.y - px(20.))
+                .track_focus(&active_modal.focus_handle)
+                .child(content)
+                .into_any_element(),
+        };
+
         div()
             .absolute()
             .size_full()
@@ -199,21 +252,7 @@ impl Render for ModalLayer {
                     this.hide_modal(window, cx);
                 }),
             )
-            .child(
-                v_flex()
-                    .h(px(0.0))
-                    .top_20()
-                    .items_center()
-                    .track_focus(&active_modal.focus_handle)
-                    .child(
-                        h_flex()
-                            .occlude()
-                            .child(active_modal.modal.view())
-                            .on_mouse_down(MouseButton::Left, |_, _, cx| {
-                                cx.stop_propagation();
-                            }),
-                    ),
-            )
+            .child(positioned)
             .into_any_element()
     }
 }
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index 53b0cc0623fa4b3ce7de5f1d8e3fd2262210a09a..c88386281e73b243dbddd6cb00c80fb26595409e 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -1204,6 +1204,7 @@ pub struct Workspace {
     last_open_dock_positions: Vec,
     removing: bool,
     utility_panes: UtilityPaneState,
+    next_modal_placement: Option,
 }
 
 impl EventEmitter for Workspace {}
@@ -1620,6 +1621,7 @@ impl Workspace {
             last_open_dock_positions: Vec::new(),
             removing: false,
             utility_panes: UtilityPaneState::default(),
+            next_modal_placement: None,
         }
     }
 
@@ -6326,12 +6328,25 @@ impl Workspace {
         self.modal_layer.read(cx).active_modal()
     }
 
+    pub fn is_modal_open(&self, cx: &App) -> bool {
+        self.modal_layer.read(cx).active_modal::().is_some()
+    }
+
+    pub fn set_next_modal_placement(&mut self, placement: ModalPlacement) {
+        self.next_modal_placement = Some(placement);
+    }
+
+    fn take_next_modal_placement(&mut self) -> ModalPlacement {
+        self.next_modal_placement.take().unwrap_or_default()
+    }
+
     pub fn toggle_modal(&mut self, window: &mut Window, cx: &mut App, build: B)
     where
         B: FnOnce(&mut Window, &mut Context) -> V,
     {
+        let placement = self.take_next_modal_placement();
         self.modal_layer.update(cx, |modal_layer, cx| {
-            modal_layer.toggle_modal(window, cx, build)
+            modal_layer.toggle_modal_with_placement(window, cx, placement, build)
         })
     }
 

From ea34cc5324c12ee44d7128f15f9bc5de42d3f358 Mon Sep 17 00:00:00 2001
From: feeiyu <158308373+feeiyu@users.noreply.github.com>
Date: Sat, 20 Dec 2025 00:06:16 +0800
Subject: [PATCH 233/266] Fix terminal doesn't switch to project directory when
 opening remote project on Windows (#45328)

Closes #45253

Release Notes:

- Fixed terminal doesn't switch to project directory when opening remote
project on Windows
---
 crates/remote/src/transport/ssh.rs | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/crates/remote/src/transport/ssh.rs b/crates/remote/src/transport/ssh.rs
index 6c8eb49c1c2158322a275e064162b53e2f5f3d5e..d13e1c4934947e39b08e05eb32e2787548e621e1 100644
--- a/crates/remote/src/transport/ssh.rs
+++ b/crates/remote/src/transport/ssh.rs
@@ -32,8 +32,7 @@ use tempfile::TempDir;
 use util::{
     paths::{PathStyle, RemotePathBuf},
     rel_path::RelPath,
-    shell::{Shell, ShellKind},
-    shell_builder::ShellBuilder,
+    shell::ShellKind,
 };
 
 pub(crate) struct SshRemoteConnection {
@@ -1544,8 +1543,6 @@ fn build_command(
     } else {
         write!(exec, "{ssh_shell} -l")?;
     };
-    let (command, command_args) = ShellBuilder::new(&Shell::Program(ssh_shell.to_owned()), false)
-        .build(Some(exec.clone()), &[]);
 
     let mut args = Vec::new();
     args.extend(ssh_args);
@@ -1556,8 +1553,7 @@ fn build_command(
     }
 
     args.push("-t".into());
-    args.push(command);
-    args.extend(command_args);
+    args.push(exec);
 
     Ok(CommandTemplate {
         program: "ssh".into(),
@@ -1597,9 +1593,6 @@ mod tests {
                 "-p",
                 "2222",
                 "-t",
-                "/bin/fish",
-                "-i",
-                "-c",
                 "cd \"$HOME/work\" && exec env INPUT_VA=val remote_program arg1 arg2"
             ]
         );
@@ -1632,9 +1625,6 @@ mod tests {
                 "-L",
                 "1:foo:2",
                 "-t",
-                "/bin/fish",
-                "-i",
-                "-c",
                 "cd && exec env INPUT_VA=val /bin/fish -l"
             ]
         );

From a7e07010e58bc53bcc8a33adbb0e5e31d251c432 Mon Sep 17 00:00:00 2001
From: "Raduan A." <36044389+0xRaduan@users.noreply.github.com>
Date: Fri, 19 Dec 2025 17:14:02 +0100
Subject: [PATCH 234/266] editor: Add automatic markdown list continuation on
 newline and indent on tab (#42800)

Closes #5089

Release notes:
- Markdown lists now continue automatically when you press Enter
(unordered, ordered, and task lists). This can be configured with
`extend_list_on_newline` (default: true).
- You can now indent list markers with Tab to quickly create nested
lists. This can be configured with `indent_list_on_tab` (default: true).

---------

Co-authored-by: Claude 
Co-authored-by: Smit Barmase 
---
 assets/settings/default.json                  |   4 +
 crates/editor/src/editor.rs                   | 459 +++++++++++---
 crates/editor/src/editor_tests.rs             | 588 ++++++++++++++++--
 crates/language/src/language.rs               |  45 ++
 crates/language/src/language_settings.rs      |   6 +
 crates/languages/src/markdown/config.toml     |   3 +
 .../settings/src/settings_content/language.rs |   8 +
 crates/settings/src/vscode_import.rs          |   2 +
 docs/src/configuring-zed.md                   |  20 +
 docs/src/languages/markdown.md                |  34 +
 10 files changed, 1021 insertions(+), 148 deletions(-)

diff --git a/assets/settings/default.json b/assets/settings/default.json
index 154fe2d6e34e6573e95e7ffedbb46df8bbf10634..746ccb5986d0fd1d5ef11df525303e344a7393d2 100644
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -1178,6 +1178,10 @@
   "remove_trailing_whitespace_on_save": true,
   // Whether to start a new line with a comment when a previous line is a comment as well.
   "extend_comment_on_newline": true,
+  // Whether to continue markdown lists when pressing enter.
+  "extend_list_on_newline": true,
+  // Whether to indent list items when pressing tab after a list marker.
+  "indent_list_on_tab": true,
   // Removes any lines containing only whitespace at the end of the file and
   // ensures just one newline at the end.
   "ensure_final_newline_on_save": true,
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 8560705802264dad55b87dbf21e1f9aa7625edf8..6e4744335b8e9fba50a6c2c8b241607b0e05d276 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -163,6 +163,7 @@ use project::{
     project_settings::{DiagnosticSeverity, GoToDiagnosticSeverityFilter, ProjectSettings},
 };
 use rand::seq::SliceRandom;
+use regex::Regex;
 use rpc::{ErrorCode, ErrorExt, proto::PeerId};
 use scroll::{Autoscroll, OngoingScroll, ScrollAnchor, ScrollManager};
 use selections_collection::{MutableSelectionsCollection, SelectionsCollection};
@@ -4787,82 +4788,146 @@ impl Editor {
                         let end = selection.end;
                         let selection_is_empty = start == end;
                         let language_scope = buffer.language_scope_at(start);
-                        let (comment_delimiter, doc_delimiter, newline_formatting) =
-                            if let Some(language) = &language_scope {
-                                let mut newline_formatting =
-                                    NewlineFormatting::new(&buffer, start..end, language);
-
-                                // Comment extension on newline is allowed only for cursor selections
-                                let comment_delimiter = maybe!({
-                                    if !selection_is_empty {
-                                        return None;
-                                    }
+                        let (delimiter, newline_config) = if let Some(language) = &language_scope {
+                            let needs_extra_newline = NewlineConfig::insert_extra_newline_brackets(
+                                &buffer,
+                                start..end,
+                                language,
+                            )
+                                || NewlineConfig::insert_extra_newline_tree_sitter(
+                                    &buffer,
+                                    start..end,
+                                );
 
-                                    if !multi_buffer.language_settings(cx).extend_comment_on_newline
-                                    {
-                                        return None;
-                                    }
+                            let mut newline_config = NewlineConfig::Newline {
+                                additional_indent: IndentSize::spaces(0),
+                                extra_line_additional_indent: if needs_extra_newline {
+                                    Some(IndentSize::spaces(0))
+                                } else {
+                                    None
+                                },
+                                prevent_auto_indent: false,
+                            };
 
-                                    return comment_delimiter_for_newline(
-                                        &start_point,
-                                        &buffer,
-                                        language,
-                                    );
-                                });
+                            let comment_delimiter = maybe!({
+                                if !selection_is_empty {
+                                    return None;
+                                }
 
-                                let doc_delimiter = maybe!({
-                                    if !selection_is_empty {
-                                        return None;
-                                    }
+                                if !multi_buffer.language_settings(cx).extend_comment_on_newline {
+                                    return None;
+                                }
 
-                                    if !multi_buffer.language_settings(cx).extend_comment_on_newline
-                                    {
-                                        return None;
-                                    }
+                                return comment_delimiter_for_newline(
+                                    &start_point,
+                                    &buffer,
+                                    language,
+                                );
+                            });
 
-                                    return documentation_delimiter_for_newline(
-                                        &start_point,
-                                        &buffer,
-                                        language,
-                                        &mut newline_formatting,
-                                    );
-                                });
+                            let doc_delimiter = maybe!({
+                                if !selection_is_empty {
+                                    return None;
+                                }
 
-                                (comment_delimiter, doc_delimiter, newline_formatting)
-                            } else {
-                                (None, None, NewlineFormatting::default())
-                            };
+                                if !multi_buffer.language_settings(cx).extend_comment_on_newline {
+                                    return None;
+                                }
 
-                        let prevent_auto_indent = doc_delimiter.is_some();
-                        let delimiter = comment_delimiter.or(doc_delimiter);
+                                return documentation_delimiter_for_newline(
+                                    &start_point,
+                                    &buffer,
+                                    language,
+                                    &mut newline_config,
+                                );
+                            });
 
-                        let capacity_for_delimiter =
-                            delimiter.as_deref().map(str::len).unwrap_or_default();
-                        let mut new_text = String::with_capacity(
-                            1 + capacity_for_delimiter
-                                + existing_indent.len as usize
-                                + newline_formatting.indent_on_newline.len as usize
-                                + newline_formatting.indent_on_extra_newline.len as usize,
-                        );
-                        new_text.push('\n');
-                        new_text.extend(existing_indent.chars());
-                        new_text.extend(newline_formatting.indent_on_newline.chars());
+                            let list_delimiter = maybe!({
+                                if !selection_is_empty {
+                                    return None;
+                                }
 
-                        if let Some(delimiter) = &delimiter {
-                            new_text.push_str(delimiter);
-                        }
+                                if !multi_buffer.language_settings(cx).extend_list_on_newline {
+                                    return None;
+                                }
 
-                        if newline_formatting.insert_extra_newline {
-                            new_text.push('\n');
-                            new_text.extend(existing_indent.chars());
-                            new_text.extend(newline_formatting.indent_on_extra_newline.chars());
-                        }
+                                return list_delimiter_for_newline(
+                                    &start_point,
+                                    &buffer,
+                                    language,
+                                    &mut newline_config,
+                                );
+                            });
+
+                            (
+                                comment_delimiter.or(doc_delimiter).or(list_delimiter),
+                                newline_config,
+                            )
+                        } else {
+                            (
+                                None,
+                                NewlineConfig::Newline {
+                                    additional_indent: IndentSize::spaces(0),
+                                    extra_line_additional_indent: None,
+                                    prevent_auto_indent: false,
+                                },
+                            )
+                        };
+
+                        let (edit_start, new_text, prevent_auto_indent) = match &newline_config {
+                            NewlineConfig::ClearCurrentLine => {
+                                let row_start =
+                                    buffer.point_to_offset(Point::new(start_point.row, 0));
+                                (row_start, String::new(), false)
+                            }
+                            NewlineConfig::UnindentCurrentLine { continuation } => {
+                                let row_start =
+                                    buffer.point_to_offset(Point::new(start_point.row, 0));
+                                let tab_size = buffer.language_settings_at(start, cx).tab_size;
+                                let tab_size_indent = IndentSize::spaces(tab_size.get());
+                                let reduced_indent =
+                                    existing_indent.with_delta(Ordering::Less, tab_size_indent);
+                                let mut new_text = String::new();
+                                new_text.extend(reduced_indent.chars());
+                                new_text.push_str(continuation);
+                                (row_start, new_text, true)
+                            }
+                            NewlineConfig::Newline {
+                                additional_indent,
+                                extra_line_additional_indent,
+                                prevent_auto_indent,
+                            } => {
+                                let capacity_for_delimiter =
+                                    delimiter.as_deref().map(str::len).unwrap_or_default();
+                                let extra_line_len = extra_line_additional_indent
+                                    .map(|i| 1 + existing_indent.len as usize + i.len as usize)
+                                    .unwrap_or(0);
+                                let mut new_text = String::with_capacity(
+                                    1 + capacity_for_delimiter
+                                        + existing_indent.len as usize
+                                        + additional_indent.len as usize
+                                        + extra_line_len,
+                                );
+                                new_text.push('\n');
+                                new_text.extend(existing_indent.chars());
+                                new_text.extend(additional_indent.chars());
+                                if let Some(delimiter) = &delimiter {
+                                    new_text.push_str(delimiter);
+                                }
+                                if let Some(extra_indent) = extra_line_additional_indent {
+                                    new_text.push('\n');
+                                    new_text.extend(existing_indent.chars());
+                                    new_text.extend(extra_indent.chars());
+                                }
+                                (start, new_text, *prevent_auto_indent)
+                            }
+                        };
 
                         let anchor = buffer.anchor_after(end);
                         let new_selection = selection.map(|_| anchor);
                         (
-                            ((start..end, new_text), prevent_auto_indent),
-                            (newline_formatting.insert_extra_newline, new_selection),
+                            ((edit_start..end, new_text), prevent_auto_indent),
+                            (newline_config.has_extra_line(), new_selection),
                         )
                     })
                     .unzip()
@@ -10387,6 +10452,22 @@ impl Editor {
             }
             prev_edited_row = selection.end.row;
 
+            // If cursor is after a list prefix, make selection non-empty to trigger line indent
+            if selection.is_empty() {
+                let cursor = selection.head();
+                let settings = buffer.language_settings_at(cursor, cx);
+                if settings.indent_list_on_tab {
+                    if let Some(language) = snapshot.language_scope_at(Point::new(cursor.row, 0)) {
+                        if is_list_prefix_row(MultiBufferRow(cursor.row), &snapshot, &language) {
+                            row_delta = Self::indent_selection(
+                                buffer, &snapshot, selection, &mut edits, row_delta, cx,
+                            );
+                            continue;
+                        }
+                    }
+                }
+            }
+
             // If the selection is non-empty, then increase the indentation of the selected lines.
             if !selection.is_empty() {
                 row_delta =
@@ -23355,7 +23436,7 @@ fn documentation_delimiter_for_newline(
     start_point: &Point,
     buffer: &MultiBufferSnapshot,
     language: &LanguageScope,
-    newline_formatting: &mut NewlineFormatting,
+    newline_config: &mut NewlineConfig,
 ) -> Option> {
     let BlockCommentConfig {
         start: start_tag,
@@ -23407,6 +23488,9 @@ fn documentation_delimiter_for_newline(
         }
     };
 
+    let mut needs_extra_line = false;
+    let mut extra_line_additional_indent = IndentSize::spaces(0);
+
     let cursor_is_before_end_tag_if_exists = {
         let mut char_position = 0u32;
         let mut end_tag_offset = None;
@@ -23424,11 +23508,11 @@ fn documentation_delimiter_for_newline(
             let cursor_is_before_end_tag = column <= end_tag_offset;
             if cursor_is_after_start_tag {
                 if cursor_is_before_end_tag {
-                    newline_formatting.insert_extra_newline = true;
+                    needs_extra_line = true;
                 }
                 let cursor_is_at_start_of_end_tag = column == end_tag_offset;
                 if cursor_is_at_start_of_end_tag {
-                    newline_formatting.indent_on_extra_newline.len = *len;
+                    extra_line_additional_indent.len = *len;
                 }
             }
             cursor_is_before_end_tag
@@ -23440,39 +23524,240 @@ fn documentation_delimiter_for_newline(
     if (cursor_is_after_start_tag || cursor_is_after_delimiter)
         && cursor_is_before_end_tag_if_exists
     {
-        if cursor_is_after_start_tag {
-            newline_formatting.indent_on_newline.len = *len;
-        }
+        let additional_indent = if cursor_is_after_start_tag {
+            IndentSize::spaces(*len)
+        } else {
+            IndentSize::spaces(0)
+        };
+
+        *newline_config = NewlineConfig::Newline {
+            additional_indent,
+            extra_line_additional_indent: if needs_extra_line {
+                Some(extra_line_additional_indent)
+            } else {
+                None
+            },
+            prevent_auto_indent: true,
+        };
         Some(delimiter.clone())
     } else {
         None
     }
 }
 
-#[derive(Debug, Default)]
-struct NewlineFormatting {
-    insert_extra_newline: bool,
-    indent_on_newline: IndentSize,
-    indent_on_extra_newline: IndentSize,
+const ORDERED_LIST_MAX_MARKER_LEN: usize = 16;
+
+fn list_delimiter_for_newline(
+    start_point: &Point,
+    buffer: &MultiBufferSnapshot,
+    language: &LanguageScope,
+    newline_config: &mut NewlineConfig,
+) -> Option> {
+    let (snapshot, range) = buffer.buffer_line_for_row(MultiBufferRow(start_point.row))?;
+
+    let num_of_whitespaces = snapshot
+        .chars_for_range(range.clone())
+        .take_while(|c| c.is_whitespace())
+        .count();
+
+    let task_list_entries: Vec<_> = language
+        .task_list()
+        .into_iter()
+        .flat_map(|config| {
+            config
+                .prefixes
+                .iter()
+                .map(|prefix| (prefix.as_ref(), config.continuation.as_ref()))
+        })
+        .collect();
+    let unordered_list_entries: Vec<_> = language
+        .unordered_list()
+        .iter()
+        .map(|marker| (marker.as_ref(), marker.as_ref()))
+        .collect();
+
+    let all_entries: Vec<_> = task_list_entries
+        .into_iter()
+        .chain(unordered_list_entries)
+        .collect();
+
+    if let Some(max_prefix_len) = all_entries.iter().map(|(p, _)| p.len()).max() {
+        let candidate: String = snapshot
+            .chars_for_range(range.clone())
+            .skip(num_of_whitespaces)
+            .take(max_prefix_len)
+            .collect();
+
+        if let Some((prefix, continuation)) = all_entries
+            .iter()
+            .filter(|(prefix, _)| candidate.starts_with(*prefix))
+            .max_by_key(|(prefix, _)| prefix.len())
+        {
+            let end_of_prefix = num_of_whitespaces + prefix.len();
+            let cursor_is_after_prefix = end_of_prefix <= start_point.column as usize;
+            let has_content_after_marker = snapshot
+                .chars_for_range(range)
+                .skip(end_of_prefix)
+                .any(|c| !c.is_whitespace());
+
+            if has_content_after_marker && cursor_is_after_prefix {
+                return Some((*continuation).into());
+            }
+
+            if start_point.column as usize == end_of_prefix {
+                if num_of_whitespaces == 0 {
+                    *newline_config = NewlineConfig::ClearCurrentLine;
+                } else {
+                    *newline_config = NewlineConfig::UnindentCurrentLine {
+                        continuation: (*continuation).into(),
+                    };
+                }
+            }
+
+            return None;
+        }
+    }
+
+    let candidate: String = snapshot
+        .chars_for_range(range.clone())
+        .skip(num_of_whitespaces)
+        .take(ORDERED_LIST_MAX_MARKER_LEN)
+        .collect();
+
+    for ordered_config in language.ordered_list() {
+        let regex = match Regex::new(&ordered_config.pattern) {
+            Ok(r) => r,
+            Err(_) => continue,
+        };
+
+        if let Some(captures) = regex.captures(&candidate) {
+            let full_match = captures.get(0)?;
+            let marker_len = full_match.len();
+            let end_of_prefix = num_of_whitespaces + marker_len;
+            let cursor_is_after_prefix = end_of_prefix <= start_point.column as usize;
+
+            let has_content_after_marker = snapshot
+                .chars_for_range(range)
+                .skip(end_of_prefix)
+                .any(|c| !c.is_whitespace());
+
+            if has_content_after_marker && cursor_is_after_prefix {
+                let number: u32 = captures.get(1)?.as_str().parse().ok()?;
+                let continuation = ordered_config
+                    .format
+                    .replace("{1}", &(number + 1).to_string());
+                return Some(continuation.into());
+            }
+
+            if start_point.column as usize == end_of_prefix {
+                let continuation = ordered_config.format.replace("{1}", "1");
+                if num_of_whitespaces == 0 {
+                    *newline_config = NewlineConfig::ClearCurrentLine;
+                } else {
+                    *newline_config = NewlineConfig::UnindentCurrentLine {
+                        continuation: continuation.into(),
+                    };
+                }
+            }
+
+            return None;
+        }
+    }
+
+    None
 }
 
-impl NewlineFormatting {
-    fn new(
-        buffer: &MultiBufferSnapshot,
-        range: Range,
-        language: &LanguageScope,
-    ) -> Self {
-        Self {
-            insert_extra_newline: Self::insert_extra_newline_brackets(
-                buffer,
-                range.clone(),
-                language,
-            ) || Self::insert_extra_newline_tree_sitter(buffer, range),
-            indent_on_newline: IndentSize::spaces(0),
-            indent_on_extra_newline: IndentSize::spaces(0),
+fn is_list_prefix_row(
+    row: MultiBufferRow,
+    buffer: &MultiBufferSnapshot,
+    language: &LanguageScope,
+) -> bool {
+    let Some((snapshot, range)) = buffer.buffer_line_for_row(row) else {
+        return false;
+    };
+
+    let num_of_whitespaces = snapshot
+        .chars_for_range(range.clone())
+        .take_while(|c| c.is_whitespace())
+        .count();
+
+    let task_list_prefixes: Vec<_> = language
+        .task_list()
+        .into_iter()
+        .flat_map(|config| {
+            config
+                .prefixes
+                .iter()
+                .map(|p| p.as_ref())
+                .collect::>()
+        })
+        .collect();
+    let unordered_list_markers: Vec<_> = language
+        .unordered_list()
+        .iter()
+        .map(|marker| marker.as_ref())
+        .collect();
+    let all_prefixes: Vec<_> = task_list_prefixes
+        .into_iter()
+        .chain(unordered_list_markers)
+        .collect();
+    if let Some(max_prefix_len) = all_prefixes.iter().map(|p| p.len()).max() {
+        let candidate: String = snapshot
+            .chars_for_range(range.clone())
+            .skip(num_of_whitespaces)
+            .take(max_prefix_len)
+            .collect();
+        if all_prefixes
+            .iter()
+            .any(|prefix| candidate.starts_with(*prefix))
+        {
+            return true;
         }
     }
 
+    let ordered_list_candidate: String = snapshot
+        .chars_for_range(range)
+        .skip(num_of_whitespaces)
+        .take(ORDERED_LIST_MAX_MARKER_LEN)
+        .collect();
+    for ordered_config in language.ordered_list() {
+        let regex = match Regex::new(&ordered_config.pattern) {
+            Ok(r) => r,
+            Err(_) => continue,
+        };
+        if let Some(captures) = regex.captures(&ordered_list_candidate) {
+            return captures.get(0).is_some();
+        }
+    }
+
+    false
+}
+
+#[derive(Debug)]
+enum NewlineConfig {
+    /// Insert newline with optional additional indent and optional extra blank line
+    Newline {
+        additional_indent: IndentSize,
+        extra_line_additional_indent: Option,
+        prevent_auto_indent: bool,
+    },
+    /// Clear the current line
+    ClearCurrentLine,
+    /// Unindent the current line and add continuation
+    UnindentCurrentLine { continuation: Arc },
+}
+
+impl NewlineConfig {
+    fn has_extra_line(&self) -> bool {
+        matches!(
+            self,
+            Self::Newline {
+                extra_line_additional_indent: Some(_),
+                ..
+            }
+        )
+    }
+
     fn insert_extra_newline_brackets(
         buffer: &MultiBufferSnapshot,
         range: Range,
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index c0112c5eda406c9cb3b3b9d004d20853b710f6e1..87674d8c507b1c294779b1f9ddba458320fc7671 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -28021,7 +28021,7 @@ async fn test_markdown_indents(cx: &mut gpui::TestAppContext) {
         "
     });
 
-    // Case 2: Test adding new line after nested list preserves indent of previous line
+    // Case 2: Test adding new line after nested list continues the list with unchecked task
     cx.set_state(&indoc! {"
         - [ ] Item 1
             - [ ] Item 1.a
@@ -28038,32 +28038,12 @@ async fn test_markdown_indents(cx: &mut gpui::TestAppContext) {
         - [x] Item 2
             - [x] Item 2.a
             - [x] Item 2.b
-            ˇ"
+            - [ ] ˇ"
     });
 
-    // Case 3: Test adding a new nested list item preserves indent
-    cx.set_state(&indoc! {"
-        - [ ] Item 1
-            - [ ] Item 1.a
-        - [x] Item 2
-            - [x] Item 2.a
-            - [x] Item 2.b
-            ˇ"
-    });
-    cx.update_editor(|editor, window, cx| {
-        editor.handle_input("-", window, cx);
-    });
-    cx.run_until_parked();
-    cx.assert_editor_state(indoc! {"
-        - [ ] Item 1
-            - [ ] Item 1.a
-        - [x] Item 2
-            - [x] Item 2.a
-            - [x] Item 2.b
-            -ˇ"
-    });
+    // Case 3: Test adding content to continued list item
     cx.update_editor(|editor, window, cx| {
-        editor.handle_input(" [x] Item 2.c", window, cx);
+        editor.handle_input("Item 2.c", window, cx);
     });
     cx.run_until_parked();
     cx.assert_editor_state(indoc! {"
@@ -28072,10 +28052,10 @@ async fn test_markdown_indents(cx: &mut gpui::TestAppContext) {
         - [x] Item 2
             - [x] Item 2.a
             - [x] Item 2.b
-            - [x] Item 2.cˇ"
+            - [ ] Item 2.cˇ"
     });
 
-    // Case 4: Test adding new line after nested ordered list preserves indent of previous line
+    // Case 4: Test adding new line after nested ordered list continues with next number
     cx.set_state(indoc! {"
         1. Item 1
             1. Item 1.a
@@ -28092,44 +28072,12 @@ async fn test_markdown_indents(cx: &mut gpui::TestAppContext) {
         2. Item 2
             1. Item 2.a
             2. Item 2.b
-            ˇ"
+            3. ˇ"
     });
 
-    // Case 5: Adding new ordered list item preserves indent
-    cx.set_state(indoc! {"
-        1. Item 1
-            1. Item 1.a
-        2. Item 2
-            1. Item 2.a
-            2. Item 2.b
-            ˇ"
-    });
-    cx.update_editor(|editor, window, cx| {
-        editor.handle_input("3", window, cx);
-    });
-    cx.run_until_parked();
-    cx.assert_editor_state(indoc! {"
-        1. Item 1
-            1. Item 1.a
-        2. Item 2
-            1. Item 2.a
-            2. Item 2.b
-            3ˇ"
-    });
-    cx.update_editor(|editor, window, cx| {
-        editor.handle_input(".", window, cx);
-    });
-    cx.run_until_parked();
-    cx.assert_editor_state(indoc! {"
-        1. Item 1
-            1. Item 1.a
-        2. Item 2
-            1. Item 2.a
-            2. Item 2.b
-            3.ˇ"
-    });
+    // Case 5: Adding content to continued ordered list item
     cx.update_editor(|editor, window, cx| {
-        editor.handle_input(" Item 2.c", window, cx);
+        editor.handle_input("Item 2.c", window, cx);
     });
     cx.run_until_parked();
     cx.assert_editor_state(indoc! {"
@@ -29497,6 +29445,524 @@ async fn test_find_references_single_case(cx: &mut TestAppContext) {
     cx.assert_editor_state(after);
 }
 
+#[gpui::test]
+async fn test_newline_task_list_continuation(cx: &mut TestAppContext) {
+    init_test(cx, |settings| {
+        settings.defaults.tab_size = Some(2.try_into().unwrap());
+    });
+
+    let markdown_language = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+    let mut cx = EditorTestContext::new(cx).await;
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
+
+    // Case 1: Adding newline after (whitespace + prefix + any non-whitespace) adds marker
+    cx.set_state(indoc! {"
+        - [ ] taskˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [ ] task
+        - [ ] ˇ
+    "});
+
+    // Case 2: Works with checked task items too
+    cx.set_state(indoc! {"
+        - [x] completed taskˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [x] completed task
+        - [ ] ˇ
+    "});
+
+    // Case 3: Cursor position doesn't matter - content after marker is what counts
+    cx.set_state(indoc! {"
+        - [ ] taˇsk
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [ ] ta
+        - [ ] ˇsk
+    "});
+
+    // Case 4: Adding newline after (whitespace + prefix + some whitespace) does NOT add marker
+    cx.set_state(indoc! {"
+        - [ ]  ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(
+        indoc! {"
+        - [ ]$$
+        ˇ
+    "}
+        .replace("$", " ")
+        .as_str(),
+    );
+
+    // Case 5: Adding newline with content adds marker preserving indentation
+    cx.set_state(indoc! {"
+        - [ ] task
+          - [ ] indentedˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [ ] task
+          - [ ] indented
+          - [ ] ˇ
+    "});
+
+    // Case 6: Adding newline with cursor right after prefix, unindents
+    cx.set_state(indoc! {"
+        - [ ] task
+          - [ ] sub task
+            - [ ] ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [ ] task
+          - [ ] sub task
+          - [ ] ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+
+    // Case 7: Adding newline with cursor right after prefix, removes marker
+    cx.assert_editor_state(indoc! {"
+        - [ ] task
+          - [ ] sub task
+        - [ ] ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [ ] task
+          - [ ] sub task
+        ˇ
+    "});
+
+    // Case 8: Cursor before or inside prefix does not add marker
+    cx.set_state(indoc! {"
+        ˇ- [ ] task
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+
+        ˇ- [ ] task
+    "});
+
+    cx.set_state(indoc! {"
+        - [ˇ ] task
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - [
+        ˇ
+        ] task
+    "});
+}
+
+#[gpui::test]
+async fn test_newline_unordered_list_continuation(cx: &mut TestAppContext) {
+    init_test(cx, |settings| {
+        settings.defaults.tab_size = Some(2.try_into().unwrap());
+    });
+
+    let markdown_language = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+    let mut cx = EditorTestContext::new(cx).await;
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
+
+    // Case 1: Adding newline after (whitespace + marker + any non-whitespace) adds marker
+    cx.set_state(indoc! {"
+        - itemˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - item
+        - ˇ
+    "});
+
+    // Case 2: Works with different markers
+    cx.set_state(indoc! {"
+        * starred itemˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        * starred item
+        * ˇ
+    "});
+
+    cx.set_state(indoc! {"
+        + plus itemˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        + plus item
+        + ˇ
+    "});
+
+    // Case 3: Cursor position doesn't matter - content after marker is what counts
+    cx.set_state(indoc! {"
+        - itˇem
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - it
+        - ˇem
+    "});
+
+    // Case 4: Adding newline after (whitespace + marker + some whitespace) does NOT add marker
+    cx.set_state(indoc! {"
+        -  ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(
+        indoc! {"
+        - $
+        ˇ
+    "}
+        .replace("$", " ")
+        .as_str(),
+    );
+
+    // Case 5: Adding newline with content adds marker preserving indentation
+    cx.set_state(indoc! {"
+        - item
+          - indentedˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - item
+          - indented
+          - ˇ
+    "});
+
+    // Case 6: Adding newline with cursor right after marker, unindents
+    cx.set_state(indoc! {"
+        - item
+          - sub item
+            - ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - item
+          - sub item
+          - ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+
+    // Case 7: Adding newline with cursor right after marker, removes marker
+    cx.assert_editor_state(indoc! {"
+        - item
+          - sub item
+        - ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        - item
+          - sub item
+        ˇ
+    "});
+
+    // Case 8: Cursor before or inside prefix does not add marker
+    cx.set_state(indoc! {"
+        ˇ- item
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+
+        ˇ- item
+    "});
+
+    cx.set_state(indoc! {"
+        -ˇ item
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        -
+        ˇitem
+    "});
+}
+
+#[gpui::test]
+async fn test_newline_ordered_list_continuation(cx: &mut TestAppContext) {
+    init_test(cx, |settings| {
+        settings.defaults.tab_size = Some(2.try_into().unwrap());
+    });
+
+    let markdown_language = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+    let mut cx = EditorTestContext::new(cx).await;
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
+
+    // Case 1: Adding newline after (whitespace + marker + any non-whitespace) increments number
+    cx.set_state(indoc! {"
+        1. first itemˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1. first item
+        2. ˇ
+    "});
+
+    // Case 2: Works with larger numbers
+    cx.set_state(indoc! {"
+        10. tenth itemˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        10. tenth item
+        11. ˇ
+    "});
+
+    // Case 3: Cursor position doesn't matter - content after marker is what counts
+    cx.set_state(indoc! {"
+        1. itˇem
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1. it
+        2. ˇem
+    "});
+
+    // Case 4: Adding newline after (whitespace + marker + some whitespace) does NOT add marker
+    cx.set_state(indoc! {"
+        1.  ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(
+        indoc! {"
+        1. $
+        ˇ
+    "}
+        .replace("$", " ")
+        .as_str(),
+    );
+
+    // Case 5: Adding newline with content adds marker preserving indentation
+    cx.set_state(indoc! {"
+        1. item
+          2. indentedˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1. item
+          2. indented
+          3. ˇ
+    "});
+
+    // Case 6: Adding newline with cursor right after marker, unindents
+    cx.set_state(indoc! {"
+        1. item
+          2. sub item
+            3. ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1. item
+          2. sub item
+          1. ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+
+    // Case 7: Adding newline with cursor right after marker, removes marker
+    cx.assert_editor_state(indoc! {"
+        1. item
+          2. sub item
+        1. ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1. item
+          2. sub item
+        ˇ
+    "});
+
+    // Case 8: Cursor before or inside prefix does not add marker
+    cx.set_state(indoc! {"
+        ˇ1. item
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+
+        ˇ1. item
+    "});
+
+    cx.set_state(indoc! {"
+        1ˇ. item
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1
+        ˇ. item
+    "});
+}
+
+#[gpui::test]
+async fn test_newline_should_not_autoindent_ordered_list(cx: &mut TestAppContext) {
+    init_test(cx, |settings| {
+        settings.defaults.tab_size = Some(2.try_into().unwrap());
+    });
+
+    let markdown_language = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+    let mut cx = EditorTestContext::new(cx).await;
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
+
+    // Case 1: Adding newline after (whitespace + marker + any non-whitespace) increments number
+    cx.set_state(indoc! {"
+        1. first item
+          1. sub first item
+          2. sub second item
+          3. ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    cx.assert_editor_state(indoc! {"
+        1. first item
+          1. sub first item
+          2. sub second item
+        1. ˇ
+    "});
+}
+
+#[gpui::test]
+async fn test_tab_list_indent(cx: &mut TestAppContext) {
+    init_test(cx, |settings| {
+        settings.defaults.tab_size = Some(2.try_into().unwrap());
+    });
+
+    let markdown_language = languages::language("markdown", tree_sitter_md::LANGUAGE.into());
+    let mut cx = EditorTestContext::new(cx).await;
+    cx.update_buffer(|buffer, cx| buffer.set_language(Some(markdown_language), cx));
+
+    // Case 1: Unordered list - cursor after prefix, adds indent before prefix
+    cx.set_state(indoc! {"
+        - ˇitem
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        $$- ˇitem
+    "};
+    cx.assert_editor_state(expected.replace("$", " ").as_str());
+
+    // Case 2: Task list - cursor after prefix
+    cx.set_state(indoc! {"
+        - [ ] ˇtask
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        $$- [ ] ˇtask
+    "};
+    cx.assert_editor_state(expected.replace("$", " ").as_str());
+
+    // Case 3: Ordered list - cursor after prefix
+    cx.set_state(indoc! {"
+        1. ˇfirst
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        $$1. ˇfirst
+    "};
+    cx.assert_editor_state(expected.replace("$", " ").as_str());
+
+    // Case 4: With existing indentation - adds more indent
+    let initial = indoc! {"
+        $$- ˇitem
+    "};
+    cx.set_state(initial.replace("$", " ").as_str());
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        $$$$- ˇitem
+    "};
+    cx.assert_editor_state(expected.replace("$", " ").as_str());
+
+    // Case 5: Empty list item
+    cx.set_state(indoc! {"
+        - ˇ
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        $$- ˇ
+    "};
+    cx.assert_editor_state(expected.replace("$", " ").as_str());
+
+    // Case 6: Cursor at end of line with content
+    cx.set_state(indoc! {"
+        - itemˇ
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        $$- itemˇ
+    "};
+    cx.assert_editor_state(expected.replace("$", " ").as_str());
+
+    // Case 7: Cursor at start of list item, indents it
+    cx.set_state(indoc! {"
+        - item
+        ˇ  - sub item
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        - item
+          ˇ  - sub item
+    "};
+    cx.assert_editor_state(expected);
+
+    // Case 8: Cursor at start of list item, moves the cursor when "indent_list_on_tab" is false
+    cx.update_editor(|_, _, cx| {
+        SettingsStore::update_global(cx, |store, cx| {
+            store.update_user_settings(cx, |settings| {
+                settings.project.all_languages.defaults.indent_list_on_tab = Some(false);
+            });
+        });
+    });
+    cx.set_state(indoc! {"
+        - item
+        ˇ  - sub item
+    "});
+    cx.update_editor(|e, window, cx| e.tab(&Tab, window, cx));
+    cx.wait_for_autoindent_applied().await;
+    let expected = indoc! {"
+        - item
+          ˇ- sub item
+    "};
+    cx.assert_editor_state(expected);
+}
+
 #[gpui::test]
 async fn test_local_worktree_trust(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index a573e3d78a4de03c6ccf382c80bc33eaf0b5690d..290cad4e4497015ef63f79e58a0dacf231168c9f 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -827,6 +827,15 @@ pub struct LanguageConfig {
     /// Delimiters and configuration for recognizing and formatting documentation comments.
     #[serde(default, alias = "documentation")]
     pub documentation_comment: Option,
+    /// List markers that are inserted unchanged on newline (e.g., `- `, `* `, `+ `).
+    #[serde(default)]
+    pub unordered_list: Vec>,
+    /// Configuration for ordered lists with auto-incrementing numbers on newline (e.g., `1. ` becomes `2. `).
+    #[serde(default)]
+    pub ordered_list: Vec,
+    /// Configuration for task lists where multiple markers map to a single continuation prefix (e.g., `- [x] ` continues as `- [ ] `).
+    #[serde(default)]
+    pub task_list: 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).
@@ -898,6 +907,24 @@ pub struct DecreaseIndentConfig {
     pub valid_after: Vec,
 }
 
+/// Configuration for continuing ordered lists with auto-incrementing numbers.
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
+pub struct OrderedListConfig {
+    /// A regex pattern with a capture group for the number portion (e.g., `(\\d+)\\. `).
+    pub pattern: String,
+    /// A format string where `{1}` is replaced with the incremented number (e.g., `{1}. `).
+    pub format: String,
+}
+
+/// Configuration for continuing task lists on newline.
+#[derive(Clone, Debug, Deserialize, JsonSchema)]
+pub struct TaskListConfig {
+    /// The list markers to match (e.g., `- [ ] `, `- [x] `).
+    pub prefixes: Vec>,
+    /// The marker to insert when continuing the list on a new line (e.g., `- [ ] `).
+    pub continuation: Arc,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, Default, JsonSchema)]
 pub struct LanguageMatcher {
     /// Given a list of `LanguageConfig`'s, the language of a file can be determined based on the path extension matching any of the `path_suffixes`.
@@ -1068,6 +1095,9 @@ impl Default for LanguageConfig {
             line_comments: Default::default(),
             block_comment: Default::default(),
             documentation_comment: Default::default(),
+            unordered_list: Default::default(),
+            ordered_list: Default::default(),
+            task_list: Default::default(),
             rewrap_prefixes: Default::default(),
             scope_opt_in_language_servers: Default::default(),
             overrides: Default::default(),
@@ -2153,6 +2183,21 @@ impl LanguageScope {
         self.language.config.documentation_comment.as_ref()
     }
 
+    /// Returns list markers that are inserted unchanged on newline (e.g., `- `, `* `, `+ `).
+    pub fn unordered_list(&self) -> &[Arc] {
+        &self.language.config.unordered_list
+    }
+
+    /// Returns configuration for ordered lists with auto-incrementing numbers (e.g., `1. ` becomes `2. `).
+    pub fn ordered_list(&self) -> &[OrderedListConfig] {
+        &self.language.config.ordered_list
+    }
+
+    /// Returns configuration for task list continuation, if any (e.g., `- [x] ` continues as `- [ ] `).
+    pub fn task_list(&self) -> Option<&TaskListConfig> {
+        self.language.config.task_list.as_ref()
+    }
+
     /// Returns additional regex patterns that act as prefix markers for creating
     /// boundaries during rewrapping.
     ///
diff --git a/crates/language/src/language_settings.rs b/crates/language/src/language_settings.rs
index fccaa545b79c1f24589889df8fcd163fbc5b6c7d..205f2431c6d9deeaa7661b583caa516bdc77ae79 100644
--- a/crates/language/src/language_settings.rs
+++ b/crates/language/src/language_settings.rs
@@ -122,6 +122,10 @@ pub struct LanguageSettings {
     pub whitespace_map: WhitespaceMap,
     /// Whether to start a new line with a comment when a previous line is a comment as well.
     pub extend_comment_on_newline: bool,
+    /// Whether to continue markdown lists when pressing enter.
+    pub extend_list_on_newline: bool,
+    /// Whether to indent list items when pressing tab after a list marker.
+    pub indent_list_on_tab: bool,
     /// Inlay hint related settings.
     pub inlay_hints: InlayHintSettings,
     /// Whether to automatically close brackets.
@@ -567,6 +571,8 @@ impl settings::Settings for AllLanguageSettings {
                     tab: SharedString::new(whitespace_map.tab.unwrap().to_string()),
                 },
                 extend_comment_on_newline: settings.extend_comment_on_newline.unwrap(),
+                extend_list_on_newline: settings.extend_list_on_newline.unwrap(),
+                indent_list_on_tab: settings.indent_list_on_tab.unwrap(),
                 inlay_hints: InlayHintSettings {
                     enabled: inlay_hints.enabled.unwrap(),
                     show_value_hints: inlay_hints.show_value_hints.unwrap(),
diff --git a/crates/languages/src/markdown/config.toml b/crates/languages/src/markdown/config.toml
index 84c79d2538a0af470ec16d55fe9cf2d1ae05805b..423a4c008f6e8a64f3c4e883b0d6e2bde65c88ae 100644
--- a/crates/languages/src/markdown/config.toml
+++ b/crates/languages/src/markdown/config.toml
@@ -20,6 +20,9 @@ rewrap_prefixes = [
     ">\\s*",
     "[-*+]\\s+\\[[\\sx]\\]\\s+"
 ]
+unordered_list = ["- ", "* ", "+ "]
+ordered_list = [{ pattern = "(\\d+)\\. ", format = "{1}. " }]
+task_list = { prefixes = ["- [ ] ", "- [x] "], continuation = "- [ ] " }
 
 auto_indent_on_paste = false
 auto_indent_using_last_non_empty_line = false
diff --git a/crates/settings/src/settings_content/language.rs b/crates/settings/src/settings_content/language.rs
index f9c85f18f380a7ad82b0d8bc202fe3763ba3a832..cf8cf7b63589e84a96e6b9d92f23a4488479d1f3 100644
--- a/crates/settings/src/settings_content/language.rs
+++ b/crates/settings/src/settings_content/language.rs
@@ -363,6 +363,14 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: true
     pub extend_comment_on_newline: Option,
+    /// Whether to continue markdown lists when pressing enter.
+    ///
+    /// Default: true
+    pub extend_list_on_newline: Option,
+    /// Whether to indent list items when pressing tab after a list marker.
+    ///
+    /// Default: true
+    pub indent_list_on_tab: Option,
     /// Inlay hint related settings.
     pub inlay_hints: Option,
     /// Whether to automatically type closing characters for you. For example,
diff --git a/crates/settings/src/vscode_import.rs b/crates/settings/src/vscode_import.rs
index d77754f611e8eb1746ee9061ce5b5e1dfdbdafdb..64343b05fd57c33eb9cfb0d8cb8674971266b464 100644
--- a/crates/settings/src/vscode_import.rs
+++ b/crates/settings/src/vscode_import.rs
@@ -430,6 +430,8 @@ impl VsCodeSettings {
             enable_language_server: None,
             ensure_final_newline_on_save: self.read_bool("files.insertFinalNewline"),
             extend_comment_on_newline: None,
+            extend_list_on_newline: None,
+            indent_list_on_tab: None,
             format_on_save: self.read_bool("editor.guides.formatOnSave").map(|b| {
                 if b {
                     FormatOnSave::On
diff --git a/docs/src/configuring-zed.md b/docs/src/configuring-zed.md
index 8a638d9f7857e1a55aaa5589a77110a7b803bbfe..81318aa8885fe883acc394e7fe983d7721dd33a5 100644
--- a/docs/src/configuring-zed.md
+++ b/docs/src/configuring-zed.md
@@ -1585,6 +1585,26 @@ Positive `integer` value between 1 and 32. Values outside of this range will be
 
 `boolean` values
 
+## Extend List On Newline
+
+- Description: Whether to continue lists when pressing Enter at the end of a list item. Supports unordered, ordered, and task lists. Pressing Enter on an empty list item removes the marker and exits the list.
+- Setting: `extend_list_on_newline`
+- Default: `true`
+
+**Options**
+
+`boolean` values
+
+## Indent List On Tab
+
+- Description: Whether to indent list items when pressing Tab on a line containing only a list marker. This enables quick creation of nested lists.
+- Setting: `indent_list_on_tab`
+- Default: `true`
+
+**Options**
+
+`boolean` values
+
 ## Status Bar
 
 - Description: Control various elements in the status bar. Note that some items in the status bar have their own settings set elsewhere.
diff --git a/docs/src/languages/markdown.md b/docs/src/languages/markdown.md
index 36ce734f7cfbcc066bb8026568209738655a6be9..64c9e7070569a23daa5bcb8aa4dace12e0021b03 100644
--- a/docs/src/languages/markdown.md
+++ b/docs/src/languages/markdown.md
@@ -33,6 +33,40 @@ Zed supports using Prettier to automatically re-format Markdown documents. You c
   },
 ```
 
+### List Continuation
+
+Zed automatically continues lists when you press Enter at the end of a list item. Supported list types:
+
+- Unordered lists (`-`, `*`, or `+` markers)
+- Ordered lists (numbers are auto-incremented)
+- Task lists (`- [ ]` and `- [x]`)
+
+Pressing Enter on an empty list item removes the marker and exits the list.
+
+To disable this behavior:
+
+```json [settings]
+  "languages": {
+    "Markdown": {
+      "extend_list_on_newline": false
+    }
+  },
+```
+
+### List Indentation
+
+Zed indents list items when you press Tab while the cursor is on a line containing only a list marker. This allows you to quickly create nested lists.
+
+To disable this behavior:
+
+```json [settings]
+  "languages": {
+    "Markdown": {
+      "indent_list_on_tab": false
+    }
+  },
+```
+
 ### Trailing Whitespace
 
 By default Zed will remove trailing whitespace on save. If you rely on invisible trailing whitespace being converted to `
` in Markdown files you can disable this behavior with:

From 32600f255aea17ffc4557b39f2fc8c275db3b59a Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 19 Dec 2025 13:14:31 -0300
Subject: [PATCH 235/266] gpui: Fix truncation flickering (#45373)

It's been a little that we've noticed some flickering and other weird
resizing behavior with text truncation in Zed:


https://github.com/user-attachments/assets/4d5691a3-cd3d-45e0-8b96-74a4e0e273d2


https://github.com/user-attachments/assets/d1d0e587-7676-4da0-8818-f4e50f0e294e

Initially, we suspected this could be due to how we calculate the length
of a line to insert truncation, which is based first on the length of
each individual character, and then second goes through a pass
calculating the line length as a whole. This could cause mismatch and
culminate in our bug.

However, even though that felt like a reasonable suspicion, I realized
something rather simple at some point: the `truncate` and
`truncate_start` methods in the `Label` didn't use `whitespace_nowrap`.
If you take Tailwind as an example, their `truncate` utility class takes
`overflow: hidden; text-overflow: ellipsis; white-space: nowrap;`. This
pointed out to a potential bug with `whitespace_nowrap` where that was
blocking truncation entirely, even though that's technically part of
what's necessary to truncate as you don't want text that will be
truncated to wrap.

Ultimately, what was happening was that the text element was caching its
layout based on its `wrap_width` but not considering its
`truncate_width`. The truncate width is essentially the new definitive
width of the text based on the available space, which was never being
computed. So the fix here was to add `truncate_width.is_none()` to the
cache validation check, so that it only uses the cached text element
size _if the truncation width is untouched_. But if that changes, we
need to account for the new width. Then, in the Label component, we
added `min_w_0` to allow the label div to shrink below its original
size, and finally, we added `whitespace_nowrap()` as the cache check
fundamentally fixed that method's problem.

In a future PR, we can basically remove the `single_line()` label method
because: 1) whenever you want a single label, you most likely want it to
truncate, and 2) most instances of `truncate` are already followed by
`single_line` in Zed today, so we can cut that part.

Result is no flickering with truncated labels!


https://github.com/user-attachments/assets/ae17cbde-0de7-42ca-98a4-22fcb452016b

Release Notes:

- Fixed a bug in GPUI where truncated text would flicker as you resized
the container in which the text was in.

Co-authored-by: Lukas Wirth 
---
 crates/gpui/src/elements/text.rs             | 10 ++++++++--
 crates/ui/src/components/label/label_like.rs | 10 ++++++++--
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/crates/gpui/src/elements/text.rs b/crates/gpui/src/elements/text.rs
index 942a0a326526431dc65f389e9cff67bac252d571..770c1f871432afbecc9ffd4e903dfeddcfcba6ee 100644
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -372,11 +372,17 @@ impl TextLayout {
                         (None, "".into(), TruncateFrom::End)
                     };
 
+                // Only use cached layout if:
+                // 1. We have a cached size
+                // 2. wrap_width matches (or both are None)
+                // 3. truncate_width is None (if truncate_width is Some, we need to re-layout
+                //    because the previous layout may have been computed without truncation)
                 if let Some(text_layout) = element_state.0.borrow().as_ref()
-                    && text_layout.size.is_some()
+                    && let Some(size) = text_layout.size
                     && (wrap_width.is_none() || wrap_width == text_layout.wrap_width)
+                    && truncate_width.is_none()
                 {
-                    return text_layout.size.unwrap();
+                    return size;
                 }
 
                 let mut line_wrapper = cx.text_system().line_wrapper(text_style.font(), font_size);
diff --git a/crates/ui/src/components/label/label_like.rs b/crates/ui/src/components/label/label_like.rs
index f6e7a1b893d54fff425618d5c604f591144a7385..03fde4083d5e9a8e07f38c830edd5116f14e6d70 100644
--- a/crates/ui/src/components/label/label_like.rs
+++ b/crates/ui/src/components/label/label_like.rs
@@ -241,10 +241,16 @@ impl RenderOnce for LabelLike {
             .when(self.strikethrough, |this| this.line_through())
             .when(self.single_line, |this| this.whitespace_nowrap())
             .when(self.truncate, |this| {
-                this.overflow_x_hidden().text_ellipsis()
+                this.min_w_0()
+                    .overflow_x_hidden()
+                    .whitespace_nowrap()
+                    .text_ellipsis()
             })
             .when(self.truncate_start, |this| {
-                this.overflow_x_hidden().text_ellipsis_start()
+                this.min_w_0()
+                    .overflow_x_hidden()
+                    .whitespace_nowrap()
+                    .text_ellipsis_start()
             })
             .text_color(color)
             .font_weight(

From e05dcecac40566c0a49b9754934d9030e4e7ad76 Mon Sep 17 00:00:00 2001
From: Ben Kunkle 
Date: Fri, 19 Dec 2025 10:21:56 -0600
Subject: [PATCH 236/266] Make `pane::CloseAllItems` best effort (#45368)

Closes #ISSUE

Release Notes:

- Fixed an issue where the `pane: close all items` action would give up
if you hit "Cancel" on the prompt for what to do with a dirty buffer
---
 crates/workspace/src/pane.rs      | 81 ++++++++++++++++++++++++++-----
 crates/workspace/src/workspace.rs | 26 ++++++----
 2 files changed, 85 insertions(+), 22 deletions(-)

diff --git a/crates/workspace/src/pane.rs b/crates/workspace/src/pane.rs
index f6256aee46b9e2b5c29c020e9ee12f6ff510210f..dd17c338a935571f4d0fe9d46b3b10fac9ffe218 100644
--- a/crates/workspace/src/pane.rs
+++ b/crates/workspace/src/pane.rs
@@ -1846,6 +1846,7 @@ impl Pane {
             }
 
             for item_to_close in items_to_close {
+                let mut should_close = true;
                 let mut should_save = true;
                 if save_intent == SaveIntent::Close {
                     workspace.update(cx, |workspace, cx| {
@@ -1861,7 +1862,7 @@ impl Pane {
                     {
                         Ok(success) => {
                             if !success {
-                                break;
+                                should_close = false;
                             }
                         }
                         Err(err) => {
@@ -1880,23 +1881,25 @@ impl Pane {
                             })?;
                             match answer.await {
                                 Ok(0) => {}
-                                Ok(1..) | Err(_) => break,
+                                Ok(1..) | Err(_) => should_close = false,
                             }
                         }
                     }
                 }
 
                 // Remove the item from the pane.
-                pane.update_in(cx, |pane, window, cx| {
-                    pane.remove_item(
-                        item_to_close.item_id(),
-                        false,
-                        pane.close_pane_if_empty,
-                        window,
-                        cx,
-                    );
-                })
-                .ok();
+                if should_close {
+                    pane.update_in(cx, |pane, window, cx| {
+                        pane.remove_item(
+                            item_to_close.item_id(),
+                            false,
+                            pane.close_pane_if_empty,
+                            window,
+                            cx,
+                        );
+                    })
+                    .ok();
+                }
             }
 
             pane.update(cx, |_, cx| cx.notify()).ok();
@@ -6614,6 +6617,60 @@ mod tests {
         cx.simulate_prompt_answer("Discard all");
         save.await.unwrap();
         assert_item_labels(&pane, [], cx);
+
+        add_labeled_item(&pane, "A", true, cx).update(cx, |item, cx| {
+            item.project_items
+                .push(TestProjectItem::new_dirty(1, "A.txt", cx))
+        });
+        add_labeled_item(&pane, "B", true, cx).update(cx, |item, cx| {
+            item.project_items
+                .push(TestProjectItem::new_dirty(2, "B.txt", cx))
+        });
+        add_labeled_item(&pane, "C", true, cx).update(cx, |item, cx| {
+            item.project_items
+                .push(TestProjectItem::new_dirty(3, "C.txt", cx))
+        });
+        assert_item_labels(&pane, ["A^", "B^", "C*^"], cx);
+
+        let close_task = pane.update_in(cx, |pane, window, cx| {
+            pane.close_all_items(
+                &CloseAllItems {
+                    save_intent: None,
+                    close_pinned: false,
+                },
+                window,
+                cx,
+            )
+        });
+
+        cx.executor().run_until_parked();
+        cx.simulate_prompt_answer("Discard all");
+        close_task.await.unwrap();
+        assert_item_labels(&pane, [], cx);
+
+        add_labeled_item(&pane, "Clean1", false, cx);
+        add_labeled_item(&pane, "Dirty", true, cx).update(cx, |item, cx| {
+            item.project_items
+                .push(TestProjectItem::new_dirty(1, "Dirty.txt", cx))
+        });
+        add_labeled_item(&pane, "Clean2", false, cx);
+        assert_item_labels(&pane, ["Clean1", "Dirty^", "Clean2*"], cx);
+
+        let close_task = pane.update_in(cx, |pane, window, cx| {
+            pane.close_all_items(
+                &CloseAllItems {
+                    save_intent: None,
+                    close_pinned: false,
+                },
+                window,
+                cx,
+            )
+        });
+
+        cx.executor().run_until_parked();
+        cx.simulate_prompt_answer("Cancel");
+        close_task.await.unwrap();
+        assert_item_labels(&pane, ["Dirty*^"], cx);
     }
 
     #[gpui::test]
diff --git a/crates/workspace/src/workspace.rs b/crates/workspace/src/workspace.rs
index c88386281e73b243dbddd6cb00c80fb26595409e..fa8e3a3dc2af33054907ea8a8c1ba095a3259207 100644
--- a/crates/workspace/src/workspace.rs
+++ b/crates/workspace/src/workspace.rs
@@ -9424,7 +9424,7 @@ mod tests {
         let right_pane = right_pane.await.unwrap();
         cx.focus(&right_pane);
 
-        let mut close = right_pane.update_in(cx, |pane, window, cx| {
+        let close = right_pane.update_in(cx, |pane, window, cx| {
             pane.close_all_items(&CloseAllItems::default(), window, cx)
                 .unwrap()
         });
@@ -9436,9 +9436,16 @@ mod tests {
         assert!(!msg.contains("3.txt"));
         assert!(!msg.contains("4.txt"));
 
+        // With best-effort close, cancelling item 1 keeps it open but items 4
+        // and (3,4) still close since their entries exist in left pane.
         cx.simulate_prompt_answer("Cancel");
         close.await;
 
+        right_pane.read_with(cx, |pane, _| {
+            assert_eq!(pane.items_len(), 1);
+        });
+
+        // Remove item 3 from left pane, making (2,3) the only item with entry 3.
         left_pane
             .update_in(cx, |left_pane, window, cx| {
                 left_pane.close_item_by_id(
@@ -9451,26 +9458,25 @@ mod tests {
             .await
             .unwrap();
 
-        close = right_pane.update_in(cx, |pane, window, cx| {
+        let close = left_pane.update_in(cx, |pane, window, cx| {
             pane.close_all_items(&CloseAllItems::default(), window, cx)
                 .unwrap()
         });
         cx.executor().run_until_parked();
 
         let details = cx.pending_prompt().unwrap().1;
-        assert!(details.contains("1.txt"));
-        assert!(!details.contains("2.txt"));
+        assert!(details.contains("0.txt"));
         assert!(details.contains("3.txt"));
-        // ideally this assertion could be made, but today we can only
-        // save whole items not project items, so the orphaned item 3 causes
-        // 4 to be saved too.
-        // assert!(!details.contains("4.txt"));
+        assert!(details.contains("4.txt"));
+        // Ideally 2.txt wouldn't appear since entry 2 still exists in item 2.
+        // But we can only save whole items, so saving (2,3) for entry 3 includes 2.
+        // assert!(!details.contains("2.txt"));
 
         cx.simulate_prompt_answer("Save all");
-
         cx.executor().run_until_parked();
         close.await;
-        right_pane.read_with(cx, |pane, _| {
+
+        left_pane.read_with(cx, |pane, _| {
             assert_eq!(pane.items_len(), 0);
         });
     }

From d7e41f74fb3e0279b24f190c19b4ccd3680d01b5 Mon Sep 17 00:00:00 2001
From: Agus Zubiaga 
Date: Fri, 19 Dec 2025 13:31:27 -0300
Subject: [PATCH 237/266] search: Respect macOS' find pasteboard (#45311)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closes #17467

Release Notes:

- On macOS, buffer search now syncs with the system find pasteboard,
allowing ⌘E and ⌘G to work seamlessly across Zed
and other apps.
---
 crates/gpui/src/app.rs                        |  36 +-
 crates/gpui/src/platform.rs                   |  12 +-
 crates/gpui/src/platform/mac.rs               |   3 +-
 .../src/platform/mac/attributed_string.rs     | 129 ------
 crates/gpui/src/platform/mac/pasteboard.rs    | 344 +++++++++++++++
 crates/gpui/src/platform/mac/platform.rs      | 397 ++----------------
 crates/gpui/src/platform/test/platform.rs     |  24 +-
 crates/search/src/buffer_search.rs            |  89 +++-
 8 files changed, 499 insertions(+), 535 deletions(-)
 delete mode 100644 crates/gpui/src/platform/mac/attributed_string.rs
 create mode 100644 crates/gpui/src/platform/mac/pasteboard.rs

diff --git a/crates/gpui/src/app.rs b/crates/gpui/src/app.rs
index 75600a9ee1b440a092a89456cbe8fbabe6fdccfa..96f815ac0b592600f22b3c9b9686571487ff77a2 100644
--- a/crates/gpui/src/app.rs
+++ b/crates/gpui/src/app.rs
@@ -1077,11 +1077,9 @@ impl App {
         self.platform.window_appearance()
     }
 
-    /// Writes data to the primary selection buffer.
-    /// Only available on Linux.
-    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
-    pub fn write_to_primary(&self, item: ClipboardItem) {
-        self.platform.write_to_primary(item)
+    /// Reads data from the platform clipboard.
+    pub fn read_from_clipboard(&self) -> Option {
+        self.platform.read_from_clipboard()
     }
 
     /// Writes data to the platform clipboard.
@@ -1096,9 +1094,31 @@ impl App {
         self.platform.read_from_primary()
     }
 
-    /// Reads data from the platform clipboard.
-    pub fn read_from_clipboard(&self) -> Option {
-        self.platform.read_from_clipboard()
+    /// Writes data to the primary selection buffer.
+    /// Only available on Linux.
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    pub fn write_to_primary(&self, item: ClipboardItem) {
+        self.platform.write_to_primary(item)
+    }
+
+    /// Reads data from macOS's "Find" pasteboard.
+    ///
+    /// Used to share the current search string between apps.
+    ///
+    /// https://developer.apple.com/documentation/appkit/nspasteboard/name-swift.struct/find
+    #[cfg(target_os = "macos")]
+    pub fn read_from_find_pasteboard(&self) -> Option {
+        self.platform.read_from_find_pasteboard()
+    }
+
+    /// Writes data to macOS's "Find" pasteboard.
+    ///
+    /// Used to share the current search string between apps.
+    ///
+    /// https://developer.apple.com/documentation/appkit/nspasteboard/name-swift.struct/find
+    #[cfg(target_os = "macos")]
+    pub fn write_to_find_pasteboard(&self, item: ClipboardItem) {
+        self.platform.write_to_find_pasteboard(item)
     }
 
     /// Writes credentials to the platform keychain.
diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs
index 22f4c46921132a7b8badfb7afd4fd38058c638b4..112775890ef6e478f0b2d347bc9c9ae56dac3c73 100644
--- a/crates/gpui/src/platform.rs
+++ b/crates/gpui/src/platform.rs
@@ -262,12 +262,18 @@ pub(crate) trait Platform: 'static {
     fn set_cursor_style(&self, style: CursorStyle);
     fn should_auto_hide_scrollbars(&self) -> bool;
 
-    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
-    fn write_to_primary(&self, item: ClipboardItem);
+    fn read_from_clipboard(&self) -> Option;
     fn write_to_clipboard(&self, item: ClipboardItem);
+
     #[cfg(any(target_os = "linux", target_os = "freebsd"))]
     fn read_from_primary(&self) -> Option;
-    fn read_from_clipboard(&self) -> Option;
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    fn write_to_primary(&self, item: ClipboardItem);
+
+    #[cfg(target_os = "macos")]
+    fn read_from_find_pasteboard(&self) -> Option;
+    #[cfg(target_os = "macos")]
+    fn write_to_find_pasteboard(&self, item: ClipboardItem);
 
     fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task>;
     fn read_credentials(&self, url: &str) -> Task)>>>;
diff --git a/crates/gpui/src/platform/mac.rs b/crates/gpui/src/platform/mac.rs
index aa056846e6bc56e53d95c41a44444dbb89a16237..a229ec7dce928597ec73b1f4be50edd1ea3e5114 100644
--- a/crates/gpui/src/platform/mac.rs
+++ b/crates/gpui/src/platform/mac.rs
@@ -5,6 +5,7 @@ mod display;
 mod display_link;
 mod events;
 mod keyboard;
+mod pasteboard;
 
 #[cfg(feature = "screen-capture")]
 mod screen_capture;
@@ -21,8 +22,6 @@ use metal_renderer as renderer;
 #[cfg(feature = "macos-blade")]
 use crate::platform::blade as renderer;
 
-mod attributed_string;
-
 #[cfg(feature = "font-kit")]
 mod open_type;
 
diff --git a/crates/gpui/src/platform/mac/attributed_string.rs b/crates/gpui/src/platform/mac/attributed_string.rs
deleted file mode 100644
index 42fe1e5bf7a396a4eaa8ade26977a207d43b49b5..0000000000000000000000000000000000000000
--- a/crates/gpui/src/platform/mac/attributed_string.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use cocoa::base::id;
-use cocoa::foundation::NSRange;
-use objc::{class, msg_send, sel, sel_impl};
-
-/// The `cocoa` crate does not define NSAttributedString (and related Cocoa classes),
-/// which are needed for copying rich text (that is, text intermingled with images)
-/// to the clipboard. This adds access to those APIs.
-#[allow(non_snake_case)]
-pub trait NSAttributedString: Sized {
-    unsafe fn alloc(_: Self) -> id {
-        msg_send![class!(NSAttributedString), alloc]
-    }
-
-    unsafe fn init_attributed_string(self, string: id) -> id;
-    unsafe fn appendAttributedString_(self, attr_string: id);
-    unsafe fn RTFDFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id;
-    unsafe fn RTFFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id;
-    unsafe fn string(self) -> id;
-}
-
-impl NSAttributedString for id {
-    unsafe fn init_attributed_string(self, string: id) -> id {
-        msg_send![self, initWithString: string]
-    }
-
-    unsafe fn appendAttributedString_(self, attr_string: id) {
-        let _: () = msg_send![self, appendAttributedString: attr_string];
-    }
-
-    unsafe fn RTFDFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id {
-        msg_send![self, RTFDFromRange: range documentAttributes: attrs]
-    }
-
-    unsafe fn RTFFromRange_documentAttributes_(self, range: NSRange, attrs: id) -> id {
-        msg_send![self, RTFFromRange: range documentAttributes: attrs]
-    }
-
-    unsafe fn string(self) -> id {
-        msg_send![self, string]
-    }
-}
-
-pub trait NSMutableAttributedString: NSAttributedString {
-    unsafe fn alloc(_: Self) -> id {
-        msg_send![class!(NSMutableAttributedString), alloc]
-    }
-}
-
-impl NSMutableAttributedString for id {}
-
-#[cfg(test)]
-mod tests {
-    use crate::platform::mac::ns_string;
-
-    use super::*;
-    use cocoa::appkit::NSImage;
-    use cocoa::base::nil;
-    use cocoa::foundation::NSAutoreleasePool;
-    #[test]
-    #[ignore] // This was SIGSEGV-ing on CI but not locally; need to investigate https://github.com/zed-industries/zed/actions/runs/10362363230/job/28684225486?pr=15782#step:4:1348
-    fn test_nsattributed_string() {
-        // TODO move these to parent module once it's actually ready to be used
-        #[allow(non_snake_case)]
-        pub trait NSTextAttachment: Sized {
-            unsafe fn alloc(_: Self) -> id {
-                msg_send![class!(NSTextAttachment), alloc]
-            }
-        }
-
-        impl NSTextAttachment for id {}
-
-        unsafe {
-            let image: id = {
-                let img: id = msg_send![class!(NSImage), alloc];
-                let img: id = msg_send![img, initWithContentsOfFile: ns_string("test.jpeg")];
-                let img: id = msg_send![img, autorelease];
-                img
-            };
-            let _size = image.size();
-
-            let string = ns_string("Test String");
-            let attr_string = NSMutableAttributedString::alloc(nil)
-                .init_attributed_string(string)
-                .autorelease();
-            let hello_string = ns_string("Hello World");
-            let hello_attr_string = NSAttributedString::alloc(nil)
-                .init_attributed_string(hello_string)
-                .autorelease();
-            attr_string.appendAttributedString_(hello_attr_string);
-
-            let attachment: id = msg_send![NSTextAttachment::alloc(nil), autorelease];
-            let _: () = msg_send![attachment, setImage: image];
-            let image_attr_string =
-                msg_send![class!(NSAttributedString), attributedStringWithAttachment: attachment];
-            attr_string.appendAttributedString_(image_attr_string);
-
-            let another_string = ns_string("Another String");
-            let another_attr_string = NSAttributedString::alloc(nil)
-                .init_attributed_string(another_string)
-                .autorelease();
-            attr_string.appendAttributedString_(another_attr_string);
-
-            let _len: cocoa::foundation::NSUInteger = msg_send![attr_string, length];
-
-            ///////////////////////////////////////////////////
-            // pasteboard.clearContents();
-
-            let rtfd_data = attr_string.RTFDFromRange_documentAttributes_(
-                NSRange::new(0, msg_send![attr_string, length]),
-                nil,
-            );
-            assert_ne!(rtfd_data, nil);
-            // if rtfd_data != nil {
-            //     pasteboard.setData_forType(rtfd_data, NSPasteboardTypeRTFD);
-            // }
-
-            // let rtf_data = attributed_string.RTFFromRange_documentAttributes_(
-            //     NSRange::new(0, attributed_string.length()),
-            //     nil,
-            // );
-            // if rtf_data != nil {
-            //     pasteboard.setData_forType(rtf_data, NSPasteboardTypeRTF);
-            // }
-
-            // let plain_text = attributed_string.string();
-            // pasteboard.setString_forType(plain_text, NSPasteboardTypeString);
-        }
-    }
-}
diff --git a/crates/gpui/src/platform/mac/pasteboard.rs b/crates/gpui/src/platform/mac/pasteboard.rs
new file mode 100644
index 0000000000000000000000000000000000000000..38710951f15b25515d906afc738c5b971b1bb135
--- /dev/null
+++ b/crates/gpui/src/platform/mac/pasteboard.rs
@@ -0,0 +1,344 @@
+use core::slice;
+use std::ffi::c_void;
+
+use cocoa::{
+    appkit::{NSPasteboard, NSPasteboardTypePNG, NSPasteboardTypeString, NSPasteboardTypeTIFF},
+    base::{id, nil},
+    foundation::NSData,
+};
+use objc::{msg_send, runtime::Object, sel, sel_impl};
+use strum::IntoEnumIterator as _;
+
+use crate::{
+    ClipboardEntry, ClipboardItem, ClipboardString, Image, ImageFormat, asset_cache::hash,
+    platform::mac::ns_string,
+};
+
+pub struct Pasteboard {
+    inner: id,
+    text_hash_type: id,
+    metadata_type: id,
+}
+
+impl Pasteboard {
+    pub fn general() -> Self {
+        unsafe { Self::new(NSPasteboard::generalPasteboard(nil)) }
+    }
+
+    pub fn find() -> Self {
+        unsafe { Self::new(NSPasteboard::pasteboardWithName(nil, NSPasteboardNameFind)) }
+    }
+
+    #[cfg(test)]
+    pub fn unique() -> Self {
+        unsafe { Self::new(NSPasteboard::pasteboardWithUniqueName(nil)) }
+    }
+
+    unsafe fn new(inner: id) -> Self {
+        Self {
+            inner,
+            text_hash_type: unsafe { ns_string("zed-text-hash") },
+            metadata_type: unsafe { ns_string("zed-metadata") },
+        }
+    }
+
+    pub fn read(&self) -> Option {
+        // First, see if it's a string.
+        unsafe {
+            let pasteboard_types: id = self.inner.types();
+            let string_type: id = ns_string("public.utf8-plain-text");
+
+            if msg_send![pasteboard_types, containsObject: string_type] {
+                let data = self.inner.dataForType(string_type);
+                if data == nil {
+                    return None;
+                } else if data.bytes().is_null() {
+                    // https://developer.apple.com/documentation/foundation/nsdata/1410616-bytes?language=objc
+                    // "If the length of the NSData object is 0, this property returns nil."
+                    return Some(self.read_string(&[]));
+                } else {
+                    let bytes =
+                        slice::from_raw_parts(data.bytes() as *mut u8, data.length() as usize);
+
+                    return Some(self.read_string(bytes));
+                }
+            }
+
+            // If it wasn't a string, try the various supported image types.
+            for format in ImageFormat::iter() {
+                if let Some(item) = self.read_image(format) {
+                    return Some(item);
+                }
+            }
+        }
+
+        // If it wasn't a string or a supported image type, give up.
+        None
+    }
+
+    fn read_image(&self, format: ImageFormat) -> Option {
+        let mut ut_type: UTType = format.into();
+
+        unsafe {
+            let types: id = self.inner.types();
+            if msg_send![types, containsObject: ut_type.inner()] {
+                self.data_for_type(ut_type.inner_mut()).map(|bytes| {
+                    let bytes = bytes.to_vec();
+                    let id = hash(&bytes);
+
+                    ClipboardItem {
+                        entries: vec![ClipboardEntry::Image(Image { format, bytes, id })],
+                    }
+                })
+            } else {
+                None
+            }
+        }
+    }
+
+    fn read_string(&self, text_bytes: &[u8]) -> ClipboardItem {
+        unsafe {
+            let text = String::from_utf8_lossy(text_bytes).to_string();
+            let metadata = self
+                .data_for_type(self.text_hash_type)
+                .and_then(|hash_bytes| {
+                    let hash_bytes = hash_bytes.try_into().ok()?;
+                    let hash = u64::from_be_bytes(hash_bytes);
+                    let metadata = self.data_for_type(self.metadata_type)?;
+
+                    if hash == ClipboardString::text_hash(&text) {
+                        String::from_utf8(metadata.to_vec()).ok()
+                    } else {
+                        None
+                    }
+                });
+
+            ClipboardItem {
+                entries: vec![ClipboardEntry::String(ClipboardString { text, metadata })],
+            }
+        }
+    }
+
+    unsafe fn data_for_type(&self, kind: id) -> Option<&[u8]> {
+        unsafe {
+            let data = self.inner.dataForType(kind);
+            if data == nil {
+                None
+            } else {
+                Some(slice::from_raw_parts(
+                    data.bytes() as *mut u8,
+                    data.length() as usize,
+                ))
+            }
+        }
+    }
+
+    pub fn write(&self, item: ClipboardItem) {
+        unsafe {
+            match item.entries.as_slice() {
+                [] => {
+                    // Writing an empty list of entries just clears the clipboard.
+                    self.inner.clearContents();
+                }
+                [ClipboardEntry::String(string)] => {
+                    self.write_plaintext(string);
+                }
+                [ClipboardEntry::Image(image)] => {
+                    self.write_image(image);
+                }
+                [ClipboardEntry::ExternalPaths(_)] => {}
+                _ => {
+                    // Agus NB: We're currently only writing string entries to the clipboard when we have more than one.
+                    //
+                    // This was the existing behavior before I refactored the outer clipboard code:
+                    // https://github.com/zed-industries/zed/blob/65f7412a0265552b06ce122655369d6cc7381dd6/crates/gpui/src/platform/mac/platform.rs#L1060-L1110
+                    //
+                    // Note how `any_images` is always `false`. We should fix that, but that's orthogonal to the refactor.
+
+                    let mut combined = ClipboardString {
+                        text: String::new(),
+                        metadata: None,
+                    };
+
+                    for entry in item.entries {
+                        match entry {
+                            ClipboardEntry::String(text) => {
+                                combined.text.push_str(&text.text());
+                                if combined.metadata.is_none() {
+                                    combined.metadata = text.metadata;
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+
+                    self.write_plaintext(&combined);
+                }
+            }
+        }
+    }
+
+    fn write_plaintext(&self, string: &ClipboardString) {
+        unsafe {
+            self.inner.clearContents();
+
+            let text_bytes = NSData::dataWithBytes_length_(
+                nil,
+                string.text.as_ptr() as *const c_void,
+                string.text.len() as u64,
+            );
+            self.inner
+                .setData_forType(text_bytes, NSPasteboardTypeString);
+
+            if let Some(metadata) = string.metadata.as_ref() {
+                let hash_bytes = ClipboardString::text_hash(&string.text).to_be_bytes();
+                let hash_bytes = NSData::dataWithBytes_length_(
+                    nil,
+                    hash_bytes.as_ptr() as *const c_void,
+                    hash_bytes.len() as u64,
+                );
+                self.inner.setData_forType(hash_bytes, self.text_hash_type);
+
+                let metadata_bytes = NSData::dataWithBytes_length_(
+                    nil,
+                    metadata.as_ptr() as *const c_void,
+                    metadata.len() as u64,
+                );
+                self.inner
+                    .setData_forType(metadata_bytes, self.metadata_type);
+            }
+        }
+    }
+
+    unsafe fn write_image(&self, image: &Image) {
+        unsafe {
+            self.inner.clearContents();
+
+            let bytes = NSData::dataWithBytes_length_(
+                nil,
+                image.bytes.as_ptr() as *const c_void,
+                image.bytes.len() as u64,
+            );
+
+            self.inner
+                .setData_forType(bytes, Into::::into(image.format).inner_mut());
+        }
+    }
+}
+
+#[link(name = "AppKit", kind = "framework")]
+unsafe extern "C" {
+    /// [Apple's documentation](https://developer.apple.com/documentation/appkit/nspasteboardnamefind?language=objc)
+    pub static NSPasteboardNameFind: id;
+}
+
+impl From for UTType {
+    fn from(value: ImageFormat) -> Self {
+        match value {
+            ImageFormat::Png => Self::png(),
+            ImageFormat::Jpeg => Self::jpeg(),
+            ImageFormat::Tiff => Self::tiff(),
+            ImageFormat::Webp => Self::webp(),
+            ImageFormat::Gif => Self::gif(),
+            ImageFormat::Bmp => Self::bmp(),
+            ImageFormat::Svg => Self::svg(),
+            ImageFormat::Ico => Self::ico(),
+        }
+    }
+}
+
+// See https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/
+pub struct UTType(id);
+
+impl UTType {
+    pub fn png() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/png
+        Self(unsafe { NSPasteboardTypePNG }) // This is a rare case where there's a built-in NSPasteboardType
+    }
+
+    pub fn jpeg() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/jpeg
+        Self(unsafe { ns_string("public.jpeg") })
+    }
+
+    pub fn gif() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/gif
+        Self(unsafe { ns_string("com.compuserve.gif") })
+    }
+
+    pub fn webp() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/webp
+        Self(unsafe { ns_string("org.webmproject.webp") })
+    }
+
+    pub fn bmp() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/bmp
+        Self(unsafe { ns_string("com.microsoft.bmp") })
+    }
+
+    pub fn svg() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/svg
+        Self(unsafe { ns_string("public.svg-image") })
+    }
+
+    pub fn ico() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/ico
+        Self(unsafe { ns_string("com.microsoft.ico") })
+    }
+
+    pub fn tiff() -> Self {
+        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/tiff
+        Self(unsafe { NSPasteboardTypeTIFF }) // This is a rare case where there's a built-in NSPasteboardType
+    }
+
+    fn inner(&self) -> *const Object {
+        self.0
+    }
+
+    pub fn inner_mut(&self) -> *mut Object {
+        self.0 as *mut _
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use cocoa::{appkit::NSPasteboardTypeString, foundation::NSData};
+
+    use crate::{ClipboardEntry, ClipboardItem, ClipboardString};
+
+    use super::*;
+
+    #[test]
+    fn test_string() {
+        let pasteboard = Pasteboard::unique();
+        assert_eq!(pasteboard.read(), None);
+
+        let item = ClipboardItem::new_string("1".to_string());
+        pasteboard.write(item.clone());
+        assert_eq!(pasteboard.read(), Some(item));
+
+        let item = ClipboardItem {
+            entries: vec![ClipboardEntry::String(
+                ClipboardString::new("2".to_string()).with_json_metadata(vec![3, 4]),
+            )],
+        };
+        pasteboard.write(item.clone());
+        assert_eq!(pasteboard.read(), Some(item));
+
+        let text_from_other_app = "text from other app";
+        unsafe {
+            let bytes = NSData::dataWithBytes_length_(
+                nil,
+                text_from_other_app.as_ptr() as *const c_void,
+                text_from_other_app.len() as u64,
+            );
+            pasteboard
+                .inner
+                .setData_forType(bytes, NSPasteboardTypeString);
+        }
+        assert_eq!(
+            pasteboard.read(),
+            Some(ClipboardItem::new_string(text_from_other_app.to_string()))
+        );
+    }
+}
diff --git a/crates/gpui/src/platform/mac/platform.rs b/crates/gpui/src/platform/mac/platform.rs
index ee67f465e34bd8109246f68b311e225aa8f9fd0a..9b32c6735bf6215fecc0455defc4237fd25e8cb0 100644
--- a/crates/gpui/src/platform/mac/platform.rs
+++ b/crates/gpui/src/platform/mac/platform.rs
@@ -1,29 +1,24 @@
 use super::{
-    BoolExt, MacKeyboardLayout, MacKeyboardMapper,
-    attributed_string::{NSAttributedString, NSMutableAttributedString},
-    events::key_to_native,
-    ns_string, renderer,
+    BoolExt, MacKeyboardLayout, MacKeyboardMapper, events::key_to_native, ns_string, renderer,
 };
 use crate::{
-    Action, AnyWindowHandle, BackgroundExecutor, ClipboardEntry, ClipboardItem, ClipboardString,
-    CursorStyle, ForegroundExecutor, Image, ImageFormat, KeyContext, Keymap, MacDispatcher,
-    MacDisplay, MacWindow, Menu, MenuItem, OsMenu, OwnedMenu, PathPromptOptions, Platform,
-    PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem,
-    PlatformWindow, Result, SystemMenuType, Task, WindowAppearance, WindowParams, hash,
+    Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, ForegroundExecutor,
+    KeyContext, Keymap, MacDispatcher, MacDisplay, MacWindow, Menu, MenuItem, OsMenu, OwnedMenu,
+    PathPromptOptions, Platform, PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper,
+    PlatformTextSystem, PlatformWindow, Result, SystemMenuType, Task, WindowAppearance,
+    WindowParams, platform::mac::pasteboard::Pasteboard,
 };
 use anyhow::{Context as _, anyhow};
 use block::ConcreteBlock;
 use cocoa::{
     appkit::{
         NSApplication, NSApplicationActivationPolicy::NSApplicationActivationPolicyRegular,
-        NSEventModifierFlags, NSMenu, NSMenuItem, NSModalResponse, NSOpenPanel, NSPasteboard,
-        NSPasteboardTypePNG, NSPasteboardTypeRTF, NSPasteboardTypeRTFD, NSPasteboardTypeString,
-        NSPasteboardTypeTIFF, NSSavePanel, NSVisualEffectState, NSVisualEffectView, NSWindow,
+        NSEventModifierFlags, NSMenu, NSMenuItem, NSModalResponse, NSOpenPanel, NSSavePanel,
+        NSVisualEffectState, NSVisualEffectView, NSWindow,
     },
     base::{BOOL, NO, YES, id, nil, selector},
     foundation::{
-        NSArray, NSAutoreleasePool, NSBundle, NSData, NSInteger, NSProcessInfo, NSRange, NSString,
-        NSUInteger, NSURL,
+        NSArray, NSAutoreleasePool, NSBundle, NSInteger, NSProcessInfo, NSString, NSUInteger, NSURL,
     },
 };
 use core_foundation::{
@@ -49,7 +44,6 @@ use ptr::null_mut;
 use semver::Version;
 use std::{
     cell::Cell,
-    convert::TryInto,
     ffi::{CStr, OsStr, c_void},
     os::{raw::c_char, unix::ffi::OsStrExt},
     path::{Path, PathBuf},
@@ -58,7 +52,6 @@ use std::{
     slice, str,
     sync::{Arc, OnceLock},
 };
-use strum::IntoEnumIterator;
 use util::{
     ResultExt,
     command::{new_smol_command, new_std_command},
@@ -164,9 +157,8 @@ pub(crate) struct MacPlatformState {
     text_system: Arc,
     renderer_context: renderer::Context,
     headless: bool,
-    pasteboard: id,
-    text_hash_pasteboard_type: id,
-    metadata_pasteboard_type: id,
+    general_pasteboard: Pasteboard,
+    find_pasteboard: Pasteboard,
     reopen: Option>,
     on_keyboard_layout_change: Option>,
     quit: Option>,
@@ -206,9 +198,8 @@ impl MacPlatform {
             background_executor: BackgroundExecutor::new(dispatcher.clone()),
             foreground_executor: ForegroundExecutor::new(dispatcher),
             renderer_context: renderer::Context::default(),
-            pasteboard: unsafe { NSPasteboard::generalPasteboard(nil) },
-            text_hash_pasteboard_type: unsafe { ns_string("zed-text-hash") },
-            metadata_pasteboard_type: unsafe { ns_string("zed-metadata") },
+            general_pasteboard: Pasteboard::general(),
+            find_pasteboard: Pasteboard::find(),
             reopen: None,
             quit: None,
             menu_command: None,
@@ -224,20 +215,6 @@ impl MacPlatform {
         }))
     }
 
-    unsafe fn read_from_pasteboard(&self, pasteboard: *mut Object, kind: id) -> Option<&[u8]> {
-        unsafe {
-            let data = pasteboard.dataForType(kind);
-            if data == nil {
-                None
-            } else {
-                Some(slice::from_raw_parts(
-                    data.bytes() as *mut u8,
-                    data.length() as usize,
-                ))
-            }
-        }
-    }
-
     unsafe fn create_menu_bar(
         &self,
         menus: &Vec,
@@ -1034,119 +1011,24 @@ impl Platform for MacPlatform {
         }
     }
 
-    fn write_to_clipboard(&self, item: ClipboardItem) {
-        use crate::ClipboardEntry;
-
-        unsafe {
-            // We only want to use NSAttributedString if there are multiple entries to write.
-            if item.entries.len() <= 1 {
-                match item.entries.first() {
-                    Some(entry) => match entry {
-                        ClipboardEntry::String(string) => {
-                            self.write_plaintext_to_clipboard(string);
-                        }
-                        ClipboardEntry::Image(image) => {
-                            self.write_image_to_clipboard(image);
-                        }
-                        ClipboardEntry::ExternalPaths(_) => {}
-                    },
-                    None => {
-                        // Writing an empty list of entries just clears the clipboard.
-                        let state = self.0.lock();
-                        state.pasteboard.clearContents();
-                    }
-                }
-            } else {
-                let mut any_images = false;
-                let attributed_string = {
-                    let mut buf = NSMutableAttributedString::alloc(nil)
-                        // TODO can we skip this? Or at least part of it?
-                        .init_attributed_string(ns_string(""))
-                        .autorelease();
-
-                    for entry in item.entries {
-                        if let ClipboardEntry::String(ClipboardString { text, metadata: _ }) = entry
-                        {
-                            let to_append = NSAttributedString::alloc(nil)
-                                .init_attributed_string(ns_string(&text))
-                                .autorelease();
-
-                            buf.appendAttributedString_(to_append);
-                        }
-                    }
-
-                    buf
-                };
-
-                let state = self.0.lock();
-                state.pasteboard.clearContents();
-
-                // Only set rich text clipboard types if we actually have 1+ images to include.
-                if any_images {
-                    let rtfd_data = attributed_string.RTFDFromRange_documentAttributes_(
-                        NSRange::new(0, msg_send![attributed_string, length]),
-                        nil,
-                    );
-                    if rtfd_data != nil {
-                        state
-                            .pasteboard
-                            .setData_forType(rtfd_data, NSPasteboardTypeRTFD);
-                    }
-
-                    let rtf_data = attributed_string.RTFFromRange_documentAttributes_(
-                        NSRange::new(0, attributed_string.length()),
-                        nil,
-                    );
-                    if rtf_data != nil {
-                        state
-                            .pasteboard
-                            .setData_forType(rtf_data, NSPasteboardTypeRTF);
-                    }
-                }
-
-                let plain_text = attributed_string.string();
-                state
-                    .pasteboard
-                    .setString_forType(plain_text, NSPasteboardTypeString);
-            }
-        }
-    }
-
     fn read_from_clipboard(&self) -> Option {
         let state = self.0.lock();
-        let pasteboard = state.pasteboard;
-
-        // First, see if it's a string.
-        unsafe {
-            let types: id = pasteboard.types();
-            let string_type: id = ns_string("public.utf8-plain-text");
-
-            if msg_send![types, containsObject: string_type] {
-                let data = pasteboard.dataForType(string_type);
-                if data == nil {
-                    return None;
-                } else if data.bytes().is_null() {
-                    // https://developer.apple.com/documentation/foundation/nsdata/1410616-bytes?language=objc
-                    // "If the length of the NSData object is 0, this property returns nil."
-                    return Some(self.read_string_from_clipboard(&state, &[]));
-                } else {
-                    let bytes =
-                        slice::from_raw_parts(data.bytes() as *mut u8, data.length() as usize);
+        state.general_pasteboard.read()
+    }
 
-                    return Some(self.read_string_from_clipboard(&state, bytes));
-                }
-            }
+    fn write_to_clipboard(&self, item: ClipboardItem) {
+        let state = self.0.lock();
+        state.general_pasteboard.write(item);
+    }
 
-            // If it wasn't a string, try the various supported image types.
-            for format in ImageFormat::iter() {
-                if let Some(item) = try_clipboard_image(pasteboard, format) {
-                    return Some(item);
-                }
-            }
-        }
+    fn read_from_find_pasteboard(&self) -> Option {
+        let state = self.0.lock();
+        state.find_pasteboard.read()
+    }
 
-        // If it wasn't a string or a supported image type, give up.
-        None
+    fn write_to_find_pasteboard(&self, item: ClipboardItem) {
+        let state = self.0.lock();
+        state.find_pasteboard.write(item);
     }
 
     fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task> {
@@ -1255,116 +1137,6 @@ impl Platform for MacPlatform {
     }
 }
 
-impl MacPlatform {
-    unsafe fn read_string_from_clipboard(
-        &self,
-        state: &MacPlatformState,
-        text_bytes: &[u8],
-    ) -> ClipboardItem {
-        unsafe {
-            let text = String::from_utf8_lossy(text_bytes).to_string();
-            let metadata = self
-                .read_from_pasteboard(state.pasteboard, state.text_hash_pasteboard_type)
-                .and_then(|hash_bytes| {
-                    let hash_bytes = hash_bytes.try_into().ok()?;
-                    let hash = u64::from_be_bytes(hash_bytes);
-                    let metadata = self
-                        .read_from_pasteboard(state.pasteboard, state.metadata_pasteboard_type)?;
-
-                    if hash == ClipboardString::text_hash(&text) {
-                        String::from_utf8(metadata.to_vec()).ok()
-                    } else {
-                        None
-                    }
-                });
-
-            ClipboardItem {
-                entries: vec![ClipboardEntry::String(ClipboardString { text, metadata })],
-            }
-        }
-    }
-
-    unsafe fn write_plaintext_to_clipboard(&self, string: &ClipboardString) {
-        unsafe {
-            let state = self.0.lock();
-            state.pasteboard.clearContents();
-
-            let text_bytes = NSData::dataWithBytes_length_(
-                nil,
-                string.text.as_ptr() as *const c_void,
-                string.text.len() as u64,
-            );
-            state
-                .pasteboard
-                .setData_forType(text_bytes, NSPasteboardTypeString);
-
-            if let Some(metadata) = string.metadata.as_ref() {
-                let hash_bytes = ClipboardString::text_hash(&string.text).to_be_bytes();
-                let hash_bytes = NSData::dataWithBytes_length_(
-                    nil,
-                    hash_bytes.as_ptr() as *const c_void,
-                    hash_bytes.len() as u64,
-                );
-                state
-                    .pasteboard
-                    .setData_forType(hash_bytes, state.text_hash_pasteboard_type);
-
-                let metadata_bytes = NSData::dataWithBytes_length_(
-                    nil,
-                    metadata.as_ptr() as *const c_void,
-                    metadata.len() as u64,
-                );
-                state
-                    .pasteboard
-                    .setData_forType(metadata_bytes, state.metadata_pasteboard_type);
-            }
-        }
-    }
-
-    unsafe fn write_image_to_clipboard(&self, image: &Image) {
-        unsafe {
-            let state = self.0.lock();
-            state.pasteboard.clearContents();
-
-            let bytes = NSData::dataWithBytes_length_(
-                nil,
-                image.bytes.as_ptr() as *const c_void,
-                image.bytes.len() as u64,
-            );
-
-            state
-                .pasteboard
-                .setData_forType(bytes, Into::::into(image.format).inner_mut());
-        }
-    }
-}
-
-fn try_clipboard_image(pasteboard: id, format: ImageFormat) -> Option {
-    let mut ut_type: UTType = format.into();
-
-    unsafe {
-        let types: id = pasteboard.types();
-        if msg_send![types, containsObject: ut_type.inner()] {
-            let data = pasteboard.dataForType(ut_type.inner_mut());
-            if data == nil {
-                None
-            } else {
-                let bytes = Vec::from(slice::from_raw_parts(
-                    data.bytes() as *mut u8,
-                    data.length() as usize,
-                ));
-                let id = hash(&bytes);
-
-                Some(ClipboardItem {
-                    entries: vec![ClipboardEntry::Image(Image { format, bytes, id })],
-                })
-            }
-        } else {
-            None
-        }
-    }
-}
-
 unsafe fn path_from_objc(path: id) -> PathBuf {
     let len = msg_send![path, lengthOfBytesUsingEncoding: NSUTF8StringEncoding];
     let bytes = unsafe { path.UTF8String() as *const u8 };
@@ -1605,120 +1377,3 @@ mod security {
     pub const errSecUserCanceled: OSStatus = -128;
     pub const errSecItemNotFound: OSStatus = -25300;
 }
-
-impl From for UTType {
-    fn from(value: ImageFormat) -> Self {
-        match value {
-            ImageFormat::Png => Self::png(),
-            ImageFormat::Jpeg => Self::jpeg(),
-            ImageFormat::Tiff => Self::tiff(),
-            ImageFormat::Webp => Self::webp(),
-            ImageFormat::Gif => Self::gif(),
-            ImageFormat::Bmp => Self::bmp(),
-            ImageFormat::Svg => Self::svg(),
-            ImageFormat::Ico => Self::ico(),
-        }
-    }
-}
-
-// See https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/
-struct UTType(id);
-
-impl UTType {
-    pub fn png() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/png
-        Self(unsafe { NSPasteboardTypePNG }) // This is a rare case where there's a built-in NSPasteboardType
-    }
-
-    pub fn jpeg() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/jpeg
-        Self(unsafe { ns_string("public.jpeg") })
-    }
-
-    pub fn gif() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/gif
-        Self(unsafe { ns_string("com.compuserve.gif") })
-    }
-
-    pub fn webp() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/webp
-        Self(unsafe { ns_string("org.webmproject.webp") })
-    }
-
-    pub fn bmp() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/bmp
-        Self(unsafe { ns_string("com.microsoft.bmp") })
-    }
-
-    pub fn svg() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/svg
-        Self(unsafe { ns_string("public.svg-image") })
-    }
-
-    pub fn ico() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/ico
-        Self(unsafe { ns_string("com.microsoft.ico") })
-    }
-
-    pub fn tiff() -> Self {
-        // https://developer.apple.com/documentation/uniformtypeidentifiers/uttype-swift.struct/tiff
-        Self(unsafe { NSPasteboardTypeTIFF }) // This is a rare case where there's a built-in NSPasteboardType
-    }
-
-    fn inner(&self) -> *const Object {
-        self.0
-    }
-
-    fn inner_mut(&self) -> *mut Object {
-        self.0 as *mut _
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::ClipboardItem;
-
-    use super::*;
-
-    #[test]
-    fn test_clipboard() {
-        let platform = build_platform();
-        assert_eq!(platform.read_from_clipboard(), None);
-
-        let item = ClipboardItem::new_string("1".to_string());
-        platform.write_to_clipboard(item.clone());
-        assert_eq!(platform.read_from_clipboard(), Some(item));
-
-        let item = ClipboardItem {
-            entries: vec![ClipboardEntry::String(
-                ClipboardString::new("2".to_string()).with_json_metadata(vec![3, 4]),
-            )],
-        };
-        platform.write_to_clipboard(item.clone());
-        assert_eq!(platform.read_from_clipboard(), Some(item));
-
-        let text_from_other_app = "text from other app";
-        unsafe {
-            let bytes = NSData::dataWithBytes_length_(
-                nil,
-                text_from_other_app.as_ptr() as *const c_void,
-                text_from_other_app.len() as u64,
-            );
-            platform
-                .0
-                .lock()
-                .pasteboard
-                .setData_forType(bytes, NSPasteboardTypeString);
-        }
-        assert_eq!(
-            platform.read_from_clipboard(),
-            Some(ClipboardItem::new_string(text_from_other_app.to_string()))
-        );
-    }
-
-    fn build_platform() -> MacPlatform {
-        let platform = MacPlatform::new(false);
-        platform.0.lock().pasteboard = unsafe { NSPasteboard::pasteboardWithUniqueName(nil) };
-        platform
-    }
-}
diff --git a/crates/gpui/src/platform/test/platform.rs b/crates/gpui/src/platform/test/platform.rs
index dfada364667989792325e02f8530e6c91bdf4716..ca9d5e2c3b7d405e40f208f5406f879467eafc5c 100644
--- a/crates/gpui/src/platform/test/platform.rs
+++ b/crates/gpui/src/platform/test/platform.rs
@@ -32,6 +32,8 @@ pub(crate) struct TestPlatform {
     current_clipboard_item: Mutex>,
     #[cfg(any(target_os = "linux", target_os = "freebsd"))]
     current_primary_item: Mutex>,
+    #[cfg(target_os = "macos")]
+    current_find_pasteboard_item: Mutex>,
     pub(crate) prompts: RefCell,
     screen_capture_sources: RefCell>,
     pub opened_url: RefCell>,
@@ -117,6 +119,8 @@ impl TestPlatform {
             current_clipboard_item: Mutex::new(None),
             #[cfg(any(target_os = "linux", target_os = "freebsd"))]
             current_primary_item: Mutex::new(None),
+            #[cfg(target_os = "macos")]
+            current_find_pasteboard_item: Mutex::new(None),
             weak: weak.clone(),
             opened_url: Default::default(),
             #[cfg(target_os = "windows")]
@@ -398,9 +402,8 @@ impl Platform for TestPlatform {
         false
     }
 
-    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
-    fn write_to_primary(&self, item: ClipboardItem) {
-        *self.current_primary_item.lock() = Some(item);
+    fn read_from_clipboard(&self) -> Option {
+        self.current_clipboard_item.lock().clone()
     }
 
     fn write_to_clipboard(&self, item: ClipboardItem) {
@@ -412,8 +415,19 @@ impl Platform for TestPlatform {
         self.current_primary_item.lock().clone()
     }
 
-    fn read_from_clipboard(&self) -> Option {
-        self.current_clipboard_item.lock().clone()
+    #[cfg(any(target_os = "linux", target_os = "freebsd"))]
+    fn write_to_primary(&self, item: ClipboardItem) {
+        *self.current_primary_item.lock() = Some(item);
+    }
+
+    #[cfg(target_os = "macos")]
+    fn read_from_find_pasteboard(&self) -> Option {
+        self.current_find_pasteboard_item.lock().clone()
+    }
+
+    #[cfg(target_os = "macos")]
+    fn write_to_find_pasteboard(&self, item: ClipboardItem) {
+        *self.current_find_pasteboard_item.lock() = Some(item);
     }
 
     fn write_credentials(&self, _url: &str, _username: &str, _password: &[u8]) -> Task> {
diff --git a/crates/search/src/buffer_search.rs b/crates/search/src/buffer_search.rs
index 12b283ab22937b7952d18d63b1378d2914211f9b..be3331048bc78a91a8d3c5a3637d6bf6ea007e4d 100644
--- a/crates/search/src/buffer_search.rs
+++ b/crates/search/src/buffer_search.rs
@@ -106,7 +106,10 @@ pub struct BufferSearchBar {
     replacement_editor_focused: bool,
     active_searchable_item: Option>,
     active_match_index: Option,
-    active_searchable_item_subscription: Option,
+    #[cfg(target_os = "macos")]
+    active_searchable_item_subscriptions: Option<[Subscription; 2]>,
+    #[cfg(not(target_os = "macos"))]
+    active_searchable_item_subscriptions: Option,
     active_search: Option>,
     searchable_items_with_matches: HashMap, AnyVec>,
     pending_search: Option>,
@@ -472,7 +475,7 @@ impl ToolbarItemView for BufferSearchBar {
         cx: &mut Context,
     ) -> ToolbarItemLocation {
         cx.notify();
-        self.active_searchable_item_subscription.take();
+        self.active_searchable_item_subscriptions.take();
         self.active_searchable_item.take();
 
         self.pending_search.take();
@@ -482,18 +485,58 @@ impl ToolbarItemView for BufferSearchBar {
         {
             let this = cx.entity().downgrade();
 
-            self.active_searchable_item_subscription =
-                Some(searchable_item_handle.subscribe_to_search_events(
-                    window,
-                    cx,
-                    Box::new(move |search_event, window, cx| {
-                        if let Some(this) = this.upgrade() {
-                            this.update(cx, |this, cx| {
-                                this.on_active_searchable_item_event(search_event, window, cx)
-                            });
+            let search_event_subscription = searchable_item_handle.subscribe_to_search_events(
+                window,
+                cx,
+                Box::new(move |search_event, window, cx| {
+                    if let Some(this) = this.upgrade() {
+                        this.update(cx, |this, cx| {
+                            this.on_active_searchable_item_event(search_event, window, cx)
+                        });
+                    }
+                }),
+            );
+
+            #[cfg(target_os = "macos")]
+            {
+                let item_focus_handle = searchable_item_handle.item_focus_handle(cx);
+
+                self.active_searchable_item_subscriptions = Some([
+                    search_event_subscription,
+                    cx.on_focus(&item_focus_handle, window, |this, window, cx| {
+                        if this.query_editor_focused || this.replacement_editor_focused {
+                            // no need to read pasteboard since focus came from toolbar
+                            return;
                         }
+
+                        cx.defer_in(window, |this, window, cx| {
+                            if let Some(item) = cx.read_from_find_pasteboard()
+                                && let Some(text) = item.text()
+                            {
+                                if this.query(cx) != text {
+                                    let search_options = item
+                                        .metadata()
+                                        .and_then(|m| m.parse().ok())
+                                        .and_then(SearchOptions::from_bits)
+                                        .unwrap_or(this.search_options);
+
+                                    drop(this.search(
+                                        &text,
+                                        Some(search_options),
+                                        true,
+                                        window,
+                                        cx,
+                                    ));
+                                }
+                            }
+                        });
                     }),
-                ));
+                ]);
+            }
+            #[cfg(not(target_os = "macos"))]
+            {
+                self.active_searchable_item_subscriptions = Some(search_event_subscription);
+            }
 
             let is_project_search = searchable_item_handle.supported_options(cx).find_in_results;
             self.active_searchable_item = Some(searchable_item_handle);
@@ -663,7 +706,7 @@ impl BufferSearchBar {
             replacement_editor,
             replacement_editor_focused: false,
             active_searchable_item: None,
-            active_searchable_item_subscription: None,
+            active_searchable_item_subscriptions: None,
             active_match_index: None,
             searchable_items_with_matches: Default::default(),
             default_options: search_options,
@@ -904,11 +947,21 @@ impl BufferSearchBar {
             });
             self.set_search_options(options, cx);
             self.clear_matches(window, cx);
+            #[cfg(target_os = "macos")]
+            self.update_find_pasteboard(cx);
             cx.notify();
         }
         self.update_matches(!updated, add_to_history, window, cx)
     }
 
+    #[cfg(target_os = "macos")]
+    pub fn update_find_pasteboard(&mut self, cx: &mut App) {
+        cx.write_to_find_pasteboard(gpui::ClipboardItem::new_string_with_metadata(
+            self.query(cx),
+            self.search_options.bits().to_string(),
+        ));
+    }
+
     pub fn focus_editor(&mut self, _: &FocusEditor, window: &mut Window, cx: &mut Context) {
         if let Some(active_editor) = self.active_searchable_item.as_ref() {
             let handle = active_editor.item_focus_handle(cx);
@@ -1098,11 +1151,12 @@ impl BufferSearchBar {
                 cx.spawn_in(window, async move |this, cx| {
                     if search.await.is_ok() {
                         this.update_in(cx, |this, window, cx| {
-                            this.activate_current_match(window, cx)
-                        })
-                    } else {
-                        Ok(())
+                            this.activate_current_match(window, cx);
+                            #[cfg(target_os = "macos")]
+                            this.update_find_pasteboard(cx);
+                        })?;
                     }
+                    anyhow::Ok(())
                 })
                 .detach_and_log_err(cx);
             }
@@ -1293,6 +1347,7 @@ impl BufferSearchBar {
                                 .insert(active_searchable_item.downgrade(), matches);
 
                             this.update_match_index(window, cx);
+
                             if add_to_history {
                                 this.search_history
                                     .add(&mut this.search_history_cursor, query_text);

From 361b8e0ba9b11b68c456d43d03adabf53d7f54f0 Mon Sep 17 00:00:00 2001
From: Julia Ryan 
Date: Fri, 19 Dec 2025 09:04:15 -0800
Subject: [PATCH 238/266] Fix sticky header scroll offset (#45377)

Closes #43319

Release Notes:

- Sticky headers no longer obscure the cursor when it moves.

---------

Co-authored-by: HactarCE <6060305+HactarCE@users.noreply.github.com>
---
 crates/editor/src/scroll/autoscroll.rs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/crates/editor/src/scroll/autoscroll.rs b/crates/editor/src/scroll/autoscroll.rs
index 28fd9442193bbec663d3f72eaa805214375dd8ca..fc2ecb9205109532da2b43c97821b5352f27aff2 100644
--- a/crates/editor/src/scroll/autoscroll.rs
+++ b/crates/editor/src/scroll/autoscroll.rs
@@ -5,7 +5,7 @@ use crate::{
 };
 use gpui::{Bounds, Context, Pixels, Window};
 use language::Point;
-use multi_buffer::Anchor;
+use multi_buffer::{Anchor, ToPoint};
 use std::cmp;
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -186,6 +186,19 @@ impl Editor {
             }
         }
 
+        let style = self.style(cx).clone();
+        let sticky_headers = self.sticky_headers(&style, cx).unwrap_or_default();
+        let visible_sticky_headers = sticky_headers
+            .iter()
+            .filter(|h| {
+                let buffer_snapshot = display_map.buffer_snapshot();
+                let buffer_range =
+                    h.range.start.to_point(buffer_snapshot)..h.range.end.to_point(buffer_snapshot);
+
+                buffer_range.contains(&Point::new(target_top as u32, 0))
+            })
+            .count();
+
         let margin = if matches!(self.mode, EditorMode::AutoHeight { .. }) {
             0.
         } else {
@@ -218,7 +231,7 @@ impl Editor {
         let was_autoscrolled = match strategy {
             AutoscrollStrategy::Fit | AutoscrollStrategy::Newest => {
                 let margin = margin.min(self.scroll_manager.vertical_scroll_margin);
-                let target_top = (target_top - margin).max(0.0);
+                let target_top = (target_top - margin - visible_sticky_headers as f64).max(0.0);
                 let target_bottom = target_bottom + margin;
                 let start_row = scroll_position.y;
                 let end_row = start_row + visible_lines;

From bfe3c66c3e38b79b7c24f94e0dcf4cf781a6dbd5 Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 11:19:12 -0600
Subject: [PATCH 239/266] docs: Automatic Documentation Github Action using
 Droid (#45374)

Adds a multi-step agentic loop to github actions for opening a
once-daily documentation PR that can be merged only be a Zedi

Release Notes:

- N/A

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .../prompts/docs-automation/phase2-explore.md |  55 +++
 .../prompts/docs-automation/phase3-analyze.md |  57 +++
 .../prompts/docs-automation/phase4-plan.md    |  76 ++++
 .../prompts/docs-automation/phase5-apply.md   |  67 ++++
 .../docs-automation/phase6-summarize.md       |  54 +++
 .../prompts/docs-automation/phase7-commit.md  |  67 ++++
 .github/workflows/docs_automation.yml         | 256 +++++++++++++
 docs/AGENTS.md                                | 353 ++++++++++++++++++
 8 files changed, 985 insertions(+)
 create mode 100644 .factory/prompts/docs-automation/phase2-explore.md
 create mode 100644 .factory/prompts/docs-automation/phase3-analyze.md
 create mode 100644 .factory/prompts/docs-automation/phase4-plan.md
 create mode 100644 .factory/prompts/docs-automation/phase5-apply.md
 create mode 100644 .factory/prompts/docs-automation/phase6-summarize.md
 create mode 100644 .factory/prompts/docs-automation/phase7-commit.md
 create mode 100644 .github/workflows/docs_automation.yml
 create mode 100644 docs/AGENTS.md

diff --git a/.factory/prompts/docs-automation/phase2-explore.md b/.factory/prompts/docs-automation/phase2-explore.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8f0b1861912f9665d70e42dd02e1bb8a398b01e
--- /dev/null
+++ b/.factory/prompts/docs-automation/phase2-explore.md
@@ -0,0 +1,55 @@
+# Phase 2: Explore Repository
+
+You are analyzing a codebase to understand its structure before reviewing documentation impact.
+
+## Objective
+Produce a structured overview of the repository to inform subsequent documentation analysis.
+
+## Instructions
+
+1. **Identify Primary Languages and Frameworks**
+   - Scan for Cargo.toml, package.json, or other manifest files
+   - Note the primary language(s) and key dependencies
+
+2. **Map Documentation Structure**
+   - This project uses **mdBook** (https://rust-lang.github.io/mdBook/)
+   - Documentation is in `docs/src/`
+   - Table of contents: `docs/src/SUMMARY.md` (mdBook format: https://rust-lang.github.io/mdBook/format/summary.html)
+   - Style guide: `docs/.rules`
+   - Agent guidelines: `docs/AGENTS.md`
+   - Formatting: Prettier (config in `docs/.prettierrc`)
+
+3. **Identify Build and Tooling**
+   - Note build systems (cargo, npm, etc.)
+   - Identify documentation tooling (mdbook, etc.)
+
+4. **Output Format**
+Produce a JSON summary:
+
+```json
+{
+  "primary_language": "Rust",
+  "frameworks": ["GPUI"],
+  "documentation": {
+    "system": "mdBook",
+    "location": "docs/src/",
+    "toc_file": "docs/src/SUMMARY.md",
+    "toc_format": "https://rust-lang.github.io/mdBook/format/summary.html",
+    "style_guide": "docs/.rules",
+    "agent_guidelines": "docs/AGENTS.md",
+    "formatter": "prettier",
+    "formatter_config": "docs/.prettierrc",
+    "custom_preprocessor": "docs_preprocessor (handles {#kb action::Name} syntax)"
+  },
+  "key_directories": {
+    "source": "crates/",
+    "docs": "docs/src/",
+    "extensions": "extensions/"
+  }
+}
+```
+
+## Constraints
+- Read-only: Do not modify any files
+- Focus on structure, not content details
+- Complete within 2 minutes
diff --git a/.factory/prompts/docs-automation/phase3-analyze.md b/.factory/prompts/docs-automation/phase3-analyze.md
new file mode 100644
index 0000000000000000000000000000000000000000..8fc8622434d3be2e6be7997e9773c1b2435202c6
--- /dev/null
+++ b/.factory/prompts/docs-automation/phase3-analyze.md
@@ -0,0 +1,57 @@
+# Phase 3: Analyze Changes
+
+You are analyzing code changes to understand their nature and scope.
+
+## Objective
+Produce a clear, neutral summary of what changed in the codebase.
+
+## Input
+You will receive:
+- List of changed files from the triggering commit/PR
+- Repository structure from Phase 2
+
+## Instructions
+
+1. **Categorize Changed Files**
+   - Source code (which crates/modules)
+   - Configuration
+   - Tests
+   - Documentation (already existing)
+   - Other
+
+2. **Analyze Each Change**
+   - Review diffs for files likely to impact documentation
+   - Focus on: public APIs, settings, keybindings, commands, user-visible behavior
+
+3. **Identify What Did NOT Change**
+   - Note stable interfaces or behaviors
+   - Important for avoiding unnecessary documentation updates
+
+4. **Output Format**
+Produce a markdown summary:
+
+```markdown
+## Change Analysis
+
+### Changed Files Summary
+| Category | Files | Impact Level |
+| --- | --- | --- |
+| Source - [crate] | file1.rs, file2.rs | High/Medium/Low |
+| Settings | settings.json | Medium |
+| Tests | test_*.rs | None |
+
+### Behavioral Changes
+- **[Feature/Area]**: Description of what changed from user perspective
+- **[Feature/Area]**: Description...
+
+### Unchanged Areas
+- [Area]: Confirmed no changes to [specific behavior]
+
+### Files Requiring Deeper Review
+- `path/to/file.rs`: Reason for deeper review
+```
+
+## Constraints
+- Read-only: Do not modify any files
+- Neutral tone: Describe what changed, not whether it's good/bad
+- Do not propose documentation changes yet
diff --git a/.factory/prompts/docs-automation/phase4-plan.md b/.factory/prompts/docs-automation/phase4-plan.md
new file mode 100644
index 0000000000000000000000000000000000000000..9e6a15814e7813cbf27afb0413987afa539feaf6
--- /dev/null
+++ b/.factory/prompts/docs-automation/phase4-plan.md
@@ -0,0 +1,76 @@
+# Phase 4: Plan Documentation Impact
+
+You are determining whether and how documentation should be updated based on code changes.
+
+## Objective
+Produce a structured documentation plan that will guide Phase 5 execution.
+
+## Documentation System
+This is an **mdBook** site (https://rust-lang.github.io/mdBook/):
+- `docs/src/SUMMARY.md` defines book structure per https://rust-lang.github.io/mdBook/format/summary.html
+- If adding new pages, they MUST be added to SUMMARY.md
+- Use `{#kb action::ActionName}` syntax for keybindings (custom preprocessor expands these)
+- Prettier formatting (80 char width) will be applied automatically
+
+## Input
+You will receive:
+- Change analysis from Phase 3
+- Repository structure from Phase 2
+- Documentation guidelines from `docs/AGENTS.md`
+
+## Instructions
+
+1. **Review AGENTS.md**
+   - Load and apply all rules from `docs/AGENTS.md`
+   - Respect scope boundaries (in-scope vs out-of-scope)
+
+2. **Evaluate Documentation Impact**
+   For each behavioral change from Phase 3:
+   - Does existing documentation cover this area?
+   - Is the documentation now inaccurate or incomplete?
+   - Classify per AGENTS.md "Change Classification" section
+
+3. **Identify Specific Updates**
+   For each required update:
+   - Exact file path
+   - Specific section or heading
+   - Type of change (update existing, add new, deprecate)
+   - Description of the change
+
+4. **Flag Uncertainty**
+   Explicitly mark:
+   - Assumptions you're making
+   - Areas where human confirmation is needed
+   - Ambiguous requirements
+
+5. **Output Format**
+Use the exact format specified in `docs/AGENTS.md` Phase 4 section:
+
+```markdown
+## Documentation Impact Assessment
+
+### Summary
+Brief description of code changes analyzed.
+
+### Documentation Updates Required: [Yes/No]
+
+### Planned Changes
+
+#### 1. [File Path]
+- **Section**: [Section name or "New section"]
+- **Change Type**: [Update/Add/Deprecate]
+- **Reason**: Why this change is needed
+- **Description**: What will be added/modified
+
+### Uncertainty Flags
+- [ ] [Description of any assumptions or areas needing confirmation]
+
+### No Changes Needed
+- [List files reviewed but not requiring updates, with brief reason]
+```
+
+## Constraints
+- Read-only: Do not modify any files
+- Conservative: When uncertain, flag for human review rather than planning changes
+- Scoped: Only plan changes that trace directly to code changes from Phase 3
+- No scope expansion: Do not plan "improvements" unrelated to triggering changes
diff --git a/.factory/prompts/docs-automation/phase5-apply.md b/.factory/prompts/docs-automation/phase5-apply.md
new file mode 100644
index 0000000000000000000000000000000000000000..9cc63071fccf880443b729baa06f0ddbd769276b
--- /dev/null
+++ b/.factory/prompts/docs-automation/phase5-apply.md
@@ -0,0 +1,67 @@
+# Phase 5: Apply Documentation Plan
+
+You are executing a pre-approved documentation plan for an **mdBook** documentation site.
+
+## Objective
+Implement exactly the changes specified in the documentation plan from Phase 4.
+
+## Documentation System
+- **mdBook**: https://rust-lang.github.io/mdBook/
+- **SUMMARY.md**: Follows mdBook format (https://rust-lang.github.io/mdBook/format/summary.html)
+- **Prettier**: Will be run automatically after this phase (80 char line width)
+- **Custom preprocessor**: Use `{#kb action::ActionName}` for keybindings instead of hardcoding
+
+## Input
+You will receive:
+- Documentation plan from Phase 4
+- Documentation guidelines from `docs/AGENTS.md`
+- Style rules from `docs/.rules`
+
+## Instructions
+
+1. **Validate Plan**
+   - Confirm all planned files are within scope per AGENTS.md
+   - Verify no out-of-scope files are targeted
+
+2. **Execute Each Planned Change**
+   For each item in "Planned Changes":
+   - Navigate to the specified file
+   - Locate the specified section
+   - Apply the described change
+   - Follow style rules from `docs/.rules`
+
+3. **Style Compliance**
+   Every edit must follow `docs/.rules`:
+   - Second person, present tense
+   - No hedging words ("simply", "just", "easily")
+   - Proper keybinding format (`Cmd+Shift+P`)
+   - Settings Editor first, JSON second
+   - Correct terminology (folder not directory, etc.)
+
+4. **Preserve Context**
+   - Maintain surrounding content structure
+   - Keep consistent heading levels
+   - Preserve existing cross-references
+
+## Constraints
+- Execute ONLY changes listed in the plan
+- Do not discover new documentation targets
+- Do not make stylistic improvements outside planned sections
+- Do not expand scope beyond what Phase 4 specified
+- If a planned change cannot be applied (file missing, section not found), skip and note it
+
+## Output
+After applying changes, output a summary:
+
+```markdown
+## Applied Changes
+
+### Successfully Applied
+- `path/to/file.md`: [Brief description of change]
+
+### Skipped (Could Not Apply)
+- `path/to/file.md`: [Reason - e.g., "Section not found"]
+
+### Warnings
+- [Any issues encountered during application]
+```
diff --git a/.factory/prompts/docs-automation/phase6-summarize.md b/.factory/prompts/docs-automation/phase6-summarize.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1480ac9431702539fa2a570c2b456bcdfae46af
--- /dev/null
+++ b/.factory/prompts/docs-automation/phase6-summarize.md
@@ -0,0 +1,54 @@
+# Phase 6: Summarize Changes
+
+You are generating a summary of documentation updates for PR review.
+
+## Objective
+Create a clear, reviewable summary of all documentation changes made.
+
+## Input
+You will receive:
+- Applied changes report from Phase 5
+- Original change analysis from Phase 3
+- Git diff of documentation changes
+
+## Instructions
+
+1. **Gather Change Information**
+   - List all modified documentation files
+   - Identify the corresponding code changes that triggered each update
+
+2. **Generate Summary**
+   Use the format specified in `docs/AGENTS.md` Phase 6 section:
+
+```markdown
+## Documentation Update Summary
+
+### Changes Made
+| File | Change | Related Code |
+| --- | --- | --- |
+| docs/src/path.md | Brief description | PR #123 or commit SHA |
+
+### Rationale
+Brief explanation of why these updates were made, linking back to the triggering code changes.
+
+### Review Notes
+- Items reviewers should pay special attention to
+- Any uncertainty flags from Phase 4 that were addressed
+- Assumptions made during documentation
+```
+
+3. **Add Context for Reviewers**
+   - Highlight any changes that might be controversial
+   - Note if any planned changes were skipped and why
+   - Flag areas where reviewer expertise is especially needed
+
+## Output Format
+The summary should be suitable for:
+- PR description body
+- Commit message (condensed version)
+- Team communication
+
+## Constraints
+- Read-only (documentation changes already applied in Phase 5)
+- Factual: Describe what was done, not justify why it's good
+- Complete: Account for all changes, including skipped items
diff --git a/.factory/prompts/docs-automation/phase7-commit.md b/.factory/prompts/docs-automation/phase7-commit.md
new file mode 100644
index 0000000000000000000000000000000000000000..adfd92eec7d3058af3917f2663228b4f6ee5c445
--- /dev/null
+++ b/.factory/prompts/docs-automation/phase7-commit.md
@@ -0,0 +1,67 @@
+# Phase 7: Commit and Open PR
+
+You are creating a git branch, committing documentation changes, and opening a PR.
+
+## Objective
+Package documentation updates into a reviewable pull request.
+
+## Input
+You will receive:
+- Summary from Phase 6
+- List of modified files
+
+## Instructions
+
+1. **Create Branch**
+   ```sh
+   git checkout -b docs/auto-update-{date}
+   ```
+   Use format: `docs/auto-update-YYYY-MM-DD` or `docs/auto-update-{short-sha}`
+
+2. **Stage and Commit**
+   - Stage only documentation files in `docs/src/`
+   - Do not stage any other files
+   
+   Commit message format:
+   ```
+   docs: auto-update documentation for [brief description]
+   
+   [Summary from Phase 6, condensed]
+   
+   Triggered by: [commit SHA or PR reference]
+   
+   Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
+   ```
+
+3. **Push Branch**
+   ```sh
+   git push -u origin docs/auto-update-{date}
+   ```
+
+4. **Create Pull Request**
+   Use the Phase 6 summary as the PR body.
+   
+   PR Title: `docs: [Brief description of documentation updates]`
+   
+   Labels (if available): `documentation`, `automated`
+   
+   Base branch: `main`
+
+## Constraints
+- Do NOT auto-merge
+- Do NOT request specific reviewers (let CODEOWNERS handle it)
+- Do NOT modify files outside `docs/src/`
+- If no changes to commit, exit gracefully with message "No documentation changes to commit"
+
+## Output
+```markdown
+## PR Created
+
+- **Branch**: docs/auto-update-{date}
+- **PR URL**: https://github.com/zed-industries/zed/pull/XXXX
+- **Status**: Ready for review
+
+### Commit
+- SHA: {commit-sha}
+- Files: {count} documentation files modified
+```
diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e4aa79c7fc09d6d7735ac82e2315d68b923d5323
--- /dev/null
+++ b/.github/workflows/docs_automation.yml
@@ -0,0 +1,256 @@
+name: Documentation Automation
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'crates/**'
+      - 'extensions/**'
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'PR number to analyze (gets full PR diff)'
+        required: false
+        type: string
+      trigger_sha:
+        description: 'Commit SHA to analyze (ignored if pr_number is set)'
+        required: false
+        type: string
+
+permissions:
+  contents: write
+  pull-requests: write
+
+env:
+  FACTORY_API_KEY: ${{ secrets.FACTORY_API_KEY }}
+  DROID_MODEL: claude-opus-4-5
+
+jobs:
+  docs-automation:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install Droid CLI
+        run: |
+          curl -fsSL https://cli.factory.ai/install.sh | bash
+          echo "${HOME}/.factory/bin" >> "$GITHUB_PATH"
+
+      - name: Setup Node.js (for Prettier)
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install Prettier
+        run: npm install -g prettier
+
+      - name: Get changed files
+        id: changed
+        run: |
+          if [ -n "${{ inputs.pr_number }}" ]; then
+            # Get full PR diff
+            echo "Analyzing PR #${{ inputs.pr_number }}"
+            echo "source=pr" >> "$GITHUB_OUTPUT"
+            echo "ref=${{ inputs.pr_number }}" >> "$GITHUB_OUTPUT"
+            gh pr diff "${{ inputs.pr_number }}" --name-only > /tmp/changed_files.txt
+          elif [ -n "${{ inputs.trigger_sha }}" ]; then
+            # Get single commit diff
+            SHA="${{ inputs.trigger_sha }}"
+            echo "Analyzing commit $SHA"
+            echo "source=commit" >> "$GITHUB_OUTPUT"
+            echo "ref=$SHA" >> "$GITHUB_OUTPUT"
+            git diff --name-only "${SHA}^" "$SHA" > /tmp/changed_files.txt
+          else
+            # Default to current commit
+            SHA="${{ github.sha }}"
+            echo "Analyzing commit $SHA"
+            echo "source=commit" >> "$GITHUB_OUTPUT"
+            echo "ref=$SHA" >> "$GITHUB_OUTPUT"
+            git diff --name-only "${SHA}^" "$SHA" > /tmp/changed_files.txt || git diff --name-only HEAD~1 HEAD > /tmp/changed_files.txt
+          fi
+          
+          echo "Changed files:"
+          cat /tmp/changed_files.txt
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+      # Phase 0: Guardrails are loaded via AGENTS.md in each phase
+
+      # Phase 2: Explore Repository (Read-Only)
+      - name: "Phase 2: Explore Repository"
+        id: phase2
+        run: |
+          droid exec \
+            --model "$DROID_MODEL" \
+            --autonomy read-only \
+            --prompt-file .factory/prompts/docs-automation/phase2-explore.md \
+            --output /tmp/phase2-output.json \
+            --format json
+          echo "Repository exploration complete"
+          cat /tmp/phase2-output.json
+
+      # Phase 3: Analyze Changes (Read-Only)
+      - name: "Phase 3: Analyze Changes"
+        id: phase3
+        run: |
+          CHANGED_FILES=$(tr '\n' ' ' < /tmp/changed_files.txt)
+          droid exec \
+            --model "$DROID_MODEL" \
+            --autonomy read-only \
+            --prompt-file .factory/prompts/docs-automation/phase3-analyze.md \
+            --context "Changed files: $CHANGED_FILES" \
+            --context-file /tmp/phase2-output.json \
+            --output /tmp/phase3-output.md \
+            --format markdown
+          echo "Change analysis complete"
+          cat /tmp/phase3-output.md
+
+      # Phase 4: Plan Documentation Impact (Read-Only)
+      - name: "Phase 4: Plan Documentation Impact"
+        id: phase4
+        run: |
+          droid exec \
+            --model "$DROID_MODEL" \
+            --autonomy read-only \
+            --prompt-file .factory/prompts/docs-automation/phase4-plan.md \
+            --context-file /tmp/phase3-output.md \
+            --context-file docs/AGENTS.md \
+            --output /tmp/phase4-plan.md \
+            --format markdown
+          echo "Documentation plan complete"
+          cat /tmp/phase4-plan.md
+          
+          # Check if updates are required
+          if grep -q "Documentation Updates Required: No" /tmp/phase4-plan.md; then
+            echo "updates_required=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "updates_required=true" >> "$GITHUB_OUTPUT"
+          fi
+
+      # Phase 5: Apply Plan (Write-Enabled)
+      - name: "Phase 5: Apply Documentation Plan"
+        id: phase5
+        if: steps.phase4.outputs.updates_required == 'true'
+        run: |
+          droid exec \
+            --model "$DROID_MODEL" \
+            --autonomy medium \
+            --prompt-file .factory/prompts/docs-automation/phase5-apply.md \
+            --context-file /tmp/phase4-plan.md \
+            --context-file docs/AGENTS.md \
+            --context-file docs/.rules \
+            --output /tmp/phase5-report.md \
+            --format markdown
+          echo "Documentation updates applied"
+          cat /tmp/phase5-report.md
+
+      # Phase 5b: Format with Prettier
+      - name: "Phase 5b: Format with Prettier"
+        id: phase5b
+        if: steps.phase4.outputs.updates_required == 'true'
+        run: |
+          echo "Formatting documentation with Prettier..."
+          cd docs && prettier --write src/
+          
+          echo "Verifying Prettier formatting passes..."
+          cd docs && prettier --check src/
+          
+          echo "Prettier formatting complete"
+
+      # Phase 6: Summarize Changes
+      - name: "Phase 6: Summarize Changes"
+        id: phase6
+        if: steps.phase4.outputs.updates_required == 'true'
+        run: |
+          # Get git diff of docs
+          git diff docs/src/ > /tmp/docs-diff.txt || true
+          
+          droid exec \
+            --model "$DROID_MODEL" \
+            --autonomy read-only \
+            --prompt-file .factory/prompts/docs-automation/phase6-summarize.md \
+            --context-file /tmp/phase5-report.md \
+            --context-file /tmp/phase3-output.md \
+            --context "Trigger SHA: ${{ steps.changed.outputs.sha }}" \
+            --output /tmp/phase6-summary.md \
+            --format markdown
+          echo "Summary generated"
+          cat /tmp/phase6-summary.md
+
+      # Phase 7: Commit and Open PR
+      - name: "Phase 7: Create PR"
+        id: phase7
+        if: steps.phase4.outputs.updates_required == 'true'
+        run: |
+          # Check if there are actual changes
+          if git diff --quiet docs/src/; then
+            echo "No documentation changes detected"
+            exit 0
+          fi
+          
+          # Configure git
+          git config user.name "factory-droid[bot]"
+          git config user.email "138933559+factory-droid[bot]@users.noreply.github.com"
+          
+          # Daily batch branch - one branch per day, multiple commits accumulate
+          BRANCH_NAME="docs/auto-update-$(date +%Y-%m-%d)"
+          
+          # Check if branch already exists on remote
+          if git ls-remote --exit-code --heads origin "$BRANCH_NAME" > /dev/null 2>&1; then
+            echo "Branch $BRANCH_NAME exists, checking out and updating..."
+            git fetch origin "$BRANCH_NAME"
+            git checkout -B "$BRANCH_NAME" "origin/$BRANCH_NAME"
+          else
+            echo "Creating new branch $BRANCH_NAME..."
+            git checkout -b "$BRANCH_NAME"
+          fi
+          
+          # Stage and commit
+          git add docs/src/
+          SUMMARY=$(head -50 < /tmp/phase6-summary.md)
+          git commit -m "docs: auto-update documentation
+
+          ${SUMMARY}
+
+          Triggered by: ${{ steps.changed.outputs.source }} ${{ steps.changed.outputs.ref }}
+
+          Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>"
+          
+          # Push
+          git push -u origin "$BRANCH_NAME"
+          
+          # Check if PR already exists for this branch
+          EXISTING_PR=$(gh pr list --head "$BRANCH_NAME" --json number --jq '.[0].number' || echo "")
+          
+          if [ -n "$EXISTING_PR" ]; then
+            echo "PR #$EXISTING_PR already exists for branch $BRANCH_NAME, updated with new commit"
+          else
+            # Create new PR
+            gh pr create \
+              --title "docs: automated documentation update ($(date +%Y-%m-%d))" \
+              --body-file /tmp/phase6-summary.md \
+              --base main || true
+            echo "PR created on branch: $BRANCH_NAME"
+          fi
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+      # Summary output
+      - name: "Summary"
+        if: always()
+        run: |
+          echo "## Documentation Automation Summary" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          
+          if [ "${{ steps.phase4.outputs.updates_required }}" == "false" ]; then
+            echo "No documentation updates required for this change." >> "$GITHUB_STEP_SUMMARY"
+          elif [ -f /tmp/phase6-summary.md ]; then
+            cat /tmp/phase6-summary.md >> "$GITHUB_STEP_SUMMARY"
+          else
+            echo "Workflow completed. Check individual phase outputs for details." >> "$GITHUB_STEP_SUMMARY"
+          fi
diff --git a/docs/AGENTS.md b/docs/AGENTS.md
new file mode 100644
index 0000000000000000000000000000000000000000..fdd61ff6aeaf8cd09ae0b017c5199e7033fba964
--- /dev/null
+++ b/docs/AGENTS.md
@@ -0,0 +1,353 @@
+# Documentation Automation Agent Guidelines
+
+This file governs automated documentation updates triggered by code changes. All automation phases must comply with these rules.
+
+## Documentation System
+
+This documentation uses **mdBook** (https://rust-lang.github.io/mdBook/).
+
+### Key Files
+
+- **`docs/src/SUMMARY.md`**: Table of contents following mdBook format (https://rust-lang.github.io/mdBook/format/summary.html)
+- **`docs/book.toml`**: mdBook configuration
+- **`docs/.prettierrc`**: Prettier config (80 char line width)
+
+### SUMMARY.md Format
+
+The `SUMMARY.md` file defines the book structure. Format rules:
+
+- Chapter titles are links: `[Title](./path/to/file.md)`
+- Nesting via indentation (2 spaces per level)
+- Separators: `---` for horizontal rules between sections
+- Draft chapters: `[Title]()` (empty parens, not yet written)
+
+Example:
+
+```markdown
+# Section Title
+
+- [Chapter](./chapter.md)
+  - [Nested Chapter](./nested.md)
+
+---
+
+# Another Section
+```
+
+### Custom Preprocessor
+
+The docs use a custom preprocessor (`docs_preprocessor`) that expands special commands:
+
+| Syntax                        | Purpose                               | Example                         |
+| ----------------------------- | ------------------------------------- | ------------------------------- |
+| `{#kb action::ActionName}`    | Keybinding for action                 | `{#kb agent::ToggleFocus}`      |
+| `{#action agent::ActionName}` | Action reference (renders as command) | `{#action agent::OpenSettings}` |
+
+**Rules:**
+
+- Always use preprocessor syntax for keybindings instead of hardcoding
+- Action names use `snake_case` in the namespace, `PascalCase` for the action
+- Common namespaces: `agent::`, `editor::`, `assistant::`, `vim::`
+
+### Formatting Requirements
+
+All documentation must pass **Prettier** formatting:
+
+```sh
+cd docs && npx prettier --check src/
+```
+
+Before any documentation change is considered complete:
+
+1. Run Prettier to format: `cd docs && npx prettier --write src/`
+2. Verify it passes: `cd docs && npx prettier --check src/`
+
+Prettier config: 80 character line width (`docs/.prettierrc`)
+
+### Section Anchors
+
+Use `{#anchor-id}` syntax for linkable section headers:
+
+```markdown
+## Getting Started {#getting-started}
+
+### Custom Models {#anthropic-custom-models}
+```
+
+Anchor IDs should be:
+
+- Lowercase with hyphens
+- Unique within the page
+- Descriptive (can include parent context like `anthropic-custom-models`)
+
+### Code Block Annotations
+
+Use annotations after the language identifier to indicate file context:
+
+```markdown
+\`\`\`json [settings]
+{
+"agent": { ... }
+}
+\`\`\`
+
+\`\`\`json [keymap]
+[
+{ "bindings": { ... } }
+]
+\`\`\`
+```
+
+Valid annotations: `[settings]` (for settings.json), `[keymap]` (for keymap.json)
+
+### Blockquote Formatting
+
+Use bold labels for callouts:
+
+```markdown
+> **Note:** Important information the user should know.
+
+> **Tip:** Helpful advice that saves time or improves workflow.
+
+> **Warn:** Caution about potential issues or gotchas.
+```
+
+### Image References
+
+Images are hosted externally. Reference format:
+
+```markdown
+![Alt text description](https://zed.dev/img/path/to/image.webp)
+```
+
+### Cross-Linking
+
+- Relative links for same-directory: `[Agent Panel](./agent-panel.md)`
+- With anchors: `[Custom Models](./llm-providers.md#anthropic-custom-models)`
+- Parent directory: `[Telemetry](../telemetry.md)`
+
+## Scope
+
+### In-Scope Documentation
+
+- All Markdown files in `docs/src/`
+- `docs/src/SUMMARY.md` (mdBook table of contents)
+- Language-specific docs in `docs/src/languages/`
+- Feature docs (AI, extensions, configuration, etc.)
+
+### Out-of-Scope (Do Not Modify)
+
+- `CHANGELOG.md`, `CONTRIBUTING.md`, `README.md` at repo root
+- Inline code comments and rustdoc
+- `CLAUDE.md`, `GEMINI.md`, or other AI instruction files
+- Build configuration (`book.toml`, theme files, `docs_preprocessor`)
+- Any file outside `docs/src/`
+
+## Page Structure Patterns
+
+### Standard Page Layout
+
+Most documentation pages follow this structure:
+
+1. **Title** (H1) - Single sentence or phrase
+2. **Overview/Introduction** - 1-3 paragraphs explaining what this is
+3. **Getting Started** `{#getting-started}` - Prerequisites and first steps
+4. **Main Content** - Feature details, organized by topic
+5. **Advanced/Configuration** - Power user options
+6. **See Also** (optional) - Related documentation links
+
+### Settings Documentation Pattern
+
+When documenting settings:
+
+1. Show the Settings Editor (UI) approach first
+2. Then show JSON as "Or add this to your settings.json:"
+3. Always show complete, valid JSON with surrounding structure:
+
+```json [settings]
+{
+  "agent": {
+    "default_model": {
+      "provider": "anthropic",
+      "model": "claude-sonnet-4"
+    }
+  }
+}
+```
+
+### Provider/Feature Documentation Pattern
+
+For each provider or distinct feature:
+
+1. H3 heading with anchor: `### Provider Name {#provider-name}`
+2. Brief description (1-2 sentences)
+3. Setup steps (numbered list)
+4. Configuration example (JSON code block)
+5. Custom models section if applicable: `#### Custom Models {#provider-custom-models}`
+
+## Style Rules
+
+Inherit all conventions from `docs/.rules`. Key points:
+
+### Voice
+
+- Second person ("you"), present tense
+- Direct and concise—no hedging ("simply", "just", "easily")
+- Honest about limitations; no promotional language
+
+### Formatting
+
+- Keybindings: backticks with `+` for simultaneous keys (`Cmd+Shift+P`)
+- Show both macOS and Linux/Windows variants when they differ
+- Use `sh` code blocks for terminal commands
+- Settings: show Settings Editor UI first, JSON as secondary
+
+### Terminology
+
+| Use             | Instead of                             |
+| --------------- | -------------------------------------- |
+| folder          | directory                              |
+| project         | workspace                              |
+| Settings Editor | settings UI                            |
+| command palette | command bar                            |
+| panel           | sidebar (be specific: "Project Panel") |
+
+## Zed-Specific Conventions
+
+### Recognized Rules Files
+
+When documenting rules/instructions for AI, note that Zed recognizes these files (in priority order):
+
+- `.rules`
+- `.cursorrules`
+- `.windsurfrules`
+- `.clinerules`
+- `.github/copilot-instructions.md`
+- `AGENT.md`
+- `AGENTS.md`
+- `CLAUDE.md`
+- `GEMINI.md`
+
+### Settings File Locations
+
+- macOS: `~/.config/zed/settings.json`
+- Linux: `~/.config/zed/settings.json`
+- Windows: `%AppData%\Zed\settings.json`
+
+### Keymap File Locations
+
+- macOS: `~/.config/zed/keymap.json`
+- Linux: `~/.config/zed/keymap.json`
+- Windows: `%AppData%\Zed\keymap.json`
+
+## Safety Constraints
+
+### Must Not
+
+- Delete existing documentation files
+- Remove sections documenting existing functionality
+- Change URLs or anchor links without verifying references
+- Modify `SUMMARY.md` structure without corresponding content
+- Add speculative documentation for unreleased features
+- Include internal implementation details not relevant to users
+
+### Must
+
+- Preserve existing structure when updating content
+- Maintain backward compatibility of documented settings/commands
+- Flag uncertainty explicitly rather than guessing
+- Link to related documentation when adding new sections
+
+## Change Classification
+
+### Requires Documentation Update
+
+- New user-facing features or commands
+- Changed keybindings or default behaviors
+- Modified settings schema or options
+- Deprecated or removed functionality
+- API changes affecting extensions
+
+### Does Not Require Documentation Update
+
+- Internal refactoring without behavioral changes
+- Performance optimizations (unless user-visible)
+- Bug fixes that restore documented behavior
+- Test changes
+- CI/CD changes
+
+## Output Format
+
+### Phase 4 Documentation Plan
+
+When generating a documentation plan, use this structure:
+
+```markdown
+## Documentation Impact Assessment
+
+### Summary
+
+Brief description of code changes analyzed.
+
+### Documentation Updates Required: [Yes/No]
+
+### Planned Changes
+
+#### 1. [File Path]
+
+- **Section**: [Section name or "New section"]
+- **Change Type**: [Update/Add/Deprecate]
+- **Reason**: Why this change is needed
+- **Description**: What will be added/modified
+
+#### 2. [File Path]
+
+...
+
+### Uncertainty Flags
+
+- [ ] [Description of any assumptions or areas needing confirmation]
+
+### No Changes Needed
+
+- [List files reviewed but not requiring updates, with brief reason]
+```
+
+### Phase 6 Summary Format
+
+```markdown
+## Documentation Update Summary
+
+### Changes Made
+
+| File           | Change            | Related Code      |
+| -------------- | ----------------- | ----------------- |
+| path/to/doc.md | Brief description | link to PR/commit |
+
+### Rationale
+
+Brief explanation of why these updates were made.
+
+### Review Notes
+
+Any items reviewers should pay special attention to.
+```
+
+## Behavioral Guidelines
+
+### Conservative by Default
+
+- When uncertain whether to document something, flag it for human review
+- Prefer smaller, focused updates over broad rewrites
+- Do not "improve" documentation unrelated to the triggering code change
+
+### Traceability
+
+- Every documentation change should trace to a specific code change
+- Include references to relevant commits, PRs, or issues in summaries
+
+### Incremental Updates
+
+- Update existing sections rather than creating parallel documentation
+- Maintain consistency with surrounding content
+- Follow the established patterns in each documentation area

From 4ef5d2c8148e555388668b094e059633c5bc405a Mon Sep 17 00:00:00 2001
From: Andrew Farkas <6060305+HactarCE@users.noreply.github.com>
Date: Fri, 19 Dec 2025 12:32:38 -0500
Subject: [PATCH 240/266] Fix relative line numbers in sticky headers (#45164)

Closes #42586

This includes a rewrite of `calculate_relative_line_numbers()`. Now it's
linear-time with respect to the number of rows displayed, instead of
linear time with respect to the number of rows displayed _plus_ the
distance to the base row.

Release Notes:

- Improved performance when using relative line numbers in large files
- Fixed relative line numbers not appearing in sticky headers
---
 crates/editor/src/editor.rs       |  66 ++++++++++-
 crates/editor/src/editor_tests.rs | 127 ++++++++++++++++++++-
 crates/editor/src/element.rs      | 176 ++++++++++++------------------
 3 files changed, 258 insertions(+), 111 deletions(-)

diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 6e4744335b8e9fba50a6c2c8b241607b0e05d276..d985a4d269f2eaeb3fa6056192095b7913b579b6 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -20475,7 +20475,7 @@ impl Editor {
         EditorSettings::get_global(cx).gutter.line_numbers
     }
 
-    pub fn relative_line_numbers(&self, cx: &mut App) -> RelativeLineNumbers {
+    pub fn relative_line_numbers(&self, cx: &App) -> RelativeLineNumbers {
         match (
             self.use_relative_line_numbers,
             EditorSettings::get_global(cx).relative_line_numbers,
@@ -25294,6 +25294,70 @@ impl EditorSnapshot {
         let digit_count = self.widest_line_number().ilog10() + 1;
         column_pixels(style, digit_count as usize, window)
     }
+
+    /// Returns the line delta from `base` to `line` in the multibuffer, ignoring wrapped lines.
+    ///
+    /// This is positive if `base` is before `line`.
+    fn relative_line_delta(&self, base: DisplayRow, line: DisplayRow) -> i64 {
+        let point = DisplayPoint::new(line, 0).to_point(self);
+        self.relative_line_delta_to_point(base, point)
+    }
+
+    /// Returns the line delta from `base` to `point` in the multibuffer, ignoring wrapped lines.
+    ///
+    /// This is positive if `base` is before `point`.
+    pub fn relative_line_delta_to_point(&self, base: DisplayRow, point: Point) -> i64 {
+        let base_point = DisplayPoint::new(base, 0).to_point(self);
+        point.row as i64 - base_point.row as i64
+    }
+
+    /// Returns the line delta from `base` to `line` in the multibuffer, counting wrapped lines.
+    ///
+    /// This is positive if `base` is before `line`.
+    fn relative_wrapped_line_delta(&self, base: DisplayRow, line: DisplayRow) -> i64 {
+        let point = DisplayPoint::new(line, 0).to_point(self);
+        self.relative_wrapped_line_delta_to_point(base, point)
+    }
+
+    /// Returns the line delta from `base` to `point` in the multibuffer, counting wrapped lines.
+    ///
+    /// This is positive if `base` is before `point`.
+    pub fn relative_wrapped_line_delta_to_point(&self, base: DisplayRow, point: Point) -> i64 {
+        let base_point = DisplayPoint::new(base, 0).to_point(self);
+        let wrap_snapshot = self.wrap_snapshot();
+        let base_wrap_row = wrap_snapshot.make_wrap_point(base_point, Bias::Left).row();
+        let wrap_row = wrap_snapshot.make_wrap_point(point, Bias::Left).row();
+        wrap_row.0 as i64 - base_wrap_row.0 as i64
+    }
+
+    /// Returns the unsigned relative line number to display for each row in `rows`.
+    ///
+    /// Wrapped rows are excluded from the hashmap if `count_relative_lines` is `false`.
+    pub fn calculate_relative_line_numbers(
+        &self,
+        rows: &Range,
+        relative_to: DisplayRow,
+        count_wrapped_lines: bool,
+    ) -> HashMap {
+        let initial_offset = if count_wrapped_lines {
+            self.relative_wrapped_line_delta(relative_to, rows.start)
+        } else {
+            self.relative_line_delta(relative_to, rows.start)
+        };
+        let display_row_infos = self
+            .row_infos(rows.start)
+            .take(rows.len())
+            .enumerate()
+            .map(|(i, row_info)| (DisplayRow(rows.start.0 + i as u32), row_info));
+        display_row_infos
+            .filter(|(_row, row_info)| {
+                row_info.buffer_row.is_some()
+                    || (count_wrapped_lines && row_info.wrapped_buffer_row.is_some())
+            })
+            .enumerate()
+            .map(|(i, (row, _row_info))| (row, (initial_offset + i as i64).unsigned_abs() as u32))
+            .collect()
+    }
 }
 
 pub fn column_pixels(style: &EditorStyle, column: usize, window: &Window) -> Pixels {
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 87674d8c507b1c294779b1f9ddba458320fc7671..613850428a8720ed37efa447a1312c262a05571a 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -36,7 +36,8 @@ use languages::markdown_lang;
 use languages::rust_lang;
 use lsp::CompletionParams;
 use multi_buffer::{
-    IndentGuide, MultiBufferFilterMode, MultiBufferOffset, MultiBufferOffsetUtf16, PathKey,
+    ExcerptRange, IndentGuide, MultiBuffer, MultiBufferFilterMode, MultiBufferOffset,
+    MultiBufferOffsetUtf16, PathKey,
 };
 use parking_lot::Mutex;
 use pretty_assertions::{assert_eq, assert_ne};
@@ -28633,6 +28634,130 @@ async fn test_sticky_scroll(cx: &mut TestAppContext) {
     assert_eq!(sticky_headers(10.0), vec![]);
 }
 
+#[gpui::test]
+fn test_relative_line_numbers(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+
+    let buffer_1 = cx.new(|cx| Buffer::local("aaaaaaaaaa\nbbb\n", cx));
+    let buffer_2 = cx.new(|cx| Buffer::local("cccccccccc\nddd\n", cx));
+    let buffer_3 = cx.new(|cx| Buffer::local("eee\nffffffffff\n", cx));
+
+    let multibuffer = cx.new(|cx| {
+        let mut multibuffer = MultiBuffer::new(ReadWrite);
+        multibuffer.push_excerpts(
+            buffer_1.clone(),
+            [ExcerptRange::new(Point::new(0, 0)..Point::new(2, 0))],
+            cx,
+        );
+        multibuffer.push_excerpts(
+            buffer_2.clone(),
+            [ExcerptRange::new(Point::new(0, 0)..Point::new(2, 0))],
+            cx,
+        );
+        multibuffer.push_excerpts(
+            buffer_3.clone(),
+            [ExcerptRange::new(Point::new(0, 0)..Point::new(2, 0))],
+            cx,
+        );
+        multibuffer
+    });
+
+    // wrapped contents of multibuffer:
+    //    aaa
+    //    aaa
+    //    aaa
+    //    a
+    //    bbb
+    //
+    //    ccc
+    //    ccc
+    //    ccc
+    //    c
+    //    ddd
+    //
+    //    eee
+    //    fff
+    //    fff
+    //    fff
+    //    f
+
+    let (editor, cx) = cx.add_window_view(|window, cx| build_editor(multibuffer, window, cx));
+    editor.update_in(cx, |editor, window, cx| {
+        editor.set_wrap_width(Some(30.0.into()), cx); // every 3 characters
+
+        // includes trailing newlines.
+        let expected_line_numbers = [2, 6, 7, 10, 14, 15, 18, 19, 23];
+        let expected_wrapped_line_numbers = [
+            2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 18, 19, 20, 21, 22, 23,
+        ];
+
+        editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
+            s.select_ranges([
+                Point::new(7, 0)..Point::new(7, 1), // second row of `ccc`
+            ]);
+        });
+
+        let snapshot = editor.snapshot(window, cx);
+
+        // these are all 0-indexed
+        let base_display_row = DisplayRow(11);
+        let base_row = 3;
+        let wrapped_base_row = 7;
+
+        // test not counting wrapped lines
+        let expected_relative_numbers = expected_line_numbers
+            .into_iter()
+            .enumerate()
+            .map(|(i, row)| (DisplayRow(row), i.abs_diff(base_row) as u32))
+            .collect_vec();
+        let actual_relative_numbers = snapshot
+            .calculate_relative_line_numbers(
+                &(DisplayRow(0)..DisplayRow(24)),
+                base_display_row,
+                false,
+            )
+            .into_iter()
+            .sorted()
+            .collect_vec();
+        assert_eq!(expected_relative_numbers, actual_relative_numbers);
+        // check `calculate_relative_line_numbers()` against `relative_line_delta()` for each line
+        for (display_row, relative_number) in expected_relative_numbers {
+            assert_eq!(
+                relative_number,
+                snapshot
+                    .relative_line_delta(display_row, base_display_row)
+                    .unsigned_abs() as u32,
+            );
+        }
+
+        // test counting wrapped lines
+        let expected_wrapped_relative_numbers = expected_wrapped_line_numbers
+            .into_iter()
+            .enumerate()
+            .map(|(i, row)| (DisplayRow(row), i.abs_diff(wrapped_base_row) as u32))
+            .collect_vec();
+        let actual_relative_numbers = snapshot
+            .calculate_relative_line_numbers(
+                &(DisplayRow(0)..DisplayRow(24)),
+                base_display_row,
+                true,
+            )
+            .into_iter()
+            .sorted()
+            .collect_vec();
+        assert_eq!(expected_wrapped_relative_numbers, actual_relative_numbers);
+        // check `calculate_relative_line_numbers()` against `relative_wrapped_line_delta()` for each line
+        for (display_row, relative_number) in expected_wrapped_relative_numbers {
+            assert_eq!(
+                relative_number,
+                snapshot
+                    .relative_wrapped_line_delta(display_row, base_display_row)
+                    .unsigned_abs() as u32,
+            );
+        }
+    });
+}
+
 #[gpui::test]
 async fn test_scroll_by_clicking_sticky_header(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 4c3b44335bcad10be4303d545a8d2ad505938098..b2e355dc5158214eabd07d519649591be8a325a8 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -66,7 +66,7 @@ use project::{
 };
 use settings::{
     GitGutterSetting, GitHunkStyleSetting, IndentGuideBackgroundColoring, IndentGuideColoring,
-    Settings,
+    RelativeLineNumbers, Settings,
 };
 use smallvec::{SmallVec, smallvec};
 use std::{
@@ -194,8 +194,6 @@ pub struct EditorElement {
     style: EditorStyle,
 }
 
-type DisplayRowDelta = u32;
-
 impl EditorElement {
     pub(crate) const SCROLLBAR_WIDTH: Pixels = px(15.);
 
@@ -3225,64 +3223,6 @@ impl EditorElement {
             .collect()
     }
 
-    fn calculate_relative_line_numbers(
-        &self,
-        snapshot: &EditorSnapshot,
-        rows: &Range,
-        relative_to: Option,
-        count_wrapped_lines: bool,
-    ) -> HashMap {
-        let mut relative_rows: HashMap = Default::default();
-        let Some(relative_to) = relative_to else {
-            return relative_rows;
-        };
-
-        let start = rows.start.min(relative_to);
-        let end = rows.end.max(relative_to);
-
-        let buffer_rows = snapshot
-            .row_infos(start)
-            .take(1 + end.minus(start) as usize)
-            .collect::>();
-
-        let head_idx = relative_to.minus(start);
-        let mut delta = 1;
-        let mut i = head_idx + 1;
-        let should_count_line = |row_info: &RowInfo| {
-            if count_wrapped_lines {
-                row_info.buffer_row.is_some() || row_info.wrapped_buffer_row.is_some()
-            } else {
-                row_info.buffer_row.is_some()
-            }
-        };
-        while i < buffer_rows.len() as u32 {
-            if should_count_line(&buffer_rows[i as usize]) {
-                if rows.contains(&DisplayRow(i + start.0)) {
-                    relative_rows.insert(DisplayRow(i + start.0), delta);
-                }
-                delta += 1;
-            }
-            i += 1;
-        }
-        delta = 1;
-        i = head_idx.min(buffer_rows.len().saturating_sub(1) as u32);
-        while i > 0 && buffer_rows[i as usize].buffer_row.is_none() && !count_wrapped_lines {
-            i -= 1;
-        }
-
-        while i > 0 {
-            i -= 1;
-            if should_count_line(&buffer_rows[i as usize]) {
-                if rows.contains(&DisplayRow(i + start.0)) {
-                    relative_rows.insert(DisplayRow(i + start.0), delta);
-                }
-                delta += 1;
-            }
-        }
-
-        relative_rows
-    }
-
     fn layout_line_numbers(
         &self,
         gutter_hitbox: Option<&Hitbox>,
@@ -3292,7 +3232,7 @@ impl EditorElement {
         rows: Range,
         buffer_rows: &[RowInfo],
         active_rows: &BTreeMap,
-        newest_selection_head: Option,
+        relative_line_base: Option,
         snapshot: &EditorSnapshot,
         window: &mut Window,
         cx: &mut App,
@@ -3304,32 +3244,16 @@ impl EditorElement {
             return Arc::default();
         }
 
-        let (newest_selection_head, relative) = self.editor.update(cx, |editor, cx| {
-            let newest_selection_head = newest_selection_head.unwrap_or_else(|| {
-                let newest = editor
-                    .selections
-                    .newest::(&editor.display_snapshot(cx));
-                SelectionLayout::new(
-                    newest,
-                    editor.selections.line_mode(),
-                    editor.cursor_offset_on_selection,
-                    editor.cursor_shape,
-                    &snapshot.display_snapshot,
-                    true,
-                    true,
-                    None,
-                )
-                .head
-            });
-            let relative = editor.relative_line_numbers(cx);
-            (newest_selection_head, relative)
-        });
+        let relative = self.editor.read(cx).relative_line_numbers(cx);
 
         let relative_line_numbers_enabled = relative.enabled();
-        let relative_to = relative_line_numbers_enabled.then(|| newest_selection_head.row());
+        let relative_rows = if relative_line_numbers_enabled && let Some(base) = relative_line_base
+        {
+            snapshot.calculate_relative_line_numbers(&rows, base, relative.wrapped())
+        } else {
+            Default::default()
+        };
 
-        let relative_rows =
-            self.calculate_relative_line_numbers(snapshot, &rows, relative_to, relative.wrapped());
         let mut line_number = String::new();
         let segments = buffer_rows.iter().enumerate().flat_map(|(ix, row_info)| {
             let display_row = DisplayRow(rows.start.0 + ix as u32);
@@ -4652,6 +4576,8 @@ impl EditorElement {
         gutter_hitbox: &Hitbox,
         text_hitbox: &Hitbox,
         style: &EditorStyle,
+        relative_line_numbers: RelativeLineNumbers,
+        relative_to: Option,
         window: &mut Window,
         cx: &mut App,
     ) -> Option {
@@ -4681,9 +4607,21 @@ impl EditorElement {
             );
 
             let line_number = show_line_numbers.then(|| {
-                let number = (start_point.row + 1).to_string();
+                let relative_number = relative_to.and_then(|base| match relative_line_numbers {
+                    RelativeLineNumbers::Disabled => None,
+                    RelativeLineNumbers::Enabled => {
+                        Some(snapshot.relative_line_delta_to_point(base, start_point))
+                    }
+                    RelativeLineNumbers::Wrapped => {
+                        Some(snapshot.relative_wrapped_line_delta_to_point(base, start_point))
+                    }
+                });
+                let number = relative_number
+                    .filter(|&delta| delta != 0)
+                    .map(|delta| delta.unsigned_abs() as u32)
+                    .unwrap_or(start_point.row + 1);
                 let color = cx.theme().colors().editor_line_number;
-                self.shape_line_number(SharedString::from(number), color, window)
+                self.shape_line_number(SharedString::from(number.to_string()), color, window)
             });
 
             lines.push(StickyHeaderLine::new(
@@ -9436,6 +9374,28 @@ impl Element for EditorElement {
                             window,
                             cx,
                         );
+
+                    // relative rows are based on newest selection, even outside the visible area
+                    let relative_row_base =  self.editor.update(cx, |editor, cx| {
+                        if editor.selections.count()==0 {
+                            return None;
+                        }
+                            let newest = editor
+                                .selections
+                                .newest::(&editor.display_snapshot(cx));
+                            Some(SelectionLayout::new(
+                                newest,
+                                editor.selections.line_mode(),
+                                editor.cursor_offset_on_selection,
+                                editor.cursor_shape,
+                                &snapshot.display_snapshot,
+                                true,
+                                true,
+                                None,
+                            )
+                            .head.row())
+                        });
+
                     let mut breakpoint_rows = self.editor.update(cx, |editor, cx| {
                         editor.active_breakpoints(start_row..end_row, window, cx)
                     });
@@ -9453,7 +9413,7 @@ impl Element for EditorElement {
                         start_row..end_row,
                         &row_infos,
                         &active_rows,
-                        newest_selection_head,
+                        relative_row_base,
                         &snapshot,
                         window,
                         cx,
@@ -9773,6 +9733,7 @@ impl Element for EditorElement {
                         && is_singleton
                         && EditorSettings::get_global(cx).sticky_scroll.enabled
                     {
+                        let relative = self.editor.read(cx).relative_line_numbers(cx);
                         self.layout_sticky_headers(
                             &snapshot,
                             editor_width,
@@ -9784,6 +9745,8 @@ impl Element for EditorElement {
                             &gutter_hitbox,
                             &text_hitbox,
                             &style,
+                            relative,
+                            relative_row_base,
                             window,
                             cx,
                         )
@@ -11631,7 +11594,7 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_shape_line_numbers(cx: &mut TestAppContext) {
+    fn test_layout_line_numbers(cx: &mut TestAppContext) {
         init_test(cx, |_| {});
         let window = cx.add_window(|window, cx| {
             let buffer = MultiBuffer::build_simple(&sample_text(6, 6, 'a'), cx);
@@ -11671,7 +11634,7 @@ mod tests {
                         })
                         .collect::>(),
                     &BTreeMap::default(),
-                    Some(DisplayPoint::new(DisplayRow(0), 0)),
+                    Some(DisplayRow(0)),
                     &snapshot,
                     window,
                     cx,
@@ -11683,10 +11646,9 @@ mod tests {
         let relative_rows = window
             .update(cx, |editor, window, cx| {
                 let snapshot = editor.snapshot(window, cx);
-                element.calculate_relative_line_numbers(
-                    &snapshot,
+                snapshot.calculate_relative_line_numbers(
                     &(DisplayRow(0)..DisplayRow(6)),
-                    Some(DisplayRow(3)),
+                    DisplayRow(3),
                     false,
                 )
             })
@@ -11702,10 +11664,9 @@ mod tests {
         let relative_rows = window
             .update(cx, |editor, window, cx| {
                 let snapshot = editor.snapshot(window, cx);
-                element.calculate_relative_line_numbers(
-                    &snapshot,
+                snapshot.calculate_relative_line_numbers(
                     &(DisplayRow(3)..DisplayRow(6)),
-                    Some(DisplayRow(1)),
+                    DisplayRow(1),
                     false,
                 )
             })
@@ -11719,10 +11680,9 @@ mod tests {
         let relative_rows = window
             .update(cx, |editor, window, cx| {
                 let snapshot = editor.snapshot(window, cx);
-                element.calculate_relative_line_numbers(
-                    &snapshot,
+                snapshot.calculate_relative_line_numbers(
                     &(DisplayRow(0)..DisplayRow(3)),
-                    Some(DisplayRow(6)),
+                    DisplayRow(6),
                     false,
                 )
             })
@@ -11759,7 +11719,7 @@ mod tests {
                         })
                         .collect::>(),
                     &BTreeMap::default(),
-                    Some(DisplayPoint::new(DisplayRow(0), 0)),
+                    Some(DisplayRow(0)),
                     &snapshot,
                     window,
                     cx,
@@ -11774,7 +11734,7 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_shape_line_numbers_wrapping(cx: &mut TestAppContext) {
+    fn test_layout_line_numbers_wrapping(cx: &mut TestAppContext) {
         init_test(cx, |_| {});
         let window = cx.add_window(|window, cx| {
             let buffer = MultiBuffer::build_simple(&sample_text(6, 6, 'a'), cx);
@@ -11819,7 +11779,7 @@ mod tests {
                         })
                         .collect::>(),
                     &BTreeMap::default(),
-                    Some(DisplayPoint::new(DisplayRow(0), 0)),
+                    Some(DisplayRow(0)),
                     &snapshot,
                     window,
                     cx,
@@ -11831,10 +11791,9 @@ mod tests {
         let relative_rows = window
             .update(cx, |editor, window, cx| {
                 let snapshot = editor.snapshot(window, cx);
-                element.calculate_relative_line_numbers(
-                    &snapshot,
+                snapshot.calculate_relative_line_numbers(
                     &(DisplayRow(0)..DisplayRow(6)),
-                    Some(DisplayRow(3)),
+                    DisplayRow(3),
                     true,
                 )
             })
@@ -11871,7 +11830,7 @@ mod tests {
                         })
                         .collect::>(),
                     &BTreeMap::from_iter([(DisplayRow(0), LineHighlightSpec::default())]),
-                    Some(DisplayPoint::new(DisplayRow(0), 0)),
+                    Some(DisplayRow(0)),
                     &snapshot,
                     window,
                     cx,
@@ -11886,10 +11845,9 @@ mod tests {
         let relative_rows = window
             .update(cx, |editor, window, cx| {
                 let snapshot = editor.snapshot(window, cx);
-                element.calculate_relative_line_numbers(
-                    &snapshot,
+                snapshot.calculate_relative_line_numbers(
                     &(DisplayRow(0)..DisplayRow(6)),
-                    Some(DisplayRow(3)),
+                    DisplayRow(3),
                     true,
                 )
             })

From b53f661515af405c339400fda585e2372b96bb1b Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 11:53:39 -0600
Subject: [PATCH 241/266] docs: Fix auto docs GitHub Action (#45383)

Small fixes to Droid workflow

Release Notes:

- N/A

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .github/workflows/docs_automation.yml | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index e4aa79c7fc09d6d7735ac82e2315d68b923d5323..bf0d27ba632e72eb79253c602bf6363bd5fa8e79 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -37,9 +37,13 @@ jobs:
           fetch-depth: 0
 
       - name: Install Droid CLI
+        id: install-droid
         run: |
           curl -fsSL https://cli.factory.ai/install.sh | bash
           echo "${HOME}/.factory/bin" >> "$GITHUB_PATH"
+          echo "DROID_BIN=${HOME}/.factory/bin/droid" >> "$GITHUB_ENV"
+          # Verify installation
+          "${HOME}/.factory/bin/droid" --version
 
       - name: Setup Node.js (for Prettier)
         uses: actions/setup-node@v4
@@ -85,7 +89,7 @@ jobs:
       - name: "Phase 2: Explore Repository"
         id: phase2
         run: |
-          droid exec \
+          "$DROID_BIN" exec \
             --model "$DROID_MODEL" \
             --autonomy read-only \
             --prompt-file .factory/prompts/docs-automation/phase2-explore.md \
@@ -99,7 +103,7 @@ jobs:
         id: phase3
         run: |
           CHANGED_FILES=$(tr '\n' ' ' < /tmp/changed_files.txt)
-          droid exec \
+          "$DROID_BIN" exec \
             --model "$DROID_MODEL" \
             --autonomy read-only \
             --prompt-file .factory/prompts/docs-automation/phase3-analyze.md \
@@ -114,7 +118,7 @@ jobs:
       - name: "Phase 4: Plan Documentation Impact"
         id: phase4
         run: |
-          droid exec \
+          "$DROID_BIN" exec \
             --model "$DROID_MODEL" \
             --autonomy read-only \
             --prompt-file .factory/prompts/docs-automation/phase4-plan.md \
@@ -137,7 +141,7 @@ jobs:
         id: phase5
         if: steps.phase4.outputs.updates_required == 'true'
         run: |
-          droid exec \
+          "$DROID_BIN" exec \
             --model "$DROID_MODEL" \
             --autonomy medium \
             --prompt-file .factory/prompts/docs-automation/phase5-apply.md \
@@ -170,7 +174,7 @@ jobs:
           # Get git diff of docs
           git diff docs/src/ > /tmp/docs-diff.txt || true
           
-          droid exec \
+          "$DROID_BIN" exec \
             --model "$DROID_MODEL" \
             --autonomy read-only \
             --prompt-file .factory/prompts/docs-automation/phase6-summarize.md \

From 1edd050baf20cfde8bfc8885d632ab163b302370 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miguel=20Raz=20Guzm=C3=A1n=20Macedo?= 
Date: Fri, 19 Dec 2025 12:09:40 -0600
Subject: [PATCH 242/266] Add script/triage_watcher.jl (#45384)

Release Notes:

- N/A
---
 script/triage_watcher.jl | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 script/triage_watcher.jl

diff --git a/script/triage_watcher.jl b/script/triage_watcher.jl
new file mode 100644
index 0000000000000000000000000000000000000000..905d2fdd4eb73c7bcbed304f9d4d94d0d94943f2
--- /dev/null
+++ b/script/triage_watcher.jl
@@ -0,0 +1,38 @@
+## Triage Watcher v0.1
+# This is a small script to watch for new issues on the Zed repository and open them in a new browser tab interactively.
+#
+## Installing Julia
+#
+# You need Julia installed on your system:
+# curl -fsSL https://install.julialang.org | sh
+#
+## Running this script:
+# 1. It only works on Macos/Linux
+# Open a new Julia repl with `julia` inside the `zed` repo
+# 2. Paste the following code
+# 3. Whenever you close your computer, just type the Up arrow on the REPL + enter to rerun the loop again to resume
+function get_issues()
+    entries = filter(x -> occursin("state:needs triage", x), split(read(`gh issue list -L 10`, String), '\n'))
+    top = findfirst.('\t', entries) .- 1
+    [entries[i][begin:top[i]] for i in eachindex(entries)]
+end
+
+nums = get_issues();
+while true
+    new_nums = get_issues()
+    # Open each new issue in a new browser tab
+    for issue_num in setdiff(new_nums, nums)
+        url = "https://github.com/zed-industries/zed/issues/" * issue_num
+        println("\nOpening $url")
+        open_tab = `/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome $url`
+        try
+            sound_file = "/Users/mrg/Downloads/mario_coin_sound.mp3"
+            run(`afplay -v 0.02 $sound_file`)
+        finally
+        end
+        run(open_tab)
+    end
+    nums = new_nums
+    print("🧘🏼")
+    sleep(60)
+end

From 22916311cd2b7d98d89d1ba72b5a567373472e2d Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 12:12:14 -0600
Subject: [PATCH 243/266] ci: Fix Factory CLI installation URL (#45386)

Change from cli.factory.ai/install.sh to app.factory.ai/cli per official
Factory documentation.

Release Notes:

- N/A

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .github/workflows/docs_automation.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index bf0d27ba632e72eb79253c602bf6363bd5fa8e79..a59022e6f641fa5a351c29240fc6bdcc560228f5 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -39,7 +39,7 @@ jobs:
       - name: Install Droid CLI
         id: install-droid
         run: |
-          curl -fsSL https://cli.factory.ai/install.sh | bash
+          curl -fsSL https://app.factory.ai/cli | sh
           echo "${HOME}/.factory/bin" >> "$GITHUB_PATH"
           echo "DROID_BIN=${HOME}/.factory/bin/droid" >> "$GITHUB_ENV"
           # Verify installation

From 1bc3fa81543f6159a5f607a9b01c83c2ae5c309a Mon Sep 17 00:00:00 2001
From: Ichimura Tomoo 
Date: Sat, 20 Dec 2025 03:18:20 +0900
Subject: [PATCH 244/266] Correct UTF-16 saving and add heuristic encoding
 detection (#45243)

This commit fixes an issue where saving UTF-16 files resulted in UTF-8
bytes due to `encoding_rs` default behavior. It also introduces a
heuristic to detect BOM-less UTF-16 and binary files.

Changes:
- Manually implement UTF-16LE/BE encoding during file save to avoid
implicit UTF-8 conversion.
- Add `analyze_byte_content` to guess UTF-16LE/BE or Binary based on
null byte distribution.
- Prevent loading binary files as text by returning an error when binary
content is detected.

Special thanks to @CrazyboyQCD for pointing out the `encoding_rs`
behavior and providing the fix, and to @ConradIrwin for the suggestion
on the detection heuristic.

Closes #14654

Release Notes:

- (nightly only) Fixed an issue where saving files with UTF-16 encoding
incorrectly wrote them as UTF-8. Also improved detection for binary
files and BOM-less UTF-16.
---
 crates/language/src/buffer.rs         |  18 +-
 crates/worktree/src/worktree.rs       | 140 +++++++++---
 crates/worktree/src/worktree_tests.rs | 306 +++++++++++++++++---------
 3 files changed, 331 insertions(+), 133 deletions(-)

diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 99e0c8d4ebdad709eea0e9ab6dbdf9d889d54ec5..5f46340b41a876443f1d12724450d2d8b30f9b33 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -1490,19 +1490,23 @@ impl Buffer {
         let (tx, rx) = futures::channel::oneshot::channel();
         let prev_version = self.text.version();
         self.reload_task = Some(cx.spawn(async move |this, cx| {
-            let Some((new_mtime, new_text)) = this.update(cx, |this, cx| {
+            let Some((new_mtime, load_bytes_task, encoding)) = this.update(cx, |this, cx| {
                 let file = this.file.as_ref()?.as_local()?;
-
-                Some((file.disk_state().mtime(), file.load(cx)))
+                Some((
+                    file.disk_state().mtime(),
+                    file.load_bytes(cx),
+                    this.encoding,
+                ))
             })?
             else {
                 return Ok(());
             };
 
-            let new_text = new_text.await?;
-            let diff = this
-                .update(cx, |this, cx| this.diff(new_text.clone(), cx))?
-                .await;
+            let bytes = load_bytes_task.await?;
+            let (cow, _encoding_used, _has_errors) = encoding.decode(&bytes);
+            let new_text = cow.into_owned();
+
+            let diff = this.update(cx, |this, cx| this.diff(new_text, cx))?.await;
             this.update(cx, |this, cx| {
                 if this.version() == diff.base_version {
                     this.finalize_last_transaction();
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index 7145bccd514fbb5d6093efda765a826162c91260..f5f632e65d71b683d1a491b1fc9e9a612f5c24a5 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -1361,7 +1361,7 @@ impl LocalWorktree {
             }
 
             let content = fs.load_bytes(&abs_path).await?;
-            let (text, encoding, has_bom) = decode_byte(content);
+            let (text, encoding, has_bom) = decode_byte(content)?;
 
             let worktree = this.upgrade().context("worktree was dropped")?;
             let file = match entry.await? {
@@ -1489,25 +1489,12 @@ impl LocalWorktree {
             let fs = fs.clone();
             let abs_path = abs_path.clone();
             async move {
-                let bom_bytes = if has_bom {
-                    if encoding == encoding_rs::UTF_16LE {
-                        vec![0xFF, 0xFE]
-                    } else if encoding == encoding_rs::UTF_16BE {
-                        vec![0xFE, 0xFF]
-                    } else if encoding == encoding_rs::UTF_8 {
-                        vec![0xEF, 0xBB, 0xBF]
-                    } else {
-                        vec![]
-                    }
-                } else {
-                    vec![]
-                };
-
                 // For UTF-8, use the optimized `fs.save` which writes Rope chunks directly to disk
                 // without allocating a contiguous string.
                 if encoding == encoding_rs::UTF_8 && !has_bom {
                     return fs.save(&abs_path, &text, line_ending).await;
                 }
+
                 // For legacy encodings (e.g. Shift-JIS), we fall back to converting the entire Rope
                 // to a String/Bytes in memory before writing.
                 //
@@ -1520,13 +1507,45 @@ impl LocalWorktree {
                     LineEnding::Windows => text_string.replace('\n', "\r\n"),
                 };
 
-                let (cow, _, _) = encoding.encode(&normalized_text);
-                let bytes = if !bom_bytes.is_empty() {
-                    let mut bytes = bom_bytes;
-                    bytes.extend_from_slice(&cow);
-                    bytes.into()
+                // Create the byte vector manually for UTF-16 encodings because encoding_rs encodes to UTF-8 by default (per WHATWG standards),
+                //  which is not what we want for saving files.
+                let bytes = if encoding == encoding_rs::UTF_16BE {
+                    let mut data = Vec::with_capacity(normalized_text.len() * 2 + 2);
+                    if has_bom {
+                        data.extend_from_slice(&[0xFE, 0xFF]); // BOM
+                    }
+                    let utf16be_bytes =
+                        normalized_text.encode_utf16().flat_map(|u| u.to_be_bytes());
+                    data.extend(utf16be_bytes);
+                    data.into()
+                } else if encoding == encoding_rs::UTF_16LE {
+                    let mut data = Vec::with_capacity(normalized_text.len() * 2 + 2);
+                    if has_bom {
+                        data.extend_from_slice(&[0xFF, 0xFE]); // BOM
+                    }
+                    let utf16le_bytes =
+                        normalized_text.encode_utf16().flat_map(|u| u.to_le_bytes());
+                    data.extend(utf16le_bytes);
+                    data.into()
                 } else {
-                    cow
+                    // For other encodings (Shift-JIS, UTF-8 with BOM, etc.), delegate to encoding_rs.
+                    let bom_bytes = if has_bom {
+                        if encoding == encoding_rs::UTF_8 {
+                            vec![0xEF, 0xBB, 0xBF]
+                        } else {
+                            vec![]
+                        }
+                    } else {
+                        vec![]
+                    };
+                    let (cow, _, _) = encoding.encode(&normalized_text);
+                    if !bom_bytes.is_empty() {
+                        let mut bytes = bom_bytes;
+                        bytes.extend_from_slice(&cow);
+                        bytes.into()
+                    } else {
+                        cow
+                    }
                 };
 
                 fs.write(&abs_path, &bytes).await
@@ -5842,11 +5861,28 @@ impl fs::Watcher for NullWatcher {
     }
 }
 
-fn decode_byte(bytes: Vec) -> (String, &'static Encoding, bool) {
+fn decode_byte(bytes: Vec) -> anyhow::Result<(String, &'static Encoding, bool)> {
     // check BOM
     if let Some((encoding, _bom_len)) = Encoding::for_bom(&bytes) {
         let (cow, _) = encoding.decode_with_bom_removal(&bytes);
-        return (cow.into_owned(), encoding, true);
+        return Ok((cow.into_owned(), encoding, true));
+    }
+
+    match analyze_byte_content(&bytes) {
+        ByteContent::Utf16Le => {
+            let encoding = encoding_rs::UTF_16LE;
+            let (cow, _, _) = encoding.decode(&bytes);
+            return Ok((cow.into_owned(), encoding, false));
+        }
+        ByteContent::Utf16Be => {
+            let encoding = encoding_rs::UTF_16BE;
+            let (cow, _, _) = encoding.decode(&bytes);
+            return Ok((cow.into_owned(), encoding, false));
+        }
+        ByteContent::Binary => {
+            anyhow::bail!("Binary files are not supported");
+        }
+        ByteContent::Unknown => {}
     }
 
     fn detect_encoding(bytes: Vec) -> (String, &'static Encoding) {
@@ -5867,14 +5903,66 @@ fn decode_byte(bytes: Vec) -> (String, &'static Encoding, bool) {
             // displaying raw escape sequences instead of the correct characters.
             if text.contains('\x1b') {
                 let (s, enc) = detect_encoding(text.into_bytes());
-                (s, enc, false)
+                Ok((s, enc, false))
             } else {
-                (text, encoding_rs::UTF_8, false)
+                Ok((text, encoding_rs::UTF_8, false))
             }
         }
         Err(e) => {
             let (s, enc) = detect_encoding(e.into_bytes());
-            (s, enc, false)
+            Ok((s, enc, false))
         }
     }
 }
+
+#[derive(PartialEq)]
+enum ByteContent {
+    Utf16Le,
+    Utf16Be,
+    Binary,
+    Unknown,
+}
+// Heuristic check using null byte distribution.
+// NOTE: This relies on the presence of ASCII characters (which become `0x00` in UTF-16).
+// Files consisting purely of non-ASCII characters (like Japanese) may not be detected here
+// and will result in `Unknown`.
+fn analyze_byte_content(bytes: &[u8]) -> ByteContent {
+    if bytes.len() < 2 {
+        return ByteContent::Unknown;
+    }
+
+    let check_len = bytes.len().min(1024);
+    let sample = &bytes[..check_len];
+
+    if !sample.contains(&0) {
+        return ByteContent::Unknown;
+    }
+
+    let mut even_nulls = 0;
+    let mut odd_nulls = 0;
+
+    for (i, &byte) in sample.iter().enumerate() {
+        if byte == 0 {
+            if i % 2 == 0 {
+                even_nulls += 1;
+            } else {
+                odd_nulls += 1;
+            }
+        }
+    }
+
+    let total_nulls = even_nulls + odd_nulls;
+    if total_nulls < check_len / 10 {
+        return ByteContent::Unknown;
+    }
+
+    if even_nulls > odd_nulls * 4 {
+        return ByteContent::Utf16Be;
+    }
+
+    if odd_nulls > even_nulls * 4 {
+        return ByteContent::Utf16Le;
+    }
+
+    ByteContent::Binary
+}
diff --git a/crates/worktree/src/worktree_tests.rs b/crates/worktree/src/worktree_tests.rs
index 094a6d52ea4168752578eab06cea511a57e65c10..45d39710c6ea825aded4d29f447124ee4c2ecb33 100644
--- a/crates/worktree/src/worktree_tests.rs
+++ b/crates/worktree/src/worktree_tests.rs
@@ -1,5 +1,5 @@
 use crate::{Entry, EntryKind, Event, PathChange, Worktree, WorktreeModelHandle};
-use anyhow::{Context as _, Result};
+use anyhow::Result;
 use encoding_rs;
 use fs::{FakeFs, Fs, RealFs, RemoveOptions};
 use git::{DOT_GIT, GITIGNORE, REPO_EXCLUDE};
@@ -2568,71 +2568,87 @@ fn init_test(cx: &mut gpui::TestAppContext) {
 #[gpui::test]
 async fn test_load_file_encoding(cx: &mut TestAppContext) {
     init_test(cx);
-    let test_cases: Vec<(&str, &[u8], &str)> = vec![
-        ("utf8.txt", "こんにちは".as_bytes(), "こんにちは"), // "こんにちは" is Japanese "Hello"
-        (
-            "sjis.txt",
-            &[0x82, 0xb1, 0x82, 0xf1, 0x82, 0xc9, 0x82, 0xbf, 0x82, 0xcd],
-            "こんにちは",
-        ),
-        (
-            "eucjp.txt",
-            &[0xa4, 0xb3, 0xa4, 0xf3, 0xa4, 0xcb, 0xa4, 0xc1, 0xa4, 0xcf],
-            "こんにちは",
-        ),
-        (
-            "iso2022jp.txt",
-            &[
+
+    struct TestCase {
+        name: &'static str,
+        bytes: Vec,
+        expected_text: &'static str,
+    }
+
+    // --- Success Cases ---
+    let success_cases = vec![
+        TestCase {
+            name: "utf8.txt",
+            bytes: "こんにちは".as_bytes().to_vec(),
+            expected_text: "こんにちは",
+        },
+        TestCase {
+            name: "sjis.txt",
+            bytes: vec![0x82, 0xb1, 0x82, 0xf1, 0x82, 0xc9, 0x82, 0xbf, 0x82, 0xcd],
+            expected_text: "こんにちは",
+        },
+        TestCase {
+            name: "eucjp.txt",
+            bytes: vec![0xa4, 0xb3, 0xa4, 0xf3, 0xa4, 0xcb, 0xa4, 0xc1, 0xa4, 0xcf],
+            expected_text: "こんにちは",
+        },
+        TestCase {
+            name: "iso2022jp.txt",
+            bytes: vec![
                 0x1b, 0x24, 0x42, 0x24, 0x33, 0x24, 0x73, 0x24, 0x4b, 0x24, 0x41, 0x24, 0x4f, 0x1b,
                 0x28, 0x42,
             ],
-            "こんにちは",
-        ),
-        // Western Europe (Windows-1252)
-        // "Café" -> 0xE9 is 'é' in Windows-1252 (it is typically 0xC3 0xA9 in UTF-8)
-        ("win1252.txt", &[0x43, 0x61, 0x66, 0xe9], "Café"),
-        // Chinese Simplified (GBK)
-        // Note: We use a slightly longer string here because short byte sequences can be ambiguous
-        // in multi-byte encodings. Providing more context helps the heuristic detector guess correctly.
-        // Text: "今天天气不错" (Today's weather is not bad / nice)
-        // Bytes:
-        //   今: BD F1
-        //   天: CC EC
-        //   天: CC EC
-        //   气: C6 F8
-        //   不: B2 BB
-        //   错: B4 ED
-        (
-            "gbk.txt",
-            &[
+            expected_text: "こんにちは",
+        },
+        TestCase {
+            name: "win1252.txt",
+            bytes: vec![0x43, 0x61, 0x66, 0xe9],
+            expected_text: "Café",
+        },
+        TestCase {
+            name: "gbk.txt",
+            bytes: vec![
                 0xbd, 0xf1, 0xcc, 0xec, 0xcc, 0xec, 0xc6, 0xf8, 0xb2, 0xbb, 0xb4, 0xed,
             ],
-            "今天天气不错",
-        ),
-        (
-            "utf16le_bom.txt",
-            &[
+            expected_text: "今天天气不错",
+        },
+        // UTF-16LE with BOM
+        TestCase {
+            name: "utf16le_bom.txt",
+            bytes: vec![
                 0xFF, 0xFE, // BOM
-                0x53, 0x30, // こ
-                0x93, 0x30, // ん
-                0x6B, 0x30, // に
-                0x61, 0x30, // ち
-                0x6F, 0x30, // は
+                0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F, 0x30,
             ],
-            "こんにちは",
-        ),
-        (
-            "utf8_bom.txt",
-            &[
-                0xEF, 0xBB, 0xBF, // UTF-8 BOM
-                0xE3, 0x81, 0x93, // こ
-                0xE3, 0x82, 0x93, // ん
-                0xE3, 0x81, 0xAB, // に
-                0xE3, 0x81, 0xA1, // ち
-                0xE3, 0x81, 0xAF, // は
+            expected_text: "こんにちは",
+        },
+        // UTF-16BE with BOM
+        TestCase {
+            name: "utf16be_bom.txt",
+            bytes: vec![
+                0xFE, 0xFF, // BOM
+                0x30, 0x53, 0x30, 0x93, 0x30, 0x6B, 0x30, 0x61, 0x30, 0x6F,
             ],
-            "こんにちは",
-        ),
+            expected_text: "こんにちは",
+        },
+        // UTF-16LE without BOM (ASCII only)
+        // This relies on the "null byte heuristic" we implemented.
+        // "ABC" -> 41 00 42 00 43 00
+        TestCase {
+            name: "utf16le_ascii_no_bom.txt",
+            bytes: vec![0x41, 0x00, 0x42, 0x00, 0x43, 0x00],
+            expected_text: "ABC",
+        },
+    ];
+
+    // --- Failure Cases ---
+    let failure_cases = vec![
+        // Binary File (Should be detected by heuristic and return Error)
+        // Contains random bytes and mixed nulls that don't match UTF-16 patterns
+        TestCase {
+            name: "binary.bin",
+            bytes: vec![0x00, 0xFF, 0x12, 0x00, 0x99, 0x88, 0x77, 0x66, 0x00],
+            expected_text: "", // Not used
+        },
     ];
 
     let root_path = if cfg!(windows) {
@@ -2642,15 +2658,11 @@ async fn test_load_file_encoding(cx: &mut TestAppContext) {
     };
 
     let fs = FakeFs::new(cx.background_executor.clone());
+    fs.create_dir(root_path).await.unwrap();
 
-    let mut files_json = serde_json::Map::new();
-    for (name, _, _) in &test_cases {
-        files_json.insert(name.to_string(), serde_json::Value::String("".to_string()));
-    }
-
-    for (name, bytes, _) in &test_cases {
-        let path = root_path.join(name);
-        fs.write(&path, bytes).await.unwrap();
+    for case in success_cases.iter().chain(failure_cases.iter()) {
+        let path = root_path.join(case.name);
+        fs.write(&path, &case.bytes).await.unwrap();
     }
 
     let tree = Worktree::local(
@@ -2667,34 +2679,54 @@ async fn test_load_file_encoding(cx: &mut TestAppContext) {
     cx.read(|cx| tree.read(cx).as_local().unwrap().scan_complete())
         .await;
 
-    for (name, _, expected) in test_cases {
-        let loaded = tree
-            .update(cx, |tree, cx| tree.load_file(rel_path(name), cx))
-            .await
-            .with_context(|| format!("Failed to load {}", name))
-            .unwrap();
+    let rel_path = |name: &str| {
+        RelPath::new(&Path::new(name), PathStyle::local())
+            .unwrap()
+            .into_arc()
+    };
 
+    // Run Success Tests
+    for case in success_cases {
+        let loaded = tree
+            .update(cx, |tree, cx| tree.load_file(&rel_path(case.name), cx))
+            .await;
+        if let Err(e) = &loaded {
+            panic!("Failed to load success case '{}': {:?}", case.name, e);
+        }
+        let loaded = loaded.unwrap();
         assert_eq!(
-            loaded.text, expected,
+            loaded.text, case.expected_text,
             "Encoding mismatch for file: {}",
-            name
+            case.name
         );
     }
+
+    // Run Failure Tests
+    for case in failure_cases {
+        let loaded = tree
+            .update(cx, |tree, cx| tree.load_file(&rel_path(case.name), cx))
+            .await;
+        assert!(
+            loaded.is_err(),
+            "Failure case '{}' unexpectedly succeeded! It should have been detected as binary.",
+            case.name
+        );
+        let err_msg = loaded.unwrap_err().to_string();
+        println!("Got expected error for {}: {}", case.name, err_msg);
+    }
 }
 
 #[gpui::test]
 async fn test_write_file_encoding(cx: &mut gpui::TestAppContext) {
     init_test(cx);
     let fs = FakeFs::new(cx.executor());
+
     let root_path = if cfg!(windows) {
         Path::new("C:\\root")
     } else {
         Path::new("/root")
     };
     fs.create_dir(root_path).await.unwrap();
-    let file_path = root_path.join("test.txt");
-
-    fs.insert_file(&file_path, "initial".into()).await;
 
     let worktree = Worktree::local(
         root_path,
@@ -2707,33 +2739,107 @@ async fn test_write_file_encoding(cx: &mut gpui::TestAppContext) {
     .await
     .unwrap();
 
-    let path: Arc = Path::new("test.txt").into();
-    let rel_path = RelPath::new(&path, PathStyle::local()).unwrap().into_arc();
+    // Define test case structure
+    struct TestCase {
+        name: &'static str,
+        text: &'static str,
+        encoding: &'static encoding_rs::Encoding,
+        has_bom: bool,
+        expected_bytes: Vec,
+    }
 
-    let text = text::Rope::from("こんにちは");
+    let cases = vec![
+        // Shift_JIS with Japanese
+        TestCase {
+            name: "Shift_JIS with Japanese",
+            text: "こんにちは",
+            encoding: encoding_rs::SHIFT_JIS,
+            has_bom: false,
+            expected_bytes: vec![0x82, 0xb1, 0x82, 0xf1, 0x82, 0xc9, 0x82, 0xbf, 0x82, 0xcd],
+        },
+        // UTF-8 No BOM
+        TestCase {
+            name: "UTF-8 No BOM",
+            text: "AB",
+            encoding: encoding_rs::UTF_8,
+            has_bom: false,
+            expected_bytes: vec![0x41, 0x42],
+        },
+        // UTF-8 with BOM
+        TestCase {
+            name: "UTF-8 with BOM",
+            text: "AB",
+            encoding: encoding_rs::UTF_8,
+            has_bom: true,
+            expected_bytes: vec![0xEF, 0xBB, 0xBF, 0x41, 0x42],
+        },
+        // UTF-16LE No BOM with Japanese
+        // NOTE: This passes thanks to the manual encoding fix implemented in `write_file`.
+        TestCase {
+            name: "UTF-16LE No BOM with Japanese",
+            text: "こんにちは",
+            encoding: encoding_rs::UTF_16LE,
+            has_bom: false,
+            expected_bytes: vec![0x53, 0x30, 0x93, 0x30, 0x6b, 0x30, 0x61, 0x30, 0x6f, 0x30],
+        },
+        // UTF-16LE with BOM
+        TestCase {
+            name: "UTF-16LE with BOM",
+            text: "A",
+            encoding: encoding_rs::UTF_16LE,
+            has_bom: true,
+            expected_bytes: vec![0xFF, 0xFE, 0x41, 0x00],
+        },
+        // UTF-16BE No BOM with Japanese
+        // NOTE: This passes thanks to the manual encoding fix.
+        TestCase {
+            name: "UTF-16BE No BOM with Japanese",
+            text: "こんにちは",
+            encoding: encoding_rs::UTF_16BE,
+            has_bom: false,
+            expected_bytes: vec![0x30, 0x53, 0x30, 0x93, 0x30, 0x6b, 0x30, 0x61, 0x30, 0x6f],
+        },
+        // UTF-16BE with BOM
+        TestCase {
+            name: "UTF-16BE with BOM",
+            text: "A",
+            encoding: encoding_rs::UTF_16BE,
+            has_bom: true,
+            expected_bytes: vec![0xFE, 0xFF, 0x00, 0x41],
+        },
+    ];
 
-    let task = worktree.update(cx, |wt, cx| {
-        wt.write_file(
-            rel_path,
-            text,
-            text::LineEnding::Unix,
-            encoding_rs::SHIFT_JIS,
-            false,
-            cx,
-        )
-    });
+    for (i, case) in cases.into_iter().enumerate() {
+        let file_name = format!("test_{}.txt", i);
+        let path: Arc = Path::new(&file_name).into();
+        let file_path = root_path.join(&file_name);
 
-    task.await.unwrap();
+        fs.insert_file(&file_path, "".into()).await;
 
-    let bytes = fs.load_bytes(&file_path).await.unwrap();
+        let rel_path = RelPath::new(&path, PathStyle::local()).unwrap().into_arc();
+        let text = text::Rope::from(case.text);
 
-    let expected_bytes = vec![
-        0x82, 0xb1, // こ
-        0x82, 0xf1, // ん
-        0x82, 0xc9, // に
-        0x82, 0xbf, // ち
-        0x82, 0xcd, // は
-    ];
+        let task = worktree.update(cx, |wt, cx| {
+            wt.write_file(
+                rel_path,
+                text,
+                text::LineEnding::Unix,
+                case.encoding,
+                case.has_bom,
+                cx,
+            )
+        });
+
+        if let Err(e) = task.await {
+            panic!("Unexpected error in case '{}': {:?}", case.name, e);
+        }
+
+        let bytes = fs.load_bytes(&file_path).await.unwrap();
 
-    assert_eq!(bytes, expected_bytes, "Should be saved as Shift-JIS");
+        assert_eq!(
+            bytes, case.expected_bytes,
+            "case '{}' mismatch. Expected {:?}, but got {:?}",
+            case.name, case.expected_bytes, bytes
+        );
+    }
 }

From e61f9081d44a99f4f04259c7b8efdcd1cc8c0ca7 Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 12:24:23 -0600
Subject: [PATCH 245/266] docs: More droid docs debugging (#45388)

Path issues

Release Notes:

- N/A

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .github/workflows/docs_automation.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index a59022e6f641fa5a351c29240fc6bdcc560228f5..ba0236fe91d3efe5975777e3df31eedf884e224d 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -40,10 +40,10 @@ jobs:
         id: install-droid
         run: |
           curl -fsSL https://app.factory.ai/cli | sh
-          echo "${HOME}/.factory/bin" >> "$GITHUB_PATH"
-          echo "DROID_BIN=${HOME}/.factory/bin/droid" >> "$GITHUB_ENV"
+          echo "${HOME}/.local/bin" >> "$GITHUB_PATH"
+          echo "DROID_BIN=${HOME}/.local/bin/droid" >> "$GITHUB_ENV"
           # Verify installation
-          "${HOME}/.factory/bin/droid" --version
+          "${HOME}/.local/bin/droid" --version
 
       - name: Setup Node.js (for Prettier)
         uses: actions/setup-node@v4

From 07db88a327baa2904d6c3ed9bc17cda7ff1f0e86 Mon Sep 17 00:00:00 2001
From: Cole Miller 
Date: Fri, 19 Dec 2025 14:08:49 -0500
Subject: [PATCH 246/266] git: Optimistically stage hunks when staging a file,
 take 2 (#45278)

Relanding #43434 with an improved approach.

Release Notes:

- N/A

---------

Co-authored-by: Ramon <55579979+van-sprundel@users.noreply.github.com>
---
 crates/buffer_diff/src/buffer_diff.rs |  28 ++++
 crates/project/src/git_store.rs       | 229 +++++++++++++++++---------
 crates/project/src/project_tests.rs   | 143 ++++++++++++++++
 3 files changed, 321 insertions(+), 79 deletions(-)

diff --git a/crates/buffer_diff/src/buffer_diff.rs b/crates/buffer_diff/src/buffer_diff.rs
index 22525096d3cbca456aa114b5acc9b4239b570dda..111b18233b6500de7de4485c8a408eec1e8cb822 100644
--- a/crates/buffer_diff/src/buffer_diff.rs
+++ b/crates/buffer_diff/src/buffer_diff.rs
@@ -1159,6 +1159,34 @@ impl BufferDiff {
         new_index_text
     }
 
+    pub fn stage_or_unstage_all_hunks(
+        &mut self,
+        stage: bool,
+        buffer: &text::BufferSnapshot,
+        file_exists: bool,
+        cx: &mut Context,
+    ) {
+        let hunks = self
+            .hunks_intersecting_range(Anchor::MIN..Anchor::MAX, buffer, cx)
+            .collect::>();
+        let Some(secondary) = self.secondary_diff.as_ref() else {
+            return;
+        };
+        self.inner.stage_or_unstage_hunks_impl(
+            &secondary.read(cx).inner,
+            stage,
+            &hunks,
+            buffer,
+            file_exists,
+        );
+        if let Some((first, last)) = hunks.first().zip(hunks.last()) {
+            let changed_range = first.buffer_range.start..last.buffer_range.end;
+            cx.emit(BufferDiffEvent::DiffChanged {
+                changed_range: Some(changed_range),
+            });
+        }
+    }
+
     pub fn range_to_hunk_range(
         &self,
         range: Range,
diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index 85ff38ab67f873d8197729de9577075951676597..d490a2cfdc843a1984bf3f719692af2dcf39aaaa 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -4205,74 +4205,29 @@ impl Repository {
         entries: Vec,
         cx: &mut Context,
     ) -> Task> {
-        if entries.is_empty() {
-            return Task::ready(Ok(()));
-        }
-        let id = self.id;
-        let save_tasks = self.save_buffers(&entries, cx);
-        let paths = entries
-            .iter()
-            .map(|p| p.as_unix_str())
-            .collect::>()
-            .join(" ");
-        let status = format!("git add {paths}");
-        let job_key = GitJobKey::WriteIndex(entries.clone());
-
-        self.spawn_job_with_tracking(
-            entries.clone(),
-            pending_op::GitStatus::Staged,
-            cx,
-            async move |this, cx| {
-                for save_task in save_tasks {
-                    save_task.await?;
-                }
-
-                this.update(cx, |this, _| {
-                    this.send_keyed_job(
-                        Some(job_key),
-                        Some(status.into()),
-                        move |git_repo, _cx| async move {
-                            match git_repo {
-                                RepositoryState::Local(LocalRepositoryState {
-                                    backend,
-                                    environment,
-                                    ..
-                                }) => backend.stage_paths(entries, environment.clone()).await,
-                                RepositoryState::Remote(RemoteRepositoryState {
-                                    project_id,
-                                    client,
-                                }) => {
-                                    client
-                                        .request(proto::Stage {
-                                            project_id: project_id.0,
-                                            repository_id: id.to_proto(),
-                                            paths: entries
-                                                .into_iter()
-                                                .map(|repo_path| repo_path.to_proto())
-                                                .collect(),
-                                        })
-                                        .await
-                                        .context("sending stage request")?;
-
-                                    Ok(())
-                                }
-                            }
-                        },
-                    )
-                })?
-                .await?
-            },
-        )
+        self.stage_or_unstage_entries(true, entries, cx)
     }
 
     pub fn unstage_entries(
         &mut self,
         entries: Vec,
         cx: &mut Context,
+    ) -> Task> {
+        self.stage_or_unstage_entries(false, entries, cx)
+    }
+
+    fn stage_or_unstage_entries(
+        &mut self,
+        stage: bool,
+        entries: Vec,
+        cx: &mut Context,
     ) -> Task> {
         if entries.is_empty() {
             return Task::ready(Ok(()));
         }
+        let Some(git_store) = self.git_store.upgrade() else {
+            return Task::ready(Ok(()));
+        };
         let id = self.id;
         let save_tasks = self.save_buffers(&entries, cx);
         let paths = entries
@@ -4280,48 +4235,164 @@ impl Repository {
             .map(|p| p.as_unix_str())
             .collect::>()
             .join(" ");
-        let status = format!("git reset {paths}");
+        let status = if stage {
+            format!("git add {paths}")
+        } else {
+            format!("git reset {paths}")
+        };
         let job_key = GitJobKey::WriteIndex(entries.clone());
 
         self.spawn_job_with_tracking(
             entries.clone(),
-            pending_op::GitStatus::Unstaged,
+            if stage {
+                pending_op::GitStatus::Staged
+            } else {
+                pending_op::GitStatus::Unstaged
+            },
             cx,
             async move |this, cx| {
                 for save_task in save_tasks {
                     save_task.await?;
                 }
 
-                this.update(cx, |this, _| {
+                this.update(cx, |this, cx| {
+                    let weak_this = cx.weak_entity();
                     this.send_keyed_job(
                         Some(job_key),
                         Some(status.into()),
-                        move |git_repo, _cx| async move {
-                            match git_repo {
+                        move |git_repo, mut cx| async move {
+                            let hunk_staging_operation_counts = weak_this
+                                .update(&mut cx, |this, cx| {
+                                    let mut hunk_staging_operation_counts = HashMap::default();
+                                    for path in &entries {
+                                        let Some(project_path) =
+                                            this.repo_path_to_project_path(path, cx)
+                                        else {
+                                            continue;
+                                        };
+                                        let Some(buffer) = git_store
+                                            .read(cx)
+                                            .buffer_store
+                                            .read(cx)
+                                            .get_by_path(&project_path)
+                                        else {
+                                            continue;
+                                        };
+                                        let Some(diff_state) = git_store
+                                            .read(cx)
+                                            .diffs
+                                            .get(&buffer.read(cx).remote_id())
+                                            .cloned()
+                                        else {
+                                            continue;
+                                        };
+                                        let Some(uncommitted_diff) =
+                                            diff_state.read(cx).uncommitted_diff.as_ref().and_then(
+                                                |uncommitted_diff| uncommitted_diff.upgrade(),
+                                            )
+                                        else {
+                                            continue;
+                                        };
+                                        let buffer_snapshot = buffer.read(cx).text_snapshot();
+                                        let file_exists = buffer
+                                            .read(cx)
+                                            .file()
+                                            .is_some_and(|file| file.disk_state().exists());
+                                        let hunk_staging_operation_count =
+                                            diff_state.update(cx, |diff_state, cx| {
+                                                uncommitted_diff.update(
+                                                    cx,
+                                                    |uncommitted_diff, cx| {
+                                                        uncommitted_diff
+                                                            .stage_or_unstage_all_hunks(
+                                                                stage,
+                                                                &buffer_snapshot,
+                                                                file_exists,
+                                                                cx,
+                                                            );
+                                                    },
+                                                );
+
+                                                diff_state.hunk_staging_operation_count += 1;
+                                                diff_state.hunk_staging_operation_count
+                                            });
+                                        hunk_staging_operation_counts.insert(
+                                            diff_state.downgrade(),
+                                            hunk_staging_operation_count,
+                                        );
+                                    }
+                                    hunk_staging_operation_counts
+                                })
+                                .unwrap_or_default();
+
+                            let result = match git_repo {
                                 RepositoryState::Local(LocalRepositoryState {
                                     backend,
                                     environment,
                                     ..
-                                }) => backend.unstage_paths(entries, environment).await,
+                                }) => {
+                                    if stage {
+                                        backend.stage_paths(entries, environment.clone()).await
+                                    } else {
+                                        backend.unstage_paths(entries, environment.clone()).await
+                                    }
+                                }
                                 RepositoryState::Remote(RemoteRepositoryState {
                                     project_id,
                                     client,
                                 }) => {
-                                    client
-                                        .request(proto::Unstage {
-                                            project_id: project_id.0,
-                                            repository_id: id.to_proto(),
-                                            paths: entries
-                                                .into_iter()
-                                                .map(|repo_path| repo_path.to_proto())
-                                                .collect(),
-                                        })
-                                        .await
-                                        .context("sending unstage request")?;
-
-                                    Ok(())
+                                    if stage {
+                                        client
+                                            .request(proto::Stage {
+                                                project_id: project_id.0,
+                                                repository_id: id.to_proto(),
+                                                paths: entries
+                                                    .into_iter()
+                                                    .map(|repo_path| repo_path.to_proto())
+                                                    .collect(),
+                                            })
+                                            .await
+                                            .context("sending stage request")
+                                            .map(|_| ())
+                                    } else {
+                                        client
+                                            .request(proto::Unstage {
+                                                project_id: project_id.0,
+                                                repository_id: id.to_proto(),
+                                                paths: entries
+                                                    .into_iter()
+                                                    .map(|repo_path| repo_path.to_proto())
+                                                    .collect(),
+                                            })
+                                            .await
+                                            .context("sending unstage request")
+                                            .map(|_| ())
+                                    }
                                 }
+                            };
+
+                            for (diff_state, hunk_staging_operation_count) in
+                                hunk_staging_operation_counts
+                            {
+                                diff_state
+                                    .update(&mut cx, |diff_state, cx| {
+                                        if result.is_ok() {
+                                            diff_state.hunk_staging_operation_count_as_of_write =
+                                                hunk_staging_operation_count;
+                                        } else if let Some(uncommitted_diff) =
+                                            &diff_state.uncommitted_diff
+                                        {
+                                            uncommitted_diff
+                                                .update(cx, |uncommitted_diff, cx| {
+                                                    uncommitted_diff.clear_pending_hunks(cx);
+                                                })
+                                                .ok();
+                                        }
+                                    })
+                                    .ok();
                             }
+
+                            result
                         },
                     )
                 })?
@@ -4347,7 +4418,7 @@ impl Repository {
                 }
             })
             .collect();
-        self.stage_entries(to_stage, cx)
+        self.stage_or_unstage_entries(true, to_stage, cx)
     }
 
     pub fn unstage_all(&mut self, cx: &mut Context) -> Task> {
@@ -4367,7 +4438,7 @@ impl Repository {
                 }
             })
             .collect();
-        self.unstage_entries(to_unstage, cx)
+        self.stage_or_unstage_entries(false, to_unstage, cx)
     }
 
     pub fn stash_all(&mut self, cx: &mut Context) -> Task> {
diff --git a/crates/project/src/project_tests.rs b/crates/project/src/project_tests.rs
index 4cebc72073cfda1bf07f028b1aff9fa7410c527d..921ca16323b300af3a02cc2e7f38b1cc6305615c 100644
--- a/crates/project/src/project_tests.rs
+++ b/crates/project/src/project_tests.rs
@@ -10922,3 +10922,146 @@ async fn test_git_worktree_remove(cx: &mut gpui::TestAppContext) {
     });
     assert!(active_repo_path.is_none());
 }
+
+#[gpui::test]
+async fn test_optimistic_hunks_in_staged_files(cx: &mut gpui::TestAppContext) {
+    use DiffHunkSecondaryStatus::*;
+    init_test(cx);
+
+    let committed_contents = r#"
+        one
+        two
+        three
+    "#
+    .unindent();
+    let file_contents = r#"
+        one
+        TWO
+        three
+    "#
+    .unindent();
+
+    let fs = FakeFs::new(cx.background_executor.clone());
+    fs.insert_tree(
+        path!("/dir"),
+        json!({
+            ".git": {},
+            "file.txt": file_contents.clone()
+        }),
+    )
+    .await;
+
+    fs.set_head_and_index_for_repo(
+        path!("/dir/.git").as_ref(),
+        &[("file.txt", committed_contents.clone())],
+    );
+
+    let project = Project::test(fs.clone(), [path!("/dir").as_ref()], cx).await;
+
+    let buffer = project
+        .update(cx, |project, cx| {
+            project.open_local_buffer(path!("/dir/file.txt"), cx)
+        })
+        .await
+        .unwrap();
+    let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
+    let uncommitted_diff = project
+        .update(cx, |project, cx| {
+            project.open_uncommitted_diff(buffer.clone(), cx)
+        })
+        .await
+        .unwrap();
+
+    // The hunk is initially unstaged.
+    uncommitted_diff.read_with(cx, |diff, cx| {
+        assert_hunks(
+            diff.hunks(&snapshot, cx),
+            &snapshot,
+            &diff.base_text_string().unwrap(),
+            &[(
+                1..2,
+                "two\n",
+                "TWO\n",
+                DiffHunkStatus::modified(HasSecondaryHunk),
+            )],
+        );
+    });
+
+    // Get the repository handle.
+    let repo = project.read_with(cx, |project, cx| {
+        project.repositories(cx).values().next().unwrap().clone()
+    });
+
+    // Stage the file.
+    let stage_task = repo.update(cx, |repo, cx| {
+        repo.stage_entries(vec![repo_path("file.txt")], cx)
+    });
+
+    // Run a few ticks to let the job start and mark hunks as pending,
+    // but don't run_until_parked which would complete the entire operation.
+    for _ in 0..10 {
+        cx.executor().tick();
+        let [hunk]: [_; 1] = uncommitted_diff
+            .read_with(cx, |diff, cx| diff.hunks(&snapshot, cx).collect::>())
+            .try_into()
+            .unwrap();
+        match hunk.secondary_status {
+            HasSecondaryHunk => {}
+            SecondaryHunkRemovalPending => break,
+            NoSecondaryHunk => panic!("hunk was not optimistically staged"),
+            _ => panic!("unexpected hunk state"),
+        }
+    }
+    uncommitted_diff.read_with(cx, |diff, cx| {
+        assert_hunks(
+            diff.hunks(&snapshot, cx),
+            &snapshot,
+            &diff.base_text_string().unwrap(),
+            &[(
+                1..2,
+                "two\n",
+                "TWO\n",
+                DiffHunkStatus::modified(SecondaryHunkRemovalPending),
+            )],
+        );
+    });
+
+    // Let the staging complete.
+    stage_task.await.unwrap();
+    cx.run_until_parked();
+
+    // The hunk is now fully staged.
+    uncommitted_diff.read_with(cx, |diff, cx| {
+        assert_hunks(
+            diff.hunks(&snapshot, cx),
+            &snapshot,
+            &diff.base_text_string().unwrap(),
+            &[(
+                1..2,
+                "two\n",
+                "TWO\n",
+                DiffHunkStatus::modified(NoSecondaryHunk),
+            )],
+        );
+    });
+
+    // Simulate a commit by updating HEAD to match the current file contents.
+    // The FakeGitRepository's commit method is a no-op, so we need to manually
+    // update HEAD to simulate the commit completing.
+    fs.set_head_for_repo(
+        path!("/dir/.git").as_ref(),
+        &[("file.txt", file_contents.clone())],
+        "newhead",
+    );
+    cx.run_until_parked();
+
+    // After committing, there are no more hunks.
+    uncommitted_diff.read_with(cx, |diff, cx| {
+        assert_hunks(
+            diff.hunks(&snapshot, cx),
+            &snapshot,
+            &diff.base_text_string().unwrap(),
+            &[] as &[(Range, &str, &str, DiffHunkStatus)],
+        );
+    });
+}

From bb2f037407289605081f44a8d956b11763d034f0 Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 13:20:05 -0600
Subject: [PATCH 247/266] docs: Droid doesn't know its own commands (#45391)

Correctly uses droid commands in auto docs actions

Release Notes:

- N/A

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .github/workflows/docs_automation.yml | 82 +++++++++++++--------------
 1 file changed, 40 insertions(+), 42 deletions(-)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index ba0236fe91d3efe5975777e3df31eedf884e224d..4c1551c0a91d243896aceef161d85472e8b07021 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -85,71 +85,74 @@ jobs:
 
       # Phase 0: Guardrails are loaded via AGENTS.md in each phase
 
-      # Phase 2: Explore Repository (Read-Only)
+      # Phase 2: Explore Repository (Read-Only - default)
       - name: "Phase 2: Explore Repository"
         id: phase2
         run: |
           "$DROID_BIN" exec \
-            --model "$DROID_MODEL" \
-            --autonomy read-only \
-            --prompt-file .factory/prompts/docs-automation/phase2-explore.md \
-            --output /tmp/phase2-output.json \
-            --format json
+            -m "$DROID_MODEL" \
+            -f .factory/prompts/docs-automation/phase2-explore.md \
+            > /tmp/phase2-output.txt 2>&1 || true
           echo "Repository exploration complete"
-          cat /tmp/phase2-output.json
+          cat /tmp/phase2-output.txt
 
-      # Phase 3: Analyze Changes (Read-Only)
+      # Phase 3: Analyze Changes (Read-Only - default)
       - name: "Phase 3: Analyze Changes"
         id: phase3
         run: |
           CHANGED_FILES=$(tr '\n' ' ' < /tmp/changed_files.txt)
+          echo "Analyzing changes in: $CHANGED_FILES"
+          
+          # Build prompt with context
+          cat > /tmp/phase3-prompt.md << 'EOF'
+          $(cat .factory/prompts/docs-automation/phase3-analyze.md)
+          
+          ## Context
+          
+          ### Changed Files
+          $CHANGED_FILES
+          
+          ### Phase 2 Output
+          $(cat /tmp/phase2-output.txt)
+          EOF
+          
           "$DROID_BIN" exec \
-            --model "$DROID_MODEL" \
-            --autonomy read-only \
-            --prompt-file .factory/prompts/docs-automation/phase3-analyze.md \
-            --context "Changed files: $CHANGED_FILES" \
-            --context-file /tmp/phase2-output.json \
-            --output /tmp/phase3-output.md \
-            --format markdown
+            -m "$DROID_MODEL" \
+            "$(cat .factory/prompts/docs-automation/phase3-analyze.md)
+            
+            Changed files: $CHANGED_FILES" \
+            > /tmp/phase3-output.md 2>&1 || true
           echo "Change analysis complete"
           cat /tmp/phase3-output.md
 
-      # Phase 4: Plan Documentation Impact (Read-Only)
+      # Phase 4: Plan Documentation Impact (Read-Only - default)
       - name: "Phase 4: Plan Documentation Impact"
         id: phase4
         run: |
           "$DROID_BIN" exec \
-            --model "$DROID_MODEL" \
-            --autonomy read-only \
-            --prompt-file .factory/prompts/docs-automation/phase4-plan.md \
-            --context-file /tmp/phase3-output.md \
-            --context-file docs/AGENTS.md \
-            --output /tmp/phase4-plan.md \
-            --format markdown
+            -m "$DROID_MODEL" \
+            -f .factory/prompts/docs-automation/phase4-plan.md \
+            > /tmp/phase4-plan.md 2>&1 || true
           echo "Documentation plan complete"
           cat /tmp/phase4-plan.md
           
           # Check if updates are required
-          if grep -q "Documentation Updates Required: No" /tmp/phase4-plan.md; then
+          if grep -q "NO_UPDATES_REQUIRED" /tmp/phase4-plan.md; then
             echo "updates_required=false" >> "$GITHUB_OUTPUT"
           else
             echo "updates_required=true" >> "$GITHUB_OUTPUT"
           fi
 
-      # Phase 5: Apply Plan (Write-Enabled)
+      # Phase 5: Apply Plan (Write-Enabled with --auto medium)
       - name: "Phase 5: Apply Documentation Plan"
         id: phase5
         if: steps.phase4.outputs.updates_required == 'true'
         run: |
           "$DROID_BIN" exec \
-            --model "$DROID_MODEL" \
-            --autonomy medium \
-            --prompt-file .factory/prompts/docs-automation/phase5-apply.md \
-            --context-file /tmp/phase4-plan.md \
-            --context-file docs/AGENTS.md \
-            --context-file docs/.rules \
-            --output /tmp/phase5-report.md \
-            --format markdown
+            -m "$DROID_MODEL" \
+            --auto medium \
+            -f .factory/prompts/docs-automation/phase5-apply.md \
+            > /tmp/phase5-report.md 2>&1 || true
           echo "Documentation updates applied"
           cat /tmp/phase5-report.md
 
@@ -166,7 +169,7 @@ jobs:
           
           echo "Prettier formatting complete"
 
-      # Phase 6: Summarize Changes
+      # Phase 6: Summarize Changes (Read-Only - default)
       - name: "Phase 6: Summarize Changes"
         id: phase6
         if: steps.phase4.outputs.updates_required == 'true'
@@ -175,14 +178,9 @@ jobs:
           git diff docs/src/ > /tmp/docs-diff.txt || true
           
           "$DROID_BIN" exec \
-            --model "$DROID_MODEL" \
-            --autonomy read-only \
-            --prompt-file .factory/prompts/docs-automation/phase6-summarize.md \
-            --context-file /tmp/phase5-report.md \
-            --context-file /tmp/phase3-output.md \
-            --context "Trigger SHA: ${{ steps.changed.outputs.sha }}" \
-            --output /tmp/phase6-summary.md \
-            --format markdown
+            -m "$DROID_MODEL" \
+            -f .factory/prompts/docs-automation/phase6-summarize.md \
+            > /tmp/phase6-summary.md 2>&1 || true
           echo "Summary generated"
           cat /tmp/phase6-summary.md
 

From 56646e6bc32a1c66eb6972edfe59ad65f64af3a7 Mon Sep 17 00:00:00 2001
From: Michael Benfield 
Date: Fri, 19 Dec 2025 11:37:57 -0800
Subject: [PATCH 248/266] Inline assistant: Don't scroll up too high (#45171)

In the case of large vertical_scroll_margin, we could scroll up such
that the assistant was out of view. Now, keep it no lower than the
center of the editor.

Closes #18058

Release Notes:

- N/A
---
 crates/agent_ui/src/inline_assistant.rs | 28 ++++++++++++-------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/crates/agent_ui/src/inline_assistant.rs b/crates/agent_ui/src/inline_assistant.rs
index 671579f9ef018b495b7993279a852595c78d3e02..b3c14c5a0ec332f66c300023759db9f09b94dc6f 100644
--- a/crates/agent_ui/src/inline_assistant.rs
+++ b/crates/agent_ui/src/inline_assistant.rs
@@ -1259,28 +1259,26 @@ impl InlineAssistant {
                 let bottom = top + 1.0;
                 (top, bottom)
             });
-            let mut scroll_target_top = scroll_target_range.0;
-            let mut scroll_target_bottom = scroll_target_range.1;
-
-            scroll_target_top -= editor.vertical_scroll_margin() as ScrollOffset;
-            scroll_target_bottom += editor.vertical_scroll_margin() as ScrollOffset;
-
             let height_in_lines = editor.visible_line_count().unwrap_or(0.);
+            let vertical_scroll_margin = editor.vertical_scroll_margin() as ScrollOffset;
+            let scroll_target_top = (scroll_target_range.0 - vertical_scroll_margin)
+                // Don't scroll up too far in the case of a large vertical_scroll_margin.
+                .max(scroll_target_range.0 - height_in_lines / 2.0);
+            let scroll_target_bottom = (scroll_target_range.1 + vertical_scroll_margin)
+                // Don't scroll down past where the top would still be visible.
+                .min(scroll_target_top + height_in_lines);
+
             let scroll_top = editor.scroll_position(cx).y;
             let scroll_bottom = scroll_top + height_in_lines;
 
             if scroll_target_top < scroll_top {
                 editor.set_scroll_position(point(0., scroll_target_top), window, cx);
             } else if scroll_target_bottom > scroll_bottom {
-                if (scroll_target_bottom - scroll_target_top) <= height_in_lines {
-                    editor.set_scroll_position(
-                        point(0., scroll_target_bottom - height_in_lines),
-                        window,
-                        cx,
-                    );
-                } else {
-                    editor.set_scroll_position(point(0., scroll_target_top), window, cx);
-                }
+                editor.set_scroll_position(
+                    point(0., scroll_target_bottom - height_in_lines),
+                    window,
+                    cx,
+                );
             }
         });
     }

From 99224ccc758bbe0735a6ebd4f88e817e9cc8a259 Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 13:43:10 -0600
Subject: [PATCH 249/266] docs: Droid needs a real model (#45393)

Droid needs a specific model with a date
Release Notes:

- N/A

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .github/workflows/docs_automation.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index 4c1551c0a91d243896aceef161d85472e8b07021..7fa39168c3cfac8b79273906d2c1110a33df69f7 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -23,7 +23,7 @@ permissions:
 
 env:
   FACTORY_API_KEY: ${{ secrets.FACTORY_API_KEY }}
-  DROID_MODEL: claude-opus-4-5
+  DROID_MODEL: claude-opus-4-5-20251101
 
 jobs:
   docs-automation:

From 8e5d33ebc6093c6fd2dbcd4dc3a5e0c35a15ec49 Mon Sep 17 00:00:00 2001
From: Nathan Sobo 
Date: Fri, 19 Dec 2025 12:59:01 -0700
Subject: [PATCH 250/266] Make prompt store fail-open when DB contains
 undecodable records (#45312)

Release Notes

- N/A

---------

Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com>
---
 crates/prompt_store/src/prompt_store.rs | 91 ++++++++++++++++++++++++-
 1 file changed, 89 insertions(+), 2 deletions(-)

diff --git a/crates/prompt_store/src/prompt_store.rs b/crates/prompt_store/src/prompt_store.rs
index 2c45410c2aa172c8a4f7118a914cacca69ea7ca8..1f63acb1965428cf3dbc6b9b5739e249c13a9c31 100644
--- a/crates/prompt_store/src/prompt_store.rs
+++ b/crates/prompt_store/src/prompt_store.rs
@@ -193,7 +193,15 @@ impl MetadataCache {
     ) -> Result {
         let mut cache = MetadataCache::default();
         for result in db.iter(txn)? {
-            let (prompt_id, metadata) = result?;
+            // Fail-open: skip records that can't be decoded (e.g. from a different branch)
+            // rather than failing the entire prompt store initialization.
+            let Ok((prompt_id, metadata)) = result else {
+                log::warn!(
+                    "Skipping unreadable prompt record in database: {:?}",
+                    result.err()
+                );
+                continue;
+            };
             cache.metadata.push(metadata.clone());
             cache.metadata_by_id.insert(prompt_id, metadata);
         }
@@ -677,7 +685,86 @@ mod tests {
         assert_eq!(
             loaded_after_reset.trim(),
             expected_content_after_reset.trim(),
-            "After saving default content, load should return default"
+            "Content should be back to default after saving default content"
+        );
+    }
+
+    /// Test that the prompt store initializes successfully even when the database
+    /// contains records with incompatible/undecodable PromptId keys (e.g., from
+    /// a different branch that used a different serialization format).
+    ///
+    /// This is a regression test for the "fail-open" behavior: we should skip
+    /// bad records rather than failing the entire store initialization.
+    #[gpui::test]
+    async fn test_prompt_store_handles_incompatible_db_records(cx: &mut TestAppContext) {
+        cx.executor().allow_parking();
+
+        let temp_dir = tempfile::tempdir().unwrap();
+        let db_path = temp_dir.path().join("prompts-db-with-bad-records");
+        std::fs::create_dir_all(&db_path).unwrap();
+
+        // First, create the DB and write an incompatible record directly.
+        // We simulate a record written by a different branch that used
+        // `{"kind":"CommitMessage"}` instead of `{"kind":"BuiltIn", ...}`.
+        {
+            let db_env = unsafe {
+                heed::EnvOpenOptions::new()
+                    .map_size(1024 * 1024 * 1024)
+                    .max_dbs(4)
+                    .open(&db_path)
+                    .unwrap()
+            };
+
+            let mut txn = db_env.write_txn().unwrap();
+            // Create the metadata.v2 database with raw bytes so we can write
+            // an incompatible key format.
+            let metadata_db: Database = db_env
+                .create_database(&mut txn, Some("metadata.v2"))
+                .unwrap();
+
+            // Write an incompatible PromptId key: `{"kind":"CommitMessage"}`
+            // This is the old/branch format that current code can't decode.
+            let bad_key = br#"{"kind":"CommitMessage"}"#;
+            let dummy_metadata = br#"{"id":{"kind":"CommitMessage"},"title":"Bad Record","default":false,"saved_at":"2024-01-01T00:00:00Z"}"#;
+            metadata_db.put(&mut txn, bad_key, dummy_metadata).unwrap();
+
+            // Also write a valid record to ensure we can still read good data.
+            let good_key = br#"{"kind":"User","uuid":"550e8400-e29b-41d4-a716-446655440000"}"#;
+            let good_metadata = br#"{"id":{"kind":"User","uuid":"550e8400-e29b-41d4-a716-446655440000"},"title":"Good Record","default":false,"saved_at":"2024-01-01T00:00:00Z"}"#;
+            metadata_db.put(&mut txn, good_key, good_metadata).unwrap();
+
+            txn.commit().unwrap();
+        }
+
+        // Now try to create a PromptStore from this DB.
+        // With fail-open behavior, this should succeed and skip the bad record.
+        // Without fail-open, this would return an error.
+        let store_result = cx.update(|cx| PromptStore::new(db_path, cx)).await;
+
+        assert!(
+            store_result.is_ok(),
+            "PromptStore should initialize successfully even with incompatible DB records. \
+             Got error: {:?}",
+            store_result.err()
+        );
+
+        let store = cx.new(|_cx| store_result.unwrap());
+
+        // Verify the good record was loaded.
+        let good_id = PromptId::User {
+            uuid: UserPromptId("550e8400-e29b-41d4-a716-446655440000".parse().unwrap()),
+        };
+        let metadata = store.read_with(cx, |store, _| store.metadata(good_id));
+        assert!(
+            metadata.is_some(),
+            "Valid records should still be loaded after skipping bad ones"
+        );
+        assert_eq!(
+            metadata
+                .as_ref()
+                .and_then(|m| m.title.as_ref().map(|t| t.as_ref())),
+            Some("Good Record"),
+            "Valid record should have correct title"
         );
     }
 }

From b091cc4d9a42773e536960ffc0f2393775158bf9 Mon Sep 17 00:00:00 2001
From: Nathan Sobo 
Date: Fri, 19 Dec 2025 13:04:41 -0700
Subject: [PATCH 251/266] Enforce 5MB per-image limit when converting images
 for language models (#45313)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

## Problem

When users paste or drag large images into the agent panel, the encoded
payload can exceed upstream provider limits (e.g., Anthropic's 5MB
per-image limit), causing API errors.

## Solution

Enforce a default 5MB limit on encoded PNG bytes in
`LanguageModelImage::from_image`:

1. Apply existing Anthropic dimension limits first (1568px max in either
dimension)
2. Iteratively downscale by ~15% per pass until the encoded PNG is under
5MB
3. Return `None` if the image can't be shrunk within 8 passes
(fail-safe)

The limit is enforced at the `LanguageModelImage` conversion layer,
which is the choke point for all image ingestion paths (agent panel
paste/drag, file mentions, text threads, etc.).

## Future Work

The 5MB limit is a conservative default. Provider-specific limits can be
introduced later by adding a `from_image_with_constraints` API.

## Testing

Added a regression test that:
1. Generates a noisy 4096x4096 PNG (guaranteed >5MB)
2. Converts it via `LanguageModelImage::from_image`
3. Asserts the result is ≤5MB and was actually downscaled

---

**Note:** This PR builds on #45312 (prompt store fail-open fix). Please
merge that first.

cc @rtfeldman

---------

Co-authored-by: Zed Zippy <234243425+zed-zippy[bot]@users.noreply.github.com>
---
 crates/language_model/src/request.rs | 168 ++++++++++++++++++++++-----
 1 file changed, 138 insertions(+), 30 deletions(-)

diff --git a/crates/language_model/src/request.rs b/crates/language_model/src/request.rs
index 5e99cca4f9d6e61672c541cb90a3a1ca7da91203..96ed0907427c305211b1484e17ab61d434781ed6 100644
--- a/crates/language_model/src/request.rs
+++ b/crates/language_model/src/request.rs
@@ -8,6 +8,7 @@ use gpui::{
     App, AppContext as _, DevicePixels, Image, ImageFormat, ObjectFit, SharedString, Size, Task,
     point, px, size,
 };
+use image::GenericImageView as _;
 use image::codecs::png::PngEncoder;
 use serde::{Deserialize, Serialize};
 use util::ResultExt;
@@ -80,6 +81,16 @@ impl std::fmt::Debug for LanguageModelImage {
 /// Anthropic wants uploaded images to be smaller than this in both dimensions.
 const ANTHROPIC_SIZE_LIMIT: f32 = 1568.;
 
+/// Default per-image hard limit (in bytes) for the encoded image payload we send upstream.
+///
+/// NOTE: `LanguageModelImage.source` is base64-encoded PNG bytes (without the `data:` prefix).
+/// This limit is enforced on the encoded PNG bytes *before* base64 encoding.
+const DEFAULT_IMAGE_MAX_BYTES: usize = 5 * 1024 * 1024;
+
+/// Conservative cap on how many times we'll attempt to shrink/re-encode an image to fit
+/// `DEFAULT_IMAGE_MAX_BYTES`.
+const MAX_IMAGE_DOWNSCALE_PASSES: usize = 8;
+
 impl LanguageModelImage {
     pub fn empty() -> Self {
         Self {
@@ -112,29 +123,62 @@ impl LanguageModelImage {
             let height = dynamic_image.height();
             let image_size = size(DevicePixels(width as i32), DevicePixels(height as i32));
 
-            let base64_image = {
-                if image_size.width.0 > ANTHROPIC_SIZE_LIMIT as i32
-                    || image_size.height.0 > ANTHROPIC_SIZE_LIMIT as i32
-                {
-                    let new_bounds = ObjectFit::ScaleDown.get_bounds(
-                        gpui::Bounds {
-                            origin: point(px(0.0), px(0.0)),
-                            size: size(px(ANTHROPIC_SIZE_LIMIT), px(ANTHROPIC_SIZE_LIMIT)),
-                        },
-                        image_size,
-                    );
-                    let resized_image = dynamic_image.resize(
-                        new_bounds.size.width.into(),
-                        new_bounds.size.height.into(),
-                        image::imageops::FilterType::Triangle,
-                    );
-
-                    encode_as_base64(data, resized_image)
-                } else {
-                    encode_as_base64(data, dynamic_image)
+            // First apply any provider-specific dimension constraints we know about (Anthropic).
+            let mut processed_image = if image_size.width.0 > ANTHROPIC_SIZE_LIMIT as i32
+                || image_size.height.0 > ANTHROPIC_SIZE_LIMIT as i32
+            {
+                let new_bounds = ObjectFit::ScaleDown.get_bounds(
+                    gpui::Bounds {
+                        origin: point(px(0.0), px(0.0)),
+                        size: size(px(ANTHROPIC_SIZE_LIMIT), px(ANTHROPIC_SIZE_LIMIT)),
+                    },
+                    image_size,
+                );
+                dynamic_image.resize(
+                    new_bounds.size.width.into(),
+                    new_bounds.size.height.into(),
+                    image::imageops::FilterType::Triangle,
+                )
+            } else {
+                dynamic_image
+            };
+
+            // Then enforce a default per-image size cap on the encoded PNG bytes.
+            //
+            // We always send PNG bytes (either original PNG bytes, or re-encoded PNG) base64'd.
+            // The upstream provider limit we want to respect is effectively on the binary image
+            // payload size, so we enforce against the encoded PNG bytes before base64 encoding.
+            let mut encoded_png = encode_png_bytes(&processed_image).log_err()?;
+            for _pass in 0..MAX_IMAGE_DOWNSCALE_PASSES {
+                if encoded_png.len() <= DEFAULT_IMAGE_MAX_BYTES {
+                    break;
                 }
+
+                // Scale down geometrically to converge quickly. We don't know the final PNG size
+                // as a function of pixels, so we iteratively shrink.
+                let (w, h) = processed_image.dimensions();
+                if w <= 1 || h <= 1 {
+                    break;
+                }
+
+                // Shrink by ~15% each pass (0.85). This is a compromise between speed and
+                // preserving image detail.
+                let new_w = ((w as f32) * 0.85).round().max(1.0) as u32;
+                let new_h = ((h as f32) * 0.85).round().max(1.0) as u32;
+
+                processed_image =
+                    processed_image.resize(new_w, new_h, image::imageops::FilterType::Triangle);
+                encoded_png = encode_png_bytes(&processed_image).log_err()?;
             }
-            .log_err()?;
+
+            if encoded_png.len() > DEFAULT_IMAGE_MAX_BYTES {
+                // Still too large after multiple passes; treat as non-convertible for now.
+                // (Provider-specific handling can be introduced later.)
+                return None;
+            }
+
+            // Now base64 encode the PNG bytes.
+            let base64_image = encode_bytes_as_base64(encoded_png.as_slice()).log_err()?;
 
             // SAFETY: The base64 encoder should not produce non-UTF8.
             let source = unsafe { String::from_utf8_unchecked(base64_image) };
@@ -164,21 +208,20 @@ impl LanguageModelImage {
     }
 }
 
-fn encode_as_base64(data: Arc, image: image::DynamicImage) -> Result> {
+fn encode_png_bytes(image: &image::DynamicImage) -> Result> {
+    let mut png = Vec::new();
+    image.write_with_encoder(PngEncoder::new(&mut png))?;
+    Ok(png)
+}
+
+fn encode_bytes_as_base64(bytes: &[u8]) -> Result> {
     let mut base64_image = Vec::new();
     {
         let mut base64_encoder = EncoderWriter::new(
             Cursor::new(&mut base64_image),
             &base64::engine::general_purpose::STANDARD,
         );
-        if data.format() == ImageFormat::Png {
-            base64_encoder.write_all(data.bytes())?;
-        } else {
-            let mut png = Vec::new();
-            image.write_with_encoder(PngEncoder::new(&mut png))?;
-
-            base64_encoder.write_all(png.as_slice())?;
-        }
+        base64_encoder.write_all(bytes)?;
     }
     Ok(base64_image)
 }
@@ -417,6 +460,71 @@ pub struct LanguageModelResponseMessage {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use base64::Engine as _;
+    use gpui::TestAppContext;
+    use image::ImageDecoder as _;
+
+    fn base64_to_png_bytes(base64_png: &str) -> Vec {
+        base64::engine::general_purpose::STANDARD
+            .decode(base64_png.as_bytes())
+            .expect("base64 should decode")
+    }
+
+    fn png_dimensions(png_bytes: &[u8]) -> (u32, u32) {
+        let decoder =
+            image::codecs::png::PngDecoder::new(Cursor::new(png_bytes)).expect("png should decode");
+        decoder.dimensions()
+    }
+
+    fn make_noisy_png_bytes(width: u32, height: u32) -> Vec {
+        // Create an RGBA image with per-pixel variance to avoid PNG compressing too well.
+        let mut img = image::RgbaImage::new(width, height);
+        for y in 0..height {
+            for x in 0..width {
+                let r = ((x ^ y) & 0xFF) as u8;
+                let g = ((x.wrapping_mul(31) ^ y.wrapping_mul(17)) & 0xFF) as u8;
+                let b = ((x.wrapping_mul(131) ^ y.wrapping_mul(7)) & 0xFF) as u8;
+                img.put_pixel(x, y, image::Rgba([r, g, b, 0xFF]));
+            }
+        }
+
+        let mut out = Vec::new();
+        image::DynamicImage::ImageRgba8(img)
+            .write_with_encoder(PngEncoder::new(&mut out))
+            .expect("png encoding should succeed");
+        out
+    }
+
+    #[gpui::test]
+    async fn test_from_image_downscales_to_default_5mb_limit(cx: &mut TestAppContext) {
+        // Pick a size that reliably produces a PNG > 5MB when filled with noise.
+        // If this fails (image is too small), bump dimensions.
+        let original_png = make_noisy_png_bytes(4096, 4096);
+        assert!(
+            original_png.len() > DEFAULT_IMAGE_MAX_BYTES,
+            "precondition failed: noisy PNG must exceed DEFAULT_IMAGE_MAX_BYTES"
+        );
+
+        let image = gpui::Image::from_bytes(ImageFormat::Png, original_png);
+        let lm_image = cx
+            .update(|cx| LanguageModelImage::from_image(Arc::new(image), cx))
+            .await
+            .expect("image conversion should succeed");
+
+        let encoded_png = base64_to_png_bytes(lm_image.source.as_ref());
+        assert!(
+            encoded_png.len() <= DEFAULT_IMAGE_MAX_BYTES,
+            "expected encoded PNG <= DEFAULT_IMAGE_MAX_BYTES, got {} bytes",
+            encoded_png.len()
+        );
+
+        // Ensure we actually downscaled in pixels (not just re-encoded).
+        let (w, h) = png_dimensions(&encoded_png);
+        assert!(
+            w < 4096 || h < 4096,
+            "expected image to be downscaled in at least one dimension; got {w}x{h}"
+        );
+    }
 
     #[test]
     fn test_language_model_tool_result_content_deserialization() {

From 71f4dc2481746c850e9a624582b27a6ff1dcae73 Mon Sep 17 00:00:00 2001
From: morgankrey 
Date: Fri, 19 Dec 2025 14:10:16 -0600
Subject: [PATCH 252/266] docs: Stash local changes before branch checkout in
 droid auto docs CLI (#45395)

Stashes local changes before branch checkout in droid auto docs CLI

Release Notes:

- N/A

---------

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>
---
 .github/workflows/docs_automation.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index 7fa39168c3cfac8b79273906d2c1110a33df69f7..5b72bc4051f34ae890bc291281f8797312f5d52d 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -202,6 +202,9 @@ jobs:
           # Daily batch branch - one branch per day, multiple commits accumulate
           BRANCH_NAME="docs/auto-update-$(date +%Y-%m-%d)"
           
+          # Stash local changes from phase 5
+          git stash push -m "docs-automation-changes" -- docs/src/
+          
           # Check if branch already exists on remote
           if git ls-remote --exit-code --heads origin "$BRANCH_NAME" > /dev/null 2>&1; then
             echo "Branch $BRANCH_NAME exists, checking out and updating..."
@@ -212,6 +215,9 @@ jobs:
             git checkout -b "$BRANCH_NAME"
           fi
           
+          # Apply stashed changes
+          git stash pop || true
+          
           # Stage and commit
           git add docs/src/
           SUMMARY=$(head -50 < /tmp/phase6-summary.md)

From ff71f4d46d282aaf656ddc7d38324affabe88a89 Mon Sep 17 00:00:00 2001
From: Conrad Irwin 
Date: Fri, 19 Dec 2025 14:27:44 -0700
Subject: [PATCH 253/266] Run cargo fix as well as cargo clippy --fix (#45394)

Release Notes:

- N/A
---
 .github/workflows/autofix_pr.yml                | 4 ++++
 tooling/xtask/src/tasks/workflows/autofix_pr.rs | 7 +++++++
 2 files changed, 11 insertions(+)

diff --git a/.github/workflows/autofix_pr.yml b/.github/workflows/autofix_pr.yml
index d3688a722aa107efb3dfb95351404f43c9aece65..33da35cb2aec86e19c9c65c399542cf1a1b78943 100644
--- a/.github/workflows/autofix_pr.yml
+++ b/.github/workflows/autofix_pr.yml
@@ -54,6 +54,10 @@ jobs:
     - name: autofix_pr::run_autofix::run_cargo_fmt
       run: cargo fmt --all
       shell: bash -euxo pipefail {0}
+    - name: autofix_pr::run_autofix::run_cargo_fix
+      if: ${{ inputs.run_clippy }}
+      run: cargo fix --workspace --release --all-targets --all-features --allow-dirty --allow-staged
+      shell: bash -euxo pipefail {0}
     - name: autofix_pr::run_autofix::run_clippy_fix
       if: ${{ inputs.run_clippy }}
       run: cargo clippy --workspace --release --all-targets --all-features --fix --allow-dirty --allow-staged
diff --git a/tooling/xtask/src/tasks/workflows/autofix_pr.rs b/tooling/xtask/src/tasks/workflows/autofix_pr.rs
index ab59e735225dfb4f9658960a35a992553642b4c2..231cbb68500145a55506c53306e90dd5b47baeda 100644
--- a/tooling/xtask/src/tasks/workflows/autofix_pr.rs
+++ b/tooling/xtask/src/tasks/workflows/autofix_pr.rs
@@ -63,6 +63,12 @@ fn run_autofix(pr_number: &WorkflowInput, run_clippy: &WorkflowInput) -> NamedJo
         named::bash("cargo fmt --all")
     }
 
+    fn run_cargo_fix() -> Step {
+        named::bash(
+            "cargo fix --workspace --release --all-targets --all-features --allow-dirty --allow-staged",
+        )
+    }
+
     fn run_clippy_fix() -> Step {
         named::bash(
             "cargo clippy --workspace --release --all-targets --all-features --fix --allow-dirty --allow-staged",
@@ -101,6 +107,7 @@ fn run_autofix(pr_number: &WorkflowInput, run_clippy: &WorkflowInput) -> NamedJo
             .add_step(steps::setup_pnpm())
             .add_step(run_prettier_fix())
             .add_step(run_cargo_fmt())
+            .add_step(run_cargo_fix().if_condition(Expression::new(run_clippy.to_string())))
             .add_step(run_clippy_fix().if_condition(Expression::new(run_clippy.to_string())))
             .add_step(create_patch())
             .add_step(upload_patch_artifact())

From 3f4da03d38c7a244f1a9df0cd9e5d67a334a2f55 Mon Sep 17 00:00:00 2001
From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com>
Date: Fri, 19 Dec 2025 16:48:53 -0500
Subject: [PATCH 254/266] settings ui: Change window kind from floating to
 normal (#45401)

#40291 made floating windows always stay on top, which made the settings
ui window always on top of Zed. To maintain the old behavior, this PR
changes the setting window to be a normal window.

Release Notes:

- N/A
---
 crates/settings_ui/src/settings_ui.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/settings_ui/src/settings_ui.rs b/crates/settings_ui/src/settings_ui.rs
index 0ec6d0aee308ce3c20b67a5db9c6a6d9224bf229..a735553f78d487ad4def08a98886f422b113dba4 100644
--- a/crates/settings_ui/src/settings_ui.rs
+++ b/crates/settings_ui/src/settings_ui.rs
@@ -602,7 +602,7 @@ pub fn open_settings_editor(
                 focus: true,
                 show: true,
                 is_movable: true,
-                kind: gpui::WindowKind::Floating,
+                kind: gpui::WindowKind::Normal,
                 window_background: cx.theme().window_background_appearance(),
                 app_id: Some(app_id.to_owned()),
                 window_decorations: Some(window_decorations),

From 1c576ccf82a3404bf33ce727458eb922f40697ec Mon Sep 17 00:00:00 2001
From: Richard Feldman 
Date: Fri, 19 Dec 2025 17:04:43 -0500
Subject: [PATCH 255/266] Fix OpenRouter giving errors for some Anthropic
 models (#45399)

Fixes #44032

Release Notes:

- Fix OpenRouter giving errors for some Anthropic models
---
 .../src/provider/open_router.rs               | 38 ++++++++++++-------
 1 file changed, 25 insertions(+), 13 deletions(-)

diff --git a/crates/language_models/src/provider/open_router.rs b/crates/language_models/src/provider/open_router.rs
index 48d68ddebff7e0c9bbe39dbca696dd2ffcf62605..3b94947129d760bb0bcc9ea078eb023f138de272 100644
--- a/crates/language_models/src/provider/open_router.rs
+++ b/crates/language_models/src/provider/open_router.rs
@@ -370,8 +370,8 @@ impl LanguageModel for OpenRouterLanguageModel {
             LanguageModelCompletionError,
         >,
     > {
-        let request = into_open_router(request, &self.model, self.max_output_tokens());
-        let request = self.stream_completion(request, cx);
+        let openrouter_request = into_open_router(request, &self.model, self.max_output_tokens());
+        let request = self.stream_completion(openrouter_request, cx);
         let future = self.request_limiter.stream(async move {
             let response = request.await?;
             Ok(OpenRouterEventMapper::new().map_stream(response))
@@ -385,15 +385,31 @@ pub fn into_open_router(
     model: &Model,
     max_output_tokens: Option,
 ) -> open_router::Request {
+    // Anthropic models via OpenRouter don't accept reasoning_details being echoed back
+    // in requests - it's an output-only field for them. However, Gemini models require
+    // the thought signatures to be echoed back for proper reasoning chain continuity.
+    // Note: OpenRouter's model API provides an `architecture.tokenizer` field (e.g. "Claude",
+    // "Gemini") which could replace this ID prefix check, but since this is the only place
+    // we need this distinction, we're just using this less invasive check instead.
+    // If we ever have a more formal distionction between the models in the future,
+    // we should revise this to use that instead.
+    let is_anthropic_model = model.id().starts_with("anthropic/");
+
     let mut messages = Vec::new();
     for message in request.messages {
-        let reasoning_details = message.reasoning_details.clone();
+        let reasoning_details_for_message = if is_anthropic_model {
+            None
+        } else {
+            message.reasoning_details.clone()
+        };
+
         for content in message.content {
             match content {
                 MessageContent::Text(text) => add_message_content_part(
                     open_router::MessagePart::Text { text },
                     message.role,
                     &mut messages,
+                    reasoning_details_for_message.clone(),
                 ),
                 MessageContent::Thinking { .. } => {}
                 MessageContent::RedactedThinking(_) => {}
@@ -404,6 +420,7 @@ pub fn into_open_router(
                         },
                         message.role,
                         &mut messages,
+                        reasoning_details_for_message.clone(),
                     );
                 }
                 MessageContent::ToolUse(tool_use) => {
@@ -419,21 +436,15 @@ pub fn into_open_router(
                         },
                     };
 
-                    if let Some(open_router::RequestMessage::Assistant {
-                        tool_calls,
-                        reasoning_details: existing_reasoning,
-                        ..
-                    }) = messages.last_mut()
+                    if let Some(open_router::RequestMessage::Assistant { tool_calls, .. }) =
+                        messages.last_mut()
                     {
                         tool_calls.push(tool_call);
-                        if existing_reasoning.is_none() && reasoning_details.is_some() {
-                            *existing_reasoning = reasoning_details.clone();
-                        }
                     } else {
                         messages.push(open_router::RequestMessage::Assistant {
                             content: None,
                             tool_calls: vec![tool_call],
-                            reasoning_details: reasoning_details.clone(),
+                            reasoning_details: reasoning_details_for_message.clone(),
                         });
                     }
                 }
@@ -509,6 +520,7 @@ fn add_message_content_part(
     new_part: open_router::MessagePart,
     role: Role,
     messages: &mut Vec,
+    reasoning_details: Option,
 ) {
     match (role, messages.last_mut()) {
         (Role::User, Some(open_router::RequestMessage::User { content }))
@@ -532,7 +544,7 @@ fn add_message_content_part(
                 Role::Assistant => open_router::RequestMessage::Assistant {
                     content: Some(open_router::MessageContent::from(vec![new_part])),
                     tool_calls: Vec::new(),
-                    reasoning_details: None,
+                    reasoning_details,
                 },
                 Role::System => open_router::RequestMessage::System {
                     content: open_router::MessageContent::from(vec![new_part]),

From 895213a94def3adb7b60b3d98c0e055dbc38f86a Mon Sep 17 00:00:00 2001
From: Haojian Wu 
Date: Fri, 19 Dec 2025 23:37:13 +0100
Subject: [PATCH 256/266] Support union declarations in C/C++ textobjects.scm
 (#45308)

Release Notes:

- C/C++: Add `union` declarations to the list of text objects
---
 crates/languages/src/c/textobjects.scm   | 6 ++++++
 crates/languages/src/cpp/textobjects.scm | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/crates/languages/src/c/textobjects.scm b/crates/languages/src/c/textobjects.scm
index 832dd62288b40f7ec9c738a9ded5adc9890a0666..e29f508b701c8ee22eec27af47d899d446e67860 100644
--- a/crates/languages/src/c/textobjects.scm
+++ b/crates/languages/src/c/textobjects.scm
@@ -23,3 +23,9 @@
         "{"
         [(_) ","?]* @class.inside
         "}")) @class.around
+
+(union_specifier
+    body: (_
+        "{"
+        (_)* @class.inside
+        "}")) @class.around
diff --git a/crates/languages/src/cpp/textobjects.scm b/crates/languages/src/cpp/textobjects.scm
index 11a27b8d581dd5d8c7cb580739007dd3df8511f1..027185a0cfab7b71f3dcd6a5d5507445e2778d34 100644
--- a/crates/languages/src/cpp/textobjects.scm
+++ b/crates/languages/src/cpp/textobjects.scm
@@ -24,6 +24,12 @@
         [(_) ","?]* @class.inside
         "}")) @class.around
 
+(union_specifier
+    body: (_
+        "{"
+        (_)* @class.inside
+        "}")) @class.around
+
 (class_specifier
   body: (_
       "{"

From 6dfabddbb4c219f7a0ec0b2174d880040d43cf1d Mon Sep 17 00:00:00 2001
From: Max Brunsfeld 
Date: Fri, 19 Dec 2025 15:21:10 -0800
Subject: [PATCH 257/266] Revert "gpui: Enable direct-to-display optimization
 for metal" (#45405)

Reverts zed-industries/zed#44334

From my testing, this PR introduced screen tearing, or some kind of
strange visual artifact, when scrolling at medium speed on a large
display.

Release notes:

- N/A
---
 crates/gpui/src/platform/mac/metal_renderer.rs | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/crates/gpui/src/platform/mac/metal_renderer.rs b/crates/gpui/src/platform/mac/metal_renderer.rs
index 66f54e5ba0c66a508f9db73d5ad8f84cb52d0d69..550041a0ccb4cd39bc7a86317d9540e806af2a28 100644
--- a/crates/gpui/src/platform/mac/metal_renderer.rs
+++ b/crates/gpui/src/platform/mac/metal_renderer.rs
@@ -46,9 +46,9 @@ pub unsafe fn new_renderer(
     _native_window: *mut c_void,
     _native_view: *mut c_void,
     _bounds: crate::Size,
-    transparent: bool,
+    _transparent: bool,
 ) -> Renderer {
-    MetalRenderer::new(context, transparent)
+    MetalRenderer::new(context)
 }
 
 pub(crate) struct InstanceBufferPool {
@@ -128,7 +128,7 @@ pub struct PathRasterizationVertex {
 }
 
 impl MetalRenderer {
-    pub fn new(instance_buffer_pool: Arc>, transparent: bool) -> Self {
+    pub fn new(instance_buffer_pool: Arc>) -> Self {
         // Prefer low‐power integrated GPUs on Intel Mac. On Apple
         // Silicon, there is only ever one GPU, so this is equivalent to
         // `metal::Device::system_default()`.
@@ -152,13 +152,8 @@ impl MetalRenderer {
         let layer = metal::MetalLayer::new();
         layer.set_device(&device);
         layer.set_pixel_format(MTLPixelFormat::BGRA8Unorm);
-        // Support direct-to-display rendering if the window is not transparent
-        // https://developer.apple.com/documentation/metal/managing-your-game-window-for-metal-in-macos
-        layer.set_opaque(!transparent);
+        layer.set_opaque(false);
         layer.set_maximum_drawable_count(3);
-        // We already present at display sync with the display link
-        // This allows to use direct-to-display even in window mode
-        layer.set_display_sync_enabled(false);
         unsafe {
             let _: () = msg_send![&*layer, setAllowsNextDrawableTimeout: NO];
             let _: () = msg_send![&*layer, setNeedsDisplayOnBoundsChange: YES];
@@ -357,8 +352,8 @@ impl MetalRenderer {
         }
     }
 
-    pub fn update_transparency(&self, transparent: bool) {
-        self.layer.set_opaque(!transparent);
+    pub fn update_transparency(&self, _transparent: bool) {
+        // todo(mac)?
     }
 
     pub fn destroy(&self) {

From 12dbbdd1d339d6de7be57015f4210127a017f2fe Mon Sep 17 00:00:00 2001
From: Anthony Eid <56899983+Anthony-Eid@users.noreply.github.com>
Date: Fri, 19 Dec 2025 18:55:17 -0500
Subject: [PATCH 258/266] git: Fix bug where opening a git blob from historic
 commit view could fail (#44226)

The failure would happen if the current version of the file was open as
an editor. This happened because the git blob and current version of the
buffer would have the same `ProjectPath`.

The fix was adding a new `DiskState::Historic` variant to represent
buffers that are past versions of a file (usually a snapshot from
version control). Historic buffers don't return a `ProjectPath` because
the file isn't real, thus there isn't and shouldn't be a `ProjectPath`
to it. (At least with the current way we represent a project path)

I also change the display name to use the local OS's path style instead
of being hardcoded to Posix, and cleaned up some code too.

Release Notes:

- N/A

---------

Co-authored-by: Cole Miller 
Co-authored-by: cameron 
Co-authored-by: xipengjin 
---
 crates/action_log/src/action_log.rs           |   8 +-
 crates/agent_ui/src/agent_diff.rs             |   4 +-
 crates/editor/src/items.rs                    |   6 +-
 crates/git_ui/src/commit_view.rs              |  54 +-----
 crates/image_viewer/src/image_viewer.rs       |   4 +-
 crates/language/src/buffer.rs                 |  15 ++
 crates/multi_buffer/src/multi_buffer.rs       |   8 +-
 .../project/src/debugger/breakpoint_store.rs  |   4 +-
 crates/project/src/project.rs                 |   6 +-
 crates/proto/proto/worktree.proto             | 161 +++++++++---------
 crates/worktree/src/worktree.rs               |   9 +-
 11 files changed, 130 insertions(+), 149 deletions(-)

diff --git a/crates/action_log/src/action_log.rs b/crates/action_log/src/action_log.rs
index 6eb18a4f12325f0c181928f99b4eb921265dbf9c..994780c40b9bd1cde45bfe6ba26630771a3040c3 100644
--- a/crates/action_log/src/action_log.rs
+++ b/crates/action_log/src/action_log.rs
@@ -6,7 +6,7 @@ use futures::{FutureExt, StreamExt, channel::mpsc};
 use gpui::{
     App, AppContext, AsyncApp, Context, Entity, SharedString, Subscription, Task, WeakEntity,
 };
-use language::{Anchor, Buffer, BufferEvent, DiskState, Point, ToPoint};
+use language::{Anchor, Buffer, BufferEvent, Point, ToPoint};
 use project::{Project, ProjectItem, lsp_store::OpenLspBufferHandle};
 use std::{cmp, ops::Range, sync::Arc};
 use text::{Edit, Patch, Rope};
@@ -150,7 +150,7 @@ impl ActionLog {
                 if buffer
                     .read(cx)
                     .file()
-                    .is_some_and(|file| file.disk_state() == DiskState::Deleted)
+                    .is_some_and(|file| file.disk_state().is_deleted())
                 {
                     // If the buffer had been edited by a tool, but it got
                     // deleted externally, we want to stop tracking it.
@@ -162,7 +162,7 @@ impl ActionLog {
                 if buffer
                     .read(cx)
                     .file()
-                    .is_some_and(|file| file.disk_state() != DiskState::Deleted)
+                    .is_some_and(|file| !file.disk_state().is_deleted())
                 {
                     // If the buffer had been deleted by a tool, but it got
                     // resurrected externally, we want to clear the edits we
@@ -769,7 +769,7 @@ impl ActionLog {
                 tracked.version != buffer.version
                     && buffer
                         .file()
-                        .is_some_and(|file| file.disk_state() != DiskState::Deleted)
+                        .is_some_and(|file| !file.disk_state().is_deleted())
             })
             .map(|(buffer, _)| buffer)
     }
diff --git a/crates/agent_ui/src/agent_diff.rs b/crates/agent_ui/src/agent_diff.rs
index 91d345b7ebb9dae5225626d7a054d0de1882dfe0..8d2bd534cac9b429cc1789e6ae0d5e7cd2f6e617 100644
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -17,7 +17,7 @@ use gpui::{
     Global, SharedString, Subscription, Task, WeakEntity, Window, prelude::*,
 };
 
-use language::{Buffer, Capability, DiskState, OffsetRangeExt, Point};
+use language::{Buffer, Capability, OffsetRangeExt, Point};
 use multi_buffer::PathKey;
 use project::{Project, ProjectItem, ProjectPath};
 use settings::{Settings, SettingsStore};
@@ -192,7 +192,7 @@ impl AgentDiffPane {
                     && buffer
                         .read(cx)
                         .file()
-                        .is_some_and(|file| file.disk_state() == DiskState::Deleted)
+                        .is_some_and(|file| file.disk_state().is_deleted())
                 {
                     editor.fold_buffer(snapshot.text.remote_id(), cx)
                 }
diff --git a/crates/editor/src/items.rs b/crates/editor/src/items.rs
index cfbb7c975c844f08d76a5568f1e02dfe3d7d74f1..34b54795455a9612da04b54f43101f3dcf00efd9 100644
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -17,8 +17,8 @@ use gpui::{
     ParentElement, Pixels, SharedString, Styled, Task, WeakEntity, Window, point,
 };
 use language::{
-    Bias, Buffer, BufferRow, CharKind, CharScopeContext, DiskState, LocalFile, Point,
-    SelectionGoal, proto::serialize_anchor as serialize_text_anchor,
+    Bias, Buffer, BufferRow, CharKind, CharScopeContext, LocalFile, Point, SelectionGoal,
+    proto::serialize_anchor as serialize_text_anchor,
 };
 use lsp::DiagnosticSeverity;
 use multi_buffer::MultiBufferOffset;
@@ -722,7 +722,7 @@ impl Item for Editor {
             .read(cx)
             .as_singleton()
             .and_then(|buffer| buffer.read(cx).file())
-            .is_some_and(|file| file.disk_state() == DiskState::Deleted);
+            .is_some_and(|file| file.disk_state().is_deleted());
 
         h_flex()
             .gap_2()
diff --git a/crates/git_ui/src/commit_view.rs b/crates/git_ui/src/commit_view.rs
index 0f5420fec4169f8e3d945dd8bd0987ebbaba8d19..7a4fdc2c73741e5834ac172df28ba5ac023ec20b 100644
--- a/crates/git_ui/src/commit_view.rs
+++ b/crates/git_ui/src/commit_view.rs
@@ -69,7 +69,7 @@ struct GitBlob {
     path: RepoPath,
     worktree_id: WorktreeId,
     is_deleted: bool,
-    display_name: Arc,
+    display_name: String,
 }
 
 const COMMIT_MESSAGE_SORT_PREFIX: u64 = 0;
@@ -243,9 +243,8 @@ impl CommitView {
                     .path
                     .file_name()
                     .map(|name| name.to_string())
-                    .unwrap_or_else(|| file.path.display(PathStyle::Posix).to_string());
-                let display_name: Arc =
-                    Arc::from(format!("{short_sha} - {file_name}").into_boxed_str());
+                    .unwrap_or_else(|| file.path.display(PathStyle::local()).to_string());
+                let display_name = format!("{short_sha} - {file_name}");
 
                 let file = Arc::new(GitBlob {
                     path: file.path.clone(),
@@ -661,15 +660,13 @@ impl language::File for GitBlob {
     }
 
     fn disk_state(&self) -> DiskState {
-        if self.is_deleted {
-            DiskState::Deleted
-        } else {
-            DiskState::New
+        DiskState::Historic {
+            was_deleted: self.is_deleted,
         }
     }
 
     fn path_style(&self, _: &App) -> PathStyle {
-        PathStyle::Posix
+        PathStyle::local()
     }
 
     fn path(&self) -> &Arc {
@@ -697,45 +694,6 @@ impl language::File for GitBlob {
     }
 }
 
-// No longer needed since metadata buffer is not created
-// impl language::File for CommitMetadataFile {
-//     fn as_local(&self) -> Option<&dyn language::LocalFile> {
-//         None
-//     }
-//
-//     fn disk_state(&self) -> DiskState {
-//         DiskState::New
-//     }
-//
-//     fn path_style(&self, _: &App) -> PathStyle {
-//         PathStyle::Posix
-//     }
-//
-//     fn path(&self) -> &Arc {
-//         &self.title
-//     }
-//
-//     fn full_path(&self, _: &App) -> PathBuf {
-//         self.title.as_std_path().to_path_buf()
-//     }
-//
-//     fn file_name<'a>(&'a self, _: &'a App) -> &'a str {
-//         self.title.file_name().unwrap_or("commit")
-//     }
-//
-//     fn worktree_id(&self, _: &App) -> WorktreeId {
-//         self.worktree_id
-//     }
-//
-//     fn to_proto(&self, _cx: &App) -> language::proto::File {
-//         unimplemented!()
-//     }
-//
-//     fn is_private(&self) -> bool {
-//         false
-//     }
-// }
-
 async fn build_buffer(
     mut text: String,
     blob: Arc,
diff --git a/crates/image_viewer/src/image_viewer.rs b/crates/image_viewer/src/image_viewer.rs
index d7c2341723e798b18d559895d6ea478b491eeaf7..4474b2a9bf7d8d4fe117575d9323e7fee8df1eb2 100644
--- a/crates/image_viewer/src/image_viewer.rs
+++ b/crates/image_viewer/src/image_viewer.rs
@@ -11,7 +11,7 @@ use gpui::{
     InteractiveElement, IntoElement, ObjectFit, ParentElement, Render, Styled, Task, WeakEntity,
     Window, canvas, div, fill, img, opaque_grey, point, size,
 };
-use language::{DiskState, File as _};
+use language::File as _;
 use persistence::IMAGE_VIEWER;
 use project::{ImageItem, Project, ProjectPath, image_store::ImageItemEvent};
 use settings::Settings;
@@ -195,7 +195,7 @@ impl Item for ImageView {
     }
 
     fn has_deleted_file(&self, cx: &App) -> bool {
-        self.image_item.read(cx).file.disk_state() == DiskState::Deleted
+        self.image_item.read(cx).file.disk_state().is_deleted()
     }
     fn buffer_kind(&self, _: &App) -> workspace::item::ItemBufferKind {
         workspace::item::ItemBufferKind::Singleton
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 5f46340b41a876443f1d12724450d2d8b30f9b33..c919aeca15714864e5a54f8b56d3f8517994cb56 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -427,6 +427,9 @@ pub enum DiskState {
     Present { mtime: MTime },
     /// Deleted file that was previously present.
     Deleted,
+    /// An old version of a file that was previously present
+    /// usually from a version control system. e.g. A git blob
+    Historic { was_deleted: bool },
 }
 
 impl DiskState {
@@ -436,6 +439,7 @@ impl DiskState {
             DiskState::New => None,
             DiskState::Present { mtime } => Some(mtime),
             DiskState::Deleted => None,
+            DiskState::Historic { .. } => None,
         }
     }
 
@@ -444,6 +448,16 @@ impl DiskState {
             DiskState::New => false,
             DiskState::Present { .. } => true,
             DiskState::Deleted => false,
+            DiskState::Historic { .. } => false,
+        }
+    }
+
+    /// Returns true if this state represents a deleted file.
+    pub fn is_deleted(&self) -> bool {
+        match self {
+            DiskState::Deleted => true,
+            DiskState::Historic { was_deleted } => *was_deleted,
+            _ => false,
         }
     }
 }
@@ -2274,6 +2288,7 @@ impl Buffer {
                 None => true,
             },
             DiskState::Deleted => false,
+            DiskState::Historic { .. } => false,
         }
     }
 
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 0c0e87b60a7b8950f7461228c929503d516791e0..3e96a81b387fabeee77c6790dd66433da99b3985 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -19,9 +19,9 @@ use gpui::{App, Context, Entity, EntityId, EventEmitter};
 use itertools::Itertools;
 use language::{
     AutoindentMode, BracketMatch, Buffer, BufferChunks, BufferRow, BufferSnapshot, Capability,
-    CharClassifier, CharKind, CharScopeContext, Chunk, CursorShape, DiagnosticEntryRef, DiskState,
-    File, IndentGuideSettings, IndentSize, Language, LanguageScope, OffsetRangeExt, OffsetUtf16,
-    Outline, OutlineItem, Point, PointUtf16, Selection, TextDimension, TextObject, ToOffset as _,
+    CharClassifier, CharKind, CharScopeContext, Chunk, CursorShape, DiagnosticEntryRef, File,
+    IndentGuideSettings, IndentSize, Language, LanguageScope, OffsetRangeExt, OffsetUtf16, Outline,
+    OutlineItem, Point, PointUtf16, Selection, TextDimension, TextObject, ToOffset as _,
     ToPoint as _, TransactionId, TreeSitterOptions, Unclipped,
     language_settings::{LanguageSettings, language_settings},
 };
@@ -2980,7 +2980,7 @@ impl MultiBuffer {
             *is_dirty |= buffer.is_dirty();
             *has_deleted_file |= buffer
                 .file()
-                .is_some_and(|file| file.disk_state() == DiskState::Deleted);
+                .is_some_and(|file| file.disk_state().is_deleted());
             *has_conflict |= buffer.has_conflict();
         }
         if edited {
diff --git a/crates/project/src/debugger/breakpoint_store.rs b/crates/project/src/debugger/breakpoint_store.rs
index 42663ab9852a5dc2e9850d20dd20940c6723d03c..d5a144ee8a83e0064b3afdca123c33e4e8da3e46 100644
--- a/crates/project/src/debugger/breakpoint_store.rs
+++ b/crates/project/src/debugger/breakpoint_store.rs
@@ -23,7 +23,7 @@ use super::session::ThreadId;
 
 mod breakpoints_in_file {
     use collections::HashMap;
-    use language::{BufferEvent, DiskState};
+    use language::BufferEvent;
 
     use super::*;
 
@@ -82,7 +82,7 @@ mod breakpoints_in_file {
                     BufferEvent::FileHandleChanged => {
                         let entity_id = buffer.entity_id();
 
-                        if buffer.read(cx).file().is_none_or(|f| f.disk_state() == DiskState::Deleted) {
+                        if buffer.read(cx).file().is_none_or(|f| f.disk_state().is_deleted()) {
                             breakpoint_store.breakpoints.retain(|_, breakpoints_in_file| {
                                 breakpoints_in_file.buffer.entity_id() != entity_id
                             });
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 25a19788fdb464f5f289ef3bc3513f21743e3a9a..5111bc04fa256f35feae40464e405d3dd926b286 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -83,7 +83,7 @@ use gpui::{
     Task, WeakEntity, Window,
 };
 use language::{
-    Buffer, BufferEvent, Capability, CodeLabel, CursorShape, Language, LanguageName,
+    Buffer, BufferEvent, Capability, CodeLabel, CursorShape, DiskState, Language, LanguageName,
     LanguageRegistry, PointUtf16, ToOffset, ToPointUtf16, Toolchain, ToolchainMetadata,
     ToolchainScope, Transaction, Unclipped, language_settings::InlayHintKind,
     proto::split_operations,
@@ -5671,7 +5671,9 @@ impl ProjectItem for Buffer {
     }
 
     fn project_path(&self, cx: &App) -> Option {
-        self.file().map(|file| ProjectPath {
+        let file = self.file()?;
+
+        (!matches!(file.disk_state(), DiskState::Historic { .. })).then(|| ProjectPath {
             worktree_id: file.worktree_id(cx),
             path: file.path().clone(),
         })
diff --git a/crates/proto/proto/worktree.proto b/crates/proto/proto/worktree.proto
index 5873cfc10c1c6af24520705c27781b916dfda3d0..7917962cf16b3f7e042e6584faf9ab7334e8ae3d 100644
--- a/crates/proto/proto/worktree.proto
+++ b/crates/proto/proto/worktree.proto
@@ -2,161 +2,162 @@ syntax = "proto3";
 package zed.messages;
 
 message Timestamp {
-    uint64 seconds = 1;
-    uint32 nanos = 2;
+  uint64 seconds = 1;
+  uint32 nanos = 2;
 }
 
 message File {
-    uint64 worktree_id = 1;
-    optional uint64 entry_id = 2;
-    string path = 3;
-    Timestamp mtime = 4;
-    bool is_deleted = 5;
+  uint64 worktree_id = 1;
+  optional uint64 entry_id = 2;
+  string path = 3;
+  Timestamp mtime = 4;
+  bool is_deleted = 5;
+  bool is_historic = 6;
 }
 
 message Entry {
-    uint64 id = 1;
-    bool is_dir = 2;
-    string path = 3;
-    uint64 inode = 4;
-    Timestamp mtime = 5;
-    bool is_ignored = 7;
-    bool is_external = 8;
-    reserved 6;
-    reserved 9;
-    bool is_fifo = 10;
-    optional uint64 size = 11;
-    optional string canonical_path = 12;
-    bool is_hidden = 13;
+  uint64 id = 1;
+  bool is_dir = 2;
+  string path = 3;
+  uint64 inode = 4;
+  Timestamp mtime = 5;
+  bool is_ignored = 7;
+  bool is_external = 8;
+  reserved 6;
+  reserved 9;
+  bool is_fifo = 10;
+  optional uint64 size = 11;
+  optional string canonical_path = 12;
+  bool is_hidden = 13;
 }
 
 message AddWorktree {
-    string path = 1;
-    uint64 project_id = 2;
-    bool visible = 3;
+  string path = 1;
+  uint64 project_id = 2;
+  bool visible = 3;
 }
 
 message AddWorktreeResponse {
-    uint64 worktree_id = 1;
-    string canonicalized_path = 2;
+  uint64 worktree_id = 1;
+  string canonicalized_path = 2;
 }
 
 message RemoveWorktree {
-    uint64 worktree_id = 1;
+  uint64 worktree_id = 1;
 }
 
 message GetPathMetadata {
-    uint64 project_id = 1;
-    string path = 2;
+  uint64 project_id = 1;
+  string path = 2;
 }
 
 message GetPathMetadataResponse {
-    bool exists = 1;
-    string path = 2;
-    bool is_dir = 3;
+  bool exists = 1;
+  string path = 2;
+  bool is_dir = 3;
 }
 
 message WorktreeMetadata {
-    uint64 id = 1;
-    string root_name = 2;
-    bool visible = 3;
-    string abs_path = 4;
+  uint64 id = 1;
+  string root_name = 2;
+  bool visible = 3;
+  string abs_path = 4;
 }
 
 message ProjectPath {
-    uint64 worktree_id = 1;
-    string path = 2;
+  uint64 worktree_id = 1;
+  string path = 2;
 }
 
 message ListRemoteDirectoryConfig {
-    bool is_dir = 1;
+  bool is_dir = 1;
 }
 
 message ListRemoteDirectory {
-    uint64 dev_server_id = 1;
-    string path = 2;
-    ListRemoteDirectoryConfig config = 3;
+  uint64 dev_server_id = 1;
+  string path = 2;
+  ListRemoteDirectoryConfig config = 3;
 }
 
 message EntryInfo {
-    bool is_dir = 1;
+  bool is_dir = 1;
 }
 
 message ListRemoteDirectoryResponse {
-    repeated string entries = 1;
-    repeated EntryInfo entry_info = 2;
+  repeated string entries = 1;
+  repeated EntryInfo entry_info = 2;
 }
 
 message CreateProjectEntry {
-    uint64 project_id = 1;
-    uint64 worktree_id = 2;
-    string path = 3;
-    bool is_directory = 4;
-    optional bytes content = 5;
+  uint64 project_id = 1;
+  uint64 worktree_id = 2;
+  string path = 3;
+  bool is_directory = 4;
+  optional bytes content = 5;
 }
 
 message RenameProjectEntry {
-    uint64 project_id = 1;
-    uint64 entry_id = 2;
-    string new_path = 3;
-    uint64 new_worktree_id = 4;
+  uint64 project_id = 1;
+  uint64 entry_id = 2;
+  string new_path = 3;
+  uint64 new_worktree_id = 4;
 }
 
 message CopyProjectEntry {
-    uint64 project_id = 1;
-    uint64 entry_id = 2;
-    string new_path = 3;
-    uint64 new_worktree_id = 5;
-    reserved 4;
+  uint64 project_id = 1;
+  uint64 entry_id = 2;
+  string new_path = 3;
+  uint64 new_worktree_id = 5;
+  reserved 4;
 }
 
 message DeleteProjectEntry {
-    uint64 project_id = 1;
-    uint64 entry_id = 2;
-    bool use_trash = 3;
+  uint64 project_id = 1;
+  uint64 entry_id = 2;
+  bool use_trash = 3;
 }
 
 message ExpandProjectEntry {
-    uint64 project_id = 1;
-    uint64 entry_id = 2;
+  uint64 project_id = 1;
+  uint64 entry_id = 2;
 }
 
 message ExpandProjectEntryResponse {
-    uint64 worktree_scan_id = 1;
+  uint64 worktree_scan_id = 1;
 }
 
 message ExpandAllForProjectEntry {
-    uint64 project_id = 1;
-    uint64 entry_id = 2;
+  uint64 project_id = 1;
+  uint64 entry_id = 2;
 }
 
 message ExpandAllForProjectEntryResponse {
-    uint64 worktree_scan_id = 1;
+  uint64 worktree_scan_id = 1;
 }
 
 message ProjectEntryResponse {
-    optional Entry entry = 1;
-    uint64 worktree_scan_id = 2;
+  optional Entry entry = 1;
+  uint64 worktree_scan_id = 2;
 }
 
 message UpdateWorktreeSettings {
-    uint64 project_id = 1;
-    uint64 worktree_id = 2;
-    string path = 3;
-    optional string content = 4;
-    optional LocalSettingsKind kind = 5;
+  uint64 project_id = 1;
+  uint64 worktree_id = 2;
+  string path = 3;
+  optional string content = 4;
+  optional LocalSettingsKind kind = 5;
 }
 
 enum LocalSettingsKind {
-    Settings = 0;
-    Tasks = 1;
-    Editorconfig = 2;
-    Debug = 3;
+  Settings = 0;
+  Tasks = 1;
+  Editorconfig = 2;
+  Debug = 3;
 }
 
 message UpdateUserSettings {
-    uint64 project_id = 1;
-    string contents = 2;
+  uint64 project_id = 1;
+  string contents = 2;
 }
 
 message TrustWorktrees {
diff --git a/crates/worktree/src/worktree.rs b/crates/worktree/src/worktree.rs
index f5f632e65d71b683d1a491b1fc9e9a612f5c24a5..ca5500249e95f0b9d3fb25f75393ab5c9ca5be9b 100644
--- a/crates/worktree/src/worktree.rs
+++ b/crates/worktree/src/worktree.rs
@@ -3235,7 +3235,8 @@ impl language::File for File {
             entry_id: self.entry_id.map(|id| id.to_proto()),
             path: self.path.as_ref().to_proto(),
             mtime: self.disk_state.mtime().map(|time| time.into()),
-            is_deleted: self.disk_state == DiskState::Deleted,
+            is_deleted: self.disk_state.is_deleted(),
+            is_historic: matches!(self.disk_state, DiskState::Historic { .. }),
         }
     }
 
@@ -3296,7 +3297,11 @@ impl File {
             "worktree id does not match file"
         );
 
-        let disk_state = if proto.is_deleted {
+        let disk_state = if proto.is_historic {
+            DiskState::Historic {
+                was_deleted: proto.is_deleted,
+            }
+        } else if proto.is_deleted {
             DiskState::Deleted
         } else if let Some(mtime) = proto.mtime.map(&Into::into) {
             DiskState::Present { mtime }

From 5fb220a19adc1c1bc972b1d2513e82d216df27e2 Mon Sep 17 00:00:00 2001
From: Jason Lee 
Date: Sat, 20 Dec 2025 08:27:41 +0800
Subject: [PATCH 259/266] gpui: Add a Popover example for test deferred 
 (#44473)

Release Notes:

- N/A

image
---
 crates/gpui/examples/popover.rs | 174 ++++++++++++++++++++++++++++++++
 1 file changed, 174 insertions(+)
 create mode 100644 crates/gpui/examples/popover.rs

diff --git a/crates/gpui/examples/popover.rs b/crates/gpui/examples/popover.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9a3d47d06dd0f92d176dd4e81d739403a4870062
--- /dev/null
+++ b/crates/gpui/examples/popover.rs
@@ -0,0 +1,174 @@
+use gpui::{
+    App, Application, Context, Corner, Div, Hsla, Stateful, Window, WindowOptions, anchored,
+    deferred, div, prelude::*, px,
+};
+
+/// An example show use deferred to create a floating layers.
+struct HelloWorld {
+    open: bool,
+    secondary_open: bool,
+}
+
+fn button(id: &'static str) -> Stateful
 {
+    div()
+        .id(id)
+        .bg(gpui::black())
+        .text_color(gpui::white())
+        .px_3()
+        .py_1()
+}
+
+fn popover() -> Div {
+    div()
+        .flex()
+        .flex_col()
+        .items_center()
+        .justify_center()
+        .shadow_lg()
+        .p_3()
+        .rounded_md()
+        .bg(gpui::white())
+        .text_color(gpui::black())
+        .border_1()
+        .text_sm()
+        .border_color(gpui::black().opacity(0.1))
+}
+
+fn line(color: Hsla) -> Div {
+    div().w(px(480.)).h_2().bg(color.opacity(0.25))
+}
+
+impl HelloWorld {
+    fn render_secondary_popover(
+        &mut self,
+        _window: &mut Window,
+        cx: &mut Context,
+    ) -> impl IntoElement {
+        button("secondary-btn")
+            .mt_2()
+            .child("Child Popover")
+            .on_click(cx.listener(|this, _, _, cx| {
+                this.secondary_open = true;
+                cx.notify();
+            }))
+            .when(self.secondary_open, |this| {
+                this.child(
+                    // GPUI can't support deferred here yet,
+                    // it was inside another deferred element.
+                    anchored()
+                        .anchor(Corner::TopLeft)
+                        .snap_to_window_with_margin(px(8.))
+                        .child(
+                            popover()
+                                .child("This is second level Popover")
+                                .bg(gpui::white())
+                                .border_color(gpui::blue())
+                                .on_mouse_down_out(cx.listener(|this, _, _, cx| {
+                                    this.secondary_open = false;
+                                    cx.notify();
+                                })),
+                        ),
+                )
+            })
+    }
+}
+
+impl Render for HelloWorld {
+    fn render(&mut self, window: &mut Window, cx: &mut Context) -> impl IntoElement {
+        div()
+            .flex()
+            .flex_col()
+            .gap_3()
+            .size_full()
+            .bg(gpui::white())
+            .text_color(gpui::black())
+            .justify_center()
+            .items_center()
+            .child(
+                div()
+                    .flex()
+                    .flex_row()
+                    .gap_4()
+                    .child(
+                        button("popover0").child("Opened Popover").child(
+                            deferred(
+                                anchored()
+                                    .anchor(Corner::TopLeft)
+                                    .snap_to_window_with_margin(px(8.))
+                                    .child(popover().w_96().gap_3().child(
+                                        "This is a default opened Popover, \
+                                        we can use deferred to render it \
+                                        in a floating layer.",
+                                    )),
+                            )
+                            .priority(0),
+                        ),
+                    )
+                    .child(
+                        button("popover1")
+                            .child("Open Popover")
+                            .on_click(cx.listener(|this, _, _, cx| {
+                                this.open = true;
+                                cx.notify();
+                            }))
+                            .when(self.open, |this| {
+                                this.child(
+                                    deferred(
+                                        anchored()
+                                            .anchor(Corner::TopLeft)
+                                            .snap_to_window_with_margin(px(8.))
+                                            .child(
+                                                popover()
+                                                    .w_96()
+                                                    .gap_3()
+                                                    .child(
+                                                        "This is first level Popover, \
+                                                   we can use deferred to render it \
+                                                   in a floating layer.\n\
+                                                   Click outside to close.",
+                                                    )
+                                                    .when(!self.secondary_open, |this| {
+                                                        this.on_mouse_down_out(cx.listener(
+                                                            |this, _, _, cx| {
+                                                                this.open = false;
+                                                                cx.notify();
+                                                            },
+                                                        ))
+                                                    })
+                                                    // Here we need render popover after the content
+                                                    // to ensure it will be on top layer.
+                                                    .child(
+                                                        self.render_secondary_popover(window, cx),
+                                                    ),
+                                            ),
+                                    )
+                                    .priority(1),
+                                )
+                            }),
+                    ),
+            )
+            .child(
+                "Here is an example text rendered, \
+                to ensure the Popover will float above this contents.",
+            )
+            .children([
+                line(gpui::red()),
+                line(gpui::yellow()),
+                line(gpui::blue()),
+                line(gpui::green()),
+            ])
+    }
+}
+
+fn main() {
+    Application::new().run(|cx: &mut App| {
+        cx.open_window(WindowOptions::default(), |_, cx| {
+            cx.new(|_| HelloWorld {
+                open: false,
+                secondary_open: false,
+            })
+        })
+        .unwrap();
+        cx.activate(true);
+    });
+}

From a86b0ab2e026a870ac92ec7764796ba217d1a07d Mon Sep 17 00:00:00 2001
From: Serophots <47299955+Serophots@users.noreply.github.com>
Date: Sat, 20 Dec 2025 00:29:26 +0000
Subject: [PATCH 260/266] gpui: Improve the tab stop example by demonstrating
 tab_group (#44647)

I've just enriched the existing tab_stop.rs example for GPUI with a
demonstration of tab_group. I don't think tab groups existed when the
original example was written.

(I didn't understand the behaviour for tab_group from the doccomments
and the example was missing, so I think this is a productive PR)

Release Notes:

- N/A
---
 crates/gpui/examples/tab_stop.rs | 44 ++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/crates/gpui/examples/tab_stop.rs b/crates/gpui/examples/tab_stop.rs
index 4d99da1a07a123e9a18b3c64a90834c31bd76909..efad97236cfc778870db1ee723c92691578860dd 100644
--- a/crates/gpui/examples/tab_stop.rs
+++ b/crates/gpui/examples/tab_stop.rs
@@ -130,6 +130,50 @@ impl Render for Example {
                             })),
                     ),
             )
+            .child(
+                div()
+                    .id("group-1")
+                    .tab_index(6)
+                    .tab_group()
+                    .tab_stop(false)
+                    .child(
+                        button("group-1-button-1")
+                            .tab_index(1)
+                            .child("Tab index [6, 1]"),
+                    )
+                    .child(
+                        button("group-1-button-2")
+                            .tab_index(2)
+                            .child("Tab index [6, 2]"),
+                    )
+                    .child(
+                        button("group-1-button-3")
+                            .tab_index(3)
+                            .child("Tab index [6, 3]"),
+                    ),
+            )
+            .child(
+                div()
+                    .id("group-2")
+                    .tab_index(7)
+                    .tab_group()
+                    .tab_stop(false)
+                    .child(
+                        button("group-2-button-1")
+                            .tab_index(1)
+                            .child("Tab index [7, 1]"),
+                    )
+                    .child(
+                        button("group-2-button-2")
+                            .tab_index(2)
+                            .child("Tab index [7, 2]"),
+                    )
+                    .child(
+                        button("group-2-button-3")
+                            .tab_index(3)
+                            .child("Tab index [7, 3]"),
+                    ),
+            )
     }
 }
 

From e5eb26e8d600c1cf4b971ffa2df2344338ba6d48 Mon Sep 17 00:00:00 2001
From: jkugs 
Date: Fri, 19 Dec 2025 19:29:44 -0500
Subject: [PATCH 261/266] gpui: Reset mouse scroll state on FocusOut to prevent
 large jumps (#43841)

This fixes an X11 scrolling issue where Zed may jump by a large amount
due to the scroll valuator state not being reset when the window loses
focus. If you Alt-Tab away from Zed, scroll in another application, then
return, the first scroll event in Zed applies the entire accumulated
delta instead of a single step.

The missing FocusOut reset was originally identified in issue #34901.

Resetting scroll positions on FocusOut matches the behavior already
implemented in the XinputLeave handler and prevents this jump.

Closes #34901
Closes #40538

Release Notes:

- Fixed an X11 issue where Alt-Tabbing to another application,
scrolling, and returning to Zed could cause the next scroll event to
jump by a large amount.
---
 crates/gpui/src/platform/linux/x11/client.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/gpui/src/platform/linux/x11/client.rs b/crates/gpui/src/platform/linux/x11/client.rs
index 7feec41d433158325592d566f83a6063f7a7196e..0de5ff02f7d0895da05dfa480bff2e19abff40db 100644
--- a/crates/gpui/src/platform/linux/x11/client.rs
+++ b/crates/gpui/src/platform/linux/x11/client.rs
@@ -944,6 +944,8 @@ impl X11Client {
                 let window = self.get_window(event.event)?;
                 window.set_active(false);
                 let mut state = self.0.borrow_mut();
+                // Set last scroll values to `None` so that a large delta isn't created if scrolling is done outside the window (the valuator is global)
+                reset_all_pointer_device_scroll_positions(&mut state.pointer_device_states);
                 state.keyboard_focused_window = None;
                 if let Some(compose_state) = state.compose_state.as_mut() {
                     compose_state.reset();

From 1d76539d28ec7dbf0ad7e2af4604b61478d3f822 Mon Sep 17 00:00:00 2001
From: Mayank Verma 
Date: Sat, 20 Dec 2025 06:03:32 +0530
Subject: [PATCH 262/266] gpui: Fix hover styles not being applied during
 layout (#43324)

Closes #43214

Release Notes:

- Fixed GPUI hover styles not being applied during layout

Here's the before/after:


https://github.com/user-attachments/assets/5b1828bb-234a-493b-a33d-368ca01a773b
---
 crates/gpui/src/elements/div.rs | 95 ++++++++++++++++++++++++++++-----
 1 file changed, 83 insertions(+), 12 deletions(-)

diff --git a/crates/gpui/src/elements/div.rs b/crates/gpui/src/elements/div.rs
index cf55edefaf70c080e171a8e21b350fd3c6d82f75..547d967620d68c309563af1d2e56d2ab3f194d4f 100644
--- a/crates/gpui/src/elements/div.rs
+++ b/crates/gpui/src/elements/div.rs
@@ -1730,6 +1730,11 @@ impl Interactivity {
                         let clicked_state = clicked_state.borrow();
                         self.active = Some(clicked_state.element);
                     }
+                    if self.hover_style.is_some() || self.group_hover_style.is_some() {
+                        element_state
+                            .hover_state
+                            .get_or_insert_with(Default::default);
+                    }
                     if let Some(active_tooltip) = element_state.active_tooltip.as_ref() {
                         if self.tooltip_builder.is_some() {
                             self.tooltip_id = set_tooltip_on_window(active_tooltip, window);
@@ -2150,14 +2155,46 @@ impl Interactivity {
         {
             let hitbox = hitbox.clone();
             let was_hovered = hitbox.is_hovered(window);
+            let hover_state = self.hover_style.as_ref().and_then(|_| {
+                element_state
+                    .as_ref()
+                    .and_then(|state| state.hover_state.as_ref())
+                    .cloned()
+            });
             let current_view = window.current_view();
             window.on_mouse_event(move |_: &MouseMoveEvent, phase, window, cx| {
                 let hovered = hitbox.is_hovered(window);
                 if phase == DispatchPhase::Capture && hovered != was_hovered {
+                    if let Some(hover_state) = &hover_state {
+                        hover_state.borrow_mut().element = hovered;
+                    }
                     cx.notify(current_view);
                 }
             });
         }
+
+        if let Some(group_hover) = self.group_hover_style.as_ref() {
+            if let Some(group_hitbox_id) = GroupHitboxes::get(&group_hover.group, cx) {
+                let hover_state = element_state
+                    .as_ref()
+                    .and_then(|element| element.hover_state.as_ref())
+                    .cloned();
+
+                let was_group_hovered = group_hitbox_id.is_hovered(window);
+                let current_view = window.current_view();
+
+                window.on_mouse_event(move |_: &MouseMoveEvent, phase, window, cx| {
+                    let group_hovered = group_hitbox_id.is_hovered(window);
+                    if phase == DispatchPhase::Capture && group_hovered != was_group_hovered {
+                        if let Some(hover_state) = &hover_state {
+                            hover_state.borrow_mut().group = group_hovered;
+                        }
+                        cx.notify(current_view);
+                    }
+                });
+            }
+        }
+
         let drag_cursor_style = self.base_style.as_ref().mouse_cursor;
 
         let mut drag_listener = mem::take(&mut self.drag_listener);
@@ -2346,8 +2383,8 @@ impl Interactivity {
                         && hitbox.is_hovered(window);
                     let mut was_hovered = was_hovered.borrow_mut();
 
-                    if is_hovered != *was_hovered {
-                        *was_hovered = is_hovered;
+                    if is_hovered != was_hovered.element {
+                        was_hovered.element = is_hovered;
                         drop(was_hovered);
 
                         hover_listener(&is_hovered, window, cx);
@@ -2580,22 +2617,46 @@ impl Interactivity {
             }
         }
 
-        if let Some(hitbox) = hitbox {
-            if !cx.has_active_drag() {
-                if let Some(group_hover) = self.group_hover_style.as_ref()
-                    && let Some(group_hitbox_id) = GroupHitboxes::get(&group_hover.group, cx)
-                    && group_hitbox_id.is_hovered(window)
-                {
+        if !cx.has_active_drag() {
+            if let Some(group_hover) = self.group_hover_style.as_ref() {
+                let is_group_hovered =
+                    if let Some(group_hitbox_id) = GroupHitboxes::get(&group_hover.group, cx) {
+                        group_hitbox_id.is_hovered(window)
+                    } else if let Some(element_state) = element_state.as_ref() {
+                        element_state
+                            .hover_state
+                            .as_ref()
+                            .map(|state| state.borrow().group)
+                            .unwrap_or(false)
+                    } else {
+                        false
+                    };
+
+                if is_group_hovered {
                     style.refine(&group_hover.style);
                 }
+            }
 
-                if let Some(hover_style) = self.hover_style.as_ref()
-                    && hitbox.is_hovered(window)
-                {
+            if let Some(hover_style) = self.hover_style.as_ref() {
+                let is_hovered = if let Some(hitbox) = hitbox {
+                    hitbox.is_hovered(window)
+                } else if let Some(element_state) = element_state.as_ref() {
+                    element_state
+                        .hover_state
+                        .as_ref()
+                        .map(|state| state.borrow().element)
+                        .unwrap_or(false)
+                } else {
+                    false
+                };
+
+                if is_hovered {
                     style.refine(hover_style);
                 }
             }
+        }
 
+        if let Some(hitbox) = hitbox {
             if let Some(drag) = cx.active_drag.take() {
                 let mut can_drop = true;
                 if let Some(can_drop_predicate) = &self.can_drop_predicate {
@@ -2654,7 +2715,7 @@ impl Interactivity {
 pub struct InteractiveElementState {
     pub(crate) focus_handle: Option,
     pub(crate) clicked_state: Option>>,
-    pub(crate) hover_state: Option>>,
+    pub(crate) hover_state: Option>>,
     pub(crate) pending_mouse_down: Option>>>,
     pub(crate) scroll_offset: Option>>>,
     pub(crate) active_tooltip: Option>>>,
@@ -2676,6 +2737,16 @@ impl ElementClickedState {
     }
 }
 
+/// Whether or not the element or a group that contains it is hovered.
+#[derive(Copy, Clone, Default, Eq, PartialEq)]
+pub struct ElementHoverState {
+    /// True if this element's group is hovered, false otherwise
+    pub group: bool,
+
+    /// True if this element is hovered, false otherwise
+    pub element: bool,
+}
+
 pub(crate) enum ActiveTooltip {
     /// Currently delaying before showing the tooltip.
     WaitingForShow { _task: Task<()> },

From 5395197619f612aef59bd80a1108de294cc2aa77 Mon Sep 17 00:00:00 2001
From: Mikayla Maki 
Date: Fri, 19 Dec 2025 16:34:14 -0800
Subject: [PATCH 263/266] Separate out component_preview crate and add
 easy-to-use example binaries (#45382)

Release Notes:

- N/A
---
 Cargo.lock                                    |  29 +++-
 Cargo.toml                                    |   2 +
 crates/component_preview/Cargo.toml           |  45 ++++++
 crates/component_preview/LICENSE-GPL          |   1 +
 .../examples/component_preview.rs             |  18 +++
 .../src}/component_preview.rs                 |  14 +-
 .../src/component_preview_example.rs          | 145 ++++++++++++++++++
 .../src}/persistence.rs                       |   0
 crates/zed/Cargo.toml                         |   2 +-
 crates/zed/src/main.rs                        |   2 +-
 crates/zed/src/zed.rs                         |   1 -
 11 files changed, 248 insertions(+), 11 deletions(-)
 create mode 100644 crates/component_preview/Cargo.toml
 create mode 120000 crates/component_preview/LICENSE-GPL
 create mode 100644 crates/component_preview/examples/component_preview.rs
 rename crates/{zed/src/zed => component_preview/src}/component_preview.rs (99%)
 create mode 100644 crates/component_preview/src/component_preview_example.rs
 rename crates/{zed/src/zed/component_preview => component_preview/src}/persistence.rs (100%)

diff --git a/Cargo.lock b/Cargo.lock
index f9acd6989be8734b6c5b528435fccea62d10f027..f12d6a3484907a873e0e02d8e7af333c31dd9740 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3525,6 +3525,33 @@ dependencies = [
  "theme",
 ]
 
+[[package]]
+name = "component_preview"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client",
+ "collections",
+ "component",
+ "db",
+ "fs",
+ "gpui",
+ "language",
+ "log",
+ "node_runtime",
+ "notifications",
+ "project",
+ "release_channel",
+ "reqwest_client",
+ "session",
+ "settings",
+ "theme",
+ "ui",
+ "ui_input",
+ "uuid",
+ "workspace",
+]
+
 [[package]]
 name = "compression-codecs"
 version = "0.4.31"
@@ -20643,6 +20670,7 @@ dependencies = [
  "collections",
  "command_palette",
  "component",
+ "component_preview",
  "copilot",
  "crashes",
  "dap",
@@ -20748,7 +20776,6 @@ dependencies = [
  "tree-sitter-md",
  "tree-sitter-rust",
  "ui",
- "ui_input",
  "ui_prompt",
  "url",
  "urlencoding",
diff --git a/Cargo.toml b/Cargo.toml
index b507e8824484ea670619b5225fef9cfd41c81d4c..54f256abac03c50d5aa0ca0d1c5dd7d433319ddf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,6 +39,7 @@ members = [
     "crates/command_palette",
     "crates/command_palette_hooks",
     "crates/component",
+    "crates/component_preview",
     "crates/context_server",
     "crates/copilot",
     "crates/crashes",
@@ -275,6 +276,7 @@ collections = { path = "crates/collections", version = "0.1.0" }
 command_palette = { path = "crates/command_palette" }
 command_palette_hooks = { path = "crates/command_palette_hooks" }
 component = { path = "crates/component" }
+component_preview  = { path = "crates/component_preview" }
 context_server = { path = "crates/context_server" }
 copilot = { path = "crates/copilot" }
 crashes = { path = "crates/crashes" }
diff --git a/crates/component_preview/Cargo.toml b/crates/component_preview/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d7ca3bad47d74d86c701007da879ddf092a08b73
--- /dev/null
+++ b/crates/component_preview/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "component_preview"
+version = "0.1.0"
+edition.workspace = true
+publish.workspace = true
+license = "GPL-3.0-or-later"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/component_preview.rs"
+
+[features]
+default = []
+preview = []
+test-support = ["db/test-support"]
+
+[dependencies]
+anyhow.workspace = true
+client.workspace = true
+collections.workspace = true
+component.workspace = true
+db.workspace = true
+fs.workspace = true
+gpui.workspace = true
+language.workspace = true
+log.workspace = true
+node_runtime.workspace = true
+notifications.workspace = true
+project.workspace = true
+release_channel.workspace = true
+reqwest_client.workspace = true
+session.workspace = true
+settings.workspace = true
+theme.workspace = true
+ui.workspace = true
+ui_input.workspace = true
+uuid.workspace = true
+workspace.workspace = true
+
+[[example]]
+name = "component_preview"
+path = "examples/component_preview.rs"
+required-features = ["preview"]
diff --git a/crates/component_preview/LICENSE-GPL b/crates/component_preview/LICENSE-GPL
new file mode 120000
index 0000000000000000000000000000000000000000..e0f9dbd5d63fef1630c297edc4ceba4790be6f02
--- /dev/null
+++ b/crates/component_preview/LICENSE-GPL
@@ -0,0 +1 @@
+LICENSE-GPL
\ No newline at end of file
diff --git a/crates/component_preview/examples/component_preview.rs b/crates/component_preview/examples/component_preview.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a49110e91ee76fef8b6f69048153f47493e52097
--- /dev/null
+++ b/crates/component_preview/examples/component_preview.rs
@@ -0,0 +1,18 @@
+//! Component Preview Example
+//!
+//! Run with: `cargo run -p component_preview --example component_preview --features="preview"`
+//!
+//! To use this in other projects, add the following to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! component_preview = { path = "../component_preview", features = ["preview"] }
+//!
+//! [[example]]
+//! name = "component_preview"
+//! path = "examples/component_preview.rs"
+//! ```
+
+fn main() {
+    component_preview::run_component_preview();
+}
diff --git a/crates/zed/src/zed/component_preview.rs b/crates/component_preview/src/component_preview.rs
similarity index 99%
rename from crates/zed/src/zed/component_preview.rs
rename to crates/component_preview/src/component_preview.rs
index e3c7fc8df542448d5b8b290e96405546be7b4b1e..0f4a8d94baf9021f0d6911e693a435ee4ab5e524 100644
--- a/crates/zed/src/zed/component_preview.rs
+++ b/crates/component_preview/src/component_preview.rs
@@ -1,7 +1,4 @@
-//! # Component Preview
-//!
-//! A view for exploring Zed components.
-
+mod component_preview_example;
 mod persistence;
 
 use client::UserStore;
@@ -11,18 +8,21 @@ use gpui::{
     App, Entity, EventEmitter, FocusHandle, Focusable, Task, WeakEntity, Window, list, prelude::*,
 };
 use gpui::{ListState, ScrollHandle, ScrollStrategy, UniformListScrollHandle};
-use languages::LanguageRegistry;
+use language::LanguageRegistry;
 use notifications::status_toast::{StatusToast, ToastIcon};
 use persistence::COMPONENT_PREVIEW_DB;
 use project::Project;
 use std::{iter::Iterator, ops::Range, sync::Arc};
 use ui::{ButtonLike, Divider, HighlightedLabel, ListItem, ListSubHeader, Tooltip, prelude::*};
 use ui_input::InputField;
+use workspace::AppState;
 use workspace::{
-    AppState, Item, ItemId, SerializableItem, Workspace, WorkspaceId, delete_unloaded_items,
-    item::ItemEvent,
+    Item, ItemId, SerializableItem, Workspace, WorkspaceId, delete_unloaded_items, item::ItemEvent,
 };
 
+#[allow(unused_imports)]
+pub use component_preview_example::*;
+
 pub fn init(app_state: Arc, cx: &mut App) {
     workspace::register_serializable_item::(cx);
 
diff --git a/crates/component_preview/src/component_preview_example.rs b/crates/component_preview/src/component_preview_example.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a5efd015566a6bafdf333346c33810032ec08284
--- /dev/null
+++ b/crates/component_preview/src/component_preview_example.rs
@@ -0,0 +1,145 @@
+/// Run the component preview application.
+///
+/// This initializes the application with minimal required infrastructure
+/// and opens a workspace with the ComponentPreview item.
+#[cfg(feature = "preview")]
+pub fn run_component_preview() {
+    use fs::RealFs;
+    use gpui::{
+        AppContext as _, Application, Bounds, KeyBinding, WindowBounds, WindowOptions, actions,
+        size,
+    };
+
+    use client::{Client, UserStore};
+    use language::LanguageRegistry;
+    use node_runtime::NodeRuntime;
+    use project::Project;
+    use reqwest_client::ReqwestClient;
+    use session::{AppSession, Session};
+    use std::sync::Arc;
+    use ui::{App, px};
+    use workspace::{AppState, Workspace, WorkspaceStore};
+
+    use crate::{ComponentPreview, init};
+
+    actions!(zed, [Quit]);
+
+    fn quit(_: &Quit, cx: &mut App) {
+        cx.quit();
+    }
+
+    Application::new().run(|cx| {
+        component::init();
+
+        cx.on_action(quit);
+        cx.bind_keys([KeyBinding::new("cmd-q", Quit, None)]);
+        let version = release_channel::AppVersion::load(env!("CARGO_PKG_VERSION"), None, None);
+        release_channel::init(version, cx);
+
+        let http_client =
+            ReqwestClient::user_agent("component_preview").expect("Failed to create HTTP client");
+        cx.set_http_client(Arc::new(http_client));
+
+        let fs = Arc::new(RealFs::new(None, cx.background_executor().clone()));
+        ::set_global(fs.clone(), cx);
+
+        settings::init(cx);
+        theme::init(theme::LoadThemes::JustBase, cx);
+
+        let languages = Arc::new(LanguageRegistry::new(cx.background_executor().clone()));
+        let client = Client::production(cx);
+        client::init(&client, cx);
+
+        let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
+        let workspace_store = cx.new(|cx| WorkspaceStore::new(client.clone(), cx));
+        let session_id = uuid::Uuid::new_v4().to_string();
+        let session = cx.background_executor().block(Session::new(session_id));
+        let session = cx.new(|cx| AppSession::new(session, cx));
+        let node_runtime = NodeRuntime::unavailable();
+
+        let app_state = Arc::new(AppState {
+            languages,
+            client,
+            user_store,
+            workspace_store,
+            fs,
+            build_window_options: |_, _| Default::default(),
+            node_runtime,
+            session,
+        });
+        AppState::set_global(Arc::downgrade(&app_state), cx);
+
+        workspace::init(app_state.clone(), cx);
+        init(app_state.clone(), cx);
+
+        let size = size(px(1200.), px(800.));
+        let bounds = Bounds::centered(None, size, cx);
+
+        cx.open_window(
+            WindowOptions {
+                window_bounds: Some(WindowBounds::Windowed(bounds)),
+                ..Default::default()
+            },
+            {
+                move |window, cx| {
+                    let app_state = app_state;
+                    theme::setup_ui_font(window, cx);
+
+                    let project = Project::local(
+                        app_state.client.clone(),
+                        app_state.node_runtime.clone(),
+                        app_state.user_store.clone(),
+                        app_state.languages.clone(),
+                        app_state.fs.clone(),
+                        None,
+                        false,
+                        cx,
+                    );
+
+                    let workspace = cx.new(|cx| {
+                        Workspace::new(
+                            Default::default(),
+                            project.clone(),
+                            app_state.clone(),
+                            window,
+                            cx,
+                        )
+                    });
+
+                    workspace.update(cx, |workspace, cx| {
+                        let weak_workspace = cx.entity().downgrade();
+                        let language_registry = app_state.languages.clone();
+                        let user_store = app_state.user_store.clone();
+
+                        let component_preview = cx.new(|cx| {
+                            ComponentPreview::new(
+                                weak_workspace,
+                                project,
+                                language_registry,
+                                user_store,
+                                None,
+                                None,
+                                window,
+                                cx,
+                            )
+                            .expect("Failed to create component preview")
+                        });
+
+                        workspace.add_item_to_active_pane(
+                            Box::new(component_preview),
+                            None,
+                            true,
+                            window,
+                            cx,
+                        );
+                    });
+
+                    workspace
+                }
+            },
+        )
+        .expect("Failed to open component preview window");
+
+        cx.activate(true);
+    });
+}
diff --git a/crates/zed/src/zed/component_preview/persistence.rs b/crates/component_preview/src/persistence.rs
similarity index 100%
rename from crates/zed/src/zed/component_preview/persistence.rs
rename to crates/component_preview/src/persistence.rs
diff --git a/crates/zed/Cargo.toml b/crates/zed/Cargo.toml
index 80eca20e00309bb8d22552287a1c39cb9891307d..5c5d35944672a36733d6da50505f8d5bacad74f3 100644
--- a/crates/zed/Cargo.toml
+++ b/crates/zed/Cargo.toml
@@ -41,6 +41,7 @@ collab_ui.workspace = true
 collections.workspace = true
 command_palette.workspace = true
 component.workspace = true
+component_preview.workspace = true
 copilot.workspace = true
 crashes.workspace = true
 dap_adapters.workspace = true
@@ -148,7 +149,6 @@ ztracing.workspace = true
 tracing.workspace = true
 toolchain_selector.workspace = true
 ui.workspace = true
-ui_input.workspace = true
 ui_prompt.workspace = true
 url.workspace = true
 urlencoding.workspace = true
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index 03e02bb0107d736c07eb3fc9626856943f8d80a6..bdf3bf3f950a329e7c1b49f5ce27560b00807a5f 100644
--- a/crates/zed/src/main.rs
+++ b/crates/zed/src/main.rs
@@ -774,7 +774,7 @@ fn main() {
 
         let app_state = app_state.clone();
 
-        crate::zed::component_preview::init(app_state.clone(), cx);
+        component_preview::init(app_state.clone(), cx);
 
         cx.spawn(async move |cx| {
             while let Some(urls) = open_rx.next().await {
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index 3441cb88d96b06dfdbb65a58553d2c58f435d157..392a57520d28be021e55cbd890d2eb968370c2f7 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -1,5 +1,4 @@
 mod app_menus;
-pub mod component_preview;
 pub mod edit_prediction_registry;
 #[cfg(target_os = "macos")]
 pub(crate) mod mac_only_instance;

From 42d5f7e73e8597b26f4457399d4c5afa8fed24b0 Mon Sep 17 00:00:00 2001
From: Lieunoir <33102721+Lieunoir@users.noreply.github.com>
Date: Sat, 20 Dec 2025 01:38:45 +0100
Subject: [PATCH 264/266] Set override_redirect for PopUps (#42224)

Currently on x11, gpui PopUp windows only rely on the "notification"
type in order to indicate that they should spawn as floating window.
Several window managers (leftwm in my case, but it also seems to be the
case for dwm and ratpoison) do not this property into account thus not
spawning them as float. On the other hand, using Floating instead of
PopUp do make those windows spawn as floating, as these window manager
do take into account the (older) "dialog" type.

The [freedekstop
documentation](https://specifications.freedesktop.org/wm/1.5/ar01s05.html#id-1.6.7)
does seem to suggest that these windows should also have the override
redirect property :
> This property is typically used on override-redirect windows.

Note that this also disables pretty much all interactions with the
window manager (such as moving the window, resizing etc...)

Release Notes:

- Fix popup windows not spawning floating sometime on x11
---
 crates/gpui/src/platform/linux/x11/window.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/gpui/src/platform/linux/x11/window.rs b/crates/gpui/src/platform/linux/x11/window.rs
index 1986ff6cce6b1930bdc3527eced5f2d5b8f45117..46d1cbd3253618cae5a7df9c27195ea8921954eb 100644
--- a/crates/gpui/src/platform/linux/x11/window.rs
+++ b/crates/gpui/src/platform/linux/x11/window.rs
@@ -431,6 +431,7 @@ impl X11WindowState {
             // https://stackoverflow.com/questions/43218127/x11-xlib-xcb-creating-a-window-requires-border-pixel-if-specifying-colormap-wh
             .border_pixel(visual_set.black_pixel)
             .colormap(colormap)
+            .override_redirect((params.kind == WindowKind::PopUp) as u32)
             .event_mask(
                 xproto::EventMask::EXPOSURE
                     | xproto::EventMask::STRUCTURE_NOTIFY

From 58461377ca064a3aadc724cfd0921f3fae5d9d85 Mon Sep 17 00:00:00 2001
From: Marshall Bowers 
Date: Fri, 19 Dec 2025 20:01:19 -0500
Subject: [PATCH 265/266] ci: Disable automated docs on pushes to `main`
 (#45416)

This PR disables the automated docs on pushes to `main`, as it is
currently making CI red.

Release Notes:

- N/A
---
 .github/workflows/docs_automation.yml | 54 +++++++++++++--------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/.github/workflows/docs_automation.yml b/.github/workflows/docs_automation.yml
index 5b72bc4051f34ae890bc291281f8797312f5d52d..46dcfa56616c24a78f61e075d3e1a7909655b8aa 100644
--- a/.github/workflows/docs_automation.yml
+++ b/.github/workflows/docs_automation.yml
@@ -1,11 +1,11 @@
 name: Documentation Automation
 
 on:
-  push:
-    branches: [main]
-    paths:
-      - 'crates/**'
-      - 'extensions/**'
+  # push:
+  #   branches: [main]
+  #   paths:
+  #     - 'crates/**'
+  #     - 'extensions/**'
   workflow_dispatch:
     inputs:
       pr_number:
@@ -29,7 +29,7 @@ jobs:
   docs-automation:
     runs-on: ubuntu-latest
     timeout-minutes: 30
-    
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -77,7 +77,7 @@ jobs:
             echo "ref=$SHA" >> "$GITHUB_OUTPUT"
             git diff --name-only "${SHA}^" "$SHA" > /tmp/changed_files.txt || git diff --name-only HEAD~1 HEAD > /tmp/changed_files.txt
           fi
-          
+
           echo "Changed files:"
           cat /tmp/changed_files.txt
         env:
@@ -102,24 +102,24 @@ jobs:
         run: |
           CHANGED_FILES=$(tr '\n' ' ' < /tmp/changed_files.txt)
           echo "Analyzing changes in: $CHANGED_FILES"
-          
+
           # Build prompt with context
           cat > /tmp/phase3-prompt.md << 'EOF'
           $(cat .factory/prompts/docs-automation/phase3-analyze.md)
-          
+
           ## Context
-          
+
           ### Changed Files
           $CHANGED_FILES
-          
+
           ### Phase 2 Output
           $(cat /tmp/phase2-output.txt)
           EOF
-          
+
           "$DROID_BIN" exec \
             -m "$DROID_MODEL" \
             "$(cat .factory/prompts/docs-automation/phase3-analyze.md)
-            
+
             Changed files: $CHANGED_FILES" \
             > /tmp/phase3-output.md 2>&1 || true
           echo "Change analysis complete"
@@ -135,7 +135,7 @@ jobs:
             > /tmp/phase4-plan.md 2>&1 || true
           echo "Documentation plan complete"
           cat /tmp/phase4-plan.md
-          
+
           # Check if updates are required
           if grep -q "NO_UPDATES_REQUIRED" /tmp/phase4-plan.md; then
             echo "updates_required=false" >> "$GITHUB_OUTPUT"
@@ -163,10 +163,10 @@ jobs:
         run: |
           echo "Formatting documentation with Prettier..."
           cd docs && prettier --write src/
-          
+
           echo "Verifying Prettier formatting passes..."
           cd docs && prettier --check src/
-          
+
           echo "Prettier formatting complete"
 
       # Phase 6: Summarize Changes (Read-Only - default)
@@ -176,7 +176,7 @@ jobs:
         run: |
           # Get git diff of docs
           git diff docs/src/ > /tmp/docs-diff.txt || true
-          
+
           "$DROID_BIN" exec \
             -m "$DROID_MODEL" \
             -f .factory/prompts/docs-automation/phase6-summarize.md \
@@ -194,17 +194,17 @@ jobs:
             echo "No documentation changes detected"
             exit 0
           fi
-          
+
           # Configure git
           git config user.name "factory-droid[bot]"
           git config user.email "138933559+factory-droid[bot]@users.noreply.github.com"
-          
+
           # Daily batch branch - one branch per day, multiple commits accumulate
           BRANCH_NAME="docs/auto-update-$(date +%Y-%m-%d)"
-          
+
           # Stash local changes from phase 5
           git stash push -m "docs-automation-changes" -- docs/src/
-          
+
           # Check if branch already exists on remote
           if git ls-remote --exit-code --heads origin "$BRANCH_NAME" > /dev/null 2>&1; then
             echo "Branch $BRANCH_NAME exists, checking out and updating..."
@@ -214,10 +214,10 @@ jobs:
             echo "Creating new branch $BRANCH_NAME..."
             git checkout -b "$BRANCH_NAME"
           fi
-          
+
           # Apply stashed changes
           git stash pop || true
-          
+
           # Stage and commit
           git add docs/src/
           SUMMARY=$(head -50 < /tmp/phase6-summary.md)
@@ -228,13 +228,13 @@ jobs:
           Triggered by: ${{ steps.changed.outputs.source }} ${{ steps.changed.outputs.ref }}
 
           Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>"
-          
+
           # Push
           git push -u origin "$BRANCH_NAME"
-          
+
           # Check if PR already exists for this branch
           EXISTING_PR=$(gh pr list --head "$BRANCH_NAME" --json number --jq '.[0].number' || echo "")
-          
+
           if [ -n "$EXISTING_PR" ]; then
             echo "PR #$EXISTING_PR already exists for branch $BRANCH_NAME, updated with new commit"
           else
@@ -254,7 +254,7 @@ jobs:
         run: |
           echo "## Documentation Automation Summary" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
-          
+
           if [ "${{ steps.phase4.outputs.updates_required }}" == "false" ]; then
             echo "No documentation updates required for this change." >> "$GITHUB_STEP_SUMMARY"
           elif [ -f /tmp/phase6-summary.md ]; then

From 0facdfa5caedb1cacf92d435697c83dad1e66ea4 Mon Sep 17 00:00:00 2001
From: Danilo Leal <67129314+danilo-leal@users.noreply.github.com>
Date: Fri, 19 Dec 2025 22:37:15 -0300
Subject: [PATCH 266/266] editor: Make `TextAlign::Center` and
 `TextAlign::Right` work (#45417)

Closes https://github.com/zed-industries/zed/issues/43208

This PR essentially unblocks the editable number field. The function
that shapes editor lines was hard-coding text alignment to the left,
meaning that whatever different alignment we'd pass through
`EditorStyles`would be ignored. To solve this, I just added a text align
and align width fields to the line paint function and updated all call
sites keeping the default configuration. Had to also add an
`alignment_offset()` helper to make sure the cursor positioning, the
selection background element, and the click-to-focus functionality were
kept in-sync with the non-left aligned editor.

Then... the big star of the show here is being able to add the `mode`
method to the number field, which uses `TextAlign::Center`, thus making
it work as we designed it to work.


https://github.com/user-attachments/assets/3539c976-d7bf-4d94-8188-a14328f94fbf

Next up, is turning the number filed to edit mode where applicable.

Release Notes:

- Fixed a bug where different text alignment configurations (i.e.,
center and right-aligned) wouldn't take effect in editors.
---
 crates/editor/src/element.rs                 | 106 +++++++++++++++----
 crates/gpui/examples/input.rs                |  11 +-
 crates/gpui/src/text_system/line.rs          |  12 ++-
 crates/terminal_view/src/terminal_element.rs |  19 +++-
 crates/ui_input/src/number_field.rs          |  66 ++++++++----
 5 files changed, 164 insertions(+), 50 deletions(-)

diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index b2e355dc5158214eabd07d519649591be8a325a8..ae8dd527122f19bdf7566e4dba3a504e6d19261d 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -46,9 +46,9 @@ use gpui::{
     KeybindingKeystroke, Length, Modifiers, ModifiersChangedEvent, MouseButton, MouseClickEvent,
     MouseDownEvent, MouseMoveEvent, MousePressureEvent, MouseUpEvent, PaintQuad, ParentElement,
     Pixels, PressureStage, ScrollDelta, ScrollHandle, ScrollWheelEvent, ShapedLine, SharedString,
-    Size, StatefulInteractiveElement, Style, Styled, TextRun, TextStyleRefinement, WeakEntity,
-    Window, anchored, deferred, div, fill, linear_color_stop, linear_gradient, outline, point, px,
-    quad, relative, size, solid_background, transparent_black,
+    Size, StatefulInteractiveElement, Style, Styled, TextAlign, TextRun, TextStyleRefinement,
+    WeakEntity, Window, anchored, deferred, div, fill, linear_color_stop, linear_gradient, outline,
+    point, px, quad, relative, size, solid_background, transparent_black,
 };
 use itertools::Itertools;
 use language::{IndentGuideSettings, language_settings::ShowWhitespaceSetting};
@@ -1695,9 +1695,13 @@ impl EditorElement {
                         [cursor_position.row().minus(visible_display_row_range.start) as usize];
                     let cursor_column = cursor_position.column() as usize;
 
-                    let cursor_character_x = cursor_row_layout.x_for_index(cursor_column);
-                    let mut block_width =
-                        cursor_row_layout.x_for_index(cursor_column + 1) - cursor_character_x;
+                    let cursor_character_x = cursor_row_layout.x_for_index(cursor_column)
+                        + cursor_row_layout
+                            .alignment_offset(self.style.text.text_align, text_hitbox.size.width);
+                    let cursor_next_x = cursor_row_layout.x_for_index(cursor_column + 1)
+                        + cursor_row_layout
+                            .alignment_offset(self.style.text.text_align, text_hitbox.size.width);
+                    let mut block_width = cursor_next_x - cursor_character_x;
                     if block_width == Pixels::ZERO {
                         block_width = em_advance;
                     }
@@ -6160,10 +6164,25 @@ impl EditorElement {
                     let color = cx.theme().colors().editor_hover_line_number;
 
                     let line = self.shape_line_number(shaped_line.text.clone(), color, window);
-                    line.paint(hitbox.origin, line_height, window, cx).log_err()
+                    line.paint(
+                        hitbox.origin,
+                        line_height,
+                        TextAlign::Left,
+                        None,
+                        window,
+                        cx,
+                    )
+                    .log_err()
                 } else {
                     shaped_line
-                        .paint(hitbox.origin, line_height, window, cx)
+                        .paint(
+                            hitbox.origin,
+                            line_height,
+                            TextAlign::Left,
+                            None,
+                            window,
+                            cx,
+                        )
                         .log_err()
                 }) else {
                     continue;
@@ -7252,23 +7271,27 @@ impl EditorElement {
                     .map(|row| {
                         let line_layout =
                             &layout.position_map.line_layouts[row.minus(start_row) as usize];
+                        let alignment_offset =
+                            line_layout.alignment_offset(layout.text_align, layout.content_width);
                         HighlightedRangeLine {
                             start_x: if row == range.start.row() {
                                 layout.content_origin.x
                                     + Pixels::from(
                                         ScrollPixelOffset::from(
-                                            line_layout.x_for_index(range.start.column() as usize),
+                                            line_layout.x_for_index(range.start.column() as usize)
+                                                + alignment_offset,
                                         ) - layout.position_map.scroll_pixel_position.x,
                                     )
                             } else {
-                                layout.content_origin.x
+                                layout.content_origin.x + alignment_offset
                                     - Pixels::from(layout.position_map.scroll_pixel_position.x)
                             },
                             end_x: if row == range.end.row() {
                                 layout.content_origin.x
                                     + Pixels::from(
                                         ScrollPixelOffset::from(
-                                            line_layout.x_for_index(range.end.column() as usize),
+                                            line_layout.x_for_index(range.end.column() as usize)
+                                                + alignment_offset,
                                         ) - layout.position_map.scroll_pixel_position.x,
                                     )
                             } else {
@@ -7276,6 +7299,7 @@ impl EditorElement {
                                     ScrollPixelOffset::from(
                                         layout.content_origin.x
                                             + line_layout.width
+                                            + alignment_offset
                                             + line_end_overshoot,
                                     ) - layout.position_map.scroll_pixel_position.x,
                                 )
@@ -8516,8 +8540,15 @@ impl LineWithInvisibles {
         for fragment in &self.fragments {
             match fragment {
                 LineFragment::Text(line) => {
-                    line.paint(fragment_origin, line_height, window, cx)
-                        .log_err();
+                    line.paint(
+                        fragment_origin,
+                        line_height,
+                        layout.text_align,
+                        Some(layout.content_width),
+                        window,
+                        cx,
+                    )
+                    .log_err();
                     fragment_origin.x += line.width;
                 }
                 LineFragment::Element { size, .. } => {
@@ -8559,8 +8590,15 @@ impl LineWithInvisibles {
         for fragment in &self.fragments {
             match fragment {
                 LineFragment::Text(line) => {
-                    line.paint_background(fragment_origin, line_height, window, cx)
-                        .log_err();
+                    line.paint_background(
+                        fragment_origin,
+                        line_height,
+                        layout.text_align,
+                        Some(layout.content_width),
+                        window,
+                        cx,
+                    )
+                    .log_err();
                     fragment_origin.x += line.width;
                 }
                 LineFragment::Element { size, .. } => {
@@ -8609,7 +8647,7 @@ impl LineWithInvisibles {
                 [token_offset, token_end_offset],
                 Box::new(move |window: &mut Window, cx: &mut App| {
                     invisible_symbol
-                        .paint(origin, line_height, window, cx)
+                        .paint(origin, line_height, TextAlign::Left, None, window, cx)
                         .log_err();
                 }),
             )
@@ -8770,6 +8808,15 @@ impl LineWithInvisibles {
 
         None
     }
+
+    pub fn alignment_offset(&self, text_align: TextAlign, content_width: Pixels) -> Pixels {
+        let line_width = self.width;
+        match text_align {
+            TextAlign::Left => px(0.0),
+            TextAlign::Center => (content_width - line_width) / 2.0,
+            TextAlign::Right => content_width - line_width,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -10172,6 +10219,8 @@ impl Element for EditorElement {
                         em_width,
                         em_advance,
                         snapshot,
+                        text_align: self.style.text.text_align,
+                        content_width: text_hitbox.size.width,
                         gutter_hitbox: gutter_hitbox.clone(),
                         text_hitbox: text_hitbox.clone(),
                         inline_blame_bounds: inline_blame_layout
@@ -10225,6 +10274,8 @@ impl Element for EditorElement {
                         sticky_buffer_header,
                         sticky_headers,
                         expand_toggles,
+                        text_align: self.style.text.text_align,
+                        content_width: text_hitbox.size.width,
                     }
                 })
             })
@@ -10405,6 +10456,8 @@ pub struct EditorLayout {
     sticky_buffer_header: Option,
     sticky_headers: Option,
     document_colors: Option<(DocumentColorsRenderMode, Vec<(Range, Hsla)>)>,
+    text_align: TextAlign,
+    content_width: Pixels,
 }
 
 struct StickyHeaders {
@@ -10572,7 +10625,9 @@ impl StickyHeaderLine {
                 gutter_origin.x + gutter_width - gutter_right_padding - line_number.width,
                 gutter_origin.y,
             );
-            line_number.paint(origin, line_height, window, cx).log_err();
+            line_number
+                .paint(origin, line_height, TextAlign::Left, None, window, cx)
+                .log_err();
         }
     }
 }
@@ -11011,6 +11066,8 @@ pub(crate) struct PositionMap {
     pub visible_row_range: Range,
     pub line_layouts: Vec,
     pub snapshot: EditorSnapshot,
+    pub text_align: TextAlign,
+    pub content_width: Pixels,
     pub text_hitbox: Hitbox,
     pub gutter_hitbox: Hitbox,
     pub inline_blame_bounds: Option<(Bounds, BufferId, BlameEntry)>,
@@ -11076,10 +11133,12 @@ impl PositionMap {
             .line_layouts
             .get(row as usize - scroll_position.y as usize)
         {
-            if let Some(ix) = line.index_for_x(x) {
+            let alignment_offset = line.alignment_offset(self.text_align, self.content_width);
+            let x_relative_to_text = x - alignment_offset;
+            if let Some(ix) = line.index_for_x(x_relative_to_text) {
                 (ix as u32, px(0.))
             } else {
-                (line.len as u32, px(0.).max(x - line.width))
+                (line.len as u32, px(0.).max(x_relative_to_text - line.width))
             }
         } else {
             (0, x)
@@ -11268,7 +11327,14 @@ impl CursorLayout {
 
         if let Some(block_text) = &self.block_text {
             block_text
-                .paint(self.origin + origin, self.line_height, window, cx)
+                .paint(
+                    self.origin + origin,
+                    self.line_height,
+                    TextAlign::Left,
+                    None,
+                    window,
+                    cx,
+                )
                 .log_err();
         }
     }
diff --git a/crates/gpui/examples/input.rs b/crates/gpui/examples/input.rs
index 44fae4ffe6bb9e120a8f96c10e0af8f4f8026cdd..aac56bdf1d0b739f28f395e537b171264c78a1e8 100644
--- a/crates/gpui/examples/input.rs
+++ b/crates/gpui/examples/input.rs
@@ -546,8 +546,15 @@ impl Element for TextElement {
             window.paint_quad(selection)
         }
         let line = prepaint.line.take().unwrap();
-        line.paint(bounds.origin, window.line_height(), window, cx)
-            .unwrap();
+        line.paint(
+            bounds.origin,
+            window.line_height(),
+            gpui::TextAlign::Left,
+            None,
+            window,
+            cx,
+        )
+        .unwrap();
 
         if focus_handle.is_focused(window)
             && let Some(cursor) = prepaint.cursor.take()
diff --git a/crates/gpui/src/text_system/line.rs b/crates/gpui/src/text_system/line.rs
index 84618eccc43dc3f189d3d49ea22b9d98f5ad9f85..1e71a611c7cef4b22668db8840ea5dac7fa13709 100644
--- a/crates/gpui/src/text_system/line.rs
+++ b/crates/gpui/src/text_system/line.rs
@@ -64,6 +64,8 @@ impl ShapedLine {
         &self,
         origin: Point,
         line_height: Pixels,
+        align: TextAlign,
+        align_width: Option,
         window: &mut Window,
         cx: &mut App,
     ) -> Result<()> {
@@ -71,8 +73,8 @@ impl ShapedLine {
             origin,
             &self.layout,
             line_height,
-            TextAlign::default(),
-            None,
+            align,
+            align_width,
             &self.decoration_runs,
             &[],
             window,
@@ -87,6 +89,8 @@ impl ShapedLine {
         &self,
         origin: Point,
         line_height: Pixels,
+        align: TextAlign,
+        align_width: Option,
         window: &mut Window,
         cx: &mut App,
     ) -> Result<()> {
@@ -94,8 +98,8 @@ impl ShapedLine {
             origin,
             &self.layout,
             line_height,
-            TextAlign::default(),
-            None,
+            align,
+            align_width,
             &self.decoration_runs,
             &[],
             window,
diff --git a/crates/terminal_view/src/terminal_element.rs b/crates/terminal_view/src/terminal_element.rs
index b5324b7c6c7e0c467c657b122717fbf17cf9f7b9..c5289a34d6cbc9ecc4ddcdaacb6aaf2ce0831846 100644
--- a/crates/terminal_view/src/terminal_element.rs
+++ b/crates/terminal_view/src/terminal_element.rs
@@ -151,7 +151,14 @@ impl BatchedTextRun {
                 std::slice::from_ref(&self.style),
                 Some(dimensions.cell_width),
             )
-            .paint(pos, dimensions.line_height, window, cx);
+            .paint(
+                pos,
+                dimensions.line_height,
+                gpui::TextAlign::Left,
+                None,
+                window,
+                cx,
+            );
     }
 }
 
@@ -1326,8 +1333,14 @@ impl Element for TerminalElement {
                                     }],
                                     None
                                 );
-                                shaped_line
-                                    .paint(ime_position, layout.dimensions.line_height, window, cx)
+                                shaped_line.paint(
+                                    ime_position,
+                                    layout.dimensions.line_height,
+                                    gpui::TextAlign::Left,
+                                    None,
+                                    window,
+                                    cx,
+                                )
                                     .log_err();
                             }
 
diff --git a/crates/ui_input/src/number_field.rs b/crates/ui_input/src/number_field.rs
index 2d596a2498f445f6a0d18ce48b02bddf20aee8da..389f61c748615da162c04182e855459f62d3d226 100644
--- a/crates/ui_input/src/number_field.rs
+++ b/crates/ui_input/src/number_field.rs
@@ -5,8 +5,11 @@ use std::{
     str::FromStr,
 };
 
-use editor::{Editor, EditorStyle};
-use gpui::{ClickEvent, Entity, FocusHandle, Focusable, FontWeight, Modifiers};
+use editor::Editor;
+use gpui::{
+    ClickEvent, Entity, FocusHandle, Focusable, FontWeight, Modifiers, TextAlign,
+    TextStyleRefinement,
+};
 
 use settings::{CenteredPaddingSettings, CodeFade, DelayMs, InactiveOpacity, MinimumContrast};
 use ui::prelude::*;
@@ -309,6 +312,11 @@ impl NumberField {
         self
     }
 
+    pub fn mode(self, mode: NumberFieldMode, cx: &mut App) -> Self {
+        self.mode.write(cx, mode);
+        self
+    }
+
     pub fn on_reset(
         mut self,
         on_reset: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static,
@@ -451,9 +459,11 @@ impl RenderOnce for NumberField {
                                         |window, cx| {
                                             let previous_focus_handle = window.focused(cx);
                                             let mut editor = Editor::single_line(window, cx);
-                                            let mut style = EditorStyle::default();
-                                            style.text.text_align = gpui::TextAlign::Right;
-                                            editor.set_style(style, window, cx);
+
+                                            editor.set_text_style_refinement(TextStyleRefinement {
+                                                text_align: Some(TextAlign::Center),
+                                                ..Default::default()
+                                            });
 
                                             editor.set_text(format!("{}", self.value), window, cx);
                                             cx.on_focus_out(&editor.focus_handle(cx), window, {
@@ -555,22 +565,36 @@ impl Component for NumberField {
         Some(
             v_flex()
                 .gap_6()
-                .children(vec![single_example(
-                    "Default Numeric Stepper",
-                    NumberField::new(
-                        "numeric-stepper-component-preview",
-                        *stepper_example.read(cx),
-                        window,
-                        cx,
-                    )
-                    .on_change({
-                        let stepper_example = stepper_example.clone();
-                        move |value, _, cx| stepper_example.write(cx, *value)
-                    })
-                    .min(1.0)
-                    .max(100.0)
-                    .into_any_element(),
-                )])
+                .children(vec![
+                    single_example(
+                        "Default Number Field",
+                        NumberField::new("number-field", *stepper_example.read(cx), window, cx)
+                            .on_change({
+                                let stepper_example = stepper_example.clone();
+                                move |value, _, cx| stepper_example.write(cx, *value)
+                            })
+                            .min(1.0)
+                            .max(100.0)
+                            .into_any_element(),
+                    ),
+                    single_example(
+                        "Read-Only Number Field",
+                        NumberField::new(
+                            "editable-number-field",
+                            *stepper_example.read(cx),
+                            window,
+                            cx,
+                        )
+                        .on_change({
+                            let stepper_example = stepper_example.clone();
+                            move |value, _, cx| stepper_example.write(cx, *value)
+                        })
+                        .min(1.0)
+                        .max(100.0)
+                        .mode(NumberFieldMode::Edit, cx)
+                        .into_any_element(),
+                    ),
+                ])
                 .into_any_element(),
         )
     }

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