WIP: start on accumulating exports/imports

.gitignore

@@ -28,3 +28,4 @@ DerivedData/
 .vscode
 .wrangler
 .flatpak-builder
+.aider*

CONTRIBUTING.md

@@ -41,7 +41,7 @@ We plan to set aside time each week to pair program with contributors on promisi
 
 Zed is made up of several smaller crates - let's go over those you're most likely to interact with:
 
-- [`gpui`](/crates/gpui) is a GPU-accelerated UI framework which provides all of the building blocks for Zed. **We recommend familiarizing yourself with the root level GPUI documentation.**
+- [`gpui`](/crates/gpui) is a GPU-accelerated UI framework which provides all of the building blocks for Zed. **We recommend familiarizing yourself with the root level GPUI documentation**
 - [`editor`](/crates/editor) contains the core `Editor` type that drives both the code editor and all various input fields within Zed. It also handles a display layer for LSP features such as Inlay Hints or code completions.
 - [`project`](/crates/project) manages files and navigation within the filetree. It is also Zed's side of communication with LSP.
 - [`workspace`](/crates/workspace) handles local state serialization and groups projects together.

Cargo.toml

@@ -58,6 +58,7 @@ members = [
     "crates/markdown_preview",
     "crates/media",
     "crates/menu",
+    "crates/miner",
     "crates/multi_buffer",
     "crates/node_runtime",
     "crates/notifications",
@@ -240,6 +241,7 @@ task = { path = "crates/task" }
 tasks_ui = { path = "crates/tasks_ui" }
 search = { path = "crates/search" }
 semantic_index = { path = "crates/semantic_index" }
+miner = { path = "crates/miner" }
 semantic_version = { path = "crates/semantic_version" }
 settings = { path = "crates/settings" }
 snippet = { path = "crates/snippet" }
@@ -308,7 +310,7 @@ heed = { version = "0.20.1", features = ["read-txn-no-tls"] }
 hex = "0.4.3"
 html5ever = "0.27.0"
 ignore = "0.4.22"
-image = "0.25.1"
+image = "0.23"
 indexmap = { version = "1.6.2", features = ["serde"] }
 indoc = "1"
 # We explicitly disable http2 support in isahc.

assets/icons/book.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book"><path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H20v20H6.5a2.5 2.5 0 0 1 0-5H20"/></svg>

assets/icons/book_copy.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book-copy"><path d="M2 16V4a2 2 0 0 1 2-2h11"/><path d="M5 14H4a2 2 0 1 0 0 4h1"/><path d="M22 18H11a2 2 0 1 0 0 4h11V6H11a2 2 0 0 0-2 2v12"/></svg>

assets/icons/book_plus.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-book-plus"><path d="M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H20v20H6.5a2.5 2.5 0 0 1 0-5H20"/><path d="M9 10h6"/><path d="M12 7v6"/></svg>

assets/keymaps/default-linux.json

@@ -152,8 +152,7 @@
       //     "focus": false
       //   }
       // ],
-      "ctrl->": "assistant::QuoteSelection",
-      "ctrl-alt-e": "editor::SelectEnclosingSymbol"
+      "ctrl->": "assistant::QuoteSelection"
     }
   },
   {

assets/keymaps/default-macos.json

@@ -188,8 +188,7 @@
           "focus": false
         }
       ],
-      "cmd->": "assistant::QuoteSelection",
-      "cmd-alt-e": "editor::SelectEnclosingSymbol"
+      "cmd->": "assistant::QuoteSelection"
     }
   },
   {

crates/assistant/src/assistant.rs

@@ -10,14 +10,14 @@ mod search;
 mod slash_command;
 mod streaming_diff;
 
-pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
+pub use assistant_panel::AssistantPanel;
+
 use assistant_settings::{AnthropicModel, AssistantSettings, CloudModel, OllamaModel, OpenAiModel};
 use assistant_slash_command::SlashCommandRegistry;
 use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
 pub(crate) use completion_provider::*;
 pub(crate) use context_store::*;
-use fs::Fs;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
 pub(crate) use inline_assistant::*;
 pub(crate) use model_selector::*;
@@ -264,7 +264,7 @@ impl Assistant {
     }
 }
 
-pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, cx: &mut AppContext) {
+pub fn init(client: Arc<Client>, cx: &mut AppContext) {
     cx.set_global(Assistant::default());
     AssistantSettings::register(cx);
 
@@ -288,7 +288,7 @@ pub fn init(fs: Arc<dyn Fs>, client: Arc<Client>, cx: &mut AppContext) {
     assistant_slash_command::init(cx);
     register_slash_commands(cx);
     assistant_panel::init(cx);
-    inline_assistant::init(fs.clone(), client.telemetry().clone(), cx);
+    inline_assistant::init(client.telemetry().clone(), cx);
     RustdocStore::init_global(cx);
 
     CommandPaletteFilter::update_global(cx, |filter, _cx| {
@@ -324,24 +324,6 @@ fn register_slash_commands(cx: &mut AppContext) {
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 }
 
-pub fn humanize_token_count(count: usize) -> String {
-    match count {
-        0..=999 => count.to_string(),
-        1000..=9999 => {
-            let thousands = count / 1000;
-            let hundreds = (count % 1000 + 50) / 100;
-            if hundreds == 0 {
-                format!("{}k", thousands)
-            } else if hundreds == 10 {
-                format!("{}k", thousands + 1)
-            } else {
-                format!("{}.{}k", thousands, hundreds)
-            }
-        }
-        _ => format!("{}k", (count + 500) / 1000),
-    }
-}
-
 #[cfg(test)]
 #[ctor::ctor]
 fn init_logger() {

crates/assistant/src/assistant_panel.rs

@@ -1,6 +1,5 @@
 use crate::{
     assistant_settings::{AssistantDockPosition, AssistantSettings},
-    humanize_token_count,
     prompt_library::open_prompt_library,
     search::*,
     slash_command::{
@@ -90,10 +89,6 @@ pub fn init(cx: &mut AppContext) {
     .detach();
 }
 
-pub enum AssistantPanelEvent {
-    ContextEdited,
-}
-
 pub struct AssistantPanel {
     workspace: WeakView<Workspace>,
     width: Option<Pixels>,
@@ -365,11 +360,11 @@ impl AssistantPanel {
             return;
         }
 
-        let Some(assistant_panel) = workspace.panel::<AssistantPanel>(cx) else {
+        let Some(assistant) = workspace.panel::<AssistantPanel>(cx) else {
             return;
         };
 
-        let context_editor = assistant_panel
+        let context_editor = assistant
             .read(cx)
             .active_context_editor()
             .and_then(|editor| {
@@ -396,37 +391,25 @@ impl AssistantPanel {
             return;
         };
 
-        if assistant_panel.update(cx, |panel, cx| panel.is_authenticated(cx)) {
+        if assistant.update(cx, |assistant, cx| assistant.is_authenticated(cx)) {
             InlineAssistant::update_global(cx, |assistant, cx| {
                 assistant.assist(
                     &active_editor,
                     Some(cx.view().downgrade()),
-                    include_context.then_some(&assistant_panel),
+                    include_context,
                     cx,
                 )
             })
         } else {
-            let assistant_panel = assistant_panel.downgrade();
+            let assistant = assistant.downgrade();
             cx.spawn(|workspace, mut cx| async move {
-                assistant_panel
+                assistant
                     .update(&mut cx, |assistant, cx| assistant.authenticate(cx))?
                     .await?;
-                if assistant_panel
-                    .update(&mut cx, |assistant, cx| assistant.is_authenticated(cx))?
-                {
+                if assistant.update(&mut cx, |assistant, cx| assistant.is_authenticated(cx))? {
                     cx.update(|cx| {
-                        let assistant_panel = if include_context {
-                            assistant_panel.upgrade()
-                        } else {
-                            None
-                        };
                         InlineAssistant::update_global(cx, |assistant, cx| {
-                            assistant.assist(
-                                &active_editor,
-                                Some(workspace),
-                                assistant_panel.as_ref(),
-                                cx,
-                            )
+                            assistant.assist(&active_editor, Some(workspace), include_context, cx)
                         })
                     })?
                 } else {
@@ -477,7 +460,7 @@ impl AssistantPanel {
             _subscriptions: subscriptions,
         });
         self.show_saved_contexts = false;
-        cx.emit(AssistantPanelEvent::ContextEdited);
+
         cx.notify();
     }
 
@@ -489,7 +472,6 @@ impl AssistantPanel {
     ) {
         match event {
             ContextEditorEvent::TabContentChanged => cx.notify(),
-            ContextEditorEvent::Edited => cx.emit(AssistantPanelEvent::ContextEdited),
         }
     }
 
@@ -881,33 +863,18 @@ impl AssistantPanel {
         context: &Model<Context>,
         cx: &mut ViewContext<Self>,
     ) -> Option<impl IntoElement> {
-        let model = CompletionProvider::global(cx).model();
-        let token_count = context.read(cx).token_count()?;
-        let max_token_count = model.max_token_count();
-
-        let remaining_tokens = max_token_count as isize - token_count as isize;
-        let token_count_color = if remaining_tokens <= 0 {
+        let remaining_tokens = context.read(cx).remaining_tokens(cx)?;
+        let remaining_tokens_color = if remaining_tokens <= 0 {
             Color::Error
-        } else if token_count as f32 / max_token_count as f32 >= 0.8 {
+        } else if remaining_tokens <= 500 {
             Color::Warning
         } else {
             Color::Muted
         };
-
         Some(
-            h_flex()
-                .gap_0p5()
-                .child(
-                    Label::new(humanize_token_count(token_count))
-                        .size(LabelSize::Small)
-                        .color(token_count_color),
-                )
-                .child(Label::new("/").size(LabelSize::Small).color(Color::Muted))
-                .child(
-                    Label::new(humanize_token_count(max_token_count))
-                        .size(LabelSize::Small)
-                        .color(Color::Muted),
-                ),
+            Label::new(remaining_tokens.to_string())
+                .size(LabelSize::Small)
+                .color(remaining_tokens_color),
         )
     }
 }
@@ -1011,7 +978,6 @@ impl Panel for AssistantPanel {
 }
 
 impl EventEmitter<PanelEvent> for AssistantPanel {}
-impl EventEmitter<AssistantPanelEvent> for AssistantPanel {}
 
 impl FocusableView for AssistantPanel {
     fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {
@@ -1572,6 +1538,11 @@ impl Context {
         }
     }
 
+    fn remaining_tokens(&self, cx: &AppContext) -> Option<isize> {
+        let model = CompletionProvider::global(cx).model();
+        Some(model.max_token_count() as isize - self.token_count? as isize)
+    }
+
     fn completion_provider_changed(&mut self, cx: &mut ModelContext<Self>) {
         self.count_remaining_tokens(cx);
     }
@@ -2212,7 +2183,6 @@ struct PendingCompletion {
 }
 
 enum ContextEditorEvent {
-    Edited,
     TabContentChanged,
 }
 
@@ -2805,7 +2775,6 @@ impl ContextEditor {
             EditorEvent::SelectionsChanged { .. } => {
                 self.scroll_position = self.cursor_scroll_position(cx);
             }
-            EditorEvent::BufferEdited => cx.emit(ContextEditorEvent::Edited),
             _ => {}
         }
     }

crates/assistant/src/inline_assistant.rs

@@ -1,9 +1,8 @@
 use crate::{
-    assistant_settings::AssistantSettings, humanize_token_count, prompts::generate_content_prompt,
-    AssistantPanel, AssistantPanelEvent, CompletionProvider, Hunk, LanguageModelRequest,
-    LanguageModelRequestMessage, Role, StreamingDiff,
+    prompts::generate_content_prompt, AssistantPanel, CompletionProvider, Hunk,
+    LanguageModelRequest, LanguageModelRequestMessage, Role, StreamingDiff,
 };
-use anyhow::{anyhow, Context as _, Result};
+use anyhow::{Context as _, Result};
 use client::telemetry::Telemetry;
 use collections::{hash_map, HashMap, HashSet, VecDeque};
 use editor::{
@@ -15,7 +14,6 @@ use editor::{
     Anchor, AnchorRangeExt, Editor, EditorElement, EditorEvent, EditorMode, EditorStyle,
     ExcerptRange, GutterDimensions, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint,
 };
-use fs::Fs;
 use futures::{channel::mpsc, SinkExt, Stream, StreamExt};
 use gpui::{
     point, AppContext, EventEmitter, FocusHandle, FocusableView, FontStyle, FontWeight, Global,
@@ -26,7 +24,7 @@ use language::{Buffer, Point, Selection, TransactionId};
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
 use rope::Rope;
-use settings::{update_settings_file, Settings};
+use settings::Settings;
 use similar::TextDiff;
 use std::{
     cmp, mem,
@@ -34,15 +32,15 @@ use std::{
     pin::Pin,
     sync::Arc,
     task::{self, Poll},
-    time::{Duration, Instant},
+    time::Instant,
 };
 use theme::ThemeSettings;
-use ui::{prelude::*, ContextMenu, PopoverMenu, Tooltip};
+use ui::{prelude::*, Tooltip};
 use util::RangeExt;
 use workspace::{notifications::NotificationId, Toast, Workspace};
 
-pub fn init(fs: Arc<dyn Fs>, telemetry: Arc<Telemetry>, cx: &mut AppContext) {
-    cx.set_global(InlineAssistant::new(fs, telemetry));
+pub fn init(telemetry: Arc<Telemetry>, cx: &mut AppContext) {
+    cx.set_global(InlineAssistant::new(telemetry));
 }
 
 const PROMPT_HISTORY_MAX_LEN: usize = 20;
@@ -55,13 +53,12 @@ pub struct InlineAssistant {
     assist_groups: HashMap<InlineAssistGroupId, InlineAssistGroup>,
     prompt_history: VecDeque<String>,
     telemetry: Option<Arc<Telemetry>>,
-    fs: Arc<dyn Fs>,
 }
 
 impl Global for InlineAssistant {}
 
 impl InlineAssistant {
-    pub fn new(fs: Arc<dyn Fs>, telemetry: Arc<Telemetry>) -> Self {
+    pub fn new(telemetry: Arc<Telemetry>) -> Self {
         Self {
             next_assist_id: InlineAssistId::default(),
             next_assist_group_id: InlineAssistGroupId::default(),
@@ -70,7 +67,6 @@ impl InlineAssistant {
             assist_groups: HashMap::default(),
             prompt_history: VecDeque::default(),
             telemetry: Some(telemetry),
-            fs,
         }
     }
 
@@ -78,7 +74,7 @@ impl InlineAssistant {
         &mut self,
         editor: &View<Editor>,
         workspace: Option<WeakView<Workspace>>,
-        assistant_panel: Option<&View<AssistantPanel>>,
+        include_context: bool,
         cx: &mut WindowContext,
     ) {
         let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
@@ -155,10 +151,7 @@ impl InlineAssistant {
                     self.prompt_history.clone(),
                     prompt_buffer.clone(),
                     codegen.clone(),
-                    editor,
-                    assistant_panel,
                     workspace.clone(),
-                    self.fs.clone(),
                     cx,
                 )
             });
@@ -215,7 +208,7 @@ impl InlineAssistant {
                 InlineAssist::new(
                     assist_id,
                     assist_group_id,
-                    assistant_panel.is_some(),
+                    include_context,
                     editor,
                     &prompt_editor,
                     block_ids[0],
@@ -713,6 +706,8 @@ impl InlineAssistant {
             return;
         }
 
+        assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
+
         let Some(user_prompt) = assist
             .decorations
             .as_ref()
@@ -721,138 +716,115 @@ impl InlineAssistant {
             return;
         };
 
+        let context = if assist.include_context {
+            assist.workspace.as_ref().and_then(|workspace| {
+                let workspace = workspace.upgrade()?.read(cx);
+                let assistant_panel = workspace.panel::<AssistantPanel>(cx)?;
+                assistant_panel.read(cx).active_context(cx)
+            })
+        } else {
+            None
+        };
+
+        let editor = if let Some(editor) = assist.editor.upgrade() {
+            editor
+        } else {
+            return;
+        };
+
+        let project_name = assist.workspace.as_ref().and_then(|workspace| {
+            let workspace = workspace.upgrade()?;
+            Some(
+                workspace
+                    .read(cx)
+                    .project()
+                    .read(cx)
+                    .worktree_root_names(cx)
+                    .collect::<Vec<&str>>()
+                    .join("/"),
+            )
+        });
+
         self.prompt_history.retain(|prompt| *prompt != user_prompt);
         self.prompt_history.push_back(user_prompt.clone());
         if self.prompt_history.len() > PROMPT_HISTORY_MAX_LEN {
             self.prompt_history.pop_front();
         }
 
-        assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
         let codegen = assist.codegen.clone();
-        let request = self.request_for_inline_assist(assist_id, cx);
-
-        cx.spawn(|mut cx| async move {
-            let request = request.await?;
-            codegen.update(&mut cx, |codegen, cx| codegen.start(request, cx))?;
-            anyhow::Ok(())
-        })
-        .detach_and_log_err(cx);
-    }
-
-    fn request_for_inline_assist(
-        &self,
-        assist_id: InlineAssistId,
-        cx: &mut WindowContext,
-    ) -> Task<Result<LanguageModelRequest>> {
-        cx.spawn(|mut cx| async move {
-            let (user_prompt, context_request, project_name, buffer, range, model) = cx
-                .read_global(|this: &InlineAssistant, cx: &WindowContext| {
-                    let assist = this.assists.get(&assist_id).context("invalid assist")?;
-                    let decorations = assist.decorations.as_ref().context("invalid assist")?;
-                    let editor = assist.editor.upgrade().context("invalid assist")?;
-                    let user_prompt = decorations.prompt_editor.read(cx).prompt(cx);
-                    let context_request = if assist.include_context {
-                        assist.workspace.as_ref().and_then(|workspace| {
-                            let workspace = workspace.upgrade()?.read(cx);
-                            let assistant_panel = workspace.panel::<AssistantPanel>(cx)?;
-                            Some(
-                                assistant_panel
-                                    .read(cx)
-                                    .active_context(cx)?
-                                    .read(cx)
-                                    .to_completion_request(cx),
-                            )
-                        })
-                    } else {
-                        None
-                    };
-                    let project_name = assist.workspace.as_ref().and_then(|workspace| {
-                        let workspace = workspace.upgrade()?;
-                        Some(
-                            workspace
-                                .read(cx)
-                                .project()
-                                .read(cx)
-                                .worktree_root_names(cx)
-                                .collect::<Vec<&str>>()
-                                .join("/"),
-                        )
-                    });
-                    let buffer = editor.read(cx).buffer().read(cx).snapshot(cx);
-                    let range = assist.codegen.read(cx).range.clone();
-                    let model = CompletionProvider::global(cx).model();
-                    anyhow::Ok((
-                        user_prompt,
-                        context_request,
-                        project_name,
-                        buffer,
-                        range,
-                        model,
-                    ))
-                })??;
-
-            let language = buffer.language_at(range.start);
-            let language_name = if let Some(language) = language.as_ref() {
-                if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
-                    None
-                } else {
-                    Some(language.name())
-                }
+        let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
+        let range = codegen.read(cx).range.clone();
+        let start = snapshot.point_to_buffer_offset(range.start);
+        let end = snapshot.point_to_buffer_offset(range.end);
+        let (buffer, range) = if let Some((start, end)) = start.zip(end) {
+            let (start_buffer, start_buffer_offset) = start;
+            let (end_buffer, end_buffer_offset) = end;
+            if start_buffer.remote_id() == end_buffer.remote_id() {
+                (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
             } else {
-                None
-            };
-
-            // Higher Temperature increases the randomness of model outputs.
-            // If Markdown or No Language is Known, increase the randomness for more creative output
-            // If Code, decrease temperature to get more deterministic outputs
-            let temperature = if let Some(language) = language_name.clone() {
-                if language.as_ref() == "Markdown" {
-                    1.0
-                } else {
-                    0.5
-                }
-            } else {
-                1.0
-            };
-
-            let prompt = cx
-                .background_executor()
-                .spawn(async move {
-                    let language_name = language_name.as_deref();
-                    let start = buffer.point_to_buffer_offset(range.start);
-                    let end = buffer.point_to_buffer_offset(range.end);
-                    let (buffer, range) = if let Some((start, end)) = start.zip(end) {
-                        let (start_buffer, start_buffer_offset) = start;
-                        let (end_buffer, end_buffer_offset) = end;
-                        if start_buffer.remote_id() == end_buffer.remote_id() {
-                            (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
-                        } else {
-                            return Err(anyhow!("invalid transformation range"));
-                        }
-                    } else {
-                        return Err(anyhow!("invalid transformation range"));
-                    };
-                    generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
-                })
-                .await?;
-
-            let mut messages = Vec::new();
-            if let Some(context_request) = context_request {
-                messages = context_request.messages;
+                self.finish_assist(assist_id, false, cx);
+                return;
             }
+        } else {
+            self.finish_assist(assist_id, false, cx);
+            return;
+        };
+
+        let language = buffer.language_at(range.start);
+        let language_name = if let Some(language) = language.as_ref() {
+            if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
+                None
+            } else {
+                Some(language.name())
+            }
+        } else {
+            None
+        };
+
+        // Higher Temperature increases the randomness of model outputs.
+        // If Markdown or No Language is Known, increase the randomness for more creative output
+        // If Code, decrease temperature to get more deterministic outputs
+        let temperature = if let Some(language) = language_name.clone() {
+            if language.as_ref() == "Markdown" {
+                1.0
+            } else {
+                0.5
+            }
+        } else {
+            1.0
+        };
+
+        let prompt = cx.background_executor().spawn(async move {
+            let language_name = language_name.as_deref();
+            generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
+        });
+
+        let mut messages = Vec::new();
+        if let Some(context) = context {
+            let request = context.read(cx).to_completion_request(cx);
+            messages = request.messages;
+        }
+        let model = CompletionProvider::global(cx).model();
+
+        cx.spawn(|mut cx| async move {
+            let prompt = prompt.await?;
 
             messages.push(LanguageModelRequestMessage {
                 role: Role::User,
                 content: prompt,
             });
 
-            Ok(LanguageModelRequest {
+            let request = LanguageModelRequest {
                 model,
                 messages,
                 stop: vec!["|END|>".to_string()],
                 temperature,
-            })
+            };
+
+            codegen.update(&mut cx, |codegen, cx| codegen.start(request, cx))?;
+            anyhow::Ok(())
         })
+        .detach_and_log_err(cx);
     }
 
     fn stop_assist(&mut self, assist_id: InlineAssistId, cx: &mut WindowContext) {
@@ -1170,7 +1142,6 @@ enum PromptEditorEvent {
 
 struct PromptEditor {
     id: InlineAssistId,
-    fs: Arc<dyn Fs>,
     height_in_lines: u8,
     editor: View<Editor>,
     edited_since_done: bool,
@@ -1179,12 +1150,9 @@ struct PromptEditor {
     prompt_history_ix: Option<usize>,
     pending_prompt: String,
     codegen: Model<Codegen>,
+    workspace: Option<WeakView<Workspace>>,
     _codegen_subscription: Subscription,
     editor_subscriptions: Vec<Subscription>,
-    pending_token_count: Task<Result<()>>,
-    token_count: Option<usize>,
-    _token_count_subscriptions: Vec<Subscription>,
-    workspace: Option<WeakView<Workspace>>,
 }
 
 impl EventEmitter<PromptEditorEvent> for PromptEditor {}
@@ -1192,7 +1160,6 @@ impl EventEmitter<PromptEditorEvent> for PromptEditor {}
 impl Render for PromptEditor {
     fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         let gutter_dimensions = *self.gutter_dimensions.lock();
-        let fs = self.fs.clone();
 
         let buttons = match &self.codegen.read(cx).status {
             CodegenStatus::Idle => {
@@ -1278,100 +1245,85 @@ impl Render for PromptEditor {
             }
         };
 
-        h_flex()
-            .bg(cx.theme().colors().editor_background)
-            .border_y_1()
-            .border_color(cx.theme().status().info_border)
-            .py_1p5()
-            .h_full()
-            .w_full()
-            .on_action(cx.listener(Self::confirm))
-            .on_action(cx.listener(Self::cancel))
-            .on_action(cx.listener(Self::move_up))
-            .on_action(cx.listener(Self::move_down))
-            .child(
-                h_flex()
-                    .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
-                    .justify_center()
-                    .gap_2()
-                    .child(
-                        PopoverMenu::new("model-switcher")
-                            .menu(move |cx| {
-                                ContextMenu::build(cx, |mut menu, cx| {
-                                    for model in CompletionProvider::global(cx).available_models() {
-                                        menu = menu.custom_entry(
-                                            {
-                                                let model = model.clone();
-                                                move |_| {
-                                                    Label::new(model.display_name())
-                                                        .into_any_element()
-                                                }
-                                            },
-                                            {
-                                                let fs = fs.clone();
-                                                let model = model.clone();
-                                                move |cx| {
-                                                    let model = model.clone();
-                                                    update_settings_file::<AssistantSettings>(
-                                                        fs.clone(),
-                                                        cx,
-                                                        move |settings| settings.set_model(model),
-                                                    );
-                                                }
-                                            },
-                                        );
-                                    }
-                                    menu
+        v_flex().h_full().w_full().justify_end().child(
+            h_flex()
+                .bg(cx.theme().colors().editor_background)
+                .border_y_1()
+                .border_color(cx.theme().status().info_border)
+                .py_1p5()
+                .w_full()
+                .on_action(cx.listener(Self::confirm))
+                .on_action(cx.listener(Self::cancel))
+                .on_action(cx.listener(Self::move_up))
+                .on_action(cx.listener(Self::move_down))
+                .child(
+                    h_flex()
+                        .w(gutter_dimensions.full_width() + (gutter_dimensions.margin / 2.0))
+                        // .pr(gutter_dimensions.fold_area_width())
+                        .justify_center()
+                        .gap_2()
+                        .children(self.workspace.clone().map(|workspace| {
+                            IconButton::new("context", IconName::Context)
+                                .size(ButtonSize::None)
+                                .icon_size(IconSize::XSmall)
+                                .icon_color(Color::Muted)
+                                .on_click({
+                                    let workspace = workspace.clone();
+                                    cx.listener(move |_, _, cx| {
+                                        workspace
+                                            .update(cx, |workspace, cx| {
+                                                workspace.focus_panel::<AssistantPanel>(cx);
+                                            })
+                                            .ok();
+                                    })
                                 })
-                                .into()
-                            })
-                            .trigger(
-                                IconButton::new("context", IconName::Settings)
-                                    .size(ButtonSize::None)
-                                    .icon_size(IconSize::Small)
-                                    .icon_color(Color::Muted)
-                                    .tooltip(move |cx| {
+                                .tooltip(move |cx| {
+                                    let token_count = workspace.upgrade().and_then(|workspace| {
+                                        let panel =
+                                            workspace.read(cx).panel::<AssistantPanel>(cx)?;
+                                        let context = panel.read(cx).active_context(cx)?;
+                                        context.read(cx).token_count()
+                                    });
+                                    if let Some(token_count) = token_count {
                                         Tooltip::with_meta(
                                             format!(
-                                                "Using {}",
-                                                CompletionProvider::global(cx)
-                                                    .model()
-                                                    .display_name()
+                                                "{} Additional Context Tokens from Assistant",
+                                                token_count
                                             ),
-                                            None,
-                                            "Click to Change Model",
+                                            Some(&crate::ToggleFocus),
+                                            "Click to open…",
                                             cx,
                                         )
-                                    }),
-                            )
-                            .anchor(gpui::AnchorCorner::BottomRight),
-                    )
-                    .children(
-                        if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {
-                            let error_message = SharedString::from(error.to_string());
-                            Some(
-                                div()
-                                    .id("error")
-                                    .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
-                                    .child(
-                                        Icon::new(IconName::XCircle)
-                                            .size(IconSize::Small)
-                                            .color(Color::Error),
-                                    ),
-                            )
-                        } else {
-                            None
-                        },
-                    ),
-            )
-            .child(div().flex_1().child(self.render_prompt_editor(cx)))
-            .child(
-                h_flex()
-                    .gap_2()
-                    .pr_4()
-                    .children(self.render_token_count(cx))
-                    .children(buttons),
-            )
+                                    } else {
+                                        Tooltip::for_action(
+                                            "Toggle Assistant Panel",
+                                            &crate::ToggleFocus,
+                                            cx,
+                                        )
+                                    }
+                                })
+                        }))
+                        .children(
+                            if let CodegenStatus::Error(error) = &self.codegen.read(cx).status {
+                                let error_message = SharedString::from(error.to_string());
+                                Some(
+                                    div()
+                                        .id("error")
+                                        .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
+                                        .child(
+                                            Icon::new(IconName::XCircle)
+                                                .size(IconSize::Small)
+                                                .color(Color::Error),
+                                        ),
+                                )
+                            } else {
+                                None
+                            },
+                        ),
+                )
+                .child(div().flex_1().child(self.render_prompt_editor(cx)))
+                .child(h_flex().gap_2().pr_4().children(buttons)),
+        )
     }
 }
 
@@ -1384,17 +1336,13 @@ impl FocusableView for PromptEditor {
 impl PromptEditor {
     const MAX_LINES: u8 = 8;
 
-    #[allow(clippy::too_many_arguments)]
     fn new(
         id: InlineAssistId,
         gutter_dimensions: Arc<Mutex<GutterDimensions>>,
         prompt_history: VecDeque<String>,
         prompt_buffer: Model<MultiBuffer>,
         codegen: Model<Codegen>,
-        parent_editor: &View<Editor>,
-        assistant_panel: Option<&View<AssistantPanel>>,
         workspace: Option<WeakView<Workspace>>,
-        fs: Arc<dyn Fs>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
         let prompt_editor = cx.new_view(|cx| {
@@ -1415,15 +1363,6 @@ impl PromptEditor {
             editor.set_placeholder_text("Add a prompt…", cx);
             editor
         });
-
-        let mut token_count_subscriptions = Vec::new();
-        token_count_subscriptions
-            .push(cx.subscribe(parent_editor, Self::handle_parent_editor_event));
-        if let Some(assistant_panel) = assistant_panel {
-            token_count_subscriptions
-                .push(cx.subscribe(assistant_panel, Self::handle_assistant_panel_event));
-        }
-
         let mut this = Self {
             id,
             height_in_lines: 1,
@@ -1436,14 +1375,9 @@ impl PromptEditor {
             _codegen_subscription: cx.observe(&codegen, Self::handle_codegen_changed),
             editor_subscriptions: Vec::new(),
             codegen,
-            fs,
-            pending_token_count: Task::ready(Ok(())),
-            token_count: None,
-            _token_count_subscriptions: token_count_subscriptions,
             workspace,
         };
         this.count_lines(cx);
-        this.count_tokens(cx);
         this.subscribe_to_editor(cx);
         this
     }
@@ -1502,47 +1436,6 @@ impl PromptEditor {
         }
     }
 
-    fn handle_parent_editor_event(
-        &mut self,
-        _: View<Editor>,
-        event: &EditorEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        if let EditorEvent::BufferEdited { .. } = event {
-            self.count_tokens(cx);
-        }
-    }
-
-    fn handle_assistant_panel_event(
-        &mut self,
-        _: View<AssistantPanel>,
-        event: &AssistantPanelEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let AssistantPanelEvent::ContextEdited { .. } = event;
-        self.count_tokens(cx);
-    }
-
-    fn count_tokens(&mut self, cx: &mut ViewContext<Self>) {
-        let assist_id = self.id;
-        self.pending_token_count = cx.spawn(|this, mut cx| async move {
-            cx.background_executor().timer(Duration::from_secs(1)).await;
-            let request = cx
-                .update_global(|inline_assistant: &mut InlineAssistant, cx| {
-                    inline_assistant.request_for_inline_assist(assist_id, cx)
-                })?
-                .await?;
-
-            let token_count = cx
-                .update(|cx| CompletionProvider::global(cx).count_tokens(request, cx))?
-                .await?;
-            this.update(&mut cx, |this, cx| {
-                this.token_count = Some(token_count);
-                cx.notify();
-            })
-        })
-    }
-
     fn handle_prompt_editor_changed(&mut self, _: View<Editor>, cx: &mut ViewContext<Self>) {
         self.count_lines(cx);
     }
@@ -1567,9 +1460,6 @@ impl PromptEditor {
                 self.edited_since_done = true;
                 cx.notify();
             }
-            EditorEvent::BufferEdited => {
-                self.count_tokens(cx);
-            }
             _ => {}
         }
     }
@@ -1661,63 +1551,6 @@ impl PromptEditor {
         }
     }
 
-    fn render_token_count(&self, cx: &mut ViewContext<Self>) -> Option<impl IntoElement> {
-        let model = CompletionProvider::global(cx).model();
-        let token_count = self.token_count?;
-        let max_token_count = model.max_token_count();
-
-        let remaining_tokens = max_token_count as isize - token_count as isize;
-        let token_count_color = if remaining_tokens <= 0 {
-            Color::Error
-        } else if token_count as f32 / max_token_count as f32 >= 0.8 {
-            Color::Warning
-        } else {
-            Color::Muted
-        };
-
-        let mut token_count = h_flex()
-            .id("token_count")
-            .gap_0p5()
-            .child(
-                Label::new(humanize_token_count(token_count))
-                    .size(LabelSize::Small)
-                    .color(token_count_color),
-            )
-            .child(Label::new("/").size(LabelSize::Small).color(Color::Muted))
-            .child(
-                Label::new(humanize_token_count(max_token_count))
-                    .size(LabelSize::Small)
-                    .color(Color::Muted),
-            );
-        if let Some(workspace) = self.workspace.clone() {
-            token_count = token_count
-                .tooltip(|cx| {
-                    Tooltip::with_meta(
-                        "Tokens Used by Inline Assistant",
-                        None,
-                        "Click to Open Assistant Panel",
-                        cx,
-                    )
-                })
-                .cursor_pointer()
-                .on_mouse_down(gpui::MouseButton::Left, |_, cx| cx.stop_propagation())
-                .on_click(move |_, cx| {
-                    cx.stop_propagation();
-                    workspace
-                        .update(cx, |workspace, cx| {
-                            workspace.focus_panel::<AssistantPanel>(cx)
-                        })
-                        .ok();
-                });
-        } else {
-            token_count = token_count
-                .cursor_default()
-                .tooltip(|cx| Tooltip::text("Tokens Used by Inline Assistant", cx));
-        }
-
-        Some(token_count)
-    }
-
     fn render_prompt_editor(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
         let settings = ThemeSettings::get_global(cx);
         let text_style = TextStyle {
@@ -2060,11 +1893,6 @@ impl Codegen {
 
                                         if lines.peek().is_some() {
                                             hunks_tx.send(diff.push_new("\n")).await?;
-                                            if line_indent.is_none() {
-                                                // Don't write out the leading indentation in empty lines on the next line
-                                                // This is the case where the above if statement didn't clear the buffer
-                                                new_text.clear();
-                                            }
                                             line_indent = None;
                                             first_line = false;
                                         }

crates/assistant/src/prompt_library.rs

@@ -6,16 +6,16 @@ use anyhow::{anyhow, Result};
 use assistant_slash_command::SlashCommandRegistry;
 use chrono::{DateTime, Utc};
 use collections::HashMap;
-use editor::{actions::Tab, CurrentLineHighlight, Editor, EditorElement, EditorEvent, EditorStyle};
+use editor::{actions::Tab, CurrentLineHighlight, Editor, EditorEvent};
 use futures::{
     future::{self, BoxFuture, Shared},
     FutureExt,
 };
 use fuzzy::StringMatchCandidate;
 use gpui::{
-    actions, point, size, transparent_black, AppContext, BackgroundExecutor, Bounds, EventEmitter,
-    Global, HighlightStyle, PromptLevel, ReadGlobal, Subscription, Task, TextStyle,
-    TitlebarOptions, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
+    actions, percentage, point, size, Animation, AnimationExt, AppContext, BackgroundExecutor,
+    Bounds, EventEmitter, Global, PromptLevel, ReadGlobal, Subscription, Task, TitlebarOptions,
+    Transformation, UpdateGlobal, View, WindowBounds, WindowHandle, WindowOptions,
 };
 use heed::{types::SerdeBincode, Database, RoTxn};
 use language::{language_settings::SoftWrap, Buffer, LanguageRegistry};
@@ -109,13 +109,12 @@ pub struct PromptLibrary {
 }
 
 struct PromptEditor {
-    title_editor: View<Editor>,
-    body_editor: View<Editor>,
+    editor: View<Editor>,
     token_count: Option<usize>,
     pending_token_count: Task<Option<()>>,
-    next_title_and_body_to_save: Option<(String, Rope)>,
+    next_body_to_save: Option<Rope>,
     pending_save: Option<Task<Option<()>>>,
-    _subscriptions: Vec<Subscription>,
+    _subscription: Subscription,
 }
 
 struct PromptPickerDelegate {
@@ -346,8 +345,7 @@ impl PromptLibrary {
 
         let prompt_metadata = self.store.metadata(prompt_id).unwrap();
         let prompt_editor = self.prompt_editors.get_mut(&prompt_id).unwrap();
-        let title = prompt_editor.title_editor.read(cx).text(cx);
-        let body = prompt_editor.body_editor.update(cx, |editor, cx| {
+        let body = prompt_editor.editor.update(cx, |editor, cx| {
             editor
                 .buffer()
                 .read(cx)
@@ -361,24 +359,20 @@ impl PromptLibrary {
         let store = self.store.clone();
         let executor = cx.background_executor().clone();
 
-        prompt_editor.next_title_and_body_to_save = Some((title, body));
+        prompt_editor.next_body_to_save = Some(body);
         if prompt_editor.pending_save.is_none() {
             prompt_editor.pending_save = Some(cx.spawn(|this, mut cx| {
                 async move {
                     loop {
-                        let title_and_body = this.update(&mut cx, |this, _| {
+                        let next_body_to_save = this.update(&mut cx, |this, _| {
                             this.prompt_editors
                                 .get_mut(&prompt_id)?
-                                .next_title_and_body_to_save
+                                .next_body_to_save
                                 .take()
                         })?;
 
-                        if let Some((title, body)) = title_and_body {
-                            let title = if title.trim().is_empty() {
-                                None
-                            } else {
-                                Some(SharedString::from(title))
-                            };
+                        if let Some(body) = next_body_to_save {
+                            let title = title_from_body(body.chars_at(0));
                             store
                                 .save(prompt_id, title, prompt_metadata.default, body)
                                 .await
@@ -431,11 +425,11 @@ impl PromptLibrary {
         if let Some(prompt_editor) = self.prompt_editors.get(&prompt_id) {
             if focus {
                 prompt_editor
-                    .body_editor
+                    .editor
                     .update(cx, |editor, cx| editor.focus(cx));
             }
             self.set_active_prompt(Some(prompt_id), cx);
-        } else if let Some(prompt_metadata) = self.store.metadata(prompt_id) {
+        } else {
             let language_registry = self.language_registry.clone();
             let commands = SlashCommandRegistry::global(cx);
             let prompt = self.store.load(prompt_id);
@@ -444,20 +438,13 @@ impl PromptLibrary {
                 let markdown = language_registry.language_for_name("Markdown").await;
                 this.update(&mut cx, |this, cx| match prompt {
                     Ok(prompt) => {
-                        let title_editor = cx.new_view(|cx| {
-                            let mut editor = Editor::auto_width(cx);
-                            editor.set_placeholder_text("Untitled", cx);
-                            editor.set_text(prompt_metadata.title.unwrap_or_default(), cx);
-                            editor
+                        let buffer = cx.new_model(|cx| {
+                            let mut buffer = Buffer::local(prompt, cx);
+                            buffer.set_language(markdown.log_err(), cx);
+                            buffer.set_language_registry(language_registry);
+                            buffer
                         });
-                        let body_editor = cx.new_view(|cx| {
-                            let buffer = cx.new_model(|cx| {
-                                let mut buffer = Buffer::local(prompt, cx);
-                                buffer.set_language(markdown.log_err(), cx);
-                                buffer.set_language_registry(language_registry);
-                                buffer
-                            });
-
+                        let editor = cx.new_view(|cx| {
                             let mut editor = Editor::for_buffer(buffer, None, cx);
                             editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
                             editor.set_show_gutter(false, cx);
@@ -473,24 +460,19 @@ impl PromptLibrary {
                             }
                             editor
                         });
-                        let _subscriptions = vec![
-                            cx.subscribe(&title_editor, move |this, editor, event, cx| {
-                                this.handle_prompt_title_editor_event(prompt_id, editor, event, cx)
-                            }),
-                            cx.subscribe(&body_editor, move |this, editor, event, cx| {
-                                this.handle_prompt_body_editor_event(prompt_id, editor, event, cx)
-                            }),
-                        ];
+                        let _subscription =
+                            cx.subscribe(&editor, move |this, _editor, event, cx| {
+                                this.handle_prompt_editor_event(prompt_id, event, cx)
+                            });
                         this.prompt_editors.insert(
                             prompt_id,
                             PromptEditor {
-                                title_editor,
-                                body_editor,
-                                next_title_and_body_to_save: None,
+                                editor,
+                                next_body_to_save: None,
                                 pending_save: None,
                                 token_count: None,
                                 pending_token_count: Task::ready(None),
-                                _subscriptions,
+                                _subscription,
                             },
                         );
                         this.set_active_prompt(Some(prompt_id), cx);
@@ -567,7 +549,7 @@ impl PromptLibrary {
     fn focus_active_prompt(&mut self, _: &Tab, cx: &mut ViewContext<Self>) {
         if let Some(active_prompt) = self.active_prompt_id {
             self.prompt_editors[&active_prompt]
-                .body_editor
+                .editor
                 .update(cx, |editor, cx| editor.focus(cx));
             cx.stop_propagation();
         }
@@ -583,11 +565,11 @@ impl PromptLibrary {
             return;
         };
 
-        let prompt_editor = &self.prompt_editors[&active_prompt_id].body_editor;
+        let prompt_editor = &self.prompt_editors[&active_prompt_id].editor;
         let provider = CompletionProvider::global(cx);
         if provider.is_authenticated() {
             InlineAssistant::update_global(cx, |assistant, cx| {
-                assistant.assist(&prompt_editor, None, None, cx)
+                assistant.assist(&prompt_editor, None, false, cx)
             })
         } else {
             for window in cx.windows() {
@@ -607,73 +589,50 @@ impl PromptLibrary {
         }
     }
 
-    fn move_down_from_title(&mut self, _: &editor::actions::MoveDown, cx: &mut ViewContext<Self>) {
-        if let Some(prompt_id) = self.active_prompt_id {
-            if let Some(prompt_editor) = self.prompt_editors.get(&prompt_id) {
-                cx.focus_view(&prompt_editor.body_editor);
-            }
-        }
-    }
-
-    fn move_up_from_body(&mut self, _: &editor::actions::MoveUp, cx: &mut ViewContext<Self>) {
-        if let Some(prompt_id) = self.active_prompt_id {
-            if let Some(prompt_editor) = self.prompt_editors.get(&prompt_id) {
-                cx.focus_view(&prompt_editor.title_editor);
-            }
-        }
-    }
-
-    fn handle_prompt_title_editor_event(
+    fn handle_prompt_editor_event(
         &mut self,
         prompt_id: PromptId,
-        title_editor: View<Editor>,
         event: &EditorEvent,
         cx: &mut ViewContext<Self>,
     ) {
-        match event {
-            EditorEvent::BufferEdited => {
-                self.save_prompt(prompt_id, cx);
-                self.count_tokens(prompt_id, cx);
-            }
-            EditorEvent::Blurred => {
-                title_editor.update(cx, |title_editor, cx| {
-                    title_editor.change_selections(None, cx, |selections| {
-                        let cursor = selections.oldest_anchor().head();
-                        selections.select_anchor_ranges([cursor..cursor]);
-                    });
-                });
-            }
-            _ => {}
-        }
-    }
+        if let EditorEvent::BufferEdited = event {
+            let prompt_editor = self.prompt_editors.get(&prompt_id).unwrap();
+            let buffer = prompt_editor
+                .editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .unwrap();
 
-    fn handle_prompt_body_editor_event(
-        &mut self,
-        prompt_id: PromptId,
-        body_editor: View<Editor>,
-        event: &EditorEvent,
-        cx: &mut ViewContext<Self>,
-    ) {
-        match event {
-            EditorEvent::BufferEdited => {
-                self.save_prompt(prompt_id, cx);
-                self.count_tokens(prompt_id, cx);
-            }
-            EditorEvent::Blurred => {
-                body_editor.update(cx, |body_editor, cx| {
-                    body_editor.change_selections(None, cx, |selections| {
-                        let cursor = selections.oldest_anchor().head();
-                        selections.select_anchor_ranges([cursor..cursor]);
-                    });
-                });
-            }
-            _ => {}
+            buffer.update(cx, |buffer, cx| {
+                let mut chars = buffer.chars_at(0);
+                match chars.next() {
+                    Some('#') => {
+                        if chars.next() != Some(' ') {
+                            drop(chars);
+                            buffer.edit([(1..1, " ")], None, cx);
+                        }
+                    }
+                    Some(' ') => {
+                        drop(chars);
+                        buffer.edit([(0..0, "#")], None, cx);
+                    }
+                    _ => {
+                        drop(chars);
+                        buffer.edit([(0..0, "# ")], None, cx);
+                    }
+                }
+            });
+
+            self.save_prompt(prompt_id, cx);
+            self.count_tokens(prompt_id, cx);
         }
     }
 
     fn count_tokens(&mut self, prompt_id: PromptId, cx: &mut ViewContext<Self>) {
         if let Some(prompt) = self.prompt_editors.get_mut(&prompt_id) {
-            let editor = &prompt.body_editor.read(cx);
+            let editor = &prompt.editor.read(cx);
             let buffer = &editor.buffer().read(cx).as_singleton().unwrap().read(cx);
             let body = buffer.as_rope().clone();
             prompt.pending_token_count = cx.spawn(|this, mut cx| {
@@ -749,209 +708,122 @@ impl PromptLibrary {
             .flex_none()
             .min_w_64()
             .children(self.active_prompt_id.and_then(|prompt_id| {
+                let buffer_font = ThemeSettings::get_global(cx).buffer_font.family.clone();
                 let prompt_metadata = self.store.metadata(prompt_id)?;
                 let prompt_editor = &self.prompt_editors[&prompt_id];
-                let focus_handle = prompt_editor.body_editor.focus_handle(cx);
+                let focus_handle = prompt_editor.editor.focus_handle(cx);
                 let current_model = CompletionProvider::global(cx).model();
-                let settings = ThemeSettings::get_global(cx);
+                let token_count = prompt_editor.token_count.map(|count| count.to_string());
 
                 Some(
-                    v_flex()
+                    h_flex()
                         .id("prompt-editor-inner")
                         .size_full()
-                        .relative()
-                        .overflow_hidden()
-                        .pl(Spacing::XXLarge.rems(cx))
-                        .pt(Spacing::Large.rems(cx))
+                        .items_start()
                         .on_click(cx.listener(move |_, _, cx| {
                             cx.focus(&focus_handle);
                         }))
-                        .child(
-                            h_flex()
-                                .group("active-editor-header")
-                                .pr(Spacing::XXLarge.rems(cx))
-                                .pt(Spacing::XSmall.rems(cx))
-                                .pb(Spacing::Large.rems(cx))
-                                .justify_between()
-                                .child(
-                                    h_flex().gap_1().child(
-                                        div()
-                                            .max_w_80()
-                                            .on_action(cx.listener(Self::move_down_from_title))
-                                            .border_1()
-                                            .border_color(transparent_black())
-                                            .rounded_md()
-                                            .group_hover("active-editor-header", |this| {
-                                                this.border_color(
-                                                    cx.theme().colors().border_variant,
-                                                )
-                                            })
-                                            .child(EditorElement::new(
-                                                &prompt_editor.title_editor,
-                                                EditorStyle {
-                                                    background: cx.theme().system().transparent,
-                                                    local_player: cx.theme().players().local(),
-                                                    text: TextStyle {
-                                                        color: cx
-                                                            .theme()
-                                                            .colors()
-                                                            .editor_foreground,
-                                                        font_family: settings
-                                                            .ui_font
-                                                            .family
-                                                            .clone(),
-                                                        font_features: settings
-                                                            .ui_font
-                                                            .features
-                                                            .clone(),
-                                                        font_size: HeadlineSize::Large
-                                                            .size()
-                                                            .into(),
-                                                        font_weight: settings.ui_font.weight,
-                                                        line_height: relative(
-                                                            settings.buffer_line_height.value(),
-                                                        ),
-                                                        ..Default::default()
-                                                    },
-                                                    scrollbar_width: Pixels::ZERO,
-                                                    syntax: cx.theme().syntax().clone(),
-                                                    status: cx.theme().status().clone(),
-                                                    inlay_hints_style: HighlightStyle {
-                                                        color: Some(cx.theme().status().hint),
-                                                        ..HighlightStyle::default()
-                                                    },
-                                                    suggestions_style: HighlightStyle {
-                                                        color: Some(cx.theme().status().predictive),
-                                                        ..HighlightStyle::default()
-                                                    },
-                                                },
-                                            )),
-                                    ),
-                                )
-                                .child(
-                                    h_flex()
-                                        .h_full()
-                                        .child(
-                                            h_flex()
-                                                .h_full()
-                                                .gap(Spacing::XXLarge.rems(cx))
-                                                .child(div()),
-                                        )
-                                        .child(
-                                            h_flex()
-                                                .h_full()
-                                                .gap(Spacing::XXLarge.rems(cx))
-                                                .child(
-                                                    IconButton::new(
-                                                        "delete-prompt",
-                                                        IconName::Trash,
-                                                    )
-                                                    .size(ButtonSize::Large)
-                                                    .style(ButtonStyle::Transparent)
-                                                    .shape(IconButtonShape::Square)
-                                                    .size(ButtonSize::Large)
-                                                    .tooltip(move |cx| {
-                                                        Tooltip::for_action(
-                                                            "Delete Prompt",
-                                                            &DeletePrompt,
-                                                            cx,
-                                                        )
-                                                    })
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(DeletePrompt));
-                                                    }),
-                                                )
-                                                // .child(
-                                                //     IconButton::new(
-                                                //         "duplicate-prompt",
-                                                //         IconName::BookCopy,
-                                                //     )
-                                                //     .size(ButtonSize::Large)
-                                                //     .style(ButtonStyle::Transparent)
-                                                //     .shape(IconButtonShape::Square)
-                                                //     .size(ButtonSize::Large)
-                                                //     .tooltip(move |cx| {
-                                                //         Tooltip::for_action(
-                                                //             "Duplicate Prompt",
-                                                //             &gpui::NoAction,
-                                                //             cx,
-                                                //         )
-                                                //     })
-                                                //     .disabled(true),
-                                                // )
-                                                .child(
-                                                    IconButton::new(
-                                                        "toggle-default-prompt",
-                                                        IconName::Sparkle,
-                                                    )
-                                                    .style(ButtonStyle::Transparent)
-                                                    .selected(prompt_metadata.default)
-                                                    .selected_icon(IconName::SparkleFilled)
-                                                    .icon_color(if prompt_metadata.default {
-                                                        Color::Accent
-                                                    } else {
-                                                        Color::Muted
-                                                    })
-                                                    .shape(IconButtonShape::Square)
-                                                    .size(ButtonSize::Large)
-                                                    .tooltip(move |cx| {
-                                                        Tooltip::text(
-                                                            if prompt_metadata.default {
-                                                                "Remove from Default Prompt"
-                                                            } else {
-                                                                "Add to Default Prompt"
-                                                            },
-                                                            cx,
-                                                        )
-                                                    })
-                                                    .on_click(|_, cx| {
-                                                        cx.dispatch_action(Box::new(
-                                                            ToggleDefaultPrompt,
-                                                        ));
-                                                    }),
-                                                ),
-                                        ),
-                                ),
-                        )
                         .child(
                             div()
                                 .on_action(cx.listener(Self::focus_picker))
                                 .on_action(cx.listener(Self::inline_assist))
-                                .on_action(cx.listener(Self::move_up_from_body))
                                 .flex_grow()
                                 .h_full()
-                                .child(prompt_editor.body_editor.clone())
-                                .children(prompt_editor.token_count.map(|token_count| {
-                                    let token_count: SharedString = token_count.to_string().into();
-                                    let label_token_count: SharedString =
-                                        token_count.to_string().into();
-
-                                    h_flex()
-                                        .id("token_count")
-                                        .absolute()
-                                        .bottom_1()
-                                        .right_4()
-                                        .flex_initial()
-                                        .px_2()
-                                        .py_1()
-                                        .tooltip(move |cx| {
-                                            let token_count = token_count.clone();
-
-                                            Tooltip::with_meta(
-                                                format!("{} tokens", token_count.clone()),
-                                                None,
-                                                format!("Model: {}", current_model.display_name()),
-                                                cx,
-                                            )
-                                        })
-                                        .child(
-                                            Label::new(format!(
-                                                "{} tokens",
-                                                label_token_count.clone()
-                                            ))
-                                            .color(Color::Muted),
+                                .pt(Spacing::XXLarge.rems(cx))
+                                .pl(Spacing::XXLarge.rems(cx))
+                                .child(prompt_editor.editor.clone()),
+                        )
+                        .child(
+                            v_flex()
+                                .w_12()
+                                .py(Spacing::Large.rems(cx))
+                                .justify_start()
+                                .items_end()
+                                .gap_1()
+                                .child(h_flex().h_8().font_family(buffer_font).when_some_else(
+                                    token_count,
+                                    |tokens_ready, token_count| {
+                                        tokens_ready.pr_3().justify_end().child(
+                                            // This isn't actually a button, it just let's us easily add
+                                            // a tooltip to the token count.
+                                            Button::new("token_count", token_count.clone())
+                                                .style(ButtonStyle::Transparent)
+                                                .color(Color::Muted)
+                                                .tooltip(move |cx| {
+                                                    Tooltip::with_meta(
+                                                        format!("{} tokens", token_count,),
+                                                        None,
+                                                        format!(
+                                                            "Model: {}",
+                                                            current_model.display_name()
+                                                        ),
+                                                        cx,
+                                                    )
+                                                }),
                                         )
-                                })),
+                                    },
+                                    |tokens_loading| {
+                                        tokens_loading.w_12().justify_center().child(
+                                            Icon::new(IconName::ArrowCircle)
+                                                .size(IconSize::Small)
+                                                .color(Color::Muted)
+                                                .with_animation(
+                                                    "arrow-circle",
+                                                    Animation::new(Duration::from_secs(4)).repeat(),
+                                                    |icon, delta| {
+                                                        icon.transform(Transformation::rotate(
+                                                            percentage(delta),
+                                                        ))
+                                                    },
+                                                ),
+                                        )
+                                    },
+                                ))
+                                .child(
+                                    h_flex().justify_center().w_12().h_8().child(
+                                        IconButton::new("toggle-default-prompt", IconName::Sparkle)
+                                            .style(ButtonStyle::Transparent)
+                                            .selected(prompt_metadata.default)
+                                            .selected_icon(IconName::SparkleFilled)
+                                            .icon_color(if prompt_metadata.default {
+                                                Color::Accent
+                                            } else {
+                                                Color::Muted
+                                            })
+                                            .shape(IconButtonShape::Square)
+                                            .tooltip(move |cx| {
+                                                Tooltip::text(
+                                                    if prompt_metadata.default {
+                                                        "Remove from Default Prompt"
+                                                    } else {
+                                                        "Add to Default Prompt"
+                                                    },
+                                                    cx,
+                                                )
+                                            })
+                                            .on_click(|_, cx| {
+                                                cx.dispatch_action(Box::new(ToggleDefaultPrompt));
+                                            }),
+                                    ),
+                                )
+                                .child(
+                                    h_flex().justify_center().w_12().h_8().child(
+                                        IconButton::new("delete-prompt", IconName::Trash)
+                                            .size(ButtonSize::Large)
+                                            .style(ButtonStyle::Transparent)
+                                            .shape(IconButtonShape::Square)
+                                            .tooltip(move |cx| {
+                                                Tooltip::for_action(
+                                                    "Delete Prompt",
+                                                    &DeletePrompt,
+                                                    cx,
+                                                )
+                                            })
+                                            .on_click(|_, cx| {
+                                                cx.dispatch_action(Box::new(DeletePrompt));
+                                            }),
+                                    ),
+                                ),
                         ),
                 )
             }))
@@ -1243,3 +1115,24 @@ pub struct GlobalPromptStore(
 );
 
 impl Global for GlobalPromptStore {}
+
+fn title_from_body(body: impl IntoIterator<Item = char>) -> Option<SharedString> {
+    let mut chars = body.into_iter().take_while(|c| *c != '\n').peekable();
+
+    let mut level = 0;
+    while let Some('#') = chars.peek() {
+        level += 1;
+        chars.next();
+    }
+
+    if level > 0 {
+        let title = chars.collect::<String>().trim().to_string();
+        if title.is_empty() {
+            None
+        } else {
+            Some(title.into())
+        }
+    } else {
+        None
+    }
+}

crates/collab/src/rpc.rs

@@ -2583,13 +2583,14 @@ async fn rejoin_dev_server_projects(
         )
         .await?
     };
+    notify_rejoined_projects(&mut rejoined_projects, &session)?;
+
     response.send(proto::RejoinRemoteProjectsResponse {
         rejoined_projects: rejoined_projects
-            .iter()
+            .into_iter()
             .map(|project| project.to_proto())
             .collect(),
-    })?;
-    notify_rejoined_projects(&mut rejoined_projects, &session)
+    })
 }
 
 async fn reconnect_dev_server(

crates/collab/src/rpc/connection_pool.rs

@@ -73,7 +73,6 @@ impl ConnectionPool {
     pub fn reset(&mut self) {
         self.connections.clear();
         self.connected_users.clear();
-        self.connected_dev_servers.clear();
         self.channels.clear();
     }
 

crates/collab/src/tests/dev_server_tests.rs

@@ -504,29 +504,6 @@ async fn test_dev_server_reconnect(
         .unwrap();
 }
 
-#[gpui::test]
-async fn test_dev_server_restart(cx1: &mut gpui::TestAppContext, cx2: &mut gpui::TestAppContext) {
-    let (server, client1) = TestServer::start1(cx1).await;
-
-    let (_dev_server, remote_workspace) =
-        create_dev_server_project(&server, client1.app_state.clone(), cx1, cx2).await;
-    let cx = VisualTestContext::from_window(remote_workspace.into(), cx1).as_mut();
-
-    server.reset().await;
-    cx.run_until_parked();
-
-    cx.simulate_keystrokes("cmd-p 1 enter");
-    remote_workspace
-        .update(cx, |ws, cx| {
-            ws.active_item_as::<Editor>(cx)
-                .unwrap()
-                .update(cx, |ed, cx| {
-                    assert_eq!(ed.text(cx).to_string(), "remote\nremote\nremote");
-                })
-        })
-        .unwrap();
-}
-
 #[gpui::test]
 async fn test_create_dev_server_project_path_validation(
     cx1: &mut gpui::TestAppContext,

crates/collab_ui/src/collab_ui.rs

@@ -124,6 +124,5 @@ fn notification_window_options(
         display_id: Some(screen.id()),
         window_background: WindowBackgroundAppearance::default(),
         app_id: Some(app_id.to_owned()),
-        window_min_size: Size::default(),
     }
 }

crates/editor/src/actions.rs

@@ -268,7 +268,6 @@ gpui::actions!(
         SelectAllMatches,
         SelectDown,
         SelectLargerSyntaxNode,
-        SelectEnclosingSymbol,
         SelectLeft,
         SelectLine,
         SelectRight,

crates/editor/src/editor.rs

@@ -335,7 +335,7 @@ pub enum SelectMode {
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum EditorMode {
-    SingleLine { auto_width: bool },
+    SingleLine,
     AutoHeight { max_lines: usize },
     Full,
 }
@@ -1580,13 +1580,7 @@ impl Editor {
     pub fn single_line(cx: &mut ViewContext<Self>) -> Self {
         let buffer = cx.new_model(|cx| Buffer::local("", cx));
         let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(
-            EditorMode::SingleLine { auto_width: false },
-            buffer,
-            None,
-            false,
-            cx,
-        )
+        Self::new(EditorMode::SingleLine, buffer, None, false, cx)
     }
 
     pub fn multi_line(cx: &mut ViewContext<Self>) -> Self {
@@ -1595,18 +1589,6 @@ impl Editor {
         Self::new(EditorMode::Full, buffer, None, false, cx)
     }
 
-    pub fn auto_width(cx: &mut ViewContext<Self>) -> Self {
-        let buffer = cx.new_model(|cx| Buffer::local("", cx));
-        let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
-        Self::new(
-            EditorMode::SingleLine { auto_width: true },
-            buffer,
-            None,
-            false,
-            cx,
-        )
-    }
-
     pub fn auto_height(max_lines: usize, cx: &mut ViewContext<Self>) -> Self {
         let buffer = cx.new_model(|cx| Buffer::local("", cx));
         let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
@@ -1719,8 +1701,8 @@ impl Editor {
 
         let blink_manager = cx.new_model(|cx| BlinkManager::new(CURSOR_BLINK_INTERVAL, cx));
 
-        let soft_wrap_mode_override = matches!(mode, EditorMode::SingleLine { .. })
-            .then(|| language_settings::SoftWrap::PreferLine);
+        let soft_wrap_mode_override =
+            (mode == EditorMode::SingleLine).then(|| language_settings::SoftWrap::PreferLine);
 
         let mut project_subscriptions = Vec::new();
         if mode == EditorMode::Full {
@@ -1767,7 +1749,7 @@ impl Editor {
             .detach();
         cx.on_blur(&focus_handle, Self::handle_blur).detach();
 
-        let show_indent_guides = if matches!(mode, EditorMode::SingleLine { .. }) {
+        let show_indent_guides = if mode == EditorMode::SingleLine {
             Some(false)
         } else {
             None
@@ -1923,7 +1905,7 @@ impl Editor {
         let mut key_context = KeyContext::new_with_defaults();
         key_context.add("Editor");
         let mode = match self.mode {
-            EditorMode::SingleLine { .. } => "single_line",
+            EditorMode::SingleLine => "single_line",
             EditorMode::AutoHeight { .. } => "auto_height",
             EditorMode::Full => "full",
         };
@@ -6678,7 +6660,7 @@ impl Editor {
             return;
         }
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -6715,7 +6697,7 @@ impl Editor {
             return;
         }
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -6746,7 +6728,7 @@ impl Editor {
             return;
         }
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -6809,7 +6791,7 @@ impl Editor {
             return;
         }
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -6857,7 +6839,7 @@ impl Editor {
     pub fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext<Self>) {
         self.take_rename(true, cx);
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if self.mode == EditorMode::SingleLine {
             cx.propagate();
             return;
         }
@@ -6918,7 +6900,7 @@ impl Editor {
             return;
         }
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -7266,7 +7248,7 @@ impl Editor {
         _: &MoveToStartOfParagraph,
         cx: &mut ViewContext<Self>,
     ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -7286,7 +7268,7 @@ impl Editor {
         _: &MoveToEndOfParagraph,
         cx: &mut ViewContext<Self>,
     ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -7306,7 +7288,7 @@ impl Editor {
         _: &SelectToStartOfParagraph,
         cx: &mut ViewContext<Self>,
     ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -7326,7 +7308,7 @@ impl Editor {
         _: &SelectToEndOfParagraph,
         cx: &mut ViewContext<Self>,
     ) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -7342,7 +7324,7 @@ impl Editor {
     }
 
     pub fn move_to_beginning(&mut self, _: &MoveToBeginning, cx: &mut ViewContext<Self>) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -7362,7 +7344,7 @@ impl Editor {
     }
 
     pub fn move_to_end(&mut self, _: &MoveToEnd, cx: &mut ViewContext<Self>) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }
@@ -8221,7 +8203,7 @@ impl Editor {
             let advance_downwards = action.advance_downwards
                 && selections_on_single_row
                 && !selections_selecting
-                && !matches!(this.mode, EditorMode::SingleLine { .. });
+                && this.mode != EditorMode::SingleLine;
 
             if advance_downwards {
                 let snapshot = this.buffer.read(cx).snapshot(cx);
@@ -8244,58 +8226,6 @@ impl Editor {
         });
     }
 
-    pub fn select_enclosing_symbol(
-        &mut self,
-        _: &SelectEnclosingSymbol,
-        cx: &mut ViewContext<Self>,
-    ) {
-        let buffer = self.buffer.read(cx).snapshot(cx);
-        let old_selections = self.selections.all::<usize>(cx).into_boxed_slice();
-
-        fn update_selection(
-            selection: &Selection<usize>,
-            buffer_snap: &MultiBufferSnapshot,
-        ) -> Option<Selection<usize>> {
-            let cursor = selection.head();
-            let (_buffer_id, symbols) = buffer_snap.symbols_containing(cursor, None)?;
-            for symbol in symbols.iter().rev() {
-                let start = symbol.range.start.to_offset(&buffer_snap);
-                let end = symbol.range.end.to_offset(&buffer_snap);
-                let new_range = start..end;
-                if start < selection.start || end > selection.end {
-                    return Some(Selection {
-                        id: selection.id,
-                        start: new_range.start,
-                        end: new_range.end,
-                        goal: SelectionGoal::None,
-                        reversed: selection.reversed,
-                    });
-                }
-            }
-            None
-        }
-
-        let mut selected_larger_symbol = false;
-        let new_selections = old_selections
-            .iter()
-            .map(|selection| match update_selection(selection, &buffer) {
-                Some(new_selection) => {
-                    if new_selection.range() != selection.range() {
-                        selected_larger_symbol = true;
-                    }
-                    new_selection
-                }
-                None => selection.clone(),
-            })
-            .collect::<Vec<_>>();
-
-        if selected_larger_symbol {
-            self.change_selections(Some(Autoscroll::fit()), cx, |s| {
-                s.select(new_selections);
-            });
-        }
-    }
-
     pub fn select_larger_syntax_node(
         &mut self,
         _: &SelectLargerSyntaxNode,
@@ -12097,7 +12027,7 @@ impl Render for Editor {
         let settings = ThemeSettings::get_global(cx);
 
         let text_style = match self.mode {
-            EditorMode::SingleLine { .. } | EditorMode::AutoHeight { .. } => TextStyle {
+            EditorMode::SingleLine | EditorMode::AutoHeight { .. } => TextStyle {
                 color: cx.theme().colors().editor_foreground,
                 font_family: settings.ui_font.family.clone(),
                 font_features: settings.ui_font.features.clone(),
@@ -12126,7 +12056,7 @@ impl Render for Editor {
         };
 
         let background = match self.mode {
-            EditorMode::SingleLine { .. } => cx.theme().system().transparent,
+            EditorMode::SingleLine => cx.theme().system().transparent,
             EditorMode::AutoHeight { max_lines: _ } => cx.theme().system().transparent,
             EditorMode::Full => cx.theme().colors().editor_background,
         };

crates/editor/src/element.rs

@@ -276,7 +276,6 @@ impl EditorElement {
         register_action(view, cx, Editor::toggle_comments);
         register_action(view, cx, Editor::select_larger_syntax_node);
         register_action(view, cx, Editor::select_smaller_syntax_node);
-        register_action(view, cx, Editor::select_enclosing_symbol);
         register_action(view, cx, Editor::move_to_enclosing_bracket);
         register_action(view, cx, Editor::undo_selection);
         register_action(view, cx, Editor::redo_selection);
@@ -1831,10 +1830,10 @@ impl EditorElement {
     }
 
     fn layout_lines(
+        &self,
         rows: Range<DisplayRow>,
         line_number_layouts: &[Option<ShapedLine>],
         snapshot: &EditorSnapshot,
-        style: &EditorStyle,
         cx: &mut WindowContext,
     ) -> Vec<LineWithInvisibles> {
         if rows.start >= rows.end {
@@ -1843,7 +1842,7 @@ impl EditorElement {
 
         // Show the placeholder when the editor is empty
         if snapshot.is_empty() {
-            let font_size = style.text.font_size.to_pixels(cx.rem_size());
+            let font_size = self.style.text.font_size.to_pixels(cx.rem_size());
             let placeholder_color = cx.theme().colors().text_placeholder;
             let placeholder_text = snapshot.placeholder_text();
 
@@ -1858,7 +1857,7 @@ impl EditorElement {
                 .filter_map(move |line| {
                     let run = TextRun {
                         len: line.len(),
-                        font: style.text.font(),
+                        font: self.style.text.font(),
                         color: placeholder_color,
                         background_color: None,
                         underline: Default::default(),
@@ -1877,10 +1876,10 @@ impl EditorElement {
                 })
                 .collect()
         } else {
-            let chunks = snapshot.highlighted_chunks(rows.clone(), true, style);
+            let chunks = snapshot.highlighted_chunks(rows.clone(), true, &self.style);
             LineWithInvisibles::from_chunks(
                 chunks,
-                &style.text,
+                &self.style.text,
                 MAX_LINE_LEN,
                 rows.len(),
                 line_number_layouts,
@@ -4475,7 +4474,7 @@ impl EditorElement {
             // We currently use single-line and auto-height editors in UI contexts,
             // so we don't want to scale everything with the buffer font size, as it
             // ends up looking off.
-            EditorMode::SingleLine { .. } | EditorMode::AutoHeight { .. } => None,
+            EditorMode::SingleLine | EditorMode::AutoHeight { .. } => None,
         }
     }
 }
@@ -4499,43 +4498,12 @@ impl Element for EditorElement {
                 editor.set_style(self.style.clone(), cx);
 
                 let layout_id = match editor.mode {
-                    EditorMode::SingleLine { auto_width } => {
+                    EditorMode::SingleLine => {
                         let rem_size = cx.rem_size();
-
-                        let height = self.style.text.line_height_in_pixels(rem_size);
-                        if auto_width {
-                            let editor_handle = cx.view().clone();
-                            let style = self.style.clone();
-                            cx.request_measured_layout(Style::default(), move |_, _, cx| {
-                                let editor_snapshot =
-                                    editor_handle.update(cx, |editor, cx| editor.snapshot(cx));
-                                let line = Self::layout_lines(
-                                    DisplayRow(0)..DisplayRow(1),
-                                    &[],
-                                    &editor_snapshot,
-                                    &style,
-                                    cx,
-                                )
-                                .pop()
-                                .unwrap();
-
-                                let font_id = cx.text_system().resolve_font(&style.text.font());
-                                let font_size = style.text.font_size.to_pixels(cx.rem_size());
-                                let em_width = cx
-                                    .text_system()
-                                    .typographic_bounds(font_id, font_size, 'm')
-                                    .unwrap()
-                                    .size
-                                    .width;
-
-                                size(line.width + em_width, height)
-                            })
-                        } else {
-                            let mut style = Style::default();
-                            style.size.height = height.into();
-                            style.size.width = relative(1.).into();
-                            cx.request_layout(style, None)
-                        }
+                        let mut style = Style::default();
+                        style.size.width = relative(1.).into();
+                        style.size.height = self.style.text.line_height_in_pixels(rem_size).into();
+                        cx.request_layout(style, None)
                     }
                     EditorMode::AutoHeight { max_lines } => {
                         let editor_handle = cx.view().clone();
@@ -4794,13 +4762,8 @@ impl Element for EditorElement {
                     );
 
                     let mut max_visible_line_width = Pixels::ZERO;
-                    let mut line_layouts = Self::layout_lines(
-                        start_row..end_row,
-                        &line_numbers,
-                        &snapshot,
-                        &self.style,
-                        cx,
-                    );
+                    let mut line_layouts =
+                        self.layout_lines(start_row..end_row, &line_numbers, &snapshot, cx);
                     for line_with_invisibles in &line_layouts {
                         if line_with_invisibles.width > max_visible_line_width {
                             max_visible_line_width = line_with_invisibles.width;
@@ -4828,43 +4791,16 @@ impl Element for EditorElement {
                         )
                     });
 
-                    let start_buffer_row =
-                        MultiBufferRow(start_anchor.to_point(&snapshot.buffer_snapshot).row);
-                    let end_buffer_row =
-                        MultiBufferRow(end_anchor.to_point(&snapshot.buffer_snapshot).row);
-
-                    let scroll_max = point(
-                        ((scroll_width - text_hitbox.size.width) / em_width).max(0.0),
-                        max_row.as_f32(),
-                    );
-
-                    self.editor.update(cx, |editor, cx| {
-                        let clamped = editor.scroll_manager.clamp_scroll_left(scroll_max.x);
-
-                        let autoscrolled = if autoscroll_horizontally {
-                            editor.autoscroll_horizontally(
-                                start_row,
-                                text_hitbox.size.width,
-                                scroll_width,
-                                em_width,
-                                &line_layouts,
-                                cx,
-                            )
-                        } else {
-                            false
-                        };
-
-                        if clamped || autoscrolled {
-                            snapshot = editor.snapshot(cx);
-                            scroll_position = snapshot.scroll_position();
-                        }
-                    });
-
                     let scroll_pixel_position = point(
                         scroll_position.x * em_width,
                         scroll_position.y * line_height,
                     );
 
+                    let start_buffer_row =
+                        MultiBufferRow(start_anchor.to_point(&snapshot.buffer_snapshot).row);
+                    let end_buffer_row =
+                        MultiBufferRow(end_anchor.to_point(&snapshot.buffer_snapshot).row);
+
                     let indent_guides = self.layout_indent_guides(
                         content_origin,
                         text_hitbox.origin,
@@ -6128,7 +6064,7 @@ mod tests {
         });
 
         for editor_mode_without_invisibles in [
-            EditorMode::SingleLine { auto_width: false },
+            EditorMode::SingleLine,
             EditorMode::AutoHeight { max_lines: 100 },
         ] {
             let invisibles = collect_invisibles_from_new_editor(

crates/editor/src/indent_guides.rs

@@ -165,16 +165,10 @@ pub fn indent_guides_in_range(
         .indent_guides_in_range(start_anchor..end_anchor, ignore_disabled_for_language, cx)
         .into_iter()
         .filter(|indent_guide| {
-            let start =
-                MultiBufferRow(indent_guide.multibuffer_row_range.start.0.saturating_sub(1));
             // Filter out indent guides that are inside a fold
-            let is_folded = snapshot.is_line_folded(start);
-            let line_indent = snapshot.line_indent_for_buffer_row(start);
-
-            let contained_in_fold =
-                line_indent.len(indent_guide.tab_size) <= indent_guide.indent_level();
-
-            !(is_folded && contained_in_fold)
+            !snapshot.is_line_folded(MultiBufferRow(
+                indent_guide.multibuffer_row_range.start.0.saturating_sub(1),
+            ))
         })
         .collect()
 }

crates/editor/src/scroll.rs

@@ -455,7 +455,7 @@ impl Editor {
     }
 
     pub fn scroll_screen(&mut self, amount: &ScrollAmount, cx: &mut ViewContext<Self>) {
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }

crates/editor/src/scroll/actions.rs

@@ -15,7 +15,7 @@ impl Editor {
             return;
         }
 
-        if matches!(self.mode, EditorMode::SingleLine { .. }) {
+        if matches!(self.mode, EditorMode::SingleLine) {
             cx.propagate();
             return;
         }

crates/gpui/Cargo.toml

@@ -42,7 +42,7 @@ futures.workspace = true
 font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "5a5c4d4" }
 gpui_macros.workspace = true
 http.workspace = true
-image = "0.25.1"
+image = "0.23"
 itertools.workspace = true
 lazy_static.workspace = true
 linkme = "0.3"
@@ -81,9 +81,6 @@ collections = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }
 http = { workspace = true, features = ["test-support"] }
 
-[build-dependencies]
-embed-resource = "2.4"
-
 [target.'cfg(target_os = "macos")'.build-dependencies]
 bindgen = "0.65.1"
 cbindgen = "0.26.0"
@@ -146,6 +143,9 @@ windows.workspace = true
 windows-core = "0.57"
 clipboard-win = "3.1.1"
 
+[target.'cfg(windows)'.build-dependencies]
+embed-resource = "2.4"
+
 [[example]]
 name = "hello_world"
 path = "examples/hello_world.rs"

crates/gpui/build.rs

@@ -3,25 +3,18 @@
 //TODO: consider generating shader code for WGSL
 //TODO: deprecate "runtime-shaders" and "macos-blade"
 
-use std::env;
-
 fn main() {
-    let target = env::var("CARGO_CFG_TARGET_OS");
+    #[cfg(target_os = "macos")]
+    macos::build();
 
-    match target.as_deref() {
-        Ok("macos") => {
-            #[cfg(target_os = "macos")]
-            macos::build();
-        }
-        Ok("windows") => {
-            let manifest = std::path::Path::new("resources/windows/gpui.manifest.xml");
-            let rc_file = std::path::Path::new("resources/windows/gpui.rc");
-            println!("cargo:rerun-if-changed={}", manifest.display());
-            println!("cargo:rerun-if-changed={}", rc_file.display());
-            embed_resource::compile(rc_file, embed_resource::NONE);
-        }
-        _ => (),
-    };
+    #[cfg(target_os = "windows")]
+    {
+        let manifest = std::path::Path::new("resources/windows/gpui.manifest.xml");
+        let rc_file = std::path::Path::new("resources/windows/gpui.rc");
+        println!("cargo:rerun-if-changed={}", manifest.display());
+        println!("cargo:rerun-if-changed={}", rc_file.display());
+        embed_resource::compile(rc_file, embed_resource::NONE);
+    }
 }
 
 #[cfg(target_os = "macos")]

crates/gpui/examples/window_positioning.rs

@@ -51,7 +51,6 @@ fn main() {
                     kind: WindowKind::PopUp,
                     is_movable: false,
                     app_id: None,
-                    window_min_size: Size::default(),
                 }
             };
 

crates/gpui/src/assets.rs

@@ -1,6 +1,6 @@
 use crate::{size, DevicePixels, Result, SharedString, Size};
 
-use image::RgbaImage;
+use image::{Bgra, ImageBuffer};
 use std::{
     borrow::Cow,
     fmt,
@@ -40,12 +40,12 @@ pub(crate) struct RenderImageParams {
 pub struct ImageData {
     /// The ID associated with this image
     pub id: ImageId,
-    data: RgbaImage,
+    data: ImageBuffer<Bgra<u8>, Vec<u8>>,
 }
 
 impl ImageData {
     /// Create a new image from the given data.
-    pub fn new(data: RgbaImage) -> Self {
+    pub fn new(data: ImageBuffer<Bgra<u8>, Vec<u8>>) -> Self {
         static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
 
         Self {

crates/gpui/src/elements/img.rs

@@ -384,13 +384,7 @@ impl Asset for Image {
             };
 
             let data = if let Ok(format) = image::guess_format(&bytes) {
-                let mut data = image::load_from_memory_with_format(&bytes, format)?.into_rgba8();
-
-                // Convert from RGBA to BGRA.
-                for pixel in data.chunks_exact_mut(4) {
-                    pixel.swap(0, 2);
-                }
-
+                let data = image::load_from_memory_with_format(&bytes, format)?.into_bgra8();
                 ImageData::new(data)
             } else {
                 let pixmap =

crates/gpui/src/geometry.rs

@@ -2287,15 +2287,6 @@ impl Pixels {
     pub fn abs(&self) -> Self {
         Self(self.0.abs())
     }
-
-    /// Returns the f64 value of `Pixels`.
-    ///
-    /// # Returns
-    ///
-    /// A f64 value of the `Pixels`.
-    pub fn to_f64(self) -> f64 {
-        self.0 as f64
-    }
 }
 
 impl Mul<Pixels> for Pixels {

crates/gpui/src/platform.rs

@@ -567,9 +567,6 @@ pub struct WindowOptions {
 
     /// Application identifier of the window. Can by used by desktop environments to group applications together.
     pub app_id: Option<String>,
-
-    /// Window minimum size
-    pub window_min_size: Size<Pixels>,
 }
 
 /// The variables that can be configured when creating a new window
@@ -597,9 +594,6 @@ pub(crate) struct WindowParams {
     pub display_id: Option<DisplayId>,
 
     pub window_background: WindowBackgroundAppearance,
-
-    #[cfg_attr(target_os = "linux", allow(dead_code))]
-    pub window_min_size: Size<Pixels>,
 }
 
 /// Represents the status of how a window should be opened.
@@ -648,7 +642,6 @@ impl Default for WindowOptions {
             display_id: None,
             window_background: WindowBackgroundAppearance::default(),
             app_id: None,
-            window_min_size: Size::default(),
         }
     }
 }

crates/gpui/src/platform/linux/platform.rs

@@ -583,11 +583,19 @@ impl Keystroke {
         let key_utf8 = state.key_get_utf8(keycode);
         let key_sym = state.key_get_one_sym(keycode);
 
+        // The logic here tries to replicate the logic in `../mac/events.rs`
+        // "Consumed" modifiers are modifiers that have been used to translate a key, for example
+        // pressing "shift" and "1" on US layout produces the key `!` but "consumes" the shift.
+        // Notes:
+        //  - macOS gets the key character directly ("."), xkb gives us the key name ("period")
+        //  - macOS logic removes consumed shift modifier for symbols: "{", not "shift-{"
+        //  - macOS logic keeps consumed shift modifiers for letters: "shift-a", not "a" or "A"
+
+        let mut handle_consumed_modifiers = true;
         let key = match key_sym {
             Keysym::Return => "enter".to_owned(),
             Keysym::Prior => "pageup".to_owned(),
             Keysym::Next => "pagedown".to_owned(),
-            Keysym::ISO_Left_Tab => "tab".to_owned(),
 
             Keysym::comma => ",".to_owned(),
             Keysym::period => ".".to_owned(),
@@ -625,22 +633,30 @@ impl Keystroke {
             Keysym::equal => "=".to_owned(),
             Keysym::plus => "+".to_owned(),
 
-            _ => xkb::keysym_get_name(key_sym).to_lowercase(),
-        };
-
-        if modifiers.shift {
-            // we only include the shift for upper-case letters by convention,
-            // so don't include for numbers and symbols, but do include for
-            // tab/enter, etc.
-            if key.chars().count() == 1 && key_utf8 == key {
-                modifiers.shift = false;
+            Keysym::ISO_Left_Tab => {
+                handle_consumed_modifiers = false;
+                "tab".to_owned()
             }
-        }
+
+            _ => {
+                handle_consumed_modifiers = false;
+                xkb::keysym_get_name(key_sym).to_lowercase()
+            }
+        };
 
         // Ignore control characters (and DEL) for the purposes of ime_key
         let ime_key =
             (key_utf32 >= 32 && key_utf32 != 127 && !key_utf8.is_empty()).then_some(key_utf8);
 
+        if handle_consumed_modifiers {
+            let mod_shift_index = state.get_keymap().mod_get_index(xkb::MOD_NAME_SHIFT);
+            let is_shift_consumed = state.mod_index_is_consumed(keycode, mod_shift_index);
+
+            if modifiers.shift && is_shift_consumed {
+                modifiers.shift = false;
+            }
+        }
+
         Keystroke {
             modifiers,
             key,

crates/gpui/src/platform/linux/wayland/client.rs

@@ -671,12 +671,12 @@ impl LinuxClient for WaylandClient {
             return;
         };
         if state.mouse_focused_window.is_some() || state.keyboard_focused_window.is_some() {
-            state.clipboard.set_primary(item.text);
-            let serial = state.serial_tracker.get(SerialKind::KeyPress);
+            let serial = state.serial_tracker.get(SerialKind::KeyEnter);
             let data_source = primary_selection_manager.create_source(&state.globals.qh, ());
             data_source.offer(state.clipboard.self_mime());
             data_source.offer(TEXT_MIME_TYPE.to_string());
             primary_selection.set_selection(Some(&data_source), serial);
+            state.clipboard.set_primary(item.text);
         }
     }
 
@@ -689,12 +689,12 @@ impl LinuxClient for WaylandClient {
             return;
         };
         if state.mouse_focused_window.is_some() || state.keyboard_focused_window.is_some() {
-            state.clipboard.set(item.text);
-            let serial = state.serial_tracker.get(SerialKind::KeyPress);
+            let serial = state.serial_tracker.get(SerialKind::KeyEnter);
             let data_source = data_device_manager.create_data_source(&state.globals.qh, ());
             data_source.offer(state.clipboard.self_mime());
             data_source.offer(TEXT_MIME_TYPE.to_string());
             data_device.set_selection(Some(&data_source), serial);
+            state.clipboard.set(item.text);
         }
     }
 

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

@@ -344,7 +344,6 @@ struct MacWindowState {
     // Whether the next left-mouse click is also the focusing click.
     first_mouse: bool,
     fullscreen_restore_bounds: Bounds<Pixels>,
-    ime_composing: bool,
 }
 
 impl MacWindowState {
@@ -505,7 +504,6 @@ impl MacWindow {
             focus,
             show,
             display_id,
-            window_min_size,
         }: WindowParams,
         executor: ForegroundExecutor,
         renderer_context: renderer::Context,
@@ -625,7 +623,6 @@ impl MacWindow {
                 external_files_dragged: false,
                 first_mouse: false,
                 fullscreen_restore_bounds: Bounds::default(),
-                ime_composing: false,
             })));
 
             (*native_window).set_ivar(
@@ -647,11 +644,6 @@ impl MacWindow {
 
             native_window.setMovable_(is_movable as BOOL);
 
-            native_window.setContentMinSize_(NSSize {
-                width: window_min_size.width.to_f64(),
-                height: window_min_size.height.to_f64(),
-            });
-
             if titlebar.map_or(true, |titlebar| titlebar.appears_transparent) {
                 native_window.setTitlebarAppearsTransparent_(YES);
                 native_window.setTitleVisibility_(NSWindowTitleVisibility::NSWindowTitleHidden);
@@ -1242,7 +1234,6 @@ extern "C" fn handle_key_event(this: &Object, native_event: id, key_equivalent:
         let mut lock = window_state.lock();
         let previous_keydown_inserted_text = lock.previous_keydown_inserted_text.take();
         let mut last_inserts = lock.last_ime_inputs.take().unwrap();
-        let ime_composing = std::mem::take(&mut lock.ime_composing);
 
         let mut callback = lock.event_callback.take();
         drop(lock);
@@ -1257,8 +1248,7 @@ extern "C" fn handle_key_event(this: &Object, native_event: id, key_equivalent:
         let is_composing =
             with_input_handler(this, |input_handler| input_handler.marked_text_range())
                 .flatten()
-                .is_some()
-                || ime_composing;
+                .is_some();
 
         if let Some((text, range)) = last_insert {
             if !is_composing {
@@ -1932,7 +1922,6 @@ fn send_to_input_handler(window: &Object, ime: ImeInput) {
                     input_handler.replace_text_in_range(range, &text)
                 }
                 ImeInput::SetMarkedText(text, range, marked_range) => {
-                    lock.ime_composing = true;
                     drop(lock);
                     input_handler.replace_and_mark_text_in_range(range, &text, marked_range)
                 }

crates/gpui/src/platform/windows/events.rs

@@ -267,8 +267,14 @@ fn handle_syskeydown_msg(
 ) -> Option<isize> {
     // we need to call `DefWindowProcW`, or we will lose the system-wide `Alt+F4`, `Alt+{other keys}`
     // shortcuts.
-    let keystroke = parse_syskeydown_msg_keystroke(wparam)?;
-    let mut func = state_ptr.state.borrow_mut().callbacks.input.take()?;
+    let Some(keystroke) = parse_syskeydown_msg_keystroke(wparam) else {
+        return None;
+    };
+    let mut lock = state_ptr.state.borrow_mut();
+    let Some(mut func) = lock.callbacks.input.take() else {
+        return None;
+    };
+    drop(lock);
     let event = KeyDownEvent {
         keystroke,
         is_held: lparam.0 & (0x1 << 30) > 0,
@@ -286,8 +292,14 @@ fn handle_syskeydown_msg(
 fn handle_syskeyup_msg(wparam: WPARAM, state_ptr: Rc<WindowsWindowStatePtr>) -> Option<isize> {
     // we need to call `DefWindowProcW`, or we will lose the system-wide `Alt+F4`, `Alt+{other keys}`
     // shortcuts.
-    let keystroke = parse_syskeydown_msg_keystroke(wparam)?;
-    let mut func = state_ptr.state.borrow_mut().callbacks.input.take()?;
+    let Some(keystroke) = parse_syskeydown_msg_keystroke(wparam) else {
+        return None;
+    };
+    let mut lock = state_ptr.state.borrow_mut();
+    let Some(mut func) = lock.callbacks.input.take() else {
+        return None;
+    };
+    drop(lock);
     let event = KeyUpEvent { keystroke };
     let result = if func(PlatformInput::KeyUp(event)).default_prevented {
         Some(0)
@@ -602,25 +614,35 @@ fn handle_ime_composition(
 ) -> Option<isize> {
     let mut ime_input = None;
     if lparam.0 as u32 & GCS_COMPSTR.0 > 0 {
-        let (comp_string, string_len) = parse_ime_compostion_string(handle)?;
-        let mut input_handler = state_ptr.state.borrow_mut().input_handler.take()?;
-        input_handler.replace_and_mark_text_in_range(
-            None,
-            &comp_string,
-            Some(string_len..string_len),
-        );
+        let Some((string, string_len)) = parse_ime_compostion_string(handle) else {
+            return None;
+        };
+        let mut lock = state_ptr.state.borrow_mut();
+        let Some(mut input_handler) = lock.input_handler.take() else {
+            return None;
+        };
+        drop(lock);
+        input_handler.replace_and_mark_text_in_range(None, string.as_str(), Some(0..string_len));
         state_ptr.state.borrow_mut().input_handler = Some(input_handler);
-        ime_input = Some(comp_string);
+        ime_input = Some(string);
     }
     if lparam.0 as u32 & GCS_CURSORPOS.0 > 0 {
-        let comp_string = &ime_input?;
+        let Some(ref comp_string) = ime_input else {
+            return None;
+        };
         let caret_pos = retrieve_composition_cursor_position(handle);
-        let mut input_handler = state_ptr.state.borrow_mut().input_handler.take()?;
-        input_handler.replace_and_mark_text_in_range(None, comp_string, Some(caret_pos..caret_pos));
+        let mut lock = state_ptr.state.borrow_mut();
+        let Some(mut input_handler) = lock.input_handler.take() else {
+            return None;
+        };
+        drop(lock);
+        input_handler.replace_and_mark_text_in_range(None, comp_string, Some(0..caret_pos));
         state_ptr.state.borrow_mut().input_handler = Some(input_handler);
     }
     if lparam.0 as u32 & GCS_RESULTSTR.0 > 0 {
-        let comp_result = parse_ime_compostion_result(handle)?;
+        let Some(comp_result) = parse_ime_compostion_result(handle) else {
+            return None;
+        };
         let mut lock = state_ptr.state.borrow_mut();
         let Some(mut input_handler) = lock.input_handler.take() else {
             return Some(1);
@@ -641,7 +663,11 @@ fn handle_calc_client_size(
     lparam: LPARAM,
     state_ptr: Rc<WindowsWindowStatePtr>,
 ) -> Option<isize> {
-    if !state_ptr.hide_title_bar || state_ptr.state.borrow().is_fullscreen() || wparam.0 == 0 {
+    if !state_ptr.hide_title_bar || state_ptr.state.borrow().is_fullscreen() {
+        return None;
+    }
+
+    if wparam.0 == 0 {
         return None;
     }
 
@@ -1071,14 +1097,13 @@ fn parse_syskeydown_msg_keystroke(wparam: WPARAM) -> Option<Keystroke> {
         VK_NEXT => "pagedown",
         VK_ESCAPE => "escape",
         VK_INSERT => "insert",
-        VK_DELETE => "delete",
         _ => return basic_vkcode_to_string(vk_code, modifiers),
     }
     .to_owned();
 
     Some(Keystroke {
         modifiers,
-        key,
+        key: key,
         ime_key: None,
     })
 }
@@ -1135,7 +1160,7 @@ fn parse_keydown_msg_keystroke(wparam: WPARAM) -> Option<KeystrokeOrModifier> {
 
     Some(KeystrokeOrModifier::Keystroke(Keystroke {
         modifiers,
-        key,
+        key: key,
         ime_key: None,
     }))
 }

crates/gpui/src/window.rs

@@ -631,7 +631,6 @@ impl Window {
             display_id,
             window_background,
             app_id,
-            window_min_size,
         } = options;
 
         let bounds = window_bounds
@@ -648,7 +647,6 @@ impl Window {
                 show,
                 display_id,
                 window_background,
-                window_min_size,
             },
         )?;
         let display_id = platform_window.display().map(|display| display.id());
@@ -754,11 +752,6 @@ impl Window {
                 handle
                     .update(&mut cx, |_, cx| {
                         cx.window.active.set(active);
-                        // If the window is occluded we may not render it again
-                        // until
-                        if !active {
-                            cx.window.rendered_frame.window_active = false;
-                        }
                         cx.window
                             .activation_observers
                             .clone()

crates/languages/src/json.rs

@@ -1,32 +1,25 @@
-use anyhow::{anyhow, bail, Context, Result};
-use async_compression::futures::bufread::GzipDecoder;
-use async_tar::Archive;
+use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use collections::HashMap;
 use feature_flags::FeatureFlagAppExt;
 use futures::StreamExt;
 use gpui::{AppContext, AsyncAppContext};
-use http::github::{latest_github_release, GitHubLspBinaryVersion};
 use language::{LanguageRegistry, LanguageServerName, LspAdapter, LspAdapterDelegate};
 use lsp::LanguageServerBinary;
 use node_runtime::NodeRuntime;
 use project::ContextProviderWithTasks;
 use serde_json::{json, Value};
 use settings::{KeymapFile, SettingsJsonSchemaParams, SettingsStore};
-use smol::{
-    fs::{self},
-    io::BufReader,
-};
+use smol::fs;
 use std::{
     any::Any,
-    env::consts,
     ffi::OsString,
     path::{Path, PathBuf},
     str::FromStr,
     sync::{Arc, OnceLock},
 };
 use task::{TaskTemplate, TaskTemplates, VariableName};
-use util::{fs::remove_matching, maybe, ResultExt};
+use util::{maybe, ResultExt};
 
 const SERVER_PATH: &str =
     "node_modules/vscode-langservers-extracted/bin/vscode-json-language-server";
@@ -258,137 +251,3 @@ fn schema_file_match(path: &Path) -> String {
         .to_string()
         .replace('\\', "/")
 }
-
-pub(super) struct NodeVersionAdapter;
-
-#[async_trait(?Send)]
-impl LspAdapter for NodeVersionAdapter {
-    fn name(&self) -> LanguageServerName {
-        LanguageServerName("package-version-server".into())
-    }
-
-    async fn fetch_latest_server_version(
-        &self,
-        delegate: &dyn LspAdapterDelegate,
-    ) -> Result<Box<dyn 'static + Send + Any>> {
-        let release = latest_github_release(
-            "zed-industries/package-version-server",
-            true,
-            false,
-            delegate.http_client(),
-        )
-        .await?;
-        let os = match consts::OS {
-            "macos" => "apple-darwin",
-            "linux" => "unknown-linux-gnu",
-            "windows" => "pc-windows-msvc",
-            other => bail!("Running on unsupported os: {other}"),
-        };
-        let suffix = if consts::OS == "windows" {
-            ".zip"
-        } else {
-            ".tar.gz"
-        };
-        let asset_name = format!("package-version-server-{}-{os}{suffix}", consts::ARCH);
-        let asset = release
-            .assets
-            .iter()
-            .find(|asset| asset.name == asset_name)
-            .with_context(|| format!("no asset found matching `{asset_name:?}`"))?;
-        Ok(Box::new(GitHubLspBinaryVersion {
-            name: release.tag_name,
-            url: asset.browser_download_url.clone(),
-        }))
-    }
-
-    async fn fetch_server_binary(
-        &self,
-        latest_version: Box<dyn 'static + Send + Any>,
-        container_dir: PathBuf,
-        delegate: &dyn LspAdapterDelegate,
-    ) -> Result<LanguageServerBinary> {
-        let version = latest_version.downcast::<GitHubLspBinaryVersion>().unwrap();
-        let destination_path =
-            container_dir.join(format!("package-version-server-{}", version.name));
-        let destination_container_path =
-            container_dir.join(format!("package-version-server-{}-tmp", version.name));
-        if fs::metadata(&destination_path).await.is_err() {
-            let mut response = delegate
-                .http_client()
-                .get(&version.url, Default::default(), true)
-                .await
-                .map_err(|err| anyhow!("error downloading release: {}", err))?;
-            if version.url.ends_with(".zip") {
-                node_runtime::extract_zip(
-                    &destination_container_path,
-                    BufReader::new(response.body_mut()),
-                )
-                .await?;
-            } else if version.url.ends_with(".tar.gz") {
-                let decompressed_bytes = GzipDecoder::new(BufReader::new(response.body_mut()));
-                let archive = Archive::new(decompressed_bytes);
-                archive.unpack(&destination_container_path).await?;
-            }
-
-            fs::copy(
-                destination_container_path.join("package-version-server"),
-                &destination_path,
-            )
-            .await?;
-            // todo("windows")
-            #[cfg(not(windows))]
-            {
-                fs::set_permissions(
-                    &destination_path,
-                    <fs::Permissions as fs::unix::PermissionsExt>::from_mode(0o755),
-                )
-                .await?;
-            }
-            remove_matching(&container_dir, |entry| entry != destination_path).await;
-        }
-
-        Ok(LanguageServerBinary {
-            path: destination_path.join("package-version-server"),
-            env: None,
-            arguments: Default::default(),
-        })
-    }
-
-    async fn cached_server_binary(
-        &self,
-        container_dir: PathBuf,
-        _delegate: &dyn LspAdapterDelegate,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_version_server_binary(container_dir).await
-    }
-
-    async fn installation_test_binary(
-        &self,
-        container_dir: PathBuf,
-    ) -> Option<LanguageServerBinary> {
-        get_cached_version_server_binary(container_dir)
-            .await
-            .map(|mut binary| {
-                binary.arguments = vec!["--version".into()];
-                binary
-            })
-    }
-}
-
-async fn get_cached_version_server_binary(container_dir: PathBuf) -> Option<LanguageServerBinary> {
-    maybe!(async {
-        let mut last = None;
-        let mut entries = fs::read_dir(&container_dir).await?;
-        while let Some(entry) = entries.next().await {
-            last = Some(entry?.path());
-        }
-
-        anyhow::Ok(LanguageServerBinary {
-            path: last.ok_or_else(|| anyhow!("no cached binary"))?,
-            env: None,
-            arguments: Default::default(),
-        })
-    })
-    .await
-    .log_err()
-}

crates/languages/src/lib.rs

@@ -117,13 +117,10 @@ pub fn init(
 
     language!(
         "json",
-        vec![
-            Arc::new(json::JsonLspAdapter::new(
-                node_runtime.clone(),
-                languages.clone(),
-            )),
-            Arc::new(json::NodeVersionAdapter)
-        ],
+        vec![Arc::new(json::JsonLspAdapter::new(
+            node_runtime.clone(),
+            languages.clone(),
+        ))],
         json_task_context()
     );
     language!("markdown");

crates/languages/src/rust.rs

@@ -201,18 +201,11 @@ impl LspAdapter for RustLspAdapter {
         completion: &lsp::CompletionItem,
         language: &Arc<Language>,
     ) -> Option<CodeLabel> {
-        let detail = completion
-            .detail
-            .as_ref()
-            .or(completion
-                .label_details
-                .as_ref()
-                .and_then(|detail| detail.detail.as_ref()))
-            .map(ToOwned::to_owned);
         match completion.kind {
-            Some(lsp::CompletionItemKind::FIELD) if detail.is_some() => {
+            Some(lsp::CompletionItemKind::FIELD) if completion.detail.is_some() => {
+                let detail = completion.detail.as_ref().unwrap();
                 let name = &completion.label;
-                let text = format!("{}: {}", name, detail.unwrap());
+                let text = format!("{}: {}", name, detail);
                 let source = Rope::from(format!("struct S {{ {} }}", text).as_str());
                 let runs = language.highlight_text(&source, 11..11 + text.len());
                 return Some(CodeLabel {
@@ -222,11 +215,12 @@ impl LspAdapter for RustLspAdapter {
                 });
             }
             Some(lsp::CompletionItemKind::CONSTANT | lsp::CompletionItemKind::VARIABLE)
-                if detail.is_some()
+                if completion.detail.is_some()
                     && completion.insert_text_format != Some(lsp::InsertTextFormat::SNIPPET) =>
             {
+                let detail = completion.detail.as_ref().unwrap();
                 let name = &completion.label;
-                let text = format!("{}: {}", name, detail.unwrap());
+                let text = format!("{}: {}", name, detail);
                 let source = Rope::from(format!("let {} = ();", text).as_str());
                 let runs = language.highlight_text(&source, 4..4 + text.len());
                 return Some(CodeLabel {
@@ -236,12 +230,12 @@ impl LspAdapter for RustLspAdapter {
                 });
             }
             Some(lsp::CompletionItemKind::FUNCTION | lsp::CompletionItemKind::METHOD)
-                if detail.is_some() =>
+                if completion.detail.is_some() =>
             {
                 lazy_static! {
                     static ref REGEX: Regex = Regex::new("\\(…?\\)").unwrap();
                 }
-                let detail = detail.unwrap();
+                let detail = completion.detail.as_ref().unwrap();
                 const FUNCTION_PREFIXES: [&'static str; 2] = ["async fn", "fn"];
                 let prefix = FUNCTION_PREFIXES
                     .iter()
@@ -275,14 +269,9 @@ impl LspAdapter for RustLspAdapter {
                     _ => None,
                 };
                 let highlight_id = language.grammar()?.highlight_id_for_name(highlight_name?)?;
-                let mut label = completion.label.clone();
-                if let Some(detail) = detail.filter(|detail| detail.starts_with(" (")) {
-                    use std::fmt::Write;
-                    write!(label, "{detail}").ok()?;
-                }
-                let mut label = CodeLabel::plain(label, None);
+                let mut label = CodeLabel::plain(completion.label.clone(), None);
                 label.runs.push((
-                    0..label.text.rfind('(').unwrap_or(completion.label.len()),
+                    0..label.text.rfind('(').unwrap_or(label.text.len()),
                     highlight_id,
                 ));
                 return Some(label);

crates/miner/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "miner"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "GPL-3.0-or-later"
+
+[[bin]]
+name = "miner"
+path = "src/miner.rs"
+
+[dependencies]
+anyhow.workspace = true
+futures.workspace = true
+heed.workspace = true
+ignore.workspace = true
+indicatif = "0.17.8"
+reqwest = { version = "0.12.5", features = ["json", "stream"] }
+serde.workspace = true
+serde_json.workspace = true
+tree-sitter.workspace = true
+tree-sitter-rust.workspace = true
+tokenizers = { version = "0.19.1", features = ["http"] }
+tokio.workspace = true

crates/miner/src/miner.rs

@@ -0,0 +1,794 @@
+use anyhow::{anyhow, Result};
+use futures::StreamExt;
+use heed::{
+    types::{SerdeJson, Str},
+    Database as HeedDatabase, EnvOpenOptions, RwTxn,
+};
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::{BTreeMap, HashMap, VecDeque},
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::SystemTime,
+};
+use tokenizers::tokenizer::Tokenizer;
+use tokenizers::FromPretrainedParameters;
+use tokio::sync::mpsc;
+use tokio::sync::Mutex;
+
+#[derive(Debug, Serialize)]
+struct Message {
+    role: String,
+    content: String,
+}
+
+pub struct OllamaClient {
+    client: Client,
+    base_url: String,
+}
+
+impl OllamaClient {
+    pub fn new(base_url: String) -> Self {
+        Self {
+            client: Client::new(),
+            base_url,
+        }
+    }
+
+    async fn stream_completion(
+        &self,
+        model: String,
+        messages: Vec<Message>,
+    ) -> Result<mpsc::Receiver<String>> {
+        let (tx, rx) = mpsc::channel(100);
+
+        let request = serde_json::json!({
+            "model": model,
+            "messages": messages,
+            "stream": true,
+        });
+
+        let response = self
+            .client
+            .post(format!("{}/api/chat", self.base_url))
+            .json(&request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!(
+                "error streaming completion: {:?}",
+                response.text().await?
+            ));
+        }
+
+        tokio::spawn(async move {
+            let mut stream = response.bytes_stream();
+            while let Some(chunk) = stream.next().await {
+                if let Ok(chunk) = chunk {
+                    if let Ok(text) = String::from_utf8(chunk.to_vec()) {
+                        if let Ok(response) = serde_json::from_str::<serde_json::Value>(&text) {
+                            if let Some(content) = response["message"]["content"].as_str() {
+                                let _ = tx.send(content.to_string()).await;
+                            }
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(rx)
+    }
+}
+
+pub struct HuggingFaceClient {
+    client: Client,
+    endpoint: String,
+    api_key: String,
+}
+
+impl HuggingFaceClient {
+    pub fn new(endpoint: String, api_key: String) -> Self {
+        Self {
+            client: Client::new(),
+            endpoint,
+            api_key,
+        }
+    }
+
+    async fn stream_completion(
+        &self,
+        model: String,
+        messages: Vec<Message>,
+    ) -> Result<mpsc::Receiver<String>> {
+        let (tx, rx) = mpsc::channel(100);
+
+        let request = serde_json::json!({
+            "model": model,
+            "messages": messages,
+            "stream": true,
+            "max_tokens": 2048
+        });
+
+        let response = self
+            .client
+            .post(&self.endpoint)
+            .header("Authorization", format!("Bearer {}", self.api_key))
+            .header("Content-Type", "application/json")
+            .json(&request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!(
+                "error streaming completion: {:?}",
+                response.text().await?
+            ));
+        }
+
+        tokio::spawn(async move {
+            let mut stream = response.bytes_stream();
+            while let Some(chunk) = stream.next().await {
+                if let Ok(chunk) = chunk {
+                    if let Ok(text) = String::from_utf8(chunk.to_vec()) {
+                        for line in text.lines() {
+                            if line.starts_with("data:") {
+                                let json_str = line.trim_start_matches("data:");
+                                if json_str == "[DONE]" {
+                                    break;
+                                }
+
+                                if let Ok(response) =
+                                    serde_json::from_str::<serde_json::Value>(json_str)
+                                {
+                                    if let Some(content) =
+                                        response["choices"][0]["delta"]["content"].as_str()
+                                    {
+                                        let _ = tx.send(content.to_string()).await;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(rx)
+    }
+}
+
+const CHUNK_SIZE: usize = 5000;
+const OVERLAP: usize = 2_000;
+
+#[derive(Debug)]
+enum Entry {
+    File(PathBuf),
+    Directory(PathBuf),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct CachedSummary {
+    summary: String,
+    mtime: SystemTime,
+}
+
+#[derive(Clone)]
+struct Database {
+    tx: mpsc::Sender<Box<dyn FnOnce(&HeedDatabase<Str, SerdeJson<CachedSummary>>, RwTxn) + Send>>,
+}
+
+impl Database {
+    async fn new(db_path: &Path, root: &Path) -> Result<Self> {
+        std::fs::create_dir_all(&db_path)?;
+        let env = unsafe {
+            EnvOpenOptions::new()
+                .map_size(1024 * 1024 * 1024)
+                .max_dbs(3000)
+                .open(db_path)?
+        };
+        let mut wtxn = env.write_txn()?;
+        let db_name = format!("summaries_{}", root.to_string_lossy());
+        let db: HeedDatabase<Str, SerdeJson<CachedSummary>> =
+            env.create_database(&mut wtxn, Some(&db_name))?;
+        wtxn.commit()?;
+
+        let (tx, mut rx) = mpsc::channel::<
+            Box<dyn FnOnce(&HeedDatabase<Str, SerdeJson<CachedSummary>>, RwTxn) + Send>,
+        >(100);
+
+        tokio::spawn(async move {
+            while let Some(f) = rx.recv().await {
+                let wtxn = env.write_txn().unwrap();
+                f(&db, wtxn);
+            }
+        });
+
+        Ok(Self { tx })
+    }
+
+    async fn transact<F, T>(&self, f: F) -> Result<T>
+    where
+        F: FnOnce(&HeedDatabase<Str, SerdeJson<CachedSummary>>, RwTxn) -> Result<T>
+            + Send
+            + 'static,
+        T: 'static + Send,
+    {
+        let (tx, rx) = tokio::sync::oneshot::channel();
+        self.tx
+            .send(Box::new(move |db, txn| {
+                let result = f(db, txn);
+                let _ = tx.send(result);
+            }))
+            .await
+            .map_err(|_| anyhow!("database closed"))?;
+        Ok(rx.await.map_err(|_| anyhow!("transaction failed"))??)
+    }
+}
+
+async fn summarize_project(
+    db_path: &Path,
+    root: &Path,
+    num_workers: usize,
+) -> Result<BTreeMap<PathBuf, String>> {
+    let database = Database::new(db_path, root).await?;
+
+    let tokenizer = Tokenizer::from_pretrained(
+        "mistralai/Mistral-7B-Instruct-v0.1",
+        Some(FromPretrainedParameters {
+            revision: "main".into(),
+            user_agent: HashMap::default(),
+            auth_token: Some(
+                std::env::var("HUGGINGFACE_API_TOKEN").expect("HUGGINGFACE_API_TOKEN not set"),
+            ),
+        }),
+    )
+    .unwrap();
+    let client = Arc::new(HuggingFaceClient::new(
+        "https://c0es55wrh8muqy3g.us-east-1.aws.endpoints.huggingface.cloud/v1/chat/completions"
+            .into(),
+        std::env::var("HUGGINGFACE_API_TOKEN").expect("HUGGINGFACE_API_TOKEN not set"),
+    ));
+    let queue = Arc::new(Mutex::new(VecDeque::new()));
+
+    let multi_progress = Arc::new(MultiProgress::new());
+    let overall_progress = multi_progress.add(ProgressBar::new_spinner());
+    overall_progress.set_style(
+        ProgressStyle::default_spinner()
+            .template("{spinner:.green} {msg}")
+            .unwrap(),
+    );
+    overall_progress.set_message("Summarizing project...");
+
+    // Populate the queue with files and directories
+    let mut walker = ignore::WalkBuilder::new(root)
+        .hidden(true)
+        .ignore(true)
+        .build();
+    while let Some(entry) = walker.next() {
+        if let Ok(entry) = entry {
+            let path = entry.path().to_owned();
+            if entry.file_type().map_or(false, |ft| ft.is_dir()) {
+                queue.lock().await.push_back(Entry::Directory(path));
+            } else {
+                queue.lock().await.push_back(Entry::File(path));
+            }
+        }
+    }
+
+    let total_entries = queue.lock().await.len();
+    let progress_bar = multi_progress.add(ProgressBar::new(total_entries as u64));
+    progress_bar.set_style(
+        ProgressStyle::default_bar()
+            .template("[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} {msg}")
+            .unwrap()
+            .progress_chars("##-"),
+    );
+
+    let summaries = Arc::new(Mutex::new(BTreeMap::new()));
+    let paths_loaded_from_cache = Arc::new(Mutex::new(BTreeMap::new()));
+
+    let rust_language = tree_sitter_rust::language();
+
+    let workers: Vec<_> = (0..num_workers)
+        .map(|_| {
+            let queue = Arc::clone(&queue);
+            let client = Arc::clone(&client);
+            let summaries = Arc::clone(&summaries);
+            let tokenizer = tokenizer.clone();
+            let progress_bar = progress_bar.clone();
+            let database = database.clone();
+            let paths_loaded_from_cache = Arc::clone(&paths_loaded_from_cache);
+            let mut parser = tree_sitter::Parser::new();
+            parser.set_language(&rust_language).unwrap();
+            let rust_language = rust_language.clone();
+
+            tokio::spawn(async move {
+                loop {
+                    let mut queue_lock = queue.lock().await;
+                    let Some(entry) = queue_lock.pop_front() else {
+                        break;
+                    };
+
+                    match entry {
+                        Entry::File(path) => {
+                            drop(queue_lock);
+                            let summary = async {
+                                let mtime = tokio::fs::metadata(&path).await?.modified()?;
+                                let key = path.to_string_lossy().to_string();
+
+                                let cached = database
+                                    .transact({
+                                        let key = key.clone();
+                                        move |db, txn| Ok(db.get(&txn, &key)?)
+                                    })
+                                    .await?;
+                                if let Some(cached) = cached {
+                                    if cached.mtime == mtime {
+                                        paths_loaded_from_cache
+                                            .lock()
+                                            .await
+                                            .insert(path.clone(), true);
+                                        return Ok(cached.summary);
+                                    }
+                                }
+
+                                progress_bar.set_message(format!("Summarizing {}", path.display()));
+
+                                let content = tokio::fs::read_to_string(&path)
+                                    .await
+                                    .unwrap_or_else(|_| "binary file".into());
+
+                                let mut summary = String::new();
+
+                                if path.extension().map_or(false, |ext| ext == "rs") {
+                                    let tree = parser.parse(&content, None).unwrap();
+                                    let root_node = tree.root_node();
+
+                                    let export_query = tree_sitter::Query::new(
+                                        &rust_language,
+                                        include_str!("./rust_exports.scm"),
+                                    )
+                                    .unwrap();
+                                    let mut export_cursor = tree_sitter::QueryCursor::new();
+                                    let mut exports = Vec::new();
+                                    for m in export_cursor.matches(
+                                        &export_query,
+                                        root_node,
+                                        content.as_bytes(),
+                                    ) {
+                                        let mut current_level = 0;
+                                        let mut current_export = String::new();
+                                        for c in m.captures {
+                                            let export = content[c.node.byte_range()].to_string();
+                                            let indent = "  ".repeat(current_level);
+                                            if current_level == 0 {
+                                                current_export = format!("{}{}", indent, export);
+                                            } else {
+                                                current_export
+                                                    .push_str(&format!("\n{}{}", indent, export));
+                                            }
+                                            current_level += 1;
+                                        }
+                                        exports.push(current_export);
+                                    }
+
+                                    let import_query = tree_sitter::Query::new(
+                                        &rust_language,
+                                        include_str!("./rust_imports.scm"),
+                                    )
+                                    .unwrap();
+                                    let mut import_cursor = tree_sitter::QueryCursor::new();
+                                    let imports: Vec<_> = import_cursor
+                                        .matches(&import_query, root_node, content.as_bytes())
+                                        .flat_map(|m| m.captures)
+                                        .map(|c| content[c.node.byte_range()].to_string())
+                                        .collect();
+
+                                    summary.push_str("Summary: Rust file containing ");
+                                    if !exports.is_empty() {
+                                        summary.push_str(&format!("{} exports", exports.len()));
+                                        if !imports.is_empty() {
+                                            summary.push_str(" and ");
+                                        }
+                                    }
+                                    if !imports.is_empty() {
+                                        summary.push_str(&format!("{} imports", imports.len()));
+                                    }
+                                    summary.push('.');
+
+                                    if !exports.is_empty() {
+                                        summary.push_str("\nExports:\n");
+                                        summary.push_str(&exports.join("\n"));
+                                    }
+                                    if !imports.is_empty() {
+                                        summary.push_str("\nImports: ");
+                                        summary.push_str(&imports.join(", "));
+                                    }
+
+                                    println!("{}", summary);
+                                } else {
+                                    let chunks = split_into_chunks(
+                                        &content, &tokenizer, CHUNK_SIZE, OVERLAP,
+                                    );
+                                    let chunk_summaries =
+                                        summarize_chunks(&client, &chunks).await?;
+                                    summary =
+                                        combine_summaries(&client, &chunk_summaries, true).await?;
+                                }
+
+                                let cached_summary = CachedSummary {
+                                    summary: summary.clone(),
+                                    mtime,
+                                };
+                                database
+                                    .transact(move |db, mut txn| {
+                                        db.put(&mut txn, &key, &cached_summary)?;
+                                        txn.commit()?;
+                                        Ok(())
+                                    })
+                                    .await?;
+
+                                anyhow::Ok(summary)
+                            };
+
+                            let summary = summary.await.unwrap_or_else(|error| {
+                                format!("path could not be summarized: {error:?}")
+                            });
+                            summaries.lock().await.insert(path, summary);
+                            progress_bar.inc(1);
+                        }
+                        Entry::Directory(path) => {
+                            let mut dir_summaries = Vec::new();
+                            let mut all_children_summarized = true;
+                            let mut all_children_from_cache = true;
+                            let dir_walker = ignore::WalkBuilder::new(&path)
+                                .hidden(true)
+                                .ignore(true)
+                                .max_depth(Some(1))
+                                .build();
+                            for entry in dir_walker {
+                                if let Ok(entry) = entry {
+                                    if entry.path() != path {
+                                        if let Some(summary) =
+                                            summaries.lock().await.get(entry.path())
+                                        {
+                                            dir_summaries.push(summary.clone());
+                                            if !paths_loaded_from_cache
+                                                .lock()
+                                                .await
+                                                .get(entry.path())
+                                                .unwrap_or(&false)
+                                            {
+                                                all_children_from_cache = false;
+                                            }
+                                        } else {
+                                            all_children_summarized = false;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                            if all_children_summarized {
+                                drop(queue_lock);
+
+                                let combined_summary = async {
+                                    let key = path.to_string_lossy().to_string();
+                                    let mtime = tokio::fs::metadata(&path).await?.modified()?;
+
+                                    if all_children_from_cache {
+                                        if let Some(cached) = database
+                                            .transact({
+                                                let key = key.clone();
+                                                move |db, txn| Ok(db.get(&txn, &key)?)
+                                            })
+                                            .await?
+                                        {
+                                            paths_loaded_from_cache
+                                                .lock()
+                                                .await
+                                                .insert(path.clone(), true);
+                                            return Ok(cached.summary);
+                                        }
+                                    }
+
+                                    progress_bar
+                                        .set_message(format!("Summarizing {}", path.display()));
+
+                                    let combined_summary =
+                                        combine_summaries(&client, &dir_summaries, false).await?;
+                                    let cached_summary = CachedSummary {
+                                        summary: combined_summary.clone(),
+                                        mtime,
+                                    };
+                                    database
+                                        .transact(move |db, mut txn| {
+                                            db.put(&mut txn, &key, &cached_summary)?;
+                                            txn.commit()?;
+                                            Ok(())
+                                        })
+                                        .await?;
+                                    anyhow::Ok(combined_summary)
+                                };
+
+                                let combined_summary = combined_summary
+                                    .await
+                                    .unwrap_or_else(|_| "could not combine summaries".into());
+                                summaries.lock().await.insert(path, combined_summary);
+                                progress_bar.inc(1);
+                            } else {
+                                queue_lock.push_back(Entry::Directory(path));
+                            }
+                        }
+                    }
+                }
+
+                Ok::<_, anyhow::Error>(())
+            })
+        })
+        .collect();
+
+    for worker in workers {
+        worker.await??;
+    }
+
+    // Remove deleted entries from the database
+    database
+        .transact(|db, mut txn| {
+            let mut paths_to_delete = Vec::new();
+            for item in db.iter(&txn)? {
+                let (path, _) = item?;
+                let path = PathBuf::from(path);
+                if !path.exists() {
+                    paths_to_delete.push(path);
+                }
+            }
+
+            for path in paths_to_delete {
+                db.delete(&mut txn, &path.to_string_lossy())?;
+            }
+            txn.commit()?;
+            Ok(())
+        })
+        .await?;
+
+    progress_bar.finish_with_message("Summarization complete");
+    overall_progress.finish_with_message("Project summarization finished");
+
+    Ok(Arc::try_unwrap(summaries).unwrap().into_inner())
+}
+
+fn split_into_chunks(
+    content: &str,
+    tokenizer: &Tokenizer,
+    chunk_size: usize,
+    overlap: usize,
+) -> Vec<String> {
+    let mut chunks = Vec::new();
+    let lines: Vec<&str> = content.lines().collect();
+    let mut current_chunk = String::new();
+    let mut current_tokens = 0;
+
+    for line in lines {
+        let line_tokens = tokenizer.encode(line, false).unwrap().get_ids().len();
+        if current_tokens + line_tokens > chunk_size {
+            chunks.push(current_chunk.clone());
+            current_chunk.clear();
+            current_tokens = 0;
+        }
+        current_chunk.push_str(line);
+        current_chunk.push('\n');
+        current_tokens += line_tokens;
+    }
+
+    if !current_chunk.is_empty() {
+        chunks.push(current_chunk);
+    }
+
+    // Add overlap
+    for i in 1..chunks.len() {
+        let overlap_text = chunks[i - 1]
+            .lines()
+            .rev()
+            .take(overlap)
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+            .collect::<Vec<_>>()
+            .join("\n");
+        chunks[i] = format!("{}\n{}", overlap_text, chunks[i]);
+    }
+
+    chunks
+}
+
+async fn summarize_chunks(client: &HuggingFaceClient, chunks: &[String]) -> Result<Vec<String>> {
+    let mut chunk_summaries = Vec::new();
+
+    for chunk in chunks {
+        let summary = summarize_file(client, chunk).await?;
+        chunk_summaries.push(summary);
+    }
+
+    Ok(chunk_summaries)
+}
+
+async fn summarize_file(client: &HuggingFaceClient, content: &str) -> Result<String> {
+    let messages = vec![Message {
+        role: "user".to_string(),
+        content: format!(
+            "You are a code summarization assistant. \
+            Provide a brief summary of the given file, \
+            focusing on its main functionality and purpose. \
+            Be terse and start your response directly with \"Summary: \".\n\
+            File:\n{}",
+            content
+        ),
+    }];
+
+    let mut receiver = client
+        .stream_completion("tgi".to_string(), messages)
+        .await?;
+
+    let mut summary = String::new();
+    while let Some(content) = receiver.recv().await {
+        summary.push_str(&content);
+    }
+
+    Ok(summary)
+}
+
+async fn combine_summaries(
+    client: &HuggingFaceClient,
+    summaries: &[String],
+    is_chunk: bool,
+) -> Result<String> {
+    let combined_content = summaries.join("\n## Summary\n");
+    let prompt = if is_chunk {
+        concat!(
+            "You are a code summarization assistant. ",
+            "Combine the given summaries into a single, coherent summary ",
+            "that captures the overall functionality and structure of the code. ",
+            "Ensure that the final summary is comprehensive and reflects ",
+            "the content as if it was summarized from a single, complete file. ",
+            "Be terse and start your response with \"Summary: \""
+        )
+    } else {
+        concat!(
+            "You are a code summarization assistant. ",
+            "Combine the given summaries of different files or directories ",
+            "into a single, coherent summary that captures the overall ",
+            "structure and functionality of the project or directory. ",
+            "Focus on the relationships between different components ",
+            "and the high-level architecture. ",
+            "Be terse and start your response with \"Summary: \""
+        )
+    };
+
+    let messages = vec![Message {
+        role: "user".to_string(),
+        content: format!("{}\n# Summaries\n{}", prompt, combined_content),
+    }];
+
+    let mut receiver = client
+        .stream_completion("tgi".to_string(), messages)
+        .await?;
+
+    let mut combined_summary = String::new();
+    while let Some(content) = receiver.recv().await {
+        combined_summary.push_str(&content);
+    }
+
+    Ok(combined_summary)
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let args: Vec<String> = std::env::args().collect();
+
+    if args.len() < 2 {
+        eprintln!(
+            "Usage: {} <project_path> [db_path] [num_workers] [--read=path]",
+            args[0]
+        );
+        std::process::exit(1);
+    }
+
+    let project_path = Path::new(&args[1]);
+    if !project_path.exists() || !project_path.is_dir() {
+        eprintln!("Error: The provided project path does not exist or is not a directory.");
+        std::process::exit(1);
+    }
+
+    let db_path = if args.len() >= 3 && !args[2].starts_with("--") {
+        PathBuf::from(&args[2])
+    } else {
+        std::env::current_dir()?.join("project_summaries")
+    };
+
+    let num_workers = if args.len() >= 4 && !args[3].starts_with("--") {
+        args[3].parse().unwrap_or(8)
+    } else {
+        8
+    };
+
+    println!("Summarizing project at: {}", project_path.display());
+    println!("Using database at: {}", db_path.display());
+    println!("Number of workers: {}", num_workers);
+    let summaries = summarize_project(&db_path, project_path, num_workers).await?;
+    println!("Finished summarization");
+
+    // Check if --read flag is provided
+    if let Some(read_path) = args.iter().find(|arg| arg.starts_with("--read=")) {
+        let path = Path::new(&read_path[7..]);
+        let full_path = project_path.join(path);
+        for (child_path, summary) in summaries.iter() {
+            if child_path.parent() == Some(&full_path) {
+                println!("<path>{}</path>", child_path.to_string_lossy());
+                println!("<summary>{}</summary>", summary);
+                println!();
+            }
+        }
+    } else {
+        dbg!(summaries);
+    }
+
+    Ok(())
+}
+
+// #[derive(Debug, Serialize)]
+// struct ChatCompletionRequest {
+//     model: String,
+//     messages: Vec<Message>,
+//     stream: bool,
+// }
+//
+// #[derive(Debug, Deserialize)]
+// struct ChatCompletionChunk {
+//     choices: Vec<Choice>,
+// }
+
+// #[derive(Debug, Deserialize)]
+// struct Choice {
+//     delta: Delta,
+// }
+
+// #[derive(Debug, Deserialize)]
+// struct Delta {
+//     content: Option<String>,
+// }
+
+// pub struct GroqClient {
+//     client: Client,
+//     api_key: String,
+// }
+
+// impl GroqClient {
+//     pub fn new(api_key: String) -> Self {
+//         Self {
+//             client: Client::new(),
+//             api_key,
+//         }
+//     }
+
+//     async fn stream_completion(
+//         &self,
+//         model: String,
+//         messages: Vec<Message>,
+//     ) -> Result<mpsc::Receiver<String>> {
+//         let (tx, rx) = mpsc::channel(100);
+
+//         let request = ChatCompletionRequest {
+//             model,
+//             messages,
+//             stream: true,
+//         };
+
+//         let response = self
+//             .client
+//             .post("https://api.groq.com/openai/v1/chat/completions")
+//             .header("Authorization", format!("Bearer {}", self.api_key))
+//             .json(&request)
+//             .send

crates/miner/src/rust_exports.scm

@@ -0,0 +1,6 @@
+(mod_item name: (identifier) @export)
+(struct_item name: (type_identifier) @export)
+(impl_item type: (type_identifier) @export)
+(enum_item name: (type_identifier) @export)
+(function_item name: (identifier) @export)
+(trait_item name: (type_identifier) @export)

crates/miner/src/rust_imports.scm

@@ -0,0 +1 @@
+(use_declaration) @import

crates/node_runtime/src/node_runtime.rs

@@ -1,7 +1,6 @@
 mod archive;
 
 use anyhow::{anyhow, bail, Context, Result};
-pub use archive::extract_zip;
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use futures::AsyncReadExt;

crates/project_panel/src/project_panel.rs

@@ -72,7 +72,7 @@ pub struct ProjectPanel {
     width: Option<Pixels>,
     pending_serialization: Task<Option<()>>,
     show_scrollbar: bool,
-    scrollbar_drag_thumb_offset: Rc<Cell<Option<f32>>>,
+    is_dragging_scrollbar: Rc<Cell<bool>>,
     hide_scrollbar_task: Option<Task<()>>,
 }
 
@@ -289,7 +289,7 @@ impl ProjectPanel {
                 pending_serialization: Task::ready(None),
                 show_scrollbar: !Self::should_autohide_scrollbar(cx),
                 hide_scrollbar_task: None,
-                scrollbar_drag_thumb_offset: Default::default(),
+                is_dragging_scrollbar: Default::default(),
             };
             this.update_visible_entries(None, cx);
 
@@ -2231,7 +2231,7 @@ impl ProjectPanel {
 
         let height = scroll_handle
             .last_item_height
-            .filter(|_| self.show_scrollbar || self.scrollbar_drag_thumb_offset.get().is_some())?;
+            .filter(|_| self.show_scrollbar || self.is_dragging_scrollbar.get())?;
 
         let total_list_length = height.0 as f64 * items_count as f64;
         let current_offset = scroll_handle.base_handle.offset().y.0.min(0.).abs() as f64;
@@ -2270,7 +2270,7 @@ impl ProjectPanel {
                 .on_mouse_up(
                     MouseButton::Left,
                     cx.listener(|this, _, cx| {
-                        if this.scrollbar_drag_thumb_offset.get().is_none()
+                        if !this.is_dragging_scrollbar.get()
                             && !this.focus_handle.contains_focused(cx)
                         {
                             this.hide_scrollbar(cx);
@@ -2293,7 +2293,7 @@ impl ProjectPanel {
                 .child(ProjectPanelScrollbar::new(
                     percentage as f32..end_offset as f32,
                     self.scroll_handle.clone(),
-                    self.scrollbar_drag_thumb_offset.clone(),
+                    self.is_dragging_scrollbar.clone(),
                     cx.view().clone().into(),
                     items_count,
                 )),

crates/project_panel/src/scrollbar.rs

@@ -9,8 +9,7 @@ use ui::{prelude::*, px, relative, IntoElement};
 pub(crate) struct ProjectPanelScrollbar {
     thumb: Range<f32>,
     scroll: UniformListScrollHandle,
-    // If Some(), there's an active drag, offset by percentage from the top of thumb.
-    scrollbar_drag_state: Rc<Cell<Option<f32>>>,
+    is_dragging_scrollbar: Rc<Cell<bool>>,
     item_count: usize,
     view: AnyView,
 }
@@ -19,14 +18,14 @@ impl ProjectPanelScrollbar {
     pub(crate) fn new(
         thumb: Range<f32>,
         scroll: UniformListScrollHandle,
-        scrollbar_drag_state: Rc<Cell<Option<f32>>>,
+        is_dragging_scrollbar: Rc<Cell<bool>>,
         view: AnyView,
         item_count: usize,
     ) -> Self {
         Self {
             thumb,
             scroll,
-            scrollbar_drag_state,
+            is_dragging_scrollbar,
             item_count,
             view,
         }
@@ -98,7 +97,7 @@ impl gpui::Element for ProjectPanelScrollbar {
             let item_count = self.item_count;
             cx.on_mouse_event({
                 let scroll = self.scroll.clone();
-                let is_dragging = self.scrollbar_drag_state.clone();
+                let is_dragging = self.is_dragging_scrollbar.clone();
                 move |event: &MouseDownEvent, phase, _cx| {
                     if phase.bubble() && bounds.contains(&event.position) {
                         if !thumb_bounds.contains(&event.position) {
@@ -114,9 +113,7 @@ impl gpui::Element for ProjectPanelScrollbar {
                                     .set_offset(point(px(0.), -max_offset * percentage));
                             }
                         } else {
-                            let thumb_top_offset =
-                                (event.position.y - thumb_bounds.origin.y) / bounds.size.height;
-                            is_dragging.set(Some(thumb_top_offset));
+                            is_dragging.set(true);
                         }
                     }
                 }
@@ -133,15 +130,14 @@ impl gpui::Element for ProjectPanelScrollbar {
                     }
                 }
             });
-            let drag_state = self.scrollbar_drag_state.clone();
+            let is_dragging = self.is_dragging_scrollbar.clone();
             let view_id = self.view.entity_id();
             cx.on_mouse_event(move |event: &MouseMoveEvent, _, cx| {
-                if let Some(drag_state) = drag_state.get().filter(|_| event.dragging()) {
+                if event.dragging() && is_dragging.get() {
                     let scroll = scroll.0.borrow();
                     if let Some(last_height) = scroll.last_item_height {
                         let max_offset = item_count as f32 * last_height;
-                        let percentage =
-                            (event.position.y - bounds.origin.y) / bounds.size.height - drag_state;
+                        let percentage = (event.position.y - bounds.origin.y) / bounds.size.height;
 
                         let percentage = percentage.min(1. - thumb_percentage_size);
                         scroll
@@ -150,13 +146,13 @@ impl gpui::Element for ProjectPanelScrollbar {
                         cx.notify(view_id);
                     }
                 } else {
-                    drag_state.set(None);
+                    is_dragging.set(false);
                 }
             });
-            let is_dragging = self.scrollbar_drag_state.clone();
+            let is_dragging = self.is_dragging_scrollbar.clone();
             cx.on_mouse_event(move |_event: &MouseUpEvent, phase, cx| {
                 if phase.bubble() {
-                    is_dragging.set(None);
+                    is_dragging.set(false);
                     cx.notify(view_id);
                 }
             });

crates/repl/src/outputs.rs

@@ -60,12 +60,7 @@ impl ImageView {
         let bytes = base64::decode(base64_encoded_data)?;
 
         let format = image::guess_format(&bytes)?;
-        let mut data = image::load_from_memory_with_format(&bytes, format)?.into_rgba8();
-
-        // Convert from RGBA to BGRA.
-        for pixel in data.chunks_exact_mut(4) {
-            pixel.swap(0, 2);
-        }
+        let data = image::load_from_memory_with_format(&bytes, format)?.into_bgra8();
 
         let height = data.height();
         let width = data.width();

crates/ui/src/clickable.rs

@@ -1,9 +1,7 @@
-use gpui::{ClickEvent, CursorStyle, WindowContext};
+use gpui::{ClickEvent, WindowContext};
 
 /// A trait for elements that can be clicked. Enables the use of the `on_click` method.
 pub trait Clickable {
     /// Sets the click handler that will fire whenever the element is clicked.
     fn on_click(self, handler: impl Fn(&ClickEvent, &mut WindowContext) + 'static) -> Self;
-    /// Sets the cursor style when hovering over the element.
-    fn cursor_style(self, cursor_style: CursorStyle) -> Self;
 }

crates/ui/src/components/button/button.rs

@@ -249,11 +249,6 @@ impl Clickable for Button {
         self.base = self.base.on_click(handler);
         self
     }
-
-    fn cursor_style(mut self, cursor_style: gpui::CursorStyle) -> Self {
-        self.base = self.base.cursor_style(cursor_style);
-        self
-    }
 }
 
 impl FixedWidth for Button {

crates/ui/src/components/button/button_like.rs

@@ -1,4 +1,4 @@
-use gpui::{relative, CursorStyle, DefiniteLength, MouseButton};
+use gpui::{relative, DefiniteLength, MouseButton};
 use gpui::{transparent_black, AnyElement, AnyView, ClickEvent, Hsla, Rems};
 use smallvec::SmallVec;
 
@@ -344,7 +344,6 @@ pub struct ButtonLike {
     size: ButtonSize,
     rounding: Option<ButtonLikeRounding>,
     tooltip: Option<Box<dyn Fn(&mut WindowContext) -> AnyView>>,
-    cursor_style: CursorStyle,
     on_click: Option<Box<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>>,
     children: SmallVec<[AnyElement; 2]>,
 }
@@ -364,7 +363,6 @@ impl ButtonLike {
             rounding: Some(ButtonLikeRounding::All),
             tooltip: None,
             children: SmallVec::new(),
-            cursor_style: CursorStyle::PointingHand,
             on_click: None,
             layer: None,
         }
@@ -407,11 +405,6 @@ impl Clickable for ButtonLike {
         self.on_click = Some(Box::new(handler));
         self
     }
-
-    fn cursor_style(mut self, cursor_style: CursorStyle) -> Self {
-        self.cursor_style = cursor_style;
-        self
-    }
 }
 
 impl FixedWidth for ButtonLike {

crates/ui/src/components/button/icon_button.rs

@@ -86,11 +86,6 @@ impl Clickable for IconButton {
         self.base = self.base.on_click(handler);
         self
     }
-
-    fn cursor_style(mut self, cursor_style: gpui::CursorStyle) -> Self {
-        self.base = self.base.cursor_style(cursor_style);
-        self
-    }
 }
 
 impl FixedWidth for IconButton {

crates/ui/src/components/button/toggle_button.rs

@@ -82,11 +82,6 @@ impl Clickable for ToggleButton {
         self.base = self.base.on_click(handler);
         self
     }
-
-    fn cursor_style(mut self, cursor_style: gpui::CursorStyle) -> Self {
-        self.base = self.base.cursor_style(cursor_style);
-        self
-    }
 }
 
 impl ButtonCommon for ToggleButton {

crates/ui/src/components/disclosure.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use gpui::{ClickEvent, CursorStyle};
+use gpui::ClickEvent;
 
 use crate::{prelude::*, Color, IconButton, IconButtonShape, IconName, IconSize};
 
@@ -10,7 +10,6 @@ pub struct Disclosure {
     is_open: bool,
     selected: bool,
     on_toggle: Option<Arc<dyn Fn(&ClickEvent, &mut WindowContext) + 'static>>,
-    cursor_style: CursorStyle,
 }
 
 impl Disclosure {
@@ -20,7 +19,6 @@ impl Disclosure {
             is_open,
             selected: false,
             on_toggle: None,
-            cursor_style: CursorStyle::PointingHand,
         }
     }
 
@@ -45,11 +43,6 @@ impl Clickable for Disclosure {
         self.on_toggle = Some(Arc::new(handler));
         self
     }
-
-    fn cursor_style(mut self, cursor_style: gpui::CursorStyle) -> Self {
-        self.cursor_style = cursor_style;
-        self
-    }
 }
 
 impl RenderOnce for Disclosure {

crates/ui/src/components/icon.rs

@@ -97,9 +97,6 @@ pub enum IconName {
     BellOff,
     BellRing,
     Bolt,
-    Book,
-    BookCopy,
-    BookPlus,
     CaseSensitive,
     Check,
     ChevronDown,
@@ -234,9 +231,6 @@ impl IconName {
             IconName::BellOff => "icons/bell_off.svg",
             IconName::BellRing => "icons/bell_ring.svg",
             IconName::Bolt => "icons/bolt.svg",
-            IconName::Book => "icons/book.svg",
-            IconName::BookCopy => "icons/book_copy.svg",
-            IconName::BookPlus => "icons/book_plus.svg",
             IconName::CaseSensitive => "icons/case_insensitive.svg",
             IconName::Check => "icons/check.svg",
             IconName::ChevronDown => "icons/chevron_down.svg",

crates/ui/src/components/title_bar/windows_window_controls.rs

@@ -11,25 +11,6 @@ impl WindowsWindowControls {
     pub fn new(button_height: Pixels) -> Self {
         Self { button_height }
     }
-
-    #[cfg(not(target_os = "windows"))]
-    fn get_font() -> &'static str {
-        "Segoe Fluent Icons"
-    }
-
-    #[cfg(target_os = "windows")]
-    fn get_font() -> &'static str {
-        use windows::Wdk::System::SystemServices::RtlGetVersion;
-
-        let mut version = unsafe { std::mem::zeroed() };
-        let status = unsafe { RtlGetVersion(&mut version) };
-
-        if status.is_ok() && version.dwBuildNumber >= 22000 {
-            "Segoe Fluent Icons"
-        } else {
-            "Segoe MDL2 Assets"
-        }
-    }
 }
 
 impl RenderOnce for WindowsWindowControls {
@@ -58,7 +39,6 @@ impl RenderOnce for WindowsWindowControls {
 
         div()
             .id("windows-window-controls")
-            .font_family(Self::get_font())
             .flex()
             .flex_row()
             .justify_center()
@@ -130,6 +110,7 @@ impl RenderOnce for WindowsCaptionButton {
             .content_center()
             .w(width)
             .h_full()
+            .font_family("Segoe Fluent Icons")
             .text_size(px(10.0))
             .hover(|style| style.bg(self.hover_background_color))
             .active(|style| {

crates/vim/src/normal/search.rs

@@ -127,16 +127,14 @@ fn search(workspace: &mut Workspace, action: &Search, cx: &mut ViewContext<Works
                         search_bar.set_replacement(None, cx);
                         search_bar.set_search_options(SearchOptions::REGEX, cx);
                     }
-                    vim.update_state(|state| {
-                        state.search = SearchState {
-                            direction,
-                            count,
-                            initial_query: query.clone(),
-                            prior_selections,
-                            prior_operator: state.operator_stack.last().cloned(),
-                            prior_mode: state.mode,
-                        }
-                    });
+                    vim.workspace_state.search = SearchState {
+                        direction,
+                        count,
+                        initial_query: query.clone(),
+                        prior_selections,
+                        prior_operator: vim.active_operator(),
+                        prior_mode: vim.state().mode,
+                    };
                 });
             }
         })
@@ -145,9 +143,7 @@ fn search(workspace: &mut Workspace, action: &Search, cx: &mut ViewContext<Works
 
 // hook into the existing to clear out any vim search state on cmd+f or edit -> find.
 fn search_deploy(_: &mut Workspace, _: &buffer_search::Deploy, cx: &mut ViewContext<Workspace>) {
-    Vim::update(cx, |vim, _| {
-        vim.update_state(|state| state.search = Default::default())
-    });
+    Vim::update(cx, |vim, _| vim.workspace_state.search = Default::default());
     cx.propagate();
 }
 
@@ -158,32 +154,27 @@ fn search_submit(workspace: &mut Workspace, _: &SearchSubmit, cx: &mut ViewConte
         pane.update(cx, |pane, cx| {
             if let Some(search_bar) = pane.toolbar().read(cx).item_of_type::<BufferSearchBar>() {
                 search_bar.update(cx, |search_bar, cx| {
-                    let (mut prior_selections, prior_mode, prior_operator) =
-                        vim.update_state(|state| {
-                            let mut count = state.search.count;
-                            let direction = state.search.direction;
-                            // in the case that the query has changed, the search bar
-                            // will have selected the next match already.
-                            if (search_bar.query(cx) != state.search.initial_query)
-                                && state.search.direction == Direction::Next
-                            {
-                                count = count.saturating_sub(1)
-                            }
-                            state.search.count = 1;
-                            search_bar.select_match(direction, count, cx);
-                            search_bar.focus_editor(&Default::default(), cx);
-
-                            let prior_selections: Vec<_> =
-                                state.search.prior_selections.drain(..).collect();
-                            let prior_mode = state.search.prior_mode;
-                            let prior_operator = state.search.prior_operator.take();
-                            (prior_selections, prior_mode, prior_operator)
-                        });
+                    let state = &mut vim.workspace_state.search;
+                    let mut count = state.count;
+                    let direction = state.direction;
 
+                    // in the case that the query has changed, the search bar
+                    // will have selected the next match already.
+                    if (search_bar.query(cx) != state.initial_query)
+                        && state.direction == Direction::Next
+                    {
+                        count = count.saturating_sub(1)
+                    }
                     vim.workspace_state
                         .registers
                         .insert('/', search_bar.query(cx).into());
+                    state.count = 1;
+                    search_bar.select_match(direction, count, cx);
+                    search_bar.focus_editor(&Default::default(), cx);
 
+                    let mut prior_selections: Vec<_> = state.prior_selections.drain(..).collect();
+                    let prior_mode = state.prior_mode;
+                    let prior_operator = state.prior_operator.take();
                     let new_selections = vim.editor_selections(cx);
 
                     // If the active editor has changed during a search, don't panic.

crates/vim/src/state.rs

@@ -93,7 +93,6 @@ pub struct EditorState {
     pub undo_modes: HashMap<TransactionId, Mode>,
 
     pub selected_register: Option<char>,
-    pub search: SearchState,
 }
 
 #[derive(Default, Clone, Debug)]
@@ -153,6 +152,7 @@ impl From<String> for Register {
 
 #[derive(Default, Clone)]
 pub struct WorkspaceState {
+    pub search: SearchState,
     pub last_find: Option<Motion>,
 
     pub recording: bool,

crates/worktree/src/ignore.rs

@@ -1,7 +1,6 @@
 use ignore::gitignore::Gitignore;
 use std::{ffi::OsStr, path::Path, sync::Arc};
 
-#[derive(Debug)]
 pub enum IgnoreStack {
     None,
     Some {

crates/worktree/src/worktree.rs

@@ -3825,8 +3825,19 @@ impl BackgroundScanner {
             .collect::<Vec<_>>()
             .await;
 
-        // Ensure that .git and .gitignore are processed first.
-        child_paths.sort_unstable();
+        // Ensure .git and gitignore files are processed first.
+        let mut ixs_to_move_to_front = Vec::new();
+        for (ix, child_abs_path) in child_paths.iter().enumerate() {
+            let filename = child_abs_path.file_name().unwrap();
+            if filename == *DOT_GIT {
+                ixs_to_move_to_front.insert(0, ix);
+            } else if filename == *GITIGNORE {
+                ixs_to_move_to_front.push(ix);
+            }
+        }
+        for (dest_ix, src_ix) in ixs_to_move_to_front.into_iter().enumerate() {
+            child_paths.swap(dest_ix, src_ix);
+        }
 
         for child_abs_path in child_paths {
             let child_abs_path: Arc<Path> = child_abs_path.into();
@@ -4076,7 +4087,6 @@ impl BackgroundScanner {
 
                     let is_dir = fs_entry.is_dir();
                     fs_entry.is_ignored = ignore_stack.is_abs_path_ignored(&abs_path, is_dir);
-
                     fs_entry.is_external = !canonical_path.starts_with(&root_canonical_path);
                     fs_entry.is_private = self.is_path_private(path);
 
@@ -4238,7 +4248,6 @@ impl BackgroundScanner {
             let was_ignored = entry.is_ignored;
             let abs_path: Arc<Path> = snapshot.abs_path().join(&entry.path).into();
             entry.is_ignored = ignore_stack.is_abs_path_ignored(&abs_path, entry.is_dir());
-
             if entry.is_dir() {
                 let child_ignore_stack = if entry.is_ignored {
                     IgnoreStack::all()

crates/zed/src/main.rs

@@ -56,11 +56,11 @@ use crate::zed::inline_completion_registry;
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 fn fail_to_launch(e: anyhow::Error) {
-    eprintln!("Zed failed to launch: {e:?}");
+    eprintln!("Zed failed to launch: {:?}", e);
     App::new().run(move |cx| {
         if let Ok(window) = cx.open_window(gpui::WindowOptions::default(), |cx| cx.new_view(|_| gpui::Empty)) {
             window.update(cx, |_, cx| {
-                let response = cx.prompt(gpui::PromptLevel::Critical, "Zed failed to launch", Some(&format!("{e}\n\nFor help resolving this, please open an issue on https://github.com/zed-industries/zed")), &["Exit"]);
+                let response = cx.prompt(gpui::PromptLevel::Critical, "Zed failed to launch", Some(&format!("{}\n\nFor help resolving this, please open an issue on https://github.com/zed-industries/zed", e)), &["Exit"]);
 
                 cx.spawn(|_, mut cx| async move {
                     response.await?;
@@ -80,7 +80,7 @@ fn fail_to_open_window_async(e: anyhow::Error, cx: &mut AsyncAppContext) {
 }
 
 fn fail_to_open_window(e: anyhow::Error, _cx: &mut AppContext) {
-    eprintln!("Zed failed to open a window: {e:?}");
+    eprintln!("Zed failed to open a window: {:?}", e);
     #[cfg(not(target_os = "linux"))]
     {
         process::exit(1);
@@ -99,7 +99,7 @@ fn fail_to_open_window(e: anyhow::Error, _cx: &mut AppContext) {
                 .add_notification(
                     notification_id,
                     Notification::new("Zed failed to launch")
-                        .body(Some(format!("{e:?}").as_str()))
+                        .body(Some(format!("{:?}", e).as_str()))
                         .priority(Priority::High)
                         .icon(ashpd::desktop::Icon::with_names(&[
                             "dialog-question-symbolic",
@@ -219,7 +219,7 @@ fn init_ui(app_state: Arc<AppState>, cx: &mut AppContext) -> Result<()> {
 
     inline_completion_registry::init(app_state.client.telemetry().clone(), cx);
 
-    assistant::init(app_state.fs.clone(), app_state.client.clone(), cx);
+    assistant::init(app_state.client.clone(), cx);
 
     repl::init(app_state.fs.clone(), cx);
 
@@ -751,7 +751,7 @@ fn init_stdout_logger() {
             )?;
             write!(buf, "{:<5}", buf.default_styled_level(record.level()))?;
             if let Some(path) = record.module_path() {
-                write!(buf, " {path}")?;
+                write!(buf, " {}", path)?;
             }
             write!(buf, "{}", subtle.value("]"))?;
             writeln!(buf, " {}", record.args())

crates/zed/src/reliability.rs

@@ -113,14 +113,14 @@ pub fn init_panic_hook(
         if !is_pty {
             if let Some(panic_data_json) = serde_json::to_string(&panic_data).log_err() {
                 let timestamp = chrono::Utc::now().format("%Y_%m_%d %H_%M_%S").to_string();
-                let panic_file_path = paths::logs_dir().join(format!("zed-{timestamp}.panic"));
+                let panic_file_path = paths::logs_dir().join(format!("zed-{}.panic", timestamp));
                 let panic_file = std::fs::OpenOptions::new()
                     .append(true)
                     .create(true)
                     .open(&panic_file_path)
                     .log_err();
                 if let Some(mut panic_file) = panic_file {
-                    writeln!(&mut panic_file, "{panic_data_json}").log_err();
+                    writeln!(&mut panic_file, "{}", panic_data_json).log_err();
                     panic_file.flush().log_err();
                 }
             }
@@ -494,7 +494,7 @@ async fn upload_previous_crashes(
 
             if let Some((panicked_on, payload)) = most_recent_panic.as_ref() {
                 request = request
-                    .header("x-zed-panicked-on", format!("{panicked_on}"))
+                    .header("x-zed-panicked-on", format!("{}", panicked_on))
                     .header("x-zed-panic", payload)
             }
             if let Some(installation_id) = installation_id.as_ref() {

crates/zed/src/zed.rs

@@ -105,10 +105,6 @@ pub fn build_window_options(display_uuid: Option<Uuid>, cx: &mut AppContext) ->
         display_id: display.map(|display| display.id()),
         window_background: cx.theme().window_background_appearance(),
         app_id: Some(app_id.to_owned()),
-        window_min_size: gpui::Size {
-            width: px(360.0),
-            height: px(240.0),
-        },
     }
 }
 
@@ -3181,7 +3177,7 @@ mod tests {
             project_panel::init((), cx);
             outline_panel::init((), cx);
             terminal_view::init(cx);
-            assistant::init(app_state.fs.clone(), app_state.client.clone(), cx);
+            assistant::init(app_state.client.clone(), cx);
             tasks_ui::init(cx);
             initialize_workspace(app_state.clone(), cx);
             app_state

crates/zed/src/zed/open_listener.rs

@@ -247,7 +247,7 @@ pub async fn handle_cli_connection(
                         Err(error) => {
                             responses
                                 .send(CliResponse::Stderr {
-                                    message: format!("{error}"),
+                                    message: format!("{}", error),
                                 })
                                 .log_err();
                             responses.send(CliResponse::Exit { status: 1 }).log_err();
@@ -263,7 +263,7 @@ pub async fn handle_cli_connection(
                 {
                     responses
                         .send(CliResponse::Stderr {
-                            message: format!("{e}"),
+                            message: format!("{}", e),
                         })
                         .log_err();
                     responses.send(CliResponse::Exit { status: 1 }).log_err();
@@ -342,7 +342,10 @@ pub async fn handle_cli_connection(
                                     Some(Err(err)) => {
                                         responses
                                             .send(CliResponse::Stderr {
-                                                message: format!("error opening {path:?}: {err}"),
+                                                message: format!(
+                                                    "error opening {:?}: {}",
+                                                    path, err
+                                                ),
                                             })
                                             .log_err();
                                         errored = true;
@@ -389,7 +392,7 @@ pub async fn handle_cli_connection(
                             errored = true;
                             responses
                                 .send(CliResponse::Stderr {
-                                    message: format!("error opening {paths:?}: {error}"),
+                                    message: format!("error opening {:?}: {}", paths, error),
                                 })
                                 .log_err();
                         }

docs/src/configuring-zed.md

@@ -2,7 +2,7 @@
 
 ## Folder-specific settings
 
-Folder-specific settings are used to override Zed's global settings for files within a specific directory in the project panel. To get started, create a `.zed` subdirectory and add a `settings.json` within it. It should be noted that folder-specific settings don't need to live only at a project's root, but can be defined at multiple levels in the project hierarchy. In setups like this, Zed will find the configuration nearest to the file you are working in and apply those settings to it. In most cases, this level of flexibility won't be needed and a single configuration for all files in a project is all that is required; the `Zed > Settings > Open Local Settings` menu action is built for this case. Running this action will look for a `.zed/settings.json` file at the root of the first top-level directory in your project panel. If it does not exist, it will create it.
+Folder-specific settings are used to override Zed's global settings for files within a specific directory in the project panel. To get started, create a `.zed` subdirectory and add a `settings.json` within it. It should be noted that folder-specific settings don't need to live only a project's root, but can be defined at multiple levels in the project hierarchy. In setups like this, Zed will find the configuration nearest to the file you are working in and apply those settings to it. In most cases, this level of flexibility won't be needed and a single configuration for all files in a project is all that is required; the `Zed > Settings > Open Local Settings` menu action is built for this case. Running this action will look for a `.zed/settings.json` file at the root of the first top-level directory in your project panel. If it does not exist, it will create it.
 
 The following global settings can be overridden with a folder-specific configuration:
 
@@ -46,7 +46,7 @@ Here are all the currently available settings.
 
 **Options**
 
-1. To disable autosave, set it to `off`:
+1. To disable autosave, set it to `off`
 
 ```json
 {
@@ -110,9 +110,9 @@ The name of any font family installed on the user's system
 
 **Options**
 
-Zed supports all OpenType features that can be enabled or disabled for a given buffer or terminal font, as well as setting values for font features.
+Zed supports all OpenType features that can be enabled, disabled or set a value to a font feature for a given buffer or terminal font.
 
-For example, to disable ligatures and set `cv01` to `7` for a given font you can add the following to your settings:
+For example, to disable ligatures and set `7` to `cv01` for a given font you can add the following to your settings:
 
 ```json
 {
@@ -201,19 +201,19 @@ List of `string` values
 "current_line_highlight": "none"
 ```
 
-2. Highlight the gutter area:
+2. Highlight the gutter area.
 
 ```json
 "current_line_highlight": "gutter"
 ```
 
-3. Highlight the editor area:
+3. Highlight the editor area.
 
 ```json
 "current_line_highlight": "line"
 ```
 
-4. Highlight the full line:
+4. Highlight the full line.
 
 ```json
 "current_line_highlight": "all"