vim: Add zH/zL/zh/zl

Just a tiny bit of polish here, so that if the user expands the
disclosure, an equivalent loading state is at the response container.

<img
src="https://github.com/user-attachments/assets/a2ecb7f4-c9ea-4a14-8a60-9f7f2983a1a1"
width="600px" />

Release Notes:

- N/A

.github/ISSUE_TEMPLATE/0_git_beta_bug_report.yml

@@ -1,51 +0,0 @@
-name: Git Beta
-description: There is a bug related to new Git features in Zed
-type: "Bug"
-labels: [git]
-title: "Git Beta: <a short description of the Git bug>"
-body:
-  - type: textarea
-    attributes:
-      label: Summary
-      description: Describe the bug with a one line summary, and provide detailed reproduction steps
-      value: |
-        <!-- Please insert a one line summary of the issue below -->
-
-        <!-- Include all steps necessary to reproduce from a clean Zed installation. Be verbose -->
-        Steps to trigger the problem:
-        1.
-        2.
-        3.
-
-        Actual Behavior:
-
-        Expected Behavior:
-
-    validations:
-      required: true
-  - type: textarea
-    id: environment
-    attributes:
-      label: Zed Version and System Specs
-      description: 'Open Zed, and in the command palette select "zed: Copy System Specs Into Clipboard"'
-      placeholder: |
-        Output of "zed: Copy System Specs Into Clipboard"
-    validations:
-      required: true
-  - type: textarea
-    attributes:
-      label: If applicable, attach your `~/Library/Logs/Zed/Zed.log` file to this issue.
-      description: |
-        macOS: `~/Library/Logs/Zed/Zed.log`
-        Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
-        If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
-      value: |
-        <details><summary>Zed.log</summary>
-
-        <!-- Click below this line and paste or drag-and-drop your log-->
-        ```
-
-        ```
-        <!-- Click above this line and paste or drag-and-drop your log--></details>
-    validations:
-      required: false

.github/workflows/ci.yml

@@ -28,6 +28,7 @@ jobs:
     if: github.repository_owner == 'zed-industries'
     outputs:
       run_tests: ${{ steps.filter.outputs.run_tests }}
+      run_license: ${{ steps.filter.outputs.run_license }}
     runs-on:
       - ubuntu-latest
     steps:
@@ -47,7 +48,12 @@ jobs:
             git fetch origin "$GITHUB_BASE_REF" --depth=350
             COMPARE_REV=$(git merge-base "origin/${GITHUB_BASE_REF}" HEAD)
           fi
-          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -v "^docs/") ]]; then
+          # Specify anything which should skip full CI in this regex:
+          # - docs/
+          # - .github/ISSUE_TEMPLATE/
+          # - .github/workflows/  (except .github/workflows/ci.yml)
+          SKIP_REGEX='^(docs/|\.github/(ISSUE_TEMPLATE|workflows/(?!ci)))'
+          if [[ $(git diff --name-only $COMPARE_REV ${{ github.sha }} | grep -vP "$SKIP_REGEX") ]]; then
             echo "run_tests=true" >> $GITHUB_OUTPUT
           else
             echo "run_tests=false" >> $GITHUB_OUTPUT

.github/workflows/community_release_actions.yml

@@ -13,12 +13,11 @@ jobs:
         id: get-release-url
         run: |
           if [ "${{ github.event.release.prerelease }}" == "true" ]; then
-              URL="https://zed.dev/releases/preview/latest"
+            URL="https://zed.dev/releases/preview/latest"
           else
-              URL="https://zed.dev/releases/stable/latest"
+            URL="https://zed.dev/releases/stable/latest"
           fi
-
-          echo "URL=$URL" >> $GITHUB_OUTPUT
+          echo "::set-output name=URL::$URL"
       - name: Get content
         uses: 2428392/gh-truncate-string-action@b3ff790d21cf42af3ca7579146eedb93c8fb0757 # v1.4.1
         id: get-content
@@ -34,34 +33,3 @@ jobs:
         with:
           webhook-url: ${{ secrets.DISCORD_WEBHOOK_URL }}
           content: ${{ steps.get-content.outputs.string }}
-
-  send_release_notes_email:
-    if: github.repository_owner == 'zed-industries' && !github.event.release.prerelease
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Check if release was promoted from preview
-        id: check-promotion-from-preview
-        run: |
-          VERSION="${{ github.event.release.tag_name }}"
-          PREVIEW_TAG="${VERSION}-pre"
-
-          if git rev-parse "$PREVIEW_TAG" > /dev/null 2>&1; then
-              echo "was_promoted_from_preview=true" >> $GITHUB_OUTPUT
-          else
-              echo "was_promoted_from_preview=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Send release notes email
-        if: steps.check-promotion-from-preview.outputs.was_promoted_from_preview == 'true'
-        run: |
-          curl -X POST "https://zed.dev/api/send_release_notes_email" \
-              -H "Authorization: Bearer ${{ secrets.RELEASE_NOTES_API_TOKEN }}" \
-              -H "Content-Type: application/json" \
-              -d '{
-                  "version": "${{ github.event.release.tag_name }}",
-                  "markdown_body": ${{ toJSON(github.event.release.body) }}
-              }'

Cargo.toml

