Rework context insertion UX (#12360)

- Confirming a completion now runs the command immediately
- Hitting `enter` on a line with a command now runs it
- The output of commands gets folded away and replaced with a custom
placeholder
- Eliminated ambient context

<img width="1588" alt="image"
src="https://github.com/zed-industries/zed/assets/482957/b1927a45-52d6-4634-acc9-2ee539c1d89a">

Release Notes:

- N/A

---------

Co-authored-by: Nathan Sobo <nathan@zed.dev>

crates/assistant/src/slash_command/active_command.rs

@@ -0,0 +1,117 @@
+use super::{file_command::FilePlaceholder, SlashCommand, SlashCommandOutput};
+use anyhow::{anyhow, Result};
+use collections::HashMap;
+use editor::Editor;
+use gpui::{AppContext, Entity, Task, WeakView};
+use language::LspAdapterDelegate;
+use std::{borrow::Cow, sync::Arc};
+use ui::{IntoElement, WindowContext};
+use workspace::Workspace;
+
+pub(crate) struct ActiveSlashCommand;
+
+impl SlashCommand for ActiveSlashCommand {
+    fn name(&self) -> String {
+        "active".into()
+    }
+
+    fn description(&self) -> String {
+        "insert active tab".into()
+    }
+
+    fn tooltip_text(&self) -> String {
+        "insert active tab".into()
+    }
+
+    fn complete_argument(
+        &self,
+        _query: String,
+        _cancel: std::sync::Arc<std::sync::atomic::AtomicBool>,
+        _cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>> {
+        Task::ready(Err(anyhow!("this command does not require argument")))
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _argument: Option<&str>,
+        workspace: WeakView<Workspace>,
+        _delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let output = workspace.update(cx, |workspace, cx| {
+            let mut timestamps_by_entity_id = HashMap::default();
+            for pane in workspace.panes() {
+                let pane = pane.read(cx);
+                for entry in pane.activation_history() {
+                    timestamps_by_entity_id.insert(entry.entity_id, entry.timestamp);
+                }
+            }
+
+            let mut most_recent_buffer = None;
+            for editor in workspace.items_of_type::<Editor>(cx) {
+                let Some(buffer) = editor.read(cx).buffer().read(cx).as_singleton() else {
+                    continue;
+                };
+
+                let timestamp = timestamps_by_entity_id
+                    .get(&editor.entity_id())
+                    .copied()
+                    .unwrap_or_default();
+                if most_recent_buffer
+                    .as_ref()
+                    .map_or(true, |(_, prev_timestamp)| timestamp > *prev_timestamp)
+                {
+                    most_recent_buffer = Some((buffer, timestamp));
+                }
+            }
+
+            if let Some((buffer, _)) = most_recent_buffer {
+                let snapshot = buffer.read(cx).snapshot();
+                let path = snapshot.resolve_file_path(cx, true);
+                let text = cx.background_executor().spawn({
+                    let path = path.clone();
+                    async move {
+                        let path = path
+                            .as_ref()
+                            .map(|path| path.to_string_lossy())
+                            .unwrap_or_else(|| Cow::Borrowed("untitled"));
+
+                        let mut output = String::with_capacity(path.len() + snapshot.len() + 9);
+                        output.push_str("```");
+                        output.push_str(&path);
+                        output.push('\n');
+                        for chunk in snapshot.as_rope().chunks() {
+                            output.push_str(chunk);
+                        }
+                        if !output.ends_with('\n') {
+                            output.push('\n');
+                        }
+                        output.push_str("```");
+                        output
+                    }
+                });
+                cx.foreground_executor().spawn(async move {
+                    Ok(SlashCommandOutput {
+                        text: text.await,
+                        render_placeholder: Arc::new(move |id, unfold, _| {
+                            FilePlaceholder {
+                                id,
+                                path: path.clone(),
+                                unfold,
+                            }
+                            .into_any_element()
+                        }),
+                    })
+                })
+            } else {
+                Task::ready(Err(anyhow!("no recent buffer found")))
+            }
+        });
+        output.unwrap_or_else(|error| Task::ready(Err(error)))
+    }
+}

crates/assistant/src/slash_command/current_file_command.rs

@@ -1,142 +0,0 @@
-use std::sync::Arc;
-use std::{borrow::Cow, cell::Cell, rc::Rc};
-
-use anyhow::{anyhow, Result};
-use collections::HashMap;
-use editor::Editor;
-use futures::channel::oneshot;
-use gpui::{AppContext, Entity, Subscription, Task, WindowHandle};
-use language::LspAdapterDelegate;
-use workspace::{Event as WorkspaceEvent, Workspace};
-
-use super::{SlashCommand, SlashCommandCleanup, SlashCommandInvocation};
-
-pub(crate) struct CurrentFileSlashCommand {
-    workspace: WindowHandle<Workspace>,
-}
-
-impl CurrentFileSlashCommand {
-    pub fn new(workspace: WindowHandle<Workspace>) -> Self {
-        Self { workspace }
-    }
-}
-
-impl SlashCommand for CurrentFileSlashCommand {
-    fn name(&self) -> String {
-        "current_file".into()
-    }
-
-    fn description(&self) -> String {
-        "insert the current file".into()
-    }
-
-    fn complete_argument(
-        &self,
-        _query: String,
-        _cancel: std::sync::Arc<std::sync::atomic::AtomicBool>,
-        _cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
-        Task::ready(Err(anyhow!("this command does not require argument")))
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
-    }
-
-    fn run(
-        self: Arc<Self>,
-        _argument: Option<&str>,
-        _delegate: Arc<dyn LspAdapterDelegate>,
-        cx: &mut AppContext,
-    ) -> SlashCommandInvocation {
-        let (invalidate_tx, invalidate_rx) = oneshot::channel();
-        let invalidate_tx = Rc::new(Cell::new(Some(invalidate_tx)));
-        let mut subscriptions: Vec<Subscription> = Vec::new();
-        let output = self.workspace.update(cx, |workspace, cx| {
-            let mut timestamps_by_entity_id = HashMap::default();
-            for pane in workspace.panes() {
-                let pane = pane.read(cx);
-                for entry in pane.activation_history() {
-                    timestamps_by_entity_id.insert(entry.entity_id, entry.timestamp);
-                }
-            }
-
-            let mut most_recent_buffer = None;
-            for editor in workspace.items_of_type::<Editor>(cx) {
-                let Some(buffer) = editor.read(cx).buffer().read(cx).as_singleton() else {
-                    continue;
-                };
-
-                let timestamp = timestamps_by_entity_id
-                    .get(&editor.entity_id())
-                    .copied()
-                    .unwrap_or_default();
-                if most_recent_buffer
-                    .as_ref()
-                    .map_or(true, |(_, prev_timestamp)| timestamp > *prev_timestamp)
-                {
-                    most_recent_buffer = Some((buffer, timestamp));
-                }
-            }
-
-            subscriptions.push({
-                let workspace_view = cx.view().clone();
-                let invalidate_tx = invalidate_tx.clone();
-                cx.window_context()
-                    .subscribe(&workspace_view, move |_workspace, event, _cx| match event {
-                        WorkspaceEvent::ActiveItemChanged
-                        | WorkspaceEvent::ItemAdded
-                        | WorkspaceEvent::ItemRemoved
-                        | WorkspaceEvent::PaneAdded(_)
-                        | WorkspaceEvent::PaneRemoved => {
-                            if let Some(invalidate_tx) = invalidate_tx.take() {
-                                _ = invalidate_tx.send(());
-                            }
-                        }
-                        _ => {}
-                    })
-            });
-
-            if let Some((buffer, _)) = most_recent_buffer {
-                subscriptions.push({
-                    let invalidate_tx = invalidate_tx.clone();
-                    cx.window_context().observe(&buffer, move |_buffer, _cx| {
-                        if let Some(invalidate_tx) = invalidate_tx.take() {
-                            _ = invalidate_tx.send(());
-                        }
-                    })
-                });
-
-                let snapshot = buffer.read(cx).snapshot();
-                let path = snapshot.resolve_file_path(cx, true);
-                cx.background_executor().spawn(async move {
-                    let path = path
-                        .as_ref()
-                        .map(|path| path.to_string_lossy())
-                        .unwrap_or_else(|| Cow::Borrowed("untitled"));
-
-                    let mut output = String::with_capacity(path.len() + snapshot.len() + 9);
-                    output.push_str("```");
-                    output.push_str(&path);
-                    output.push('\n');
-                    for chunk in snapshot.as_rope().chunks() {
-                        output.push_str(chunk);
-                    }
-                    if !output.ends_with('\n') {
-                        output.push('\n');
-                    }
-                    output.push_str("```");
-                    Ok(output)
-                })
-            } else {
-                Task::ready(Err(anyhow!("no recent buffer found")))
-            }
-        });
-
-        SlashCommandInvocation {
-            output: output.unwrap_or_else(|error| Task::ready(Err(error))),
-            invalidated: invalidate_rx,
-            cleanup: SlashCommandCleanup::new(move || drop(subscriptions)),
-        }
-    }
-}

crates/assistant/src/slash_command/file_command.rs

@@ -1,14 +1,15 @@
-use super::{SlashCommand, SlashCommandCleanup, SlashCommandInvocation};
+use super::{SlashCommand, SlashCommandOutput};
 use anyhow::Result;
-use futures::channel::oneshot;
 use fuzzy::PathMatch;
-use gpui::{AppContext, Model, Task};
+use gpui::{AppContext, Model, RenderOnce, SharedString, Task, WeakView};
 use language::LspAdapterDelegate;
 use project::{PathMatchCandidateSet, Project};
 use std::{
-    path::Path,
+    path::{Path, PathBuf},
     sync::{atomic::AtomicBool, Arc},
 };
+use ui::{prelude::*, ButtonLike, ElevationIndex};
+use workspace::Workspace;
 
 pub(crate) struct FileSlashCommand {
     project: Model<Project>,
@@ -30,7 +31,6 @@ impl FileSlashCommand {
             .read(cx)
             .visible_worktrees(cx)
             .collect::<Vec<_>>();
-        let include_root_name = worktrees.len() > 1;
         let candidate_sets = worktrees
             .into_iter()
             .map(|worktree| {
@@ -40,7 +40,7 @@ impl FileSlashCommand {
                     include_ignored: worktree
                         .root_entry()
                         .map_or(false, |entry| entry.is_ignored),
-                    include_root_name,
+                    include_root_name: true,
                     directories_only: false,
                 }
             })
@@ -68,7 +68,11 @@ impl SlashCommand for FileSlashCommand {
     }
 
     fn description(&self) -> String {
-        "insert an entire file".into()
+        "insert a file".into()
+    }
+
+    fn tooltip_text(&self) -> String {
+        "insert file".into()
     }
 
     fn requires_argument(&self) -> bool {
@@ -100,36 +104,30 @@ impl SlashCommand for FileSlashCommand {
     fn run(
         self: Arc<Self>,
         argument: Option<&str>,
+        _workspace: WeakView<Workspace>,
         _delegate: Arc<dyn LspAdapterDelegate>,
-        cx: &mut AppContext,
-    ) -> SlashCommandInvocation {
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
         let project = self.project.read(cx);
         let Some(argument) = argument else {
-            return SlashCommandInvocation {
-                output: Task::ready(Err(anyhow::anyhow!("missing path"))),
-                invalidated: oneshot::channel().1,
-                cleanup: SlashCommandCleanup::default(),
-            };
+            return Task::ready(Err(anyhow::anyhow!("missing path")));
         };
 
-        let path = Path::new(argument);
+        let path = PathBuf::from(argument);
         let abs_path = project.worktrees().find_map(|worktree| {
             let worktree = worktree.read(cx);
-            worktree.entry_for_path(path)?;
-            worktree.absolutize(path).ok()
+            let worktree_root_path = Path::new(worktree.root_name());
+            let relative_path = path.strip_prefix(worktree_root_path).ok()?;
+            worktree.absolutize(&relative_path).ok()
         });
 
         let Some(abs_path) = abs_path else {
-            return SlashCommandInvocation {
-                output: Task::ready(Err(anyhow::anyhow!("missing path"))),
-                invalidated: oneshot::channel().1,
-                cleanup: SlashCommandCleanup::default(),
-            };
+            return Task::ready(Err(anyhow::anyhow!("missing path")));
         };
 
         let fs = project.fs().clone();
         let argument = argument.to_string();
-        let output = cx.background_executor().spawn(async move {
+        let text = cx.background_executor().spawn(async move {
             let content = fs.load(&abs_path).await?;
             let mut output = String::with_capacity(argument.len() + content.len() + 9);
             output.push_str("```");
@@ -140,12 +138,46 @@ impl SlashCommand for FileSlashCommand {
                 output.push('\n');
             }
             output.push_str("```");
-            Ok(output)
+            anyhow::Ok(output)
         });
-        SlashCommandInvocation {
-            output,
-            invalidated: oneshot::channel().1,
-            cleanup: SlashCommandCleanup::default(),
-        }
+        cx.foreground_executor().spawn(async move {
+            let text = text.await?;
+            Ok(SlashCommandOutput {
+                text,
+                render_placeholder: Arc::new(move |id, unfold, _cx| {
+                    FilePlaceholder {
+                        path: Some(path.clone()),
+                        id,
+                        unfold,
+                    }
+                    .into_any_element()
+                }),
+            })
+        })
+    }
+}
+
+#[derive(IntoElement)]
+pub struct FilePlaceholder {
+    pub path: Option<PathBuf>,
+    pub id: ElementId,
+    pub unfold: Arc<dyn Fn(&mut WindowContext)>,
+}
+
+impl RenderOnce for FilePlaceholder {
+    fn render(self, _cx: &mut WindowContext) -> impl IntoElement {
+        let unfold = self.unfold;
+        let title = if let Some(path) = self.path.as_ref() {
+            SharedString::from(path.to_string_lossy().to_string())
+        } else {
+            SharedString::from("untitled")
+        };
+
+        ButtonLike::new(self.id)
+            .style(ButtonStyle::Filled)
+            .layer(ElevationIndex::ElevatedSurface)
+            .child(Icon::new(IconName::File))
+            .child(Label::new(title))
+            .on_click(move |_, cx| unfold(cx))
     }
 }

crates/assistant/src/slash_command/project_command.rs

@@ -0,0 +1,151 @@
+use super::{SlashCommand, SlashCommandOutput};
+use anyhow::{anyhow, Context, Result};
+use fs::Fs;
+use gpui::{AppContext, Model, Task, WeakView};
+use language::LspAdapterDelegate;
+use project::{Project, ProjectPath};
+use std::{
+    fmt::Write,
+    path::Path,
+    sync::{atomic::AtomicBool, Arc},
+};
+use ui::{prelude::*, ButtonLike, ElevationIndex};
+use workspace::Workspace;
+
+pub(crate) struct ProjectSlashCommand;
+
+impl ProjectSlashCommand {
+    async fn build_message(fs: Arc<dyn Fs>, path_to_cargo_toml: &Path) -> Result<String> {
+        let buffer = fs.load(path_to_cargo_toml).await?;
+        let cargo_toml: cargo_toml::Manifest = toml::from_str(&buffer)?;
+
+        let mut message = String::new();
+        writeln!(message, "You are in a Rust project.")?;
+
+        if let Some(workspace) = cargo_toml.workspace {
+            writeln!(
+                message,
+                "The project is a Cargo workspace with the following members:"
+            )?;
+            for member in workspace.members {
+                writeln!(message, "- {member}")?;
+            }
+
+            if !workspace.default_members.is_empty() {
+                writeln!(message, "The default members are:")?;
+                for member in workspace.default_members {
+                    writeln!(message, "- {member}")?;
+                }
+            }
+
+            if !workspace.dependencies.is_empty() {
+                writeln!(
+                    message,
+                    "The following workspace dependencies are installed:"
+                )?;
+                for dependency in workspace.dependencies.keys() {
+                    writeln!(message, "- {dependency}")?;
+                }
+            }
+        } else if let Some(package) = cargo_toml.package {
+            writeln!(
+                message,
+                "The project name is \"{name}\".",
+                name = package.name
+            )?;
+
+            let description = package
+                .description
+                .as_ref()
+                .and_then(|description| description.get().ok().cloned());
+            if let Some(description) = description.as_ref() {
+                writeln!(message, "It describes itself as \"{description}\".")?;
+            }
+
+            if !cargo_toml.dependencies.is_empty() {
+                writeln!(message, "The following dependencies are installed:")?;
+                for dependency in cargo_toml.dependencies.keys() {
+                    writeln!(message, "- {dependency}")?;
+                }
+            }
+        }
+
+        Ok(message)
+    }
+
+    fn path_to_cargo_toml(project: Model<Project>, cx: &mut AppContext) -> Option<Arc<Path>> {
+        let worktree = project.read(cx).worktrees().next()?;
+        let worktree = worktree.read(cx);
+        let entry = worktree.entry_for_path("Cargo.toml")?;
+        let path = ProjectPath {
+            worktree_id: worktree.id(),
+            path: entry.path.clone(),
+        };
+        Some(Arc::from(
+            project.read(cx).absolute_path(&path, cx)?.as_path(),
+        ))
+    }
+}
+
+impl SlashCommand for ProjectSlashCommand {
+    fn name(&self) -> String {
+        "project".into()
+    }
+
+    fn description(&self) -> String {
+        "insert current project context".into()
+    }
+
+    fn tooltip_text(&self) -> String {
+        "insert current project context".into()
+    }
+
+    fn complete_argument(
+        &self,
+        _query: String,
+        _cancel: Arc<AtomicBool>,
+        _cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>> {
+        Task::ready(Err(anyhow!("this command does not require argument")))
+    }
+
+    fn requires_argument(&self) -> bool {
+        false
+    }
+
+    fn run(
+        self: Arc<Self>,
+        _argument: Option<&str>,
+        workspace: WeakView<Workspace>,
+        _delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let output = workspace.update(cx, |workspace, cx| {
+            let project = workspace.project().clone();
+            let fs = workspace.project().read(cx).fs().clone();
+            let path = Self::path_to_cargo_toml(project, cx);
+            let output = cx.background_executor().spawn(async move {
+                let path = path.with_context(|| "Cargo.toml not found")?;
+                Self::build_message(fs, &path).await
+            });
+
+            cx.foreground_executor().spawn(async move {
+                let text = output.await?;
+
+                Ok(SlashCommandOutput {
+                    text,
+                    render_placeholder: Arc::new(move |id, unfold, _cx| {
+                        ButtonLike::new(id)
+                            .style(ButtonStyle::Filled)
+                            .layer(ElevationIndex::ElevatedSurface)
+                            .child(Icon::new(IconName::FileTree))
+                            .child(Label::new("Project"))
+                            .on_click(move |_, cx| unfold(cx))
+                            .into_any_element()
+                    }),
+                })
+            })
+        });
+        output.unwrap_or_else(|error| Task::ready(Err(error)))
+    }
+}

crates/assistant/src/slash_command/prompt_command.rs

@@ -1,11 +1,12 @@
-use super::{SlashCommand, SlashCommandCleanup, SlashCommandInvocation};
+use super::{SlashCommand, SlashCommandOutput};
 use crate::prompts::PromptLibrary;
 use anyhow::{anyhow, Context, Result};
-use futures::channel::oneshot;
 use fuzzy::StringMatchCandidate;
-use gpui::{AppContext, Task};
+use gpui::{AppContext, Task, WeakView};
 use language::LspAdapterDelegate;
 use std::sync::{atomic::AtomicBool, Arc};
+use ui::{prelude::*, ButtonLike, ElevationIndex};
+use workspace::Workspace;
 
 pub(crate) struct PromptSlashCommand {
     library: Arc<PromptLibrary>,
@@ -26,6 +27,10 @@ impl SlashCommand for PromptSlashCommand {
         "insert a prompt from the library".into()
     }
 
+    fn tooltip_text(&self) -> String {
+        "insert prompt".into()
+    }
+
     fn requires_argument(&self) -> bool {
         true
     }
@@ -64,32 +69,43 @@ impl SlashCommand for PromptSlashCommand {
     fn run(
         self: Arc<Self>,
         title: Option<&str>,
+        _workspace: WeakView<Workspace>,
         _delegate: Arc<dyn LspAdapterDelegate>,
-        cx: &mut AppContext,
-    ) -> SlashCommandInvocation {
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
         let Some(title) = title else {
-            return SlashCommandInvocation {
-                output: Task::ready(Err(anyhow!("missing prompt name"))),
-                invalidated: oneshot::channel().1,
-                cleanup: SlashCommandCleanup::default(),
-            };
+            return Task::ready(Err(anyhow!("missing prompt name")));
         };
 
         let library = self.library.clone();
-        let title = title.to_string();
-        let output = cx.background_executor().spawn(async move {
-            let prompt = library
-                .prompts()
-                .into_iter()
-                .find(|prompt| &prompt.1.title().to_string() == &title)
-                .with_context(|| format!("no prompt found with title {:?}", title))?
-                .1;
-            Ok(prompt.body())
+        let title = SharedString::from(title.to_string());
+        let prompt = cx.background_executor().spawn({
+            let title = title.clone();
+            async move {
+                let prompt = library
+                    .prompts()
+                    .into_iter()
+                    .map(|prompt| (prompt.1.title(), prompt))
+                    .find(|(t, _)| t == &title)
+                    .with_context(|| format!("no prompt found with title {:?}", title))?
+                    .1;
+                anyhow::Ok(prompt.1.body())
+            }
         });
-        SlashCommandInvocation {
-            output,
-            invalidated: oneshot::channel().1,
-            cleanup: SlashCommandCleanup::default(),
-        }
+        cx.foreground_executor().spawn(async move {
+            let prompt = prompt.await?;
+            Ok(SlashCommandOutput {
+                text: prompt,
+                render_placeholder: Arc::new(move |id, unfold, _cx| {
+                    ButtonLike::new(id)
+                        .style(ButtonStyle::Filled)
+                        .layer(ElevationIndex::ElevatedSurface)
+                        .child(Icon::new(IconName::Library))
+                        .child(Label::new(title.clone()))
+                        .on_click(move |_, cx| unfold(cx))
+                        .into_any_element()
+                }),
+            })
+        })
     }
 }