assistant: Add /docs slash command (#13794)

This PR adds a new `/docs` slash command to the Assistant. This slash
command replaces `/rustdoc`.

The `/docs` slash command works with different providers. There is
currently a built-in provider for rustdoc, but new providers can be
defined within extensions. The Gleam extension contains an example of
this.

When you first type `/docs` a completion menu will be shown with the
list of available providers:


https://github.com/zed-industries/zed/assets/1486634/32287000-5855-44d9-a2eb-569596f5abd9

After completing the provider you want to use then you can type the
package name and/or item path to search for the relevant docs:


https://github.com/zed-industries/zed/assets/1486634/6fc55a63-7fcd-42ea-80ce-08c670bf03fc

There are still some rough edges around completions that I would like to
get cleaned up in a future PR. Both of these seem to stem from the fact
that we're using an intermediate completion in the slash command:

1. Accepting a provider completion will show an error until you press
<kbd>Space</kbd> to continue typing.
- We need a way of not submitting a slash command when a completion is
accepted.
2. We currently need to show the provider name in the documentation item
completion list.
- Without it, the provider name gets wiped out when accepting a
completion, causing the slash command to become invalid.

Release Notes:

- N/A

crates/assistant/src/assistant.rs

@@ -27,8 +27,9 @@ use semantic_index::{CloudEmbeddingProvider, SemanticIndex};
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore};
 use slash_command::{
-    active_command, default_command, diagnostics_command, fetch_command, file_command, now_command,
-    project_command, prompt_command, rustdoc_command, search_command, tabs_command, term_command,
+    active_command, default_command, diagnostics_command, docs_command, fetch_command,
+    file_command, now_command, project_command, prompt_command, search_command, tabs_command,
+    term_command,
 };
 use std::{
     fmt::{self, Display},
@@ -323,7 +324,7 @@ fn register_slash_commands(cx: &mut AppContext) {
     slash_command_registry.register_command(term_command::TermSlashCommand, true);
     slash_command_registry.register_command(now_command::NowSlashCommand, true);
     slash_command_registry.register_command(diagnostics_command::DiagnosticsCommand, true);
-    slash_command_registry.register_command(rustdoc_command::RustdocSlashCommand, false);
+    slash_command_registry.register_command(docs_command::DocsSlashCommand, true);
     slash_command_registry.register_command(fetch_command::FetchSlashCommand, false);
 }
 

crates/assistant/src/assistant_panel.rs

@@ -1,3 +1,4 @@
+use crate::slash_command::docs_command::{DocsSlashCommand, DocsSlashCommandArgs};
 use crate::{
     assistant_settings::{AssistantDockPosition, AssistantSettings},
     humanize_token_count,
@@ -39,7 +40,7 @@ use gpui::{
     Subscription, Task, Transformation, UpdateGlobal, View, ViewContext, VisualContext, WeakView,
     WindowContext,
 };
-use indexed_docs::{IndexedDocsStore, PackageName, ProviderId};
+use indexed_docs::IndexedDocsStore;
 use language::{
     language_settings::SoftWrap, AnchorRangeExt as _, AutoindentMode, Buffer, LanguageRegistry,
     LspAdapterDelegate, OffsetRangeExt as _, Point, ToOffset as _,
@@ -2695,8 +2696,8 @@ impl ContextEditor {
                                     // TODO: In the future we should investigate how we can expose
                                     // this as a hook on the `SlashCommand` trait so that we don't
                                     // need to special-case it here.
-                                    if command.name == "rustdoc" {
-                                        return render_rustdoc_slash_command_trailer(
+                                    if command.name == DocsSlashCommand::NAME {
+                                        return render_docs_slash_command_trailer(
                                             row,
                                             command.clone(),
                                             cx,
@@ -3405,25 +3406,29 @@ fn render_pending_slash_command_gutter_decoration(
     icon.into_any_element()
 }
 
-fn render_rustdoc_slash_command_trailer(
+fn render_docs_slash_command_trailer(
     row: MultiBufferRow,
     command: PendingSlashCommand,
     cx: &mut WindowContext,
 ) -> AnyElement {
-    let Some(rustdoc_store) = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx).ok() else {
+    let Some(argument) = command.argument else {
         return Empty.into_any();
     };
 
-    let Some((crate_name, _)) = command
-        .argument
-        .as_ref()
-        .and_then(|arg| arg.split_once(':'))
+    let args = DocsSlashCommandArgs::parse(&argument);
+
+    let Some(store) = args
+        .provider()
+        .and_then(|provider| IndexedDocsStore::try_global(provider, cx).ok())
     else {
         return Empty.into_any();
     };
 
-    let crate_name = PackageName::from(crate_name);
-    if !rustdoc_store.is_indexing(&crate_name) {
+    let Some(package) = args.package() else {
+        return Empty.into_any();
+    };
+
+    if !store.is_indexing(&package) {
         return Empty.into_any();
     }
 
@@ -3434,7 +3439,7 @@ fn render_rustdoc_slash_command_trailer(
             Animation::new(Duration::from_secs(4)).repeat(),
             |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
         ))
-        .tooltip(move |cx| Tooltip::text(format!("Indexing {crate_name}…"), cx))
+        .tooltip(move |cx| Tooltip::text(format!("Indexing {package}…"), cx))
         .into_any_element()
 }
 

crates/assistant/src/slash_command.rs

@@ -20,12 +20,12 @@ use workspace::Workspace;
 pub mod active_command;
 pub mod default_command;
 pub mod diagnostics_command;
+pub mod docs_command;
 pub mod fetch_command;
 pub mod file_command;
 pub mod now_command;
 pub mod project_command;
 pub mod prompt_command;
-pub mod rustdoc_command;
 pub mod search_command;
 pub mod tabs_command;
 pub mod term_command;

crates/assistant/src/slash_command/docs_command.rs

@@ -0,0 +1,365 @@
+use std::path::Path;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use anyhow::{anyhow, bail, Result};
+use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
+use gpui::{AppContext, Model, Task, WeakView};
+use indexed_docs::{
+    IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName, ProviderId, RustdocIndexer,
+};
+use language::LspAdapterDelegate;
+use project::{Project, ProjectPath};
+use ui::prelude::*;
+use util::{maybe, ResultExt};
+use workspace::Workspace;
+
+pub(crate) struct DocsSlashCommand;
+
+impl DocsSlashCommand {
+    pub const NAME: &'static str = "docs";
+
+    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(),
+        ))
+    }
+
+    /// Ensures that the rustdoc provider is registered.
+    ///
+    /// Ideally we would do this sooner, but we need to wait until we're able to
+    /// access the workspace so we can read the project.
+    fn ensure_rustdoc_provider_is_registered(
+        &self,
+        workspace: Option<WeakView<Workspace>>,
+        cx: &mut AppContext,
+    ) {
+        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
+        if indexed_docs_registry
+            .get_provider_store(ProviderId::rustdoc())
+            .is_none()
+        {
+            let index_provider_deps = maybe!({
+                let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
+                let workspace = workspace
+                    .upgrade()
+                    .ok_or_else(|| anyhow!("workspace was dropped"))?;
+                let project = workspace.read(cx).project().clone();
+                let fs = project.read(cx).fs().clone();
+                let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
+                    .and_then(|path| path.parent().map(|path| path.to_path_buf()))
+                    .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
+
+                anyhow::Ok((fs, cargo_workspace_root))
+            });
+
+            if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
+                indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new(
+                    LocalProvider::new(fs, cargo_workspace_root),
+                ))));
+            }
+        }
+    }
+}
+
+impl SlashCommand for DocsSlashCommand {
+    fn name(&self) -> String {
+        Self::NAME.into()
+    }
+
+    fn description(&self) -> String {
+        "insert docs".into()
+    }
+
+    fn menu_text(&self) -> String {
+        "Insert Documentation".into()
+    }
+
+    fn requires_argument(&self) -> bool {
+        true
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        query: String,
+        _cancel: Arc<AtomicBool>,
+        workspace: Option<WeakView<Workspace>>,
+        cx: &mut AppContext,
+    ) -> Task<Result<Vec<String>>> {
+        self.ensure_rustdoc_provider_is_registered(workspace, cx);
+
+        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
+        let args = DocsSlashCommandArgs::parse(&query);
+        let store = args
+            .provider()
+            .ok_or_else(|| anyhow!("no docs provider specified"))
+            .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
+        cx.background_executor().spawn(async move {
+            /// HACK: Prefixes the completions with the provider ID so that it doesn't get deleted
+            /// when a completion is accepted.
+            ///
+            /// We will likely want to extend `complete_argument` with support for replacing just
+            /// a particular range of the argument when a completion is accepted.
+            fn prefix_with_provider(provider: ProviderId, items: Vec<String>) -> Vec<String> {
+                items
+                    .into_iter()
+                    .map(|item| format!("{provider} {item}"))
+                    .collect()
+            }
+
+            match args {
+                DocsSlashCommandArgs::NoProvider => {
+                    let providers = indexed_docs_registry.list_providers();
+                    Ok(providers
+                        .into_iter()
+                        .map(|provider| provider.to_string())
+                        .collect())
+                }
+                DocsSlashCommandArgs::SearchPackageDocs {
+                    provider,
+                    package,
+                    index,
+                } => {
+                    let store = store?;
+
+                    if index {
+                        // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
+                        // until it completes.
+                        let _ = store.clone().index(package.as_str().into());
+                    }
+
+                    let items = store.search(package).await;
+                    Ok(prefix_with_provider(provider, items))
+                }
+                DocsSlashCommandArgs::SearchItemDocs {
+                    provider,
+                    item_path,
+                    ..
+                } => {
+                    let store = store?;
+                    let items = store.search(item_path).await;
+                    Ok(prefix_with_provider(provider, items))
+                }
+            }
+        })
+    }
+
+    fn run(
+        self: Arc<Self>,
+        argument: Option<&str>,
+        _workspace: WeakView<Workspace>,
+        _delegate: Arc<dyn LspAdapterDelegate>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<SlashCommandOutput>> {
+        let Some(argument) = argument else {
+            return Task::ready(Err(anyhow!("missing argument")));
+        };
+
+        let args = DocsSlashCommandArgs::parse(argument);
+        let text = cx.background_executor().spawn({
+            let store = args
+                .provider()
+                .ok_or_else(|| anyhow!("no docs provider specified"))
+                .and_then(|provider| IndexedDocsStore::try_global(provider, cx));
+            async move {
+                match args {
+                    DocsSlashCommandArgs::NoProvider => bail!("no docs provider specified"),
+                    DocsSlashCommandArgs::SearchPackageDocs {
+                        provider, package, ..
+                    } => {
+                        let store = store?;
+                        let item_docs = store.load(package.clone()).await?;
+
+                        anyhow::Ok((provider, package, item_docs.to_string()))
+                    }
+                    DocsSlashCommandArgs::SearchItemDocs {
+                        provider,
+                        item_path,
+                        ..
+                    } => {
+                        let store = store?;
+                        let item_docs = store.load(item_path.clone()).await?;
+
+                        anyhow::Ok((provider, item_path, item_docs.to_string()))
+                    }
+                }
+            }
+        });
+
+        cx.foreground_executor().spawn(async move {
+            let (provider, path, text) = text.await?;
+            let range = 0..text.len();
+            Ok(SlashCommandOutput {
+                text,
+                sections: vec![SlashCommandOutputSection {
+                    range,
+                    icon: IconName::FileRust,
+                    label: format!("docs ({provider}): {path}",).into(),
+                }],
+                run_commands_in_text: false,
+            })
+        })
+    }
+}
+
+fn is_item_path_delimiter(char: char) -> bool {
+    !char.is_alphanumeric() && char != '-' && char != '_'
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum DocsSlashCommandArgs {
+    NoProvider,
+    SearchPackageDocs {
+        provider: ProviderId,
+        package: String,
+        index: bool,
+    },
+    SearchItemDocs {
+        provider: ProviderId,
+        package: String,
+        item_path: String,
+    },
+}
+
+impl DocsSlashCommandArgs {
+    pub fn parse(argument: &str) -> Self {
+        let Some((provider, argument)) = argument.split_once(' ') else {
+            return Self::NoProvider;
+        };
+
+        let provider = ProviderId(provider.into());
+
+        if let Some((package, rest)) = argument.split_once(is_item_path_delimiter) {
+            if rest.trim().is_empty() {
+                Self::SearchPackageDocs {
+                    provider,
+                    package: package.to_owned(),
+                    index: true,
+                }
+            } else {
+                Self::SearchItemDocs {
+                    provider,
+                    package: package.to_owned(),
+                    item_path: argument.to_owned(),
+                }
+            }
+        } else {
+            Self::SearchPackageDocs {
+                provider,
+                package: argument.to_owned(),
+                index: false,
+            }
+        }
+    }
+
+    pub fn provider(&self) -> Option<ProviderId> {
+        match self {
+            Self::NoProvider => None,
+            Self::SearchPackageDocs { provider, .. } | Self::SearchItemDocs { provider, .. } => {
+                Some(provider.clone())
+            }
+        }
+    }
+
+    pub fn package(&self) -> Option<PackageName> {
+        match self {
+            Self::NoProvider => None,
+            Self::SearchPackageDocs { package, .. } | Self::SearchItemDocs { package, .. } => {
+                Some(package.as_str().into())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_docs_slash_command_args() {
+        assert_eq!(
+            DocsSlashCommandArgs::parse(""),
+            DocsSlashCommandArgs::NoProvider
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc"),
+            DocsSlashCommandArgs::NoProvider
+        );
+
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc "),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "".into(),
+                index: false
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam "),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("gleam".into()),
+                package: "".into(),
+                index: false
+            }
+        );
+
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc gpui"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "gpui".into(),
+                index: false,
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("gleam".into()),
+                package: "gleam_stdlib".into(),
+                index: false
+            }
+        );
+
+        // Adding an item path delimiter indicates we can start indexing.
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc gpui:"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "gpui".into(),
+                index: true,
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib/"),
+            DocsSlashCommandArgs::SearchPackageDocs {
+                provider: ProviderId("gleam".into()),
+                package: "gleam_stdlib".into(),
+                index: true
+            }
+        );
+
+        assert_eq!(
+            DocsSlashCommandArgs::parse("rustdoc gpui::foo::bar::Baz"),
+            DocsSlashCommandArgs::SearchItemDocs {
+                provider: ProviderId("rustdoc".into()),
+                package: "gpui".into(),
+                item_path: "gpui::foo::bar::Baz".into()
+            }
+        );
+        assert_eq!(
+            DocsSlashCommandArgs::parse("gleam gleam_stdlib/gleam/int"),
+            DocsSlashCommandArgs::SearchItemDocs {
+                provider: ProviderId("gleam".into()),
+                package: "gleam_stdlib".into(),
+                item_path: "gleam_stdlib/gleam/int".into()
+            }
+        );
+    }
+}

crates/assistant/src/slash_command/rustdoc_command.rs

@@ -1,265 +0,0 @@
-use std::path::Path;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-
-use anyhow::{anyhow, bail, Context, Result};
-use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandOutputSection};
-use fs::Fs;
-use futures::AsyncReadExt;
-use gpui::{AppContext, Model, Task, WeakView};
-use http::{AsyncBody, HttpClient, HttpClientWithUrl};
-use indexed_docs::{
-    convert_rustdoc_to_markdown, IndexedDocsRegistry, IndexedDocsStore, LocalProvider, PackageName,
-    ProviderId, RustdocIndexer, RustdocSource,
-};
-use language::LspAdapterDelegate;
-use project::{Project, ProjectPath};
-use ui::prelude::*;
-use util::{maybe, ResultExt};
-use workspace::Workspace;
-
-pub(crate) struct RustdocSlashCommand;
-
-impl RustdocSlashCommand {
-    async fn build_message(
-        fs: Arc<dyn Fs>,
-        http_client: Arc<HttpClientWithUrl>,
-        crate_name: PackageName,
-        module_path: Vec<String>,
-        path_to_cargo_toml: Option<&Path>,
-    ) -> Result<(RustdocSource, String)> {
-        let cargo_workspace_root = path_to_cargo_toml.and_then(|path| path.parent());
-        if let Some(cargo_workspace_root) = cargo_workspace_root {
-            let mut local_cargo_doc_path = cargo_workspace_root.join("target/doc");
-            local_cargo_doc_path.push(crate_name.as_ref());
-            if !module_path.is_empty() {
-                local_cargo_doc_path.push(module_path.join("/"));
-            }
-            local_cargo_doc_path.push("index.html");
-
-            if let Ok(contents) = fs.load(&local_cargo_doc_path).await {
-                let (markdown, _items) = convert_rustdoc_to_markdown(contents.as_bytes())?;
-
-                return Ok((RustdocSource::Local, markdown));
-            }
-        }
-
-        let version = "latest";
-        let path = format!(
-            "{crate_name}/{version}/{crate_name}/{module_path}",
-            module_path = module_path.join("/")
-        );
-
-        let mut response = http_client
-            .get(
-                &format!("https://docs.rs/{path}"),
-                AsyncBody::default(),
-                true,
-            )
-            .await?;
-
-        let mut body = Vec::new();
-        response
-            .body_mut()
-            .read_to_end(&mut body)
-            .await
-            .context("error reading docs.rs response body")?;
-
-        if response.status().is_client_error() {
-            let text = String::from_utf8_lossy(body.as_slice());
-            bail!(
-                "status error {}, response: {text:?}",
-                response.status().as_u16()
-            );
-        }
-
-        let (markdown, _items) = convert_rustdoc_to_markdown(&body[..])?;
-
-        Ok((RustdocSource::DocsDotRs, markdown))
-    }
-
-    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(),
-        ))
-    }
-
-    /// Ensures that the rustdoc provider is registered.
-    ///
-    /// Ideally we would do this sooner, but we need to wait until we're able to
-    /// access the workspace so we can read the project.
-    fn ensure_rustdoc_provider_is_registered(
-        &self,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut AppContext,
-    ) {
-        let indexed_docs_registry = IndexedDocsRegistry::global(cx);
-        if indexed_docs_registry
-            .get_provider_store(ProviderId::rustdoc())
-            .is_none()
-        {
-            let index_provider_deps = maybe!({
-                let workspace = workspace.ok_or_else(|| anyhow!("no workspace"))?;
-                let workspace = workspace
-                    .upgrade()
-                    .ok_or_else(|| anyhow!("workspace was dropped"))?;
-                let project = workspace.read(cx).project().clone();
-                let fs = project.read(cx).fs().clone();
-                let cargo_workspace_root = Self::path_to_cargo_toml(project, cx)
-                    .and_then(|path| path.parent().map(|path| path.to_path_buf()))
-                    .ok_or_else(|| anyhow!("no Cargo workspace root found"))?;
-
-                anyhow::Ok((fs, cargo_workspace_root))
-            });
-
-            if let Some((fs, cargo_workspace_root)) = index_provider_deps.log_err() {
-                indexed_docs_registry.register_provider(Box::new(RustdocIndexer::new(Box::new(
-                    LocalProvider::new(fs, cargo_workspace_root),
-                ))));
-            }
-        }
-    }
-}
-
-impl SlashCommand for RustdocSlashCommand {
-    fn name(&self) -> String {
-        "rustdoc".into()
-    }
-
-    fn description(&self) -> String {
-        "insert Rust docs".into()
-    }
-
-    fn menu_text(&self) -> String {
-        "Insert Rust Documentation".into()
-    }
-
-    fn requires_argument(&self) -> bool {
-        true
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        query: String,
-        _cancel: Arc<AtomicBool>,
-        workspace: Option<WeakView<Workspace>>,
-        cx: &mut AppContext,
-    ) -> Task<Result<Vec<String>>> {
-        self.ensure_rustdoc_provider_is_registered(workspace, cx);
-
-        let store = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx);
-        cx.background_executor().spawn(async move {
-            let store = store?;
-
-            if let Some((crate_name, rest)) = query.split_once(':') {
-                if rest.is_empty() {
-                    // We don't need to hold onto this task, as the `IndexedDocsStore` will hold it
-                    // until it completes.
-                    let _ = store.clone().index(crate_name.into());
-                }
-            }
-
-            let items = store.search(query).await;
-            Ok(items)
-        })
-    }
-
-    fn run(
-        self: Arc<Self>,
-        argument: Option<&str>,
-        workspace: WeakView<Workspace>,
-        _delegate: Arc<dyn LspAdapterDelegate>,
-        cx: &mut WindowContext,
-    ) -> Task<Result<SlashCommandOutput>> {
-        let Some(argument) = argument else {
-            return Task::ready(Err(anyhow!("missing crate name")));
-        };
-        let Some(workspace) = workspace.upgrade() else {
-            return Task::ready(Err(anyhow!("workspace was dropped")));
-        };
-
-        let project = workspace.read(cx).project().clone();
-        let fs = project.read(cx).fs().clone();
-        let http_client = workspace.read(cx).client().http_client();
-        let path_to_cargo_toml = Self::path_to_cargo_toml(project, cx);
-
-        let mut path_components = argument.split("::");
-        let crate_name = match path_components
-            .next()
-            .ok_or_else(|| anyhow!("missing crate name"))
-        {
-            Ok(crate_name) => PackageName::from(crate_name),
-            Err(err) => return Task::ready(Err(err)),
-        };
-        let item_path = path_components.map(ToString::to_string).collect::<Vec<_>>();
-
-        let text = cx.background_executor().spawn({
-            let rustdoc_store = IndexedDocsStore::try_global(ProviderId::rustdoc(), cx);
-            let crate_name = crate_name.clone();
-            let item_path = item_path.clone();
-            async move {
-                let rustdoc_store = rustdoc_store?;
-                let item_docs = rustdoc_store
-                    .load(
-                        crate_name.clone(),
-                        if item_path.is_empty() {
-                            None
-                        } else {
-                            Some(item_path.join("::"))
-                        },
-                    )
-                    .await;
-
-                if let Ok(item_docs) = item_docs {
-                    anyhow::Ok((RustdocSource::Index, item_docs.to_string()))
-                } else {
-                    Self::build_message(
-                        fs,
-                        http_client,
-                        crate_name,
-                        item_path,
-                        path_to_cargo_toml.as_deref(),
-                    )
-                    .await
-                }
-            }
-        });
-
-        let module_path = if item_path.is_empty() {
-            None
-        } else {
-            Some(SharedString::from(item_path.join("::")))
-        };
-        cx.foreground_executor().spawn(async move {
-            let (source, text) = text.await?;
-            let range = 0..text.len();
-            let crate_path = module_path
-                .map(|module_path| format!("{}::{}", crate_name, module_path))
-                .unwrap_or_else(|| crate_name.to_string());
-            Ok(SlashCommandOutput {
-                text,
-                sections: vec![SlashCommandOutputSection {
-                    range,
-                    icon: IconName::FileRust,
-                    label: format!(
-                        "rustdoc ({source}): {crate_path}",
-                        source = match source {
-                            RustdocSource::Index => "index",
-                            RustdocSource::Local => "local",
-                            RustdocSource::DocsDotRs => "docs.rs",
-                        }
-                    )
-                    .into(),
-                }],
-                run_commands_in_text: false,
-            })
-        })
-    }
-}

