1use crate::{
2 acp::completion_provider::ContextPickerCompletionProvider,
3 context_picker::fetch_context_picker::fetch_url_content,
4};
5use acp_thread::{MentionUri, selection_name};
6use agent::{TextThreadStore, ThreadId, ThreadStore};
7use agent_client_protocol as acp;
8use anyhow::{Context as _, Result, anyhow};
9use assistant_slash_commands::codeblock_fence_for_path;
10use collections::{HashMap, HashSet};
11use editor::{
12 Anchor, AnchorRangeExt, ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement,
13 EditorEvent, EditorMode, EditorStyle, ExcerptId, FoldPlaceholder, MultiBuffer,
14 SemanticsProvider, ToOffset,
15 actions::Paste,
16 display_map::{Crease, CreaseId, FoldId},
17};
18use futures::{
19 FutureExt as _, TryFutureExt as _,
20 future::{Shared, join_all, try_join_all},
21};
22use gpui::{
23 AppContext, ClipboardEntry, Context, Entity, EventEmitter, FocusHandle, Focusable,
24 HighlightStyle, Image, ImageFormat, Img, Subscription, Task, TextStyle, UnderlineStyle,
25 WeakEntity,
26};
27use language::{Buffer, Language};
28use language_model::LanguageModelImage;
29use project::{CompletionIntent, Project, ProjectPath, Worktree};
30use rope::Point;
31use settings::Settings;
32use std::{
33 cell::Cell,
34 ffi::OsStr,
35 fmt::{Display, Write},
36 ops::Range,
37 path::{Path, PathBuf},
38 rc::Rc,
39 sync::Arc,
40 time::Duration,
41};
42use text::{OffsetRangeExt, ToOffset as _};
43use theme::ThemeSettings;
44use ui::{
45 ActiveTheme, AnyElement, App, ButtonCommon, ButtonLike, ButtonStyle, Color, Icon, IconName,
46 IconSize, InteractiveElement, IntoElement, Label, LabelCommon, LabelSize, ParentElement,
47 Render, SelectableButton, SharedString, Styled, TextSize, TintColor, Toggleable, Window, div,
48 h_flex, px,
49};
50use url::Url;
51use util::ResultExt;
52use workspace::{Workspace, notifications::NotifyResultExt as _};
53use zed_actions::agent::Chat;
54
55const PARSE_SLASH_COMMAND_DEBOUNCE: Duration = Duration::from_millis(50);
56
57pub struct MessageEditor {
58 mention_set: MentionSet,
59 editor: Entity<Editor>,
60 project: Entity<Project>,
61 workspace: WeakEntity<Workspace>,
62 thread_store: Entity<ThreadStore>,
63 text_thread_store: Entity<TextThreadStore>,
64 prevent_slash_commands: bool,
65 _subscriptions: Vec<Subscription>,
66 _parse_slash_command_task: Task<()>,
67}
68
69#[derive(Clone, Copy)]
70pub enum MessageEditorEvent {
71 Send,
72 Cancel,
73 Focus,
74}
75
76impl EventEmitter<MessageEditorEvent> for MessageEditor {}
77
78impl MessageEditor {
79 pub fn new(
80 workspace: WeakEntity<Workspace>,
81 project: Entity<Project>,
82 thread_store: Entity<ThreadStore>,
83 text_thread_store: Entity<TextThreadStore>,
84 placeholder: impl Into<Arc<str>>,
85 prevent_slash_commands: bool,
86 mode: EditorMode,
87 window: &mut Window,
88 cx: &mut Context<Self>,
89 ) -> Self {
90 let language = Language::new(
91 language::LanguageConfig {
92 completion_query_characters: HashSet::from_iter(['.', '-', '_', '@']),
93 ..Default::default()
94 },
95 None,
96 );
97 let completion_provider = ContextPickerCompletionProvider::new(
98 workspace.clone(),
99 thread_store.downgrade(),
100 text_thread_store.downgrade(),
101 cx.weak_entity(),
102 );
103 let semantics_provider = Rc::new(SlashCommandSemanticsProvider {
104 range: Cell::new(None),
105 });
106 let mention_set = MentionSet::default();
107 let editor = cx.new(|cx| {
108 let buffer = cx.new(|cx| Buffer::local("", cx).with_language(Arc::new(language), cx));
109 let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
110
111 let mut editor = Editor::new(mode, buffer, None, window, cx);
112 editor.set_placeholder_text(placeholder, cx);
113 editor.set_show_indent_guides(false, cx);
114 editor.set_soft_wrap();
115 editor.set_use_modal_editing(true);
116 editor.set_completion_provider(Some(Rc::new(completion_provider)));
117 editor.set_context_menu_options(ContextMenuOptions {
118 min_entries_visible: 12,
119 max_entries_visible: 12,
120 placement: Some(ContextMenuPlacement::Above),
121 });
122 if prevent_slash_commands {
123 editor.set_semantics_provider(Some(semantics_provider.clone()));
124 }
125 editor
126 });
127
128 cx.on_focus(&editor.focus_handle(cx), window, |_, _, cx| {
129 cx.emit(MessageEditorEvent::Focus)
130 })
131 .detach();
132
133 let mut subscriptions = Vec::new();
134 if prevent_slash_commands {
135 subscriptions.push(cx.subscribe_in(&editor, window, {
136 let semantics_provider = semantics_provider.clone();
137 move |this, editor, event, window, cx| match event {
138 EditorEvent::Edited { .. } => {
139 this.highlight_slash_command(
140 semantics_provider.clone(),
141 editor.clone(),
142 window,
143 cx,
144 );
145 }
146 _ => {}
147 }
148 }));
149 }
150
151 Self {
152 editor,
153 project,
154 mention_set,
155 thread_store,
156 text_thread_store,
157 workspace,
158 prevent_slash_commands,
159 _subscriptions: subscriptions,
160 _parse_slash_command_task: Task::ready(()),
161 }
162 }
163
164 #[cfg(test)]
165 pub(crate) fn editor(&self) -> &Entity<Editor> {
166 &self.editor
167 }
168
169 #[cfg(test)]
170 pub(crate) fn mention_set(&mut self) -> &mut MentionSet {
171 &mut self.mention_set
172 }
173
174 pub fn is_empty(&self, cx: &App) -> bool {
175 self.editor.read(cx).is_empty(cx)
176 }
177
178 pub fn mentioned_path_and_threads(&self) -> (HashSet<PathBuf>, HashSet<ThreadId>) {
179 let mut excluded_paths = HashSet::default();
180 let mut excluded_threads = HashSet::default();
181
182 for uri in self.mention_set.uri_by_crease_id.values() {
183 match uri {
184 MentionUri::File { abs_path, .. } => {
185 excluded_paths.insert(abs_path.clone());
186 }
187 MentionUri::Thread { id, .. } => {
188 excluded_threads.insert(id.clone());
189 }
190 _ => {}
191 }
192 }
193
194 (excluded_paths, excluded_threads)
195 }
196
197 pub fn confirm_completion(
198 &mut self,
199 crease_text: SharedString,
200 start: text::Anchor,
201 content_len: usize,
202 mention_uri: MentionUri,
203 window: &mut Window,
204 cx: &mut Context<Self>,
205 ) {
206 let snapshot = self
207 .editor
208 .update(cx, |editor, cx| editor.snapshot(window, cx));
209 let Some((excerpt_id, _, _)) = snapshot.buffer_snapshot.as_singleton() else {
210 return;
211 };
212 let Some(anchor) = snapshot
213 .buffer_snapshot
214 .anchor_in_excerpt(*excerpt_id, start)
215 else {
216 return;
217 };
218
219 if let MentionUri::File { abs_path, .. } = &mention_uri {
220 let extension = abs_path
221 .extension()
222 .and_then(OsStr::to_str)
223 .unwrap_or_default();
224
225 if Img::extensions().contains(&extension) && !extension.contains("svg") {
226 let project = self.project.clone();
227 let Some(project_path) = project
228 .read(cx)
229 .project_path_for_absolute_path(abs_path, cx)
230 else {
231 return;
232 };
233 let image = cx
234 .spawn(async move |_, cx| {
235 let image = project
236 .update(cx, |project, cx| project.open_image(project_path, cx))
237 .map_err(|e| e.to_string())?
238 .await
239 .map_err(|e| e.to_string())?;
240 image
241 .read_with(cx, |image, _cx| image.image.clone())
242 .map_err(|e| e.to_string())
243 })
244 .shared();
245 let Some(crease_id) = insert_crease_for_image(
246 *excerpt_id,
247 start,
248 content_len,
249 Some(abs_path.as_path().into()),
250 image.clone(),
251 self.editor.clone(),
252 window,
253 cx,
254 ) else {
255 return;
256 };
257 self.confirm_mention_for_image(
258 crease_id,
259 anchor,
260 Some(abs_path.clone()),
261 image,
262 window,
263 cx,
264 );
265 return;
266 }
267 }
268
269 let Some(crease_id) = crate::context_picker::insert_crease_for_mention(
270 *excerpt_id,
271 start,
272 content_len,
273 crease_text.clone(),
274 mention_uri.icon_path(cx),
275 self.editor.clone(),
276 window,
277 cx,
278 ) else {
279 return;
280 };
281
282 match mention_uri {
283 MentionUri::Fetch { url } => {
284 self.confirm_mention_for_fetch(crease_id, anchor, url, window, cx);
285 }
286 MentionUri::Directory { abs_path } => {
287 self.confirm_mention_for_directory(crease_id, anchor, abs_path, window, cx);
288 }
289 MentionUri::Thread { id, name } => {
290 self.confirm_mention_for_thread(crease_id, anchor, id, name, window, cx);
291 }
292 MentionUri::TextThread { path, name } => {
293 self.confirm_mention_for_text_thread(crease_id, anchor, path, name, window, cx);
294 }
295 MentionUri::File { .. }
296 | MentionUri::Symbol { .. }
297 | MentionUri::Rule { .. }
298 | MentionUri::Selection { .. } => {
299 self.mention_set.insert_uri(crease_id, mention_uri.clone());
300 }
301 }
302 }
303
304 fn confirm_mention_for_directory(
305 &mut self,
306 crease_id: CreaseId,
307 anchor: Anchor,
308 abs_path: PathBuf,
309 window: &mut Window,
310 cx: &mut Context<Self>,
311 ) {
312 fn collect_files_in_path(worktree: &Worktree, path: &Path) -> Vec<(Arc<Path>, PathBuf)> {
313 let mut files = Vec::new();
314
315 for entry in worktree.child_entries(path) {
316 if entry.is_dir() {
317 files.extend(collect_files_in_path(worktree, &entry.path));
318 } else if entry.is_file() {
319 files.push((entry.path.clone(), worktree.full_path(&entry.path)));
320 }
321 }
322
323 files
324 }
325
326 let uri = MentionUri::Directory {
327 abs_path: abs_path.clone(),
328 };
329 let Some(project_path) = self
330 .project
331 .read(cx)
332 .project_path_for_absolute_path(&abs_path, cx)
333 else {
334 return;
335 };
336 let Some(entry) = self.project.read(cx).entry_for_path(&project_path, cx) else {
337 return;
338 };
339 let Some(worktree) = self.project.read(cx).worktree_for_entry(entry.id, cx) else {
340 return;
341 };
342 let project = self.project.clone();
343 let task = cx.spawn(async move |_, cx| {
344 let directory_path = entry.path.clone();
345
346 let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id())?;
347 let file_paths = worktree.read_with(cx, |worktree, _cx| {
348 collect_files_in_path(worktree, &directory_path)
349 })?;
350 let descendants_future = cx.update(|cx| {
351 join_all(file_paths.into_iter().map(|(worktree_path, full_path)| {
352 let rel_path = worktree_path
353 .strip_prefix(&directory_path)
354 .log_err()
355 .map_or_else(|| worktree_path.clone(), |rel_path| rel_path.into());
356
357 let open_task = project.update(cx, |project, cx| {
358 project.buffer_store().update(cx, |buffer_store, cx| {
359 let project_path = ProjectPath {
360 worktree_id,
361 path: worktree_path,
362 };
363 buffer_store.open_buffer(project_path, cx)
364 })
365 });
366
367 // TODO: report load errors instead of just logging
368 let rope_task = cx.spawn(async move |cx| {
369 let buffer = open_task.await.log_err()?;
370 let rope = buffer
371 .read_with(cx, |buffer, _cx| buffer.as_rope().clone())
372 .log_err()?;
373 Some(rope)
374 });
375
376 cx.background_spawn(async move {
377 let rope = rope_task.await?;
378 Some((rel_path, full_path, rope.to_string()))
379 })
380 }))
381 })?;
382
383 let contents = cx
384 .background_spawn(async move {
385 let contents = descendants_future.await.into_iter().flatten();
386 contents.collect()
387 })
388 .await;
389 anyhow::Ok(contents)
390 });
391 let task = cx
392 .spawn(async move |_, _| {
393 task.await
394 .map(|contents| DirectoryContents(contents).to_string())
395 .map_err(|e| e.to_string())
396 })
397 .shared();
398
399 self.mention_set.directories.insert(abs_path, task.clone());
400
401 let editor = self.editor.clone();
402 cx.spawn_in(window, async move |this, cx| {
403 if task.await.notify_async_err(cx).is_some() {
404 this.update(cx, |this, _| {
405 this.mention_set.insert_uri(crease_id, uri);
406 })
407 .ok();
408 } else {
409 editor
410 .update(cx, |editor, cx| {
411 editor.display_map.update(cx, |display_map, cx| {
412 display_map.unfold_intersecting(vec![anchor..anchor], true, cx);
413 });
414 editor.remove_creases([crease_id], cx);
415 })
416 .ok();
417 }
418 })
419 .detach();
420 }
421
422 fn confirm_mention_for_fetch(
423 &mut self,
424 crease_id: CreaseId,
425 anchor: Anchor,
426 url: url::Url,
427 window: &mut Window,
428 cx: &mut Context<Self>,
429 ) {
430 let Some(http_client) = self
431 .workspace
432 .update(cx, |workspace, _cx| workspace.client().http_client())
433 .ok()
434 else {
435 return;
436 };
437
438 let url_string = url.to_string();
439 let fetch = cx
440 .background_executor()
441 .spawn(async move {
442 fetch_url_content(http_client, url_string)
443 .map_err(|e| e.to_string())
444 .await
445 })
446 .shared();
447 self.mention_set
448 .add_fetch_result(url.clone(), fetch.clone());
449
450 cx.spawn_in(window, async move |this, cx| {
451 let fetch = fetch.await.notify_async_err(cx);
452 this.update(cx, |this, cx| {
453 let mention_uri = MentionUri::Fetch { url };
454 if fetch.is_some() {
455 this.mention_set.insert_uri(crease_id, mention_uri.clone());
456 } else {
457 // Remove crease if we failed to fetch
458 this.editor.update(cx, |editor, cx| {
459 editor.display_map.update(cx, |display_map, cx| {
460 display_map.unfold_intersecting(vec![anchor..anchor], true, cx);
461 });
462 editor.remove_creases([crease_id], cx);
463 });
464 }
465 })
466 .ok();
467 })
468 .detach();
469 }
470
471 pub fn confirm_mention_for_selection(
472 &mut self,
473 source_range: Range<text::Anchor>,
474 selections: Vec<(Entity<Buffer>, Range<text::Anchor>, Range<usize>)>,
475 window: &mut Window,
476 cx: &mut Context<Self>,
477 ) {
478 let snapshot = self.editor.read(cx).buffer().read(cx).snapshot(cx);
479 let Some((&excerpt_id, _, _)) = snapshot.as_singleton() else {
480 return;
481 };
482 let Some(start) = snapshot.anchor_in_excerpt(excerpt_id, source_range.start) else {
483 return;
484 };
485
486 let offset = start.to_offset(&snapshot);
487
488 for (buffer, selection_range, range_to_fold) in selections {
489 let range = snapshot.anchor_after(offset + range_to_fold.start)
490 ..snapshot.anchor_after(offset + range_to_fold.end);
491
492 let path = buffer
493 .read(cx)
494 .file()
495 .map_or(PathBuf::from("untitled"), |file| file.path().to_path_buf());
496 let snapshot = buffer.read(cx).snapshot();
497
498 let point_range = selection_range.to_point(&snapshot);
499 let line_range = point_range.start.row..point_range.end.row;
500
501 let uri = MentionUri::Selection {
502 path: path.clone(),
503 line_range: line_range.clone(),
504 };
505 let crease = crate::context_picker::crease_for_mention(
506 selection_name(&path, &line_range).into(),
507 uri.icon_path(cx),
508 range,
509 self.editor.downgrade(),
510 );
511
512 let crease_id = self.editor.update(cx, |editor, cx| {
513 let crease_ids = editor.insert_creases(vec![crease.clone()], cx);
514 editor.fold_creases(vec![crease], false, window, cx);
515 crease_ids.first().copied().unwrap()
516 });
517
518 self.mention_set
519 .insert_uri(crease_id, MentionUri::Selection { path, line_range });
520 }
521 }
522
523 fn confirm_mention_for_thread(
524 &mut self,
525 crease_id: CreaseId,
526 anchor: Anchor,
527 id: ThreadId,
528 name: String,
529 window: &mut Window,
530 cx: &mut Context<Self>,
531 ) {
532 let uri = MentionUri::Thread {
533 id: id.clone(),
534 name,
535 };
536 let open_task = self.thread_store.update(cx, |thread_store, cx| {
537 thread_store.open_thread(&id, window, cx)
538 });
539 let task = cx
540 .spawn(async move |_, cx| {
541 let thread = open_task.await.map_err(|e| e.to_string())?;
542 let content = thread
543 .read_with(cx, |thread, _cx| thread.latest_detailed_summary_or_text())
544 .map_err(|e| e.to_string())?;
545 Ok(content)
546 })
547 .shared();
548
549 self.mention_set.insert_thread(id, task.clone());
550
551 let editor = self.editor.clone();
552 cx.spawn_in(window, async move |this, cx| {
553 if task.await.notify_async_err(cx).is_some() {
554 this.update(cx, |this, _| {
555 this.mention_set.insert_uri(crease_id, uri);
556 })
557 .ok();
558 } else {
559 editor
560 .update(cx, |editor, cx| {
561 editor.display_map.update(cx, |display_map, cx| {
562 display_map.unfold_intersecting(vec![anchor..anchor], true, cx);
563 });
564 editor.remove_creases([crease_id], cx);
565 })
566 .ok();
567 }
568 })
569 .detach();
570 }
571
572 fn confirm_mention_for_text_thread(
573 &mut self,
574 crease_id: CreaseId,
575 anchor: Anchor,
576 path: PathBuf,
577 name: String,
578 window: &mut Window,
579 cx: &mut Context<Self>,
580 ) {
581 let uri = MentionUri::TextThread {
582 path: path.clone(),
583 name,
584 };
585 let context = self.text_thread_store.update(cx, |text_thread_store, cx| {
586 text_thread_store.open_local_context(path.as_path().into(), cx)
587 });
588 let task = cx
589 .spawn(async move |_, cx| {
590 let context = context.await.map_err(|e| e.to_string())?;
591 let xml = context
592 .update(cx, |context, cx| context.to_xml(cx))
593 .map_err(|e| e.to_string())?;
594 Ok(xml)
595 })
596 .shared();
597
598 self.mention_set.insert_text_thread(path, task.clone());
599
600 let editor = self.editor.clone();
601 cx.spawn_in(window, async move |this, cx| {
602 if task.await.notify_async_err(cx).is_some() {
603 this.update(cx, |this, _| {
604 this.mention_set.insert_uri(crease_id, uri);
605 })
606 .ok();
607 } else {
608 editor
609 .update(cx, |editor, cx| {
610 editor.display_map.update(cx, |display_map, cx| {
611 display_map.unfold_intersecting(vec![anchor..anchor], true, cx);
612 });
613 editor.remove_creases([crease_id], cx);
614 })
615 .ok();
616 }
617 })
618 .detach();
619 }
620
621 pub fn contents(
622 &self,
623 window: &mut Window,
624 cx: &mut Context<Self>,
625 ) -> Task<Result<Vec<acp::ContentBlock>>> {
626 let contents =
627 self.mention_set
628 .contents(self.project.clone(), self.thread_store.clone(), window, cx);
629 let editor = self.editor.clone();
630 let prevent_slash_commands = self.prevent_slash_commands;
631
632 cx.spawn(async move |_, cx| {
633 let contents = contents.await?;
634
635 editor.update(cx, |editor, cx| {
636 let mut ix = 0;
637 let mut chunks: Vec<acp::ContentBlock> = Vec::new();
638 let text = editor.text(cx);
639 editor.display_map.update(cx, |map, cx| {
640 let snapshot = map.snapshot(cx);
641 for (crease_id, crease) in snapshot.crease_snapshot.creases() {
642 // Skip creases that have been edited out of the message buffer.
643 if !crease.range().start.is_valid(&snapshot.buffer_snapshot) {
644 continue;
645 }
646
647 let Some(mention) = contents.get(&crease_id) else {
648 continue;
649 };
650
651 let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot);
652 if crease_range.start > ix {
653 let chunk = if prevent_slash_commands
654 && ix == 0
655 && parse_slash_command(&text[ix..]).is_some()
656 {
657 format!(" {}", &text[ix..crease_range.start]).into()
658 } else {
659 text[ix..crease_range.start].into()
660 };
661 chunks.push(chunk);
662 }
663 let chunk = match mention {
664 Mention::Text { uri, content } => {
665 acp::ContentBlock::Resource(acp::EmbeddedResource {
666 annotations: None,
667 resource: acp::EmbeddedResourceResource::TextResourceContents(
668 acp::TextResourceContents {
669 mime_type: None,
670 text: content.clone(),
671 uri: uri.to_uri().to_string(),
672 },
673 ),
674 })
675 }
676 Mention::Image(mention_image) => {
677 acp::ContentBlock::Image(acp::ImageContent {
678 annotations: None,
679 data: mention_image.data.to_string(),
680 mime_type: mention_image.format.mime_type().into(),
681 uri: mention_image
682 .abs_path
683 .as_ref()
684 .map(|path| format!("file://{}", path.display())),
685 })
686 }
687 };
688 chunks.push(chunk);
689 ix = crease_range.end;
690 }
691
692 if ix < text.len() {
693 let last_chunk = if prevent_slash_commands
694 && ix == 0
695 && parse_slash_command(&text[ix..]).is_some()
696 {
697 format!(" {}", text[ix..].trim_end())
698 } else {
699 text[ix..].trim_end().to_owned()
700 };
701 if !last_chunk.is_empty() {
702 chunks.push(last_chunk.into());
703 }
704 }
705 });
706
707 chunks
708 })
709 })
710 }
711
712 pub fn clear(&mut self, window: &mut Window, cx: &mut Context<Self>) {
713 self.editor.update(cx, |editor, cx| {
714 editor.clear(window, cx);
715 editor.remove_creases(self.mention_set.drain(), cx)
716 });
717 }
718
719 fn send(&mut self, _: &Chat, _: &mut Window, cx: &mut Context<Self>) {
720 cx.emit(MessageEditorEvent::Send)
721 }
722
723 fn cancel(&mut self, _: &editor::actions::Cancel, _: &mut Window, cx: &mut Context<Self>) {
724 cx.emit(MessageEditorEvent::Cancel)
725 }
726
727 fn paste(&mut self, _: &Paste, window: &mut Window, cx: &mut Context<Self>) {
728 let images = cx
729 .read_from_clipboard()
730 .map(|item| {
731 item.into_entries()
732 .filter_map(|entry| {
733 if let ClipboardEntry::Image(image) = entry {
734 Some(image)
735 } else {
736 None
737 }
738 })
739 .collect::<Vec<_>>()
740 })
741 .unwrap_or_default();
742
743 if images.is_empty() {
744 return;
745 }
746 cx.stop_propagation();
747
748 let replacement_text = "image";
749 for image in images {
750 let (excerpt_id, text_anchor, multibuffer_anchor) =
751 self.editor.update(cx, |message_editor, cx| {
752 let snapshot = message_editor.snapshot(window, cx);
753 let (excerpt_id, _, buffer_snapshot) =
754 snapshot.buffer_snapshot.as_singleton().unwrap();
755
756 let text_anchor = buffer_snapshot.anchor_before(buffer_snapshot.len());
757 let multibuffer_anchor = snapshot
758 .buffer_snapshot
759 .anchor_in_excerpt(*excerpt_id, text_anchor);
760 message_editor.edit(
761 [(
762 multi_buffer::Anchor::max()..multi_buffer::Anchor::max(),
763 format!("{replacement_text} "),
764 )],
765 cx,
766 );
767 (*excerpt_id, text_anchor, multibuffer_anchor)
768 });
769
770 let content_len = replacement_text.len();
771 let Some(anchor) = multibuffer_anchor else {
772 return;
773 };
774 let task = Task::ready(Ok(Arc::new(image))).shared();
775 let Some(crease_id) = insert_crease_for_image(
776 excerpt_id,
777 text_anchor,
778 content_len,
779 None.clone(),
780 task.clone(),
781 self.editor.clone(),
782 window,
783 cx,
784 ) else {
785 return;
786 };
787 self.confirm_mention_for_image(crease_id, anchor, None, task, window, cx);
788 }
789 }
790
791 pub fn insert_dragged_files(
792 &self,
793 paths: Vec<project::ProjectPath>,
794 window: &mut Window,
795 cx: &mut Context<Self>,
796 ) {
797 let buffer = self.editor.read(cx).buffer().clone();
798 let Some(buffer) = buffer.read(cx).as_singleton() else {
799 return;
800 };
801 for path in paths {
802 let Some(entry) = self.project.read(cx).entry_for_path(&path, cx) else {
803 continue;
804 };
805 let Some(abs_path) = self.project.read(cx).absolute_path(&path, cx) else {
806 continue;
807 };
808
809 let anchor = buffer.update(cx, |buffer, _cx| buffer.anchor_before(buffer.len()));
810 let path_prefix = abs_path
811 .file_name()
812 .unwrap_or(path.path.as_os_str())
813 .display()
814 .to_string();
815 let Some(completion) = ContextPickerCompletionProvider::completion_for_path(
816 path,
817 &path_prefix,
818 false,
819 entry.is_dir(),
820 anchor..anchor,
821 cx.weak_entity(),
822 self.project.clone(),
823 cx,
824 ) else {
825 continue;
826 };
827
828 self.editor.update(cx, |message_editor, cx| {
829 message_editor.edit(
830 [(
831 multi_buffer::Anchor::max()..multi_buffer::Anchor::max(),
832 completion.new_text,
833 )],
834 cx,
835 );
836 });
837 if let Some(confirm) = completion.confirm.clone() {
838 confirm(CompletionIntent::Complete, window, cx);
839 }
840 }
841 }
842
843 pub fn set_read_only(&mut self, read_only: bool, cx: &mut Context<Self>) {
844 self.editor.update(cx, |message_editor, cx| {
845 message_editor.set_read_only(read_only);
846 cx.notify()
847 })
848 }
849
850 fn confirm_mention_for_image(
851 &mut self,
852 crease_id: CreaseId,
853 anchor: Anchor,
854 abs_path: Option<PathBuf>,
855 image: Shared<Task<Result<Arc<Image>, String>>>,
856 window: &mut Window,
857 cx: &mut Context<Self>,
858 ) {
859 let editor = self.editor.clone();
860 let task = cx
861 .spawn_in(window, {
862 let abs_path = abs_path.clone();
863 async move |_, cx| {
864 let image = image.await.map_err(|e| e.to_string())?;
865 let format = image.format;
866 let image = cx
867 .update(|_, cx| LanguageModelImage::from_image(image, cx))
868 .map_err(|e| e.to_string())?
869 .await;
870 if let Some(image) = image {
871 Ok(MentionImage {
872 abs_path,
873 data: image.source,
874 format,
875 })
876 } else {
877 Err("Failed to convert image".into())
878 }
879 }
880 })
881 .shared();
882
883 self.mention_set.insert_image(crease_id, task.clone());
884
885 cx.spawn_in(window, async move |this, cx| {
886 if task.await.notify_async_err(cx).is_some() {
887 if let Some(abs_path) = abs_path.clone() {
888 this.update(cx, |this, _cx| {
889 this.mention_set
890 .insert_uri(crease_id, MentionUri::File { abs_path });
891 })
892 .ok();
893 }
894 } else {
895 editor
896 .update(cx, |editor, cx| {
897 editor.display_map.update(cx, |display_map, cx| {
898 display_map.unfold_intersecting(vec![anchor..anchor], true, cx);
899 });
900 editor.remove_creases([crease_id], cx);
901 })
902 .ok();
903 }
904 })
905 .detach();
906 }
907
908 pub fn set_mode(&mut self, mode: EditorMode, cx: &mut Context<Self>) {
909 self.editor.update(cx, |editor, cx| {
910 editor.set_mode(mode);
911 cx.notify()
912 });
913 }
914
915 pub fn set_message(
916 &mut self,
917 message: Vec<acp::ContentBlock>,
918 window: &mut Window,
919 cx: &mut Context<Self>,
920 ) {
921 self.clear(window, cx);
922
923 let mut text = String::new();
924 let mut mentions = Vec::new();
925 let mut images = Vec::new();
926
927 for chunk in message {
928 match chunk {
929 acp::ContentBlock::Text(text_content) => {
930 text.push_str(&text_content.text);
931 }
932 acp::ContentBlock::Resource(acp::EmbeddedResource {
933 resource: acp::EmbeddedResourceResource::TextResourceContents(resource),
934 ..
935 }) => {
936 if let Some(mention_uri) = MentionUri::parse(&resource.uri).log_err() {
937 let start = text.len();
938 write!(&mut text, "{}", mention_uri.as_link()).ok();
939 let end = text.len();
940 mentions.push((start..end, mention_uri, resource.text));
941 }
942 }
943 acp::ContentBlock::Image(content) => {
944 let start = text.len();
945 text.push_str("image");
946 let end = text.len();
947 images.push((start..end, content));
948 }
949 acp::ContentBlock::Audio(_)
950 | acp::ContentBlock::Resource(_)
951 | acp::ContentBlock::ResourceLink(_) => {}
952 }
953 }
954
955 let snapshot = self.editor.update(cx, |editor, cx| {
956 editor.set_text(text, window, cx);
957 editor.buffer().read(cx).snapshot(cx)
958 });
959
960 for (range, mention_uri, text) in mentions {
961 let anchor = snapshot.anchor_before(range.start);
962 let crease_id = crate::context_picker::insert_crease_for_mention(
963 anchor.excerpt_id,
964 anchor.text_anchor,
965 range.end - range.start,
966 mention_uri.name().into(),
967 mention_uri.icon_path(cx),
968 self.editor.clone(),
969 window,
970 cx,
971 );
972
973 if let Some(crease_id) = crease_id {
974 self.mention_set.insert_uri(crease_id, mention_uri.clone());
975 }
976
977 match mention_uri {
978 MentionUri::Thread { id, .. } => {
979 self.mention_set
980 .insert_thread(id, Task::ready(Ok(text.into())).shared());
981 }
982 MentionUri::TextThread { path, .. } => {
983 self.mention_set
984 .insert_text_thread(path, Task::ready(Ok(text)).shared());
985 }
986 MentionUri::Fetch { url } => {
987 self.mention_set
988 .add_fetch_result(url, Task::ready(Ok(text)).shared());
989 }
990 MentionUri::Directory { abs_path } => {
991 let task = Task::ready(Ok(text)).shared();
992 self.mention_set.directories.insert(abs_path, task);
993 }
994 MentionUri::File { .. }
995 | MentionUri::Symbol { .. }
996 | MentionUri::Rule { .. }
997 | MentionUri::Selection { .. } => {}
998 }
999 }
1000 for (range, content) in images {
1001 let Some(format) = ImageFormat::from_mime_type(&content.mime_type) else {
1002 continue;
1003 };
1004 let anchor = snapshot.anchor_before(range.start);
1005 let abs_path = content
1006 .uri
1007 .as_ref()
1008 .and_then(|uri| uri.strip_prefix("file://").map(|s| Path::new(s).into()));
1009
1010 let name = content
1011 .uri
1012 .as_ref()
1013 .and_then(|uri| {
1014 uri.strip_prefix("file://")
1015 .and_then(|path| Path::new(path).file_name())
1016 })
1017 .map(|name| name.to_string_lossy().to_string())
1018 .unwrap_or("Image".to_owned());
1019 let crease_id = crate::context_picker::insert_crease_for_mention(
1020 anchor.excerpt_id,
1021 anchor.text_anchor,
1022 range.end - range.start,
1023 name.into(),
1024 IconName::Image.path().into(),
1025 self.editor.clone(),
1026 window,
1027 cx,
1028 );
1029 let data: SharedString = content.data.to_string().into();
1030
1031 if let Some(crease_id) = crease_id {
1032 self.mention_set.insert_image(
1033 crease_id,
1034 Task::ready(Ok(MentionImage {
1035 abs_path,
1036 data,
1037 format,
1038 }))
1039 .shared(),
1040 );
1041 }
1042 }
1043 cx.notify();
1044 }
1045
1046 fn highlight_slash_command(
1047 &mut self,
1048 semantics_provider: Rc<SlashCommandSemanticsProvider>,
1049 editor: Entity<Editor>,
1050 window: &mut Window,
1051 cx: &mut Context<Self>,
1052 ) {
1053 struct InvalidSlashCommand;
1054
1055 self._parse_slash_command_task = cx.spawn_in(window, async move |_, cx| {
1056 cx.background_executor()
1057 .timer(PARSE_SLASH_COMMAND_DEBOUNCE)
1058 .await;
1059 editor
1060 .update_in(cx, |editor, window, cx| {
1061 let snapshot = editor.snapshot(window, cx);
1062 let range = parse_slash_command(&editor.text(cx));
1063 semantics_provider.range.set(range);
1064 if let Some((start, end)) = range {
1065 editor.highlight_text::<InvalidSlashCommand>(
1066 vec![
1067 snapshot.buffer_snapshot.anchor_after(start)
1068 ..snapshot.buffer_snapshot.anchor_before(end),
1069 ],
1070 HighlightStyle {
1071 underline: Some(UnderlineStyle {
1072 thickness: px(1.),
1073 color: Some(gpui::red()),
1074 wavy: true,
1075 }),
1076 ..Default::default()
1077 },
1078 cx,
1079 );
1080 } else {
1081 editor.clear_highlights::<InvalidSlashCommand>(cx);
1082 }
1083 })
1084 .ok();
1085 })
1086 }
1087
1088 #[cfg(test)]
1089 pub fn set_text(&mut self, text: &str, window: &mut Window, cx: &mut Context<Self>) {
1090 self.editor.update(cx, |editor, cx| {
1091 editor.set_text(text, window, cx);
1092 });
1093 }
1094
1095 #[cfg(test)]
1096 pub fn text(&self, cx: &App) -> String {
1097 self.editor.read(cx).text(cx)
1098 }
1099}
1100
1101struct DirectoryContents(Arc<[(Arc<Path>, PathBuf, String)]>);
1102
1103impl Display for DirectoryContents {
1104 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1105 for (_relative_path, full_path, content) in self.0.iter() {
1106 let fence = codeblock_fence_for_path(Some(full_path), None);
1107 write!(f, "\n{fence}\n{content}\n```")?;
1108 }
1109 Ok(())
1110 }
1111}
1112
1113impl Focusable for MessageEditor {
1114 fn focus_handle(&self, cx: &App) -> FocusHandle {
1115 self.editor.focus_handle(cx)
1116 }
1117}
1118
1119impl Render for MessageEditor {
1120 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1121 div()
1122 .key_context("MessageEditor")
1123 .on_action(cx.listener(Self::send))
1124 .on_action(cx.listener(Self::cancel))
1125 .capture_action(cx.listener(Self::paste))
1126 .flex_1()
1127 .child({
1128 let settings = ThemeSettings::get_global(cx);
1129 let font_size = TextSize::Small
1130 .rems(cx)
1131 .to_pixels(settings.agent_font_size(cx));
1132 let line_height = settings.buffer_line_height.value() * font_size;
1133
1134 let text_style = TextStyle {
1135 color: cx.theme().colors().text,
1136 font_family: settings.buffer_font.family.clone(),
1137 font_fallbacks: settings.buffer_font.fallbacks.clone(),
1138 font_features: settings.buffer_font.features.clone(),
1139 font_size: font_size.into(),
1140 line_height: line_height.into(),
1141 ..Default::default()
1142 };
1143
1144 EditorElement::new(
1145 &self.editor,
1146 EditorStyle {
1147 background: cx.theme().colors().editor_background,
1148 local_player: cx.theme().players().local(),
1149 text: text_style,
1150 syntax: cx.theme().syntax().clone(),
1151 ..Default::default()
1152 },
1153 )
1154 })
1155 }
1156}
1157
1158pub(crate) fn insert_crease_for_image(
1159 excerpt_id: ExcerptId,
1160 anchor: text::Anchor,
1161 content_len: usize,
1162 abs_path: Option<Arc<Path>>,
1163 image: Shared<Task<Result<Arc<Image>, String>>>,
1164 editor: Entity<Editor>,
1165 window: &mut Window,
1166 cx: &mut App,
1167) -> Option<CreaseId> {
1168 let crease_label = abs_path
1169 .as_ref()
1170 .and_then(|path| path.file_name())
1171 .map(|name| name.to_string_lossy().to_string().into())
1172 .unwrap_or(SharedString::from("Image"));
1173
1174 editor.update(cx, |editor, cx| {
1175 let snapshot = editor.buffer().read(cx).snapshot(cx);
1176
1177 let start = snapshot.anchor_in_excerpt(excerpt_id, anchor)?;
1178
1179 let start = start.bias_right(&snapshot);
1180 let end = snapshot.anchor_before(start.to_offset(&snapshot) + content_len);
1181
1182 let placeholder = FoldPlaceholder {
1183 render: render_image_fold_icon_button(crease_label, image, cx.weak_entity()),
1184 merge_adjacent: false,
1185 ..Default::default()
1186 };
1187
1188 let crease = Crease::Inline {
1189 range: start..end,
1190 placeholder,
1191 render_toggle: None,
1192 render_trailer: None,
1193 metadata: None,
1194 };
1195
1196 let ids = editor.insert_creases(vec![crease.clone()], cx);
1197 editor.fold_creases(vec![crease], false, window, cx);
1198
1199 Some(ids[0])
1200 })
1201}
1202
1203fn render_image_fold_icon_button(
1204 label: SharedString,
1205 image_task: Shared<Task<Result<Arc<Image>, String>>>,
1206 editor: WeakEntity<Editor>,
1207) -> Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement> {
1208 Arc::new({
1209 let image_task = image_task.clone();
1210 move |fold_id, fold_range, cx| {
1211 let is_in_text_selection = editor
1212 .update(cx, |editor, cx| editor.is_range_selected(&fold_range, cx))
1213 .unwrap_or_default();
1214
1215 ButtonLike::new(fold_id)
1216 .style(ButtonStyle::Filled)
1217 .selected_style(ButtonStyle::Tinted(TintColor::Accent))
1218 .toggle_state(is_in_text_selection)
1219 .child(
1220 h_flex()
1221 .gap_1()
1222 .child(
1223 Icon::new(IconName::Image)
1224 .size(IconSize::XSmall)
1225 .color(Color::Muted),
1226 )
1227 .child(
1228 Label::new(label.clone())
1229 .size(LabelSize::Small)
1230 .buffer_font(cx)
1231 .single_line(),
1232 ),
1233 )
1234 .hoverable_tooltip({
1235 let image_task = image_task.clone();
1236 move |_, cx| {
1237 let image = image_task.peek().cloned().transpose().ok().flatten();
1238 let image_task = image_task.clone();
1239 cx.new::<ImageHover>(|cx| ImageHover {
1240 image,
1241 _task: cx.spawn(async move |this, cx| {
1242 if let Ok(image) = image_task.clone().await {
1243 this.update(cx, |this, cx| {
1244 if this.image.replace(image).is_none() {
1245 cx.notify();
1246 }
1247 })
1248 .ok();
1249 }
1250 }),
1251 })
1252 .into()
1253 }
1254 })
1255 .into_any_element()
1256 }
1257 })
1258}
1259
1260struct ImageHover {
1261 image: Option<Arc<Image>>,
1262 _task: Task<()>,
1263}
1264
1265impl Render for ImageHover {
1266 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
1267 if let Some(image) = self.image.clone() {
1268 gpui::img(image).max_w_96().max_h_96().into_any_element()
1269 } else {
1270 gpui::Empty.into_any_element()
1271 }
1272 }
1273}
1274
1275#[derive(Debug, Eq, PartialEq)]
1276pub enum Mention {
1277 Text { uri: MentionUri, content: String },
1278 Image(MentionImage),
1279}
1280
1281#[derive(Clone, Debug, Eq, PartialEq)]
1282pub struct MentionImage {
1283 pub abs_path: Option<PathBuf>,
1284 pub data: SharedString,
1285 pub format: ImageFormat,
1286}
1287
1288#[derive(Default)]
1289pub struct MentionSet {
1290 uri_by_crease_id: HashMap<CreaseId, MentionUri>,
1291 fetch_results: HashMap<Url, Shared<Task<Result<String, String>>>>,
1292 images: HashMap<CreaseId, Shared<Task<Result<MentionImage, String>>>>,
1293 thread_summaries: HashMap<ThreadId, Shared<Task<Result<SharedString, String>>>>,
1294 text_thread_summaries: HashMap<PathBuf, Shared<Task<Result<String, String>>>>,
1295 directories: HashMap<PathBuf, Shared<Task<Result<String, String>>>>,
1296}
1297
1298impl MentionSet {
1299 pub fn insert_uri(&mut self, crease_id: CreaseId, uri: MentionUri) {
1300 self.uri_by_crease_id.insert(crease_id, uri);
1301 }
1302
1303 pub fn add_fetch_result(&mut self, url: Url, content: Shared<Task<Result<String, String>>>) {
1304 self.fetch_results.insert(url, content);
1305 }
1306
1307 pub fn insert_image(
1308 &mut self,
1309 crease_id: CreaseId,
1310 task: Shared<Task<Result<MentionImage, String>>>,
1311 ) {
1312 self.images.insert(crease_id, task);
1313 }
1314
1315 fn insert_thread(&mut self, id: ThreadId, task: Shared<Task<Result<SharedString, String>>>) {
1316 self.thread_summaries.insert(id, task);
1317 }
1318
1319 fn insert_text_thread(&mut self, path: PathBuf, task: Shared<Task<Result<String, String>>>) {
1320 self.text_thread_summaries.insert(path, task);
1321 }
1322
1323 pub fn drain(&mut self) -> impl Iterator<Item = CreaseId> {
1324 self.fetch_results.clear();
1325 self.thread_summaries.clear();
1326 self.text_thread_summaries.clear();
1327 self.uri_by_crease_id
1328 .drain()
1329 .map(|(id, _)| id)
1330 .chain(self.images.drain().map(|(id, _)| id))
1331 }
1332
1333 pub fn contents(
1334 &self,
1335 project: Entity<Project>,
1336 thread_store: Entity<ThreadStore>,
1337 _window: &mut Window,
1338 cx: &mut App,
1339 ) -> Task<Result<HashMap<CreaseId, Mention>>> {
1340 let mut processed_image_creases = HashSet::default();
1341
1342 let mut contents = self
1343 .uri_by_crease_id
1344 .iter()
1345 .map(|(&crease_id, uri)| {
1346 match uri {
1347 MentionUri::File { abs_path, .. } => {
1348 let uri = uri.clone();
1349 let abs_path = abs_path.to_path_buf();
1350
1351 if let Some(task) = self.images.get(&crease_id).cloned() {
1352 processed_image_creases.insert(crease_id);
1353 return cx.spawn(async move |_| {
1354 let image = task.await.map_err(|e| anyhow!("{e}"))?;
1355 anyhow::Ok((crease_id, Mention::Image(image)))
1356 });
1357 }
1358
1359 let buffer_task = project.update(cx, |project, cx| {
1360 let path = project
1361 .find_project_path(abs_path, cx)
1362 .context("Failed to find project path")?;
1363 anyhow::Ok(project.open_buffer(path, cx))
1364 });
1365 cx.spawn(async move |cx| {
1366 let buffer = buffer_task?.await?;
1367 let content = buffer.read_with(cx, |buffer, _cx| buffer.text())?;
1368
1369 anyhow::Ok((crease_id, Mention::Text { uri, content }))
1370 })
1371 }
1372 MentionUri::Directory { abs_path } => {
1373 let Some(content) = self.directories.get(abs_path).cloned() else {
1374 return Task::ready(Err(anyhow!("missing directory load task")));
1375 };
1376 let uri = uri.clone();
1377 cx.spawn(async move |_| {
1378 Ok((
1379 crease_id,
1380 Mention::Text {
1381 uri,
1382 content: content
1383 .await
1384 .map_err(|e| anyhow::anyhow!("{e}"))?
1385 .to_string(),
1386 },
1387 ))
1388 })
1389 }
1390 MentionUri::Symbol {
1391 path, line_range, ..
1392 }
1393 | MentionUri::Selection {
1394 path, line_range, ..
1395 } => {
1396 let uri = uri.clone();
1397 let path_buf = path.clone();
1398 let line_range = line_range.clone();
1399
1400 let buffer_task = project.update(cx, |project, cx| {
1401 let path = project
1402 .find_project_path(&path_buf, cx)
1403 .context("Failed to find project path")?;
1404 anyhow::Ok(project.open_buffer(path, cx))
1405 });
1406
1407 cx.spawn(async move |cx| {
1408 let buffer = buffer_task?.await?;
1409 let content = buffer.read_with(cx, |buffer, _cx| {
1410 buffer
1411 .text_for_range(
1412 Point::new(line_range.start, 0)
1413 ..Point::new(
1414 line_range.end,
1415 buffer.line_len(line_range.end),
1416 ),
1417 )
1418 .collect()
1419 })?;
1420
1421 anyhow::Ok((crease_id, Mention::Text { uri, content }))
1422 })
1423 }
1424 MentionUri::Thread { id, .. } => {
1425 let Some(content) = self.thread_summaries.get(id).cloned() else {
1426 return Task::ready(Err(anyhow!("missing thread summary")));
1427 };
1428 let uri = uri.clone();
1429 cx.spawn(async move |_| {
1430 Ok((
1431 crease_id,
1432 Mention::Text {
1433 uri,
1434 content: content
1435 .await
1436 .map_err(|e| anyhow::anyhow!("{e}"))?
1437 .to_string(),
1438 },
1439 ))
1440 })
1441 }
1442 MentionUri::TextThread { path, .. } => {
1443 let Some(content) = self.text_thread_summaries.get(path).cloned() else {
1444 return Task::ready(Err(anyhow!("missing text thread summary")));
1445 };
1446 let uri = uri.clone();
1447 cx.spawn(async move |_| {
1448 Ok((
1449 crease_id,
1450 Mention::Text {
1451 uri,
1452 content: content
1453 .await
1454 .map_err(|e| anyhow::anyhow!("{e}"))?
1455 .to_string(),
1456 },
1457 ))
1458 })
1459 }
1460 MentionUri::Rule { id: prompt_id, .. } => {
1461 let Some(prompt_store) = thread_store.read(cx).prompt_store().clone()
1462 else {
1463 return Task::ready(Err(anyhow!("missing prompt store")));
1464 };
1465 let text_task = prompt_store.read(cx).load(*prompt_id, cx);
1466 let uri = uri.clone();
1467 cx.spawn(async move |_| {
1468 // TODO: report load errors instead of just logging
1469 let text = text_task.await?;
1470 anyhow::Ok((crease_id, Mention::Text { uri, content: text }))
1471 })
1472 }
1473 MentionUri::Fetch { url } => {
1474 let Some(content) = self.fetch_results.get(url).cloned() else {
1475 return Task::ready(Err(anyhow!("missing fetch result")));
1476 };
1477 let uri = uri.clone();
1478 cx.spawn(async move |_| {
1479 Ok((
1480 crease_id,
1481 Mention::Text {
1482 uri,
1483 content: content.await.map_err(|e| anyhow::anyhow!("{e}"))?,
1484 },
1485 ))
1486 })
1487 }
1488 }
1489 })
1490 .collect::<Vec<_>>();
1491
1492 // Handle images that didn't have a mention URI (because they were added by the paste handler).
1493 contents.extend(self.images.iter().filter_map(|(crease_id, image)| {
1494 if processed_image_creases.contains(crease_id) {
1495 return None;
1496 }
1497 let crease_id = *crease_id;
1498 let image = image.clone();
1499 Some(cx.spawn(async move |_| {
1500 Ok((
1501 crease_id,
1502 Mention::Image(image.await.map_err(|e| anyhow::anyhow!("{e}"))?),
1503 ))
1504 }))
1505 }));
1506
1507 cx.spawn(async move |_cx| {
1508 let contents = try_join_all(contents).await?.into_iter().collect();
1509 anyhow::Ok(contents)
1510 })
1511 }
1512}
1513
1514struct SlashCommandSemanticsProvider {
1515 range: Cell<Option<(usize, usize)>>,
1516}
1517
1518impl SemanticsProvider for SlashCommandSemanticsProvider {
1519 fn hover(
1520 &self,
1521 buffer: &Entity<Buffer>,
1522 position: text::Anchor,
1523 cx: &mut App,
1524 ) -> Option<Task<Vec<project::Hover>>> {
1525 let snapshot = buffer.read(cx).snapshot();
1526 let offset = position.to_offset(&snapshot);
1527 let (start, end) = self.range.get()?;
1528 if !(start..end).contains(&offset) {
1529 return None;
1530 }
1531 let range = snapshot.anchor_after(start)..snapshot.anchor_after(end);
1532 return Some(Task::ready(vec![project::Hover {
1533 contents: vec![project::HoverBlock {
1534 text: "Slash commands are not supported".into(),
1535 kind: project::HoverBlockKind::PlainText,
1536 }],
1537 range: Some(range),
1538 language: None,
1539 }]));
1540 }
1541
1542 fn inline_values(
1543 &self,
1544 _buffer_handle: Entity<Buffer>,
1545 _range: Range<text::Anchor>,
1546 _cx: &mut App,
1547 ) -> Option<Task<anyhow::Result<Vec<project::InlayHint>>>> {
1548 None
1549 }
1550
1551 fn inlay_hints(
1552 &self,
1553 _buffer_handle: Entity<Buffer>,
1554 _range: Range<text::Anchor>,
1555 _cx: &mut App,
1556 ) -> Option<Task<anyhow::Result<Vec<project::InlayHint>>>> {
1557 None
1558 }
1559
1560 fn resolve_inlay_hint(
1561 &self,
1562 _hint: project::InlayHint,
1563 _buffer_handle: Entity<Buffer>,
1564 _server_id: lsp::LanguageServerId,
1565 _cx: &mut App,
1566 ) -> Option<Task<anyhow::Result<project::InlayHint>>> {
1567 None
1568 }
1569
1570 fn supports_inlay_hints(&self, _buffer: &Entity<Buffer>, _cx: &mut App) -> bool {
1571 false
1572 }
1573
1574 fn document_highlights(
1575 &self,
1576 _buffer: &Entity<Buffer>,
1577 _position: text::Anchor,
1578 _cx: &mut App,
1579 ) -> Option<Task<Result<Vec<project::DocumentHighlight>>>> {
1580 None
1581 }
1582
1583 fn definitions(
1584 &self,
1585 _buffer: &Entity<Buffer>,
1586 _position: text::Anchor,
1587 _kind: editor::GotoDefinitionKind,
1588 _cx: &mut App,
1589 ) -> Option<Task<Result<Vec<project::LocationLink>>>> {
1590 None
1591 }
1592
1593 fn range_for_rename(
1594 &self,
1595 _buffer: &Entity<Buffer>,
1596 _position: text::Anchor,
1597 _cx: &mut App,
1598 ) -> Option<Task<Result<Option<Range<text::Anchor>>>>> {
1599 None
1600 }
1601
1602 fn perform_rename(
1603 &self,
1604 _buffer: &Entity<Buffer>,
1605 _position: text::Anchor,
1606 _new_name: String,
1607 _cx: &mut App,
1608 ) -> Option<Task<Result<project::ProjectTransaction>>> {
1609 None
1610 }
1611}
1612
1613fn parse_slash_command(text: &str) -> Option<(usize, usize)> {
1614 if let Some(remainder) = text.strip_prefix('/') {
1615 let pos = remainder
1616 .find(char::is_whitespace)
1617 .unwrap_or(remainder.len());
1618 let command = &remainder[..pos];
1619 if !command.is_empty() && command.chars().all(char::is_alphanumeric) {
1620 return Some((0, 1 + command.len()));
1621 }
1622 }
1623 None
1624}
1625
1626#[cfg(test)]
1627mod tests {
1628 use std::{ops::Range, path::Path, sync::Arc};
1629
1630 use agent::{TextThreadStore, ThreadStore};
1631 use agent_client_protocol as acp;
1632 use editor::{AnchorRangeExt as _, Editor, EditorMode};
1633 use fs::FakeFs;
1634 use futures::StreamExt as _;
1635 use gpui::{
1636 AppContext, Entity, EventEmitter, FocusHandle, Focusable, TestAppContext, VisualTestContext,
1637 };
1638 use lsp::{CompletionContext, CompletionTriggerKind};
1639 use project::{CompletionIntent, Project, ProjectPath};
1640 use serde_json::json;
1641 use text::Point;
1642 use ui::{App, Context, IntoElement, Render, SharedString, Window};
1643 use util::path;
1644 use workspace::{AppState, Item, Workspace};
1645
1646 use crate::acp::{
1647 message_editor::{Mention, MessageEditor},
1648 thread_view::tests::init_test,
1649 };
1650
1651 #[gpui::test]
1652 async fn test_at_mention_removal(cx: &mut TestAppContext) {
1653 init_test(cx);
1654
1655 let fs = FakeFs::new(cx.executor());
1656 fs.insert_tree("/project", json!({"file": ""})).await;
1657 let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;
1658
1659 let (workspace, cx) =
1660 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
1661
1662 let thread_store = cx.new(|cx| ThreadStore::fake(project.clone(), cx));
1663 let text_thread_store = cx.new(|cx| TextThreadStore::fake(project.clone(), cx));
1664
1665 let message_editor = cx.update(|window, cx| {
1666 cx.new(|cx| {
1667 MessageEditor::new(
1668 workspace.downgrade(),
1669 project.clone(),
1670 thread_store.clone(),
1671 text_thread_store.clone(),
1672 "Test",
1673 false,
1674 EditorMode::AutoHeight {
1675 min_lines: 1,
1676 max_lines: None,
1677 },
1678 window,
1679 cx,
1680 )
1681 })
1682 });
1683 let editor = message_editor.update(cx, |message_editor, _| message_editor.editor.clone());
1684
1685 cx.run_until_parked();
1686
1687 let excerpt_id = editor.update(cx, |editor, cx| {
1688 editor
1689 .buffer()
1690 .read(cx)
1691 .excerpt_ids()
1692 .into_iter()
1693 .next()
1694 .unwrap()
1695 });
1696 let completions = editor.update_in(cx, |editor, window, cx| {
1697 editor.set_text("Hello @file ", window, cx);
1698 let buffer = editor.buffer().read(cx).as_singleton().unwrap();
1699 let completion_provider = editor.completion_provider().unwrap();
1700 completion_provider.completions(
1701 excerpt_id,
1702 &buffer,
1703 text::Anchor::MAX,
1704 CompletionContext {
1705 trigger_kind: CompletionTriggerKind::TRIGGER_CHARACTER,
1706 trigger_character: Some("@".into()),
1707 },
1708 window,
1709 cx,
1710 )
1711 });
1712 let [_, completion]: [_; 2] = completions
1713 .await
1714 .unwrap()
1715 .into_iter()
1716 .flat_map(|response| response.completions)
1717 .collect::<Vec<_>>()
1718 .try_into()
1719 .unwrap();
1720
1721 editor.update_in(cx, |editor, window, cx| {
1722 let snapshot = editor.buffer().read(cx).snapshot(cx);
1723 let start = snapshot
1724 .anchor_in_excerpt(excerpt_id, completion.replace_range.start)
1725 .unwrap();
1726 let end = snapshot
1727 .anchor_in_excerpt(excerpt_id, completion.replace_range.end)
1728 .unwrap();
1729 editor.edit([(start..end, completion.new_text)], cx);
1730 (completion.confirm.unwrap())(CompletionIntent::Complete, window, cx);
1731 });
1732
1733 cx.run_until_parked();
1734
1735 // Backspace over the inserted crease (and the following space).
1736 editor.update_in(cx, |editor, window, cx| {
1737 editor.backspace(&Default::default(), window, cx);
1738 editor.backspace(&Default::default(), window, cx);
1739 });
1740
1741 let content = message_editor
1742 .update_in(cx, |message_editor, window, cx| {
1743 message_editor.contents(window, cx)
1744 })
1745 .await
1746 .unwrap();
1747
1748 // We don't send a resource link for the deleted crease.
1749 pretty_assertions::assert_matches!(content.as_slice(), [acp::ContentBlock::Text { .. }]);
1750 }
1751
1752 struct MessageEditorItem(Entity<MessageEditor>);
1753
1754 impl Item for MessageEditorItem {
1755 type Event = ();
1756
1757 fn include_in_nav_history() -> bool {
1758 false
1759 }
1760
1761 fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString {
1762 "Test".into()
1763 }
1764 }
1765
1766 impl EventEmitter<()> for MessageEditorItem {}
1767
1768 impl Focusable for MessageEditorItem {
1769 fn focus_handle(&self, cx: &App) -> FocusHandle {
1770 self.0.read(cx).focus_handle(cx).clone()
1771 }
1772 }
1773
1774 impl Render for MessageEditorItem {
1775 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
1776 self.0.clone().into_any_element()
1777 }
1778 }
1779
1780 #[gpui::test]
1781 async fn test_context_completion_provider(cx: &mut TestAppContext) {
1782 init_test(cx);
1783
1784 let app_state = cx.update(AppState::test);
1785
1786 cx.update(|cx| {
1787 language::init(cx);
1788 editor::init(cx);
1789 workspace::init(app_state.clone(), cx);
1790 Project::init_settings(cx);
1791 });
1792
1793 app_state
1794 .fs
1795 .as_fake()
1796 .insert_tree(
1797 path!("/dir"),
1798 json!({
1799 "editor": "",
1800 "a": {
1801 "one.txt": "1",
1802 "two.txt": "2",
1803 "three.txt": "3",
1804 "four.txt": "4"
1805 },
1806 "b": {
1807 "five.txt": "5",
1808 "six.txt": "6",
1809 "seven.txt": "7",
1810 "eight.txt": "8",
1811 }
1812 }),
1813 )
1814 .await;
1815
1816 let project = Project::test(app_state.fs.clone(), [path!("/dir").as_ref()], cx).await;
1817 let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
1818 let workspace = window.root(cx).unwrap();
1819
1820 let worktree = project.update(cx, |project, cx| {
1821 let mut worktrees = project.worktrees(cx).collect::<Vec<_>>();
1822 assert_eq!(worktrees.len(), 1);
1823 worktrees.pop().unwrap()
1824 });
1825 let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id());
1826
1827 let mut cx = VisualTestContext::from_window(*window, cx);
1828
1829 let paths = vec![
1830 path!("a/one.txt"),
1831 path!("a/two.txt"),
1832 path!("a/three.txt"),
1833 path!("a/four.txt"),
1834 path!("b/five.txt"),
1835 path!("b/six.txt"),
1836 path!("b/seven.txt"),
1837 path!("b/eight.txt"),
1838 ];
1839
1840 let mut opened_editors = Vec::new();
1841 for path in paths {
1842 let buffer = workspace
1843 .update_in(&mut cx, |workspace, window, cx| {
1844 workspace.open_path(
1845 ProjectPath {
1846 worktree_id,
1847 path: Path::new(path).into(),
1848 },
1849 None,
1850 false,
1851 window,
1852 cx,
1853 )
1854 })
1855 .await
1856 .unwrap();
1857 opened_editors.push(buffer);
1858 }
1859
1860 let thread_store = cx.new(|cx| ThreadStore::fake(project.clone(), cx));
1861 let text_thread_store = cx.new(|cx| TextThreadStore::fake(project.clone(), cx));
1862
1863 let (message_editor, editor) = workspace.update_in(&mut cx, |workspace, window, cx| {
1864 let workspace_handle = cx.weak_entity();
1865 let message_editor = cx.new(|cx| {
1866 MessageEditor::new(
1867 workspace_handle,
1868 project.clone(),
1869 thread_store.clone(),
1870 text_thread_store.clone(),
1871 "Test",
1872 false,
1873 EditorMode::AutoHeight {
1874 max_lines: None,
1875 min_lines: 1,
1876 },
1877 window,
1878 cx,
1879 )
1880 });
1881 workspace.active_pane().update(cx, |pane, cx| {
1882 pane.add_item(
1883 Box::new(cx.new(|_| MessageEditorItem(message_editor.clone()))),
1884 true,
1885 true,
1886 None,
1887 window,
1888 cx,
1889 );
1890 });
1891 message_editor.read(cx).focus_handle(cx).focus(window);
1892 let editor = message_editor.read(cx).editor().clone();
1893 (message_editor, editor)
1894 });
1895
1896 cx.simulate_input("Lorem ");
1897
1898 editor.update(&mut cx, |editor, cx| {
1899 assert_eq!(editor.text(cx), "Lorem ");
1900 assert!(!editor.has_visible_completions_menu());
1901 });
1902
1903 cx.simulate_input("@");
1904
1905 editor.update(&mut cx, |editor, cx| {
1906 assert_eq!(editor.text(cx), "Lorem @");
1907 assert!(editor.has_visible_completions_menu());
1908 assert_eq!(
1909 current_completion_labels(editor),
1910 &[
1911 "eight.txt dir/b/",
1912 "seven.txt dir/b/",
1913 "six.txt dir/b/",
1914 "five.txt dir/b/",
1915 "Files & Directories",
1916 "Symbols",
1917 "Threads",
1918 "Fetch"
1919 ]
1920 );
1921 });
1922
1923 // Select and confirm "File"
1924 editor.update_in(&mut cx, |editor, window, cx| {
1925 assert!(editor.has_visible_completions_menu());
1926 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
1927 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
1928 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
1929 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
1930 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
1931 });
1932
1933 cx.run_until_parked();
1934
1935 editor.update(&mut cx, |editor, cx| {
1936 assert_eq!(editor.text(cx), "Lorem @file ");
1937 assert!(editor.has_visible_completions_menu());
1938 });
1939
1940 cx.simulate_input("one");
1941
1942 editor.update(&mut cx, |editor, cx| {
1943 assert_eq!(editor.text(cx), "Lorem @file one");
1944 assert!(editor.has_visible_completions_menu());
1945 assert_eq!(current_completion_labels(editor), vec!["one.txt dir/a/"]);
1946 });
1947
1948 editor.update_in(&mut cx, |editor, window, cx| {
1949 assert!(editor.has_visible_completions_menu());
1950 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
1951 });
1952
1953 editor.update(&mut cx, |editor, cx| {
1954 assert_eq!(editor.text(cx), "Lorem [@one.txt](file:///dir/a/one.txt) ");
1955 assert!(!editor.has_visible_completions_menu());
1956 assert_eq!(
1957 fold_ranges(editor, cx),
1958 vec![Point::new(0, 6)..Point::new(0, 39)]
1959 );
1960 });
1961
1962 let contents = message_editor
1963 .update_in(&mut cx, |message_editor, window, cx| {
1964 message_editor.mention_set().contents(
1965 project.clone(),
1966 thread_store.clone(),
1967 window,
1968 cx,
1969 )
1970 })
1971 .await
1972 .unwrap()
1973 .into_values()
1974 .collect::<Vec<_>>();
1975
1976 pretty_assertions::assert_eq!(
1977 contents,
1978 [Mention::Text {
1979 content: "1".into(),
1980 uri: "file:///dir/a/one.txt".parse().unwrap()
1981 }]
1982 );
1983
1984 cx.simulate_input(" ");
1985
1986 editor.update(&mut cx, |editor, cx| {
1987 assert_eq!(editor.text(cx), "Lorem [@one.txt](file:///dir/a/one.txt) ");
1988 assert!(!editor.has_visible_completions_menu());
1989 assert_eq!(
1990 fold_ranges(editor, cx),
1991 vec![Point::new(0, 6)..Point::new(0, 39)]
1992 );
1993 });
1994
1995 cx.simulate_input("Ipsum ");
1996
1997 editor.update(&mut cx, |editor, cx| {
1998 assert_eq!(
1999 editor.text(cx),
2000 "Lorem [@one.txt](file:///dir/a/one.txt) Ipsum ",
2001 );
2002 assert!(!editor.has_visible_completions_menu());
2003 assert_eq!(
2004 fold_ranges(editor, cx),
2005 vec![Point::new(0, 6)..Point::new(0, 39)]
2006 );
2007 });
2008
2009 cx.simulate_input("@file ");
2010
2011 editor.update(&mut cx, |editor, cx| {
2012 assert_eq!(
2013 editor.text(cx),
2014 "Lorem [@one.txt](file:///dir/a/one.txt) Ipsum @file ",
2015 );
2016 assert!(editor.has_visible_completions_menu());
2017 assert_eq!(
2018 fold_ranges(editor, cx),
2019 vec![Point::new(0, 6)..Point::new(0, 39)]
2020 );
2021 });
2022
2023 editor.update_in(&mut cx, |editor, window, cx| {
2024 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2025 });
2026
2027 cx.run_until_parked();
2028
2029 let contents = message_editor
2030 .update_in(&mut cx, |message_editor, window, cx| {
2031 message_editor.mention_set().contents(
2032 project.clone(),
2033 thread_store.clone(),
2034 window,
2035 cx,
2036 )
2037 })
2038 .await
2039 .unwrap()
2040 .into_values()
2041 .collect::<Vec<_>>();
2042
2043 assert_eq!(contents.len(), 2);
2044 pretty_assertions::assert_eq!(
2045 contents[1],
2046 Mention::Text {
2047 content: "8".to_string(),
2048 uri: "file:///dir/b/eight.txt".parse().unwrap(),
2049 }
2050 );
2051
2052 editor.update(&mut cx, |editor, cx| {
2053 assert_eq!(
2054 editor.text(cx),
2055 "Lorem [@one.txt](file:///dir/a/one.txt) Ipsum [@eight.txt](file:///dir/b/eight.txt) "
2056 );
2057 assert!(!editor.has_visible_completions_menu());
2058 assert_eq!(
2059 fold_ranges(editor, cx),
2060 vec![
2061 Point::new(0, 6)..Point::new(0, 39),
2062 Point::new(0, 47)..Point::new(0, 84)
2063 ]
2064 );
2065 });
2066
2067 let plain_text_language = Arc::new(language::Language::new(
2068 language::LanguageConfig {
2069 name: "Plain Text".into(),
2070 matcher: language::LanguageMatcher {
2071 path_suffixes: vec!["txt".to_string()],
2072 ..Default::default()
2073 },
2074 ..Default::default()
2075 },
2076 None,
2077 ));
2078
2079 // Register the language and fake LSP
2080 let language_registry = project.read_with(&cx, |project, _| project.languages().clone());
2081 language_registry.add(plain_text_language);
2082
2083 let mut fake_language_servers = language_registry.register_fake_lsp(
2084 "Plain Text",
2085 language::FakeLspAdapter {
2086 capabilities: lsp::ServerCapabilities {
2087 workspace_symbol_provider: Some(lsp::OneOf::Left(true)),
2088 ..Default::default()
2089 },
2090 ..Default::default()
2091 },
2092 );
2093
2094 // Open the buffer to trigger LSP initialization
2095 let buffer = project
2096 .update(&mut cx, |project, cx| {
2097 project.open_local_buffer(path!("/dir/a/one.txt"), cx)
2098 })
2099 .await
2100 .unwrap();
2101
2102 // Register the buffer with language servers
2103 let _handle = project.update(&mut cx, |project, cx| {
2104 project.register_buffer_with_language_servers(&buffer, cx)
2105 });
2106
2107 cx.run_until_parked();
2108
2109 let fake_language_server = fake_language_servers.next().await.unwrap();
2110 fake_language_server.set_request_handler::<lsp::WorkspaceSymbolRequest, _, _>(
2111 |_, _| async move {
2112 Ok(Some(lsp::WorkspaceSymbolResponse::Flat(vec![
2113 #[allow(deprecated)]
2114 lsp::SymbolInformation {
2115 name: "MySymbol".into(),
2116 location: lsp::Location {
2117 uri: lsp::Url::from_file_path(path!("/dir/a/one.txt")).unwrap(),
2118 range: lsp::Range::new(
2119 lsp::Position::new(0, 0),
2120 lsp::Position::new(0, 1),
2121 ),
2122 },
2123 kind: lsp::SymbolKind::CONSTANT,
2124 tags: None,
2125 container_name: None,
2126 deprecated: None,
2127 },
2128 ])))
2129 },
2130 );
2131
2132 cx.simulate_input("@symbol ");
2133
2134 editor.update(&mut cx, |editor, cx| {
2135 assert_eq!(
2136 editor.text(cx),
2137 "Lorem [@one.txt](file:///dir/a/one.txt) Ipsum [@eight.txt](file:///dir/b/eight.txt) @symbol "
2138 );
2139 assert!(editor.has_visible_completions_menu());
2140 assert_eq!(
2141 current_completion_labels(editor),
2142 &[
2143 "MySymbol",
2144 ]
2145 );
2146 });
2147
2148 editor.update_in(&mut cx, |editor, window, cx| {
2149 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2150 });
2151
2152 let contents = message_editor
2153 .update_in(&mut cx, |message_editor, window, cx| {
2154 message_editor
2155 .mention_set()
2156 .contents(project.clone(), thread_store, window, cx)
2157 })
2158 .await
2159 .unwrap()
2160 .into_values()
2161 .collect::<Vec<_>>();
2162
2163 assert_eq!(contents.len(), 3);
2164 pretty_assertions::assert_eq!(
2165 contents[2],
2166 Mention::Text {
2167 content: "1".into(),
2168 uri: "file:///dir/a/one.txt?symbol=MySymbol#L1:1"
2169 .parse()
2170 .unwrap(),
2171 }
2172 );
2173
2174 cx.run_until_parked();
2175
2176 editor.read_with(&mut cx, |editor, cx| {
2177 assert_eq!(
2178 editor.text(cx),
2179 "Lorem [@one.txt](file:///dir/a/one.txt) Ipsum [@eight.txt](file:///dir/b/eight.txt) [@MySymbol](file:///dir/a/one.txt?symbol=MySymbol#L1:1) "
2180 );
2181 });
2182 }
2183
2184 fn fold_ranges(editor: &Editor, cx: &mut App) -> Vec<Range<Point>> {
2185 let snapshot = editor.buffer().read(cx).snapshot(cx);
2186 editor.display_map.update(cx, |display_map, cx| {
2187 display_map
2188 .snapshot(cx)
2189 .folds_in_range(0..snapshot.len())
2190 .map(|fold| fold.range.to_point(&snapshot))
2191 .collect()
2192 })
2193 }
2194
2195 fn current_completion_labels(editor: &Editor) -> Vec<String> {
2196 let completions = editor.current_completions().expect("Missing completions");
2197 completions
2198 .into_iter()
2199 .map(|completion| completion.label.text.to_string())
2200 .collect::<Vec<_>>()
2201 }
2202}