@@ -174,14 +174,11 @@ members = [
     "extensions/html",
     "extensions/perplexity",
     "extensions/proto",
-    "extensions/purescript",
     "extensions/ruff",
     "extensions/slash-commands-example",
     "extensions/snippets",
     "extensions/test-extension",
     "extensions/toml",
-    "extensions/uiua",
-    "extensions/zig",
 
     #
     # Tooling

assets/icons/expand_down.svg

@@ -0,0 +1,4 @@
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10.5 8.5L7.5 11.5M7.5 11.5L4.5 8.5M7.5 11.5L7.5 5.5" stroke="black" stroke-linecap="square"/>
+<path d="M5 3.5L10 3.5" stroke="black"/>
+</svg>

assets/icons/expand_up.svg

@@ -0,0 +1,4 @@
+<svg width="15" height="15" viewBox="0 0 15 15" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M4.5 6.5L7.5 3.5M7.5 3.5L10.5 6.5M7.5 3.5V9.5" stroke="black" stroke-linecap="square"/>
+<path d="M5 11.5H10" stroke="black"/>
+</svg>

assets/icons/settings_alt.svg

@@ -1,6 +1,6 @@
 <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M3 4H8" stroke="black" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M6 10L11 10" stroke="black" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/>
-<circle cx="4" cy="10" r="1.875" stroke="black" stroke-width="1.75"/>
-<circle cx="10" cy="4" r="1.875" stroke="black" stroke-width="1.75"/>
+<path d="M3 4H8" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M6 10L11 10" stroke="black" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+<circle cx="4" cy="10" r="1.875" stroke="black" stroke-width="1.5"/>
+<circle cx="10" cy="4" r="1.875" stroke="black" stroke-width="1.5"/>
 </svg>

assets/keymaps/default-linux.json

@@ -362,6 +362,7 @@
       "ctrl-k ctrl-0": "editor::FoldAll",
       "ctrl-k ctrl-j": "editor::UnfoldAll",
       "ctrl-space": "editor::ShowCompletions",
+      "ctrl-shift-space": "editor::ShowWordCompletions",
       "ctrl-.": "editor::ToggleCodeActions",
       "ctrl-k r": "editor::RevealInFileManager",
       "ctrl-k p": "editor::CopyPath",

assets/keymaps/default-macos.json

@@ -466,6 +466,7 @@
       // Using `ctrl-space` in Zed requires disabling the macOS global shortcut.
       // System Preferences->Keyboard->Keyboard Shortcuts->Input Sources->Select the previous input source (uncheck)
       "ctrl-space": "editor::ShowCompletions",
+      "ctrl-shift-space": "editor::ShowWordCompletions",
       "cmd-.": "editor::ToggleCodeActions",
       "cmd-k r": "editor::RevealInFileManager",
       "cmd-k p": "editor::CopyPath",

assets/keymaps/vim.json

@@ -155,6 +155,7 @@
       "z +": ["workspace::SendKeystrokes", "shift-l j z t ^"],
       "z t": "editor::ScrollCursorTop",
       "z z": "editor::ScrollCursorCenter",
+      "z l": "vim::ScrollLeftHalfWay",
       "z .": ["workspace::SendKeystrokes", "z z ^"],
       "z b": "editor::ScrollCursorBottom",
       "z a": "editor::ToggleFold",

assets/prompts/assistant_system_prompt.hbs

@@ -11,8 +11,8 @@ You should only perform actions that modify the user’s system if explicitly re
 
 Be concise and direct in your responses.
 
-The user has opened a project that contains the following top-level directories/files:
+The user has opened a project that contains the following root directories/files:
 
-{{#each worktree_root_names}}
-- {{this}}
+{{#each worktrees}}
+- {{root_name}} (absolute path: {{abs_path}})
 {{/each}}

assets/settings/default.json

@@ -336,14 +336,14 @@
     "active_line_width": 1,
     // Determines how indent guides are colored.
     // This setting can take the following three values:
-    ///
+    //
     // 1. "disabled"
     // 2. "fixed"
     // 3. "indent_aware"
     "coloring": "fixed",
     // Determines how indent guide backgrounds are colored.
     // This setting can take the following two values:
-    ///
+    //
     // 1. "disabled"
     // 2. "indent_aware"
     "background_coloring": "disabled"
@@ -402,8 +402,8 @@
     // Time to wait after scrolling the buffer, before requesting the hints,
     // set to 0 to disable debouncing.
     "scroll_debounce_ms": 50,
-    /// A set of modifiers which, when pressed, will toggle the visibility of inlay hints.
-    /// If the set if empty or not all the modifiers specified are pressed, inlay hints will not be toggled.
+    // A set of modifiers which, when pressed, will toggle the visibility of inlay hints.
+    // If the set if empty or not all the modifiers specified are pressed, inlay hints will not be toggled.
     "toggle_on_modifiers_press": {
       "control": false,
       "shift": false,
@@ -440,7 +440,7 @@
     "scrollbar": {
       // When to show the scrollbar in the project panel.
       // This setting can take five values:
-      ///
+      //
       // 1. null (default): Inherit editor settings
       // 2. Show the scrollbar if there's important information or
       //    follow the system's configured behavior (default):
@@ -455,7 +455,7 @@
     },
     // Which files containing diagnostic errors/warnings to mark in the project panel.
     // This setting can take the following three values:
-    ///
+    //
     // 1. Do not mark any files:
     //    "off"
     // 2. Only mark files with errors:
@@ -512,7 +512,7 @@
     "scrollbar": {
       // When to show the scrollbar in the project panel.
       // This setting can take five values:
-      ///
+      //
       // 1. null (default): Inherit editor settings
       // 2. Show the scrollbar if there's important information or
       //    follow the system's configured behavior (default):
@@ -547,7 +547,7 @@
   "git_panel": {
     // Whether to show the git panel button in the status bar.
     "button": true,
-    // Where to the git panel. Can be 'left' or 'right'.
+    // Where to show the git panel. Can be 'left' or 'right'.
     "dock": "left",
     // Default width of the git panel.
     "default_width": 360,
@@ -686,7 +686,7 @@
     // Which files containing diagnostic errors/warnings to mark in the tabs.
     // Diagnostics are only shown when file icons are also active.
     // This setting only works when can take the following three values:
-    ///
+    //
     // 1. Do not mark any files:
     //    "off"
     // 2. Only mark files with errors:
@@ -850,15 +850,7 @@
       //
       // The minimum column number to show the inline blame information at
       // "min_column": 0
-    },
-    // How git hunks are displayed visually in the editor.
-    // This setting can take two values:
-    //
-    // 1. Show unstaged hunks filled and staged hunks hollow:
-    //    "hunk_style": "staged_hollow"
-    // 2. Show unstaged hunks hollow and staged hunks filled:
-    //    "hunk_style": "unstaged_hollow"
-    "hunk_style": "staged_hollow"
+    }
   },
   // Configuration for how direnv configuration should be loaded. May take 2 values:
   // 1. Load direnv configuration using `direnv export json` directly.
@@ -1022,7 +1014,7 @@
     "scrollbar": {
       // When to show the scrollbar in the terminal.
       // This setting can take five values:
-      ///
+      //
       // 1. null (default): Inherit editor settings
       // 2. Show the scrollbar if there's important information or
       //    follow the system's configured behavior (default):
@@ -1093,6 +1085,32 @@
   "auto_install_extensions": {
     "html": true
   },
+  // Controls how completions are processed for this language.
+  "completions": {
+    // Controls how words are completed.
+    // For large documents, not all words may be fetched for completion.
+    //
+    // May take 3 values:
+    // 1. "enabled"
+    //   Always fetch document's words for completions along with LSP completions.
+    // 2. "fallback"
+    //   Only if LSP response errors or times out, use document's words to show completions.
+    // 3. "disabled"
+    //   Never fetch or complete document's words for completions.
+    //   (Word-based completions can still be queried via a separate action)
+    //
+    // Default: fallback
+    "words": "fallback",
+    // Whether to fetch LSP completions or not.
+    //
+    // Default: true
+    "lsp": true,
+    // When fetching LSP completions, determines how long to wait for a response of a particular server.
+    // When set to 0, waits indefinitely.
+    //
+    // Default: 0
+    "lsp_fetch_timeout_ms": 0
+  },
   // Different settings for specific languages.
   "languages": {
     "Astro": {

crates/anthropic/src/anthropic.rs

@@ -553,7 +553,7 @@ pub struct Metadata {
     pub user_id: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Default)]
 pub struct Usage {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub input_tokens: Option<u32>,

crates/assistant/src/inline_assistant.rs

@@ -1246,7 +1246,7 @@ impl InlineAssistant {
                     });
 
                     enum DeletedLines {}
-                    let mut editor = Editor::for_multibuffer(multi_buffer, None, true, window, cx);
+                    let mut editor = Editor::for_multibuffer(multi_buffer, None, window, cx);
                     editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx);
                     editor.set_show_wrap_guides(false, cx);
                     editor.set_show_gutter(false, cx);
@@ -1693,7 +1693,6 @@ impl PromptEditor {
                 },
                 prompt_buffer,
                 None,
-                false,
                 window,
                 cx,
             );

crates/assistant/src/terminal_inline_assistant.rs

@@ -720,7 +720,6 @@ impl PromptEditor {
                 },
                 prompt_buffer,
                 None,
-                false,
                 window,
                 cx,
             );

crates/assistant2/Cargo.toml

@@ -38,6 +38,7 @@ file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
+git.workspace = true
 gpui.workspace = true
 heed.workspace = true
 html_to_markdown.workspace = true
@@ -65,6 +66,7 @@ serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
 streaming_diff.workspace = true
+telemetry.workspace = true
 telemetry_events.workspace = true
 terminal.workspace = true
 terminal_view.workspace = true

crates/assistant2/src/active_thread.rs

@@ -1,26 +1,27 @@
-use std::sync::Arc;
-
+use crate::thread::{MessageId, RequestKind, Thread, ThreadError, ThreadEvent};
+use crate::thread_store::ThreadStore;
+use crate::tool_use::{ToolUse, ToolUseStatus};
+use crate::ui::ContextPill;
 use collections::HashMap;
 use editor::{Editor, MultiBuffer};
 use gpui::{
-    list, AbsoluteLength, AnyElement, App, ClickEvent, DefiniteLength, EdgesRefinement, Empty,
-    Entity, Focusable, Length, ListAlignment, ListOffset, ListState, StyleRefinement, Subscription,
-    Task, TextStyleRefinement, UnderlineStyle,
+    list, percentage, AbsoluteLength, Animation, AnimationExt, AnyElement, App, ClickEvent,
+    DefiniteLength, EdgesRefinement, Empty, Entity, Focusable, Length, ListAlignment, ListOffset,
+    ListState, StyleRefinement, Subscription, Task, TextStyleRefinement, Transformation,
+    UnderlineStyle,
 };
 use language::{Buffer, LanguageRegistry};
 use language_model::{LanguageModelRegistry, LanguageModelToolUseId, Role};
 use markdown::{Markdown, MarkdownStyle};
 use scripting_tool::{ScriptingTool, ScriptingToolInput};
 use settings::Settings as _;
+use std::sync::Arc;
+use std::time::Duration;
 use theme::ThemeSettings;
+use ui::Color;
 use ui::{prelude::*, Disclosure, KeyBinding};
 use util::ResultExt as _;
 
-use crate::thread::{MessageId, RequestKind, Thread, ThreadError, ThreadEvent};
-use crate::thread_store::ThreadStore;
-use crate::tool_use::{ToolUse, ToolUseStatus};
-use crate::ui::ContextPill;
-
 pub struct ActiveThread {
     language_registry: Arc<LanguageRegistry>,
     thread_store: Entity<ThreadStore>,
@@ -394,7 +395,6 @@ impl ActiveThread {
                 editor::EditorMode::AutoHeight { max_lines: 8 },
                 buffer,
                 None,
-                false,
                 window,
                 cx,
             );
@@ -497,7 +497,7 @@ impl ActiveThread {
         };
 
         let thread = self.thread.read(cx);
-
+        // Get all the data we need from thread before we start using it in closures
         let context = thread.context_for_message(message_id);
         let tool_uses = thread.tool_uses_for_message(message_id);
         let scripting_tool_uses = thread.scripting_tool_uses_for_message(message_id);
@@ -652,28 +652,27 @@ impl ActiveThread {
                         )
                         .child(message_content),
                 ),
-            Role::Assistant => v_flex()
-                .id(("message-container", ix))
-                .child(message_content)
-                .map(|parent| {
-                    if tool_uses.is_empty() && scripting_tool_uses.is_empty() {
-                        return parent;
-                    }
-
-                    parent.child(
-                        v_flex()
-                            .children(
-                                tool_uses
-                                    .into_iter()
-                                    .map(|tool_use| self.render_tool_use(tool_use, cx)),
+            Role::Assistant => {
+                v_flex()
+                    .id(("message-container", ix))
+                    .child(message_content)
+                    .when(
+                        !tool_uses.is_empty() || !scripting_tool_uses.is_empty(),
+                        |parent| {
+                            parent.child(
+                                v_flex()
+                                    .children(
+                                        tool_uses
+                                            .into_iter()
+                                            .map(|tool_use| self.render_tool_use(tool_use, cx)),
+                                    )
+                                    .children(scripting_tool_uses.into_iter().map(|tool_use| {
+                                        self.render_scripting_tool_use(tool_use, cx)
+                                    })),
                             )
-                            .children(
-                                scripting_tool_uses
-                                    .into_iter()
-                                    .map(|tool_use| self.render_scripting_tool_use(tool_use, cx)),
-                            ),
+                        },
                     )
-                }),
+            }
             Role::System => div().id(("message-container", ix)).py_1().px_2().child(
                 v_flex()
                     .bg(colors.editor_background)
@@ -692,27 +691,28 @@ impl ActiveThread {
             .copied()
             .unwrap_or_default();
 
+        let lighter_border = cx.theme().colors().border.opacity(0.5);
+
         div().px_2p5().child(
             v_flex()
-                .gap_1()
                 .rounded_lg()
                 .border_1()
-                .border_color(cx.theme().colors().border)
+                .border_color(lighter_border)
                 .child(
                     h_flex()
                         .justify_between()
-                        .py_0p5()
+                        .py_1()
                         .pl_1()
                         .pr_2()
-                        .bg(cx.theme().colors().editor_foreground.opacity(0.02))
+                        .bg(cx.theme().colors().editor_foreground.opacity(0.025))
                         .map(|element| {
                             if is_open {
-                                element.border_b_1().rounded_t(px(6.))
+                                element.border_b_1().rounded_t_md()
                             } else {
                                 element.rounded_md()
                             }
                         })
-                        .border_color(cx.theme().colors().border)
+                        .border_color(lighter_border)
                         .child(
                             h_flex()
                                 .gap_1()
@@ -729,57 +729,129 @@ impl ActiveThread {
                                         }
                                     }),
                                 ))
-                                .child(Label::new(tool_use.name)),
+                                .child(
+                                    Label::new(tool_use.name)
+                                        .size(LabelSize::Small)
+                                        .buffer_font(cx),
+                                ),
                         )
-                        .child(
-                            Label::new(match tool_use.status {
-                                ToolUseStatus::Pending => "Pending",
-                                ToolUseStatus::Running => "Running",
-                                ToolUseStatus::Finished(_) => "Finished",
-                                ToolUseStatus::Error(_) => "Error",
-                            })
-                            .size(LabelSize::XSmall)
-                            .buffer_font(cx),
-                        ),
+                        .child({
+                            let (icon_name, color, animated) = match &tool_use.status {
+                                ToolUseStatus::Pending => {
+                                    (IconName::Warning, Color::Warning, false)
+                                }
+                                ToolUseStatus::Running => {
+                                    (IconName::ArrowCircle, Color::Accent, true)
+                                }
+                                ToolUseStatus::Finished(_) => {
+                                    (IconName::Check, Color::Success, false)
+                                }
+                                ToolUseStatus::Error(_) => (IconName::Close, Color::Error, false),
+                            };
+
+                            let icon = Icon::new(icon_name).color(color).size(IconSize::Small);
+
+                            if animated {
+                                icon.with_animation(
+                                    "arrow-circle",
+                                    Animation::new(Duration::from_secs(2)).repeat(),
+                                    |icon, delta| {
+                                        icon.transform(Transformation::rotate(percentage(delta)))
+                                    },
+                                )
+                                .into_any_element()
+                            } else {
+                                icon.into_any_element()
+                            }
+                        }),
                 )
                 .map(|parent| {
                     if !is_open {
                         return parent;
                     }
 
+                    let content_container = || v_flex().py_1().gap_0p5().px_2p5();
+
                     parent.child(
                         v_flex()
+                            .gap_1()
+                            .bg(cx.theme().colors().editor_background)
+                            .rounded_b_lg()
                             .child(
-                                v_flex()
-                                    .gap_0p5()
-                                    .py_1()
-                                    .px_2p5()
+                                content_container()
                                     .border_b_1()
-                                    .border_color(cx.theme().colors().border)
-                                    .child(Label::new("Input:"))
-                                    .child(Label::new(
-                                        serde_json::to_string_pretty(&tool_use.input)
-                                            .unwrap_or_default(),
-                                    )),
+                                    .border_color(lighter_border)
+                                    .child(
+                                        Label::new("Input")
+                                            .size(LabelSize::XSmall)
+                                            .color(Color::Muted)
+                                            .buffer_font(cx),
+                                    )
+                                    .child(
+                                        Label::new(
+                                            serde_json::to_string_pretty(&tool_use.input)
+                                                .unwrap_or_default(),
+                                        )
+                                        .size(LabelSize::Small)
+                                        .buffer_font(cx),
+                                    ),
                             )
-                            .map(|parent| match tool_use.status {
-                                ToolUseStatus::Finished(output) => parent.child(
-                                    v_flex()
-                                        .gap_0p5()
-                                        .py_1()
-                                        .px_2p5()
-                                        .child(Label::new("Result:"))
-                                        .child(Label::new(output)),
+                            .map(|container| match tool_use.status {
+                                ToolUseStatus::Finished(output) => container.child(
+                                    content_container()
+                                        .child(
+                                            Label::new("Result")
+                                                .size(LabelSize::XSmall)
+                                                .color(Color::Muted)
+                                                .buffer_font(cx),
+                                        )
+                                        .child(
+                                            Label::new(output)
+                                                .size(LabelSize::Small)
+                                                .buffer_font(cx),
+                                        ),
                                 ),
-                                ToolUseStatus::Error(err) => parent.child(
-                                    v_flex()
-                                        .gap_0p5()
-                                        .py_1()
-                                        .px_2p5()
-                                        .child(Label::new("Error:"))
-                                        .child(Label::new(err)),
+                                ToolUseStatus::Running => container.child(
+                                    content_container().child(
+                                        h_flex()
+                                            .gap_1()
+                                            .pb_1()
+                                            .child(
+                                                Icon::new(IconName::ArrowCircle)
+                                                    .size(IconSize::Small)
+                                                    .color(Color::Accent)
+                                                    .with_animation(
+                                                        "arrow-circle",
+                                                        Animation::new(Duration::from_secs(2))
+                                                            .repeat(),
+                                                        |icon, delta| {
+                                                            icon.transform(Transformation::rotate(
+                                                                percentage(delta),
+                                                            ))
+                                                        },
+                                                    ),
+                                            )
+                                            .child(
+                                                Label::new("Running…")
+                                                    .size(LabelSize::XSmall)
+                                                    .color(Color::Muted)
+                                                    .buffer_font(cx),
+                                            ),
+                                    ),
                                 ),
-                                ToolUseStatus::Pending | ToolUseStatus::Running => parent,
+                                ToolUseStatus::Error(err) => container.child(
+                                    content_container()
+                                        .child(
+                                            Label::new("Error")
+                                                .size(LabelSize::XSmall)
+                                                .color(Color::Muted)
+                                                .buffer_font(cx),
+                                        )
+                                        .child(
+                                            Label::new(err).size(LabelSize::Small).buffer_font(cx),
+                                        ),
+                                ),
+                                ToolUseStatus::Pending => container,
                             }),
                     )
                 }),
@@ -812,7 +884,7 @@ impl ActiveThread {
                         .bg(cx.theme().colors().editor_foreground.opacity(0.02))
                         .map(|element| {
                             if is_open {
-                                element.border_b_1().rounded_t(px(6.))
+                                element.border_b_1().rounded_t_md()
                             } else {
                                 element.rounded_md()
                             }

crates/assistant2/src/assistant.rs

@@ -53,7 +53,8 @@ actions!(
         FocusLeft,
         FocusRight,
         RemoveFocusedContext,
-        AcceptSuggestedContext
+        AcceptSuggestedContext,
+        OpenActiveThreadAsMarkdown
     ]
 );
 

crates/assistant2/src/assistant_panel.rs

@@ -11,7 +11,7 @@ use assistant_slash_command::SlashCommandWorkingSet;
 use assistant_tool::ToolWorkingSet;
 
 use client::zed_urls;
-use editor::Editor;
+use editor::{Editor, MultiBuffer};
 use fs::Fs;
 use gpui::{
     prelude::*, Action, AnyElement, App, AsyncWindowContext, Corner, Entity, EventEmitter,
@@ -38,7 +38,10 @@ use crate::message_editor::MessageEditor;
 use crate::thread::{Thread, ThreadError, ThreadId};
 use crate::thread_history::{PastContext, PastThread, ThreadHistory};
 use crate::thread_store::ThreadStore;
-use crate::{InlineAssistant, NewPromptEditor, NewThread, OpenConfiguration, OpenHistory};
+use crate::{
+    InlineAssistant, NewPromptEditor, NewThread, OpenActiveThreadAsMarkdown, OpenConfiguration,
+    OpenHistory,
+};
 
 pub fn init(cx: &mut App) {
     cx.observe_new(
@@ -411,6 +414,65 @@ impl AssistantPanel {
         }
     }
 
+    pub(crate) fn open_active_thread_as_markdown(
+        &mut self,
+        _: &OpenActiveThreadAsMarkdown,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(workspace) = self
+            .workspace
+            .upgrade()
+            .ok_or_else(|| anyhow!("workspace dropped"))
+            .log_err()
+        else {
+            return;
+        };
+
+        let markdown_language_task = workspace
+            .read(cx)
+            .app_state()
+            .languages
+            .language_for_name("Markdown");
+        let thread = self.active_thread(cx);
+        cx.spawn_in(window, |_this, mut cx| async move {
+            let markdown_language = markdown_language_task.await?;
+
+            workspace.update_in(&mut cx, |workspace, window, cx| {
+                let thread = thread.read(cx);
+                let markdown = thread.to_markdown()?;
+                let thread_summary = thread
+                    .summary()
+                    .map(|summary| summary.to_string())
+                    .unwrap_or_else(|| "Thread".to_string());
+
+                let project = workspace.project().clone();
+                let buffer = project.update(cx, |project, cx| {
+                    project.create_local_buffer(&markdown, Some(markdown_language), cx)
+                });
+                let buffer = cx.new(|cx| {
+                    MultiBuffer::singleton(buffer, cx).with_title(thread_summary.clone())
+                });
+
+                workspace.add_item_to_active_pane(
+                    Box::new(cx.new(|cx| {
+                        let mut editor =
+                            Editor::for_multibuffer(buffer, Some(project.clone()), window, cx);
+                        editor.set_breadcrumb_header(thread_summary);
+                        editor
+                    })),
+                    None,
+                    true,
+                    window,
+                    cx,
+                );
+
+                anyhow::Ok(())
+            })
+        })
+        .detach_and_log_err(cx);
+    }
+
     fn handle_assistant_configuration_event(
         &mut self,
         _entity: &Entity<AssistantConfiguration>,
@@ -1011,6 +1073,7 @@ impl Render for AssistantPanel {
             .on_action(cx.listener(|this, _: &OpenHistory, window, cx| {
                 this.open_history(window, cx);
             }))
+            .on_action(cx.listener(Self::open_active_thread_as_markdown))
             .on_action(cx.listener(Self::deploy_prompt_library))
             .child(self.render_toolbar(cx))
             .map(|parent| match self.active_view {

crates/assistant2/src/context_picker/thread_context_picker.rs

@@ -223,13 +223,18 @@ pub fn render_thread_context_entry(
     h_flex()
         .gap_1p5()
         .w_full()
+        .justify_between()
         .child(
-            Icon::new(IconName::MessageCircle)
-                .size(IconSize::XSmall)
-                .color(Color::Muted),
+            h_flex()
+                .gap_1p5()
+                .max_w_72()
+                .child(
+                    Icon::new(IconName::MessageCircle)
+                        .size(IconSize::XSmall)
+                        .color(Color::Muted),
+                )
+                .child(Label::new(thread.summary.clone()).truncate()),
         )
-        .child(Label::new(thread.summary.clone()))
-        .child(div().w_full())
         .when(added, |el| {
             el.child(
                 h_flex()

crates/assistant2/src/history_store.rs

@@ -2,10 +2,10 @@ use assistant_context_editor::SavedContextMetadata;
 use chrono::{DateTime, Utc};
 use gpui::{prelude::*, Entity};
 
-use crate::thread_store::{SavedThreadMetadata, ThreadStore};
+use crate::thread_store::{SerializedThreadMetadata, ThreadStore};
 
 pub enum HistoryEntry {
-    Thread(SavedThreadMetadata),
+    Thread(SerializedThreadMetadata),
     Context(SavedContextMetadata),
 }
 

crates/assistant2/src/inline_assistant.rs

@@ -1341,7 +1341,7 @@ impl InlineAssistant {
                     });
 
                     enum DeletedLines {}
-                    let mut editor = Editor::for_multibuffer(multi_buffer, None, true, window, cx);
+                    let mut editor = Editor::for_multibuffer(multi_buffer, None, window, cx);
                     editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx);
                     editor.set_show_wrap_guides(false, cx);
                     editor.set_show_gutter(false, cx);

crates/assistant2/src/inline_prompt_editor.rs

@@ -843,7 +843,6 @@ impl PromptEditor<BufferCodegen> {
                 },
                 prompt_buffer,
                 None,
-                false,
                 window,
                 cx,
             );
@@ -1001,7 +1000,6 @@ impl PromptEditor<TerminalCodegen> {
                 },
                 prompt_buffer,
                 None,
-                false,
                 window,
                 cx,
             );

crates/assistant2/src/message_editor.rs

@@ -20,7 +20,8 @@ use ui::{
     Tooltip,
 };
 use vim_mode_setting::VimModeSetting;
-use workspace::Workspace;
+use workspace::notifications::{NotificationId, NotifyTaskExt};
+use workspace::{Toast, Workspace};
 
 use crate::assistant_model_selector::AssistantModelSelector;
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
@@ -34,6 +35,7 @@ use crate::{Chat, ChatMode, RemoveAllContext, ToggleContextPicker};
 pub struct MessageEditor {
     thread: Entity<Thread>,
     editor: Entity<Editor>,
+    workspace: WeakEntity<Workspace>,
     context_store: Entity<ContextStore>,
     context_strip: Entity<ContextStrip>,
     context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
@@ -106,6 +108,7 @@ impl MessageEditor {
         Self {
             thread,
             editor: editor.clone(),
+            workspace,
             context_store,
             context_strip,
             context_picker_menu_handle,
@@ -150,6 +153,14 @@ impl MessageEditor {
     }
 
     fn chat(&mut self, _: &Chat, window: &mut Window, cx: &mut Context<Self>) {
+        if self.is_editor_empty(cx) {
+            return;
+        }
+
+        if self.thread.read(cx).is_streaming() {
+            return;
+        }
+
         self.send_to_model(RequestKind::Chat, window, cx);
     }
 
@@ -272,6 +283,34 @@ impl MessageEditor {
             self.context_strip.focus_handle(cx).focus(window);
         }
     }
+
+    fn handle_feedback_click(
+        &mut self,
+        is_positive: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        let workspace = self.workspace.clone();
+        let report = self
+            .thread
+            .update(cx, |thread, cx| thread.report_feedback(is_positive, cx));
+
+        cx.spawn(|_, mut cx| async move {
+            report.await?;
+            workspace.update(&mut cx, |workspace, cx| {
+                let message = if is_positive {
+                    "Positive feedback recorded. Thank you!"
+                } else {
+                    "Negative feedback recorded. Thank you for helping us improve!"
+                };
+
+                struct ThreadFeedback;
+                let id = NotificationId::unique::<ThreadFeedback>();
+                workspace.show_toast(Toast::new(id, message).autohide(), cx)
+            })
+        })
+        .detach_and_notify_err(window, cx);
+    }
 }
 
 impl Focusable for MessageEditor {
@@ -489,7 +528,45 @@ impl Render for MessageEditor {
                     .bg(bg_color)
                     .border_t_1()
                     .border_color(cx.theme().colors().border)
-                    .child(self.context_strip.clone())
+                    .child(
+                        h_flex()
+                            .justify_between()
+                            .child(self.context_strip.clone())
+                            .when(!self.thread.read(cx).is_empty(), |this| {
+                                this.child(
+                                    h_flex()
+                                        .gap_2()
+                                        .child(
+                                            IconButton::new(
+                                                "feedback-thumbs-up",
+                                                IconName::ThumbsUp,
+                                            )
+                                            .style(ButtonStyle::Subtle)
+                                            .icon_size(IconSize::Small)
+                                            .tooltip(Tooltip::text("Helpful"))
+                                            .on_click(
+                                                cx.listener(|this, _, window, cx| {
+                                                    this.handle_feedback_click(true, window, cx);
+                                                }),
+                                            ),
+                                        )
+                                        .child(
+                                            IconButton::new(
+                                                "feedback-thumbs-down",
+                                                IconName::ThumbsDown,
+                                            )
+                                            .style(ButtonStyle::Subtle)
+                                            .icon_size(IconSize::Small)
+                                            .tooltip(Tooltip::text("Not Helpful"))
+                                            .on_click(
+                                                cx.listener(|this, _, window, cx| {
+                                                    this.handle_feedback_click(false, window, cx);
+                                                }),
+                                            ),
+                                        ),
+                                )
+                            }),
+                    )
                     .child(
                         v_flex()
                             .gap_5()

crates/assistant2/src/thread.rs

@@ -1,26 +1,31 @@
+use std::io::Write;
 use std::sync::Arc;
 
 use anyhow::{Context as _, Result};
 use assistant_tool::ToolWorkingSet;
 use chrono::{DateTime, Utc};
 use collections::{BTreeMap, HashMap, HashSet};
-use futures::StreamExt as _;
+use futures::future::Shared;
+use futures::{FutureExt, StreamExt as _};
+use git;
 use gpui::{App, AppContext, Context, Entity, EventEmitter, SharedString, Task};
 use language_model::{
     LanguageModel, LanguageModelCompletionEvent, LanguageModelRegistry, LanguageModelRequest,
     LanguageModelRequestMessage, LanguageModelRequestTool, LanguageModelToolResult,
     LanguageModelToolUseId, MaxMonthlySpendReachedError, MessageContent, PaymentRequiredError,
-    Role, StopReason,
+    Role, StopReason, TokenUsage,
 };
 use project::Project;
-use prompt_store::PromptBuilder;
+use prompt_store::{AssistantSystemPromptWorktree, PromptBuilder};
 use scripting_tool::{ScriptingSession, ScriptingTool};
 use serde::{Deserialize, Serialize};
 use util::{post_inc, ResultExt, TryFutureExt as _};
 use uuid::Uuid;
 
 use crate::context::{attach_context_to_message, ContextId, ContextSnapshot};
-use crate::thread_store::SavedThread;
+use crate::thread_store::{
+    SerializedMessage, SerializedThread, SerializedToolResult, SerializedToolUse,
+};
 use crate::tool_use::{PendingToolUse, ToolUse, ToolUseState};
 
 #[derive(Debug, Clone, Copy)]
@@ -62,6 +67,27 @@ pub struct Message {
     pub text: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProjectSnapshot {
+    pub worktree_snapshots: Vec<WorktreeSnapshot>,
+    pub unsaved_buffer_paths: Vec<String>,
+    pub timestamp: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WorktreeSnapshot {
+    pub worktree_path: String,
+    pub git_state: Option<GitState>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GitState {
+    pub remote_url: Option<String>,
+    pub head_sha: Option<String>,
+    pub current_branch: Option<String>,
+    pub diff: Option<String>,
+}
+
 /// A thread of conversation with the LLM.
 pub struct Thread {
     id: ThreadId,
@@ -80,6 +106,8 @@ pub struct Thread {
     tool_use: ToolUseState,
     scripting_session: Entity<ScriptingSession>,
     scripting_tool_use: ToolUseState,
+    initial_project_snapshot: Shared<Task<Option<Arc<ProjectSnapshot>>>>,
+    cumulative_token_usage: TokenUsage,
 }
 
 impl Thread {
@@ -89,8 +117,6 @@ impl Thread {
         prompt_builder: Arc<PromptBuilder>,
         cx: &mut Context<Self>,
     ) -> Self {
-        let scripting_session = cx.new(|cx| ScriptingSession::new(project.clone(), cx));
-
         Self {
             id: ThreadId::new(),
             updated_at: Utc::now(),
@@ -102,42 +128,52 @@ impl Thread {
             context_by_message: HashMap::default(),
             completion_count: 0,
             pending_completions: Vec::new(),
-            project,
+            project: project.clone(),
             prompt_builder,
             tools,
             tool_use: ToolUseState::new(),
-            scripting_session,
+            scripting_session: cx.new(|cx| ScriptingSession::new(project.clone(), cx)),
             scripting_tool_use: ToolUseState::new(),
+            initial_project_snapshot: {
+                let project_snapshot = Self::project_snapshot(project, cx);
+                cx.foreground_executor()
+                    .spawn(async move { Some(project_snapshot.await) })
+                    .shared()
+            },
+            cumulative_token_usage: TokenUsage::default(),
         }
     }
 
-    pub fn from_saved(
+    pub fn deserialize(
         id: ThreadId,
-        saved: SavedThread,
+        serialized: SerializedThread,
         project: Entity<Project>,
         tools: Arc<ToolWorkingSet>,
         prompt_builder: Arc<PromptBuilder>,
         cx: &mut Context<Self>,
     ) -> Self {
         let next_message_id = MessageId(
-            saved
+            serialized
                 .messages
                 .last()
                 .map(|message| message.id.0 + 1)
                 .unwrap_or(0),
         );
-        let tool_use =
-            ToolUseState::from_saved_messages(&saved.messages, |name| name != ScriptingTool::NAME);
+        let tool_use = ToolUseState::from_serialized_messages(&serialized.messages, |name| {
+            name != ScriptingTool::NAME
+        });
         let scripting_tool_use =
-            ToolUseState::from_saved_messages(&saved.messages, |name| name == ScriptingTool::NAME);
+            ToolUseState::from_serialized_messages(&serialized.messages, |name| {
+                name == ScriptingTool::NAME
+            });
         let scripting_session = cx.new(|cx| ScriptingSession::new(project.clone(), cx));
 
         Self {
             id,
-            updated_at: saved.updated_at,
-            summary: Some(saved.summary),
+            updated_at: serialized.updated_at,
+            summary: Some(serialized.summary),
             pending_summary: Task::ready(None),
-            messages: saved
+            messages: serialized
                 .messages
                 .into_iter()
                 .map(|message| Message {
@@ -157,6 +193,9 @@ impl Thread {
             tool_use,
             scripting_session,
             scripting_tool_use,
+            initial_project_snapshot: Task::ready(serialized.initial_project_snapshot).shared(),
+            // TODO: persist token usage?
+            cumulative_token_usage: TokenUsage::default(),
         }
     }
 
@@ -199,7 +238,7 @@ impl Thread {
     }
 
     pub fn is_streaming(&self) -> bool {
-        !self.pending_completions.is_empty()
+        !self.pending_completions.is_empty() || !self.all_tools_finished()
     }
 
     pub fn tools(&self) -> &Arc<ToolWorkingSet> {
@@ -344,6 +383,47 @@ impl Thread {
         text
     }
 
+    /// Serializes this thread into a format for storage or telemetry.
+    pub fn serialize(&self, cx: &mut Context<Self>) -> Task<Result<SerializedThread>> {
+        let initial_project_snapshot = self.initial_project_snapshot.clone();
+        cx.spawn(|this, cx| async move {
+            let initial_project_snapshot = initial_project_snapshot.await;
+            this.read_with(&cx, |this, _| SerializedThread {
+                summary: this.summary_or_default(),
+                updated_at: this.updated_at(),
+                messages: this
+                    .messages()
+                    .map(|message| SerializedMessage {
+                        id: message.id,
+                        role: message.role,
+                        text: message.text.clone(),
+                        tool_uses: this
+                            .tool_uses_for_message(message.id)
+                            .into_iter()
+                            .chain(this.scripting_tool_uses_for_message(message.id))
+                            .map(|tool_use| SerializedToolUse {
+                                id: tool_use.id,
+                                name: tool_use.name,
+                                input: tool_use.input,
+                            })
+                            .collect(),
+                        tool_results: this
+                            .tool_results_for_message(message.id)
+                            .into_iter()
+                            .chain(this.scripting_tool_results_for_message(message.id))
+                            .map(|tool_result| SerializedToolResult {
+                                tool_use_id: tool_result.tool_use_id.clone(),
+                                is_error: tool_result.is_error,
+                                content: tool_result.content.clone(),
+                            })
+                            .collect(),
+                    })
+                    .collect(),
+                initial_project_snapshot,
+            })
+        })
+    }
+
     pub fn send_to_model(
         &mut self,
         model: Arc<dyn LanguageModel>,
@@ -384,8 +464,14 @@ impl Thread {
         let worktree_root_names = self
             .project
             .read(cx)
-            .worktree_root_names(cx)
-            .map(ToString::to_string)
+            .visible_worktrees(cx)
+            .map(|worktree| {
+                let worktree = worktree.read(cx);
+                AssistantSystemPromptWorktree {
+                    root_name: worktree.root_name().into(),
+                    abs_path: worktree.abs_path(),
+                }
+            })
             .collect::<Vec<_>>();
         let system_prompt = self
             .prompt_builder
@@ -483,6 +569,7 @@ impl Thread {
             let stream_completion = async {
                 let mut events = stream.await?;
                 let mut stop_reason = StopReason::EndTurn;
+                let mut current_token_usage = TokenUsage::default();
 
                 while let Some(event) = events.next().await {
                     let event = event?;
@@ -495,6 +582,12 @@ impl Thread {
                             LanguageModelCompletionEvent::Stop(reason) => {
                                 stop_reason = reason;
                             }
+                            LanguageModelCompletionEvent::UsageUpdate(token_usage) => {
+                                thread.cumulative_token_usage =
+                                    thread.cumulative_token_usage.clone() + token_usage.clone()
+                                        - current_token_usage.clone();
+                                current_token_usage = token_usage;
+                            }
                             LanguageModelCompletionEvent::Text(chunk) => {
                                 if let Some(last_message) = thread.messages.last_mut() {
                                     if last_message.role == Role::Assistant {
@@ -788,6 +881,185 @@ impl Thread {
             false
         }
     }
+
+    /// Reports feedback about the thread and stores it in our telemetry backend.
+    pub fn report_feedback(&self, is_positive: bool, cx: &mut Context<Self>) -> Task<Result<()>> {
+        let final_project_snapshot = Self::project_snapshot(self.project.clone(), cx);
+        let serialized_thread = self.serialize(cx);
+        let thread_id = self.id().clone();
+        let client = self.project.read(cx).client();
+
+        cx.background_spawn(async move {
+            let final_project_snapshot = final_project_snapshot.await;
+            let serialized_thread = serialized_thread.await?;
+            let thread_data =
+                serde_json::to_value(serialized_thread).unwrap_or_else(|_| serde_json::Value::Null);
+
+            let rating = if is_positive { "positive" } else { "negative" };
+            telemetry::event!(
+                "Assistant Thread Rated",
+                rating,
+                thread_id,
+                thread_data,
+                final_project_snapshot
+            );
+            client.telemetry().flush_events();
+
+            Ok(())
+        })
+    }
+
+    /// Create a snapshot of the current project state including git information and unsaved buffers.
+    fn project_snapshot(
+        project: Entity<Project>,
+        cx: &mut Context<Self>,
+    ) -> Task<Arc<ProjectSnapshot>> {
+        let worktree_snapshots: Vec<_> = project
+            .read(cx)
+            .visible_worktrees(cx)
+            .map(|worktree| Self::worktree_snapshot(worktree, cx))
+            .collect();
+
+        cx.spawn(move |_, cx| async move {
+            let worktree_snapshots = futures::future::join_all(worktree_snapshots).await;
+
+            let mut unsaved_buffers = Vec::new();
+            cx.update(|app_cx| {
+                let buffer_store = project.read(app_cx).buffer_store();
+                for buffer_handle in buffer_store.read(app_cx).buffers() {
+                    let buffer = buffer_handle.read(app_cx);
+                    if buffer.is_dirty() {
+                        if let Some(file) = buffer.file() {
+                            let path = file.path().to_string_lossy().to_string();
+                            unsaved_buffers.push(path);
+                        }
+                    }
+                }
+            })
+            .ok();
+
+            Arc::new(ProjectSnapshot {
+                worktree_snapshots,
+                unsaved_buffer_paths: unsaved_buffers,
+                timestamp: Utc::now(),
+            })
+        })
+    }
+
+    fn worktree_snapshot(worktree: Entity<project::Worktree>, cx: &App) -> Task<WorktreeSnapshot> {
+        cx.spawn(move |cx| async move {
+            // Get worktree path and snapshot
+            let worktree_info = cx.update(|app_cx| {
+                let worktree = worktree.read(app_cx);
+                let path = worktree.abs_path().to_string_lossy().to_string();
+                let snapshot = worktree.snapshot();
+                (path, snapshot)
+            });
+
+            let Ok((worktree_path, snapshot)) = worktree_info else {
+                return WorktreeSnapshot {
+                    worktree_path: String::new(),
+                    git_state: None,
+                };
+            };
+
+            // Extract git information
+            let git_state = match snapshot.repositories().first() {
+                None => None,
+                Some(repo_entry) => {
+                    // Get branch information
+                    let current_branch = repo_entry.branch().map(|branch| branch.name.to_string());
+
+                    // Get repository info
+                    let repo_result = worktree.read_with(&cx, |worktree, _cx| {
+                        if let project::Worktree::Local(local_worktree) = &worktree {
+                            local_worktree.get_local_repo(repo_entry).map(|local_repo| {
+                                let repo = local_repo.repo();
+                                (repo.remote_url("origin"), repo.head_sha(), repo.clone())
+                            })
+                        } else {
+                            None
+                        }
+                    });
+
+                    match repo_result {
+                        Ok(Some((remote_url, head_sha, repository))) => {
+                            // Get diff asynchronously
+                            let diff = repository
+                                .diff(git::repository::DiffType::HeadToWorktree, cx)
+                                .await
+                                .ok();
+
+                            Some(GitState {
+                                remote_url,
+                                head_sha,
+                                current_branch,
+                                diff,
+                            })
+                        }
+                        Err(_) | Ok(None) => None,
+                    }
+                }
+            };
+
+            WorktreeSnapshot {
+                worktree_path,
+                git_state,
+            }
+        })
+    }
+
+    pub fn to_markdown(&self) -> Result<String> {
+        let mut markdown = Vec::new();
+
+        if let Some(summary) = self.summary() {
+            writeln!(markdown, "# {summary}\n")?;
+        };
+
+        for message in self.messages() {
+            writeln!(
+                markdown,
+                "## {role}\n",
+                role = match message.role {
+                    Role::User => "User",
+                    Role::Assistant => "Assistant",
+                    Role::System => "System",
+                }
+            )?;
+            writeln!(markdown, "{}\n", message.text)?;
+
+            for tool_use in self.tool_uses_for_message(message.id) {
+                writeln!(
+                    markdown,
+                    "**Use Tool: {} ({})**",
+                    tool_use.name, tool_use.id
+                )?;
+                writeln!(markdown, "```json")?;
+                writeln!(
+                    markdown,
+                    "{}",
+                    serde_json::to_string_pretty(&tool_use.input)?
+                )?;
+                writeln!(markdown, "```")?;
+            }
+
+            for tool_result in self.tool_results_for_message(message.id) {
+                write!(markdown, "**Tool Results: {}", tool_result.tool_use_id)?;
+                if tool_result.is_error {
+                    write!(markdown, " (Error)")?;
+                }
+
+                writeln!(markdown, "**\n")?;
+                writeln!(markdown, "{}", tool_result.content)?;
+            }
+        }
+
+        Ok(String::from_utf8_lossy(&markdown).to_string())
+    }
+
+    pub fn cumulative_token_usage(&self) -> TokenUsage {
+        self.cumulative_token_usage.clone()
+    }
 }
 
 #[derive(Debug, Clone)]

crates/assistant2/src/thread_history.rs

@@ -7,7 +7,7 @@ use time::{OffsetDateTime, UtcOffset};
 use ui::{prelude::*, IconButtonShape, ListItem, ListItemSpacing, Tooltip};
 
 use crate::history_store::{HistoryEntry, HistoryStore};
-use crate::thread_store::SavedThreadMetadata;
+use crate::thread_store::SerializedThreadMetadata;
 use crate::{AssistantPanel, RemoveSelectedThread};
 
 pub struct ThreadHistory {
@@ -221,14 +221,14 @@ impl Render for ThreadHistory {
 
 #[derive(IntoElement)]
 pub struct PastThread {
-    thread: SavedThreadMetadata,
+    thread: SerializedThreadMetadata,
     assistant_panel: WeakEntity<AssistantPanel>,
     selected: bool,
 }
 
 impl PastThread {
     pub fn new(
-        thread: SavedThreadMetadata,
+        thread: SerializedThreadMetadata,
         assistant_panel: WeakEntity<AssistantPanel>,
         selected: bool,
     ) -> Self {

crates/assistant2/src/thread_store.rs

@@ -20,7 +20,7 @@ use prompt_store::PromptBuilder;
 use serde::{Deserialize, Serialize};
 use util::ResultExt as _;
 
-use crate::thread::{MessageId, Thread, ThreadId};
+use crate::thread::{MessageId, ProjectSnapshot, Thread, ThreadId};
 
 pub fn init(cx: &mut App) {
     ThreadsDatabase::init(cx);
@@ -32,7 +32,7 @@ pub struct ThreadStore {
     prompt_builder: Arc<PromptBuilder>,
     context_server_manager: Entity<ContextServerManager>,
     context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
-    threads: Vec<SavedThreadMetadata>,
+    threads: Vec<SerializedThreadMetadata>,
 }
 
 impl ThreadStore {
@@ -70,13 +70,13 @@ impl ThreadStore {
         self.threads.len()
     }
 
-    pub fn threads(&self) -> Vec<SavedThreadMetadata> {
+    pub fn threads(&self) -> Vec<SerializedThreadMetadata> {
         let mut threads = self.threads.iter().cloned().collect::<Vec<_>>();
         threads.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.updated_at));
         threads
     }
 
-    pub fn recent_threads(&self, limit: usize) -> Vec<SavedThreadMetadata> {
+    pub fn recent_threads(&self, limit: usize) -> Vec<SerializedThreadMetadata> {
         self.threads().into_iter().take(limit).collect()
     }
 
@@ -107,7 +107,7 @@ impl ThreadStore {
 
             this.update(&mut cx, |this, cx| {
                 cx.new(|cx| {
-                    Thread::from_saved(
+                    Thread::deserialize(
                         id.clone(),
                         thread,
                         this.project.clone(),
@@ -121,53 +121,14 @@ impl ThreadStore {
     }
 
     pub fn save_thread(&self, thread: &Entity<Thread>, cx: &mut Context<Self>) -> Task<Result<()>> {
-        let (metadata, thread) = thread.update(cx, |thread, _cx| {
-            let id = thread.id().clone();
-            let thread = SavedThread {
-                summary: thread.summary_or_default(),
-                updated_at: thread.updated_at(),
-                messages: thread
-                    .messages()
-                    .map(|message| {
-                        let all_tool_uses = thread
-                            .tool_uses_for_message(message.id)
-                            .into_iter()
-                            .chain(thread.scripting_tool_uses_for_message(message.id))
-                            .map(|tool_use| SavedToolUse {
-                                id: tool_use.id,
-                                name: tool_use.name,
-                                input: tool_use.input,
-                            })
-                            .collect();
-                        let all_tool_results = thread
-                            .tool_results_for_message(message.id)
-                            .into_iter()
-                            .chain(thread.scripting_tool_results_for_message(message.id))
-                            .map(|tool_result| SavedToolResult {
-                                tool_use_id: tool_result.tool_use_id.clone(),
-                                is_error: tool_result.is_error,
-                                content: tool_result.content.clone(),
-                            })
-                            .collect();
-
-                        SavedMessage {
-                            id: message.id,
-                            role: message.role,
-                            text: message.text.clone(),
-                            tool_uses: all_tool_uses,
-                            tool_results: all_tool_results,
-                        }
-                    })
-                    .collect(),
-            };
-
-            (id, thread)
-        });
+        let (metadata, serialized_thread) =
+            thread.update(cx, |thread, cx| (thread.id().clone(), thread.serialize(cx)));
 
         let database_future = ThreadsDatabase::global_future(cx);
         cx.spawn(|this, mut cx| async move {
+            let serialized_thread = serialized_thread.await?;
             let database = database_future.await.map_err(|err| anyhow!(err))?;
-            database.save_thread(metadata, thread).await?;
+            database.save_thread(metadata, serialized_thread).await?;
 
             this.update(&mut cx, |this, cx| this.reload(cx))?.await
         })
@@ -270,39 +231,41 @@ impl ThreadStore {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct SavedThreadMetadata {
+pub struct SerializedThreadMetadata {
     pub id: ThreadId,
     pub summary: SharedString,
     pub updated_at: DateTime<Utc>,
 }
 
 #[derive(Serialize, Deserialize)]
-pub struct SavedThread {
+pub struct SerializedThread {
     pub summary: SharedString,
     pub updated_at: DateTime<Utc>,
-    pub messages: Vec<SavedMessage>,
+    pub messages: Vec<SerializedMessage>,
+    #[serde(default)]
+    pub initial_project_snapshot: Option<Arc<ProjectSnapshot>>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct SavedMessage {
+pub struct SerializedMessage {
     pub id: MessageId,
     pub role: Role,
     pub text: String,
     #[serde(default)]
-    pub tool_uses: Vec<SavedToolUse>,
+    pub tool_uses: Vec<SerializedToolUse>,
     #[serde(default)]
-    pub tool_results: Vec<SavedToolResult>,
+    pub tool_results: Vec<SerializedToolResult>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct SavedToolUse {
+pub struct SerializedToolUse {
     pub id: LanguageModelToolUseId,
     pub name: SharedString,
     pub input: serde_json::Value,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub struct SavedToolResult {
+pub struct SerializedToolResult {
     pub tool_use_id: LanguageModelToolUseId,
     pub is_error: bool,
     pub content: Arc<str>,
@@ -317,7 +280,7 @@ impl Global for GlobalThreadsDatabase {}
 pub(crate) struct ThreadsDatabase {
     executor: BackgroundExecutor,
     env: heed::Env,
-    threads: Database<SerdeBincode<ThreadId>, SerdeJson<SavedThread>>,
+    threads: Database<SerdeBincode<ThreadId>, SerdeJson<SerializedThread>>,
 }
 
 impl ThreadsDatabase {
@@ -364,7 +327,7 @@ impl ThreadsDatabase {
         })
     }
 
-    pub fn list_threads(&self) -> Task<Result<Vec<SavedThreadMetadata>>> {
+    pub fn list_threads(&self) -> Task<Result<Vec<SerializedThreadMetadata>>> {
         let env = self.env.clone();
         let threads = self.threads;
 
@@ -373,7 +336,7 @@ impl ThreadsDatabase {
             let mut iter = threads.iter(&txn)?;
             let mut threads = Vec::new();
             while let Some((key, value)) = iter.next().transpose()? {
-                threads.push(SavedThreadMetadata {
+                threads.push(SerializedThreadMetadata {
                     id: key,
                     summary: value.summary,
                     updated_at: value.updated_at,
@@ -384,7 +347,7 @@ impl ThreadsDatabase {
         })
     }
 
-    pub fn try_find_thread(&self, id: ThreadId) -> Task<Result<Option<SavedThread>>> {
+    pub fn try_find_thread(&self, id: ThreadId) -> Task<Result<Option<SerializedThread>>> {
         let env = self.env.clone();
         let threads = self.threads;
 
@@ -395,7 +358,7 @@ impl ThreadsDatabase {
         })
     }
 
-    pub fn save_thread(&self, id: ThreadId, thread: SavedThread) -> Task<Result<()>> {
+    pub fn save_thread(&self, id: ThreadId, thread: SerializedThread) -> Task<Result<()>> {
         let env = self.env.clone();
         let threads = self.threads;
 

crates/assistant2/src/tool_selector.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use gpui::Entity;
 use scripting_tool::ScriptingTool;
-use ui::{prelude::*, ContextMenu, IconButtonShape, PopoverMenu, Tooltip};
+use ui::{prelude::*, ContextMenu, PopoverMenu, Tooltip};
 
 pub struct ToolSelector {
     tools: Arc<ToolWorkingSet>,
@@ -20,25 +20,20 @@ impl ToolSelector {
         cx: &mut Context<Self>,
     ) -> Entity<ContextMenu> {
         ContextMenu::build(window, cx, |mut menu, _window, cx| {
+            let icon_position = IconPosition::End;
             let tools_by_source = self.tools.tools_by_source(cx);
 
             let all_tools_enabled = self.tools.are_all_tools_enabled();
-            menu = menu.header("Tools").toggleable_entry(
-                "All Tools",
-                all_tools_enabled,
-                IconPosition::End,
-                None,
-                {
-                    let tools = self.tools.clone();
-                    move |_window, cx| {
-                        if all_tools_enabled {
-                            tools.disable_all_tools(cx);
-                        } else {
-                            tools.enable_all_tools();
-                        }
+            menu = menu.toggleable_entry("All Tools", all_tools_enabled, icon_position, None, {
+                let tools = self.tools.clone();
+                move |_window, cx| {
+                    if all_tools_enabled {
+                        tools.disable_all_tools(cx);
+                    } else {
+                        tools.enable_all_tools();
                     }
-                },
-            );
+                }
+            });
 
             for (source, tools) in tools_by_source {
                 let mut tools = tools
@@ -61,31 +56,51 @@ impl ToolSelector {
                     tools.sort_by(|(_, name_a, _), (_, name_b, _)| name_a.cmp(name_b));
                 }
 
-                menu = match source {
-                    ToolSource::Native => menu.header("Zed"),
-                    ToolSource::ContextServer { id } => menu.separator().header(id),
+                menu = match &source {
+                    ToolSource::Native => menu.separator().header("Zed Tools"),
+                    ToolSource::ContextServer { id } => {
+                        let all_tools_from_source_enabled =
+                            self.tools.are_all_tools_from_source_enabled(&source);
+
+                        menu.separator().header(id).toggleable_entry(
+                            "All Tools",
+                            all_tools_from_source_enabled,
+                            icon_position,
+                            None,
+                            {
+                                let tools = self.tools.clone();
+                                let source = source.clone();
+                                move |_window, cx| {
+                                    if all_tools_from_source_enabled {
+                                        tools.disable_source(source.clone(), cx);
+                                    } else {
+                                        tools.enable_source(&source);
+                                    }
+                                }
+                            },
+                        )
+                    }
                 };
 
                 for (source, name, is_enabled) in tools {
-                    menu =
-                        menu.toggleable_entry(name.clone(), is_enabled, IconPosition::End, None, {
-                            let tools = self.tools.clone();
-                            move |_window, _cx| {
-                                if name.as_ref() == ScriptingTool::NAME {
-                                    if is_enabled {
-                                        tools.disable_scripting_tool();
-                                    } else {
-                                        tools.enable_scripting_tool();
-                                    }
+                    menu = menu.toggleable_entry(name.clone(), is_enabled, icon_position, None, {
+                        let tools = self.tools.clone();
+                        move |_window, _cx| {
+                            if name.as_ref() == ScriptingTool::NAME {
+                                if is_enabled {
+                                    tools.disable_scripting_tool();
                                 } else {
-                                    if is_enabled {
-                                        tools.disable(source.clone(), &[name.clone()]);
-                                    } else {
-                                        tools.enable(source.clone(), &[name.clone()]);
-                                    }
+                                    tools.enable_scripting_tool();
+                                }
+                            } else {
+                                if is_enabled {
+                                    tools.disable(source.clone(), &[name.clone()]);
+                                } else {
+                                    tools.enable(source.clone(), &[name.clone()]);
                                 }
                             }
-                        });
+                        }
+                    });
                 }
             }
 
@@ -103,7 +118,6 @@ impl Render for ToolSelector {
             })
             .trigger_with_tooltip(
                 IconButton::new("tool-selector-button", IconName::SettingsAlt)
-                    .shape(IconButtonShape::Square)
                     .icon_size(IconSize::Small)
                     .icon_color(Color::Muted),
                 Tooltip::text("Customize Tools"),

crates/assistant2/src/tool_use.rs

@@ -11,7 +11,7 @@ use language_model::{
 };
 
 use crate::thread::MessageId;
-use crate::thread_store::SavedMessage;
+use crate::thread_store::SerializedMessage;
 
 #[derive(Debug)]
 pub struct ToolUse {
@@ -46,11 +46,11 @@ impl ToolUseState {
         }
     }
 
-    /// Constructs a [`ToolUseState`] from the given list of [`SavedMessage`]s.
+    /// Constructs a [`ToolUseState`] from the given list of [`SerializedMessage`]s.
     ///
     /// Accepts a function to filter the tools that should be used to populate the state.
-    pub fn from_saved_messages(
-        messages: &[SavedMessage],
+    pub fn from_serialized_messages(
+        messages: &[SerializedMessage],
         mut filter_by_tool_name: impl FnMut(&str) -> bool,
     ) -> Self {
         let mut this = Self::new();

crates/assistant2/src/ui/context_pill.rs

@@ -126,7 +126,13 @@ impl RenderOnce for ContextPill {
                     h_flex()
                         .id("context-data")
                         .gap_1()
-                        .child(Label::new(context.name.clone()).size(LabelSize::Small))
+                        .child(
+                            div().max_w_64().child(
+                                Label::new(context.name.clone())
+                                    .size(LabelSize::Small)
+                                    .truncate(),
+                            ),
+                        )
                         .when_some(context.parent.as_ref(), |element, parent_name| {
                             if *dupe_name {
                                 element.child(
@@ -174,21 +180,22 @@ impl RenderOnce for ContextPill {
                 })
                 .hover(|style| style.bg(color.element_hover.opacity(0.5)))
                 .child(
-                    Label::new(name.clone())
-                        .size(LabelSize::Small)
-                        .color(Color::Muted),
+                    div().px_0p5().max_w_64().child(
+                        Label::new(name.clone())
+                            .size(LabelSize::Small)
+                            .color(Color::Muted)
+                            .truncate(),
+                    ),
                 )
                 .child(
-                    div().px_0p5().child(
-                        Label::new(match kind {
-                            ContextKind::File => "Active Tab",
-                            ContextKind::Thread
-                            | ContextKind::Directory
-                            | ContextKind::FetchedUrl => "Active",
-                        })
-                        .size(LabelSize::XSmall)
-                        .color(Color::Muted),
-                    ),
+                    Label::new(match kind {
+                        ContextKind::File => "Active Tab",
+                        ContextKind::Thread | ContextKind::Directory | ContextKind::FetchedUrl => {
+                            "Active"
+                        }
+                    })
+                    .size(LabelSize::XSmall)
+                    .color(Color::Muted),
                 )
                 .child(
                     Icon::new(IconName::Plus)

crates/assistant_context_editor/src/context.rs

@@ -2254,6 +2254,7 @@ impl AssistantContext {
                                         );
                                     }
                                     LanguageModelCompletionEvent::ToolUse(_) => {}
+                                    LanguageModelCompletionEvent::UsageUpdate(_) => {}
                                 }
                             });
 

crates/assistant_context_editor/src/slash_command.rs

@@ -48,7 +48,7 @@ impl SlashCommandCompletionProvider {
         name_range: Range<Anchor>,
         window: &mut Window,
         cx: &mut App,
-    ) -> Task<Result<Vec<project::Completion>>> {
+    ) -> Task<Result<Option<Vec<project::Completion>>>> {
         let slash_commands = self.slash_commands.clone();
         let candidates = slash_commands
             .command_names(cx)
@@ -71,65 +71,67 @@ impl SlashCommandCompletionProvider {
             .await;
 
             cx.update(|_, cx| {
-                matches
-                    .into_iter()
-                    .filter_map(|mat| {
-                        let command = slash_commands.command(&mat.string, cx)?;
-                        let mut new_text = mat.string.clone();
-                        let requires_argument = command.requires_argument();
-                        let accepts_arguments = command.accepts_arguments();
-                        if requires_argument || accepts_arguments {
-                            new_text.push(' ');
-                        }
+                Some(
+                    matches
+                        .into_iter()
+                        .filter_map(|mat| {
+                            let command = slash_commands.command(&mat.string, cx)?;
+                            let mut new_text = mat.string.clone();
+                            let requires_argument = command.requires_argument();
+                            let accepts_arguments = command.accepts_arguments();
+                            if requires_argument || accepts_arguments {
+                                new_text.push(' ');
+                            }
 
-                        let confirm =
-                            editor
-                                .clone()
-                                .zip(workspace.clone())
-                                .map(|(editor, workspace)| {
-                                    let command_name = mat.string.clone();
-                                    let command_range = command_range.clone();
-                                    let editor = editor.clone();
-                                    let workspace = workspace.clone();
-                                    Arc::new(
-                                    move |intent: CompletionIntent,
-                                          window: &mut Window,
-                                          cx: &mut App| {
-                                        if !requires_argument
-                                            && (!accepts_arguments || intent.is_complete())
-                                        {
-                                            editor
-                                                .update(cx, |editor, cx| {
-                                                    editor.run_command(
-                                                        command_range.clone(),
-                                                        &command_name,
-                                                        &[],
-                                                        true,
-                                                        workspace.clone(),
-                                                        window,
-                                                        cx,
-                                                    );
-                                                })
-                                                .ok();
-                                            false
-                                        } else {
-                                            requires_argument || accepts_arguments
-                                        }
-                                    },
-                                ) as Arc<_>
-                                });
-                        Some(project::Completion {
-                            old_range: name_range.clone(),
-                            documentation: Some(CompletionDocumentation::SingleLine(
-                                command.description().into(),
-                            )),
-                            new_text,
-                            label: command.label(cx),
-                            confirm,
-                            source: CompletionSource::Custom,
+                            let confirm =
+                                editor
+                                    .clone()
+                                    .zip(workspace.clone())
+                                    .map(|(editor, workspace)| {
+                                        let command_name = mat.string.clone();
+                                        let command_range = command_range.clone();
+                                        let editor = editor.clone();
+                                        let workspace = workspace.clone();
+                                        Arc::new(
+                                            move |intent: CompletionIntent,
+                                            window: &mut Window,
+                                            cx: &mut App| {
+                                                if !requires_argument
+                                                && (!accepts_arguments || intent.is_complete())
+                                                {
+                                                    editor
+                                                        .update(cx, |editor, cx| {
+                                                            editor.run_command(
+                                                                command_range.clone(),
+                                                                &command_name,
+                                                                &[],
+                                                                true,
+                                                                workspace.clone(),
+                                                                window,
+                                                                cx,
+                                                            );
+                                                        })
+                                                        .ok();
+                                                    false
+                                                } else {
+                                                    requires_argument || accepts_arguments
+                                                }
+                                            },
+                                        ) as Arc<_>
+                                    });
+                            Some(project::Completion {
+                                old_range: name_range.clone(),
+                                documentation: Some(CompletionDocumentation::SingleLine(
+                                    command.description().into(),
+                                )),
+                                new_text,
+                                label: command.label(cx),
+                                confirm,
+                                source: CompletionSource::Custom,
+                            })
                         })
-                    })
-                    .collect()
+                        .collect(),
+                )
             })
         })
     }
@@ -143,7 +145,7 @@ impl SlashCommandCompletionProvider {
         last_argument_range: Range<Anchor>,
         window: &mut Window,
         cx: &mut App,
-    ) -> Task<Result<Vec<project::Completion>>> {
+    ) -> Task<Result<Option<Vec<project::Completion>>>> {
         let new_cancel_flag = Arc::new(AtomicBool::new(false));
         let mut flag = self.cancel_flag.lock();
         flag.store(true, SeqCst);
@@ -161,27 +163,28 @@ impl SlashCommandCompletionProvider {
             let workspace = self.workspace.clone();
             let arguments = arguments.to_vec();
             cx.background_spawn(async move {
-                Ok(completions
-                    .await?
-                    .into_iter()
-                    .map(|new_argument| {
-                        let confirm =
-                            editor
-                                .clone()
-                                .zip(workspace.clone())
-                                .map(|(editor, workspace)| {
-                                    Arc::new({
-                                        let mut completed_arguments = arguments.clone();
-                                        if new_argument.replace_previous_arguments {
-                                            completed_arguments.clear();
-                                        } else {
-                                            completed_arguments.pop();
-                                        }
-                                        completed_arguments.push(new_argument.new_text.clone());
+                Ok(Some(
+                    completions
+                        .await?
+                        .into_iter()
+                        .map(|new_argument| {
+                            let confirm =
+                                editor
+                                    .clone()
+                                    .zip(workspace.clone())
+                                    .map(|(editor, workspace)| {
+                                        Arc::new({
+                                            let mut completed_arguments = arguments.clone();
+                                            if new_argument.replace_previous_arguments {
+                                                completed_arguments.clear();
+                                            } else {
+                                                completed_arguments.pop();
+                                            }
+                                            completed_arguments.push(new_argument.new_text.clone());
 
-                                        let command_range = command_range.clone();
-                                        let command_name = command_name.clone();
-                                        move |intent: CompletionIntent,
+                                            let command_range = command_range.clone();
+                                            let command_name = command_name.clone();
+                                            move |intent: CompletionIntent,
                                               window: &mut Window,
                                               cx: &mut App| {
                                             if new_argument.after_completion.run()
@@ -205,31 +208,32 @@ impl SlashCommandCompletionProvider {
                                                 !new_argument.after_completion.run()
                                             }
                                         }
-                                    }) as Arc<_>
-                                });
+                                        }) as Arc<_>
+                                    });
 
-                        let mut new_text = new_argument.new_text.clone();
-                        if new_argument.after_completion == AfterCompletion::Continue {
-                            new_text.push(' ');
-                        }
+                            let mut new_text = new_argument.new_text.clone();
+                            if new_argument.after_completion == AfterCompletion::Continue {
+                                new_text.push(' ');
+                            }
 
-                        project::Completion {
-                            old_range: if new_argument.replace_previous_arguments {
-                                argument_range.clone()
-                            } else {
-                                last_argument_range.clone()
-                            },
-                            label: new_argument.label,
-                            new_text,
-                            documentation: None,
-                            confirm,
-                            source: CompletionSource::Custom,
-                        }
-                    })
-                    .collect())
+                            project::Completion {
+                                old_range: if new_argument.replace_previous_arguments {
+                                    argument_range.clone()
+                                } else {
+                                    last_argument_range.clone()
+                                },
+                                label: new_argument.label,
+                                new_text,
+                                documentation: None,
+                                confirm,
+                                source: CompletionSource::Custom,
+                            }
+                        })
+                        .collect(),
+                ))
             })
         } else {
-            Task::ready(Ok(Vec::new()))
+            Task::ready(Ok(Some(Vec::new())))
         }
     }
 }
@@ -242,7 +246,7 @@ impl CompletionProvider for SlashCommandCompletionProvider {
         _: editor::CompletionContext,
         window: &mut Window,
         cx: &mut Context<Editor>,
-    ) -> Task<Result<Vec<project::Completion>>> {
+    ) -> Task<Result<Option<Vec<project::Completion>>>> {
         let Some((name, arguments, command_range, last_argument_range)) =
             buffer.update(cx, |buffer, _cx| {
                 let position = buffer_position.to_point(buffer);
@@ -286,7 +290,7 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                 Some((name, arguments, command_range, last_argument_range))
             })
         else {
-            return Task::ready(Ok(Vec::new()));
+            return Task::ready(Ok(Some(Vec::new())));
         };
 
         if let Some((arguments, argument_range)) = arguments {

crates/assistant_tool/src/tool_working_set.rs

@@ -46,56 +46,119 @@ impl ToolWorkingSet {
     }
 
     pub fn tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
-        let mut tools = ToolRegistry::global(cx).tools();
-        tools.extend(
-            self.state
-                .lock()
-                .context_server_tools_by_id
-                .values()
-                .cloned(),
-        );
+        self.state.lock().tools(cx)
+    }
 
-        tools
+    pub fn tools_by_source(&self, cx: &App) -> IndexMap<ToolSource, Vec<Arc<dyn Tool>>> {
+        self.state.lock().tools_by_source(cx)
     }
 
     pub fn are_all_tools_enabled(&self) -> bool {
         let state = self.state.lock();
-
         state.disabled_tools_by_source.is_empty() && !state.is_scripting_tool_disabled
     }
 
+    pub fn are_all_tools_from_source_enabled(&self, source: &ToolSource) -> bool {
+        let state = self.state.lock();
+        !state.disabled_tools_by_source.contains_key(source)
+    }
+
+    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
+        self.state.lock().enabled_tools(cx)
+    }
+
     pub fn enable_all_tools(&self) {
         let mut state = self.state.lock();
-
         state.disabled_tools_by_source.clear();
-        state.is_scripting_tool_disabled = false;
+        state.enable_scripting_tool();
     }
 
     pub fn disable_all_tools(&self, cx: &App) {
-        let tools = self.tools_by_source(cx);
-
-        for (source, tools) in tools {
-            let tool_names = tools
-                .into_iter()
-                .map(|tool| tool.name().into())
-                .collect::<Vec<_>>();
-
-            self.disable(source, &tool_names);
-        }
-
-        self.disable_scripting_tool();
+        let mut state = self.state.lock();
+        state.disable_all_tools(cx);
     }
 
-    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
-        let all_tools = self.tools(cx);
-
-        all_tools
-            .into_iter()
-            .filter(|tool| self.is_enabled(&tool.source(), &tool.name().into()))
-            .collect()
+    pub fn enable_source(&self, source: &ToolSource) {
+        let mut state = self.state.lock();
+        state.enable_source(source);
     }
 
-    pub fn tools_by_source(&self, cx: &App) -> IndexMap<ToolSource, Vec<Arc<dyn Tool>>> {
+    pub fn disable_source(&self, source: ToolSource, cx: &App) {
+        let mut state = self.state.lock();
+        state.disable_source(source, cx);
+    }
+
+    pub fn insert(&self, tool: Arc<dyn Tool>) -> ToolId {
+        let mut state = self.state.lock();
+        let tool_id = state.next_tool_id;
+        state.next_tool_id.0 += 1;
+        state
+            .context_server_tools_by_id
+            .insert(tool_id, tool.clone());
+        state.tools_changed();
+        tool_id
+    }
+
+    pub fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
+        self.state.lock().is_enabled(source, name)
+    }
+
+    pub fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
+        self.state.lock().is_disabled(source, name)
+    }
+
+    pub fn enable(&self, source: ToolSource, tools_to_enable: &[Arc<str>]) {
+        let mut state = self.state.lock();
+        state.enable(source, tools_to_enable);
+    }
+
+    pub fn disable(&self, source: ToolSource, tools_to_disable: &[Arc<str>]) {
+        let mut state = self.state.lock();
+        state.disable(source, tools_to_disable);
+    }
+
+    pub fn remove(&self, tool_ids_to_remove: &[ToolId]) {
+        let mut state = self.state.lock();
+        state
+            .context_server_tools_by_id
+            .retain(|id, _| !tool_ids_to_remove.contains(id));
+        state.tools_changed();
+    }
+
+    pub fn is_scripting_tool_enabled(&self) -> bool {
+        let state = self.state.lock();
+        !state.is_scripting_tool_disabled
+    }
+
+    pub fn enable_scripting_tool(&self) {
+        let mut state = self.state.lock();
+        state.enable_scripting_tool();
+    }
+
+    pub fn disable_scripting_tool(&self) {
+        let mut state = self.state.lock();
+        state.disable_scripting_tool();
+    }
+}
+
+impl WorkingSetState {
+    fn tools_changed(&mut self) {
+        self.context_server_tools_by_name.clear();
+        self.context_server_tools_by_name.extend(
+            self.context_server_tools_by_id
+                .values()
+                .map(|tool| (tool.name(), tool.clone())),
+        );
+    }
+
+    fn tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
+        let mut tools = ToolRegistry::global(cx).tools();
+        tools.extend(self.context_server_tools_by_id.values().cloned());
+
+        tools
+    }
+
+    fn tools_by_source(&self, cx: &App) -> IndexMap<ToolSource, Vec<Arc<dyn Tool>>> {
         let mut tools_by_source = IndexMap::default();
 
         for tool in self.tools(cx) {
@@ -114,78 +177,78 @@ impl ToolWorkingSet {
         tools_by_source
     }
 
-    pub fn insert(&self, tool: Arc<dyn Tool>) -> ToolId {
-        let mut state = self.state.lock();
-        let tool_id = state.next_tool_id;
-        state.next_tool_id.0 += 1;
-        state
-            .context_server_tools_by_id
-            .insert(tool_id, tool.clone());
-        state.tools_changed();
-        tool_id
+    fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
+        let all_tools = self.tools(cx);
+
+        all_tools
+            .into_iter()
+            .filter(|tool| self.is_enabled(&tool.source(), &tool.name().into()))
+            .collect()
     }
 
-    pub fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
+    fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
         !self.is_disabled(source, name)
     }
 
-    pub fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        let state = self.state.lock();
-        state
-            .disabled_tools_by_source
+    fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
+        self.disabled_tools_by_source
             .get(source)
             .map_or(false, |disabled_tools| disabled_tools.contains(name))
     }
 
-    pub fn enable(&self, source: ToolSource, tools_to_enable: &[Arc<str>]) {
-        let mut state = self.state.lock();
-        state
-            .disabled_tools_by_source
+    fn enable(&mut self, source: ToolSource, tools_to_enable: &[Arc<str>]) {
+        self.disabled_tools_by_source
             .entry(source)
             .or_default()
             .retain(|name| !tools_to_enable.contains(name));
     }
 
-    pub fn disable(&self, source: ToolSource, tools_to_disable: &[Arc<str>]) {
-        let mut state = self.state.lock();
-        state
-            .disabled_tools_by_source
+    fn disable(&mut self, source: ToolSource, tools_to_disable: &[Arc<str>]) {
+        self.disabled_tools_by_source
             .entry(source)
             .or_default()
             .extend(tools_to_disable.into_iter().cloned());
     }
 
-    pub fn remove(&self, tool_ids_to_remove: &[ToolId]) {
-        let mut state = self.state.lock();
-        state
-            .context_server_tools_by_id
-            .retain(|id, _| !tool_ids_to_remove.contains(id));
-        state.tools_changed();
+    fn enable_source(&mut self, source: &ToolSource) {
+        self.disabled_tools_by_source.remove(source);
     }
 
-    pub fn is_scripting_tool_enabled(&self) -> bool {
-        let state = self.state.lock();
-        !state.is_scripting_tool_disabled
-    }
+    fn disable_source(&mut self, source: ToolSource, cx: &App) {
+        let tools_by_source = self.tools_by_source(cx);
+        let Some(tools) = tools_by_source.get(&source) else {
+            return;
+        };
 
-    pub fn enable_scripting_tool(&self) {
-        let mut state = self.state.lock();
-        state.is_scripting_tool_disabled = false;
-    }
-
-    pub fn disable_scripting_tool(&self) {
-        let mut state = self.state.lock();
-        state.is_scripting_tool_disabled = true;
-    }
-}
-
-impl WorkingSetState {
-    fn tools_changed(&mut self) {
-        self.context_server_tools_by_name.clear();
-        self.context_server_tools_by_name.extend(
-            self.context_server_tools_by_id
-                .values()
-                .map(|tool| (tool.name(), tool.clone())),
+        self.disabled_tools_by_source.insert(
+            source,
+            tools
+                .into_iter()
+                .map(|tool| tool.name().into())
+                .collect::<HashSet<_>>(),
         );
     }
+
+    fn disable_all_tools(&mut self, cx: &App) {
+        let tools = self.tools_by_source(cx);
+
+        for (source, tools) in tools {
+            let tool_names = tools
+                .into_iter()
+                .map(|tool| tool.name().into())
+                .collect::<Vec<_>>();
+
+            self.disable(source, &tool_names);
+        }
+
+        self.disable_scripting_tool();
+    }
+
+    fn enable_scripting_tool(&mut self) {
+        self.is_scripting_tool_disabled = false;
+    }
+
+    fn disable_scripting_tool(&mut self) {
+        self.is_scripting_tool_disabled = true;
+    }
 }

crates/assistant_tools/Cargo.toml

@@ -16,15 +16,21 @@ anyhow.workspace = true
 assistant_tool.workspace = true
 chrono.workspace = true
 collections.workspace = true
+feature_flags.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 language_model.workspace = true
 project.workspace = true
+release_channel.workspace = true
 schemars.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+theme.workspace = true
+ui.workspace = true
 util.workspace = true
+workspace.workspace = true
+settings.workspace = true
 
 [dev-dependencies]
 rand.workspace = true

crates/assistant_tools/src/assistant_tools.rs

@@ -1,25 +1,38 @@
+mod bash_tool;
+mod delete_path_tool;
+mod diagnostics_tool;
 mod edit_files_tool;
 mod list_directory_tool;
 mod now_tool;
+mod path_search_tool;
 mod read_file_tool;
 mod regex_search;
 
 use assistant_tool::ToolRegistry;
 use gpui::App;
 
+use crate::bash_tool::BashTool;
+use crate::delete_path_tool::DeletePathTool;
+use crate::diagnostics_tool::DiagnosticsTool;
 use crate::edit_files_tool::EditFilesTool;
 use crate::list_directory_tool::ListDirectoryTool;
 use crate::now_tool::NowTool;
+use crate::path_search_tool::PathSearchTool;
 use crate::read_file_tool::ReadFileTool;
 use crate::regex_search::RegexSearchTool;
 
 pub fn init(cx: &mut App) {
     assistant_tool::init(cx);
+    crate::edit_files_tool::log::init(cx);
 
     let registry = ToolRegistry::global(cx);
-    registry.register_tool(NowTool);
-    registry.register_tool(ReadFileTool);
-    registry.register_tool(ListDirectoryTool);
+    registry.register_tool(BashTool);
+    registry.register_tool(DeletePathTool);
+    registry.register_tool(DiagnosticsTool);
     registry.register_tool(EditFilesTool);
+    registry.register_tool(ListDirectoryTool);
+    registry.register_tool(NowTool);
+    registry.register_tool(PathSearchTool);
+    registry.register_tool(ReadFileTool);
     registry.register_tool(RegexSearchTool);
 }

crates/assistant_tools/src/bash_tool.rs

@@ -0,0 +1,81 @@
+use anyhow::{anyhow, Context as _, Result};
+use assistant_tool::Tool;
+use gpui::{App, Entity, Task};
+use language_model::LanguageModelRequestMessage;
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use util::command::new_smol_command;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct BashToolInput {
+    /// The bash command to execute as a one-liner.
+    command: String,
+    /// Working directory for the command. This must be one of the root directories of the project.
+    cd: String,
+}
+
+pub struct BashTool;
+
+impl Tool for BashTool {
+    fn name(&self) -> String {
+        "bash".to_string()
+    }
+
+    fn description(&self) -> String {
+        include_str!("./bash_tool/description.md").to_string()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        let schema = schemars::schema_for!(BashToolInput);
+        serde_json::to_value(&schema).unwrap()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let input: BashToolInput = match serde_json::from_value(input) {
+            Ok(input) => input,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+
+        let Some(worktree) = project.read(cx).worktree_for_root_name(&input.cd, cx) else {
+            return Task::ready(Err(anyhow!("Working directory not found in the project")));
+        };
+        let working_directory = worktree.read(cx).abs_path();
+
+        cx.spawn(|_| async move {
+            // Add 2>&1 to merge stderr into stdout for proper interleaving.
+            let command = format!("({}) 2>&1", input.command);
+
+            let output = new_smol_command("bash")
+                .arg("-c")
+                .arg(&command)
+                .current_dir(working_directory)
+                .output()
+                .await
+                .context("Failed to execute bash command")?;
+
+            let output_string = String::from_utf8_lossy(&output.stdout).to_string();
+
+            if output.status.success() {
+                if output_string.is_empty() {
+                    Ok("Command executed successfully.".to_string())
+                } else {
+                    Ok(output_string)
+                }
+            } else {
+                Ok(format!(
+                    "Command failed with exit code {}\n{}",
+                    output.status.code().unwrap_or(-1),
+                    &output_string
+                ))
+            }
+        })
+    }
+}

crates/assistant_tools/src/bash_tool/description.md

@@ -0,0 +1,7 @@
+Executes a bash one-liner and returns the combined output.
+
+This tool spawns a bash process, combines stdout and stderr into one interleaved stream as they are produced (preserving the order of writes), and captures that stream into a string which is returned.
+
+Make sure you use the `cd` parameter to navigate to one of the root directories of the project. NEVER do it as part of the `command` itself, otherwise it will error.
+
+Remember that each invocation of this tool will spawn a new bash process, so you can't rely on any state from previous invocations.

crates/assistant_tools/src/delete_path_tool.rs

@@ -0,0 +1,165 @@
+use anyhow::{anyhow, Result};
+use assistant_tool::Tool;
+use gpui::{App, Entity, Task};
+use language_model::LanguageModelRequestMessage;
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{fs, path::PathBuf, sync::Arc};
+use util::paths::PathMatcher;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct DeletePathToolInput {
+    /// The glob to match files in the project to delete.
+    ///
+    /// <example>
+    /// If the project has the following files:
+    ///
+    /// - directory1/a/something.txt
+    /// - directory2/a/things.txt
+    /// - directory3/a/other.txt
+    ///
+    /// You can delete the first two files by providing a glob of "*thing*.txt"
+    /// </example>
+    pub glob: String,
+}
+
+pub struct DeletePathTool;
+
+impl Tool for DeletePathTool {
+    fn name(&self) -> String {
+        "delete-path".into()
+    }
+
+    fn description(&self) -> String {
+        include_str!("./delete_path_tool/description.md").into()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        let schema = schemars::schema_for!(DeletePathToolInput);
+        serde_json::to_value(&schema).unwrap()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let glob = match serde_json::from_value::<DeletePathToolInput>(input) {
+            Ok(input) => input.glob,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+        let path_matcher = match PathMatcher::new(&[glob.clone()]) {
+            Ok(matcher) => matcher,
+            Err(err) => return Task::ready(Err(anyhow!("Invalid glob: {}", err))),
+        };
+
+        struct Match {
+            display_path: String,
+            path: PathBuf,
+        }
+
+        let mut matches = Vec::new();
+        let mut deleted_paths = Vec::new();
+        let mut errors = Vec::new();
+
+        for worktree_handle in project.read(cx).worktrees(cx) {
+            let worktree = worktree_handle.read(cx);
+            let worktree_root = worktree.abs_path().to_path_buf();
+
+            // Don't consider ignored entries.
+            for entry in worktree.entries(false, 0) {
+                if path_matcher.is_match(&entry.path) {
+                    matches.push(Match {
+                        path: worktree_root.join(&entry.path),
+                        display_path: entry.path.display().to_string(),
+                    });
+                }
+            }
+        }
+
+        if matches.is_empty() {
+            return Task::ready(Ok(format!("No paths in the project matched {glob:?}")));
+        }
+
+        let paths_matched = matches.len();
+
+        // Delete the files
+        for Match { path, display_path } in matches {
+            match fs::remove_file(&path) {
+                Ok(()) => {
+                    deleted_paths.push(display_path);
+                }
+                Err(file_err) => {
+                    // Try to remove directory if it's not a file. Retrying as a directory
+                    // on error saves a syscall compared to checking whether it's
+                    // a directory up front for every single file.
+                    if let Err(dir_err) = fs::remove_dir_all(&path) {
+                        let error = if path.is_dir() {
+                            format!("Failed to delete directory {}: {dir_err}", display_path)
+                        } else {
+                            format!("Failed to delete file {}: {file_err}", display_path)
+                        };
+
+                        errors.push(error);
+                    } else {
+                        deleted_paths.push(display_path);
+                    }
+                }
+            }
+        }
+
+        if errors.is_empty() {
+            // 0 deleted paths should never happen if there were no errors;
+            // we already returned if matches was empty.
+            let answer = if deleted_paths.len() == 1 {
+                format!(
+                    "Deleted {}",
+                    deleted_paths.first().unwrap_or(&String::new())
+                )
+            } else {
+                // Sort to group entries in the same directory together
+                deleted_paths.sort();
+
+                let mut buf = format!("Deleted these {} paths:\n", deleted_paths.len());
+
+                for path in deleted_paths.iter() {
+                    buf.push('\n');
+                    buf.push_str(path);
+                }
+
+                buf
+            };
+
+            Task::ready(Ok(answer))
+        } else {
+            if deleted_paths.is_empty() {
+                Task::ready(Err(anyhow!(
+                    "{glob:?} matched {} deleted because of {}:\n{}",
+                    if paths_matched == 1 {
+                        "1 path, but it was not".to_string()
+                    } else {
+                        format!("{} paths, but none were", paths_matched)
+                    },
+                    if errors.len() == 1 {
+                        "this error".to_string()
+                    } else {
+                        format!("{} errors", errors.len())
+                    },
+                    errors.join("\n")
+                )))
+            } else {
+                // Sort to group entries in the same directory together
+                deleted_paths.sort();
+                Task::ready(Ok(format!(
+                    "Deleted {} paths matching glob {glob:?}:\n{}\n\nErrors:\n{}",
+                    deleted_paths.len(),
+                    deleted_paths.join("\n"),
+                    errors.join("\n")
+                )))
+            }
+        }
+    }
+}

crates/assistant_tools/src/delete_path_tool/description.md

@@ -0,0 +1 @@
+Deletes all files and directories in the project which match the given glob, and returns a list of the paths that were deleted.

crates/assistant_tools/src/diagnostics_tool.rs

@@ -0,0 +1,127 @@
+use anyhow::{anyhow, Result};
+use assistant_tool::Tool;
+use gpui::{App, Entity, Task};
+use language::{DiagnosticSeverity, OffsetRangeExt};
+use language_model::LanguageModelRequestMessage;
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{
+    fmt::Write,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct DiagnosticsToolInput {
+    /// The path to get diagnostics for. If not provided, returns a project-wide summary.
+    ///
+    /// This path should never be absolute, and the first component
+    /// of the path should always be a root directory in a project.
+    ///
+    /// <example>
+    /// If the project has the following root directories:
+    ///
+    /// - lorem
+    /// - ipsum
+    ///
+    /// If you wanna access diagnostics for `dolor.txt` in `ipsum`, you should use the path `ipsum/dolor.txt`.
+    /// </example>
+    pub path: Option<PathBuf>,
+}
+
+pub struct DiagnosticsTool;
+
+impl Tool for DiagnosticsTool {
+    fn name(&self) -> String {
+        "diagnostics".into()
+    }
+
+    fn description(&self) -> String {
+        include_str!("./diagnostics_tool/description.md").into()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        let schema = schemars::schema_for!(DiagnosticsToolInput);
+        serde_json::to_value(&schema).unwrap()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let input = match serde_json::from_value::<DiagnosticsToolInput>(input) {
+            Ok(input) => input,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+
+        if let Some(path) = input.path {
+            let Some(project_path) = project.read(cx).find_project_path(&path, cx) else {
+                return Task::ready(Err(anyhow!("Could not find path in project")));
+            };
+            let buffer = project.update(cx, |project, cx| project.open_buffer(project_path, cx));
+
+            cx.spawn(|cx| async move {
+                let mut output = String::new();
+                let buffer = buffer.await?;
+                let snapshot = buffer.read_with(&cx, |buffer, _cx| buffer.snapshot())?;
+
+                for (_, group) in snapshot.diagnostic_groups(None) {
+                    let entry = &group.entries[group.primary_ix];
+                    let range = entry.range.to_point(&snapshot);
+                    let severity = match entry.diagnostic.severity {
+                        DiagnosticSeverity::ERROR => "error",
+                        DiagnosticSeverity::WARNING => "warning",
+                        _ => continue,
+                    };
+
+                    writeln!(
+                        output,
+                        "{} at line {}: {}",
+                        severity,
+                        range.start.row + 1,
+                        entry.diagnostic.message
+                    )?;
+                }
+
+                if output.is_empty() {
+                    Ok("File doesn't have errors or warnings!".to_string())
+                } else {
+                    Ok(output)
+                }
+            })
+        } else {
+            let project = project.read(cx);
+            let mut output = String::new();
+            let mut has_diagnostics = false;
+
+            for (project_path, _, summary) in project.diagnostic_summaries(true, cx) {
+                if summary.error_count > 0 || summary.warning_count > 0 {
+                    let Some(worktree) = project.worktree_for_id(project_path.worktree_id, cx)
+                    else {
+                        continue;
+                    };
+
+                    has_diagnostics = true;
+                    output.push_str(&format!(
+                        "{}: {} error(s), {} warning(s)\n",
+                        Path::new(worktree.read(cx).root_name())
+                            .join(project_path.path)
+                            .display(),
+                        summary.error_count,
+                        summary.warning_count
+                    ));
+                }
+            }
+
+            if has_diagnostics {
+                Task::ready(Ok(output))
+            } else {
+                Task::ready(Ok("No errors or warnings found in the project.".to_string()))
+            }
+        }
+    }
+}

crates/assistant_tools/src/diagnostics_tool/description.md

@@ -0,0 +1,16 @@
+Get errors and warnings for the project or a specific file.
+
+This tool can be invoked after a series of edits to determine if further edits are necessary, or if the user asks to fix errors or warnings in their codebase.
+
+When a path is provided, shows all diagnostics for that specific file.
+When no path is provided, shows a summary of error and warning counts for all files in the project.
+
+<example>
+To get diagnostics for a specific file:
+{
+    "path": "src/main.rs"
+}
+
+To get a project-wide diagnostic summary:
+{}
+</example>

crates/assistant_tools/src/edit_files_tool.rs

@@ -1,32 +1,60 @@
 mod edit_action;
+pub mod log;
 
 use anyhow::{anyhow, Context, Result};
 use assistant_tool::Tool;
 use collections::HashSet;
 use edit_action::{EditAction, EditActionParser};
 use futures::StreamExt;
-use gpui::{App, Entity, Task};
+use gpui::{App, AsyncApp, Entity, Task};
 use language_model::{
     LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
-use project::{Project, ProjectPath};
+use log::{EditToolLog, EditToolRequestId};
+use project::{search::SearchQuery, Project};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use std::fmt::Write;
 use std::sync::Arc;
+use util::paths::PathMatcher;
+use util::ResultExt;
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct EditFilesToolInput {
-    /// High-level edit instructions. These will be interpreted by a smaller model,
-    /// so explain the edits you want that model to make and to which files need changing.
-    /// The description should be concise and clear. We will show this description to the user
-    /// as well.
+    /// High-level edit instructions. These will be interpreted by a smaller
+    /// model, so explain the changes you want that model to make and which
+    /// file paths need changing.
+    ///
+    /// The description should be concise and clear. We will show this
+    /// description to the user as well.
+    ///
+    /// WARNING: When specifying which file paths need changing, you MUST
+    /// start each path with one of the project's root directories.
+    ///
+    /// WARNING: NEVER include code blocks or snippets in edit instructions.
+    /// Only provide natural language descriptions of the changes needed! The tool will
+    /// reject any instructions that contain code blocks or snippets.
+    ///
+    /// The following examples assume we have two root directories in the project:
+    /// - root-1
+    /// - root-2
     ///
     /// <example>
-    /// If you want to rename a function you can say "Rename the function 'foo' to 'bar'".
+    /// If you want to introduce a new quit function to kill the process, your
+    /// instructions should be: "Add a new `quit` function to
+    /// `root-1/src/main.rs` to kill the process".
+    ///
+    /// Notice how the file path starts with root-1. Without that, the path
+    /// would be ambiguous and the call would fail!
     /// </example>
     ///
     /// <example>
-    /// If you want to add a new function you can say "Add a new method to the `User` struct that prints the age".
+    /// If you want to change documentation to always start with a capital
+    /// letter, your instructions should be: "In `root-2/db.js`,
+    /// `root-2/inMemory.js` and `root-2/sql.js`, change all the documentation
+    /// to start with a capital letter".
+    ///
+    /// Notice how we never specify code snippets in the instructions!
     /// </example>
     pub edit_instructions: String,
 }
@@ -59,6 +87,65 @@ impl Tool for EditFilesTool {
             Err(err) => return Task::ready(Err(anyhow!(err))),
         };
 
+        match EditToolLog::try_global(cx) {
+            Some(log) => {
+                let req_id = log.update(cx, |log, cx| {
+                    log.new_request(input.edit_instructions.clone(), cx)
+                });
+
+                let task =
+                    EditToolRequest::new(input, messages, project, Some((log.clone(), req_id)), cx);
+
+                cx.spawn(|mut cx| async move {
+                    let result = task.await;
+
+                    let str_result = match &result {
+                        Ok(out) => Ok(out.clone()),
+                        Err(err) => Err(err.to_string()),
+                    };
+
+                    log.update(&mut cx, |log, cx| {
+                        log.set_tool_output(req_id, str_result, cx)
+                    })
+                    .log_err();
+
+                    result
+                })
+            }
+
+            None => EditToolRequest::new(input, messages, project, None, cx),
+        }
+    }
+}
+
+struct EditToolRequest {
+    parser: EditActionParser,
+    changed_buffers: HashSet<Entity<language::Buffer>>,
+    bad_searches: Vec<BadSearch>,
+    project: Entity<Project>,
+    log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
+}
+
+#[derive(Debug)]
+enum DiffResult {
+    BadSearch(BadSearch),
+    Diff(language::Diff),
+}
+
+#[derive(Debug)]
+struct BadSearch {
+    file_path: String,
+    search: String,
+}
+
+impl EditToolRequest {
+    fn new(
+        input: EditFilesToolInput,
+        messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        log: Option<(Entity<EditToolLog>, EditToolRequestId)>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
         let model_registry = LanguageModelRegistry::read_global(cx);
         let Some(model) = model_registry.editor_model() else {
             return Task::ready(Err(anyhow!("No editor model configured")));
@@ -81,98 +168,208 @@ impl Tool for EditFilesTool {
         });
 
         cx.spawn(|mut cx| async move {
-            let request = LanguageModelRequest {
+            let llm_request = LanguageModelRequest {
                 messages,
                 tools: vec![],
                 stop: vec![],
-                temperature: None,
+                temperature: Some(0.0),
             };
 
-            let mut parser = EditActionParser::new();
-
-            let stream = model.stream_completion_text(request, &cx);
+            let stream = model.stream_completion_text(llm_request, &cx);
             let mut chunks = stream.await?;
 
-            let mut changed_buffers = HashSet::default();
-            let mut applied_edits = 0;
+            let mut request = Self {
+                parser: EditActionParser::new(),
+                changed_buffers: HashSet::default(),
+                bad_searches: Vec::new(),
+                project,
+                log,
+            };
 
             while let Some(chunk) = chunks.stream.next().await {
-                for action in parser.parse_chunk(&chunk?) {
-                    let project_path = project.read_with(&cx, |project, cx| {
-                        let worktree_root_name = action
-                            .file_path()
-                            .components()
-                            .next()
-                            .context("Invalid path")?;
-                        let worktree = project
-                            .worktree_for_root_name(
-                                &worktree_root_name.as_os_str().to_string_lossy(),
-                                cx,
-                            )
-                            .context("Directory not found in project")?;
-                        anyhow::Ok(ProjectPath {
-                            worktree_id: worktree.read(cx).id(),
-                            path: Arc::from(
-                                action.file_path().strip_prefix(worktree_root_name).unwrap(),
-                            ),
-                        })
-                    })??;
-
-                    let buffer = project
-                        .update(&mut cx, |project, cx| project.open_buffer(project_path, cx))?
-                        .await?;
-
-                    let diff = buffer
-                        .read_with(&cx, |buffer, cx| {
-                            let new_text = match action {
-                                EditAction::Replace { old, new, .. } => {
-                                    // TODO: Replace in background?
-                                    buffer.text().replace(&old, &new)
-                                }
-                                EditAction::Write { content, .. } => content,
-                            };
-
-                            buffer.diff(new_text, cx)
-                        })?
-                        .await;
-
-                    let _clock =
-                        buffer.update(&mut cx, |buffer, cx| buffer.apply_diff(diff, cx))?;
-
-                    changed_buffers.insert(buffer);
-
-                    applied_edits += 1;
-                }
+                request.process_response_chunk(&chunk?, &mut cx).await?;
             }
 
-            // Save each buffer once at the end
-            for buffer in changed_buffers {
-                project
-                    .update(&mut cx, |project, cx| project.save_buffer(buffer, cx))?
-                    .await?;
-            }
-
-            let errors = parser.errors();
-
-            if errors.is_empty() {
-                Ok("Successfully applied all edits".into())
-            } else {
-                let error_message = errors
-                    .iter()
-                    .map(|e| e.to_string())
-                    .collect::<Vec<_>>()
-                    .join("\n");
-
-                if applied_edits > 0 {
-                    Err(anyhow!(
-                        "Applied {} edit(s), but some blocks failed to parse:\n{}",
-                        applied_edits,
-                        error_message
-                    ))
-                } else {
-                    Err(anyhow!(error_message))
-                }
-            }
+            request.finalize(&mut cx).await
         })
     }
+
+    async fn process_response_chunk(&mut self, chunk: &str, cx: &mut AsyncApp) -> Result<()> {
+        let new_actions = self.parser.parse_chunk(chunk);
+
+        if let Some((ref log, req_id)) = self.log {
+            log.update(cx, |log, cx| {
+                log.push_editor_response_chunk(req_id, chunk, &new_actions, cx)
+            })
+            .log_err();
+        }
+
+        for action in new_actions {
+            self.apply_action(action, cx).await?;
+        }
+
+        Ok(())
+    }
+
+    async fn apply_action(&mut self, action: EditAction, cx: &mut AsyncApp) -> Result<()> {
+        let project_path = self.project.read_with(cx, |project, cx| {
+            project
+                .find_project_path(action.file_path(), cx)
+                .context("Path not found in project")
+        })??;
+
+        let buffer = self
+            .project
+            .update(cx, |project, cx| project.open_buffer(project_path, cx))?
+            .await?;
+
+        let result = match action {
+            EditAction::Replace {
+                old,
+                new,
+                file_path,
+            } => {
+                let snapshot = buffer.read_with(cx, |buffer, _cx| buffer.snapshot())?;
+
+                cx.background_executor()
+                    .spawn(Self::replace_diff(old, new, file_path, snapshot))
+                    .await
+            }
+            EditAction::Write { content, .. } => Ok(DiffResult::Diff(
+                buffer
+                    .read_with(cx, |buffer, cx| buffer.diff(content, cx))?
+                    .await,
+            )),
+        }?;
+
+        match result {
+            DiffResult::BadSearch(invalid_replace) => {
+                self.bad_searches.push(invalid_replace);
+            }
+            DiffResult::Diff(diff) => {
+                let _clock = buffer.update(cx, |buffer, cx| buffer.apply_diff(diff, cx))?;
+
+                self.changed_buffers.insert(buffer);
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn replace_diff(
+        old: String,
+        new: String,
+        file_path: std::path::PathBuf,
+        snapshot: language::BufferSnapshot,
+    ) -> Result<DiffResult> {
+        let query = SearchQuery::text(
+            old.clone(),
+            false,
+            true,
+            true,
+            PathMatcher::new(&[])?,
+            PathMatcher::new(&[])?,
+            None,
+        )?;
+
+        let matches = query.search(&snapshot, None).await;
+
+        if matches.is_empty() {
+            return Ok(DiffResult::BadSearch(BadSearch {
+                search: new.clone(),
+                file_path: file_path.display().to_string(),
+            }));
+        }
+
+        let edit_range = matches[0].clone();
+        let diff = language::text_diff(&old, &new);
+
+        let edits = diff
+            .into_iter()
+            .map(|(old_range, text)| {
+                let start = edit_range.start + old_range.start;
+                let end = edit_range.start + old_range.end;
+                (start..end, text)
+            })
+            .collect::<Vec<_>>();
+
+        let diff = language::Diff {
+            base_version: snapshot.version().clone(),
+            line_ending: snapshot.line_ending(),
+            edits,
+        };
+
+        anyhow::Ok(DiffResult::Diff(diff))
+    }
+
+    async fn finalize(self, cx: &mut AsyncApp) -> Result<String> {
+        let mut answer = match self.changed_buffers.len() {
+            0 => "No files were edited.".to_string(),
+            1 => "Successfully edited ".to_string(),
+            _ => "Successfully edited these files:\n\n".to_string(),
+        };
+
+        // Save each buffer once at the end
+        for buffer in self.changed_buffers {
+            let (path, save_task) = self.project.update(cx, |project, cx| {
+                let path = buffer
+                    .read(cx)
+                    .file()
+                    .map(|file| file.path().display().to_string());
+
+                let task = project.save_buffer(buffer.clone(), cx);
+
+                (path, task)
+            })?;
+
+            save_task.await?;
+
+            if let Some(path) = path {
+                writeln!(&mut answer, "{}", path)?;
+            }
+        }
+
+        let errors = self.parser.errors();
+
+        if errors.is_empty() && self.bad_searches.is_empty() {
+            Ok(answer.trim_end().to_string())
+        } else {
+            if !self.bad_searches.is_empty() {
+                writeln!(
+                    &mut answer,
+                    "\nThese searches failed because they didn't match any strings:"
+                )?;
+
+                for replace in self.bad_searches {
+                    writeln!(
+                        &mut answer,
+                        "- '{}' does not appear in `{}`",
+                        replace.search.replace("\r", "\\r").replace("\n", "\\n"),
+                        replace.file_path
+                    )?;
+                }
+
+                writeln!(&mut answer, "Make sure to use exact searches.")?;
+            }
+
+            if !errors.is_empty() {
+                writeln!(
+                    &mut answer,
+                    "\nThese SEARCH/REPLACE blocks failed to parse:"
+                )?;
+
+                for error in errors {
+                    writeln!(&mut answer, "- {}", error)?;
+                }
+            }
+
+            writeln!(
+                &mut answer,
+                "\nYou can fix errors by running the tool again. You can include instructions,\
+                but errors are part of the conversation so you don't need to repeat them."
+            )?;
+
+            Err(anyhow!(answer))
+        }
+    }
 }

crates/assistant_tools/src/edit_files_tool/description.md

@@ -1,4 +1,4 @@
-Edit files in the current project.
+Edit files in the current project by specifying instructions in natural language.
 
 When using this tool, you should suggest one coherent edit that can be made to the codebase.
 

crates/assistant_tools/src/edit_files_tool/edit_prompt.md

@@ -106,7 +106,7 @@ Every *SEARCH/REPLACE block* must use this format:
 7. The end of the replace block: >>>>>>> REPLACE
 8. The closing fence: ```
 
-Use the *FULL* file path, as shown to you by the user.
+Use the *FULL* file path, as shown to you by the user. Make sure to include the project's root directory name at the start of the path. *NEVER* specify the absolute path of the file!
 
 Every *SEARCH* section must *EXACTLY MATCH* the existing file content, character for character, including all comments, docstrings, etc.
 If the file contains code or other data wrapped/escaped in json/xml/quotes or other containers, you need to propose edits to the literal contents of the file, including the container markup.

crates/assistant_tools/src/edit_files_tool/log.rs

@@ -0,0 +1,415 @@
+use std::path::Path;
+
+use collections::HashSet;
+use feature_flags::FeatureFlagAppExt;
+use gpui::{
+    actions, list, prelude::*, App, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global,
+    ListAlignment, ListState, SharedString, Subscription, Window,
+};
+use release_channel::ReleaseChannel;
+use settings::Settings;
+use ui::prelude::*;
+use workspace::{item::ItemEvent, Item, Workspace, WorkspaceId};
+
+use super::edit_action::EditAction;
+
+actions!(debug, [EditTool]);
+
+pub fn init(cx: &mut App) {
+    if cx.is_staff() || ReleaseChannel::global(cx) == ReleaseChannel::Dev {
+        // Track events even before opening the log
+        EditToolLog::global(cx);
+    }
+
+    cx.observe_new(|workspace: &mut Workspace, _, _| {
+        workspace.register_action(|workspace, _: &EditTool, window, cx| {
+            let viewer = cx.new(EditToolLogViewer::new);
+            workspace.add_item_to_active_pane(Box::new(viewer), None, true, window, cx)
+        });
+    })
+    .detach();
+}
+
+pub struct GlobalEditToolLog(Entity<EditToolLog>);
+
+impl Global for GlobalEditToolLog {}
+
+#[derive(Default)]
+pub struct EditToolLog {
+    requests: Vec<EditToolRequest>,
+}
+
+#[derive(Clone, Copy, Hash, Eq, PartialEq)]
+pub struct EditToolRequestId(u32);
+
+impl EditToolLog {
+    pub fn global(cx: &mut App) -> Entity<Self> {
+        match Self::try_global(cx) {
+            Some(entity) => entity,
+            None => {
+                let entity = cx.new(|_cx| Self::default());
+                cx.set_global(GlobalEditToolLog(entity.clone()));
+                entity
+            }
+        }
+    }
+
+    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
+        cx.try_global::<GlobalEditToolLog>()
+            .map(|log| log.0.clone())
+    }
+
+    pub fn new_request(
+        &mut self,
+        instructions: String,
+        cx: &mut Context<Self>,
+    ) -> EditToolRequestId {
+        let id = EditToolRequestId(self.requests.len() as u32);
+        self.requests.push(EditToolRequest {
+            id,
+            instructions,
+            editor_response: None,
+            tool_output: None,
+            parsed_edits: Vec::new(),
+        });
+        cx.emit(EditToolLogEvent::Inserted);
+        id
+    }
+
+    pub fn push_editor_response_chunk(
+        &mut self,
+        id: EditToolRequestId,
+        chunk: &str,
+        new_actions: &[EditAction],
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(request) = self.requests.get_mut(id.0 as usize) {
+            match &mut request.editor_response {
+                None => {
+                    request.editor_response = Some(chunk.to_string());
+                }
+                Some(response) => {
+                    response.push_str(chunk);
+                }
+            }
+            request.parsed_edits.extend(new_actions.iter().cloned());
+
+            cx.emit(EditToolLogEvent::Updated);
+        }
+    }
+
+    pub fn set_tool_output(
+        &mut self,
+        id: EditToolRequestId,
+        tool_output: Result<String, String>,
+        cx: &mut Context<Self>,
+    ) {
+        if let Some(request) = self.requests.get_mut(id.0 as usize) {
+            request.tool_output = Some(tool_output);
+            cx.emit(EditToolLogEvent::Updated);
+        }
+    }
+}
+
+enum EditToolLogEvent {
+    Inserted,
+    Updated,
+}
+
+impl EventEmitter<EditToolLogEvent> for EditToolLog {}
+
+pub struct EditToolRequest {
+    id: EditToolRequestId,
+    instructions: String,
+    // we don't use a result here because the error might have occurred after we got a response
+    editor_response: Option<String>,
+    parsed_edits: Vec<EditAction>,
+    tool_output: Option<Result<String, String>>,
+}
+
+pub struct EditToolLogViewer {
+    focus_handle: FocusHandle,
+    log: Entity<EditToolLog>,
+    list_state: ListState,
+    expanded_edits: HashSet<(EditToolRequestId, usize)>,
+    _subscription: Subscription,
+}
+
+impl EditToolLogViewer {
+    pub fn new(cx: &mut Context<Self>) -> Self {
+        let log = EditToolLog::global(cx);
+
+        let subscription = cx.subscribe(&log, Self::handle_log_event);
+
+        Self {
+            focus_handle: cx.focus_handle(),
+            log: log.clone(),
+            list_state: ListState::new(
+                log.read(cx).requests.len(),
+                ListAlignment::Bottom,
+                px(1024.),
+                {
+                    let this = cx.entity().downgrade();
+                    move |ix, window: &mut Window, cx: &mut App| {
+                        this.update(cx, |this, cx| this.render_request(ix, window, cx))
+                            .unwrap()
+                    }
+                },
+            ),
+            expanded_edits: HashSet::default(),
+            _subscription: subscription,
+        }
+    }
+
+    fn handle_log_event(
+        &mut self,
+        _: Entity<EditToolLog>,
+        event: &EditToolLogEvent,
+        cx: &mut Context<Self>,
+    ) {
+        match event {
+            EditToolLogEvent::Inserted => {
+                let count = self.list_state.item_count();
+                self.list_state.splice(count..count, 1);
+            }
+            EditToolLogEvent::Updated => {}
+        }
+
+        cx.notify();
+    }
+
+    fn render_request(
+        &self,
+        index: usize,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> AnyElement {
+        let requests = &self.log.read(cx).requests;
+        let request = &requests[index];
+
+        v_flex()
+            .gap_3()
+            .child(Self::render_section(IconName::ArrowRight, "Tool Input"))
+            .child(request.instructions.clone())
+            .py_5()
+            .when(index + 1 < requests.len(), |element| {
+                element
+                    .border_b_1()
+                    .border_color(cx.theme().colors().border)
+            })
+            .map(|parent| match &request.editor_response {
+                None => {
+                    if request.tool_output.is_none() {
+                        parent.child("...")
+                    } else {
+                        parent
+                    }
+                }
+                Some(response) => parent
+                    .child(Self::render_section(
+                        IconName::ZedAssistant,
+                        "Editor Response",
+                    ))
+                    .child(Label::new(response.clone()).buffer_font(cx)),
+            })
+            .when(!request.parsed_edits.is_empty(), |parent| {
+                parent
+                    .child(Self::render_section(IconName::Microscope, "Parsed Edits"))
+                    .child(
+                        v_flex()
+                            .gap_2()
+                            .children(request.parsed_edits.iter().enumerate().map(
+                                |(index, edit)| {
+                                    self.render_edit_action(edit, request.id, index, cx)
+                                },
+                            )),
+                    )
+            })
+            .when_some(request.tool_output.as_ref(), |parent, output| {
+                parent
+                    .child(Self::render_section(IconName::ArrowLeft, "Tool Output"))
+                    .child(match output {
+                        Ok(output) => Label::new(output.clone()).color(Color::Success),
+                        Err(error) => Label::new(error.clone()).color(Color::Error),
+                    })
+            })
+            .into_any()
+    }
+
+    fn render_section(icon: IconName, title: &'static str) -> AnyElement {
+        h_flex()
+            .gap_1()
+            .child(Icon::new(icon).color(Color::Muted))
+            .child(Label::new(title).size(LabelSize::Small).color(Color::Muted))
+            .into_any()
+    }
+
+    fn render_edit_action(
+        &self,
+        edit_action: &EditAction,
+        request_id: EditToolRequestId,
+        index: usize,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        let expanded_id = (request_id, index);
+
+        match edit_action {
+            EditAction::Replace {
+                file_path,
+                old,
+                new,
+            } => self
+                .render_edit_action_container(
+                    expanded_id,
+                    &file_path,
+                    [
+                        Self::render_block(IconName::MagnifyingGlass, "Search", old.clone(), cx)
+                            .border_r_1()
+                            .border_color(cx.theme().colors().border)
+                            .into_any(),
+                        Self::render_block(IconName::Replace, "Replace", new.clone(), cx)
+                            .into_any(),
+                    ],
+                    cx,
+                )
+                .into_any(),
+            EditAction::Write { file_path, content } => self
+                .render_edit_action_container(
+                    expanded_id,
+                    &file_path,
+                    [
+                        Self::render_block(IconName::Pencil, "Write", content.clone(), cx)
+                            .into_any(),
+                    ],
+                    cx,
+                )
+                .into_any(),
+        }
+    }
+
+    fn render_edit_action_container(
+        &self,
+        expanded_id: (EditToolRequestId, usize),
+        file_path: &Path,
+        content: impl IntoIterator<Item = AnyElement>,
+        cx: &Context<Self>,
+    ) -> AnyElement {
+        let is_expanded = self.expanded_edits.contains(&expanded_id);
+
+        v_flex()
+            .child(
+                h_flex()
+                    .bg(cx.theme().colors().element_background)
+                    .border_1()
+                    .border_color(cx.theme().colors().border)
+                    .rounded_t_md()
+                    .when(!is_expanded, |el| el.rounded_b_md())
+                    .py_1()
+                    .px_2()
+                    .gap_1()
+                    .child(
+                        ui::Disclosure::new(ElementId::Integer(expanded_id.1), is_expanded)
+                            .on_click(cx.listener(move |this, _ev, _window, cx| {
+                                if is_expanded {
+                                    this.expanded_edits.remove(&expanded_id);
+                                } else {
+                                    this.expanded_edits.insert(expanded_id);
+                                }
+
+                                cx.notify();
+                            })),
+                    )
+                    .child(Label::new(file_path.display().to_string()).size(LabelSize::Small)),
+            )
+            .child(if is_expanded {
+                h_flex()
+                    .border_1()
+                    .border_t_0()
+                    .border_color(cx.theme().colors().border)
+                    .rounded_b_md()
+                    .children(content)
+                    .into_any()
+            } else {
+                Empty.into_any()
+            })
+            .into_any()
+    }
+
+    fn render_block(icon: IconName, title: &'static str, content: String, cx: &App) -> Div {
+        v_flex()
+            .p_1()
+            .gap_1()
+            .flex_1()
+            .h_full()
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(Icon::new(icon).color(Color::Muted))
+                    .child(Label::new(title).size(LabelSize::Small).color(Color::Muted)),
+            )
+            .font(theme::ThemeSettings::get_global(cx).buffer_font.clone())
+            .text_sm()
+            .child(content)
+            .child(div().flex_1())
+    }
+}
+
+impl EventEmitter<()> for EditToolLogViewer {}
+
+impl Focusable for EditToolLogViewer {
+    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Item for EditToolLogViewer {
+    type Event = ();
+
+    fn to_item_events(_: &Self::Event, _: impl FnMut(ItemEvent)) {}
+
+    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
+        Some("Edit Tool Log".into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<WorkspaceId>,
+        _window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<Self>>
+    where
+        Self: Sized,
+    {
+        Some(cx.new(Self::new))
+    }
+}
+
+impl Render for EditToolLogViewer {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        if self.list_state.item_count() == 0 {
+            return v_flex()
+                .justify_center()
+                .size_full()
+                .gap_1()
+                .bg(cx.theme().colors().editor_background)
+                .text_center()
+                .text_lg()
+                .child("No requests yet")
+                .child(
+                    div()
+                        .text_ui(cx)
+                        .child("Go ask the assistant to perform some edits"),
+                );
+        }
+
+        v_flex()
+            .p_4()
+            .bg(cx.theme().colors().editor_background)
+            .size_full()
+            .child(list(self.list_state.clone()).flex_grow())
+    }
+}

crates/assistant_tools/src/list_directory_tool.rs

@@ -12,10 +12,10 @@ pub struct ListDirectoryToolInput {
     /// The relative path of the directory to list.
     ///
     /// This path should never be absolute, and the first component
-    /// of the path should always be a top-level directory in a project.
+    /// of the path should always be a root directory in a project.
     ///
     /// <example>
-    /// If the project has the following top-level directories:
+    /// If the project has the following root directories:
     ///
     /// - directory1
     /// - directory2
@@ -24,7 +24,7 @@ pub struct ListDirectoryToolInput {
     /// </example>
     ///
     /// <example>
-    /// If the project has the following top-level directories:
+    /// If the project has the following root directories:
     ///
     /// - foo
     /// - bar
@@ -62,27 +62,37 @@ impl Tool for ListDirectoryTool {
             Err(err) => return Task::ready(Err(anyhow!(err))),
         };
 
-        let Some(worktree_root_name) = input.path.components().next() else {
-            return Task::ready(Err(anyhow!("Invalid path")));
+        let Some(project_path) = project.read(cx).find_project_path(&input.path, cx) else {
+            return Task::ready(Err(anyhow!("Path not found in project")));
         };
         let Some(worktree) = project
             .read(cx)
-            .worktree_for_root_name(&worktree_root_name.as_os_str().to_string_lossy(), cx)
+            .worktree_for_id(project_path.worktree_id, cx)
         else {
-            return Task::ready(Err(anyhow!("Directory not found in the project")));
+            return Task::ready(Err(anyhow!("Worktree not found")));
         };
-        let path = input.path.strip_prefix(worktree_root_name).unwrap();
+        let worktree = worktree.read(cx);
+
+        let Some(entry) = worktree.entry_for_path(&project_path.path) else {
+            return Task::ready(Err(anyhow!("Path not found: {}", input.path.display())));
+        };
+
+        if !entry.is_dir() {
+            return Task::ready(Err(anyhow!("{} is a file.", input.path.display())));
+        }
+
         let mut output = String::new();
-        for entry in worktree.read(cx).child_entries(path) {
+        for entry in worktree.child_entries(&project_path.path) {
             writeln!(
                 output,
                 "{}",
-                Path::new(worktree_root_name.as_os_str())
-                    .join(&entry.path)
-                    .display(),
+                Path::new(worktree.root_name()).join(&entry.path).display(),
             )
             .unwrap();
         }
+        if output.is_empty() {
+            return Task::ready(Ok(format!("{} is empty.", input.path.display())));
+        }
         Task::ready(Ok(output))
     }
 }

crates/assistant_tools/src/path_search_tool.rs

@@ -0,0 +1,88 @@
+use anyhow::{anyhow, Result};
+use assistant_tool::Tool;
+use gpui::{App, Entity, Task};
+use language_model::LanguageModelRequestMessage;
+use project::Project;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::{path::PathBuf, sync::Arc};
+use util::paths::PathMatcher;
+
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
+pub struct PathSearchToolInput {
+    /// The glob to search all project paths for.
+    ///
+    /// <example>
+    /// If the project has the following root directories:
+    ///
+    /// - directory1/a/something.txt
+    /// - directory2/a/things.txt
+    /// - directory3/a/other.txt
+    ///
+    /// You can get back the first two paths by providing a glob of "*thing*.txt"
+    /// </example>
+    pub glob: String,
+}
+
+pub struct PathSearchTool;
+
+impl Tool for PathSearchTool {
+    fn name(&self) -> String {
+        "path-search".into()
+    }
+
+    fn description(&self) -> String {
+        include_str!("./path_search_tool/description.md").into()
+    }
+
+    fn input_schema(&self) -> serde_json::Value {
+        let schema = schemars::schema_for!(PathSearchToolInput);
+        serde_json::to_value(&schema).unwrap()
+    }
+
+    fn run(
+        self: Arc<Self>,
+        input: serde_json::Value,
+        _messages: &[LanguageModelRequestMessage],
+        project: Entity<Project>,
+        cx: &mut App,
+    ) -> Task<Result<String>> {
+        let glob = match serde_json::from_value::<PathSearchToolInput>(input) {
+            Ok(input) => input.glob,
+            Err(err) => return Task::ready(Err(anyhow!(err))),
+        };
+        let path_matcher = match PathMatcher::new(&[glob.clone()]) {
+            Ok(matcher) => matcher,
+            Err(err) => return Task::ready(Err(anyhow!("Invalid glob: {}", err))),
+        };
+
+        let mut matches = Vec::new();
+
+        for worktree_handle in project.read(cx).worktrees(cx) {
+            let worktree = worktree_handle.read(cx);
+            let root_name = worktree.root_name();
+
+            // Don't consider ignored entries.
+            for entry in worktree.entries(false, 0) {
+                if path_matcher.is_match(&entry.path) {
+                    matches.push(
+                        PathBuf::from(root_name)
+                            .join(&entry.path)
+                            .to_string_lossy()
+                            .to_string(),
+                    );
+                }
+            }
+        }
+
+        if matches.is_empty() {
+            Task::ready(Ok(format!(
+                "No paths in the project matched the glob {glob:?}"
+            )))
+        } else {
+            // Sort to group entries in the same directory together.
+            matches.sort();
+            Task::ready(Ok(matches.join("\n")))
+        }
+    }
+}

crates/assistant_tools/src/path_search_tool/description.md

@@ -0,0 +1 @@
+Returns all the paths in the project which match the given glob.

crates/assistant_tools/src/read_file_tool.rs

@@ -5,7 +5,7 @@ use anyhow::{anyhow, Result};
 use assistant_tool::Tool;
 use gpui::{App, Entity, Task};
 use language_model::LanguageModelRequestMessage;
-use project::{Project, ProjectPath};
+use project::Project;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
@@ -14,10 +14,10 @@ pub struct ReadFileToolInput {
     /// The relative path of the file to read.
     ///
     /// This path should never be absolute, and the first component
-    /// of the path should always be a top-level directory in a project.
+    /// of the path should always be a root directory in a project.
     ///
     /// <example>
-    /// If the project has the following top-level directories:
+    /// If the project has the following root directories:
     ///
     /// - directory1
     /// - directory2
@@ -56,18 +56,8 @@ impl Tool for ReadFileTool {
             Err(err) => return Task::ready(Err(anyhow!(err))),
         };
 
-        let Some(worktree_root_name) = input.path.components().next() else {
-            return Task::ready(Err(anyhow!("Invalid path")));
-        };
-        let Some(worktree) = project
-            .read(cx)
-            .worktree_for_root_name(&worktree_root_name.as_os_str().to_string_lossy(), cx)
-        else {
-            return Task::ready(Err(anyhow!("Directory not found in the project")));
-        };
-        let project_path = ProjectPath {
-            worktree_id: worktree.read(cx).id(),
-            path: Arc::from(input.path.strip_prefix(worktree_root_name).unwrap()),
+        let Some(project_path) = project.read(cx).find_project_path(&input.path, cx) else {
+            return Task::ready(Err(anyhow!("Path not found in project")));
         };
         cx.spawn(|cx| async move {
             let buffer = cx

crates/auto_update_ui/src/auto_update_ui.rs

@@ -93,7 +93,7 @@ fn view_release_notes_locally(
 
                             let tab_description = SharedString::from(body.title.to_string());
                             let editor = cx.new(|cx| {
-                                Editor::for_multibuffer(buffer, Some(project), true, window, cx)
+                                Editor::for_multibuffer(buffer, Some(project), window, cx)
                             });
                             let workspace_handle = workspace.weak_handle();
                             let markdown_preview: Entity<MarkdownPreviewView> =

crates/cli/src/main.rs

@@ -198,6 +198,8 @@ fn main() -> Result<()> {
     let mut paths = vec![];
     let mut urls = vec![];
     let mut stdin_tmp_file: Option<fs::File> = None;
+    let mut anonymous_fd_tmp_files = vec![];
+
     for path in args.paths_with_position.iter() {
         if path.starts_with("zed://")
             || path.starts_with("http://")
@@ -211,6 +213,11 @@ fn main() -> Result<()> {
             paths.push(file.path().to_string_lossy().to_string());
             let (file, _) = file.keep()?;
             stdin_tmp_file = Some(file);
+        } else if let Some(file) = anonymous_fd(path) {
+            let tmp_file = NamedTempFile::new()?;
+            paths.push(tmp_file.path().to_string_lossy().to_string());
+            let (tmp_file, _) = tmp_file.keep()?;
+            anonymous_fd_tmp_files.push((file, tmp_file));
         } else {
             paths.push(parse_path_with_position(path)?)
         }
@@ -252,31 +259,33 @@ fn main() -> Result<()> {
         }
     });
 
-    let pipe_handle: JoinHandle<anyhow::Result<()>> = thread::spawn(move || {
-        if let Some(mut tmp_file) = stdin_tmp_file {
-            let mut stdin = std::io::stdin().lock();
-            if io::IsTerminal::is_terminal(&stdin) {
-                return Ok(());
-            }
-            let mut buffer = [0; 8 * 1024];
-            loop {
-                let bytes_read = io::Read::read(&mut stdin, &mut buffer)?;
-                if bytes_read == 0 {
-                    break;
+    let stdin_pipe_handle: Option<JoinHandle<anyhow::Result<()>>> =
+        stdin_tmp_file.map(|tmp_file| {
+            thread::spawn(move || {
+                let stdin = std::io::stdin().lock();
+                if io::IsTerminal::is_terminal(&stdin) {
+                    return Ok(());
                 }
-                io::Write::write(&mut tmp_file, &buffer[..bytes_read])?;
-            }
-            io::Write::flush(&mut tmp_file)?;
-        }
-        Ok(())
-    });
+                return pipe_to_tmp(stdin, tmp_file);
+            })
+        });
+
+    let anonymous_fd_pipe_handles: Vec<JoinHandle<anyhow::Result<()>>> = anonymous_fd_tmp_files
+        .into_iter()
+        .map(|(file, tmp_file)| thread::spawn(move || pipe_to_tmp(file, tmp_file)))
+        .collect();
 
     if args.foreground {
         app.run_foreground(url)?;
     } else {
         app.launch(url)?;
         sender.join().unwrap()?;
-        pipe_handle.join().unwrap()?;
+        if let Some(handle) = stdin_pipe_handle {
+            handle.join().unwrap()?;
+        }
+        for handle in anonymous_fd_pipe_handles {
+            handle.join().unwrap()?;
+        }
     }
 
     if let Some(exit_status) = exit_status.lock().take() {
@@ -285,6 +294,64 @@ fn main() -> Result<()> {
     Ok(())
 }
 
+fn pipe_to_tmp(mut src: impl io::Read, mut dest: fs::File) -> Result<()> {
+    let mut buffer = [0; 8 * 1024];
+    loop {
+        let bytes_read = match src.read(&mut buffer) {
+            Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,
+            res => res?,
+        };
+        if bytes_read == 0 {
+            break;
+        }
+        io::Write::write_all(&mut dest, &buffer[..bytes_read])?;
+    }
+    io::Write::flush(&mut dest)?;
+    Ok(())
+}
+
+fn anonymous_fd(path: &str) -> Option<fs::File> {
+    #[cfg(target_os = "linux")]
+    {
+        use std::os::fd::{self, FromRawFd};
+
+        let fd_str = path.strip_prefix("/proc/self/fd/")?;
+
+        let link = fs::read_link(path).ok()?;
+        if !link.starts_with("memfd:") {
+            return None;
+        }
+
+        let fd: fd::RawFd = fd_str.parse().ok()?;
+        let file = unsafe { fs::File::from_raw_fd(fd) };
+        return Some(file);
+    }
+    #[cfg(target_os = "macos")]
+    {
+        use std::os::{
+            fd::{self, FromRawFd},
+            unix::fs::FileTypeExt,
+        };
+
+        let fd_str = path.strip_prefix("/dev/fd/")?;
+
+        let metadata = fs::metadata(path).ok()?;
+        let file_type = metadata.file_type();
+        if !file_type.is_fifo() && !file_type.is_socket() {
+            return None;
+        }
+        let fd: fd::RawFd = fd_str.parse().ok()?;
+        let file = unsafe { fs::File::from_raw_fd(fd) };
+        return Some(file);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+    {
+        _ = path;
+        // not implemented for bsd, windows. Could be, but isn't yet
+        return None;
+    }
+}
+
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
 mod linux {
     use std::{

crates/collab/src/api/events.rs

@@ -660,6 +660,10 @@ fn for_snowflake(
                 e.event_type.clone(),
                 serde_json::to_value(&e.event_properties).unwrap(),
             ),
+            Event::AssistantThreadFeedback(e) => (
+                "Assistant Feedback".to_string(),
+                serde_json::to_value(&e).unwrap(),
+            ),
         };
 
         if let serde_json::Value::Object(ref mut map) = event_properties {

crates/collab/src/tests/following_tests.rs

@@ -313,9 +313,8 @@ async fn test_basic_following(
         result
     });
     let multibuffer_editor_a = workspace_a.update_in(cx_a, |workspace, window, cx| {
-        let editor = cx.new(|cx| {
-            Editor::for_multibuffer(multibuffer_a, Some(project_a.clone()), true, window, cx)
-        });
+        let editor = cx
+            .new(|cx| Editor::for_multibuffer(multibuffer_a, Some(project_a.clone()), window, cx));
         workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx);
         editor
     });

crates/collab_ui/src/chat_panel/message_editor.rs

@@ -61,9 +61,9 @@ impl CompletionProvider for MessageEditorCompletionProvider {
         _: editor::CompletionContext,
         _window: &mut Window,
         cx: &mut Context<Editor>,
-    ) -> Task<anyhow::Result<Vec<Completion>>> {
+    ) -> Task<Result<Option<Vec<Completion>>>> {
         let Some(handle) = self.0.upgrade() else {
-            return Task::ready(Ok(Vec::new()));
+            return Task::ready(Ok(None));
         };
         handle.update(cx, |message_editor, cx| {
             message_editor.completions(buffer, buffer_position, cx)
@@ -246,20 +246,22 @@ impl MessageEditor {
         buffer: &Entity<Buffer>,
         end_anchor: Anchor,
         cx: &mut Context<Self>,
-    ) -> Task<Result<Vec<Completion>>> {
+    ) -> Task<Result<Option<Vec<Completion>>>> {
         if let Some((start_anchor, query, candidates)) =
             self.collect_mention_candidates(buffer, end_anchor, cx)
         {
             if !candidates.is_empty() {
                 return cx.spawn(|_, cx| async move {
-                    Ok(Self::resolve_completions_for_candidates(
-                        &cx,
-                        query.as_str(),
-                        &candidates,
-                        start_anchor..end_anchor,
-                        Self::completion_for_mention,
-                    )
-                    .await)
+                    Ok(Some(
+                        Self::resolve_completions_for_candidates(
+                            &cx,
+                            query.as_str(),
+                            &candidates,
+                            start_anchor..end_anchor,
+                            Self::completion_for_mention,
+                        )
+                        .await,
+                    ))
                 });
             }
         }
@@ -269,19 +271,21 @@ impl MessageEditor {
         {
             if !candidates.is_empty() {
                 return cx.spawn(|_, cx| async move {
-                    Ok(Self::resolve_completions_for_candidates(
-                        &cx,
-                        query.as_str(),
-                        candidates,
-                        start_anchor..end_anchor,
-                        Self::completion_for_emoji,
-                    )
-                    .await)
+                    Ok(Some(
+                        Self::resolve_completions_for_candidates(
+                            &cx,
+                            query.as_str(),
+                            candidates,
+                            start_anchor..end_anchor,
+                            Self::completion_for_emoji,
+                        )
+                        .await,
+                    ))
                 });
             }
         }
 
-        Task::ready(Ok(vec![]))
+        Task::ready(Ok(Some(Vec::new())))
     }
 
     async fn resolve_completions_for_candidates(

crates/copilot/src/copilot.rs

@@ -170,7 +170,9 @@ enum SignInStatus {
         prompt: Option<request::PromptUserDeviceFlow>,
         task: Shared<Task<Result<(), Arc<anyhow::Error>>>>,
     },
-    SignedOut,
+    SignedOut {
+        awaiting_signing_in: bool,
+    },
 }
 
 #[derive(Debug, Clone)]
@@ -180,7 +182,9 @@ pub enum Status {
     },
     Error(Arc<str>),
     Disabled,
-    SignedOut,
+    SignedOut {
+        awaiting_signing_in: bool,
+    },
     SigningIn {
         prompt: Option<request::PromptUserDeviceFlow>,
     },
@@ -345,8 +349,8 @@ impl Copilot {
             buffers: Default::default(),
             _subscription: cx.on_app_quit(Self::shutdown_language_server),
         };
-        this.enable_or_disable_copilot(cx);
-        cx.observe_global::<SettingsStore>(move |this, cx| this.enable_or_disable_copilot(cx))
+        this.start_copilot(true, false, cx);
+        cx.observe_global::<SettingsStore>(move |this, cx| this.start_copilot(true, false, cx))
             .detach();
         this
     }
@@ -364,26 +368,40 @@ impl Copilot {
         }
     }
 
-    fn enable_or_disable_copilot(&mut self, cx: &mut Context<Self>) {
+    fn start_copilot(
+        &mut self,
+        check_edit_prediction_provider: bool,
+        awaiting_sign_in_after_start: bool,
+        cx: &mut Context<Self>,
+    ) {
+        if !matches!(self.server, CopilotServer::Disabled) {
+            return;
+        }
+        let language_settings = all_language_settings(None, cx);
+        if check_edit_prediction_provider
+            && language_settings.edit_predictions.provider != EditPredictionProvider::Copilot
+        {
+            return;
+        }
         let server_id = self.server_id;
         let http = self.http.clone();
         let node_runtime = self.node_runtime.clone();
-        let language_settings = all_language_settings(None, cx);
-        if language_settings.edit_predictions.provider == EditPredictionProvider::Copilot {
-            if matches!(self.server, CopilotServer::Disabled) {
-                let env = self.build_env(&language_settings.edit_predictions.copilot);
-                let start_task = cx
-                    .spawn(move |this, cx| {
-                        Self::start_language_server(server_id, http, node_runtime, env, this, cx)
-                    })
-                    .shared();
-                self.server = CopilotServer::Starting { task: start_task };
-                cx.notify();
-            }
-        } else {
-            self.server = CopilotServer::Disabled;
-            cx.notify();
-        }
+        let env = self.build_env(&language_settings.edit_predictions.copilot);
+        let start_task = cx
+            .spawn(move |this, cx| {
+                Self::start_language_server(
+                    server_id,
+                    http,
+                    node_runtime,
+                    env,
+                    this,
+                    awaiting_sign_in_after_start,
+                    cx,
+                )
+            })
+            .shared();
+        self.server = CopilotServer::Starting { task: start_task };
+        cx.notify();
     }
 
     fn build_env(&self, copilot_settings: &CopilotSettings) -> Option<HashMap<String, String>> {
@@ -449,6 +467,7 @@ impl Copilot {
         node_runtime: NodeRuntime,
         env: Option<HashMap<String, String>>,
         this: WeakEntity<Self>,
+        awaiting_sign_in_after_start: bool,
         mut cx: AsyncApp,
     ) {
         let start_language_server = async {
@@ -522,7 +541,9 @@ impl Copilot {
                 Ok((server, status)) => {
                     this.server = CopilotServer::Running(RunningCopilotServer {
                         lsp: server,
-                        sign_in_status: SignInStatus::SignedOut,
+                        sign_in_status: SignInStatus::SignedOut {
+                            awaiting_signing_in: awaiting_sign_in_after_start,
+                        },
                         registered_buffers: Default::default(),
                     });
                     cx.emit(Event::CopilotLanguageServerStarted);
@@ -545,7 +566,7 @@ impl Copilot {
                     cx.notify();
                     task.clone()
                 }
-                SignInStatus::SignedOut | SignInStatus::Unauthorized { .. } => {
+                SignInStatus::SignedOut { .. } | SignInStatus::Unauthorized { .. } => {
                     let lsp = server.lsp.clone();
                     let task = cx
                         .spawn(|this, mut cx| async move {
@@ -633,7 +654,7 @@ impl Copilot {
                     anyhow::Ok(())
                 })
             }
-            CopilotServer::Disabled => cx.background_spawn(async move {
+            CopilotServer::Disabled => cx.background_spawn(async {
                 clear_copilot_config_dir().await;
                 anyhow::Ok(())
             }),
@@ -651,7 +672,8 @@ impl Copilot {
                 let server_id = self.server_id;
                 move |this, cx| async move {
                     clear_copilot_dir().await;
-                    Self::start_language_server(server_id, http, node_runtime, env, this, cx).await
+                    Self::start_language_server(server_id, http, node_runtime, env, this, false, cx)
+                        .await
                 }
             })
             .shared();
@@ -961,7 +983,11 @@ impl Copilot {
                     SignInStatus::SigningIn { prompt, .. } => Status::SigningIn {
                         prompt: prompt.clone(),
                     },
-                    SignInStatus::SignedOut => Status::SignedOut,
+                    SignInStatus::SignedOut {
+                        awaiting_signing_in,
+                    } => Status::SignedOut {
+                        awaiting_signing_in: *awaiting_signing_in,
+                    },
                 }
             }
         }
@@ -990,7 +1016,11 @@ impl Copilot {
                     }
                 }
                 request::SignInStatus::Ok { user: None } | request::SignInStatus::NotSignedIn => {
-                    server.sign_in_status = SignInStatus::SignedOut;
+                    if !matches!(server.sign_in_status, SignInStatus::SignedOut { .. }) {
+                        server.sign_in_status = SignInStatus::SignedOut {
+                            awaiting_signing_in: false,
+                        };
+                    }
                     cx.emit(Event::CopilotAuthSignedOut);
                     for buffer in self.buffers.iter().cloned().collect::<Vec<_>>() {
                         self.unregister_buffer(&buffer);

crates/copilot/src/copilot_completion_provider.rs

@@ -271,7 +271,10 @@ mod tests {
     use gpui::{AppContext as _, BackgroundExecutor, TestAppContext, UpdateGlobal};
     use indoc::indoc;
     use language::{
-        language_settings::{AllLanguageSettings, AllLanguageSettingsContent},
+        language_settings::{
+            AllLanguageSettings, AllLanguageSettingsContent, CompletionSettings,
+            WordsCompletionMode,
+        },
         Point,
     };
     use project::Project;
@@ -286,7 +289,13 @@ mod tests {
     #[gpui::test(iterations = 10)]
     async fn test_copilot(executor: BackgroundExecutor, cx: &mut TestAppContext) {
         // flaky
-        init_test(cx, |_| {});
+        init_test(cx, |settings| {
+            settings.defaults.completions = Some(CompletionSettings {
+                words: WordsCompletionMode::Disabled,
+                lsp: true,
+                lsp_fetch_timeout_ms: 0,
+            });
+        });
 
         let (copilot, copilot_lsp) = Copilot::fake(cx);
         let mut cx = EditorLspTestContext::new_rust(
@@ -511,7 +520,13 @@ mod tests {
         cx: &mut TestAppContext,
     ) {
         // flaky
-        init_test(cx, |_| {});
+        init_test(cx, |settings| {
+            settings.defaults.completions = Some(CompletionSettings {
+                words: WordsCompletionMode::Disabled,
+                lsp: true,
+                lsp_fetch_timeout_ms: 0,
+            });
+        });
 
         let (copilot, copilot_lsp) = Copilot::fake(cx);
         let mut cx = EditorLspTestContext::new_rust(
@@ -730,8 +745,8 @@ mod tests {
             );
             multibuffer
         });
-        let editor = cx
-            .add_window(|window, cx| Editor::for_multibuffer(multibuffer, None, true, window, cx));
+        let editor =
+            cx.add_window(|window, cx| Editor::for_multibuffer(multibuffer, None, window, cx));
         editor
             .update(cx, |editor, window, cx| {
                 use gpui::Focusable;
@@ -766,7 +781,7 @@ mod tests {
             assert!(editor.has_active_inline_completion());
             assert_eq!(
                 editor.display_text(cx),
-                "\n\n\na = 1\nb = 2 + a\n\n\n\n\n\nc = 3\nd = 4\n\n"
+                "\n\na = 1\nb = 2 + a\n\n\n\nc = 3\nd = 4\n"
             );
             assert_eq!(editor.text(cx), "a = 1\nb = 2\n\nc = 3\nd = 4\n");
         });
@@ -788,7 +803,7 @@ mod tests {
             assert!(!editor.has_active_inline_completion());
             assert_eq!(
                 editor.display_text(cx),
-                "\n\n\na = 1\nb = 2\n\n\n\n\n\nc = 3\nd = 4\n\n"
+                "\n\na = 1\nb = 2\n\n\n\nc = 3\nd = 4\n"
             );
             assert_eq!(editor.text(cx), "a = 1\nb = 2\n\nc = 3\nd = 4\n");
 
@@ -797,7 +812,7 @@ mod tests {
             assert!(!editor.has_active_inline_completion());
             assert_eq!(
                 editor.display_text(cx),
-                "\n\n\na = 1\nb = 2\n\n\n\n\n\nc = 3\nd = 4 \n\n"
+                "\n\na = 1\nb = 2\n\n\n\nc = 3\nd = 4 \n"
             );
             assert_eq!(editor.text(cx), "a = 1\nb = 2\n\nc = 3\nd = 4 \n");
         });
@@ -808,7 +823,7 @@ mod tests {
             assert!(editor.has_active_inline_completion());
             assert_eq!(
                 editor.display_text(cx),
-                "\n\n\na = 1\nb = 2\n\n\n\n\n\nc = 3\nd = 4 + c\n\n"
+                "\n\na = 1\nb = 2\n\n\n\nc = 3\nd = 4 + c\n"
             );
             assert_eq!(editor.text(cx), "a = 1\nb = 2\n\nc = 3\nd = 4 \n");
         });
@@ -982,8 +997,8 @@ mod tests {
             );
             multibuffer
         });
-        let editor = cx
-            .add_window(|window, cx| Editor::for_multibuffer(multibuffer, None, true, window, cx));
+        let editor =
+            cx.add_window(|window, cx| Editor::for_multibuffer(multibuffer, None, window, cx));
         editor
             .update(cx, |editor, window, cx| {
                 use gpui::Focusable;

crates/copilot/src/sign_in.rs

@@ -1,9 +1,10 @@
 use crate::{request::PromptUserDeviceFlow, Copilot, Status};
 use gpui::{
-    div, App, ClipboardItem, Context, DismissEvent, Element, Entity, EventEmitter, FocusHandle,
-    Focusable, InteractiveElement, IntoElement, MouseDownEvent, ParentElement, Render, Styled,
-    Subscription, Window,
+    div, percentage, svg, Animation, AnimationExt, App, ClipboardItem, Context, DismissEvent,
+    Element, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement,
+    MouseDownEvent, ParentElement, Render, Styled, Subscription, Transformation, Window,
 };
+use std::time::Duration;
 use ui::{prelude::*, Button, Label, Vector, VectorName};
 use util::ResultExt as _;
 use workspace::notifications::NotificationId;
@@ -17,11 +18,13 @@ pub fn initiate_sign_in(window: &mut Window, cx: &mut App) {
     let Some(copilot) = Copilot::global(cx) else {
         return;
     };
-    let status = copilot.read(cx).status();
     let Some(workspace) = window.root::<Workspace>().flatten() else {
         return;
     };
-    match status {
+    if matches!(copilot.read(cx).status(), Status::Disabled) {
+        copilot.update(cx, |this, cx| this.start_copilot(false, true, cx));
+    }
+    match copilot.read(cx).status() {
         Status::Starting { task } => {
             workspace.update(cx, |workspace, cx| {
                 workspace.show_toast(
@@ -54,6 +57,15 @@ pub fn initiate_sign_in(window: &mut Window, cx: &mut App) {
                                 copilot
                                     .update(cx, |copilot, cx| copilot.sign_in(cx))
                                     .detach_and_log_err(cx);
+                                if let Some(window_handle) = cx.active_window() {
+                                    window_handle
+                                        .update(cx, |_, window, cx| {
+                                            workspace.toggle_modal(window, cx, |_, cx| {
+                                                CopilotCodeVerification::new(&copilot, cx)
+                                            });
+                                        })
+                                        .log_err();
+                                }
                             }
                         })
                         .log_err();
@@ -76,6 +88,7 @@ pub struct CopilotCodeVerification {
     status: Status,
     connect_clicked: bool,
     focus_handle: FocusHandle,
+    copilot: Entity<Copilot>,
     _subscription: Subscription,
 }
 
@@ -86,7 +99,20 @@ impl Focusable for CopilotCodeVerification {
 }
 
 impl EventEmitter<DismissEvent> for CopilotCodeVerification {}
-impl ModalView for CopilotCodeVerification {}
+impl ModalView for CopilotCodeVerification {
+    fn on_before_dismiss(
+        &mut self,
+        _: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> workspace::DismissDecision {
+        self.copilot.update(cx, |copilot, cx| {
+            if matches!(copilot.status(), Status::SigningIn { .. }) {
+                copilot.sign_out(cx).detach_and_log_err(cx);
+            }
+        });
+        workspace::DismissDecision::Dismiss(true)
+    }
+}
 
 impl CopilotCodeVerification {
     pub fn new(copilot: &Entity<Copilot>, cx: &mut Context<Self>) -> Self {
@@ -95,6 +121,7 @@ impl CopilotCodeVerification {
             status,
             connect_clicked: false,
             focus_handle: cx.focus_handle(),
+            copilot: copilot.clone(),
             _subscription: cx.observe(copilot, |this, copilot, cx| {
                 let status = copilot.read(cx).status();
                 match status {
@@ -180,9 +207,12 @@ impl CopilotCodeVerification {
             .child(
                 Button::new("copilot-enable-cancel-button", "Cancel")
                     .full_width()
-                    .on_click(cx.listener(|_, _, _, cx| cx.emit(DismissEvent))),
+                    .on_click(cx.listener(|_, _, _, cx| {
+                        cx.emit(DismissEvent);
+                    })),
             )
     }
+
     fn render_enabled_modal(cx: &mut Context<Self>) -> impl Element {
         v_flex()
             .gap_2()
@@ -216,16 +246,27 @@ impl CopilotCodeVerification {
             )
     }
 
-    fn render_disabled_modal() -> impl Element {
-        v_flex()
-            .child(Headline::new("Copilot is disabled").size(HeadlineSize::Large))
-            .child(Label::new("You can enable Copilot in your settings."))
+    fn render_loading(window: &mut Window, _: &mut Context<Self>) -> impl Element {
+        let loading_icon = svg()
+            .size_8()
+            .path(IconName::ArrowCircle.path())
+            .text_color(window.text_style().color)
+            .with_animation(
+                "icon_circle_arrow",
+                Animation::new(Duration::from_secs(2)).repeat(),
+                |svg, delta| svg.with_transformation(Transformation::rotate(percentage(delta))),
+            );
+
+        h_flex().justify_center().child(loading_icon)
     }
 }
 
 impl Render for CopilotCodeVerification {
-    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let prompt = match &self.status {
+            Status::SigningIn { prompt: None } => {
+                Self::render_loading(window, cx).into_any_element()
+            }
             Status::SigningIn {
                 prompt: Some(prompt),
             } => Self::render_prompting_modal(self.connect_clicked, prompt, cx).into_any_element(),
@@ -237,10 +278,6 @@ impl Render for CopilotCodeVerification {
                 self.connect_clicked = false;
                 Self::render_enabled_modal(cx).into_any_element()
             }
-            Status::Disabled => {
-                self.connect_clicked = false;
-                Self::render_disabled_modal().into_any_element()
-            }
             _ => div().into_any_element(),
         };
 

crates/diagnostics/src/diagnostics.rs

@@ -198,13 +198,8 @@ impl ProjectDiagnosticsEditor {
 
         let excerpts = cx.new(|cx| MultiBuffer::new(project_handle.read(cx).capability()));
         let editor = cx.new(|cx| {
-            let mut editor = Editor::for_multibuffer(
-                excerpts.clone(),
-                Some(project_handle.clone()),
-                true,
-                window,
-                cx,
-            );
+            let mut editor =
+                Editor::for_multibuffer(excerpts.clone(), Some(project_handle.clone()), window, cx);
             editor.set_vertical_scroll_margin(5, cx);
             editor.disable_inline_diagnostics();
             editor

crates/diagnostics/src/diagnostics_tests.rs

@@ -169,10 +169,10 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(16), EXCERPT_HEADER.into()),
-            (DisplayRow(18), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(27), EXCERPT_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(15), EXCERPT_HEADER.into()),
+            (DisplayRow(16), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(25), EXCERPT_HEADER.into()),
         ]
     );
     assert_eq!(
@@ -186,7 +186,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n", // primary message
             "\n", // padding
-            "\n", // expand
             "    let x = vec![];\n",
             "    let y = vec![];\n",
             "\n", // supporting diagnostic
@@ -198,7 +197,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             "    c(y);\n",
             "\n", // supporting diagnostic
             "    d(x);\n",
-            "\n", // expand
             "\n", // context ellipsis
             // diagnostic group 2
             "\n", // primary message
@@ -210,13 +208,11 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             "    a(x);\n",
             "\n", // supporting diagnostic
             "    b(y);\n",
-            "\n", // expand
             "\n", // context ellipsis
             "    c(y);\n",
             "    d(x);\n",
             "\n", // supporting diagnostic
             "}",
-            "\n", // expand
         )
     );
 
@@ -224,7 +220,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
     editor.update(cx, |editor, cx| {
         assert_eq!(
             editor.selections.display_ranges(cx),
-            [DisplayPoint::new(DisplayRow(13), 6)..DisplayPoint::new(DisplayRow(13), 6)]
+            [DisplayPoint::new(DisplayRow(12), 6)..DisplayPoint::new(DisplayRow(12), 6)]
         );
     });
 
@@ -260,12 +256,12 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(8), FILE_HEADER.into()),
-            (DisplayRow(12), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(25), EXCERPT_HEADER.into()),
-            (DisplayRow(27), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(36), EXCERPT_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(7), FILE_HEADER.into()),
+            (DisplayRow(9), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(22), EXCERPT_HEADER.into()),
+            (DisplayRow(23), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(32), EXCERPT_HEADER.into()),
         ]
     );
 
@@ -280,7 +276,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n", // primary message
             "\n", // padding
-            "\n", // expand
             "const a: i32 = 'a';\n",
             "\n", // supporting diagnostic
             "const b: i32 = c;\n",
@@ -292,8 +287,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n", // primary message
             "\n", // padding
-            "\n", // expand
-            "\n", // expand
             "    let x = vec![];\n",
             "    let y = vec![];\n",
             "\n", // supporting diagnostic
@@ -309,7 +302,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 2
             "\n", // primary message
             "\n", // filename
-            "\n", // expand
             "fn main() {\n",
             "    let x = vec![];\n",
             "\n", // supporting diagnostic
@@ -317,13 +309,11 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             "    a(x);\n",
             "\n", // supporting diagnostic
             "    b(y);\n",
-            "\n", // expand
             "\n", // context ellipsis
             "    c(y);\n",
             "    d(x);\n",
             "\n", // supporting diagnostic
             "}",
-            "\n", // expand
         )
     );
 
@@ -331,7 +321,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
     editor.update(cx, |editor, cx| {
         assert_eq!(
             editor.selections.display_ranges(cx),
-            [DisplayPoint::new(DisplayRow(22), 6)..DisplayPoint::new(DisplayRow(22), 6)]
+            [DisplayPoint::new(DisplayRow(19), 6)..DisplayPoint::new(DisplayRow(19), 6)]
         );
     });
 
@@ -380,14 +370,14 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(8), EXCERPT_HEADER.into()),
-            (DisplayRow(10), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(15), FILE_HEADER.into()),
-            (DisplayRow(19), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(32), EXCERPT_HEADER.into()),
-            (DisplayRow(34), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(43), EXCERPT_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(7), EXCERPT_HEADER.into()),
+            (DisplayRow(8), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(13), FILE_HEADER.into()),
+            (DisplayRow(15), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(28), EXCERPT_HEADER.into()),
+            (DisplayRow(29), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(38), EXCERPT_HEADER.into()),
         ]
     );
 
@@ -402,7 +392,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n", // primary message
             "\n", // padding
-            "\n", // expand
             "const a: i32 = 'a';\n",
             "\n", // supporting diagnostic
             "const b: i32 = c;\n",
@@ -410,7 +399,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 2
             "\n", // primary message
             "\n", // padding
-            "\n", // expand
             "const a: i32 = 'a';\n",
             "const b: i32 = c;\n",
             "\n", // supporting diagnostic
@@ -422,8 +410,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n", // primary message
             "\n", // padding
-            "\n", // expand
-            "\n", // expand
             "    let x = vec![];\n",
             "    let y = vec![];\n",
             "\n", // supporting diagnostic
@@ -439,7 +425,6 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             // diagnostic group 2
             "\n", // primary message
             "\n", // filename
-            "\n", // expand
             "fn main() {\n",
             "    let x = vec![];\n",
             "\n", // supporting diagnostic
@@ -447,13 +432,11 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
             "    a(x);\n",
             "\n", // supporting diagnostic
             "    b(y);\n",
-            "\n", // expand
             "\n", // context ellipsis
             "    c(y);\n",
             "    d(x);\n",
             "\n", // supporting diagnostic
             "}",
-            "\n", // expand
         )
     );
 }
@@ -535,7 +518,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
         ]
     );
     assert_eq!(
@@ -546,9 +529,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n",     // primary message
             "\n",     // padding
-            "\n",     // expand
             "a();\n", //
-            "b();", "\n", // expand
+            "b();",
         )
     );
 
@@ -584,9 +566,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(7), EXCERPT_HEADER.into()),
-            (DisplayRow(9), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(6), EXCERPT_HEADER.into()),
+            (DisplayRow(7), DIAGNOSTIC_HEADER.into()),
         ]
     );
     assert_eq!(
@@ -597,10 +579,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n",     // primary message
             "\n",     // padding
-            "\n",     // expand
             "a();\n", // location
             "b();\n", //
-            "\n",     // expand
             "\n",     // collapsed context
             // diagnostic group 2
             "\n",     // primary message
@@ -608,7 +588,6 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             "a();\n", // context
             "b();\n", //
             "c();",   // context
-            "\n",     // expand
         )
     );
 
@@ -655,9 +634,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(8), EXCERPT_HEADER.into()),
-            (DisplayRow(10), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(7), EXCERPT_HEADER.into()),
+            (DisplayRow(8), DIAGNOSTIC_HEADER.into()),
         ]
     );
     assert_eq!(
@@ -668,11 +647,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n",     // primary message
             "\n",     // padding
-            "\n",     // expand
             "a();\n", // location
             "b();\n", //
             "c();\n", // context
-            "\n",     // expand
             "\n",     // collapsed context
             // diagnostic group 2
             "\n",     // primary message
@@ -680,7 +657,6 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             "b();\n", // context
             "c();\n", //
             "d();",   // context
-            "\n",     // expand
         )
     );
 
@@ -716,9 +692,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
         editor_blocks(&editor, cx),
         [
             (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(8), EXCERPT_HEADER.into()),
-            (DisplayRow(10), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(7), EXCERPT_HEADER.into()),
+            (DisplayRow(8), DIAGNOSTIC_HEADER.into()),
         ]
     );
     assert_eq!(
@@ -729,11 +705,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             // diagnostic group 1
             "\n",     // primary message
             "\n",     // padding
-            "\n",     // expand
             "b();\n", // location
             "c();\n", //
             "d();\n", // context
-            "\n",     // expand
             "\n",     // collapsed context
             // diagnostic group 2
             "\n",     // primary message
@@ -741,7 +715,6 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
             "c();\n", // context
             "d();\n", //
             "e();",   // context
-            "\n",     // expand
         )
     );
 }

crates/editor/src/actions.rs

@@ -1,6 +1,6 @@
 //! This module contains all actions supported by [`Editor`].
 use super::*;
-use gpui::{action_as, action_with_deprecated_aliases};
+use gpui::{action_as, action_with_deprecated_aliases, actions};
 use schemars::JsonSchema;
 use util::serde::default_true;
 #[derive(PartialEq, Clone, Deserialize, Default, JsonSchema)]
@@ -248,7 +248,7 @@ impl_actions!(
     ]
 );
 
-gpui::actions!(
+actions!(
     editor,
     [
         AcceptEditPrediction,
@@ -404,6 +404,7 @@ gpui::actions!(
         ShowCharacterPalette,
         ShowEditPrediction,
         ShowSignatureHelp,
+        ShowWordCompletions,
         ShuffleLines,
         SortLinesCaseInsensitive,
         SortLinesCaseSensitive,

crates/editor/src/display_map.rs

@@ -118,10 +118,8 @@ impl DisplayMap {
         font: Font,
         font_size: Pixels,
         wrap_width: Option<Pixels>,
-        show_excerpt_controls: bool,
         buffer_header_height: u32,
         excerpt_header_height: u32,
-        excerpt_footer_height: u32,
         fold_placeholder: FoldPlaceholder,
         cx: &mut Context<Self>,
     ) -> Self {
@@ -134,13 +132,7 @@ impl DisplayMap {
         let (fold_map, snapshot) = FoldMap::new(snapshot);
         let (tab_map, snapshot) = TabMap::new(snapshot, tab_size);
         let (wrap_map, snapshot) = WrapMap::new(snapshot, font, font_size, wrap_width, cx);
-        let block_map = BlockMap::new(
-            snapshot,
-            show_excerpt_controls,
-            buffer_header_height,
-            excerpt_header_height,
-            excerpt_footer_height,
-        );
+        let block_map = BlockMap::new(snapshot, buffer_header_height, excerpt_header_height);
 
         cx.observe(&wrap_map, |_, _, cx| cx.notify()).detach();
 
@@ -555,10 +547,6 @@ impl DisplayMap {
     pub fn is_rewrapping(&self, cx: &gpui::App) -> bool {
         self.wrap_map.read(cx).is_rewrapping()
     }
-
-    pub fn show_excerpt_controls(&self) -> bool {
-        self.block_map.show_excerpt_controls()
-    }
 }
 
 #[derive(Debug, Default)]
@@ -1102,8 +1090,8 @@ impl DisplaySnapshot {
             .map(|(row, block)| (DisplayRow(row), block))
     }
 
-    pub fn sticky_header_excerpt(&self, row: DisplayRow) -> Option<StickyHeaderExcerpt<'_>> {
-        self.block_snapshot.sticky_header_excerpt(row.0)
+    pub fn sticky_header_excerpt(&self, row: f32) -> Option<StickyHeaderExcerpt<'_>> {
+        self.block_snapshot.sticky_header_excerpt(row)
     }
 
     pub fn block_for_id(&self, id: BlockId) -> Option<Block> {
@@ -1301,10 +1289,6 @@ impl DisplaySnapshot {
         self.block_snapshot.buffer_header_height
     }
 
-    pub fn excerpt_footer_height(&self) -> u32 {
-        self.block_snapshot.excerpt_footer_height
-    }
-
     pub fn excerpt_header_height(&self) -> u32 {
         self.block_snapshot.excerpt_header_height
     }
@@ -1514,10 +1498,8 @@ pub mod tests {
                 font,
                 font_size,
                 wrap_width,
-                true,
                 buffer_start_excerpt_header_height,
                 excerpt_header_height,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -1764,10 +1746,8 @@ pub mod tests {
                     font("Helvetica"),
                     font_size,
                     wrap_width,
-                    true,
                     1,
                     1,
-                    0,
                     FoldPlaceholder::test(),
                     cx,
                 )
@@ -1875,10 +1855,8 @@ pub mod tests {
                 font("Helvetica"),
                 font_size,
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -1938,8 +1916,6 @@ pub mod tests {
                 font("Helvetica"),
                 font_size,
                 None,
-                true,
-                1,
                 1,
                 1,
                 FoldPlaceholder::test(),
@@ -2032,8 +2008,6 @@ pub mod tests {
                 font("Helvetica"),
                 font_size,
                 None,
-                true,
-                1,
                 1,
                 1,
                 FoldPlaceholder::test(),
@@ -2134,10 +2108,8 @@ pub mod tests {
                 font("Courier"),
                 px(16.0),
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -2239,10 +2211,8 @@ pub mod tests {
                 font("Courier"),
                 px(16.0),
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -2328,10 +2298,8 @@ pub mod tests {
                 font("Courier"),
                 px(16.0),
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -2472,10 +2440,8 @@ pub mod tests {
                 font("Courier"),
                 font_size,
                 Some(px(40.0)),
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -2556,8 +2522,6 @@ pub mod tests {
                 font("Courier"),
                 font_size,
                 None,
-                true,
-                1,
                 1,
                 1,
                 FoldPlaceholder::test(),
@@ -2682,10 +2646,8 @@ pub mod tests {
                 font("Helvetica"),
                 font_size,
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             );
@@ -2721,10 +2683,8 @@ pub mod tests {
                 font("Helvetica"),
                 font_size,
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )
@@ -2798,10 +2758,8 @@ pub mod tests {
                 font("Helvetica"),
                 font_size,
                 None,
-                true,
                 1,
                 1,
-                0,
                 FoldPlaceholder::test(),
                 cx,
             )

crates/editor/src/display_map/block_map.rs

@@ -37,10 +37,8 @@ pub struct BlockMap {
     custom_blocks: Vec<Arc<CustomBlock>>,
     custom_blocks_by_id: TreeMap<CustomBlockId, Arc<CustomBlock>>,
     transforms: RefCell<SumTree<Transform>>,
-    show_excerpt_controls: bool,
     buffer_header_height: u32,
     excerpt_header_height: u32,
-    excerpt_footer_height: u32,
     pub(super) folded_buffers: HashSet<BufferId>,
 }
 
@@ -58,7 +56,6 @@ pub struct BlockSnapshot {
     custom_blocks_by_id: TreeMap<CustomBlockId, Arc<CustomBlock>>,
     pub(super) buffer_header_height: u32,
     pub(super) excerpt_header_height: u32,
-    pub(super) excerpt_footer_height: u32,
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -285,14 +282,12 @@ pub enum Block {
         first_excerpt: ExcerptInfo,
         prev_excerpt: Option<ExcerptInfo>,
         height: u32,
-        show_excerpt_controls: bool,
     },
     ExcerptBoundary {
         prev_excerpt: Option<ExcerptInfo>,
         next_excerpt: Option<ExcerptInfo>,
         height: u32,
         starts_new_buffer: bool,
-        show_excerpt_controls: bool,
     },
 }
 
@@ -362,13 +357,11 @@ impl Debug for Block {
                 first_excerpt,
                 prev_excerpt,
                 height,
-                show_excerpt_controls,
             } => f
                 .debug_struct("FoldedBuffer")
                 .field("first_excerpt", &first_excerpt)
                 .field("prev_excerpt", prev_excerpt)
                 .field("height", height)
-                .field("show_excerpt_controls", show_excerpt_controls)
                 .finish(),
             Self::ExcerptBoundary {
                 starts_new_buffer,
@@ -413,10 +406,8 @@ pub struct BlockRows<'a> {
 impl BlockMap {
     pub fn new(
         wrap_snapshot: WrapSnapshot,
-        show_excerpt_controls: bool,
         buffer_header_height: u32,
         excerpt_header_height: u32,
-        excerpt_footer_height: u32,
     ) -> Self {
         let row_count = wrap_snapshot.max_point().row() + 1;
         let mut transforms = SumTree::default();
@@ -428,10 +419,8 @@ impl BlockMap {
             folded_buffers: HashSet::default(),
             transforms: RefCell::new(transforms),
             wrap_snapshot: RefCell::new(wrap_snapshot.clone()),
-            show_excerpt_controls,
             buffer_header_height,
             excerpt_header_height,
-            excerpt_footer_height,
         };
         map.sync(
             &wrap_snapshot,
@@ -454,7 +443,6 @@ impl BlockMap {
                 custom_blocks_by_id: self.custom_blocks_by_id.clone(),
                 buffer_header_height: self.buffer_header_height,
                 excerpt_header_height: self.excerpt_header_height,
-                excerpt_footer_height: self.excerpt_footer_height,
             },
         }
     }
@@ -650,8 +638,6 @@ impl BlockMap {
 
             if buffer.show_headers() {
                 blocks_in_edit.extend(BlockMap::header_and_footer_blocks(
-                    self.show_excerpt_controls,
-                    self.excerpt_footer_height,
                     self.buffer_header_height,
                     self.excerpt_header_height,
                     buffer,
@@ -722,13 +708,7 @@ impl BlockMap {
         }
     }
 
-    pub fn show_excerpt_controls(&self) -> bool {
-        self.show_excerpt_controls
-    }
-
     fn header_and_footer_blocks<'a, R, T>(
-        show_excerpt_controls: bool,
-        excerpt_footer_height: u32,
         buffer_header_height: u32,
         excerpt_header_height: u32,
         buffer: &'a multi_buffer::MultiBufferSnapshot,
@@ -774,11 +754,6 @@ impl BlockMap {
                 .filter(|prev| !folded_buffers.contains(&prev.buffer_id));
 
             let mut height = 0;
-            if prev_excerpt.is_some() {
-                if show_excerpt_controls {
-                    height += excerpt_footer_height;
-                }
-            }
 
             if let Some(new_buffer_id) = new_buffer_id {
                 let first_excerpt = excerpt_boundary.next.clone().unwrap();
@@ -812,7 +787,6 @@ impl BlockMap {
                         Block::FoldedBuffer {
                             prev_excerpt,
                             height: height + buffer_header_height,
-                            show_excerpt_controls,
                             first_excerpt,
                         },
                     ));
@@ -822,9 +796,6 @@ impl BlockMap {
             if excerpt_boundary.next.is_some() {
                 if new_buffer_id.is_some() {
                     height += buffer_header_height;
-                    if show_excerpt_controls {
-                        height += excerpt_header_height;
-                    }
                 } else {
                     height += excerpt_header_height;
                 }
@@ -845,7 +816,6 @@ impl BlockMap {
                     next_excerpt: excerpt_boundary.next,
                     height,
                     starts_new_buffer: new_buffer_id.is_some(),
-                    show_excerpt_controls,
                 },
             ))
         })
@@ -1432,7 +1402,8 @@ impl BlockSnapshot {
         })
     }
 
-    pub fn sticky_header_excerpt(&self, top_row: u32) -> Option<StickyHeaderExcerpt<'_>> {
+    pub fn sticky_header_excerpt(&self, position: f32) -> Option<StickyHeaderExcerpt<'_>> {
+        let top_row = position as u32;
         let mut cursor = self.transforms.cursor::<BlockRow>(&());
         cursor.seek(&BlockRow(top_row), Bias::Left, &());
 
@@ -1445,19 +1416,13 @@ impl BlockSnapshot {
                     prev_excerpt,
                     next_excerpt,
                     starts_new_buffer,
-                    show_excerpt_controls,
                     ..
                 }) => {
-                    let matches_start = if *show_excerpt_controls && prev_excerpt.is_some() {
-                        start < top_row
-                    } else {
-                        start <= top_row
-                    };
+                    let matches_start = (start as f32) < position;
 
                     if matches_start && top_row <= end {
                         return next_excerpt.as_ref().map(|excerpt| StickyHeaderExcerpt {
                             next_buffer_row: None,
-                            next_excerpt_controls_present: *show_excerpt_controls,
                             excerpt,
                         });
                     }
@@ -1467,7 +1432,6 @@ impl BlockSnapshot {
                     return prev_excerpt.as_ref().map(|excerpt| StickyHeaderExcerpt {
                         excerpt,
                         next_buffer_row,
-                        next_excerpt_controls_present: *show_excerpt_controls,
                     });
                 }
                 Some(Block::FoldedBuffer {
@@ -1476,7 +1440,6 @@ impl BlockSnapshot {
                 }) if top_row <= start => {
                     return Some(StickyHeaderExcerpt {
                         next_buffer_row: Some(end),
-                        next_excerpt_controls_present: false,
                         excerpt,
                     });
                 }
@@ -1785,7 +1748,6 @@ impl BlockChunks<'_> {
 
 pub struct StickyHeaderExcerpt<'a> {
     pub excerpt: &'a ExcerptInfo,
-    pub next_excerpt_controls_present: bool,
     pub next_buffer_row: Option<u32>,
 }
 
@@ -2066,7 +2028,7 @@ mod tests {
         let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
         let (wrap_map, wraps_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
-        let mut block_map = BlockMap::new(wraps_snapshot.clone(), true, 1, 1, 1);
+        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
         let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
         let block_ids = writer.insert(vec![
@@ -2279,14 +2241,11 @@ mod tests {
         let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
         let (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font, font_size, Some(wrap_width), cx);
 
-        let block_map = BlockMap::new(wraps_snapshot.clone(), true, 1, 1, 1);
+        let block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
         let snapshot = block_map.read(wraps_snapshot, Default::default());
 
         // Each excerpt has a header above and footer below. Excerpts are also *separated* by a newline.
-        assert_eq!(
-            snapshot.text(),
-            "\n\nBuff\ner 1\n\n\n\nBuff\ner 2\n\n\n\nBuff\ner 3\n"
-        );
+        assert_eq!(snapshot.text(), "\nBuff\ner 1\n\nBuff\ner 2\n\nBuff\ner 3");
 
         let blocks: Vec<_> = snapshot
             .blocks_in_range(0..u32::MAX)
@@ -2295,10 +2254,9 @@ mod tests {
         assert_eq!(
             blocks,
             vec![
-                (0..2, BlockId::ExcerptBoundary(Some(excerpt_ids[0]))), // path, header
-                (4..7, BlockId::ExcerptBoundary(Some(excerpt_ids[1]))), // footer, path, header
-                (9..12, BlockId::ExcerptBoundary(Some(excerpt_ids[2]))), // footer, path, header
-                (14..15, BlockId::ExcerptBoundary(None)),               // footer
+                (0..1, BlockId::ExcerptBoundary(Some(excerpt_ids[0]))), // path, header
+                (3..4, BlockId::ExcerptBoundary(Some(excerpt_ids[1]))), // path, header
+                (6..7, BlockId::ExcerptBoundary(Some(excerpt_ids[2]))), // path, header
             ]
         );
     }
@@ -2317,7 +2275,7 @@ mod tests {
         let (_tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
         let (_wrap_map, wraps_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
-        let mut block_map = BlockMap::new(wraps_snapshot.clone(), false, 1, 1, 0);
+        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
         let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
         let block_ids = writer.insert(vec![
@@ -2420,7 +2378,7 @@ mod tests {
         let (_, wraps_snapshot) = cx.update(|cx| {
             WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), Some(px(60.)), cx)
         });
-        let mut block_map = BlockMap::new(wraps_snapshot.clone(), true, 1, 1, 0);
+        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
         let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
         writer.insert(vec![
@@ -2464,7 +2422,7 @@ mod tests {
         let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, tab_size);
         let (wrap_map, wraps_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
-        let mut block_map = BlockMap::new(wraps_snapshot.clone(), false, 1, 1, 0);
+        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
         let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
         let replace_block_id = writer.insert(vec![BlockProperties {
@@ -2631,12 +2589,12 @@ mod tests {
         let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
         let (_, wrap_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
-        let mut block_map = BlockMap::new(wrap_snapshot.clone(), true, 2, 1, 1);
+        let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
         let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default());
 
         assert_eq!(
             blocks_snapshot.text(),
-            "\n\n\n111\n\n\n\n\n222\n\n\n333\n\n\n444\n\n\n\n\n555\n\n\n666\n"
+            "\n\n111\n\n\n222\n\n333\n\n444\n\n\n555\n\n666"
         );
         assert_eq!(
             blocks_snapshot
@@ -2644,30 +2602,21 @@ mod tests {
                 .map(|i| i.buffer_row)
                 .collect::<Vec<_>>(),
             vec![
-                None,
                 None,
                 None,
                 Some(0),
                 None,
                 None,
-                None,
-                None,
                 Some(1),
                 None,
-                None,
                 Some(2),
                 None,
-                None,
                 Some(3),
                 None,
                 None,
-                None,
-                None,
                 Some(4),
                 None,
-                None,
                 Some(5),
-                None,
             ]
         );
 
@@ -2715,7 +2664,7 @@ mod tests {
         let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default());
         assert_eq!(
             blocks_snapshot.text(),
-            "\n\n\n111\n\n\n\n\n\n222\n\n\n\n333\n\n\n444\n\n\n\n\n\n\n555\n\n\n666\n\n"
+            "\n\n111\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
         );
         assert_eq!(
             blocks_snapshot
@@ -2723,35 +2672,26 @@ mod tests {
                 .map(|i| i.buffer_row)
                 .collect::<Vec<_>>(),
             vec![
-                None,
                 None,
                 None,
                 Some(0),
                 None,
                 None,
                 None,
-                None,
-                None,
                 Some(1),
                 None,
                 None,
-                None,
                 Some(2),
                 None,
-                None,
                 Some(3),
                 None,
                 None,
                 None,
                 None,
-                None,
-                None,
                 Some(4),
                 None,
-                None,
                 Some(5),
                 None,
-                None,
             ]
         );
 
@@ -2793,7 +2733,7 @@ mod tests {
         );
         assert_eq!(
             blocks_snapshot.text(),
-            "\n\n\n\n\n\n222\n\n\n\n333\n\n\n444\n\n\n\n\n\n\n555\n\n\n666\n\n"
+            "\n\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
         );
         assert_eq!(
             blocks_snapshot
@@ -2806,27 +2746,20 @@ mod tests {
                 None,
                 None,
                 None,
-                None,
                 Some(1),
                 None,
                 None,
-                None,
                 Some(2),
                 None,
-                None,
                 Some(3),
                 None,
                 None,
                 None,
                 None,
-                None,
-                None,
                 Some(4),
                 None,
-                None,
                 Some(5),
                 None,
-                None,
             ]
         );
 
@@ -2862,7 +2795,7 @@ mod tests {
                 .count(),
             "Should have two folded blocks, producing headers"
         );
-        assert_eq!(blocks_snapshot.text(), "\n\n\n\n\n\n\n\n555\n\n\n666\n\n");
+        assert_eq!(blocks_snapshot.text(), "\n\n\n\n\n\n\n555\n\n666\n");
         assert_eq!(
             blocks_snapshot
                 .row_infos(BlockRow(0))
@@ -2876,13 +2809,10 @@ mod tests {
                 None,
                 None,
                 None,
-                None,
                 Some(4),
                 None,
-                None,
                 Some(5),
                 None,
-                None,
             ]
         );
 
@@ -2917,7 +2847,7 @@ mod tests {
         );
         assert_eq!(
             blocks_snapshot.text(),
-            "\n\n\n\n111\n\n\n\n\n\n\n\n555\n\n\n666\n\n",
+            "\n\n\n111\n\n\n\n\n\n555\n\n666\n",
             "Should have extra newline for 111 buffer, due to a new block added when it was folded"
         );
         assert_eq!(
@@ -2929,21 +2859,16 @@ mod tests {
                 None,
                 None,
                 None,
-                None,
                 Some(0),
                 None,
                 None,
                 None,
                 None,
                 None,
-                None,
-                None,
                 Some(4),
                 None,
-                None,
                 Some(5),
                 None,
-                None,
             ]
         );
 
@@ -2974,7 +2899,7 @@ mod tests {
 
         assert_eq!(
             blocks_snapshot.text(),
-            "\n\n\n\n111\n\n\n\n\n",
+            "\n\n\n111\n\n\n\n",
             "Should have a single, first buffer left after folding"
         );
         assert_eq!(
@@ -2982,18 +2907,7 @@ mod tests {
                 .row_infos(BlockRow(0))
                 .map(|i| i.buffer_row)
                 .collect::<Vec<_>>(),
-            vec![
-                None,
-                None,
-                None,
-                None,
-                Some(0),
-                None,
-                None,
-                None,
-                None,
-                None,
-            ]
+            vec![None, None, None, Some(0), None, None, None, None,]
         );
     }
 
@@ -3020,10 +2934,10 @@ mod tests {
         let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
         let (_, wrap_snapshot) =
             cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
-        let mut block_map = BlockMap::new(wrap_snapshot.clone(), true, 2, 1, 1);
+        let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
         let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default());
 
-        assert_eq!(blocks_snapshot.text(), "\n\n\n111\n");
+        assert_eq!(blocks_snapshot.text(), "\n\n111");
 
         let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default());
         buffer.read_with(cx, |buffer, cx| {
@@ -3077,11 +2991,9 @@ mod tests {
         let font_size = px(14.0);
         let buffer_start_header_height = rng.gen_range(1..=5);
         let excerpt_header_height = rng.gen_range(1..=5);
-        let excerpt_footer_height = rng.gen_range(1..=5);
 
         log::info!("Wrap width: {:?}", wrap_width);
         log::info!("Excerpt Header Height: {:?}", excerpt_header_height);
-        log::info!("Excerpt Footer Height: {:?}", excerpt_footer_height);
         let is_singleton = rng.gen();
         let buffer = if is_singleton {
             let len = rng.gen_range(0..10);
@@ -3108,10 +3020,8 @@ mod tests {
             cx.update(|cx| WrapMap::new(tab_snapshot, font, font_size, wrap_width, cx));
         let mut block_map = BlockMap::new(
             wraps_snapshot,
-            true,
             buffer_start_header_height,
             excerpt_header_height,
-            excerpt_footer_height,
         );
 
         for _ in 0..operations {
@@ -3329,8 +3239,6 @@ mod tests {
 
             // Note that this needs to be synced with the related section in BlockMap::sync
             expected_blocks.extend(BlockMap::header_and_footer_blocks(
-                true,
-                excerpt_footer_height,
                 buffer_start_header_height,
                 excerpt_header_height,
                 &buffer_snapshot,

crates/editor/src/display_map/wrap_map.rs

@@ -983,6 +983,7 @@ impl Iterator for WrapRows<'_> {
                 buffer_row: None,
                 multibuffer_row: None,
                 diff_status,
+                expand_info: None,
             }
         } else {
             buffer_row

crates/editor/src/editor.rs

@@ -101,11 +101,12 @@ use itertools::Itertools;
 use language::{
     language_settings::{
         self, all_language_settings, language_settings, InlayHintSettings, RewrapBehavior,
+        WordsCompletionMode,
     },
     point_from_lsp, text_diff_with_options, AutoindentMode, BracketMatch, BracketPair, Buffer,
     Capability, CharKind, CodeLabel, CursorShape, Diagnostic, DiffOptions, EditPredictionsMode,
     EditPreview, HighlightedText, IndentKind, IndentSize, Language, OffsetRangeExt, Point,
-    Selection, SelectionGoal, TextObject, TransactionId, TreeSitterOptions,
+    Selection, SelectionGoal, TextObject, TransactionId, TreeSitterOptions, WordsQuery,
 };
 use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
@@ -195,7 +196,6 @@ use crate::signature_help::{SignatureHelpHiddenBy, SignatureHelpState};
 
 pub const FILE_HEADER_HEIGHT: u32 = 2;
 pub const MULTI_BUFFER_EXCERPT_HEADER_HEIGHT: u32 = 1;
-pub const MULTI_BUFFER_EXCERPT_FOOTER_HEIGHT: u32 = 1;
 pub const DEFAULT_MULTIBUFFER_CONTEXT: u32 = 2;
 const CURSOR_BLINK_INTERVAL: Duration = Duration::from_millis(500);
 const MAX_LINE_LEN: usize = 1024;
@@ -1091,7 +1091,6 @@ impl Editor {
             EditorMode::SingleLine { auto_width: false },
             buffer,
             None,
-            false,
             window,
             cx,
         )
@@ -1100,7 +1099,7 @@ impl Editor {
     pub fn multi_line(window: &mut Window, cx: &mut Context<Self>) -> Self {
         let buffer = cx.new(|cx| Buffer::local("", cx));
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(EditorMode::Full, buffer, None, false, window, cx)
+        Self::new(EditorMode::Full, buffer, None, window, cx)
     }
 
     pub fn auto_width(window: &mut Window, cx: &mut Context<Self>) -> Self {
@@ -1110,7 +1109,6 @@ impl Editor {
             EditorMode::SingleLine { auto_width: true },
             buffer,
             None,
-            false,
             window,
             cx,
         )
@@ -1123,7 +1121,6 @@ impl Editor {
             EditorMode::AutoHeight { max_lines },
             buffer,
             None,
-            false,
             window,
             cx,
         )
@@ -1136,33 +1133,23 @@ impl Editor {
         cx: &mut Context<Self>,
     ) -> Self {
         let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(EditorMode::Full, buffer, project, false, window, cx)
+        Self::new(EditorMode::Full, buffer, project, window, cx)
     }
 
     pub fn for_multibuffer(
         buffer: Entity<MultiBuffer>,
         project: Option<Entity<Project>>,
-        show_excerpt_controls: bool,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        Self::new(
-            EditorMode::Full,
-            buffer,
-            project,
-            show_excerpt_controls,
-            window,
-            cx,
-        )
+        Self::new(EditorMode::Full, buffer, project, window, cx)
     }
 
     pub fn clone(&self, window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let show_excerpt_controls = self.display_map.read(cx).show_excerpt_controls();
         let mut clone = Self::new(
             self.mode,
             self.buffer.clone(),
             self.project.clone(),
-            show_excerpt_controls,
             window,
             cx,
         );
@@ -1182,7 +1169,6 @@ impl Editor {
         mode: EditorMode,
         buffer: Entity<MultiBuffer>,
         project: Option<Entity<Project>>,
-        show_excerpt_controls: bool,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
@@ -1227,10 +1213,8 @@ impl Editor {
                 style.font(),
                 font_size,
                 None,
-                show_excerpt_controls,
                 FILE_HEADER_HEIGHT,
                 MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
-                MULTI_BUFFER_EXCERPT_FOOTER_HEIGHT,
                 fold_placeholder,
                 cx,
             )
@@ -3993,20 +3977,34 @@ impl Editor {
         }))
     }
 
+    pub fn show_word_completions(
+        &mut self,
+        _: &ShowWordCompletions,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
+        self.open_completions_menu(true, None, window, cx);
+    }
+
     pub fn show_completions(
         &mut self,
         options: &ShowCompletions,
         window: &mut Window,
         cx: &mut Context<Self>,
+    ) {
+        self.open_completions_menu(false, options.trigger.as_deref(), window, cx);
+    }
+
+    fn open_completions_menu(
+        &mut self,
+        ignore_completion_provider: bool,
+        trigger: Option<&str>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
     ) {
         if self.pending_rename.is_some() {
             return;
         }
-
-        let Some(provider) = self.completion_provider.as_ref() else {
-            return;
-        };
-
         if !self.snippet_stack.is_empty() && self.context_menu.borrow().as_ref().is_some() {
             return;
         }
@@ -4021,22 +4019,21 @@ impl Editor {
             } else {
                 return;
             };
-        let show_completion_documentation = buffer
-            .read(cx)
-            .snapshot()
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let show_completion_documentation = buffer_snapshot
             .settings_at(buffer_position, cx)
             .show_completion_documentation;
 
         let query = Self::completion_query(&self.buffer.read(cx).read(cx), position);
 
-        let trigger_kind = match &options.trigger {
+        let trigger_kind = match trigger {
             Some(trigger) if buffer.read(cx).completion_triggers().contains(trigger) => {
                 CompletionTriggerKind::TRIGGER_CHARACTER
             }
             _ => CompletionTriggerKind::INVOKED,
         };
         let completion_context = CompletionContext {
-            trigger_character: options.trigger.as_ref().and_then(|trigger| {
+            trigger_character: trigger.and_then(|trigger| {
                 if trigger_kind == CompletionTriggerKind::TRIGGER_CHARACTER {
                     Some(String::from(trigger))
                 } else {
@@ -4045,9 +4042,87 @@ impl Editor {
             }),
             trigger_kind,
         };
-        let completions =
-            provider.completions(&buffer, buffer_position, completion_context, window, cx);
-        let sort_completions = provider.sort_completions();
+
+        let (old_range, word_kind) = buffer_snapshot.surrounding_word(buffer_position);
+        let (old_range, word_to_exclude) = if word_kind == Some(CharKind::Word) {
+            let word_to_exclude = buffer_snapshot
+                .text_for_range(old_range.clone())
+                .collect::<String>();
+            (
+                buffer_snapshot.anchor_before(old_range.start)
+                    ..buffer_snapshot.anchor_after(old_range.end),
+                Some(word_to_exclude),
+            )
+        } else {
+            (buffer_position..buffer_position, None)
+        };
+
+        let completion_settings = language_settings(
+            buffer_snapshot
+                .language_at(buffer_position)
+                .map(|language| language.name()),
+            buffer_snapshot.file(),
+            cx,
+        )
+        .completions;
+
+        // The document can be large, so stay in reasonable bounds when searching for words,
+        // otherwise completion pop-up might be slow to appear.
+        const WORD_LOOKUP_ROWS: u32 = 5_000;
+        let buffer_row = text::ToPoint::to_point(&buffer_position, &buffer_snapshot).row;
+        let min_word_search = buffer_snapshot.clip_point(
+            Point::new(buffer_row.saturating_sub(WORD_LOOKUP_ROWS), 0),
+            Bias::Left,
+        );
+        let max_word_search = buffer_snapshot.clip_point(
+            Point::new(buffer_row + WORD_LOOKUP_ROWS, 0).min(buffer_snapshot.max_point()),
+            Bias::Right,
+        );
+        let word_search_range = buffer_snapshot.point_to_offset(min_word_search)
+            ..buffer_snapshot.point_to_offset(max_word_search);
+
+        let provider = self
+            .completion_provider
+            .as_ref()
+            .filter(|_| !ignore_completion_provider);
+        let skip_digits = query
+            .as_ref()
+            .map_or(true, |query| !query.chars().any(|c| c.is_digit(10)));
+
+        let (mut words, provided_completions) = match provider {
+            Some(provider) => {
+                let completions =
+                    provider.completions(&buffer, buffer_position, completion_context, window, cx);
+
+                let words = match completion_settings.words {
+                    WordsCompletionMode::Disabled => Task::ready(HashMap::default()),
+                    WordsCompletionMode::Enabled | WordsCompletionMode::Fallback => cx
+                        .background_spawn(async move {
+                            buffer_snapshot.words_in_range(WordsQuery {
+                                fuzzy_contents: None,
+                                range: word_search_range,
+                                skip_digits,
+                            })
+                        }),
+                };
+
+                (words, completions)
+            }
+            None => (
+                cx.background_spawn(async move {
+                    buffer_snapshot.words_in_range(WordsQuery {
+                        fuzzy_contents: None,
+                        range: word_search_range,
+                        skip_digits,
+                    })
+                }),
+                Task::ready(Ok(None)),
+            ),
+        };
+
+        let sort_completions = provider
+            .as_ref()
+            .map_or(true, |provider| provider.sort_completions());
 
         let id = post_inc(&mut self.next_completion_id);
         let task = cx.spawn_in(window, |editor, mut cx| {
@@ -4055,8 +4130,37 @@ impl Editor {
                 editor.update(&mut cx, |this, _| {
                     this.completion_tasks.retain(|(task_id, _)| *task_id >= id);
                 })?;
-                let completions = completions.await.log_err();
-                let menu = if let Some(completions) = completions {
+
+                let mut completions = Vec::new();
+                if let Some(provided_completions) = provided_completions.await.log_err().flatten() {
+                    completions.extend(provided_completions);
+                    if completion_settings.words == WordsCompletionMode::Fallback {
+                        words = Task::ready(HashMap::default());
+                    }
+                }
+
+                let mut words = words.await;
+                if let Some(word_to_exclude) = &word_to_exclude {
+                    words.remove(word_to_exclude);
+                }
+                for lsp_completion in &completions {
+                    words.remove(&lsp_completion.new_text);
+                }
+                completions.extend(words.into_iter().map(|(word, word_range)| Completion {
+                    old_range: old_range.clone(),
+                    new_text: word.clone(),
+                    label: CodeLabel::plain(word, None),
+                    documentation: None,
+                    source: CompletionSource::BufferWord {
+                        word_range,
+                        resolved: false,
+                    },
+                    confirm: None,
+                }));
+
+                let menu = if completions.is_empty() {
+                    None
+                } else {
                     let mut menu = CompletionsMenu::new(
                         id,
                         sort_completions,
@@ -4070,8 +4174,6 @@ impl Editor {
                         .await;
 
                     menu.visible().then_some(menu)
-                } else {
-                    None
                 };
 
                 editor.update_in(&mut cx, |editor, window, cx| {
@@ -4112,7 +4214,7 @@ impl Editor {
                     }
                 })?;
 
-                Ok::<_, anyhow::Error>(())
+                anyhow::Ok(())
             }
             .log_err()
         });
@@ -4600,8 +4702,8 @@ impl Editor {
 
         workspace.update_in(&mut cx, |workspace, window, cx| {
             let project = workspace.project().clone();
-            let editor = cx
-                .new(|cx| Editor::for_multibuffer(excerpt_buffer, Some(project), true, window, cx));
+            let editor =
+                cx.new(|cx| Editor::for_multibuffer(excerpt_buffer, Some(project), window, cx));
             workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx);
             editor.update(cx, |editor, cx| {
                 editor.highlight_background::<Self>(
@@ -12288,7 +12390,6 @@ impl Editor {
             Editor::for_multibuffer(
                 excerpt_buffer,
                 Some(workspace.project().clone()),
-                true,
                 window,
                 cx,
             )
@@ -16838,7 +16939,7 @@ pub trait CompletionProvider {
         trigger: CompletionContext,
         window: &mut Window,
         cx: &mut Context<Editor>,
-    ) -> Task<Result<Vec<Completion>>>;
+    ) -> Task<Result<Option<Vec<Completion>>>>;
 
     fn resolve_completions(
         &self,
@@ -17078,15 +17179,25 @@ impl CompletionProvider for Entity<Project> {
         options: CompletionContext,
         _window: &mut Window,
         cx: &mut Context<Editor>,
-    ) -> Task<Result<Vec<Completion>>> {
+    ) -> Task<Result<Option<Vec<Completion>>>> {
         self.update(cx, |project, cx| {
             let snippets = snippet_completions(project, buffer, buffer_position, cx);
             let project_completions = project.completions(buffer, buffer_position, options, cx);
             cx.background_spawn(async move {
-                let mut completions = project_completions.await?;
                 let snippets_completions = snippets.await?;
-                completions.extend(snippets_completions);
-                Ok(completions)
+                match project_completions.await? {
+                    Some(mut completions) => {
+                        completions.extend(snippets_completions);
+                        Ok(Some(completions))
+                    }
+                    None => {
+                        if snippets_completions.is_empty() {
+                            Ok(None)
+                        } else {
+                            Ok(Some(snippets_completions))
+                        }
+                    }
+                }
             })
         })
     }

crates/editor/src/editor_tests.rs

@@ -16,7 +16,8 @@ use gpui::{
 use indoc::indoc;
 use language::{
     language_settings::{
-        AllLanguageSettings, AllLanguageSettingsContent, LanguageSettingsContent, PrettierSettings,
+        AllLanguageSettings, AllLanguageSettingsContent, CompletionSettings,
+        LanguageSettingsContent, PrettierSettings,
     },
     BracketPairConfig,
     Capability::ReadWrite,
@@ -30,7 +31,7 @@ use pretty_assertions::{assert_eq, assert_ne};
 use project::project_settings::{LspSettings, ProjectSettings};
 use project::FakeFs;
 use serde_json::{self, json};
-use std::{cell::RefCell, future::Future, rc::Rc, time::Instant};
+use std::{cell::RefCell, future::Future, rc::Rc, sync::atomic::AtomicBool, time::Instant};
 use std::{
     iter,
     sync::atomic::{self, AtomicUsize},
@@ -7675,7 +7676,6 @@ async fn test_multibuffer_format_during_save(cx: &mut TestAppContext) {
             EditorMode::Full,
             multi_buffer,
             Some(project.clone()),
-            true,
             window,
             cx,
         )
@@ -9194,6 +9194,225 @@ async fn test_completion(cx: &mut TestAppContext) {
     apply_additional_edits.await.unwrap();
 }
 
+#[gpui::test]
+async fn test_words_completion(cx: &mut TestAppContext) {
+    let lsp_fetch_timeout_ms = 10;
+    init_test(cx, |language_settings| {
+        language_settings.defaults.completions = Some(CompletionSettings {
+            words: WordsCompletionMode::Fallback,
+            lsp: true,
+            lsp_fetch_timeout_ms: 10,
+        });
+    });
+
+    let mut cx = EditorLspTestContext::new_rust(
+        lsp::ServerCapabilities {
+            completion_provider: Some(lsp::CompletionOptions {
+                trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
+                ..lsp::CompletionOptions::default()
+            }),
+            signature_help_provider: Some(lsp::SignatureHelpOptions::default()),
+            ..lsp::ServerCapabilities::default()
+        },
+        cx,
+    )
+    .await;
+
+    let throttle_completions = Arc::new(AtomicBool::new(false));
+
+    let lsp_throttle_completions = throttle_completions.clone();
+    let _completion_requests_handler =
+        cx.lsp
+            .server
+            .on_request::<lsp::request::Completion, _, _>(move |_, cx| {
+                let lsp_throttle_completions = lsp_throttle_completions.clone();
+                async move {
+                    if lsp_throttle_completions.load(atomic::Ordering::Acquire) {
+                        cx.background_executor()
+                            .timer(Duration::from_millis(lsp_fetch_timeout_ms * 10))
+                            .await;
+                    }
+                    Ok(Some(lsp::CompletionResponse::Array(vec![
+                        lsp::CompletionItem {
+                            label: "first".into(),
+                            ..lsp::CompletionItem::default()
+                        },
+                        lsp::CompletionItem {
+                            label: "last".into(),
+                            ..lsp::CompletionItem::default()
+                        },
+                    ])))
+                }
+            });
+
+    cx.set_state(indoc! {"
+        oneˇ
+        two
+        three
+    "});
+    cx.simulate_keystroke(".");
+    cx.executor().run_until_parked();
+    cx.condition(|editor, _| editor.context_menu_visible())
+        .await;
+    cx.update_editor(|editor, window, cx| {
+        if let Some(CodeContextMenu::Completions(menu)) = editor.context_menu.borrow_mut().as_ref()
+        {
+            assert_eq!(
+                completion_menu_entries(&menu),
+                &["first", "last"],
+                "When LSP server is fast to reply, no fallback word completions are used"
+            );
+        } else {
+            panic!("expected completion menu to be open");
+        }
+        editor.cancel(&Cancel, window, cx);
+    });
+    cx.executor().run_until_parked();
+    cx.condition(|editor, _| !editor.context_menu_visible())
+        .await;
+
+    throttle_completions.store(true, atomic::Ordering::Release);
+    cx.simulate_keystroke(".");
+    cx.executor()
+        .advance_clock(Duration::from_millis(lsp_fetch_timeout_ms * 2));
+    cx.executor().run_until_parked();
+    cx.condition(|editor, _| editor.context_menu_visible())
+        .await;
+    cx.update_editor(|editor, _, _| {
+        if let Some(CodeContextMenu::Completions(menu)) = editor.context_menu.borrow_mut().as_ref()
+        {
+            assert_eq!(completion_menu_entries(&menu), &["one", "three", "two"],
+                "When LSP server is slow, document words can be shown instead, if configured accordingly");
+        } else {
+            panic!("expected completion menu to be open");
+        }
+    });
+}
+
+#[gpui::test]
+async fn test_word_completions_do_not_duplicate_lsp_ones(cx: &mut TestAppContext) {
+    init_test(cx, |language_settings| {
+        language_settings.defaults.completions = Some(CompletionSettings {
+            words: WordsCompletionMode::Enabled,
+            lsp: true,
+            lsp_fetch_timeout_ms: 0,
+        });
+    });
+
+    let mut cx = EditorLspTestContext::new_rust(
+        lsp::ServerCapabilities {
+            completion_provider: Some(lsp::CompletionOptions {
+                trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
+                ..lsp::CompletionOptions::default()
+            }),
+            signature_help_provider: Some(lsp::SignatureHelpOptions::default()),
+            ..lsp::ServerCapabilities::default()
+        },
+        cx,
+    )
+    .await;
+
+    let _completion_requests_handler =
+        cx.lsp
+            .server
+            .on_request::<lsp::request::Completion, _, _>(move |_, _| async move {
+                Ok(Some(lsp::CompletionResponse::Array(vec![
+                    lsp::CompletionItem {
+                        label: "first".into(),
+                        ..lsp::CompletionItem::default()
+                    },
+                    lsp::CompletionItem {
+                        label: "last".into(),
+                        ..lsp::CompletionItem::default()
+                    },
+                ])))
+            });
+
+    cx.set_state(indoc! {"ˇ
+        first
+        last
+        second
+    "});
+    cx.simulate_keystroke(".");
+    cx.executor().run_until_parked();
+    cx.condition(|editor, _| editor.context_menu_visible())
+        .await;
+    cx.update_editor(|editor, window, cx| {
+        if let Some(CodeContextMenu::Completions(menu)) = editor.context_menu.borrow_mut().as_ref()
+        {
+            assert_eq!(
+                completion_menu_entries(&menu),
+                &["first", "last", "second"],
+                "Word completions that has the same edit as the any of the LSP ones, should not be proposed"
+            );
+        } else {
+            panic!("expected completion menu to be open");
+        }
+        editor.cancel(&Cancel, window, cx);
+    });
+}
+
+#[gpui::test]
+async fn test_word_completions_usually_skip_digits(cx: &mut TestAppContext) {
+    init_test(cx, |language_settings| {
+        language_settings.defaults.completions = Some(CompletionSettings {
+            words: WordsCompletionMode::Fallback,
+            lsp: false,
+            lsp_fetch_timeout_ms: 0,
+        });
+    });
+
+    let mut cx = EditorLspTestContext::new_rust(lsp::ServerCapabilities::default(), cx).await;
+
+    cx.set_state(indoc! {"ˇ
+        0_usize
+        let
+        33
+        4.5f32
+    "});
+    cx.update_editor(|editor, window, cx| {
+        editor.show_completions(&ShowCompletions::default(), window, cx);
+    });
+    cx.executor().run_until_parked();
+    cx.condition(|editor, _| editor.context_menu_visible())
+        .await;
+    cx.update_editor(|editor, window, cx| {
+        if let Some(CodeContextMenu::Completions(menu)) = editor.context_menu.borrow_mut().as_ref()
+        {
+            assert_eq!(
+                completion_menu_entries(&menu),
+                &["let"],
+                "With no digits in the completion query, no digits should be in the word completions"
+            );
+        } else {
+            panic!("expected completion menu to be open");
+        }
+        editor.cancel(&Cancel, window, cx);
+    });
+
+    cx.set_state(indoc! {"3ˇ
+        0_usize
+        let
+        3
+        33.35f32
+    "});
+    cx.update_editor(|editor, window, cx| {
+        editor.show_completions(&ShowCompletions::default(), window, cx);
+    });
+    cx.executor().run_until_parked();
+    cx.condition(|editor, _| editor.context_menu_visible())
+        .await;
+    cx.update_editor(|editor, _, _| {
+        if let Some(CodeContextMenu::Completions(menu)) = editor.context_menu.borrow_mut().as_ref()
+        {
+            assert_eq!(completion_menu_entries(&menu), &["33", "35f32"], "The digit is in the completion query, \
+                return matching words with digits (`33`, `35f32`) but exclude query duplicates (`3`)");
+        } else {
+            panic!("expected completion menu to be open");
+        }
+    });
+}
+
 #[gpui::test]
 async fn test_multiline_completion(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
@@ -13342,7 +13561,6 @@ async fn test_mutlibuffer_in_navigation_history(cx: &mut TestAppContext) {
             EditorMode::Full,
             multi_buffer,
             Some(project.clone()),
-            true,
             window,
             cx,
         )
@@ -13825,9 +14043,8 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut TestAppContext) {
         multibuffer
     });
 
-    let editor = cx.add_window(|window, cx| {
-        Editor::new(EditorMode::Full, multi_buffer, None, true, window, cx)
-    });
+    let editor =
+        cx.add_window(|window, cx| Editor::new(EditorMode::Full, multi_buffer, None, window, cx));
     editor
         .update(cx, |editor, _window, cx| {
             for (buffer, diff_base) in [
@@ -13946,9 +14163,8 @@ async fn test_expand_diff_hunk_at_excerpt_boundary(cx: &mut TestAppContext) {
         multibuffer
     });
 
-    let editor = cx.add_window(|window, cx| {
-        Editor::new(EditorMode::Full, multi_buffer, None, true, window, cx)
-    });
+    let editor =
+        cx.add_window(|window, cx| Editor::new(EditorMode::Full, multi_buffer, None, window, cx));
     editor
         .update(cx, |editor, _window, cx| {
             let diff = cx.new(|cx| BufferDiff::new_with_base_text(base, &buffer, cx));
@@ -15504,14 +15720,7 @@ async fn test_display_diff_hunks(cx: &mut TestAppContext) {
     });
 
     let editor = cx.add_window(|window, cx| {
-        Editor::new(
-            EditorMode::Full,
-            multibuffer,
-            Some(project),
-            true,
-            window,
-            cx,
-        )
+        Editor::new(EditorMode::Full, multibuffer, Some(project), window, cx)
     });
     cx.run_until_parked();
 
@@ -15530,9 +15739,9 @@ async fn test_display_diff_hunks(cx: &mut TestAppContext) {
     assert_eq!(
         hunks,
         [
-            DisplayRow(3)..DisplayRow(5),
-            DisplayRow(10)..DisplayRow(12),
-            DisplayRow(17)..DisplayRow(19),
+            DisplayRow(2)..DisplayRow(4),
+            DisplayRow(7)..DisplayRow(9),
+            DisplayRow(12)..DisplayRow(14),
         ]
     );
 }
@@ -15963,7 +16172,6 @@ async fn test_find_enclosing_node_with_task(cx: &mut TestAppContext) {
             EditorMode::Full,
             multi_buffer,
             Some(project.clone()),
-            true,
             window,
             cx,
         )
@@ -16118,7 +16326,6 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
             EditorMode::Full,
             multi_buffer.clone(),
             Some(project.clone()),
-            true,
             window,
             cx,
         )
@@ -16126,7 +16333,7 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
 
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\naaaa\nbbbb\ncccc\n\n\n\nffff\ngggg\n\n\n\njjjj\n\n\n\n\nllll\nmmmm\nnnnn\n\n\n\nqqqq\nrrrr\n\n\n\nuuuu\n\n\n\n\nvvvv\nwwww\nxxxx\n\n\n\n1111\n2222\n\n\n\n5555\n",
+        "\n\naaaa\nbbbb\ncccc\n\n\nffff\ngggg\n\n\njjjj\n\n\nllll\nmmmm\nnnnn\n\n\nqqqq\nrrrr\n\n\nuuuu\n\n\nvvvv\nwwww\nxxxx\n\n\n1111\n2222\n\n\n5555",
     );
 
     multi_buffer_editor.update(cx, |editor, cx| {
@@ -16134,7 +16341,7 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n\n\nllll\nmmmm\nnnnn\n\n\n\nqqqq\nrrrr\n\n\n\nuuuu\n\n\n\n\nvvvv\nwwww\nxxxx\n\n\n\n1111\n2222\n\n\n\n5555\n",
+        "\n\n\n\nllll\nmmmm\nnnnn\n\n\nqqqq\nrrrr\n\n\nuuuu\n\n\nvvvv\nwwww\nxxxx\n\n\n1111\n2222\n\n\n5555",
         "After folding the first buffer, its text should not be displayed"
     );
 
@@ -16143,7 +16350,7 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n\n\n\n\nvvvv\nwwww\nxxxx\n\n\n\n1111\n2222\n\n\n\n5555\n",
+        "\n\n\n\n\n\nvvvv\nwwww\nxxxx\n\n\n1111\n2222\n\n\n5555",
         "After folding the second buffer, its text should not be displayed"
     );
 
@@ -16168,7 +16375,7 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n\n\nllll\nmmmm\nnnnn\n\n\n\nqqqq\nrrrr\n\n\n\nuuuu\n\n\n",
+        "\n\n\n\nllll\nmmmm\nnnnn\n\n\nqqqq\nrrrr\n\n\nuuuu\n\n",
         "After unfolding the second buffer, its text should be displayed"
     );
 
@@ -16190,7 +16397,7 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
 
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\nB\n\n\n\n\n\n\n\n\n\n\nllll\nmmmm\nnnnn\n\n\n\nqqqq\nrrrr\n\n\n\nuuuu\n\n\n",
+        "\n\nB\n\n\n\n\n\n\nllll\nmmmm\nnnnn\n\n\nqqqq\nrrrr\n\n\nuuuu\n\n",
         "After unfolding the first buffer, its and 2nd buffer's text should be displayed"
     );
 
@@ -16199,7 +16406,7 @@ async fn test_folding_buffers(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\nB\n\n\n\n\n\n\n\n\n\n\nllll\nmmmm\nnnnn\n\n\n\nqqqq\nrrrr\n\n\n\nuuuu\n\n\n\n\nvvvv\nwwww\nxxxx\n\n\n\n1111\n2222\n\n\n\n5555\n",
+        "\n\nB\n\n\n\n\n\n\nllll\nmmmm\nnnnn\n\n\nqqqq\nrrrr\n\n\nuuuu\n\n\nvvvv\nwwww\nxxxx\n\n\n1111\n2222\n\n\n5555",
         "After unfolding the all buffers, all original text should be displayed"
     );
 }
@@ -16285,13 +16492,12 @@ async fn test_folding_buffers_with_one_excerpt(cx: &mut TestAppContext) {
             EditorMode::Full,
             multi_buffer,
             Some(project.clone()),
-            true,
             window,
             cx,
         )
     });
 
-    let full_text = "\n\n\n1111\n2222\n3333\n\n\n\n\n4444\n5555\n6666\n\n\n\n\n7777\n8888\n9999\n";
+    let full_text = "\n\n1111\n2222\n3333\n\n\n4444\n5555\n6666\n\n\n7777\n8888\n9999";
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
         full_text,
@@ -16302,7 +16508,7 @@ async fn test_folding_buffers_with_one_excerpt(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n\n\n4444\n5555\n6666\n\n\n\n\n7777\n8888\n9999\n",
+        "\n\n\n\n4444\n5555\n6666\n\n\n7777\n8888\n9999",
         "After folding the first buffer, its text should not be displayed"
     );
 
@@ -16312,7 +16518,7 @@ async fn test_folding_buffers_with_one_excerpt(cx: &mut TestAppContext) {
 
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n\n\n\n\n7777\n8888\n9999\n",
+        "\n\n\n\n\n\n7777\n8888\n9999",
         "After folding the second buffer, its text should not be displayed"
     );
 
@@ -16330,7 +16536,7 @@ async fn test_folding_buffers_with_one_excerpt(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n\n\n4444\n5555\n6666\n\n\n",
+        "\n\n\n\n4444\n5555\n6666\n\n",
         "After unfolding the second buffer, its text should be displayed"
     );
 
@@ -16339,7 +16545,7 @@ async fn test_folding_buffers_with_one_excerpt(cx: &mut TestAppContext) {
     });
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
-        "\n\n\n1111\n2222\n3333\n\n\n\n\n4444\n5555\n6666\n\n\n",
+        "\n\n1111\n2222\n3333\n\n\n4444\n5555\n6666\n\n",
         "After unfolding the first buffer, its text should be displayed"
     );
 
@@ -16405,7 +16611,6 @@ async fn test_folding_buffer_when_multibuffer_has_only_one_excerpt(cx: &mut Test
             EditorMode::Full,
             multi_buffer,
             Some(project.clone()),
-            true,
             window,
             cx,
         )
@@ -16424,7 +16629,7 @@ async fn test_folding_buffer_when_multibuffer_has_only_one_excerpt(cx: &mut Test
         editor.change_selections(None, window, cx, |s| s.select_ranges(Some(highlight_range)));
     });
 
-    let full_text = format!("\n\n\n{sample_text}\n");
+    let full_text = format!("\n\n{sample_text}");
     assert_eq!(
         multi_buffer_editor.update(cx, |editor, cx| editor.display_text(cx)),
         full_text,
@@ -16453,14 +16658,7 @@ async fn test_multi_buffer_navigation_with_folded_buffers(cx: &mut TestAppContex
             ],
             cx,
         );
-        let mut editor = Editor::new(
-            EditorMode::Full,
-            multi_buffer.clone(),
-            None,
-            true,
-            window,
-            cx,
-        );
+        let mut editor = Editor::new(EditorMode::Full, multi_buffer.clone(), None, window, cx);
 
         let buffer_ids = multi_buffer.read(cx).excerpt_buffer_ids();
         // fold all but the second buffer, so that we test navigating between two
@@ -16772,7 +16970,7 @@ async fn assert_highlighted_edits(
 ) {
     let window = cx.add_window(|window, cx| {
         let buffer = MultiBuffer::build_simple(text, cx);
-        Editor::new(EditorMode::Full, buffer, None, true, window, cx)
+        Editor::new(EditorMode::Full, buffer, None, window, cx)
     });
     let cx = &mut VisualTestContext::from_window(*window, cx);
 

crates/editor/src/element.rs

@@ -15,15 +15,15 @@ use crate::{
     inlay_hint_settings,
     items::BufferSearchHighlights,
     mouse_context_menu::{self, MenuPosition, MouseContextMenu},
-    scroll::{axis_pair, scroll_amount::ScrollAmount, AxisPair},
+    scroll::{axis_pair, scroll_amount::ScrollAmount, AxisPair, HorizontalLayoutDetails},
     BlockId, ChunkReplacement, CursorShape, CustomBlockId, DisplayDiffHunk, DisplayPoint,
     DisplayRow, DocumentHighlightRead, DocumentHighlightWrite, EditDisplayMode, Editor, EditorMode,
-    EditorSettings, EditorSnapshot, EditorStyle, ExpandExcerpts, FocusedBlock, GoToHunk,
-    GoToPreviousHunk, GutterDimensions, HalfPageDown, HalfPageUp, HandleInput, HoveredCursor,
-    InlayHintRefreshReason, InlineCompletion, JumpData, LineDown, LineHighlight, LineUp,
-    OpenExcerpts, PageDown, PageUp, Point, RowExt, RowRangeExt, SelectPhase, SelectedTextHighlight,
-    Selection, SoftWrap, StickyHeaderExcerpt, ToPoint, ToggleFold, COLUMNAR_SELECTION_MODIFIERS,
-    CURSORS_VISIBLE_FOR, FILE_HEADER_HEIGHT, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
+    EditorSettings, EditorSnapshot, EditorStyle, FocusedBlock, GoToHunk, GoToPreviousHunk,
+    GutterDimensions, HalfPageDown, HalfPageUp, HandleInput, HoveredCursor, InlayHintRefreshReason,
+    InlineCompletion, JumpData, LineDown, LineHighlight, LineUp, OpenExcerpts, PageDown, PageUp,
+    Point, RowExt, RowRangeExt, SelectPhase, SelectedTextHighlight, Selection, SoftWrap,
+    StickyHeaderExcerpt, ToPoint, ToggleFold, COLUMNAR_SELECTION_MODIFIERS, CURSORS_VISIBLE_FOR,
+    FILE_HEADER_HEIGHT, GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED, MAX_LINE_LEN,
     MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
 };
 use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
@@ -33,10 +33,10 @@ use file_icons::FileIcons;
 use git::{blame::BlameEntry, status::FileStatus, Oid};
 use gpui::{
     anchored, deferred, div, fill, linear_color_stop, linear_gradient, outline, point, px, quad,
-    relative, size, solid_background, svg, transparent_black, Action, AnyElement, App,
-    AvailableSpace, Axis, Bounds, ClickEvent, ClipboardItem, ContentMask, Context, Corner, Corners,
-    CursorStyle, DispatchPhase, Edges, Element, ElementInputHandler, Entity, Focusable as _,
-    FontId, GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Keystroke, Length,
+    relative, size, solid_background, transparent_black, Action, AnyElement, App, AvailableSpace,
+    Axis, Bounds, ClickEvent, ClipboardItem, ContentMask, Context, Corner, Corners, CursorStyle,
+    DispatchPhase, Edges, Element, ElementInputHandler, Entity, Focusable as _, FontId,
+    GlobalElementId, Hitbox, Hsla, InteractiveElement, IntoElement, Keystroke, Length,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, PaintQuad,
     ParentElement, Pixels, ScrollDelta, ScrollWheelEvent, ShapedLine, SharedString, Size,
     StatefulInteractiveElement, Style, Styled, Subscription, TextRun, TextStyleRefinement, Window,
@@ -52,10 +52,10 @@ use language::{
 };
 use lsp::DiagnosticSeverity;
 use multi_buffer::{
-    Anchor, ExcerptId, ExcerptInfo, ExpandExcerptDirection, MultiBufferPoint, MultiBufferRow,
-    RowInfo,
+    Anchor, ExcerptId, ExcerptInfo, ExpandExcerptDirection, ExpandInfo, MultiBufferPoint,
+    MultiBufferRow, RowInfo,
 };
-use project::project_settings::{self, GitGutterSetting, GitHunkStyleSetting, ProjectSettings};
+use project::project_settings::{self, GitGutterSetting, ProjectSettings};
 use settings::Settings;
 use smallvec::{smallvec, SmallVec};
 use std::{
@@ -72,7 +72,7 @@ use sum_tree::Bias;
 use text::BufferId;
 use theme::{ActiveTheme, Appearance, BufferLineHeight, PlayerColor};
 use ui::{
-    h_flex, prelude::*, ButtonLike, ButtonStyle, ContextMenu, IconButtonShape, KeyBinding, Tooltip,
+    h_flex, prelude::*, ButtonLike, ContextMenu, IconButtonShape, KeyBinding, Tooltip,
     POPOVER_Y_PADDING,
 };
 use unicode_segmentation::UnicodeSegmentation;
@@ -390,6 +390,7 @@ impl EditorElement {
         register_action(editor, window, Editor::set_mark);
         register_action(editor, window, Editor::swap_selection_ends);
         register_action(editor, window, Editor::show_completions);
+        register_action(editor, window, Editor::show_word_completions);
         register_action(editor, window, Editor::toggle_code_actions);
         register_action(editor, window, Editor::open_excerpts);
         register_action(editor, window, Editor::open_excerpts_in_split);
@@ -1515,6 +1516,19 @@ impl EditorElement {
         }
     }
 
+    fn prepaint_expand_toggles(
+        &self,
+        expand_toggles: &mut [Option<(AnyElement, gpui::Point<Pixels>)>],
+        window: &mut Window,
+        cx: &mut App,
+    ) {
+        for (expand_toggle, origin) in expand_toggles.iter_mut().flatten() {
+            let available_space = size(AvailableSpace::MinContent, AvailableSpace::MinContent);
+            expand_toggle.layout_as_root(available_space, window, cx);
+            expand_toggle.prepaint_as_root(*origin, available_space, window, cx);
+        }
+    }
+
     fn prepaint_crease_trailers(
         &self,
         trailers: Vec<Option<AnyElement>>,
@@ -2009,6 +2023,7 @@ impl EditorElement {
         &self,
         line_height: Pixels,
         range: Range<DisplayRow>,
+        row_infos: &[RowInfo],
         scroll_pixel_position: gpui::Point<Pixels>,
         gutter_dimensions: &GutterDimensions,
         gutter_hitbox: &Hitbox,
@@ -2074,6 +2089,12 @@ impl EditorElement {
                         }
                     }
                     let display_row = multibuffer_point.to_display_point(snapshot).row();
+                    if row_infos
+                        .get((display_row - range.start).0 as usize)
+                        .is_some_and(|row_info| row_info.expand_info.is_some())
+                    {
+                        return None;
+                    }
                     let button = editor.render_run_indicator(
                         &self.style,
                         Some(display_row) == active_task_indicator_row,
@@ -2098,6 +2119,82 @@ impl EditorElement {
         })
     }
 
+    fn layout_excerpt_gutter(
+        &self,
+        gutter_hitbox: &Hitbox,
+        line_height: Pixels,
+        scroll_position: gpui::Point<f32>,
+        buffer_rows: &[RowInfo],
+        window: &mut Window,
+        cx: &mut App,
+    ) -> Vec<Option<(AnyElement, gpui::Point<Pixels>)>> {
+        let editor_font_size = self.style.text.font_size.to_pixels(window.rem_size()) * 1.2;
+
+        let icon_size = editor_font_size.round();
+        let button_h_padding = ((icon_size - px(1.0)) / 2.0).round() - px(2.0);
+
+        let scroll_top = scroll_position.y * line_height;
+
+        let elements = buffer_rows
+            .into_iter()
+            .enumerate()
+            .map(|(ix, row_info)| {
+                let ExpandInfo {
+                    excerpt_id,
+                    direction,
+                } = row_info.expand_info?;
+
+                let icon_name = match direction {
+                    ExpandExcerptDirection::Up => IconName::ExpandUp,
+                    ExpandExcerptDirection::Down => IconName::ExpandDown,
+                    ExpandExcerptDirection::UpAndDown => IconName::ExpandVertical,
+                };
+
+                let editor = self.editor.clone();
+                let max_row = self
+                    .editor
+                    .read(cx)
+                    .buffer()
+                    .read(cx)
+                    .snapshot(cx)
+                    .widest_line_number();
+                let is_wide = max_row > 999
+                    && row_info
+                        .buffer_row
+                        .is_some_and(|row| row.ilog10() == max_row.ilog10());
+
+                let toggle = IconButton::new(("expand", ix), icon_name)
+                    .icon_color(Color::Custom(cx.theme().colors().editor_line_number))
+                    .selected_icon_color(Color::Custom(cx.theme().colors().editor_foreground))
+                    .icon_size(IconSize::Custom(rems(editor_font_size / window.rem_size())))
+                    .width((icon_size + button_h_padding * 2).into())
+                    .when(is_wide, |el| {
+                        el.width((icon_size + button_h_padding).into())
+                    })
+                    .on_click(move |_, _, cx| {
+                        editor.update(cx, |editor, cx| {
+                            editor.expand_excerpt(excerpt_id, direction, cx);
+                        });
+                    })
+                    .tooltip(Tooltip::for_action_title(
+                        "Expand excerpt",
+                        &crate::actions::ExpandExcerpts::default(),
+                    ))
+                    .into_any_element();
+
+                let position = point(
+                    px(1.),
+                    ix as f32 * line_height - (scroll_top % line_height) + px(1.),
+                );
+                let origin = gutter_hitbox.origin + position;
+
+                Some((toggle, origin))
+            })
+            .collect();
+
+        elements
+    }
+
     fn layout_code_actions_indicator(
         &self,
         line_height: Pixels,
@@ -2315,6 +2412,9 @@ impl EditorElement {
                 .into_iter()
                 .enumerate()
                 .map(|(ix, info)| {
+                    if info.expand_info.is_some() {
+                        return None;
+                    }
                     let row = info.multibuffer_row?;
                     let display_row = DisplayRow(rows.start.0 + ix as u32);
                     let active = active_rows.contains_key(&display_row);
@@ -2337,6 +2437,9 @@ impl EditorElement {
         buffer_rows
             .into_iter()
             .map(|row_info| {
+                if row_info.expand_info.is_some() {
+                    return None;
+                }
                 if let Some(row) = row_info.multibuffer_row {
                     snapshot.render_crease_trailer(row, window, cx)
                 } else {
@@ -2514,25 +2617,11 @@ impl EditorElement {
 
             Block::FoldedBuffer {
                 first_excerpt,
-                prev_excerpt,
-                show_excerpt_controls,
                 height,
+                ..
             } => {
                 let selected = selected_buffer_ids.contains(&first_excerpt.buffer_id);
-                let mut result = v_flex().id(block_id).w_full();
-
-                if let Some(prev_excerpt) = prev_excerpt {
-                    if *show_excerpt_controls {
-                        result = result.child(self.render_expand_excerpt_control(
-                            block_id,
-                            ExpandExcerptDirection::Down,
-                            prev_excerpt.id,
-                            gutter_dimensions,
-                            window,
-                            cx,
-                        ));
-                    }
-                }
+                let result = v_flex().id(block_id).w_full();
 
                 let jump_data = header_jump_data(snapshot, block_row_start, *height, first_excerpt);
                 result
@@ -2540,6 +2629,7 @@ impl EditorElement {
                         first_excerpt,
                         true,
                         selected,
+                        false,
                         jump_data,
                         window,
                         cx,
@@ -2548,28 +2638,14 @@ impl EditorElement {
             }
 
             Block::ExcerptBoundary {
-                prev_excerpt,
                 next_excerpt,
-                show_excerpt_controls,
                 height,
                 starts_new_buffer,
+                ..
             } => {
                 let color = cx.theme().colors().clone();
                 let mut result = v_flex().id(block_id).w_full();
 
-                if let Some(prev_excerpt) = prev_excerpt {
-                    if *show_excerpt_controls {
-                        result = result.child(self.render_expand_excerpt_control(
-                            block_id,
-                            ExpandExcerptDirection::Down,
-                            prev_excerpt.id,
-                            gutter_dimensions,
-                            window,
-                            cx,
-                        ));
-                    }
-                }
-
                 if let Some(next_excerpt) = next_excerpt {
                     let jump_data =
                         header_jump_data(snapshot, block_row_start, *height, next_excerpt);
@@ -2582,6 +2658,7 @@ impl EditorElement {
                                 next_excerpt,
                                 false,
                                 selected,
+                                false,
                                 jump_data,
                                 window,
                                 cx,
@@ -2590,40 +2667,17 @@ impl EditorElement {
                             result = result
                                 .child(div().h(FILE_HEADER_HEIGHT as f32 * window.line_height()));
                         }
-
-                        if *show_excerpt_controls {
-                            result = result.child(self.render_expand_excerpt_control(
-                                block_id,
-                                ExpandExcerptDirection::Up,
-                                next_excerpt.id,
-                                gutter_dimensions,
-                                window,
-                                cx,
-                            ));
-                        }
                     } else {
-                        if *show_excerpt_controls {
-                            result = result.child(
-                                h_flex()
-                                    .relative()
-                                    .child(
-                                        div()
-                                            .top(px(0.))
-                                            .absolute()
-                                            .w_full()
-                                            .h_px()
-                                            .bg(color.border_variant),
-                                    )
-                                    .child(self.render_expand_excerpt_control(
-                                        block_id,
-                                        ExpandExcerptDirection::Up,
-                                        next_excerpt.id,
-                                        gutter_dimensions,
-                                        window,
-                                        cx,
-                                    )),
-                            );
-                        }
+                        result = result.child(
+                            h_flex().relative().child(
+                                div()
+                                    .top(line_height / 2.)
+                                    .absolute()
+                                    .w_full()
+                                    .h_px()
+                                    .bg(color.border_variant),
+                            ),
+                        );
                     };
                 }
 
@@ -2662,6 +2716,7 @@ impl EditorElement {
         for_excerpt: &ExcerptInfo,
         is_folded: bool,
         is_selected: bool,
+        _is_sticky: bool,
         jump_data: JumpData,
         window: &mut Window,
         cx: &mut App,
@@ -2708,7 +2763,7 @@ impl EditorElement {
                     .pl_0p5()
                     .pr_5()
                     .rounded_sm()
-                    .shadow_md()
+                    // .when(is_sticky, |el| el.shadow_md())
                     .border_1()
                     .map(|div| {
                         let border_color = if is_selected
@@ -2847,95 +2902,6 @@ impl EditorElement {
             )
     }
 
-    fn render_expand_excerpt_control(
-        &self,
-        block_id: BlockId,
-        direction: ExpandExcerptDirection,
-        excerpt_id: ExcerptId,
-        gutter_dimensions: &GutterDimensions,
-        window: &Window,
-        cx: &mut App,
-    ) -> impl IntoElement {
-        let color = cx.theme().colors().clone();
-        let hover_color = color.border_variant.opacity(0.5);
-        let focus_handle = self.editor.focus_handle(cx).clone();
-
-        let icon_offset =
-            gutter_dimensions.width - (gutter_dimensions.left_padding + gutter_dimensions.margin);
-        let header_height = MULTI_BUFFER_EXCERPT_HEADER_HEIGHT as f32 * window.line_height();
-        let group_name = if direction == ExpandExcerptDirection::Down {
-            "expand-down"
-        } else {
-            "expand-up"
-        };
-
-        let expand_area = |id: SharedString| {
-            h_flex()
-                .id(id)
-                .w_full()
-                .cursor_pointer()
-                .block_mouse_down()
-                .on_mouse_move(|_, _, cx| cx.stop_propagation())
-                .hover(|style| style.bg(hover_color))
-                .tooltip({
-                    let focus_handle = focus_handle.clone();
-                    move |window, cx| {
-                        Tooltip::for_action_in(
-                            "Expand Excerpt",
-                            &ExpandExcerpts { lines: 0 },
-                            &focus_handle,
-                            window,
-                            cx,
-                        )
-                    }
-                })
-        };
-
-        expand_area(
-            format!(
-                "block-{}-{}",
-                block_id,
-                if direction == ExpandExcerptDirection::Down {
-                    "down"
-                } else {
-                    "up"
-                }
-            )
-            .into(),
-        )
-        .group(group_name)
-        .child(
-            h_flex()
-                .w(icon_offset)
-                .h(header_height)
-                .flex_none()
-                .justify_end()
-                .child(
-                    ButtonLike::new("expand-icon")
-                        .style(ButtonStyle::Transparent)
-                        .child(
-                            svg()
-                                .path(if direction == ExpandExcerptDirection::Down {
-                                    IconName::ArrowDownFromLine.path()
-                                } else {
-                                    IconName::ArrowUpFromLine.path()
-                                })
-                                .size(IconSize::XSmall.rems())
-                                .text_color(cx.theme().colors().editor_line_number)
-                                .group_hover(group_name, |style| {
-                                    style.text_color(cx.theme().colors().editor_active_line_number)
-                                }),
-                        ),
-                ),
-        )
-        .on_click(window.listener_for(&self.editor, {
-            move |editor, _, _, cx| {
-                editor.expand_excerpt(excerpt_id, direction, cx);
-                cx.stop_propagation();
-            }
-        }))
-    }
-
     fn render_blocks(
         &self,
         rows: Range<DisplayRow>,
@@ -3167,7 +3133,6 @@ impl EditorElement {
         &self,
         StickyHeaderExcerpt {
             excerpt,
-            next_excerpt_controls_present,
             next_buffer_row,
         }: StickyHeaderExcerpt<'_>,
         scroll_position: f32,
@@ -3204,7 +3169,7 @@ impl EditorElement {
                     .top_0(),
             )
             .child(
-                self.render_buffer_header(excerpt, false, selected, jump_data, window, cx)
+                self.render_buffer_header(excerpt, false, selected, true, jump_data, window, cx)
                     .into_any_element(),
             )
             .into_any_element();
@@ -3214,11 +3179,7 @@ impl EditorElement {
         if let Some(next_buffer_row) = next_buffer_row {
             // Push up the sticky header when the excerpt is getting close to the top of the viewport
 
-            let mut max_row = next_buffer_row - FILE_HEADER_HEIGHT * 2;
-
-            if next_excerpt_controls_present {
-                max_row -= MULTI_BUFFER_EXCERPT_HEADER_HEIGHT;
-            }
+            let max_row = next_buffer_row - FILE_HEADER_HEIGHT * 2;
 
             let offset = scroll_position - max_row as f32;
 
@@ -4415,7 +4376,7 @@ impl EditorElement {
                     }),
                 };
 
-                if let Some((hunk_bounds, background_color, corner_radii, status)) = hunk_to_paint {
+                if let Some((hunk_bounds, background_color, corner_radii, _)) = hunk_to_paint {
                     // Flatten the background color with the editor color to prevent
                     // elements below transparent hunks from showing through
                     let flattened_background_color = cx
@@ -4424,29 +4385,13 @@ impl EditorElement {
                         .editor_background
                         .blend(background_color);
 
-                    if !Self::diff_hunk_hollow(status, cx) {
-                        window.paint_quad(quad(
-                            hunk_bounds,
-                            corner_radii,
-                            flattened_background_color,
-                            Edges::default(),
-                            transparent_black(),
-                        ));
-                    } else {
-                        let flattened_unstaged_background_color = cx
-                            .theme()
-                            .colors()
-                            .editor_background
-                            .blend(background_color.opacity(0.3));
-
-                        window.paint_quad(quad(
-                            hunk_bounds,
-                            corner_radii,
-                            flattened_unstaged_background_color,
-                            Edges::all(Pixels(1.0)),
-                            flattened_background_color,
-                        ));
-                    }
+                    window.paint_quad(quad(
+                        hunk_bounds,
+                        corner_radii,
+                        flattened_background_color,
+                        Edges::default(),
+                        transparent_black(),
+                    ));
                 }
             }
         });
@@ -4530,6 +4475,12 @@ impl EditorElement {
                 }
             });
 
+            window.with_element_namespace("expand_toggles", |window| {
+                for (expand_toggle, _) in layout.expand_toggles.iter_mut().flatten() {
+                    expand_toggle.paint(window, cx);
+                }
+            });
+
             for test_indicator in layout.test_indicators.iter_mut() {
                 test_indicator.paint(window, cx);
             }
@@ -5651,18 +5602,6 @@ impl EditorElement {
             &[run],
         )
     }
-
-    fn diff_hunk_hollow(status: DiffHunkStatus, cx: &mut App) -> bool {
-        let unstaged = status.has_secondary_hunk();
-        let unstaged_hollow = ProjectSettings::get_global(cx)
-            .git
-            .hunk_style
-            .map_or(false, |style| {
-                matches!(style, GitHunkStyleSetting::UnstagedHollow)
-            });
-
-        unstaged == unstaged_hollow
-    }
 }
 
 fn header_jump_data(
@@ -6814,9 +6753,10 @@ impl Element for EditorElement {
                             }
                         };
 
+                        let unstaged = diff_status.has_secondary_hunk();
                         let hunk_opacity = if is_light { 0.16 } else { 0.12 };
 
-                        let hollow_highlight = LineHighlight {
+                        let staged_highlight = LineHighlight {
                             background: (background_color.opacity(if is_light {
                                 0.08
                             } else {
@@ -6830,13 +6770,13 @@ impl Element for EditorElement {
                             }),
                         };
 
-                        let filled_highlight =
+                        let unstaged_highlight =
                             solid_background(background_color.opacity(hunk_opacity)).into();
 
-                        let background = if Self::diff_hunk_hollow(diff_status, cx) {
-                            hollow_highlight
+                        let background = if unstaged {
+                            unstaged_highlight
                         } else {
-                            filled_highlight
+                            staged_highlight
                         };
 
                         highlighted_rows
@@ -6918,6 +6858,18 @@ impl Element for EditorElement {
                         cx,
                     );
 
+                    let mut expand_toggles =
+                        window.with_element_namespace("expand_toggles", |window| {
+                            self.layout_excerpt_gutter(
+                                &gutter_hitbox,
+                                line_height,
+                                scroll_position,
+                                &row_infos,
+                                window,
+                                cx,
+                            )
+                        });
+
                     let mut crease_toggles =
                         window.with_element_namespace("crease_toggles", |window| {
                             self.layout_crease_toggles(
@@ -7015,7 +6967,7 @@ impl Element for EditorElement {
                     let mut scroll_width = scroll_range_bounds.size.width;
 
                     let sticky_header_excerpt = if snapshot.buffer_snapshot.show_headers() {
-                        snapshot.sticky_header_excerpt(start_row)
+                        snapshot.sticky_header_excerpt(scroll_position.y)
                     } else {
                         None
                     };
@@ -7079,6 +7031,11 @@ impl Element for EditorElement {
                     );
 
                     self.editor.update(cx, |editor, cx| {
+                        editor.scroll_manager.latest_horizontal_details = HorizontalLayoutDetails {
+                            letter_width: letter_size.width.0,
+                            editor_width: editor_width.0,
+                            scroll_max: scroll_max.x,
+                        };
                         let clamped = editor.scroll_manager.clamp_scroll_left(scroll_max.x);
 
                         let autoscrolled = if autoscroll_horizontally {
@@ -7332,7 +7289,14 @@ impl Element for EditorElement {
                                             .tasks
                                             .contains_key(&(buffer_id, row));
 
-                                        if !has_test_indicator {
+                                        let has_expand_indicator = row_infos
+                                            .get(
+                                                (newest_selection_head.row() - start_row).0
+                                                    as usize,
+                                            )
+                                            .is_some_and(|row_info| row_info.expand_info.is_some());
+
+                                        if !has_test_indicator && !has_expand_indicator {
                                             code_actions_indicator = self
                                                 .layout_code_actions_indicator(
                                                     line_height,
@@ -7365,6 +7329,7 @@ impl Element for EditorElement {
                         self.layout_run_indicators(
                             line_height,
                             start_row..end_row,
+                            &row_infos,
                             scroll_pixel_position,
                             &gutter_dimensions,
                             &gutter_hitbox,
@@ -7427,6 +7392,10 @@ impl Element for EditorElement {
                         )
                     });
 
+                    window.with_element_namespace("expand_toggles", |window| {
+                        self.prepaint_expand_toggles(&mut expand_toggles, window, cx)
+                    });
+
                     let invisible_symbol_font_size = font_size / 2.;
                     let tab_invisible = window
                         .text_system()
@@ -7528,6 +7497,7 @@ impl Element for EditorElement {
                         tab_invisible,
                         space_invisible,
                         sticky_buffer_header,
+                        expand_toggles,
                     }
                 })
             })
@@ -7701,6 +7671,7 @@ pub struct EditorLayout {
     code_actions_indicator: Option<AnyElement>,
     test_indicators: Vec<AnyElement>,
     crease_toggles: Vec<Option<AnyElement>>,
+    expand_toggles: Vec<Option<(AnyElement, gpui::Point<Pixels>)>>,
     diff_hunk_controls: Vec<AnyElement>,
     crease_trailers: Vec<Option<CreaseTrailerLayout>>,
     inline_completion_popover: Option<AnyElement>,
@@ -8334,7 +8305,7 @@ mod tests {
         init_test(cx, |_| {});
         let window = cx.add_window(|window, cx| {
             let buffer = MultiBuffer::build_simple(&sample_text(6, 6, 'a'), cx);
-            Editor::new(EditorMode::Full, buffer, None, true, window, cx)
+            Editor::new(EditorMode::Full, buffer, None, window, cx)
         });
 
         let editor = window.root(cx).unwrap();
@@ -8434,7 +8405,7 @@ mod tests {
 
         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, true, window, cx)
+            Editor::new(EditorMode::Full, buffer, None, window, cx)
         });
         let cx = &mut VisualTestContext::from_window(*window, cx);
         let editor = window.root(cx).unwrap();
@@ -8497,90 +8468,6 @@ mod tests {
             state.active_rows.keys().cloned().collect::<Vec<_>>(),
             vec![DisplayRow(0), DisplayRow(3), DisplayRow(5), DisplayRow(6)]
         );
-
-        // multi-buffer support
-        // in DisplayPoint coordinates, this is what we're dealing with:
-        //  0: [[file
-        //  1:   header
-        //  2:   section]]
-        //  3: aaaaaa
-        //  4: bbbbbb
-        //  5: cccccc
-        //  6:
-        //  7: [[footer]]
-        //  8: [[header]]
-        //  9: ffffff
-        // 10: gggggg
-        // 11: hhhhhh
-        // 12:
-        // 13: [[footer]]
-        // 14: [[file
-        // 15:   header
-        // 16:   section]]
-        // 17: bbbbbb
-        // 18: cccccc
-        // 19: dddddd
-        // 20: [[footer]]
-        let window = cx.add_window(|window, cx| {
-            let buffer = MultiBuffer::build_multi(
-                [
-                    (
-                        &(sample_text(8, 6, 'a') + "\n"),
-                        vec![
-                            Point::new(0, 0)..Point::new(3, 0),
-                            Point::new(4, 0)..Point::new(7, 0),
-                        ],
-                    ),
-                    (
-                        &(sample_text(8, 6, 'a') + "\n"),
-                        vec![Point::new(1, 0)..Point::new(3, 0)],
-                    ),
-                ],
-                cx,
-            );
-            Editor::new(EditorMode::Full, buffer, None, true, window, cx)
-        });
-        let editor = window.root(cx).unwrap();
-        let style = cx.update(|_, cx| editor.read(cx).style().unwrap().clone());
-        let _state = window.update(cx, |editor, window, cx| {
-            editor.cursor_shape = CursorShape::Block;
-            editor.change_selections(None, window, cx, |s| {
-                s.select_display_ranges([
-                    DisplayPoint::new(DisplayRow(4), 0)..DisplayPoint::new(DisplayRow(7), 0),
-                    DisplayPoint::new(DisplayRow(10), 0)..DisplayPoint::new(DisplayRow(13), 0),
-                ]);
-            });
-        });
-
-        let (_, state) = cx.draw(
-            point(px(500.), px(500.)),
-            size(px(500.), px(500.)),
-            |_, _| EditorElement::new(&editor, style),
-        );
-        assert_eq!(state.selections.len(), 1);
-        let local_selections = &state.selections[0].1;
-        assert_eq!(local_selections.len(), 2);
-
-        // moves cursor on excerpt boundary back a line
-        // and doesn't allow selection to bleed through
-        assert_eq!(
-            local_selections[0].range,
-            DisplayPoint::new(DisplayRow(4), 0)..DisplayPoint::new(DisplayRow(7), 0)
-        );
-        assert_eq!(
-            local_selections[0].head,
-            DisplayPoint::new(DisplayRow(6), 0)
-        );
-        // moves cursor on buffer boundary back two lines
-        // and doesn't allow selection to bleed through
-        assert_eq!(
-            local_selections[1].range,
-            DisplayPoint::new(DisplayRow(10), 0)..DisplayPoint::new(DisplayRow(13), 0)
-        );
-        assert_eq!(
-            local_selections[1].head,
-            DisplayPoint::new(DisplayRow(12), 0)
-        );
     }
 
     #[gpui::test]
@@ -8589,7 +8476,7 @@ mod tests {
 
         let window = cx.add_window(|window, cx| {
             let buffer = MultiBuffer::build_simple("", cx);
-            Editor::new(EditorMode::Full, buffer, None, true, window, cx)
+            Editor::new(EditorMode::Full, buffer, None, window, cx)
         });
         let cx = &mut VisualTestContext::from_window(*window, cx);
         let editor = window.root(cx).unwrap();
@@ -8815,7 +8702,7 @@ mod tests {
         );
         let window = cx.add_window(|window, cx| {
             let buffer = MultiBuffer::build_simple(input_text, cx);
-            Editor::new(editor_mode, buffer, None, true, window, cx)
+            Editor::new(editor_mode, buffer, None, window, cx)
         });
         let cx = &mut VisualTestContext::from_window(*window, cx);
         let editor = window.root(cx).unwrap();

crates/editor/src/inlay_hint_cache.rs

@@ -2618,7 +2618,7 @@ pub mod tests {
 
         cx.executor().run_until_parked();
         let editor = cx.add_window(|window, cx| {
-            Editor::for_multibuffer(multibuffer, Some(project.clone()), true, window, cx)
+            Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx)
         });
 
         let editor_edited = Arc::new(AtomicBool::new(false));
@@ -2830,7 +2830,6 @@ pub mod tests {
                     "main hint #5".to_string(),
                     "other hint(edited) #0".to_string(),
                     "other hint(edited) #1".to_string(),
-                    "other hint(edited) #2".to_string(),
                 ];
                 assert_eq!(
                     expected_hints,
@@ -2921,7 +2920,7 @@ pub mod tests {
 
         cx.executor().run_until_parked();
         let editor = cx.add_window(|window, cx| {
-            Editor::for_multibuffer(multibuffer, Some(project.clone()), true, window, cx)
+            Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx)
         });
         let editor_edited = Arc::new(AtomicBool::new(false));
         let fake_server = fake_servers.next().await.unwrap();

crates/editor/src/items.rs

@@ -129,13 +129,8 @@ impl FollowableItem for Editor {
                 });
 
                 cx.new(|cx| {
-                    let mut editor = Editor::for_multibuffer(
-                        multibuffer,
-                        Some(project.clone()),
-                        true,
-                        window,
-                        cx,
-                    );
+                    let mut editor =
+                        Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx);
                     editor.remote_id = Some(remote_id);
                     editor
                 })

crates/editor/src/movement.rs

@@ -893,8 +893,6 @@ mod tests {
                 font,
                 font_size,
                 None,
-                true,
-                1,
                 1,
                 1,
                 FoldPlaceholder::test(),
@@ -1110,138 +1108,136 @@ mod tests {
                     font,
                     px(14.0),
                     None,
-                    true,
                     0,
                     2,
-                    0,
                     FoldPlaceholder::test(),
                     cx,
                 )
             });
             let snapshot = display_map.update(cx, |map, cx| map.snapshot(cx));
 
-            assert_eq!(snapshot.text(), "\n\nabc\ndefg\n\n\nhijkl\nmn");
+            assert_eq!(snapshot.text(), "abc\ndefg\nhijkl\nmn");
 
             let col_2_x = snapshot
-                .x_for_display_point(DisplayPoint::new(DisplayRow(2), 2), &text_layout_details);
+                .x_for_display_point(DisplayPoint::new(DisplayRow(0), 2), &text_layout_details);
 
             // Can't move up into the first excerpt's header
             assert_eq!(
                 up(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(2), 2),
+                    DisplayPoint::new(DisplayRow(0), 2),
                     SelectionGoal::HorizontalPosition(col_2_x.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(2), 0),
+                    DisplayPoint::new(DisplayRow(0), 0),
                     SelectionGoal::HorizontalPosition(col_2_x.0),
                 ),
             );
             assert_eq!(
                 up(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(2), 0),
+                    DisplayPoint::new(DisplayRow(0), 0),
                     SelectionGoal::None,
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(2), 0),
+                    DisplayPoint::new(DisplayRow(0), 0),
                     SelectionGoal::HorizontalPosition(0.0),
                 ),
             );
 
             let col_4_x = snapshot
-                .x_for_display_point(DisplayPoint::new(DisplayRow(3), 4), &text_layout_details);
+                .x_for_display_point(DisplayPoint::new(DisplayRow(1), 4), &text_layout_details);
 
             // Move up and down within first excerpt
             assert_eq!(
                 up(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(3), 4),
+                    DisplayPoint::new(DisplayRow(1), 4),
                     SelectionGoal::HorizontalPosition(col_4_x.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(2), 3),
+                    DisplayPoint::new(DisplayRow(0), 3),
                     SelectionGoal::HorizontalPosition(col_4_x.0)
                 ),
             );
             assert_eq!(
                 down(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(2), 3),
+                    DisplayPoint::new(DisplayRow(0), 3),
                     SelectionGoal::HorizontalPosition(col_4_x.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(3), 4),
+                    DisplayPoint::new(DisplayRow(1), 4),
                     SelectionGoal::HorizontalPosition(col_4_x.0)
                 ),
             );
 
             let col_5_x = snapshot
-                .x_for_display_point(DisplayPoint::new(DisplayRow(6), 5), &text_layout_details);
+                .x_for_display_point(DisplayPoint::new(DisplayRow(2), 5), &text_layout_details);
 
             // Move up and down across second excerpt's header
             assert_eq!(
                 up(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(6), 5),
+                    DisplayPoint::new(DisplayRow(2), 5),
                     SelectionGoal::HorizontalPosition(col_5_x.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(3), 4),
+                    DisplayPoint::new(DisplayRow(1), 4),
                     SelectionGoal::HorizontalPosition(col_5_x.0)
                 ),
             );
             assert_eq!(
                 down(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(3), 4),
+                    DisplayPoint::new(DisplayRow(1), 4),
                     SelectionGoal::HorizontalPosition(col_5_x.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(6), 5),
+                    DisplayPoint::new(DisplayRow(2), 5),
                     SelectionGoal::HorizontalPosition(col_5_x.0)
                 ),
             );
 
             let max_point_x = snapshot
-                .x_for_display_point(DisplayPoint::new(DisplayRow(7), 2), &text_layout_details);
+                .x_for_display_point(DisplayPoint::new(DisplayRow(3), 2), &text_layout_details);
 
             // Can't move down off the end, and attempting to do so leaves the selection goal unchanged
             assert_eq!(
                 down(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(7), 0),
+                    DisplayPoint::new(DisplayRow(3), 0),
                     SelectionGoal::HorizontalPosition(0.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(7), 2),
+                    DisplayPoint::new(DisplayRow(3), 2),
                     SelectionGoal::HorizontalPosition(0.0)
                 ),
             );
             assert_eq!(
                 down(
                     &snapshot,
-                    DisplayPoint::new(DisplayRow(7), 2),
+                    DisplayPoint::new(DisplayRow(3), 2),
                     SelectionGoal::HorizontalPosition(max_point_x.0),
                     false,
                     &text_layout_details
                 ),
                 (
-                    DisplayPoint::new(DisplayRow(7), 2),
+                    DisplayPoint::new(DisplayRow(3), 2),
                     SelectionGoal::HorizontalPosition(max_point_x.0)
                 ),
             );

crates/editor/src/proposed_changes_editor.rs

@@ -62,8 +62,7 @@ impl ProposedChangesEditor {
         let (recalculate_diffs_tx, mut recalculate_diffs_rx) = mpsc::unbounded();
         let mut this = Self {
             editor: cx.new(|cx| {
-                let mut editor =
-                    Editor::for_multibuffer(multibuffer.clone(), project, true, window, cx);
+                let mut editor = Editor::for_multibuffer(multibuffer.clone(), project, window, cx);
                 editor.set_expand_all_diff_hunks(cx);
                 editor.set_completion_provider(None);
                 editor.clear_code_action_providers();

crates/editor/src/rust_analyzer_ext.rs

@@ -86,7 +86,7 @@ pub fn expand_macro_recursively(
                 cx.new(|cx| MultiBuffer::singleton(buffer, cx).with_title(macro_expansion.name));
             workspace.add_item_to_active_pane(
                 Box::new(cx.new(|cx| {
-                    let mut editor = Editor::for_multibuffer(multibuffer, None, false, window, cx);
+                    let mut editor = Editor::for_multibuffer(multibuffer, None, window, cx);
                     editor.set_read_only(true);
                     editor
                 })),

crates/editor/src/scroll.rs

@@ -172,6 +172,13 @@ impl OngoingScroll {
     }
 }
 
+#[derive(Default, Debug)]
+pub struct HorizontalLayoutDetails {
+    pub letter_width: f32,
+    pub editor_width: f32,
+    pub scroll_max: f32,
+}
+
 pub struct ScrollManager {
     pub(crate) vertical_scroll_margin: f32,
     anchor: ScrollAnchor,
@@ -183,6 +190,7 @@ pub struct ScrollManager {
     dragging_scrollbar: AxisPair<bool>,
     visible_line_count: Option<f32>,
     forbid_vertical_scroll: bool,
+    pub(crate) latest_horizontal_details: HorizontalLayoutDetails,
 }
 
 impl ScrollManager {
@@ -198,6 +206,7 @@ impl ScrollManager {
             last_autoscroll: None,
             visible_line_count: None,
             forbid_vertical_scroll: false,
+            latest_horizontal_details: Default::default(),
         }
     }
 
@@ -379,6 +388,15 @@ impl ScrollManager {
         cx.notify();
     }
 
+    pub fn horizontal_scroll(
+        &mut self,
+        f: impl Fn(f32, &HorizontalLayoutDetails) -> f32,
+        cx: &mut Context<Editor>,
+    ) {
+        self.anchor.offset.x = f(self.anchor.offset.x, &self.latest_horizontal_details);
+        cx.notify();
+    }
+
     pub fn clamp_scroll_left(&mut self, max: f32) -> bool {
         if max < self.anchor.offset.x {
             self.anchor.offset.x = max;

crates/editor/src/test.rs

@@ -61,8 +61,6 @@ pub fn marked_display_snapshot(
             font,
             font_size,
             None,
-            true,
-            1,
             1,
             1,
             FoldPlaceholder::test(),
@@ -108,7 +106,7 @@ pub(crate) fn build_editor(
     window: &mut Window,
     cx: &mut Context<Editor>,
 ) -> Editor {
-    Editor::new(EditorMode::Full, buffer, None, true, window, cx)
+    Editor::new(EditorMode::Full, buffer, None, window, cx)
 }
 
 pub(crate) fn build_editor_with_project(
@@ -117,5 +115,5 @@ pub(crate) fn build_editor_with_project(
     window: &mut Window,
     cx: &mut Context<Editor>,
 ) -> Editor {
-    Editor::new(EditorMode::Full, buffer, Some(project), true, window, cx)
+    Editor::new(EditorMode::Full, buffer, Some(project), window, cx)
 }

crates/extension/src/extension.rs

@@ -1,4 +1,5 @@
 pub mod extension_builder;
+mod extension_events;
 mod extension_host_proxy;
 mod extension_manifest;
 mod types;
@@ -14,12 +15,14 @@ use gpui::{App, Task};
 use language::LanguageName;
 use semantic_version::SemanticVersion;
 
+pub use crate::extension_events::*;
 pub use crate::extension_host_proxy::*;
 pub use crate::extension_manifest::*;
 pub use crate::types::*;
 
 /// Initializes the `extension` crate.
 pub fn init(cx: &mut App) {
+    extension_events::init(cx);
     ExtensionHostProxy::default_global(cx);
 }
 

crates/extension/src/extension_events.rs

@@ -0,0 +1,37 @@
+use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Global};
+
+pub fn init(cx: &mut App) {
+    let extension_events = cx.new(ExtensionEvents::new);
+    cx.set_global(GlobalExtensionEvents(extension_events));
+}
+
+struct GlobalExtensionEvents(Entity<ExtensionEvents>);
+
+impl Global for GlobalExtensionEvents {}
+
+/// An event bus for broadcasting extension-related events throughout the app.
+pub struct ExtensionEvents;
+
+impl ExtensionEvents {
+    /// Returns the global [`ExtensionEvents`].
+    pub fn try_global(cx: &App) -> Option<Entity<Self>> {
+        return cx
+            .try_global::<GlobalExtensionEvents>()
+            .map(|g| g.0.clone());
+    }
+
+    fn new(_cx: &mut Context<Self>) -> Self {
+        Self
+    }
+
+    pub fn emit(&mut self, event: Event, cx: &mut Context<Self>) {
+        cx.emit(event)
+    }
+}
+
+#[derive(Clone)]
+pub enum Event {
+    ExtensionsInstalledChanged,
+}
+
+impl EventEmitter<Event> for ExtensionEvents {}

crates/extension_host/src/extension_host.rs

@@ -14,7 +14,7 @@ use collections::{btree_map, BTreeMap, BTreeSet, HashMap, HashSet};
 use extension::extension_builder::{CompileExtensionOptions, ExtensionBuilder};
 pub use extension::ExtensionManifest;
 use extension::{
-    ExtensionContextServerProxy, ExtensionGrammarProxy, ExtensionHostProxy,
+    ExtensionContextServerProxy, ExtensionEvents, ExtensionGrammarProxy, ExtensionHostProxy,
     ExtensionIndexedDocsProviderProxy, ExtensionLanguageProxy, ExtensionLanguageServerProxy,
     ExtensionSlashCommandProxy, ExtensionSnippetProxy, ExtensionThemeProxy,
 };
@@ -1316,6 +1316,12 @@ impl ExtensionStore {
                 this.proxy.set_extensions_loaded();
                 this.proxy.reload_current_theme(cx);
                 this.proxy.reload_current_icon_theme(cx);
+
+                if let Some(events) = ExtensionEvents::try_global(cx) {
+                    events.update(cx, |this, cx| {
+                        this.emit(extension::Event::ExtensionsInstalledChanged, cx)
+                    });
+                }
             })
             .ok();
         })

crates/extension_host/src/extension_store_test.rs

@@ -714,6 +714,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
         })
         .await
         .unwrap()
+        .unwrap()
         .into_iter()
         .map(|c| c.label.text)
         .collect::<Vec<_>>();
@@ -780,6 +781,7 @@ fn init_test(cx: &mut TestAppContext) {
         let store = SettingsStore::test(cx);
         cx.set_global(store);
         release_channel::init(SemanticVersion::default(), cx);
+        extension::init(cx);
         theme::init(theme::LoadThemes::JustBase, cx);
         Project::init_settings(cx);
         ExtensionSettings::register(cx);

crates/file_finder/src/open_path_prompt.rs

@@ -1,5 +1,5 @@
 use futures::channel::oneshot;
-use fuzzy::StringMatchCandidate;
+use fuzzy::{StringMatch, StringMatchCandidate};
 use picker::{Picker, PickerDelegate};
 use project::DirectoryLister;
 use std::{
@@ -9,7 +9,7 @@ use std::{
         Arc,
     },
 };
-use ui::{prelude::*, LabelLike, ListItemSpacing};
+use ui::{prelude::*, HighlightedLabel, ListItemSpacing};
 use ui::{Context, ListItem, Window};
 use util::{maybe, paths::compare_paths};
 use workspace::Workspace;
@@ -22,6 +22,7 @@ pub struct OpenPathDelegate {
     selected_index: usize,
     directory_state: Option<DirectoryState>,
     matches: Vec<usize>,
+    string_matches: Vec<StringMatch>,
     cancel_flag: Arc<AtomicBool>,
     should_dismiss: bool,
 }
@@ -34,6 +35,7 @@ impl OpenPathDelegate {
             selected_index: 0,
             directory_state: None,
             matches: Vec::new(),
+            string_matches: Vec::new(),
             cancel_flag: Arc::new(AtomicBool::new(false)),
             should_dismiss: true,
         }
@@ -223,6 +225,7 @@ impl PickerDelegate for OpenPathDelegate {
             if suffix == "" {
                 this.update(&mut cx, |this, cx| {
                     this.delegate.matches.clear();
+                    this.delegate.string_matches.clear();
                     this.delegate
                         .matches
                         .extend(match_candidates.iter().map(|m| m.path.id));
@@ -249,6 +252,7 @@ impl PickerDelegate for OpenPathDelegate {
 
             this.update(&mut cx, |this, cx| {
                 this.delegate.matches.clear();
+                this.delegate.string_matches = matches.clone();
                 this.delegate
                     .matches
                     .extend(matches.into_iter().map(|m| m.candidate_id));
@@ -337,13 +341,22 @@ impl PickerDelegate for OpenPathDelegate {
         let m = self.matches.get(ix)?;
         let directory_state = self.directory_state.as_ref()?;
         let candidate = directory_state.match_candidates.get(*m)?;
+        let highlight_positions = self
+            .string_matches
+            .iter()
+            .find(|string_match| string_match.candidate_id == *m)
+            .map(|string_match| string_match.positions.clone())
+            .unwrap_or_default();
 
         Some(
             ListItem::new(ix)
                 .spacing(ListItemSpacing::Sparse)
                 .inset(true)
                 .toggle_state(selected)
-                .child(LabelLike::new().child(candidate.path.string.clone())),
+                .child(HighlightedLabel::new(
+                    candidate.path.string.clone(),
+                    highlight_positions,
+                )),
         )
     }
 

crates/git_ui/src/commit_modal.rs

@@ -146,7 +146,7 @@ impl CommitModal {
         cx: &mut Context<Self>,
     ) -> Self {
         let panel = git_panel.read(cx);
-        let suggested_commit_message = panel.suggest_commit_message(cx);
+        let suggested_commit_message = panel.suggest_commit_message();
 
         let commit_editor = git_panel.update(cx, |git_panel, cx| {
             git_panel.set_modal_open(true, cx);

crates/git_ui/src/git_panel.rs

@@ -358,7 +358,6 @@ pub(crate) fn commit_message_editor(
         EditorMode::AutoHeight { max_lines },
         buffer,
         None,
-        false,
         window,
         cx,
     );
@@ -1413,7 +1412,7 @@ impl GitPanel {
             return Some(message.to_string());
         }
 
-        self.suggest_commit_message(cx)
+        self.suggest_commit_message()
             .filter(|message| !message.trim().is_empty())
     }
 
@@ -1582,15 +1581,7 @@ impl GitPanel {
     }
 
     /// Suggests a commit message based on the changed files and their statuses
-    pub fn suggest_commit_message(&self, cx: &App) -> Option<String> {
-        if let Some(merge_message) = self
-            .active_repository
-            .as_ref()
-            .and_then(|repo| repo.read(cx).merge_message.as_ref())
-        {
-            return Some(merge_message.clone());
-        }
-
+    pub fn suggest_commit_message(&self) -> Option<String> {
         let git_status_entry = if let Some(staged_entry) = &self.single_staged_entry {
             Some(staged_entry)
         } else if let Some(single_tracked_entry) = &self.single_tracked_entry {
@@ -1726,6 +1717,19 @@ impl GitPanel {
         }));
     }
 
+    fn update_editor_placeholder(&mut self, cx: &mut Context<Self>) {
+        let suggested_commit_message = self.suggest_commit_message();
+        let placeholder_text = suggested_commit_message
+            .as_deref()
+            .unwrap_or("Enter commit message");
+
+        self.commit_editor.update(cx, |editor, cx| {
+            editor.set_placeholder_text(Arc::from(placeholder_text), cx)
+        });
+
+        cx.notify();
+    }
+
     pub(crate) fn fetch(&mut self, window: &mut Window, cx: &mut Context<Self>) {
         if !self.can_push_and_pull(cx) {
             return;
@@ -2182,6 +2186,7 @@ impl GitPanel {
                             git_panel.clear_pending();
                         }
                         git_panel.update_visible_entries(cx);
+                        git_panel.update_editor_placeholder(cx);
                         git_panel.update_scrollbar_properties(window, cx);
                     })
                     .ok();
@@ -2217,7 +2222,7 @@ impl GitPanel {
                     git_panel.commit_editor = cx.new(|cx| {
                         commit_message_editor(
                             buffer,
-                            git_panel.suggest_commit_message(cx).as_deref(),
+                            git_panel.suggest_commit_message().as_deref(),
                             git_panel.project.clone(),
                             true,
                             window,
@@ -2237,15 +2242,7 @@ impl GitPanel {
     fn update_visible_entries(&mut self, cx: &mut Context<Self>) {
         self.entries.clear();
         self.single_staged_entry.take();
-        self.single_tracked_entry.take();
-        self.conflicted_count = 0;
-        self.conflicted_staged_count = 0;
-        self.new_count = 0;
-        self.tracked_count = 0;
-        self.new_staged_count = 0;
-        self.tracked_staged_count = 0;
-        self.entry_count = 0;
-
+        self.single_staged_entry.take();
         let mut changed_entries = Vec::new();
         let mut new_entries = Vec::new();
         let mut conflict_entries = Vec::new();
@@ -2397,15 +2394,6 @@ impl GitPanel {
 
         self.select_first_entry_if_none(cx);
 
-        let suggested_commit_message = self.suggest_commit_message(cx);
-        let placeholder_text = suggested_commit_message
-            .as_deref()
-            .unwrap_or("Enter commit message");
-
-        self.commit_editor.update(cx, |editor, cx| {
-            editor.set_placeholder_text(Arc::from(placeholder_text), cx)
-        });
-
         cx.notify();
     }
 
@@ -2929,10 +2917,6 @@ impl GitPanel {
                                         .disabled(!can_commit || self.modal_open)
                                         .on_click({
                                             cx.listener(move |this, _: &ClickEvent, window, cx| {
-                                                telemetry::event!(
-                                                    "Git Committed",
-                                                    source = "Git Panel"
-                                                );
                                                 this.commit_changes(window, cx)
                                             })
                                         }),

crates/git_ui/src/project_diff.rs

@@ -141,13 +141,8 @@ impl ProjectDiff {
         let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite));
 
         let editor = cx.new(|cx| {
-            let mut diff_display_editor = Editor::for_multibuffer(
-                multibuffer.clone(),
-                Some(project.clone()),
-                true,
-                window,
-                cx,
-            );
+            let mut diff_display_editor =
+                Editor::for_multibuffer(multibuffer.clone(), Some(project.clone()), window, cx);
             diff_display_editor.disable_inline_diagnostics();
             diff_display_editor.set_expand_all_diff_hunks(cx);
             diff_display_editor.register_addon(GitPanelAddon {
@@ -924,6 +919,12 @@ impl Render for ProjectDiffToolbar {
                                     &StageAndNext,
                                     &focus_handle,
                                 ))
+                                // don't actually disable the button so it's mashable
+                                .color(if button_states.stage {
+                                    Color::Default
+                                } else {
+                                    Color::Disabled
+                                })
                                 .on_click(cx.listener(|this, _, window, cx| {
                                     this.dispatch_action(&StageAndNext, window, cx)
                                 })),
@@ -935,6 +936,11 @@ impl Render for ProjectDiffToolbar {
                                     &UnstageAndNext,
                                     &focus_handle,
                                 ))
+                                .color(if button_states.unstage {
+                                    Color::Default
+                                } else {
+                                    Color::Disabled
+                                })
                                 .on_click(cx.listener(|this, _, window, cx| {
                                     this.dispatch_action(&UnstageAndNext, window, cx)
                                 })),

crates/gpui/Cargo.toml

@@ -98,8 +98,8 @@ profiling.workspace = true
 rand = { optional = true, workspace = true }
 raw-window-handle = "0.6"
 refineable.workspace = true
-resvg = { version = "0.44.0", default-features = false }
-usvg = { version = "0.44.0", default-features = false }
+resvg = { version = "0.45.0", default-features = false, features = ["text", "system-fonts", "memmap-fonts"] }
+usvg = { version = "0.45.0", default-features = false }
 schemars.workspace = true
 seahash = "4.1"
 semantic_version.workspace = true

crates/gpui/src/app.rs

@@ -1046,7 +1046,7 @@ impl App {
         &self.foreground_executor
     }
 
-    /// Spawns the future returned by the given function on the thread pool. The closure will be invoked
+    /// Spawns the future returned by the given function on the main thread. The closure will be invoked
     /// with [AsyncApp], which allows the application state to be accessed across await points.
     #[track_caller]
     pub fn spawn<Fut, R>(&self, f: impl FnOnce(AsyncApp) -> Fut) -> Task<R>

crates/gpui/src/elements/div.rs

@@ -1948,6 +1948,14 @@ impl Interactivity {
                             if pending_mouse_down.is_some() && hitbox.is_hovered(window) {
                                 captured_mouse_down = pending_mouse_down.take();
                                 window.refresh();
+                            } else if pending_mouse_down.is_some() {
+                                // Clear the pending mouse down event (without firing click handlers)
+                                // if the hitbox is not being hovered.
+                                // This avoids dragging elements that changed their position
+                                // immediately after being clicked.
+                                // See https://github.com/zed-industries/zed/issues/24600 for more details
+                                pending_mouse_down.take();
+                                window.refresh();
                             }
                         }
                         // Fire click handlers during the bubble phase.

crates/gpui/src/platform/mac/window.rs

@@ -512,6 +512,8 @@ impl MacWindow {
         unsafe {
             let pool = NSAutoreleasePool::new(nil);
 
+            let () = msg_send![class!(NSWindow), setAllowsAutomaticWindowTabbing: NO];
+
             let mut style_mask;
             if let Some(titlebar) = titlebar.as_ref() {
                 style_mask = NSWindowStyleMask::NSClosableWindowMask

crates/gpui/src/svg_renderer.rs

@@ -1,7 +1,10 @@
 use crate::{AssetSource, DevicePixels, IsZero, Result, SharedString, Size};
 use anyhow::anyhow;
 use resvg::tiny_skia::Pixmap;
-use std::{hash::Hash, sync::Arc};
+use std::{
+    hash::Hash,
+    sync::{Arc, LazyLock},
+};
 
 /// When rendering SVGs, we render them at twice the size to get a higher-quality result.
 pub const SMOOTH_SVG_SCALE_FACTOR: f32 = 2.;
@@ -15,6 +18,7 @@ pub(crate) struct RenderSvgParams {
 #[derive(Clone)]
 pub struct SvgRenderer {
     asset_source: Arc<dyn AssetSource>,
+    usvg_options: Arc<usvg::Options<'static>>,
 }
 
 pub enum SvgSize {
@@ -24,7 +28,31 @@ pub enum SvgSize {
 
 impl SvgRenderer {
     pub fn new(asset_source: Arc<dyn AssetSource>) -> Self {
-        Self { asset_source }
+        let font_db = LazyLock::new(|| {
+            let mut db = usvg::fontdb::Database::new();
+            db.load_system_fonts();
+            Arc::new(db)
+        });
+        let default_font_resolver = usvg::FontResolver::default_font_selector();
+        let font_resolver = Box::new(
+            move |font: &usvg::Font, db: &mut Arc<usvg::fontdb::Database>| {
+                if db.is_empty() {
+                    *db = font_db.clone();
+                }
+                default_font_resolver(font, db)
+            },
+        );
+        let options = usvg::Options {
+            font_resolver: usvg::FontResolver {
+                select_font: font_resolver,
+                select_fallback: usvg::FontResolver::default_fallback_selector(),
+            },
+            ..Default::default()
+        };
+        Self {
+            asset_source,
+            usvg_options: Arc::new(options),
+        }
     }
 
     pub(crate) fn render(&self, params: &RenderSvgParams) -> Result<Option<Vec<u8>>> {
@@ -49,7 +77,7 @@ impl SvgRenderer {
     }
 
     pub fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
-        let tree = usvg::Tree::from_data(bytes, &usvg::Options::default())?;
+        let tree = usvg::Tree::from_data(bytes, &self.usvg_options)?;
 
         let size = match size {
             SvgSize::Size(size) => size,

crates/inline_completion_button/src/inline_completion_button.rs

@@ -18,7 +18,7 @@ use gpui::{
 use indoc::indoc;
 use language::{
     language_settings::{self, all_language_settings, AllLanguageSettings, EditPredictionProvider},
-    File, Language,
+    EditPredictionsMode, File, Language,
 };
 use regex::Regex;
 use settings::{update_settings_file, Settings, SettingsStore};
@@ -456,13 +456,47 @@ impl InlineCompletionButton {
         }
 
         let settings = AllLanguageSettings::get_global(cx);
+
         let globally_enabled = settings.show_edit_predictions(None, cx);
         menu = menu.toggleable_entry("All Files", globally_enabled, IconPosition::Start, None, {
             let fs = fs.clone();
             move |_, cx| toggle_inline_completions_globally(fs.clone(), cx)
         });
-        menu = menu.separator().header("Privacy Settings");
 
+        menu = menu.separator().header("Display Modes");
+        let current_mode = settings.edit_predictions_mode();
+        let subtle_mode = matches!(current_mode, EditPredictionsMode::Subtle);
+        let eager_mode = matches!(current_mode, EditPredictionsMode::Eager);
+
+        menu = menu.item(
+            ContextMenuEntry::new("Eager")
+                .toggleable(IconPosition::Start, eager_mode)
+                .documentation_aside(move |_| {
+                    Label::new("Display predictions inline when there are no language server completions available.").into_any_element()
+                })
+                .handler({
+                    let fs = fs.clone();
+                    move |_, cx| {
+                        toggle_edit_prediction_mode(fs.clone(), EditPredictionsMode::Eager, cx)
+                    }
+                }),
+        );
+
+        menu = menu.item(
+            ContextMenuEntry::new("Subtle")
+                .toggleable(IconPosition::Start, subtle_mode)
+                .documentation_aside(move |_| {
+                    Label::new("Display predictions inline only when holding a modifier key (alt by default).").into_any_element()
+                })
+                .handler({
+                    let fs = fs.clone();
+                    move |_, cx| {
+                        toggle_edit_prediction_mode(fs.clone(), EditPredictionsMode::Subtle, cx)
+                    }
+                }),
+        );
+
+        menu = menu.separator().header("Privacy Settings");
         if let Some(provider) = &self.edit_prediction_provider {
             let data_collection = provider.data_collection_state(cx);
             if data_collection.is_supported() {
@@ -590,44 +624,6 @@ impl InlineCompletionButton {
             );
         }
 
-        if cx.has_flag::<feature_flags::PredictEditsNonEagerModeFeatureFlag>() {
-            let is_eager_preview_enabled = match settings.edit_predictions_mode() {
-                language::EditPredictionsMode::Subtle => false,
-                language::EditPredictionsMode::Eager => true,
-            };
-            menu = menu.separator().toggleable_entry(
-                "Eager Preview Mode",
-                is_eager_preview_enabled,
-                IconPosition::Start,
-                None,
-                {
-                    let fs = fs.clone();
-                    move |_window, cx| {
-                        update_settings_file::<AllLanguageSettings>(
-                            fs.clone(),
-                            cx,
-                            move |settings, _cx| {
-                                let new_mode = match is_eager_preview_enabled {
-                                    true => language::EditPredictionsMode::Subtle,
-                                    false => language::EditPredictionsMode::Eager,
-                                };
-
-                                if let Some(edit_predictions) = settings.edit_predictions.as_mut() {
-                                    edit_predictions.mode = new_mode;
-                                } else {
-                                    settings.edit_predictions =
-                                        Some(language_settings::EditPredictionSettingsContent {
-                                            mode: new_mode,
-                                            ..Default::default()
-                                        });
-                                }
-                            },
-                        );
-                    }
-                },
-            );
-        }
-
         if let Some(editor_focus_handle) = self.editor_focus_handle.clone() {
             menu = menu
                 .separator()
@@ -861,3 +857,22 @@ fn hide_copilot(fs: Arc<dyn Fs>, cx: &mut App) {
             .edit_prediction_provider = Some(EditPredictionProvider::None);
     });
 }
+
+fn toggle_edit_prediction_mode(fs: Arc<dyn Fs>, mode: EditPredictionsMode, cx: &mut App) {
+    let settings = AllLanguageSettings::get_global(cx);
+    let current_mode = settings.edit_predictions_mode();
+
+    if current_mode != mode {
+        update_settings_file::<AllLanguageSettings>(fs, cx, move |settings, _cx| {
+            if let Some(edit_predictions) = settings.edit_predictions.as_mut() {
+                edit_predictions.mode = mode;
+            } else {
+                settings.edit_predictions =
+                    Some(language_settings::EditPredictionSettingsContent {
+                        mode,
+                        ..Default::default()
+                    });
+            }
+        });
+    }
+}

crates/language/src/buffer.rs

@@ -526,8 +526,8 @@ impl DerefMut for ChunkRendererContext<'_, '_> {
 /// A set of edits to a given version of a buffer, computed asynchronously.
 #[derive(Debug)]
 pub struct Diff {
-    pub(crate) base_version: clock::Global,
-    line_ending: LineEnding,
+    pub base_version: clock::Global,
+    pub line_ending: LineEnding,
     pub edits: Vec<(Range<usize>, Arc<str>)>,
 }
 
@@ -4145,6 +4145,72 @@ impl BufferSnapshot {
             None
         }
     }
+
+    pub fn words_in_range(&self, query: WordsQuery) -> HashMap<String, Range<Anchor>> {
+        let query_str = query.fuzzy_contents;
+        if query_str.map_or(false, |query| query.is_empty()) {
+            return HashMap::default();
+        }
+
+        let classifier = CharClassifier::new(self.language.clone().map(|language| LanguageScope {
+            language,
+            override_id: None,
+        }));
+
+        let mut query_ix = 0;
+        let query_chars = query_str.map(|query| query.chars().collect::<Vec<_>>());
+        let query_len = query_chars.as_ref().map_or(0, |query| query.len());
+
+        let mut words = HashMap::default();
+        let mut current_word_start_ix = None;
+        let mut chunk_ix = query.range.start;
+        for chunk in self.chunks(query.range, false) {
+            for (i, c) in chunk.text.char_indices() {
+                let ix = chunk_ix + i;
+                if classifier.is_word(c) {
+                    if current_word_start_ix.is_none() {
+                        current_word_start_ix = Some(ix);
+                    }
+
+                    if let Some(query_chars) = &query_chars {
+                        if query_ix < query_len {
+                            if c.to_lowercase().eq(query_chars[query_ix].to_lowercase()) {
+                                query_ix += 1;
+                            }
+                        }
+                    }
+                    continue;
+                } else if let Some(word_start) = current_word_start_ix.take() {
+                    if query_ix == query_len {
+                        let word_range = self.anchor_before(word_start)..self.anchor_after(ix);
+                        let mut word_text = self.text_for_range(word_start..ix).peekable();
+                        let first_char = word_text
+                            .peek()
+                            .and_then(|first_chunk| first_chunk.chars().next());
+                        // Skip empty and "words" starting with digits as a heuristic to reduce useless completions
+                        if !query.skip_digits
+                            || first_char.map_or(true, |first_char| !first_char.is_digit(10))
+                        {
+                            words.insert(word_text.collect(), word_range);
+                        }
+                    }
+                }
+                query_ix = 0;
+            }
+            chunk_ix += chunk.text.len();
+        }
+
+        words
+    }
+}
+
+pub struct WordsQuery<'a> {
+    /// Only returns words with all chars from the fuzzy string in them.
+    pub fuzzy_contents: Option<&'a str>,
+    /// Skips words that start with a digit.
+    pub skip_digits: bool,
+    /// Buffer offset range, to look for words.
+    pub range: Range<usize>,
 }
 
 fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize {

crates/language/src/buffer_tests.rs

@@ -13,6 +13,7 @@ use proto::deserialize_operation;
 use rand::prelude::*;
 use regex::RegexBuilder;
 use settings::SettingsStore;
+use std::collections::BTreeSet;
 use std::{
     env,
     ops::Range,
@@ -3140,6 +3141,150 @@ fn test_trailing_whitespace_ranges(mut rng: StdRng) {
     );
 }
 
+#[gpui::test]
+fn test_words_in_range(cx: &mut gpui::App) {
+    init_settings(cx, |_| {});
+
+    // The first line are words excluded from the results with heuristics, we do not expect them in the test assertions.
+    let contents = r#"
+0_isize 123 3.4 4  
+let word=öäpple.bar你 Öäpple word2-öÄpPlE-Pizza-word ÖÄPPLE word
+    "#;
+
+    let buffer = cx.new(|cx| {
+        let buffer = Buffer::local(contents, cx).with_language(Arc::new(rust_lang()), cx);
+        assert_eq!(buffer.text(), contents);
+        buffer.check_invariants();
+        buffer
+    });
+
+    buffer.update(cx, |buffer, _| {
+        let snapshot = buffer.snapshot();
+        assert_eq!(
+            BTreeSet::from_iter(["Pizza".to_string()]),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: Some("piz"),
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::from_iter([
+                "öäpple".to_string(),
+                "Öäpple".to_string(),
+                "öÄpPlE".to_string(),
+                "ÖÄPPLE".to_string(),
+            ]),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: Some("öp"),
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::from_iter([
+                "öÄpPlE".to_string(),
+                "Öäpple".to_string(),
+                "ÖÄPPLE".to_string(),
+                "öäpple".to_string(),
+            ]),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: Some("öÄ"),
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::default(),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: Some("öÄ好"),
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::from_iter(["bar你".to_string(),]),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: Some("你"),
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::default(),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: Some(""),
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                },)
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::from_iter([
+                "bar你".to_string(),
+                "öÄpPlE".to_string(),
+                "Öäpple".to_string(),
+                "ÖÄPPLE".to_string(),
+                "öäpple".to_string(),
+                "let".to_string(),
+                "Pizza".to_string(),
+                "word".to_string(),
+                "word2".to_string(),
+            ]),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: None,
+                    skip_digits: true,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+        assert_eq!(
+            BTreeSet::from_iter([
+                "0_isize".to_string(),
+                "123".to_string(),
+                "3".to_string(),
+                "4".to_string(),
+                "bar你".to_string(),
+                "öÄpPlE".to_string(),
+                "Öäpple".to_string(),
+                "ÖÄPPLE".to_string(),
+                "öäpple".to_string(),
+                "let".to_string(),
+                "Pizza".to_string(),
+                "word".to_string(),
+                "word2".to_string(),
+            ]),
+            snapshot
+                .words_in_range(WordsQuery {
+                    fuzzy_contents: None,
+                    skip_digits: false,
+                    range: 0..snapshot.len(),
+                })
+                .into_keys()
+                .collect::<BTreeSet<_>>()
+        );
+    });
+}
+
 fn ruby_lang() -> Language {
     Language::new(
         LanguageConfig {

crates/language/src/language.rs

@@ -555,6 +555,23 @@ pub trait LspAdapter: 'static + Send + Sync {
         // By default all language servers are rooted at the root of the worktree.
         Some(Arc::from("".as_ref()))
     }
+
+    /// Method only implemented by the default JSON language server adapter.
+    /// Used to provide dynamic reloading of the JSON schemas used to
+    /// provide autocompletion and diagnostics in Zed setting and keybind
+    /// files
+    fn is_primary_zed_json_schema_adapter(&self) -> bool {
+        false
+    }
+
+    /// Method only implemented by the default JSON language server adapter.
+    /// Used to clear the cache of JSON schemas that are used to provide
+    /// autocompletion and diagnostics in Zed settings and keybinds files.
+    /// Should not be called unless the callee is sure that
+    /// `Self::is_primary_zed_json_schema_adapter` returns `true`
+    async fn clear_zed_json_schema_cache(&self) {
+        unreachable!("Not implemented for this adapter. This method should only be called on the default JSON language server adapter");
+    }
 }
 
 async fn try_fetch_server_binary<L: LspAdapter + 'static + Send + Sync + ?Sized>(

crates/language/src/language_settings.rs

@@ -79,10 +79,10 @@ pub struct LanguageSettings {
     /// The column at which to soft-wrap lines, for buffers where soft-wrap
     /// is enabled.
     pub preferred_line_length: u32,
-    // Whether to show wrap guides (vertical rulers) in the editor.
-    // Setting this to true will show a guide at the 'preferred_line_length' value
-    // if softwrap is set to 'preferred_line_length', and will show any
-    // additional guides as specified by the 'wrap_guides' setting.
+    /// Whether to show wrap guides (vertical rulers) in the editor.
+    /// Setting this to true will show a guide at the 'preferred_line_length' value
+    /// if softwrap is set to 'preferred_line_length', and will show any
+    /// additional guides as specified by the 'wrap_guides' setting.
     pub show_wrap_guides: bool,
     /// Character counts at which to show wrap guides (vertical rulers) in the editor.
     pub wrap_guides: Vec<usize>,
@@ -137,7 +137,7 @@ pub struct LanguageSettings {
     pub use_on_type_format: bool,
     /// Whether indentation of pasted content should be adjusted based on the context.
     pub auto_indent_on_paste: bool,
-    // Controls how the editor handles the autoclosed characters.
+    /// Controls how the editor handles the autoclosed characters.
     pub always_treat_brackets_as_autoclosed: bool,
     /// Which code actions to run on save
     pub code_actions_on_format: HashMap<String, bool>,
@@ -151,6 +151,8 @@ pub struct LanguageSettings {
     /// Whether to display inline and alongside documentation for items in the
     /// completions menu.
     pub show_completion_documentation: bool,
+    /// Completion settings for this language.
+    pub completions: CompletionSettings,
 }
 
 impl LanguageSettings {
@@ -306,6 +308,51 @@ pub struct AllLanguageSettingsContent {
     pub file_types: HashMap<Arc<str>, Vec<String>>,
 }
 
+/// Controls how completions are processed for this language.
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct CompletionSettings {
+    /// Controls how words are completed.
+    /// For large documents, not all words may be fetched for completion.
+    ///
+    /// Default: `fallback`
+    #[serde(default = "default_words_completion_mode")]
+    pub words: WordsCompletionMode,
+    /// Whether to fetch LSP completions or not.
+    ///
+    /// Default: true
+    #[serde(default = "default_true")]
+    pub lsp: bool,
+    /// When fetching LSP completions, determines how long to wait for a response of a particular server.
+    /// When set to 0, waits indefinitely.
+    ///
+    /// Default: 0
+    #[serde(default = "default_lsp_fetch_timeout_ms")]
+    pub lsp_fetch_timeout_ms: u64,
+}
+
+/// Controls how document's words are completed.
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum WordsCompletionMode {
+    /// Always fetch document's words for completions along with LSP completions.
+    Enabled,
+    /// Only if LSP response errors or times out,
+    /// use document's words to show completions.
+    Fallback,
+    /// Never fetch or complete document's words for completions.
+    /// (Word-based completions can still be queried via a separate action)
+    Disabled,
+}
+
+fn default_words_completion_mode() -> WordsCompletionMode {
+    WordsCompletionMode::Fallback
+}
+
+fn default_lsp_fetch_timeout_ms() -> u64 {
+    0
+}
+
 /// The settings for a particular language.
 #[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
 pub struct LanguageSettingsContent {
@@ -478,6 +525,8 @@ pub struct LanguageSettingsContent {
     ///
     /// Default: true
     pub show_completion_documentation: Option<bool>,
+    /// Controls how completions are processed for this language.
+    pub completions: Option<CompletionSettings>,
 }
 
 /// The behavior of `editor::Rewrap`.
@@ -532,8 +581,6 @@ pub struct CopilotSettingsContent {
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct FeaturesContent {
-    /// Whether the GitHub Copilot feature is enabled.
-    pub copilot: Option<bool>,
     /// Determines which edit prediction provider to use.
     pub edit_prediction_provider: Option<EditPredictionProvider>,
 }
@@ -1110,7 +1157,6 @@ impl settings::Settings for AllLanguageSettings {
             languages.insert(language_name.clone(), language_settings);
         }
 
-        let mut copilot_enabled = default_value.features.as_ref().and_then(|f| f.copilot);
         let mut edit_prediction_provider = default_value
             .features
             .as_ref()
@@ -1157,9 +1203,6 @@ impl settings::Settings for AllLanguageSettings {
         }
 
         for user_settings in sources.customizations() {
-            if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
-                copilot_enabled = Some(copilot);
-            }
             if let Some(provider) = user_settings
                 .features
                 .as_ref()
@@ -1234,8 +1277,6 @@ impl settings::Settings for AllLanguageSettings {
             edit_predictions: EditPredictionSettings {
                 provider: if let Some(provider) = edit_prediction_provider {
                     provider
-                } else if copilot_enabled.unwrap_or(true) {
-                    EditPredictionProvider::Copilot
                 } else {
                     EditPredictionProvider::None
                 },
@@ -1381,6 +1422,7 @@ fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent
         &mut settings.show_completion_documentation,
         src.show_completion_documentation,
     );
+    merge(&mut settings.completions, src.completions);
 }
 
 /// Allows to enable/disable formatting with Prettier

crates/language_model/src/language_model.rs

@@ -17,9 +17,11 @@ use proto::Plan;
 use schemars::JsonSchema;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::fmt;
+use std::ops::{Add, Sub};
 use std::{future::Future, sync::Arc};
 use thiserror::Error;
 use ui::IconName;
+use util::serde::is_default;
 
 pub use crate::model::*;
 pub use crate::rate_limiter::*;
@@ -59,6 +61,7 @@ pub enum LanguageModelCompletionEvent {
     Text(String),
     ToolUse(LanguageModelToolUse),
     StartMessage { message_id: String },
+    UsageUpdate(TokenUsage),
 }
 
 #[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)]
@@ -69,6 +72,46 @@ pub enum StopReason {
     ToolUse,
 }
 
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize, Default)]
+pub struct TokenUsage {
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub input_tokens: u32,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub output_tokens: u32,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub cache_creation_input_tokens: u32,
+    #[serde(default, skip_serializing_if = "is_default")]
+    pub cache_read_input_tokens: u32,
+}
+
+impl Add<TokenUsage> for TokenUsage {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self {
+            input_tokens: self.input_tokens + other.input_tokens,
+            output_tokens: self.output_tokens + other.output_tokens,
+            cache_creation_input_tokens: self.cache_creation_input_tokens
+                + other.cache_creation_input_tokens,
+            cache_read_input_tokens: self.cache_read_input_tokens + other.cache_read_input_tokens,
+        }
+    }
+}
+
+impl Sub<TokenUsage> for TokenUsage {
+    type Output = Self;
+
+    fn sub(self, other: Self) -> Self {
+        Self {
+            input_tokens: self.input_tokens - other.input_tokens,
+            output_tokens: self.output_tokens - other.output_tokens,
+            cache_creation_input_tokens: self.cache_creation_input_tokens
+                - other.cache_creation_input_tokens,
+            cache_read_input_tokens: self.cache_read_input_tokens - other.cache_read_input_tokens,
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
 pub struct LanguageModelToolUseId(Arc<str>);
 
@@ -176,6 +219,7 @@ pub trait LanguageModel: Send + Sync {
                         Ok(LanguageModelCompletionEvent::Text(text)) => Some(Ok(text)),
                         Ok(LanguageModelCompletionEvent::Stop(_)) => None,
                         Ok(LanguageModelCompletionEvent::ToolUse(_)) => None,
+                        Ok(LanguageModelCompletionEvent::UsageUpdate(_)) => None,
                         Err(err) => Some(Err(err)),
                     }
                 }))

crates/language_models/Cargo.toml

@@ -33,6 +33,7 @@ gpui_tokio.workspace = true
 http_client.workspace = true
 language_model.workspace = true
 lmstudio = { workspace = true, features = ["schemars"] }
+log.workspace = true
 menu.workspace = true
 mistral = { workspace = true, features = ["schemars"] }
 ollama = { workspace = true, features = ["schemars"] }

crates/language_models/src/provider/anthropic.rs

@@ -1,6 +1,6 @@
 use crate::ui::InstructionListItem;
 use crate::AllLanguageModelSettings;
-use anthropic::{AnthropicError, ContentDelta, Event, ResponseContent};
+use anthropic::{AnthropicError, ContentDelta, Event, ResponseContent, Usage};
 use anyhow::{anyhow, Context as _, Result};
 use collections::{BTreeMap, HashMap};
 use credentials_provider::CredentialsProvider;
@@ -582,12 +582,16 @@ pub fn map_to_language_model_completion_events(
     struct State {
         events: Pin<Box<dyn Send + Stream<Item = Result<Event, AnthropicError>>>>,
         tool_uses_by_index: HashMap<usize, RawToolUse>,
+        usage: Usage,
+        stop_reason: StopReason,
     }
 
     futures::stream::unfold(
         State {
             events,
             tool_uses_by_index: HashMap::default(),
+            usage: Usage::default(),
+            stop_reason: StopReason::EndTurn,
         },
         |mut state| async move {
             while let Some(event) = state.events.next().await {
@@ -599,7 +603,7 @@ pub fn map_to_language_model_completion_events(
                         } => match content_block {
                             ResponseContent::Text { text } => {
                                 return Some((
-                                    Some(Ok(LanguageModelCompletionEvent::Text(text))),
+                                    vec![Ok(LanguageModelCompletionEvent::Text(text))],
                                     state,
                                 ));
                             }
@@ -612,28 +616,25 @@ pub fn map_to_language_model_completion_events(
                                         input_json: String::new(),
                                     },
                                 );
-
-                                return Some((None, state));
                             }
                         },
                         Event::ContentBlockDelta { index, delta } => match delta {
                             ContentDelta::TextDelta { text } => {
                                 return Some((
-                                    Some(Ok(LanguageModelCompletionEvent::Text(text))),
+                                    vec![Ok(LanguageModelCompletionEvent::Text(text))],
                                     state,
                                 ));
                             }
                             ContentDelta::InputJsonDelta { partial_json } => {
                                 if let Some(tool_use) = state.tool_uses_by_index.get_mut(&index) {
                                     tool_use.input_json.push_str(&partial_json);
-                                    return Some((None, state));
                                 }
                             }
                         },
                         Event::ContentBlockStop { index } => {
                             if let Some(tool_use) = state.tool_uses_by_index.remove(&index) {
                                 return Some((
-                                    Some(maybe!({
+                                    vec![maybe!({
                                         Ok(LanguageModelCompletionEvent::ToolUse(
                                             LanguageModelToolUse {
                                                 id: tool_use.id.into(),
@@ -650,44 +651,63 @@ pub fn map_to_language_model_completion_events(
                                                 },
                                             },
                                         ))
-                                    })),
+                                    })],
                                     state,
                                 ));
                             }
                         }
                         Event::MessageStart { message } => {
+                            update_usage(&mut state.usage, &message.usage);
                             return Some((
-                                Some(Ok(LanguageModelCompletionEvent::StartMessage {
-                                    message_id: message.id,
-                                })),
+                                vec![
+                                    Ok(LanguageModelCompletionEvent::StartMessage {
+                                        message_id: message.id,
+                                    }),
+                                    Ok(LanguageModelCompletionEvent::UsageUpdate(convert_usage(
+                                        &state.usage,
+                                    ))),
+                                ],
                                 state,
-                            ))
+                            ));
                         }
-                        Event::MessageDelta { delta, .. } => {
+                        Event::MessageDelta { delta, usage } => {
+                            update_usage(&mut state.usage, &usage);
                             if let Some(stop_reason) = delta.stop_reason.as_deref() {
-                                let stop_reason = match stop_reason {
+                                state.stop_reason = match stop_reason {
                                     "end_turn" => StopReason::EndTurn,
                                     "max_tokens" => StopReason::MaxTokens,
                                     "tool_use" => StopReason::ToolUse,
-                                    _ => StopReason::EndTurn,
+                                    _ => {
+                                        log::error!(
+                                            "Unexpected anthropic stop_reason: {stop_reason}"
+                                        );
+                                        StopReason::EndTurn
+                                    }
                                 };
-
-                                return Some((
-                                    Some(Ok(LanguageModelCompletionEvent::Stop(stop_reason))),
-                                    state,
-                                ));
                             }
+                            return Some((
+                                vec![Ok(LanguageModelCompletionEvent::UsageUpdate(
+                                    convert_usage(&state.usage),
+                                ))],
+                                state,
+                            ));
+                        }
+                        Event::MessageStop => {
+                            return Some((
+                                vec![Ok(LanguageModelCompletionEvent::Stop(state.stop_reason))],
+                                state,
+                            ));
                         }
                         Event::Error { error } => {
                             return Some((
-                                Some(Err(anyhow!(AnthropicError::ApiError(error)))),
+                                vec![Err(anyhow!(AnthropicError::ApiError(error)))],
                                 state,
                             ));
                         }
                         _ => {}
                     },
                     Err(err) => {
-                        return Some((Some(Err(anyhow!(err))), state));
+                        return Some((vec![Err(anyhow!(err))], state));
                     }
                 }
             }
@@ -695,7 +715,32 @@ pub fn map_to_language_model_completion_events(
             None
         },
     )
-    .filter_map(|event| async move { event })
+    .flat_map(futures::stream::iter)
+}
+
+/// Updates usage data by preferring counts from `new`.
+fn update_usage(usage: &mut Usage, new: &Usage) {
+    if let Some(input_tokens) = new.input_tokens {
+        usage.input_tokens = Some(input_tokens);
+    }
+    if let Some(output_tokens) = new.output_tokens {
+        usage.output_tokens = Some(output_tokens);
+    }
+    if let Some(cache_creation_input_tokens) = new.cache_creation_input_tokens {
+        usage.cache_creation_input_tokens = Some(cache_creation_input_tokens);
+    }
+    if let Some(cache_read_input_tokens) = new.cache_read_input_tokens {
+        usage.cache_read_input_tokens = Some(cache_read_input_tokens);
+    }
+}
+
+fn convert_usage(usage: &Usage) -> language_model::TokenUsage {
+    language_model::TokenUsage {
+        input_tokens: usage.input_tokens.unwrap_or(0),
+        output_tokens: usage.output_tokens.unwrap_or(0),
+        cache_creation_input_tokens: usage.cache_creation_input_tokens.unwrap_or(0),
+        cache_read_input_tokens: usage.cache_read_input_tokens.unwrap_or(0),
+    }
 }
 
 struct ConfigurationView {

crates/language_models/src/provider/copilot_chat.rs

@@ -129,7 +129,7 @@ impl LanguageModelProvider for CopilotChatLanguageModelProvider {
             Status::Error(err) => anyhow!(format!("Received the following error while signing into Copilot: {err}")),
             Status::Starting { task: _ } => anyhow!("Copilot is still starting, please wait for Copilot to start then try again"),
             Status::Unauthorized => anyhow!("Unable to authorize with Copilot. Please make sure that you have an active Copilot and Copilot Chat subscription."),
-            Status::SignedOut => anyhow!("You have signed out of Copilot. Please sign in to Copilot and try again."),
+            Status::SignedOut {..} => anyhow!("You have signed out of Copilot. Please sign in to Copilot and try again."),
             Status::SigningIn { prompt: _ } => anyhow!("Still signing into Copilot..."),
         };
 
@@ -366,7 +366,6 @@ impl Render for ConfigurationView {
 
             match &self.copilot_status {
                 Some(status) => match status {
-                    Status::Disabled => v_flex().gap_6().p_4().child(Label::new(ERROR_LABEL)),
                     Status::Starting { task: _ } => {
                         const LABEL: &str = "Starting Copilot...";
                         v_flex()
@@ -376,7 +375,10 @@ impl Render for ConfigurationView {
                             .child(Label::new(LABEL))
                             .child(loading_icon)
                     }
-                    Status::SigningIn { prompt: _ } => {
+                    Status::SigningIn { prompt: _ }
+                    | Status::SignedOut {
+                        awaiting_signing_in: true,
+                    } => {
                         const LABEL: &str = "Signing in to Copilot...";
                         v_flex()
                             .gap_6()

crates/languages/src/json.rs

@@ -15,6 +15,7 @@ use settings::{KeymapFile, SettingsJsonSchemaParams, SettingsStore};
 use smol::{
     fs::{self},
     io::BufReader,
+    lock::RwLock,
 };
 use std::{
     any::Any,
@@ -22,7 +23,7 @@ use std::{
     ffi::OsString,
     path::{Path, PathBuf},
     str::FromStr,
-    sync::{Arc, OnceLock},
+    sync::Arc,
 };
 use task::{TaskTemplate, TaskTemplates, VariableName};
 use util::{fs::remove_matching, maybe, merge_json_value_into, ResultExt};
@@ -60,7 +61,7 @@ fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
 pub struct JsonLspAdapter {
     node: NodeRuntime,
     languages: Arc<LanguageRegistry>,
-    workspace_config: OnceLock<Value>,
+    workspace_config: RwLock<Option<Value>>,
 }
 
 impl JsonLspAdapter {
@@ -141,6 +142,20 @@ impl JsonLspAdapter {
             }
         })
     }
+
+    async fn get_or_init_workspace_config(&self, cx: &mut AsyncApp) -> Result<Value> {
+        {
+            let reader = self.workspace_config.read().await;
+            if let Some(config) = reader.as_ref() {
+                return Ok(config.clone());
+            }
+        }
+        let mut writer = self.workspace_config.write().await;
+        let config =
+            cx.update(|cx| Self::get_workspace_config(self.languages.language_names(), cx))?;
+        writer.replace(config.clone());
+        return Ok(config);
+    }
 }
 
 #[async_trait(?Send)]
@@ -251,11 +266,7 @@ impl LspAdapter for JsonLspAdapter {
         _: Arc<dyn LanguageToolchainStore>,
         cx: &mut AsyncApp,
     ) -> Result<Value> {
-        let mut config = cx.update(|cx| {
-            self.workspace_config
-                .get_or_init(|| Self::get_workspace_config(self.languages.language_names(), cx))
-                .clone()
-        })?;
+        let mut config = self.get_or_init_workspace_config(cx).await?;
 
         let project_options = cx.update(|cx| {
             language_server_settings(delegate.as_ref(), &self.name(), cx)
@@ -277,6 +288,14 @@ impl LspAdapter for JsonLspAdapter {
         .into_iter()
         .collect()
     }
+
+    fn is_primary_zed_json_schema_adapter(&self) -> bool {
+        true
+    }
+
+    async fn clear_zed_json_schema_cache(&self) {
+        self.workspace_config.write().await.take();
+    }
 }
 
 async fn get_cached_server_binary(

crates/languages/src/json/config.toml

@@ -10,3 +10,8 @@ brackets = [
 ]
 tab_size = 2
 prettier_parser_name = "json"
+scope_opt_in_language_servers = ["json-language-server"]
+
+[overrides.string]
+word_characters = [":"]
+opt_into_language_servers = ["json-language-server"]

crates/languages/src/jsonc/config.toml

@@ -10,3 +10,8 @@ brackets = [
 ]
 tab_size = 2
 prettier_parser_name = "jsonc"
+
+scope_opt_in_language_servers = ["json-language-server"]
+[overrides.string]
+word_characters = [":"]
+opt_into_language_servers = ["json-language-server"]

crates/multi_buffer/src/multi_buffer.rs

@@ -68,7 +68,8 @@ pub struct MultiBuffer {
     /// Contains the state of the buffers being edited
     buffers: RefCell<HashMap<BufferId, BufferState>>,
     // only used by consumers using `set_excerpts_for_buffer`
-    buffers_by_path: BTreeMap<PathKey, Vec<ExcerptId>>,
+    excerpts_by_path: BTreeMap<PathKey, Vec<ExcerptId>>,
+    paths_by_excerpt: HashMap<ExcerptId, PathKey>,
     diffs: HashMap<BufferId, DiffState>,
     // all_diff_hunks_expanded: bool,
     subscriptions: Topic,
@@ -360,12 +361,19 @@ impl ExcerptBoundary {
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct ExpandInfo {
+    pub direction: ExpandExcerptDirection,
+    pub excerpt_id: ExcerptId,
+}
+
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub struct RowInfo {
     pub buffer_id: Option<BufferId>,
     pub buffer_row: Option<u32>,
     pub multibuffer_row: Option<MultiBufferRow>,
     pub diff_status: Option<buffer_diff::DiffHunkStatus>,
+    pub expand_info: Option<ExpandInfo>,
 }
 
 /// A slice into a [`Buffer`] that is being edited in a [`MultiBuffer`].
@@ -438,6 +446,7 @@ pub struct DiffTransformSummary {
 pub struct MultiBufferRows<'a> {
     point: Point,
     is_empty: bool,
+    is_singleton: bool,
     cursor: MultiBufferCursor<'a, Point>,
 }
 
@@ -569,7 +578,8 @@ impl MultiBuffer {
             singleton: false,
             capability,
             title: None,
-            buffers_by_path: Default::default(),
+            excerpts_by_path: Default::default(),
+            paths_by_excerpt: Default::default(),
             buffer_changed_since_sync: Default::default(),
             history: History {
                 next_transaction_id: clock::Lamport::default(),
@@ -585,7 +595,8 @@ impl MultiBuffer {
         Self {
             snapshot: Default::default(),
             buffers: Default::default(),
-            buffers_by_path: Default::default(),
+            excerpts_by_path: Default::default(),
+            paths_by_excerpt: Default::default(),
             diffs: HashMap::default(),
             subscriptions: Default::default(),
             singleton: false,
@@ -630,7 +641,8 @@ impl MultiBuffer {
         Self {
             snapshot: RefCell::new(self.snapshot.borrow().clone()),
             buffers: RefCell::new(buffers),
-            buffers_by_path: Default::default(),
+            excerpts_by_path: Default::default(),
+            paths_by_excerpt: Default::default(),
             diffs: diff_bases,
             subscriptions: Default::default(),
             singleton: self.singleton,
@@ -1470,7 +1482,7 @@ impl MultiBuffer {
     }
 
     pub fn location_for_path(&self, path: &PathKey, cx: &App) -> Option<Anchor> {
-        let excerpt_id = self.buffers_by_path.get(path)?.first()?;
+        let excerpt_id = self.excerpts_by_path.get(path)?.first()?;
         let snapshot = self.snapshot(cx);
         let excerpt = snapshot.excerpt(*excerpt_id)?;
         Some(Anchor::in_buffer(
@@ -1481,7 +1493,93 @@ impl MultiBuffer {
     }
 
     pub fn excerpt_paths(&self) -> impl Iterator<Item = &PathKey> {
-        self.buffers_by_path.keys()
+        self.excerpts_by_path.keys()
+    }
+
+    fn expand_excerpts_with_paths(
+        &mut self,
+        ids: impl IntoIterator<Item = ExcerptId>,
+        line_count: u32,
+        direction: ExpandExcerptDirection,
+        cx: &mut Context<Self>,
+    ) {
+        let grouped = ids
+            .into_iter()
+            .chunk_by(|id| self.paths_by_excerpt.get(id).cloned())
+            .into_iter()
+            .flat_map(|(k, v)| Some((k?, v.into_iter().collect::<Vec<_>>())))
+            .collect::<Vec<_>>();
+        let snapshot = self.snapshot(cx);
+
+        for (path, ids) in grouped.into_iter() {
+            let Some(excerpt_ids) = self.excerpts_by_path.get(&path) else {
+                continue;
+            };
+
+            let ids_to_expand = HashSet::from_iter(ids);
+            let expanded_ranges = excerpt_ids.iter().filter_map(|excerpt_id| {
+                let excerpt = snapshot.excerpt(*excerpt_id)?;
+
+                let mut context = excerpt.range.context.to_point(&excerpt.buffer);
+                if ids_to_expand.contains(excerpt_id) {
+                    match direction {
+                        ExpandExcerptDirection::Up => {
+                            context.start.row = context.start.row.saturating_sub(line_count);
+                            context.start.column = 0;
+                        }
+                        ExpandExcerptDirection::Down => {
+                            context.end.row =
+                                (context.end.row + line_count).min(excerpt.buffer.max_point().row);
+                            context.end.column = excerpt.buffer.line_len(context.end.row);
+                        }
+                        ExpandExcerptDirection::UpAndDown => {
+                            context.start.row = context.start.row.saturating_sub(line_count);
+                            context.start.column = 0;
+                            context.end.row =
+                                (context.end.row + line_count).min(excerpt.buffer.max_point().row);
+                            context.end.column = excerpt.buffer.line_len(context.end.row);
+                        }
+                    }
+                }
+
+                Some(ExcerptRange {
+                    context,
+                    primary: excerpt
+                        .range
+                        .primary
+                        .as_ref()
+                        .map(|range| range.to_point(&excerpt.buffer)),
+                })
+            });
+            let mut merged_ranges: Vec<ExcerptRange<Point>> = Vec::new();
+            for range in expanded_ranges {
+                if let Some(last_range) = merged_ranges.last_mut() {
+                    if last_range.context.end >= range.context.start {
+                        last_range.context.end = range.context.end;
+                        continue;
+                    }
+                }
+                merged_ranges.push(range)
+            }
+            let Some(excerpt_id) = excerpt_ids.first() else {
+                continue;
+            };
+            let Some(buffer_id) = &snapshot.buffer_id_for_excerpt(*excerpt_id) else {
+                continue;
+            };
+
+            let Some(buffer) = self
+                .buffers
+                .borrow()
+                .get(buffer_id)
+                .map(|b| b.buffer.clone())
+            else {
+                continue;
+            };
+
+            let buffer_snapshot = buffer.read(cx).snapshot();
+            self.update_path_excerpts(path.clone(), buffer, &buffer_snapshot, merged_ranges, cx);
+        }
     }
 
     /// Sets excerpts, returns `true` if at least one new excerpt was added.
@@ -1495,15 +1593,30 @@ impl MultiBuffer {
     ) -> bool {
         let buffer_snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
 
+        let (new, _) = build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
+        self.update_path_excerpts(path, buffer, &buffer_snapshot, new, cx)
+    }
+
+    fn update_path_excerpts(
+        &mut self,
+        path: PathKey,
+        buffer: Entity<Buffer>,
+        buffer_snapshot: &BufferSnapshot,
+        new: Vec<ExcerptRange<Point>>,
+        cx: &mut Context<Self>,
+    ) -> bool {
         let mut insert_after = self
-            .buffers_by_path
+            .excerpts_by_path
             .range(..path.clone())
             .next_back()
             .map(|(_, value)| *value.last().unwrap())
             .unwrap_or(ExcerptId::min());
-        let existing = self.buffers_by_path.get(&path).cloned().unwrap_or_default();
 
-        let (new, _) = build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
+        let existing = self
+            .excerpts_by_path
+            .get(&path)
+            .cloned()
+            .unwrap_or_default();
 
         let mut new_iter = new.into_iter().peekable();
         let mut existing_iter = existing.into_iter().peekable();
@@ -1586,20 +1699,23 @@ impl MultiBuffer {
         ));
         self.remove_excerpts(to_remove, cx);
         if new_excerpt_ids.is_empty() {
-            self.buffers_by_path.remove(&path);
+            self.excerpts_by_path.remove(&path);
         } else {
-            self.buffers_by_path.insert(path, new_excerpt_ids);
+            for excerpt_id in &new_excerpt_ids {
+                self.paths_by_excerpt.insert(*excerpt_id, path.clone());
+            }
+            self.excerpts_by_path.insert(path, new_excerpt_ids);
         }
 
         added_a_new_excerpt
     }
 
     pub fn paths(&self) -> impl Iterator<Item = PathKey> + '_ {
-        self.buffers_by_path.keys().cloned()
+        self.excerpts_by_path.keys().cloned()
     }
 
     pub fn remove_excerpts_for_path(&mut self, path: PathKey, cx: &mut Context<Self>) {
-        if let Some(to_remove) = self.buffers_by_path.remove(&path) {
+        if let Some(to_remove) = self.excerpts_by_path.remove(&path) {
             self.remove_excerpts(to_remove, cx)
         }
     }
@@ -2071,6 +2187,7 @@ impl MultiBuffer {
         let mut removed_buffer_ids = Vec::new();
 
         while let Some(excerpt_id) = excerpt_ids.next() {
+            self.paths_by_excerpt.remove(&excerpt_id);
             // Seek to the next excerpt to remove, preserving any preceding excerpts.
             let locator = snapshot.excerpt_locator_for_id(excerpt_id);
             new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
@@ -2635,6 +2752,10 @@ impl MultiBuffer {
             return;
         }
         self.sync(cx);
+        if !self.excerpts_by_path.is_empty() {
+            self.expand_excerpts_with_paths(ids, line_count, direction, cx);
+            return;
+        }
         let mut snapshot = self.snapshot.borrow_mut();
 
         let ids = ids.into_iter().collect::<Vec<_>>();
@@ -4034,6 +4155,7 @@ impl MultiBufferSnapshot {
         let mut result = MultiBufferRows {
             point: Point::new(0, 0),
             is_empty: self.excerpts.is_empty(),
+            is_singleton: self.is_singleton(),
             cursor,
         };
         result.seek(start_row);
@@ -6216,6 +6338,22 @@ where
         self.cached_region.clone()
     }
 
+    fn is_at_start_of_excerpt(&mut self) -> bool {
+        if self.diff_transforms.start().1 > *self.excerpts.start() {
+            return false;
+        } else if self.diff_transforms.start().1 < *self.excerpts.start() {
+            return true;
+        }
+
+        self.diff_transforms.prev(&());
+        let prev_transform = self.diff_transforms.item();
+        self.diff_transforms.next(&());
+
+        prev_transform.map_or(true, |next_transform| {
+            matches!(next_transform, DiffTransform::BufferContent { .. })
+        })
+    }
+
     fn is_at_end_of_excerpt(&mut self) -> bool {
         if self.diff_transforms.end(&()).1 < self.excerpts.end(&()) {
             return false;
@@ -7092,6 +7230,7 @@ impl Iterator for MultiBufferRows<'_> {
                 buffer_row: Some(0),
                 multibuffer_row: Some(MultiBufferRow(0)),
                 diff_status: None,
+                expand_info: None,
             });
         }
 
@@ -7103,7 +7242,6 @@ impl Iterator for MultiBufferRows<'_> {
             } else {
                 if self.point == self.cursor.diff_transforms.end(&()).0 .0 {
                     let multibuffer_row = MultiBufferRow(self.point.row);
-                    self.point += Point::new(1, 0);
                     let last_excerpt = self
                         .cursor
                         .excerpts
@@ -7115,11 +7253,43 @@ impl Iterator for MultiBufferRows<'_> {
                         .end
                         .to_point(&last_excerpt.buffer)
                         .row;
+
+                    let first_row = last_excerpt
+                        .range
+                        .context
+                        .start
+                        .to_point(&last_excerpt.buffer)
+                        .row;
+
+                    let expand_info = if self.is_singleton {
+                        None
+                    } else {
+                        let needs_expand_up = first_row == last_row
+                            && last_row > 0
+                            && !region.diff_hunk_status.is_some_and(|d| d.is_deleted());
+                        let needs_expand_down = last_row < last_excerpt.buffer.max_point().row;
+
+                        if needs_expand_up && needs_expand_down {
+                            Some(ExpandExcerptDirection::UpAndDown)
+                        } else if needs_expand_up {
+                            Some(ExpandExcerptDirection::Up)
+                        } else if needs_expand_down {
+                            Some(ExpandExcerptDirection::Down)
+                        } else {
+                            None
+                        }
+                        .map(|direction| ExpandInfo {
+                            direction,
+                            excerpt_id: last_excerpt.id,
+                        })
+                    };
+                    self.point += Point::new(1, 0);
                     return Some(RowInfo {
                         buffer_id: Some(last_excerpt.buffer_id),
                         buffer_row: Some(last_row),
                         multibuffer_row: Some(multibuffer_row),
                         diff_status: None,
+                        expand_info,
                     });
                 } else {
                     return None;
@@ -7129,6 +7299,33 @@ impl Iterator for MultiBufferRows<'_> {
 
         let overshoot = self.point - region.range.start;
         let buffer_point = region.buffer_range.start + overshoot;
+        let expand_info = if self.is_singleton {
+            None
+        } else {
+            let needs_expand_up = self.point.row == region.range.start.row
+                && self.cursor.is_at_start_of_excerpt()
+                && buffer_point.row > 0;
+            let needs_expand_down = (region.excerpt.has_trailing_newline
+                && self.point.row + 1 == region.range.end.row
+                || !region.excerpt.has_trailing_newline && self.point.row == region.range.end.row)
+                && self.cursor.is_at_end_of_excerpt()
+                && buffer_point.row < region.buffer.max_point().row;
+
+            if needs_expand_up && needs_expand_down {
+                Some(ExpandExcerptDirection::UpAndDown)
+            } else if needs_expand_up {
+                Some(ExpandExcerptDirection::Up)
+            } else if needs_expand_down {
+                Some(ExpandExcerptDirection::Down)
+            } else {
+                None
+            }
+            .map(|direction| ExpandInfo {
+                direction,
+                excerpt_id: region.excerpt.id,
+            })
+        };
+
         let result = Some(RowInfo {
             buffer_id: Some(region.buffer.remote_id()),
             buffer_row: Some(buffer_point.row),
@@ -7136,6 +7333,7 @@ impl Iterator for MultiBufferRows<'_> {
             diff_status: region
                 .diff_hunk_status
                 .filter(|_| self.point < region.range.end),
+            expand_info,
         });
         self.point += Point::new(1, 0);
         result