use anyhow::{Result, anyhow};use assistant_slash_command::{    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,    SlashCommandOutputSection, SlashCommandResult,};use editor::{BufferOffset, 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(&editor.display_snapshot(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 buffer_ranges = snapshot.range_to_buffer_ranges(range.clone());         if buffer_ranges.is_empty() {            creases.extend(crease_for_range(range, &snapshot, cx));            continue;        }         for (buffer_snapshot, buffer_range, _excerpt_id) in buffer_ranges {            creases.extend(crease_for_buffer_range(buffer_snapshot, buffer_range, cx));        }    }    creases} /// Creates a crease for a range within a specific buffer (excerpt)./// This is used when we know the exact buffer and range within it.fn crease_for_buffer_range(    buffer: &BufferSnapshot,    Range { start, end }: Range<BufferOffset>,    cx: &App,) -> Option<(String, String)> {    let selected_text: String = buffer.text_for_range(start.0..end.0).collect();     if selected_text.is_empty() {        return None;    }     let start_point = buffer.offset_to_point(start.0);    let end_point = buffer.offset_to_point(end.0);    let start_buffer_row = start_point.row;    let end_buffer_row = end_point.row;     let language = buffer.language_at(start.0);    let language_name_arc = language.map(|l| l.code_fence_block_name());    let language_name = language_name_arc.as_deref().unwrap_or_default();     let filename = buffer        .file()        .map(|file| file.full_path(cx).to_string_lossy().into_owned());     let text = if language_name == "markdown" {        selected_text            .lines()            .map(|line| format!("> {}", line))            .collect::<Vec<_>>()            .join("\n")    } else {        let start_symbols = buffer.symbols_containing(start, None);        let end_symbols = buffer.symbols_containing(end, None);         let outline_text = if !start_symbols.is_empty() && !end_symbols.is_empty() {            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 =            language.and_then(|l| l.default_scope().line_comment_prefixes().first().cloned());         let fence =            codeblock_fence_for_path(filename.as_deref(), Some(start_buffer_row..=end_buffer_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 = start_buffer_row + 1;        let end_line = end_buffer_row + 1;        if start_line == end_line {            format!("{path}, Line {start_line}")        } else {            format!("{path}, Lines {start_line} to {end_line}")        }    } else {        "Quoted selection".to_string()    };     Some((text, crease_title))} /// Fallback function to create a crease from a multibuffer range when we can't split by excerpt.fn crease_for_range(    range: Range<Point>,    snapshot: &MultiBufferSnapshot,    cx: &App,) -> Option<(String, String)> {    let selected_text = snapshot.text_for_range(range.clone()).collect::<String>();    if selected_text.is_empty() {        return None;    }     // Get actual file line numbers (not multibuffer row numbers)    let start_buffer_row = snapshot        .point_to_buffer_point(range.start)        .map(|(_, point, _)| point.row)        .unwrap_or(range.start.row);    let end_buffer_row = snapshot        .point_to_buffer_point(range.end)        .map(|(_, point, _)| point.row)        .unwrap_or(range.end.row);     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).to_string_lossy().into_owned());     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(start_buffer_row..=end_buffer_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 = start_buffer_row + 1;        let end_line = end_buffer_row + 1;        if start_line == end_line {            format!("{path}, Line {start_line}")        } else {            format!("{path}, Lines {start_line} to {end_line}")        }    } else {        "Quoted selection".to_string()    };     Some((text, crease_title))} #[cfg(test)]mod tests {    use super::*;    use gpui::TestAppContext;    use multi_buffer::MultiBuffer;     #[gpui::test]    fn test_selections_creases_single_excerpt(cx: &mut TestAppContext) {        let buffer = cx.update(|cx| {            MultiBuffer::build_multi(                [("a\nb\nc\n", vec![Point::new(0, 0)..Point::new(3, 0)])],                cx,            )        });        let creases = cx.update(|cx| {            let snapshot = buffer.read(cx).snapshot(cx);            selections_creases(vec![Point::new(0, 0)..Point::new(2, 1)], snapshot, cx)        });        assert_eq!(creases.len(), 1);        assert_eq!(creases[0].0, "```untitled:1-3\na\nb\nc\n```");        assert_eq!(creases[0].1, "Quoted selection");    }     #[gpui::test]    fn test_selections_creases_spans_multiple_excerpts(cx: &mut TestAppContext) {        let buffer = cx.update(|cx| {            MultiBuffer::build_multi(                [                    ("aaa\nbbb\n", vec![Point::new(0, 0)..Point::new(2, 0)]),                    ("111\n222\n", vec![Point::new(0, 0)..Point::new(2, 0)]),                ],                cx,            )        });        let creases = cx.update(|cx| {            let snapshot = buffer.read(cx).snapshot(cx);            let end = snapshot.offset_to_point(snapshot.len());            selections_creases(vec![Point::new(0, 0)..end], snapshot, cx)        });        assert_eq!(creases.len(), 2);        assert!(creases[0].0.contains("aaa") && !creases[0].0.contains("111"));        assert!(creases[1].0.contains("111") && !creases[1].0.contains("aaa"));    }}