crates/indexed_docs/src/providers/rustdoc.rs

@@ -16,16 +16,6 @@ use http::{AsyncBody, HttpClient, HttpClientWithUrl};
 
 use crate::{IndexedDocsDatabase, IndexedDocsProvider, PackageName, ProviderId};
 
-#[derive(Debug, Clone, Copy)]
-pub enum RustdocSource {
-    /// The docs were sourced from Zed's rustdoc index.
-    Index,
-    /// The docs were sourced from local `cargo doc` output.
-    Local,
-    /// The docs were sourced from `docs.rs`.
-    DocsDotRs,
-}
-
 #[derive(Debug)]
 struct RustdocItemWithHistory {
     pub item: RustdocItem,

crates/indexed_docs/src/registry.rs

@@ -34,6 +34,14 @@ impl IndexedDocsRegistry {
         }
     }
 
+    pub fn list_providers(&self) -> Vec<ProviderId> {
+        self.stores_by_provider
+            .read()
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>()
+    }
+
     pub fn register_provider(
         &self,
         provider: Box<dyn IndexedDocsProvider + Send + Sync + 'static>,

crates/indexed_docs/src/store.rs

@@ -94,22 +94,12 @@ impl IndexedDocsStore {
         self.indexing_tasks_by_package.read().contains_key(package)
     }
 
-    pub async fn load(
-        &self,
-        package: PackageName,
-        item_path: Option<String>,
-    ) -> Result<MarkdownDocs> {
-        let item_path = if let Some(item_path) = item_path {
-            format!("{package}::{item_path}")
-        } else {
-            package.to_string()
-        };
-
+    pub async fn load(&self, key: String) -> Result<MarkdownDocs> {
         self.database_future
             .clone()
             .await
             .map_err(|err| anyhow!(err))?
-            .load(item_path)
+            .load(key)
             .await
     }
 
@@ -160,10 +150,6 @@ impl IndexedDocsStore {
         let executor = self.executor.clone();
         let database_future = self.database_future.clone();
         self.executor.spawn(async move {
-            if query.is_empty() {
-                return Vec::new();
-            }
-
             let Some(database) = database_future.await.map_err(|err| anyhow!(err)).log_err() else {
                 return Vec::new();
             };