Extract ExtensionSlashCommand to assistant_slash_command crate (#20617)

This PR extracts the `ExtensionSlashCommand` implementation to the
`assistant_slash_command` crate.

The slash command related methods have been added to the `Extension`
trait. We also create separate data types for the slash command data
within the `extension` crate so that we can talk about them without
depending on the `extension_host` or `assistant_slash_command`.

Release Notes:

- N/A

crates/assistant_slash_command/Cargo.toml

@@ -13,8 +13,10 @@ path = "src/assistant_slash_command.rs"
 
 [dependencies]
 anyhow.workspace = true
+async-trait.workspace = true
 collections.workspace = true
 derive_more.workspace = true
+extension.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
@@ -22,6 +24,7 @@ language_model.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+ui.workspace = true
 workspace.workspace = true
 
 [dev-dependencies]

crates/assistant_slash_command/src/assistant_slash_command.rs

@@ -1,5 +1,8 @@
+mod extension_slash_command;
 mod slash_command_registry;
 
+pub use crate::extension_slash_command::*;
+pub use crate::slash_command_registry::*;
 use anyhow::Result;
 use futures::stream::{self, BoxStream};
 use futures::StreamExt;
@@ -7,7 +10,6 @@ use gpui::{AnyElement, AppContext, ElementId, SharedString, Task, WeakView, Wind
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate, OffsetRangeExt};
 pub use language_model::Role;
 use serde::{Deserialize, Serialize};
-pub use slash_command_registry::*;
 use std::{
     ops::Range,
     sync::{atomic::AtomicBool, Arc},

crates/assistant_slash_command/src/extension_slash_command.rs

@@ -0,0 +1,143 @@
+use std::path::PathBuf;
+use std::sync::{atomic::AtomicBool, Arc};
+
+use anyhow::Result;
+use async_trait::async_trait;
+use extension::{Extension, WorktreeDelegate};
+use gpui::{Task, WeakView, WindowContext};
+use language::{BufferSnapshot, LspAdapterDelegate};
+use ui::prelude::*;
+use workspace::Workspace;
+
+use crate::{
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+    SlashCommandResult,
+};
+
+/// An adapter that allows an [`LspAdapterDelegate`] to be used as a [`WorktreeDelegate`].
+struct WorktreeDelegateAdapter(Arc<dyn LspAdapterDelegate>);
+
+#[async_trait]
+impl WorktreeDelegate for WorktreeDelegateAdapter {
+    fn id(&self) -> u64 {
+        self.0.worktree_id().to_proto()
+    }
+
+    fn root_path(&self) -> String {
+        self.0.worktree_root_path().to_string_lossy().to_string()
+    }
+
+    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
+        self.0.read_text_file(path).await
+    }
+
+    async fn which(&self, binary_name: String) -> Option<String> {
+        self.0
+            .which(binary_name.as_ref())
+            .await
+            .map(|path| path.to_string_lossy().to_string())
+    }
+
+    async fn shell_env(&self) -> Vec<(String, String)> {
+        self.0.shell_env().await.into_iter().collect()
+    }
+}
+
+pub struct ExtensionSlashCommand {
+    extension: Arc<dyn Extension>,
+    command: extension::SlashCommand,
+}
+
+impl ExtensionSlashCommand {
+    pub fn new(extension: Arc<dyn Extension>, command: extension::SlashCommand) -> Self {
+        Self { extension, command }
+    }
+}
+
+impl SlashCommand for ExtensionSlashCommand {
+    fn name(&self) -> String {
+        self.command.name.clone()
+    }
+
+    fn description(&self) -> String {
+        self.command.description.clone()
+    }
+
+    fn menu_text(&self) -> String {
+        self.command.tooltip_text.clone()
+    }
+
+    fn requires_argument(&self) -> bool {
+        self.command.requires_argument
+    }
+
+    fn complete_argument(
+        self: Arc<Self>,
+        arguments: &[String],
+        _cancel: Arc<AtomicBool>,
+        _workspace: Option<WeakView<Workspace>>,
+        cx: &mut WindowContext,
+    ) -> Task<Result<Vec<ArgumentCompletion>>> {
+        let command = self.command.clone();
+        let arguments = arguments.to_owned();
+        cx.background_executor().spawn(async move {
+            let completions = self
+                .extension
+                .complete_slash_command_argument(command, arguments)
+                .await?;
+
+            anyhow::Ok(
+                completions
+                    .into_iter()
+                    .map(|completion| ArgumentCompletion {
+                        label: completion.label.into(),
+                        new_text: completion.new_text,
+                        replace_previous_arguments: false,
+                        after_completion: completion.run_command.into(),
+                    })
+                    .collect(),
+            )
+        })
+    }
+
+    fn run(
+        self: Arc<Self>,
+        arguments: &[String],
+        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
+        _context_buffer: BufferSnapshot,
+        _workspace: WeakView<Workspace>,
+        delegate: Option<Arc<dyn LspAdapterDelegate>>,
+        cx: &mut WindowContext,
+    ) -> Task<SlashCommandResult> {
+        let command = self.command.clone();
+        let arguments = arguments.to_owned();
+        let output = cx.background_executor().spawn(async move {
+            let delegate =
+                delegate.map(|delegate| Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _);
+            let output = self
+                .extension
+                .run_slash_command(command, arguments, delegate)
+                .await?;
+
+            anyhow::Ok(output)
+        });
+        cx.foreground_executor().spawn(async move {
+            let output = output.await?;
+            Ok(SlashCommandOutput {
+                text: output.text,
+                sections: output
+                    .sections
+                    .into_iter()
+                    .map(|section| SlashCommandOutputSection {
+                        range: section.range,
+                        icon: IconName::Code,
+                        label: section.label.into(),
+                        metadata: None,
+                    })
+                    .collect(),
+                run_commands_in_text: false,
+            }
+            .to_event_stream())
+        })
+    }
+}