use anyhow::{Result, anyhow};use assistant_slash_command::{    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,    SlashCommandOutputSection, SlashCommandResult,};use editor::{Editor, MultiBufferSnapshot};use futures::StreamExt;use gpui::{App, SharedString, Task, WeakEntity, Window};use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};use rope::Point;use std::ops::Range;use std::sync::Arc;use std::sync::atomic::AtomicBool;use ui::IconName;use workspace::Workspace; use crate::file_command::codeblock_fence_for_path; pub struct SelectionCommand; impl SlashCommand for SelectionCommand {    fn name(&self) -> String {        "selection".into()    }     fn label(&self, _cx: &App) -> CodeLabel {        CodeLabel::plain(self.name(), None)    }     fn description(&self) -> String {        "Insert editor selection".into()    }     fn icon(&self) -> IconName {        IconName::Quote    }     fn menu_text(&self) -> String {        self.description()    }     fn requires_argument(&self) -> bool {        false    }     fn accepts_arguments(&self) -> bool {        true    }     fn complete_argument(        self: Arc<Self>,        _arguments: &[String],        _cancel: Arc<AtomicBool>,        _workspace: Option<WeakEntity<Workspace>>,        _window: &mut Window,        _cx: &mut App,    ) -> Task<Result<Vec<ArgumentCompletion>>> {        Task::ready(Err(anyhow!("this command does not require argument")))    }     fn run(        self: Arc<Self>,        _arguments: &[String],        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],        _context_buffer: BufferSnapshot,        workspace: WeakEntity<Workspace>,        _delegate: Option<Arc<dyn LspAdapterDelegate>>,        _window: &mut Window,        cx: &mut App,    ) -> Task<SlashCommandResult> {        let mut events = vec![];         let Some(creases) = workspace            .update(cx, |workspace, cx| {                let editor = workspace                    .active_item(cx)                    .and_then(|item| item.act_as::<Editor>(cx))?;                 editor.update(cx, |editor, cx| {                    let selection_ranges = editor                        .selections                        .all_adjusted(cx)                        .iter()                        .map(|selection| selection.range())                        .collect::<Vec<_>>();                    let snapshot = editor.buffer().read(cx).snapshot(cx);                    Some(selections_creases(selection_ranges, snapshot, cx))                })            })            .unwrap_or_else(|e| {                events.push(Err(e));                None            })        else {            return Task::ready(Err(anyhow!("no active selection")));        };         for (text, title) in creases {            events.push(Ok(SlashCommandEvent::StartSection {                icon: IconName::TextSnippet,                label: SharedString::from(title),                metadata: None,            }));            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {                text,                run_commands_in_text: false,            })));            events.push(Ok(SlashCommandEvent::EndSection));            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {                text: "\n".to_string(),                run_commands_in_text: false,            })));        }         let result = futures::stream::iter(events).boxed();         Task::ready(Ok(result))    }} pub fn selections_creases(    selection_ranges: Vec<Range<Point>>,    snapshot: MultiBufferSnapshot,    cx: &App,) -> Vec<(String, String)> {    let mut creases = Vec::new();    for range in selection_ranges {        let selected_text = snapshot.text_for_range(range.clone()).collect::<String>();        if selected_text.is_empty() {            continue;        }        let start_language = snapshot.language_at(range.start);        let end_language = snapshot.language_at(range.end);        let language_name = if start_language == end_language {            start_language.map(|language| language.code_fence_block_name())        } else {            None        };        let language_name = language_name.as_deref().unwrap_or("");        let filename = snapshot.file_at(range.start).map(|file| file.full_path(cx));        let text = if language_name == "markdown" {            selected_text                .lines()                .map(|line| format!("> {}", line))                .collect::<Vec<_>>()                .join("\n")        } else {            let start_symbols = snapshot                .symbols_containing(range.start, None)                .map(|(_, symbols)| symbols);            let end_symbols = snapshot                .symbols_containing(range.end, None)                .map(|(_, symbols)| symbols);             let outline_text =                if let Some((start_symbols, end_symbols)) = start_symbols.zip(end_symbols) {                    Some(                        start_symbols                            .into_iter()                            .zip(end_symbols)                            .take_while(|(a, b)| a == b)                            .map(|(a, _)| a.text)                            .collect::<Vec<_>>()                            .join(" > "),                    )                } else {                    None                };             let line_comment_prefix = start_language                .and_then(|l| l.default_scope().line_comment_prefixes().first().cloned());             let fence = codeblock_fence_for_path(                filename.as_deref(),                Some(range.start.row..=range.end.row),            );             if let Some((line_comment_prefix, outline_text)) = line_comment_prefix.zip(outline_text)            {                let breadcrumb = format!("{line_comment_prefix}Excerpt from: {outline_text}\n");                format!("{fence}{breadcrumb}{selected_text}\n```")            } else {                format!("{fence}{selected_text}\n```")            }        };        let crease_title = if let Some(path) = filename {            let start_line = range.start.row + 1;            let end_line = range.end.row + 1;            if start_line == end_line {                format!("{}, Line {}", path.display(), start_line)            } else {                format!("{}, Lines {} to {}", path.display(), start_line, end_line)            }        } else {            "Quoted selection".to_string()        };        creases.push((text, crease_title));    }    creases}