Add slash commands for adding context into the assistant (#12102)

Tasks

* [x] remove old flaps and output when editing a slash command
* [x] the completing a command name that takes args, insert a space to
prepare for typing an arg
* [x] always trigger completions when  typing in a slash command
* [x] don't show line numbers
* [x] implement `prompt` command
* [x] `current-file` command
* [x] state gets corrupted on `duplicate line up` on a slash command
* [x] exclude slash command source from completion request

Next steps:
* show output token count in flap trailer
* add `/project` command that matches project ambient context
* delete ambient context

Release Notes:

- N/A

---------

Co-authored-by: Marshall <marshall@zed.dev>
Co-authored-by: Antonio Scandurra <me@as-cii.com>

crates/assistant/Cargo.toml

@@ -21,6 +21,7 @@ editor.workspace = true
 file_icons.workspace = true
 fs.workspace = true
 futures.workspace = true
+fuzzy.workspace = true
 gpui.workspace = true
 http.workspace = true
 indoc.workspace = true

crates/assistant/src/ambient_context/current_project.rs

@@ -34,10 +34,12 @@ impl Default for CurrentProjectContext {
 impl CurrentProjectContext {
     /// Returns the [`CurrentProjectContext`] as a message to the language model.
     pub fn to_message(&self) -> Option<LanguageModelRequestMessage> {
-        self.enabled.then(|| LanguageModelRequestMessage {
-            role: Role::System,
-            content: self.message.clone(),
-        })
+        self.enabled
+            .then(|| LanguageModelRequestMessage {
+                role: Role::System,
+                content: self.message.clone(),
+            })
+            .filter(|message| !message.content.is_empty())
     }
 
     /// Updates the [`CurrentProjectContext`] for the given [`Project`].

crates/assistant/src/ambient_context/recent_buffers.rs

@@ -87,10 +87,12 @@ impl RecentBuffersContext {
 
     /// Returns the [`RecentBuffersContext`] as a message to the language model.
     pub fn to_message(&self) -> Option<LanguageModelRequestMessage> {
-        self.enabled.then(|| LanguageModelRequestMessage {
-            role: Role::System,
-            content: self.snapshot.message.to_string(),
-        })
+        self.enabled
+            .then(|| LanguageModelRequestMessage {
+                role: Role::System,
+                content: self.snapshot.message.to_string(),
+            })
+            .filter(|message| !message.content.is_empty())
     }
 }
 

crates/assistant/src/assistant.rs

@@ -7,6 +7,7 @@ mod prompt_library;
 mod prompts;
 mod saved_conversation;
 mod search;
+mod slash_command;
 mod streaming_diff;
 
 use ambient_context::AmbientContextSnapshot;
@@ -16,6 +17,7 @@ use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
 pub(crate) use completion_provider::*;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
+pub(crate) use prompt_library::*;
 pub(crate) use saved_conversation::*;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore};

crates/assistant/src/completion_provider.rs

@@ -233,7 +233,7 @@ impl CompletionProvider {
             CompletionProvider::Anthropic(provider) => provider.count_tokens(request, cx),
             CompletionProvider::ZedDotDev(provider) => provider.count_tokens(request, cx),
             #[cfg(test)]
-            CompletionProvider::Fake(_) => unimplemented!(),
+            CompletionProvider::Fake(_) => futures::FutureExt::boxed(futures::future::ready(Ok(0))),
         }
     }
 

crates/assistant/src/prompt_library.rs

@@ -156,10 +156,10 @@ impl PromptLibrary {
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct UserPrompt {
     version: String,
-    title: String,
+    pub title: String,
     author: String,
     languages: Vec<String>,
-    prompt: String,
+    pub prompt: String,
 }
 
 impl UserPrompt {

crates/assistant/src/slash_command.rs

@@ -0,0 +1,319 @@
+use anyhow::Result;
+use collections::HashMap;
+use editor::{CompletionProvider, Editor};
+use futures::channel::oneshot;
+use fuzzy::{match_strings, StringMatchCandidate};
+use gpui::{AppContext, Model, Task, ViewContext, WindowHandle};
+use language::{Anchor, Buffer, CodeLabel, Documentation, LanguageServerId, ToPoint};
+use parking_lot::{Mutex, RwLock};
+use project::Project;
+use rope::Point;
+use std::{
+    ops::Range,
+    sync::{
+        atomic::{AtomicBool, Ordering::SeqCst},
+        Arc,
+    },
+};
+use workspace::Workspace;
+
+use crate::PromptLibrary;
+
+mod current_file_command;
+mod file_command;
+mod prompt_command;
+
+pub(crate) struct SlashCommandCompletionProvider {
+    commands: Arc<SlashCommandRegistry>,
+    cancel_flag: Mutex<Arc<AtomicBool>>,
+}
+
+#[derive(Default)]
+pub(crate) struct SlashCommandRegistry {
+    commands: HashMap<String, Box<dyn SlashCommand>>,
+}
+
+pub(crate) trait SlashCommand: 'static + Send + Sync {
+    fn name(&self) -> String;
+    fn description(&self) -> String;
+    fn complete_argument(
+        &self,
+        query: String,
+        cancel: Arc<AtomicBool>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>>;
+    fn requires_argument(&self) -> bool;
+    fn run(&self, argument: Option<&str>, cx: &mut AppContext) -> SlashCommandInvocation;
+}
+
+pub(crate) struct SlashCommandInvocation {
+    pub output: Task<Result<String>>,
+    pub invalidated: oneshot::Receiver<()>,
+    pub cleanup: SlashCommandCleanup,
+}
+
+#[derive(Default)]
+pub(crate) struct SlashCommandCleanup(Option<Box<dyn FnOnce()>>);
+
+impl SlashCommandCleanup {
+    pub fn new(cleanup: impl FnOnce() + 'static) -> Self {
+        Self(Some(Box::new(cleanup)))
+    }
+}
+
+impl Drop for SlashCommandCleanup {
+    fn drop(&mut self) {
+        if let Some(cleanup) = self.0.take() {
+            cleanup();
+        }
+    }
+}
+
+pub(crate) struct SlashCommandLine {
+    /// The range within the line containing the command name.
+    pub name: Range<usize>,
+    /// The range within the line containing the command argument.
+    pub argument: Option<Range<usize>>,
+}
+
+impl SlashCommandRegistry {
+    pub fn new(
+        project: Model<Project>,
+        prompt_library: Arc<PromptLibrary>,
+        window: Option<WindowHandle<Workspace>>,
+    ) -> Arc<Self> {
+        let mut this = Self {
+            commands: HashMap::default(),
+        };
+
+        this.register_command(file_command::FileSlashCommand::new(project));
+        this.register_command(prompt_command::PromptSlashCommand::new(prompt_library));
+        if let Some(window) = window {
+            this.register_command(current_file_command::CurrentFileSlashCommand::new(window));
+        }
+
+        Arc::new(this)
+    }
+
+    fn register_command(&mut self, command: impl SlashCommand) {
+        self.commands.insert(command.name(), Box::new(command));
+    }
+
+    fn command_names(&self) -> impl Iterator<Item = &String> {
+        self.commands.keys()
+    }
+
+    pub(crate) fn command(&self, name: &str) -> Option<&dyn SlashCommand> {
+        self.commands.get(name).map(|b| &**b)
+    }
+}
+
+impl SlashCommandCompletionProvider {
+    pub fn new(commands: Arc<SlashCommandRegistry>) -> Self {
+        Self {
+            cancel_flag: Mutex::new(Arc::new(AtomicBool::new(false))),
+            commands,
+        }
+    }
+
+    fn complete_command_name(
+        &self,
+        command_name: &str,
+        range: Range<Anchor>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<project::Completion>>> {
+        let candidates = self
+            .commands
+            .command_names()
+            .enumerate()
+            .map(|(ix, def)| StringMatchCandidate {
+                id: ix,
+                string: def.clone(),
+                char_bag: def.as_str().into(),
+            })
+            .collect::<Vec<_>>();
+        let commands = self.commands.clone();
+        let command_name = command_name.to_string();
+        let executor = cx.background_executor().clone();
+        executor.clone().spawn(async move {
+            let matches = match_strings(
+                &candidates,
+                &command_name,
+                true,
+                usize::MAX,
+                &Default::default(),
+                executor,
+            )
+            .await;
+
+            Ok(matches
+                .into_iter()
+                .filter_map(|mat| {
+                    let command = commands.command(&mat.string)?;
+                    let mut new_text = mat.string.clone();
+                    if command.requires_argument() {
+                        new_text.push(' ');
+                    }
+
+                    Some(project::Completion {
+                        old_range: range.clone(),
+                        documentation: Some(Documentation::SingleLine(command.description())),
+                        new_text,
+                        label: CodeLabel::plain(mat.string, None),
+                        server_id: LanguageServerId(0),
+                        lsp_completion: Default::default(),
+                    })
+                })
+                .collect())
+        })
+    }
+
+    fn complete_command_argument(
+        &self,
+        command_name: &str,
+        argument: String,
+        range: Range<Anchor>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<project::Completion>>> {
+        let new_cancel_flag = Arc::new(AtomicBool::new(false));
+        let mut flag = self.cancel_flag.lock();
+        flag.store(true, SeqCst);
+        *flag = new_cancel_flag.clone();
+
+        if let Some(command) = self.commands.command(command_name) {
+            let completions = command.complete_argument(argument, new_cancel_flag.clone(), cx);
+            cx.background_executor().spawn(async move {
+                Ok(completions
+                    .await?
+                    .into_iter()
+                    .map(|arg| project::Completion {
+                        old_range: range.clone(),
+                        label: CodeLabel::plain(arg.clone(), None),
+                        new_text: arg.clone(),
+                        documentation: None,
+                        server_id: LanguageServerId(0),
+                        lsp_completion: Default::default(),
+                    })
+                    .collect())
+            })
+        } else {
+            cx.background_executor()
+                .spawn(async move { Ok(Vec::new()) })
+        }
+    }
+}
+
+impl CompletionProvider for SlashCommandCompletionProvider {
+    fn completions(
+        &self,
+        buffer: &Model<Buffer>,
+        buffer_position: Anchor,
+        cx: &mut ViewContext<Editor>,
+    ) -> Task<Result<Vec<project::Completion>>> {
+        let task = buffer.update(cx, |buffer, cx| {
+            let position = buffer_position.to_point(buffer);
+            let line_start = Point::new(position.row, 0);
+            let mut lines = buffer.text_for_range(line_start..position).lines();
+            let line = lines.next()?;
+            let call = SlashCommandLine::parse(line)?;
+
+            let name = &line[call.name.clone()];
+            if let Some(argument) = call.argument {
+                let start = buffer.anchor_after(Point::new(position.row, argument.start as u32));
+                let argument = line[argument.clone()].to_string();
+                Some(self.complete_command_argument(name, argument, start..buffer_position, cx))
+            } else {
+                let start = buffer.anchor_after(Point::new(position.row, call.name.start as u32));
+                Some(self.complete_command_name(name, start..buffer_position, cx))
+            }
+        });
+
+        task.unwrap_or_else(|| Task::ready(Ok(Vec::new())))
+    }
+
+    fn resolve_completions(
+        &self,
+        _: Model<Buffer>,
+        _: Vec<usize>,
+        _: Arc<RwLock<Box<[project::Completion]>>>,
+        _: &mut ViewContext<Editor>,
+    ) -> Task<Result<bool>> {
+        Task::ready(Ok(true))
+    }
+
+    fn apply_additional_edits_for_completion(
+        &self,
+        _: Model<Buffer>,
+        _: project::Completion,
+        _: bool,
+        _: &mut ViewContext<Editor>,
+    ) -> Task<Result<Option<language::Transaction>>> {
+        Task::ready(Ok(None))
+    }
+
+    fn is_completion_trigger(
+        &self,
+        buffer: &Model<Buffer>,
+        position: language::Anchor,
+        _text: &str,
+        _trigger_in_words: bool,
+        cx: &mut ViewContext<Editor>,
+    ) -> bool {
+        let buffer = buffer.read(cx);
+        let position = position.to_point(buffer);
+        let line_start = Point::new(position.row, 0);
+        let mut lines = buffer.text_for_range(line_start..position).lines();
+        if let Some(line) = lines.next() {
+            SlashCommandLine::parse(line).is_some()
+        } else {
+            false
+        }
+    }
+}
+
+impl SlashCommandLine {
+    pub(crate) fn parse(line: &str) -> Option<Self> {
+        let mut call: Option<Self> = None;
+        let mut ix = 0;
+        for c in line.chars() {
+            let next_ix = ix + c.len_utf8();
+            if let Some(call) = &mut call {
+                // The command arguments start at the first non-whitespace character
+                // after the command name, and continue until the end of the line.
+                if let Some(argument) = &mut call.argument {
+                    if (*argument).is_empty() && c.is_whitespace() {
+                        argument.start = next_ix;
+                    }
+                    argument.end = next_ix;
+                }
+                // The command name ends at the first whitespace character.
+                else if !call.name.is_empty() {
+                    if c.is_whitespace() {
+                        call.argument = Some(next_ix..next_ix);
+                    } else {
+                        call.name.end = next_ix;
+                    }
+                }
+                // The command name must begin with a letter.
+                else if c.is_alphabetic() {
+                    call.name.end = next_ix;
+                } else {
+                    return None;
+                }
+            }
+            // Commands start with a slash.
+            else if c == '/' {
+                call = Some(SlashCommandLine {
+                    name: next_ix..next_ix,
+                    argument: None,
+                });
+            }
+            // The line can't contain anything before the slash except for whitespace.
+            else if !c.is_whitespace() {
+                return None;
+            }
+            ix = next_ix;
+        }
+        call
+    }
+}

crates/assistant/src/slash_command/current_file_command.rs

@@ -0,0 +1,135 @@
+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 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, _argument: Option<&str>, 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

@@ -0,0 +1,145 @@
+use super::{SlashCommand, SlashCommandCleanup, SlashCommandInvocation};
+use anyhow::Result;
+use futures::channel::oneshot;
+use fuzzy::PathMatch;
+use gpui::{AppContext, Model, Task};
+use project::{PathMatchCandidateSet, Project};
+use std::{
+    path::Path,
+    sync::{atomic::AtomicBool, Arc},
+};
+
+pub(crate) struct FileSlashCommand {
+    project: Model<Project>,
+}
+
+impl FileSlashCommand {
+    pub fn new(project: Model<Project>) -> Self {
+        Self { project }
+    }
+
+    fn search_paths(
+        &self,
+        query: String,
+        cancellation_flag: Arc<AtomicBool>,
+        cx: &mut AppContext,
+    ) -> Task<Vec<PathMatch>> {
+        let worktrees = self
+            .project
+            .read(cx)
+            .visible_worktrees(cx)
+            .collect::<Vec<_>>();
+        let include_root_name = worktrees.len() > 1;
+        let candidate_sets = worktrees
+            .into_iter()
+            .map(|worktree| {
+                let worktree = worktree.read(cx);
+                PathMatchCandidateSet {
+                    snapshot: worktree.snapshot(),
+                    include_ignored: worktree
+                        .root_entry()
+                        .map_or(false, |entry| entry.is_ignored),
+                    include_root_name,
+                    directories_only: false,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let executor = cx.background_executor().clone();
+        cx.foreground_executor().spawn(async move {
+            fuzzy::match_path_sets(
+                candidate_sets.as_slice(),
+                query.as_str(),
+                None,
+                false,
+                100,
+                &cancellation_flag,
+                executor,
+            )
+            .await
+        })
+    }
+}
+
+impl SlashCommand for FileSlashCommand {
+    fn name(&self) -> String {
+        "file".into()
+    }
+
+    fn description(&self) -> String {
+        "insert an entire file".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        &self,
+        query: String,
+        cancellation_flag: Arc<AtomicBool>,
+        cx: &mut AppContext,
+    ) -> gpui::Task<Result<Vec<String>>> {
+        let paths = self.search_paths(query, cancellation_flag, cx);
+        cx.background_executor().spawn(async move {
+            Ok(paths
+                .await
+                .into_iter()
+                .map(|path_match| {
+                    format!(
+                        "{}{}",
+                        path_match.path_prefix,
+                        path_match.path.to_string_lossy()
+                    )
+                })
+                .collect())
+        })
+    }
+
+    fn run(&self, argument: Option<&str>, cx: &mut AppContext) -> SlashCommandInvocation {
+        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(),
+            };
+        };
+
+        let path = Path::new(argument);
+        let abs_path = project.worktrees().find_map(|worktree| {
+            let worktree = worktree.read(cx);
+            worktree.entry_for_path(path)?;
+            worktree.absolutize(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(),
+            };
+        };
+
+        let fs = project.fs().clone();
+        let argument = argument.to_string();
+        let output = 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("```");
+            output.push_str(&argument);
+            output.push('\n');
+            output.push_str(&content);
+            if !output.ends_with('\n') {
+                output.push('\n');
+            }
+            output.push_str("```");
+            Ok(output)
+        });
+        SlashCommandInvocation {
+            output,
+            invalidated: oneshot::channel().1,
+            cleanup: SlashCommandCleanup::default(),
+        }
+    }
+}

crates/assistant/src/slash_command/prompt_command.rs

@@ -0,0 +1,88 @@
+use super::{SlashCommand, SlashCommandCleanup, SlashCommandInvocation};
+use crate::PromptLibrary;
+use anyhow::{anyhow, Context, Result};
+use futures::channel::oneshot;
+use fuzzy::StringMatchCandidate;
+use gpui::{AppContext, Task};
+use std::sync::{atomic::AtomicBool, Arc};
+
+pub(crate) struct PromptSlashCommand {
+    library: Arc<PromptLibrary>,
+}
+
+impl PromptSlashCommand {
+    pub fn new(library: Arc<PromptLibrary>) -> Self {
+        Self { library }
+    }
+}
+
+impl SlashCommand for PromptSlashCommand {
+    fn name(&self) -> String {
+        "prompt".into()
+    }
+
+    fn description(&self) -> String {
+        "insert a prompt from the library".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        &self,
+        query: String,
+        cancellation_flag: Arc<AtomicBool>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>> {
+        let library = self.library.clone();
+        let executor = cx.background_executor().clone();
+        cx.background_executor().spawn(async move {
+            let candidates = library
+                .prompts()
+                .into_iter()
+                .enumerate()
+                .map(|(ix, prompt)| StringMatchCandidate::new(ix, prompt.title))
+                .collect::<Vec<_>>();
+            let matches = fuzzy::match_strings(
+                &candidates,
+                &query,
+                false,
+                100,
+                &cancellation_flag,
+                executor,
+            )
+            .await;
+            Ok(matches
+                .into_iter()
+                .map(|mat| candidates[mat.candidate_id].string.clone())
+                .collect())
+        })
+    }
+
+    fn run(&self, title: Option<&str>, cx: &mut AppContext) -> SlashCommandInvocation {
+        let Some(title) = title else {
+            return SlashCommandInvocation {
+                output: Task::ready(Err(anyhow!("missing prompt name"))),
+                invalidated: oneshot::channel().1,
+                cleanup: SlashCommandCleanup::default(),
+            };
+        };
+
+        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.title == title)
+                .with_context(|| format!("no prompt found with title {:?}", title))?;
+            Ok(prompt.prompt)
+        });
+        SlashCommandInvocation {
+            output,
+            invalidated: oneshot::channel().1,
+            cleanup: SlashCommandCleanup::default(),
+        }
+    }
+}