1use crate::{
2 acp::completion_provider::{ContextPickerCompletionProvider, SlashCommandCompletion},
3 context_picker::{ContextPickerAction, fetch_context_picker::fetch_url_content},
4};
5use acp_thread::{MentionUri, selection_name};
6use agent_client_protocol as acp;
7use agent_servers::{AgentServer, AgentServerDelegate};
8use agent2::HistoryStore;
9use anyhow::{Result, anyhow};
10use assistant_slash_commands::codeblock_fence_for_path;
11use assistant_tool::outline;
12use collections::{HashMap, HashSet};
13use editor::{
14 Addon, Anchor, AnchorRangeExt, ContextMenuOptions, ContextMenuPlacement, Editor, EditorElement,
15 EditorEvent, EditorMode, EditorSnapshot, EditorStyle, ExcerptId, FoldPlaceholder, InlayId,
16 MultiBuffer, ToOffset,
17 actions::Paste,
18 display_map::{Crease, CreaseId, FoldId, Inlay},
19};
20use futures::{
21 FutureExt as _,
22 future::{Shared, join_all},
23};
24use gpui::{
25 Animation, AnimationExt as _, AppContext, ClipboardEntry, Context, Entity, EntityId,
26 EventEmitter, FocusHandle, Focusable, Image, ImageFormat, Img, KeyContext, SharedString,
27 Subscription, Task, TextStyle, WeakEntity, pulsating_between,
28};
29use language::{Buffer, Language, language_settings::InlayHintKind};
30use language_model::LanguageModelImage;
31use postage::stream::Stream as _;
32use project::{
33 CompletionIntent, InlayHint, InlayHintLabel, Project, ProjectItem, ProjectPath, Worktree,
34};
35use prompt_store::{PromptId, PromptStore};
36use rope::Point;
37use settings::Settings;
38use std::{
39 cell::RefCell,
40 ffi::OsStr,
41 fmt::Write,
42 ops::{Range, RangeInclusive},
43 path::{Path, PathBuf},
44 rc::Rc,
45 sync::Arc,
46 time::Duration,
47};
48use text::OffsetRangeExt;
49use theme::ThemeSettings;
50use ui::{ButtonLike, TintColor, Toggleable, prelude::*};
51use util::{ResultExt, debug_panic, rel_path::RelPath};
52use workspace::{Workspace, notifications::NotifyResultExt as _};
53use zed_actions::agent::Chat;
54
55pub struct MessageEditor {
56 mention_set: MentionSet,
57 editor: Entity<Editor>,
58 project: Entity<Project>,
59 workspace: WeakEntity<Workspace>,
60 history_store: Entity<HistoryStore>,
61 prompt_store: Option<Entity<PromptStore>>,
62 prompt_capabilities: Rc<RefCell<acp::PromptCapabilities>>,
63 available_commands: Rc<RefCell<Vec<acp::AvailableCommand>>>,
64 agent_name: SharedString,
65 _subscriptions: Vec<Subscription>,
66 _parse_slash_command_task: Task<()>,
67}
68
69#[derive(Clone, Copy, Debug)]
70pub enum MessageEditorEvent {
71 Send,
72 Cancel,
73 Focus,
74 LostFocus,
75}
76
77impl EventEmitter<MessageEditorEvent> for MessageEditor {}
78
79const COMMAND_HINT_INLAY_ID: u32 = 0;
80
81impl MessageEditor {
82 pub fn new(
83 workspace: WeakEntity<Workspace>,
84 project: Entity<Project>,
85 history_store: Entity<HistoryStore>,
86 prompt_store: Option<Entity<PromptStore>>,
87 prompt_capabilities: Rc<RefCell<acp::PromptCapabilities>>,
88 available_commands: Rc<RefCell<Vec<acp::AvailableCommand>>>,
89 agent_name: SharedString,
90 placeholder: &str,
91 mode: EditorMode,
92 window: &mut Window,
93 cx: &mut Context<Self>,
94 ) -> Self {
95 let language = Language::new(
96 language::LanguageConfig {
97 completion_query_characters: HashSet::from_iter(['.', '-', '_', '@']),
98 ..Default::default()
99 },
100 None,
101 );
102 let completion_provider = Rc::new(ContextPickerCompletionProvider::new(
103 cx.weak_entity(),
104 workspace.clone(),
105 history_store.clone(),
106 prompt_store.clone(),
107 prompt_capabilities.clone(),
108 available_commands.clone(),
109 ));
110 let mention_set = MentionSet::default();
111 let editor = cx.new(|cx| {
112 let buffer = cx.new(|cx| Buffer::local("", cx).with_language(Arc::new(language), cx));
113 let buffer = cx.new(|cx| MultiBuffer::singleton(buffer, cx));
114
115 let mut editor = Editor::new(mode, buffer, None, window, cx);
116 editor.set_placeholder_text(placeholder, window, cx);
117 editor.set_show_indent_guides(false, cx);
118 editor.set_soft_wrap();
119 editor.set_use_modal_editing(true);
120 editor.set_completion_provider(Some(completion_provider.clone()));
121 editor.set_context_menu_options(ContextMenuOptions {
122 min_entries_visible: 12,
123 max_entries_visible: 12,
124 placement: Some(ContextMenuPlacement::Above),
125 });
126 editor.register_addon(MessageEditorAddon::new());
127 editor
128 });
129
130 cx.on_focus_in(&editor.focus_handle(cx), window, |_, _, cx| {
131 cx.emit(MessageEditorEvent::Focus)
132 })
133 .detach();
134 cx.on_focus_out(&editor.focus_handle(cx), window, |_, _, _, cx| {
135 cx.emit(MessageEditorEvent::LostFocus)
136 })
137 .detach();
138
139 let mut has_hint = false;
140 let mut subscriptions = Vec::new();
141
142 subscriptions.push(cx.subscribe_in(&editor, window, {
143 move |this, editor, event, window, cx| {
144 if let EditorEvent::Edited { .. } = event
145 && !editor.read(cx).read_only(cx)
146 {
147 let snapshot = editor.update(cx, |editor, cx| {
148 let new_hints = this
149 .command_hint(editor.buffer(), cx)
150 .into_iter()
151 .collect::<Vec<_>>();
152 let has_new_hint = !new_hints.is_empty();
153 editor.splice_inlays(
154 if has_hint {
155 &[InlayId::Hint(COMMAND_HINT_INLAY_ID)]
156 } else {
157 &[]
158 },
159 new_hints,
160 cx,
161 );
162 has_hint = has_new_hint;
163
164 editor.snapshot(window, cx)
165 });
166 this.mention_set.remove_invalid(snapshot);
167
168 cx.notify();
169 }
170 }
171 }));
172
173 Self {
174 editor,
175 project,
176 mention_set,
177 workspace,
178 history_store,
179 prompt_store,
180 prompt_capabilities,
181 available_commands,
182 agent_name,
183 _subscriptions: subscriptions,
184 _parse_slash_command_task: Task::ready(()),
185 }
186 }
187
188 fn command_hint(&self, buffer: &Entity<MultiBuffer>, cx: &App) -> Option<Inlay> {
189 let available_commands = self.available_commands.borrow();
190 if available_commands.is_empty() {
191 return None;
192 }
193
194 let snapshot = buffer.read(cx).snapshot(cx);
195 let parsed_command = SlashCommandCompletion::try_parse(&snapshot.text(), 0)?;
196 if parsed_command.argument.is_some() {
197 return None;
198 }
199
200 let command_name = parsed_command.command?;
201 let available_command = available_commands
202 .iter()
203 .find(|command| command.name == command_name)?;
204
205 let acp::AvailableCommandInput::Unstructured { mut hint } =
206 available_command.input.clone()?;
207
208 let mut hint_pos = parsed_command.source_range.end + 1;
209 if hint_pos > snapshot.len() {
210 hint_pos = snapshot.len();
211 hint.insert(0, ' ');
212 }
213
214 let hint_pos = snapshot.anchor_after(hint_pos);
215
216 Some(Inlay::hint(
217 COMMAND_HINT_INLAY_ID,
218 hint_pos,
219 &InlayHint {
220 position: hint_pos.text_anchor,
221 label: InlayHintLabel::String(hint),
222 kind: Some(InlayHintKind::Parameter),
223 padding_left: false,
224 padding_right: false,
225 tooltip: None,
226 resolve_state: project::ResolveState::Resolved,
227 },
228 ))
229 }
230
231 pub fn insert_thread_summary(
232 &mut self,
233 thread: agent2::DbThreadMetadata,
234 window: &mut Window,
235 cx: &mut Context<Self>,
236 ) {
237 let start = self.editor.update(cx, |editor, cx| {
238 editor.set_text(format!("{}\n", thread.title), window, cx);
239 editor
240 .buffer()
241 .read(cx)
242 .snapshot(cx)
243 .anchor_before(Point::zero())
244 .text_anchor
245 });
246
247 self.confirm_mention_completion(
248 thread.title.clone(),
249 start,
250 thread.title.len(),
251 MentionUri::Thread {
252 id: thread.id.clone(),
253 name: thread.title.to_string(),
254 },
255 window,
256 cx,
257 )
258 .detach();
259 }
260
261 #[cfg(test)]
262 pub(crate) fn editor(&self) -> &Entity<Editor> {
263 &self.editor
264 }
265
266 #[cfg(test)]
267 pub(crate) fn mention_set(&mut self) -> &mut MentionSet {
268 &mut self.mention_set
269 }
270
271 pub fn is_empty(&self, cx: &App) -> bool {
272 self.editor.read(cx).is_empty(cx)
273 }
274
275 pub fn mentions(&self) -> HashSet<MentionUri> {
276 self.mention_set
277 .mentions
278 .values()
279 .map(|(uri, _)| uri.clone())
280 .collect()
281 }
282
283 pub fn confirm_mention_completion(
284 &mut self,
285 crease_text: SharedString,
286 start: text::Anchor,
287 content_len: usize,
288 mention_uri: MentionUri,
289 window: &mut Window,
290 cx: &mut Context<Self>,
291 ) -> Task<()> {
292 let snapshot = self
293 .editor
294 .update(cx, |editor, cx| editor.snapshot(window, cx));
295 let Some((excerpt_id, _, _)) = snapshot.buffer_snapshot().as_singleton() else {
296 return Task::ready(());
297 };
298 let Some(start_anchor) = snapshot
299 .buffer_snapshot()
300 .anchor_in_excerpt(*excerpt_id, start)
301 else {
302 return Task::ready(());
303 };
304 let end_anchor = snapshot
305 .buffer_snapshot()
306 .anchor_before(start_anchor.to_offset(&snapshot.buffer_snapshot()) + content_len + 1);
307
308 let crease = if let MentionUri::File { abs_path } = &mention_uri
309 && let Some(extension) = abs_path.extension()
310 && let Some(extension) = extension.to_str()
311 && Img::extensions().contains(&extension)
312 && !extension.contains("svg")
313 {
314 let Some(project_path) = self
315 .project
316 .read(cx)
317 .project_path_for_absolute_path(&abs_path, cx)
318 else {
319 log::error!("project path not found");
320 return Task::ready(());
321 };
322 let image = self
323 .project
324 .update(cx, |project, cx| project.open_image(project_path, cx));
325 let image = cx
326 .spawn(async move |_, cx| {
327 let image = image.await.map_err(|e| e.to_string())?;
328 let image = image
329 .update(cx, |image, _| image.image.clone())
330 .map_err(|e| e.to_string())?;
331 Ok(image)
332 })
333 .shared();
334 insert_crease_for_mention(
335 *excerpt_id,
336 start,
337 content_len,
338 mention_uri.name().into(),
339 IconName::Image.path().into(),
340 Some(image),
341 self.editor.clone(),
342 window,
343 cx,
344 )
345 } else {
346 insert_crease_for_mention(
347 *excerpt_id,
348 start,
349 content_len,
350 crease_text,
351 mention_uri.icon_path(cx),
352 None,
353 self.editor.clone(),
354 window,
355 cx,
356 )
357 };
358 let Some((crease_id, tx)) = crease else {
359 return Task::ready(());
360 };
361
362 let task = match mention_uri.clone() {
363 MentionUri::Fetch { url } => self.confirm_mention_for_fetch(url, cx),
364 MentionUri::Directory { .. } => Task::ready(Ok(Mention::UriOnly)),
365 MentionUri::Thread { id, .. } => self.confirm_mention_for_thread(id, cx),
366 MentionUri::TextThread { path, .. } => self.confirm_mention_for_text_thread(path, cx),
367 MentionUri::File { abs_path } => self.confirm_mention_for_file(abs_path, cx),
368 MentionUri::Symbol {
369 abs_path,
370 line_range,
371 ..
372 } => self.confirm_mention_for_symbol(abs_path, line_range, cx),
373 MentionUri::Rule { id, .. } => self.confirm_mention_for_rule(id, cx),
374 MentionUri::PastedImage => {
375 debug_panic!("pasted image URI should not be included in completions");
376 Task::ready(Err(anyhow!(
377 "pasted imaged URI should not be included in completions"
378 )))
379 }
380 MentionUri::Selection { .. } => {
381 // Handled elsewhere
382 debug_panic!("unexpected selection URI");
383 Task::ready(Err(anyhow!("unexpected selection URI")))
384 }
385 };
386 let task = cx
387 .spawn(async move |_, _| task.await.map_err(|e| e.to_string()))
388 .shared();
389 self.mention_set
390 .mentions
391 .insert(crease_id, (mention_uri, task.clone()));
392
393 // Notify the user if we failed to load the mentioned context
394 cx.spawn_in(window, async move |this, cx| {
395 let result = task.await.notify_async_err(cx);
396 drop(tx);
397 if result.is_none() {
398 this.update(cx, |this, cx| {
399 this.editor.update(cx, |editor, cx| {
400 // Remove mention
401 editor.edit([(start_anchor..end_anchor, "")], cx);
402 });
403 this.mention_set.mentions.remove(&crease_id);
404 })
405 .ok();
406 }
407 })
408 }
409
410 fn confirm_mention_for_file(
411 &mut self,
412 abs_path: PathBuf,
413 cx: &mut Context<Self>,
414 ) -> Task<Result<Mention>> {
415 let Some(project_path) = self
416 .project
417 .read(cx)
418 .project_path_for_absolute_path(&abs_path, cx)
419 else {
420 return Task::ready(Err(anyhow!("project path not found")));
421 };
422 let extension = abs_path
423 .extension()
424 .and_then(OsStr::to_str)
425 .unwrap_or_default();
426
427 if Img::extensions().contains(&extension) && !extension.contains("svg") {
428 if !self.prompt_capabilities.borrow().image {
429 return Task::ready(Err(anyhow!("This model does not support images yet")));
430 }
431 let task = self
432 .project
433 .update(cx, |project, cx| project.open_image(project_path, cx));
434 return cx.spawn(async move |_, cx| {
435 let image = task.await?;
436 let image = image.update(cx, |image, _| image.image.clone())?;
437 let format = image.format;
438 let image = cx
439 .update(|cx| LanguageModelImage::from_image(image, cx))?
440 .await;
441 if let Some(image) = image {
442 Ok(Mention::Image(MentionImage {
443 data: image.source,
444 format,
445 }))
446 } else {
447 Err(anyhow!("Failed to convert image"))
448 }
449 });
450 }
451
452 let buffer = self
453 .project
454 .update(cx, |project, cx| project.open_buffer(project_path, cx));
455 cx.spawn(async move |_, cx| {
456 let buffer = buffer.await?;
457 let buffer_content = outline::get_buffer_content_or_outline(
458 buffer.clone(),
459 Some(&abs_path.to_string_lossy()),
460 &cx,
461 )
462 .await?;
463
464 Ok(Mention::Text {
465 content: buffer_content.text,
466 tracked_buffers: vec![buffer],
467 })
468 })
469 }
470
471 fn confirm_mention_for_fetch(
472 &mut self,
473 url: url::Url,
474 cx: &mut Context<Self>,
475 ) -> Task<Result<Mention>> {
476 let http_client = match self
477 .workspace
478 .update(cx, |workspace, _| workspace.client().http_client())
479 {
480 Ok(http_client) => http_client,
481 Err(e) => return Task::ready(Err(e)),
482 };
483 cx.background_executor().spawn(async move {
484 let content = fetch_url_content(http_client, url.to_string()).await?;
485 Ok(Mention::Text {
486 content,
487 tracked_buffers: Vec::new(),
488 })
489 })
490 }
491
492 fn confirm_mention_for_symbol(
493 &mut self,
494 abs_path: PathBuf,
495 line_range: RangeInclusive<u32>,
496 cx: &mut Context<Self>,
497 ) -> Task<Result<Mention>> {
498 let Some(project_path) = self
499 .project
500 .read(cx)
501 .project_path_for_absolute_path(&abs_path, cx)
502 else {
503 return Task::ready(Err(anyhow!("project path not found")));
504 };
505 let buffer = self
506 .project
507 .update(cx, |project, cx| project.open_buffer(project_path, cx));
508 cx.spawn(async move |_, cx| {
509 let buffer = buffer.await?;
510 let mention = buffer.update(cx, |buffer, cx| {
511 let start = Point::new(*line_range.start(), 0).min(buffer.max_point());
512 let end = Point::new(*line_range.end() + 1, 0).min(buffer.max_point());
513 let content = buffer.text_for_range(start..end).collect();
514 Mention::Text {
515 content,
516 tracked_buffers: vec![cx.entity()],
517 }
518 })?;
519 anyhow::Ok(mention)
520 })
521 }
522
523 fn confirm_mention_for_rule(
524 &mut self,
525 id: PromptId,
526 cx: &mut Context<Self>,
527 ) -> Task<Result<Mention>> {
528 let Some(prompt_store) = self.prompt_store.clone() else {
529 return Task::ready(Err(anyhow!("missing prompt store")));
530 };
531 let prompt = prompt_store.read(cx).load(id, cx);
532 cx.spawn(async move |_, _| {
533 let prompt = prompt.await?;
534 Ok(Mention::Text {
535 content: prompt,
536 tracked_buffers: Vec::new(),
537 })
538 })
539 }
540
541 pub fn confirm_mention_for_selection(
542 &mut self,
543 source_range: Range<text::Anchor>,
544 selections: Vec<(Entity<Buffer>, Range<text::Anchor>, Range<usize>)>,
545 window: &mut Window,
546 cx: &mut Context<Self>,
547 ) {
548 let snapshot = self.editor.read(cx).buffer().read(cx).snapshot(cx);
549 let Some((&excerpt_id, _, _)) = snapshot.as_singleton() else {
550 return;
551 };
552 let Some(start) = snapshot.anchor_in_excerpt(excerpt_id, source_range.start) else {
553 return;
554 };
555
556 let offset = start.to_offset(&snapshot);
557
558 for (buffer, selection_range, range_to_fold) in selections {
559 let range = snapshot.anchor_after(offset + range_to_fold.start)
560 ..snapshot.anchor_after(offset + range_to_fold.end);
561
562 let abs_path = buffer
563 .read(cx)
564 .project_path(cx)
565 .and_then(|project_path| self.project.read(cx).absolute_path(&project_path, cx));
566 let snapshot = buffer.read(cx).snapshot();
567
568 let text = snapshot
569 .text_for_range(selection_range.clone())
570 .collect::<String>();
571 let point_range = selection_range.to_point(&snapshot);
572 let line_range = point_range.start.row..=point_range.end.row;
573
574 let uri = MentionUri::Selection {
575 abs_path: abs_path.clone(),
576 line_range: line_range.clone(),
577 };
578 let crease = crate::context_picker::crease_for_mention(
579 selection_name(abs_path.as_deref(), &line_range).into(),
580 uri.icon_path(cx),
581 range,
582 self.editor.downgrade(),
583 );
584
585 let crease_id = self.editor.update(cx, |editor, cx| {
586 let crease_ids = editor.insert_creases(vec![crease.clone()], cx);
587 editor.fold_creases(vec![crease], false, window, cx);
588 crease_ids.first().copied().unwrap()
589 });
590
591 self.mention_set.mentions.insert(
592 crease_id,
593 (
594 uri,
595 Task::ready(Ok(Mention::Text {
596 content: text,
597 tracked_buffers: vec![buffer],
598 }))
599 .shared(),
600 ),
601 );
602 }
603 }
604
605 fn confirm_mention_for_thread(
606 &mut self,
607 id: acp::SessionId,
608 cx: &mut Context<Self>,
609 ) -> Task<Result<Mention>> {
610 let server = Rc::new(agent2::NativeAgentServer::new(
611 self.project.read(cx).fs().clone(),
612 self.history_store.clone(),
613 ));
614 let delegate = AgentServerDelegate::new(
615 self.project.read(cx).agent_server_store().clone(),
616 self.project.clone(),
617 None,
618 None,
619 );
620 let connection = server.connect(None, delegate, cx);
621 cx.spawn(async move |_, cx| {
622 let (agent, _) = connection.await?;
623 let agent = agent.downcast::<agent2::NativeAgentConnection>().unwrap();
624 let summary = agent
625 .0
626 .update(cx, |agent, cx| agent.thread_summary(id, cx))?
627 .await?;
628 anyhow::Ok(Mention::Text {
629 content: summary.to_string(),
630 tracked_buffers: Vec::new(),
631 })
632 })
633 }
634
635 fn confirm_mention_for_text_thread(
636 &mut self,
637 path: PathBuf,
638 cx: &mut Context<Self>,
639 ) -> Task<Result<Mention>> {
640 let context = self.history_store.update(cx, |text_thread_store, cx| {
641 text_thread_store.load_text_thread(path.as_path().into(), cx)
642 });
643 cx.spawn(async move |_, cx| {
644 let context = context.await?;
645 let xml = context.update(cx, |context, cx| context.to_xml(cx))?;
646 Ok(Mention::Text {
647 content: xml,
648 tracked_buffers: Vec::new(),
649 })
650 })
651 }
652
653 fn validate_slash_commands(
654 text: &str,
655 available_commands: &[acp::AvailableCommand],
656 agent_name: &str,
657 ) -> Result<()> {
658 if let Some(parsed_command) = SlashCommandCompletion::try_parse(text, 0) {
659 if let Some(command_name) = parsed_command.command {
660 // Check if this command is in the list of available commands from the server
661 let is_supported = available_commands
662 .iter()
663 .any(|cmd| cmd.name == command_name);
664
665 if !is_supported {
666 return Err(anyhow!(
667 "The /{} command is not supported by {}.\n\nAvailable commands: {}",
668 command_name,
669 agent_name,
670 if available_commands.is_empty() {
671 "none".to_string()
672 } else {
673 available_commands
674 .iter()
675 .map(|cmd| format!("/{}", cmd.name))
676 .collect::<Vec<_>>()
677 .join(", ")
678 }
679 ));
680 }
681 }
682 }
683 Ok(())
684 }
685
686 pub fn contents(
687 &self,
688 full_mention_content: bool,
689 cx: &mut Context<Self>,
690 ) -> Task<Result<(Vec<acp::ContentBlock>, Vec<Entity<Buffer>>)>> {
691 // Check for unsupported slash commands before spawning async task
692 let text = self.editor.read(cx).text(cx);
693 let available_commands = self.available_commands.borrow().clone();
694 if let Err(err) =
695 Self::validate_slash_commands(&text, &available_commands, &self.agent_name)
696 {
697 return Task::ready(Err(err));
698 }
699
700 let contents = self.mention_set.contents(
701 &self.prompt_capabilities.borrow(),
702 full_mention_content,
703 self.project.clone(),
704 cx,
705 );
706 let editor = self.editor.clone();
707
708 cx.spawn(async move |_, cx| {
709 let contents = contents.await?;
710 let mut all_tracked_buffers = Vec::new();
711
712 let result = editor.update(cx, |editor, cx| {
713 let mut ix = 0;
714 let mut chunks: Vec<acp::ContentBlock> = Vec::new();
715 let text = editor.text(cx);
716 editor.display_map.update(cx, |map, cx| {
717 let snapshot = map.snapshot(cx);
718 for (crease_id, crease) in snapshot.crease_snapshot.creases() {
719 let Some((uri, mention)) = contents.get(&crease_id) else {
720 continue;
721 };
722
723 let crease_range = crease.range().to_offset(&snapshot.buffer_snapshot());
724 if crease_range.start > ix {
725 //todo(): Custom slash command ContentBlock?
726 // let chunk = if prevent_slash_commands
727 // && ix == 0
728 // && parse_slash_command(&text[ix..]).is_some()
729 // {
730 // format!(" {}", &text[ix..crease_range.start]).into()
731 // } else {
732 // text[ix..crease_range.start].into()
733 // };
734 let chunk = text[ix..crease_range.start].into();
735 chunks.push(chunk);
736 }
737 let chunk = match mention {
738 Mention::Text {
739 content,
740 tracked_buffers,
741 } => {
742 all_tracked_buffers.extend(tracked_buffers.iter().cloned());
743 acp::ContentBlock::Resource(acp::EmbeddedResource {
744 annotations: None,
745 resource: acp::EmbeddedResourceResource::TextResourceContents(
746 acp::TextResourceContents {
747 mime_type: None,
748 text: content.clone(),
749 uri: uri.to_uri().to_string(),
750 meta: None,
751 },
752 ),
753 meta: None,
754 })
755 }
756 Mention::Image(mention_image) => {
757 let uri = match uri {
758 MentionUri::File { .. } => Some(uri.to_uri().to_string()),
759 MentionUri::PastedImage => None,
760 other => {
761 debug_panic!(
762 "unexpected mention uri for image: {:?}",
763 other
764 );
765 None
766 }
767 };
768 acp::ContentBlock::Image(acp::ImageContent {
769 annotations: None,
770 data: mention_image.data.to_string(),
771 mime_type: mention_image.format.mime_type().into(),
772 uri,
773 meta: None,
774 })
775 }
776 Mention::UriOnly => {
777 acp::ContentBlock::ResourceLink(acp::ResourceLink {
778 name: uri.name(),
779 uri: uri.to_uri().to_string(),
780 annotations: None,
781 description: None,
782 mime_type: None,
783 size: None,
784 title: None,
785 meta: None,
786 })
787 }
788 };
789 chunks.push(chunk);
790 ix = crease_range.end;
791 }
792
793 if ix < text.len() {
794 //todo(): Custom slash command ContentBlock?
795 // let last_chunk = if prevent_slash_commands
796 // && ix == 0
797 // && parse_slash_command(&text[ix..]).is_some()
798 // {
799 // format!(" {}", text[ix..].trim_end())
800 // } else {
801 // text[ix..].trim_end().to_owned()
802 // };
803 let last_chunk = text[ix..].trim_end().to_owned();
804 if !last_chunk.is_empty() {
805 chunks.push(last_chunk.into());
806 }
807 }
808 });
809 Ok((chunks, all_tracked_buffers))
810 })?;
811 result
812 })
813 }
814
815 pub fn clear(&mut self, window: &mut Window, cx: &mut Context<Self>) {
816 self.editor.update(cx, |editor, cx| {
817 editor.clear(window, cx);
818 editor.remove_creases(
819 self.mention_set
820 .mentions
821 .drain()
822 .map(|(crease_id, _)| crease_id),
823 cx,
824 )
825 });
826 }
827
828 pub fn send(&mut self, cx: &mut Context<Self>) {
829 if self.is_empty(cx) {
830 return;
831 }
832 self.editor.update(cx, |editor, cx| {
833 editor.clear_inlay_hints(cx);
834 });
835 cx.emit(MessageEditorEvent::Send)
836 }
837
838 fn chat(&mut self, _: &Chat, _: &mut Window, cx: &mut Context<Self>) {
839 self.send(cx);
840 }
841
842 fn cancel(&mut self, _: &editor::actions::Cancel, _: &mut Window, cx: &mut Context<Self>) {
843 cx.emit(MessageEditorEvent::Cancel)
844 }
845
846 fn paste(&mut self, _: &Paste, window: &mut Window, cx: &mut Context<Self>) {
847 if !self.prompt_capabilities.borrow().image {
848 return;
849 }
850
851 let images = cx
852 .read_from_clipboard()
853 .map(|item| {
854 item.into_entries()
855 .filter_map(|entry| {
856 if let ClipboardEntry::Image(image) = entry {
857 Some(image)
858 } else {
859 None
860 }
861 })
862 .collect::<Vec<_>>()
863 })
864 .unwrap_or_default();
865
866 if images.is_empty() {
867 return;
868 }
869 cx.stop_propagation();
870
871 let replacement_text = MentionUri::PastedImage.as_link().to_string();
872 for image in images {
873 let (excerpt_id, text_anchor, multibuffer_anchor) =
874 self.editor.update(cx, |message_editor, cx| {
875 let snapshot = message_editor.snapshot(window, cx);
876 let (excerpt_id, _, buffer_snapshot) =
877 snapshot.buffer_snapshot().as_singleton().unwrap();
878
879 let text_anchor = buffer_snapshot.anchor_before(buffer_snapshot.len());
880 let multibuffer_anchor = snapshot
881 .buffer_snapshot()
882 .anchor_in_excerpt(*excerpt_id, text_anchor);
883 message_editor.edit(
884 [(
885 multi_buffer::Anchor::max()..multi_buffer::Anchor::max(),
886 format!("{replacement_text} "),
887 )],
888 cx,
889 );
890 (*excerpt_id, text_anchor, multibuffer_anchor)
891 });
892
893 let content_len = replacement_text.len();
894 let Some(start_anchor) = multibuffer_anchor else {
895 continue;
896 };
897 let end_anchor = self.editor.update(cx, |editor, cx| {
898 let snapshot = editor.buffer().read(cx).snapshot(cx);
899 snapshot.anchor_before(start_anchor.to_offset(&snapshot) + content_len)
900 });
901 let image = Arc::new(image);
902 let Some((crease_id, tx)) = insert_crease_for_mention(
903 excerpt_id,
904 text_anchor,
905 content_len,
906 MentionUri::PastedImage.name().into(),
907 IconName::Image.path().into(),
908 Some(Task::ready(Ok(image.clone())).shared()),
909 self.editor.clone(),
910 window,
911 cx,
912 ) else {
913 continue;
914 };
915 let task = cx
916 .spawn_in(window, {
917 async move |_, cx| {
918 let format = image.format;
919 let image = cx
920 .update(|_, cx| LanguageModelImage::from_image(image, cx))
921 .map_err(|e| e.to_string())?
922 .await;
923 drop(tx);
924 if let Some(image) = image {
925 Ok(Mention::Image(MentionImage {
926 data: image.source,
927 format,
928 }))
929 } else {
930 Err("Failed to convert image".into())
931 }
932 }
933 })
934 .shared();
935
936 self.mention_set
937 .mentions
938 .insert(crease_id, (MentionUri::PastedImage, task.clone()));
939
940 cx.spawn_in(window, async move |this, cx| {
941 if task.await.notify_async_err(cx).is_none() {
942 this.update(cx, |this, cx| {
943 this.editor.update(cx, |editor, cx| {
944 editor.edit([(start_anchor..end_anchor, "")], cx);
945 });
946 this.mention_set.mentions.remove(&crease_id);
947 })
948 .ok();
949 }
950 })
951 .detach();
952 }
953 }
954
955 pub fn insert_dragged_files(
956 &mut self,
957 paths: Vec<project::ProjectPath>,
958 added_worktrees: Vec<Entity<Worktree>>,
959 window: &mut Window,
960 cx: &mut Context<Self>,
961 ) {
962 let path_style = self.project.read(cx).path_style(cx);
963 let buffer = self.editor.read(cx).buffer().clone();
964 let Some(buffer) = buffer.read(cx).as_singleton() else {
965 return;
966 };
967 let mut tasks = Vec::new();
968 for path in paths {
969 let Some(entry) = self.project.read(cx).entry_for_path(&path, cx) else {
970 continue;
971 };
972 let Some(worktree) = self.project.read(cx).worktree_for_id(path.worktree_id, cx) else {
973 continue;
974 };
975 let abs_path = worktree.read(cx).absolutize(&path.path);
976 let (file_name, _) =
977 crate::context_picker::file_context_picker::extract_file_name_and_directory(
978 &path.path,
979 worktree.read(cx).root_name(),
980 path_style,
981 );
982
983 let uri = if entry.is_dir() {
984 MentionUri::Directory { abs_path }
985 } else {
986 MentionUri::File { abs_path }
987 };
988
989 let new_text = format!("{} ", uri.as_link());
990 let content_len = new_text.len() - 1;
991
992 let anchor = buffer.update(cx, |buffer, _cx| buffer.anchor_before(buffer.len()));
993
994 self.editor.update(cx, |message_editor, cx| {
995 message_editor.edit(
996 [(
997 multi_buffer::Anchor::max()..multi_buffer::Anchor::max(),
998 new_text,
999 )],
1000 cx,
1001 );
1002 });
1003 tasks.push(self.confirm_mention_completion(
1004 file_name,
1005 anchor,
1006 content_len,
1007 uri,
1008 window,
1009 cx,
1010 ));
1011 }
1012 cx.spawn(async move |_, _| {
1013 join_all(tasks).await;
1014 drop(added_worktrees);
1015 })
1016 .detach();
1017 }
1018
1019 pub fn insert_selections(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1020 let editor = self.editor.read(cx);
1021 let editor_buffer = editor.buffer().read(cx);
1022 let Some(buffer) = editor_buffer.as_singleton() else {
1023 return;
1024 };
1025 let cursor_anchor = editor.selections.newest_anchor().head();
1026 let cursor_offset = cursor_anchor.to_offset(&editor_buffer.snapshot(cx));
1027 let anchor = buffer.update(cx, |buffer, _cx| {
1028 buffer.anchor_before(cursor_offset.min(buffer.len()))
1029 });
1030 let Some(workspace) = self.workspace.upgrade() else {
1031 return;
1032 };
1033 let Some(completion) = ContextPickerCompletionProvider::completion_for_action(
1034 ContextPickerAction::AddSelections,
1035 anchor..anchor,
1036 cx.weak_entity(),
1037 &workspace,
1038 cx,
1039 ) else {
1040 return;
1041 };
1042
1043 self.editor.update(cx, |message_editor, cx| {
1044 message_editor.edit([(cursor_anchor..cursor_anchor, completion.new_text)], cx);
1045 });
1046 if let Some(confirm) = completion.confirm {
1047 confirm(CompletionIntent::Complete, window, cx);
1048 }
1049 }
1050
1051 pub fn set_read_only(&mut self, read_only: bool, cx: &mut Context<Self>) {
1052 self.editor.update(cx, |message_editor, cx| {
1053 message_editor.set_read_only(read_only);
1054 cx.notify()
1055 })
1056 }
1057
1058 pub fn set_mode(&mut self, mode: EditorMode, cx: &mut Context<Self>) {
1059 self.editor.update(cx, |editor, cx| {
1060 editor.set_mode(mode);
1061 cx.notify()
1062 });
1063 }
1064
1065 pub fn set_message(
1066 &mut self,
1067 message: Vec<acp::ContentBlock>,
1068 window: &mut Window,
1069 cx: &mut Context<Self>,
1070 ) {
1071 self.clear(window, cx);
1072
1073 let mut text = String::new();
1074 let mut mentions = Vec::new();
1075
1076 for chunk in message {
1077 match chunk {
1078 acp::ContentBlock::Text(text_content) => {
1079 text.push_str(&text_content.text);
1080 }
1081 acp::ContentBlock::Resource(acp::EmbeddedResource {
1082 resource: acp::EmbeddedResourceResource::TextResourceContents(resource),
1083 ..
1084 }) => {
1085 let Some(mention_uri) = MentionUri::parse(&resource.uri).log_err() else {
1086 continue;
1087 };
1088 let start = text.len();
1089 write!(&mut text, "{}", mention_uri.as_link()).ok();
1090 let end = text.len();
1091 mentions.push((
1092 start..end,
1093 mention_uri,
1094 Mention::Text {
1095 content: resource.text,
1096 tracked_buffers: Vec::new(),
1097 },
1098 ));
1099 }
1100 acp::ContentBlock::ResourceLink(resource) => {
1101 if let Some(mention_uri) = MentionUri::parse(&resource.uri).log_err() {
1102 let start = text.len();
1103 write!(&mut text, "{}", mention_uri.as_link()).ok();
1104 let end = text.len();
1105 mentions.push((start..end, mention_uri, Mention::UriOnly));
1106 }
1107 }
1108 acp::ContentBlock::Image(acp::ImageContent {
1109 uri,
1110 data,
1111 mime_type,
1112 annotations: _,
1113 meta: _,
1114 }) => {
1115 let mention_uri = if let Some(uri) = uri {
1116 MentionUri::parse(&uri)
1117 } else {
1118 Ok(MentionUri::PastedImage)
1119 };
1120 let Some(mention_uri) = mention_uri.log_err() else {
1121 continue;
1122 };
1123 let Some(format) = ImageFormat::from_mime_type(&mime_type) else {
1124 log::error!("failed to parse MIME type for image: {mime_type:?}");
1125 continue;
1126 };
1127 let start = text.len();
1128 write!(&mut text, "{}", mention_uri.as_link()).ok();
1129 let end = text.len();
1130 mentions.push((
1131 start..end,
1132 mention_uri,
1133 Mention::Image(MentionImage {
1134 data: data.into(),
1135 format,
1136 }),
1137 ));
1138 }
1139 acp::ContentBlock::Audio(_) | acp::ContentBlock::Resource(_) => {}
1140 }
1141 }
1142
1143 let snapshot = self.editor.update(cx, |editor, cx| {
1144 editor.set_text(text, window, cx);
1145 editor.buffer().read(cx).snapshot(cx)
1146 });
1147
1148 for (range, mention_uri, mention) in mentions {
1149 let anchor = snapshot.anchor_before(range.start);
1150 let Some((crease_id, tx)) = insert_crease_for_mention(
1151 anchor.excerpt_id,
1152 anchor.text_anchor,
1153 range.end - range.start,
1154 mention_uri.name().into(),
1155 mention_uri.icon_path(cx),
1156 None,
1157 self.editor.clone(),
1158 window,
1159 cx,
1160 ) else {
1161 continue;
1162 };
1163 drop(tx);
1164
1165 self.mention_set.mentions.insert(
1166 crease_id,
1167 (mention_uri.clone(), Task::ready(Ok(mention)).shared()),
1168 );
1169 }
1170 cx.notify();
1171 }
1172
1173 pub fn text(&self, cx: &App) -> String {
1174 self.editor.read(cx).text(cx)
1175 }
1176
1177 #[cfg(test)]
1178 pub fn set_text(&mut self, text: &str, window: &mut Window, cx: &mut Context<Self>) {
1179 self.editor.update(cx, |editor, cx| {
1180 editor.set_text(text, window, cx);
1181 });
1182 }
1183}
1184
1185fn full_mention_for_directory(
1186 project: &Entity<Project>,
1187 abs_path: &Path,
1188 cx: &mut App,
1189) -> Task<Result<Mention>> {
1190 fn collect_files_in_path(worktree: &Worktree, path: &RelPath) -> Vec<(Arc<RelPath>, String)> {
1191 let mut files = Vec::new();
1192
1193 for entry in worktree.child_entries(path) {
1194 if entry.is_dir() {
1195 files.extend(collect_files_in_path(worktree, &entry.path));
1196 } else if entry.is_file() {
1197 files.push((
1198 entry.path.clone(),
1199 worktree
1200 .full_path(&entry.path)
1201 .to_string_lossy()
1202 .to_string(),
1203 ));
1204 }
1205 }
1206
1207 files
1208 }
1209
1210 let Some(project_path) = project
1211 .read(cx)
1212 .project_path_for_absolute_path(&abs_path, cx)
1213 else {
1214 return Task::ready(Err(anyhow!("project path not found")));
1215 };
1216 let Some(entry) = project.read(cx).entry_for_path(&project_path, cx) else {
1217 return Task::ready(Err(anyhow!("project entry not found")));
1218 };
1219 let directory_path = entry.path.clone();
1220 let worktree_id = project_path.worktree_id;
1221 let Some(worktree) = project.read(cx).worktree_for_id(worktree_id, cx) else {
1222 return Task::ready(Err(anyhow!("worktree not found")));
1223 };
1224 let project = project.clone();
1225 cx.spawn(async move |cx| {
1226 let file_paths = worktree.read_with(cx, |worktree, _cx| {
1227 collect_files_in_path(worktree, &directory_path)
1228 })?;
1229 let descendants_future = cx.update(|cx| {
1230 join_all(file_paths.into_iter().map(|(worktree_path, full_path)| {
1231 let rel_path = worktree_path
1232 .strip_prefix(&directory_path)
1233 .log_err()
1234 .map_or_else(|| worktree_path.clone(), |rel_path| rel_path.into());
1235
1236 let open_task = project.update(cx, |project, cx| {
1237 project.buffer_store().update(cx, |buffer_store, cx| {
1238 let project_path = ProjectPath {
1239 worktree_id,
1240 path: worktree_path,
1241 };
1242 buffer_store.open_buffer(project_path, cx)
1243 })
1244 });
1245
1246 cx.spawn(async move |cx| {
1247 let buffer = open_task.await.log_err()?;
1248 let buffer_content = outline::get_buffer_content_or_outline(
1249 buffer.clone(),
1250 Some(&full_path),
1251 &cx,
1252 )
1253 .await
1254 .ok()?;
1255
1256 Some((rel_path, full_path, buffer_content.text, buffer))
1257 })
1258 }))
1259 })?;
1260
1261 let contents = cx
1262 .background_spawn(async move {
1263 let (contents, tracked_buffers) = descendants_future
1264 .await
1265 .into_iter()
1266 .flatten()
1267 .map(|(rel_path, full_path, rope, buffer)| {
1268 ((rel_path, full_path, rope), buffer)
1269 })
1270 .unzip();
1271 Mention::Text {
1272 content: render_directory_contents(contents),
1273 tracked_buffers,
1274 }
1275 })
1276 .await;
1277 anyhow::Ok(contents)
1278 })
1279}
1280
1281fn render_directory_contents(entries: Vec<(Arc<RelPath>, String, String)>) -> String {
1282 let mut output = String::new();
1283 for (_relative_path, full_path, content) in entries {
1284 let fence = codeblock_fence_for_path(Some(&full_path), None);
1285 write!(output, "\n{fence}\n{content}\n```").unwrap();
1286 }
1287 output
1288}
1289
1290impl Focusable for MessageEditor {
1291 fn focus_handle(&self, cx: &App) -> FocusHandle {
1292 self.editor.focus_handle(cx)
1293 }
1294}
1295
1296impl Render for MessageEditor {
1297 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1298 div()
1299 .key_context("MessageEditor")
1300 .on_action(cx.listener(Self::chat))
1301 .on_action(cx.listener(Self::cancel))
1302 .capture_action(cx.listener(Self::paste))
1303 .flex_1()
1304 .child({
1305 let settings = ThemeSettings::get_global(cx);
1306
1307 let text_style = TextStyle {
1308 color: cx.theme().colors().text,
1309 font_family: settings.buffer_font.family.clone(),
1310 font_fallbacks: settings.buffer_font.fallbacks.clone(),
1311 font_features: settings.buffer_font.features.clone(),
1312 font_size: settings.agent_buffer_font_size(cx).into(),
1313 line_height: relative(settings.buffer_line_height.value()),
1314 ..Default::default()
1315 };
1316
1317 EditorElement::new(
1318 &self.editor,
1319 EditorStyle {
1320 background: cx.theme().colors().editor_background,
1321 local_player: cx.theme().players().local(),
1322 text: text_style,
1323 syntax: cx.theme().syntax().clone(),
1324 inlay_hints_style: editor::make_inlay_hints_style(cx),
1325 ..Default::default()
1326 },
1327 )
1328 })
1329 }
1330}
1331
1332pub(crate) fn insert_crease_for_mention(
1333 excerpt_id: ExcerptId,
1334 anchor: text::Anchor,
1335 content_len: usize,
1336 crease_label: SharedString,
1337 crease_icon: SharedString,
1338 // abs_path: Option<Arc<Path>>,
1339 image: Option<Shared<Task<Result<Arc<Image>, String>>>>,
1340 editor: Entity<Editor>,
1341 window: &mut Window,
1342 cx: &mut App,
1343) -> Option<(CreaseId, postage::barrier::Sender)> {
1344 let (tx, rx) = postage::barrier::channel();
1345
1346 let crease_id = editor.update(cx, |editor, cx| {
1347 let snapshot = editor.buffer().read(cx).snapshot(cx);
1348
1349 let start = snapshot.anchor_in_excerpt(excerpt_id, anchor)?;
1350
1351 let start = start.bias_right(&snapshot);
1352 let end = snapshot.anchor_before(start.to_offset(&snapshot) + content_len);
1353
1354 let placeholder = FoldPlaceholder {
1355 render: render_mention_fold_button(
1356 crease_label,
1357 crease_icon,
1358 start..end,
1359 rx,
1360 image,
1361 cx.weak_entity(),
1362 cx,
1363 ),
1364 merge_adjacent: false,
1365 ..Default::default()
1366 };
1367
1368 let crease = Crease::Inline {
1369 range: start..end,
1370 placeholder,
1371 render_toggle: None,
1372 render_trailer: None,
1373 metadata: None,
1374 };
1375
1376 let ids = editor.insert_creases(vec![crease.clone()], cx);
1377 editor.fold_creases(vec![crease], false, window, cx);
1378
1379 Some(ids[0])
1380 })?;
1381
1382 Some((crease_id, tx))
1383}
1384
1385fn render_mention_fold_button(
1386 label: SharedString,
1387 icon: SharedString,
1388 range: Range<Anchor>,
1389 mut loading_finished: postage::barrier::Receiver,
1390 image_task: Option<Shared<Task<Result<Arc<Image>, String>>>>,
1391 editor: WeakEntity<Editor>,
1392 cx: &mut App,
1393) -> Arc<dyn Send + Sync + Fn(FoldId, Range<Anchor>, &mut App) -> AnyElement> {
1394 let loading = cx.new(|cx| {
1395 let loading = cx.spawn(async move |this, cx| {
1396 loading_finished.recv().await;
1397 this.update(cx, |this: &mut LoadingContext, cx| {
1398 this.loading = None;
1399 cx.notify();
1400 })
1401 .ok();
1402 });
1403 LoadingContext {
1404 id: cx.entity_id(),
1405 label,
1406 icon,
1407 range,
1408 editor,
1409 loading: Some(loading),
1410 image: image_task.clone(),
1411 }
1412 });
1413 Arc::new(move |_fold_id, _fold_range, _cx| loading.clone().into_any_element())
1414}
1415
1416struct LoadingContext {
1417 id: EntityId,
1418 label: SharedString,
1419 icon: SharedString,
1420 range: Range<Anchor>,
1421 editor: WeakEntity<Editor>,
1422 loading: Option<Task<()>>,
1423 image: Option<Shared<Task<Result<Arc<Image>, String>>>>,
1424}
1425
1426impl Render for LoadingContext {
1427 fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
1428 let is_in_text_selection = self
1429 .editor
1430 .update(cx, |editor, cx| editor.is_range_selected(&self.range, cx))
1431 .unwrap_or_default();
1432 ButtonLike::new(("loading-context", self.id))
1433 .style(ButtonStyle::Filled)
1434 .selected_style(ButtonStyle::Tinted(TintColor::Accent))
1435 .toggle_state(is_in_text_selection)
1436 .when_some(self.image.clone(), |el, image_task| {
1437 el.hoverable_tooltip(move |_, cx| {
1438 let image = image_task.peek().cloned().transpose().ok().flatten();
1439 let image_task = image_task.clone();
1440 cx.new::<ImageHover>(|cx| ImageHover {
1441 image,
1442 _task: cx.spawn(async move |this, cx| {
1443 if let Ok(image) = image_task.clone().await {
1444 this.update(cx, |this, cx| {
1445 if this.image.replace(image).is_none() {
1446 cx.notify();
1447 }
1448 })
1449 .ok();
1450 }
1451 }),
1452 })
1453 .into()
1454 })
1455 })
1456 .child(
1457 h_flex()
1458 .gap_1()
1459 .child(
1460 Icon::from_path(self.icon.clone())
1461 .size(IconSize::XSmall)
1462 .color(Color::Muted),
1463 )
1464 .child(
1465 Label::new(self.label.clone())
1466 .size(LabelSize::Small)
1467 .buffer_font(cx)
1468 .single_line(),
1469 )
1470 .map(|el| {
1471 if self.loading.is_some() {
1472 el.with_animation(
1473 "loading-context-crease",
1474 Animation::new(Duration::from_secs(2))
1475 .repeat()
1476 .with_easing(pulsating_between(0.4, 0.8)),
1477 |label, delta| label.opacity(delta),
1478 )
1479 .into_any()
1480 } else {
1481 el.into_any()
1482 }
1483 }),
1484 )
1485 }
1486}
1487
1488struct ImageHover {
1489 image: Option<Arc<Image>>,
1490 _task: Task<()>,
1491}
1492
1493impl Render for ImageHover {
1494 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
1495 if let Some(image) = self.image.clone() {
1496 gpui::img(image).max_w_96().max_h_96().into_any_element()
1497 } else {
1498 gpui::Empty.into_any_element()
1499 }
1500 }
1501}
1502
1503#[derive(Debug, Clone, Eq, PartialEq)]
1504pub enum Mention {
1505 Text {
1506 content: String,
1507 tracked_buffers: Vec<Entity<Buffer>>,
1508 },
1509 Image(MentionImage),
1510 UriOnly,
1511}
1512
1513#[derive(Clone, Debug, Eq, PartialEq)]
1514pub struct MentionImage {
1515 pub data: SharedString,
1516 pub format: ImageFormat,
1517}
1518
1519#[derive(Default)]
1520pub struct MentionSet {
1521 mentions: HashMap<CreaseId, (MentionUri, Shared<Task<Result<Mention, String>>>)>,
1522}
1523
1524impl MentionSet {
1525 fn contents(
1526 &self,
1527 prompt_capabilities: &acp::PromptCapabilities,
1528 full_mention_content: bool,
1529 project: Entity<Project>,
1530 cx: &mut App,
1531 ) -> Task<Result<HashMap<CreaseId, (MentionUri, Mention)>>> {
1532 if !prompt_capabilities.embedded_context {
1533 let mentions = self
1534 .mentions
1535 .iter()
1536 .map(|(crease_id, (uri, _))| (*crease_id, (uri.clone(), Mention::UriOnly)))
1537 .collect();
1538
1539 return Task::ready(Ok(mentions));
1540 }
1541
1542 let mentions = self.mentions.clone();
1543 cx.spawn(async move |cx| {
1544 let mut contents = HashMap::default();
1545 for (crease_id, (mention_uri, task)) in mentions {
1546 let content = if full_mention_content
1547 && let MentionUri::Directory { abs_path } = &mention_uri
1548 {
1549 cx.update(|cx| full_mention_for_directory(&project, abs_path, cx))?
1550 .await?
1551 } else {
1552 task.await.map_err(|e| anyhow!("{e}"))?
1553 };
1554
1555 contents.insert(crease_id, (mention_uri, content));
1556 }
1557 Ok(contents)
1558 })
1559 }
1560
1561 fn remove_invalid(&mut self, snapshot: EditorSnapshot) {
1562 for (crease_id, crease) in snapshot.crease_snapshot.creases() {
1563 if !crease.range().start.is_valid(&snapshot.buffer_snapshot()) {
1564 self.mentions.remove(&crease_id);
1565 }
1566 }
1567 }
1568}
1569
1570pub struct MessageEditorAddon {}
1571
1572impl MessageEditorAddon {
1573 pub fn new() -> Self {
1574 Self {}
1575 }
1576}
1577
1578impl Addon for MessageEditorAddon {
1579 fn to_any(&self) -> &dyn std::any::Any {
1580 self
1581 }
1582
1583 fn to_any_mut(&mut self) -> Option<&mut dyn std::any::Any> {
1584 Some(self)
1585 }
1586
1587 fn extend_key_context(&self, key_context: &mut KeyContext, cx: &App) {
1588 let settings = agent_settings::AgentSettings::get_global(cx);
1589 if settings.use_modifier_to_send {
1590 key_context.add("use_modifier_to_send");
1591 }
1592 }
1593}
1594
1595#[cfg(test)]
1596mod tests {
1597 use std::{cell::RefCell, ops::Range, path::Path, rc::Rc, sync::Arc};
1598
1599 use acp_thread::MentionUri;
1600 use agent_client_protocol as acp;
1601 use agent2::HistoryStore;
1602 use assistant_context::ContextStore;
1603 use assistant_tool::outline;
1604 use editor::{AnchorRangeExt as _, Editor, EditorMode};
1605 use fs::FakeFs;
1606 use futures::StreamExt as _;
1607 use gpui::{
1608 AppContext, Entity, EventEmitter, FocusHandle, Focusable, TestAppContext, VisualTestContext,
1609 };
1610 use lsp::{CompletionContext, CompletionTriggerKind};
1611 use project::{CompletionIntent, Project, ProjectPath};
1612 use serde_json::json;
1613 use text::Point;
1614 use ui::{App, Context, IntoElement, Render, SharedString, Window};
1615 use util::{path, paths::PathStyle, rel_path::rel_path};
1616 use workspace::{AppState, Item, Workspace};
1617
1618 use crate::acp::{
1619 message_editor::{Mention, MessageEditor},
1620 thread_view::tests::init_test,
1621 };
1622
1623 #[gpui::test]
1624 async fn test_at_mention_removal(cx: &mut TestAppContext) {
1625 init_test(cx);
1626
1627 let fs = FakeFs::new(cx.executor());
1628 fs.insert_tree("/project", json!({"file": ""})).await;
1629 let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;
1630
1631 let (workspace, cx) =
1632 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
1633
1634 let context_store = cx.new(|cx| ContextStore::fake(project.clone(), cx));
1635 let history_store = cx.new(|cx| HistoryStore::new(context_store, cx));
1636
1637 let message_editor = cx.update(|window, cx| {
1638 cx.new(|cx| {
1639 MessageEditor::new(
1640 workspace.downgrade(),
1641 project.clone(),
1642 history_store.clone(),
1643 None,
1644 Default::default(),
1645 Default::default(),
1646 "Test Agent".into(),
1647 "Test",
1648 EditorMode::AutoHeight {
1649 min_lines: 1,
1650 max_lines: None,
1651 },
1652 window,
1653 cx,
1654 )
1655 })
1656 });
1657 let editor = message_editor.update(cx, |message_editor, _| message_editor.editor.clone());
1658
1659 cx.run_until_parked();
1660
1661 let excerpt_id = editor.update(cx, |editor, cx| {
1662 editor
1663 .buffer()
1664 .read(cx)
1665 .excerpt_ids()
1666 .into_iter()
1667 .next()
1668 .unwrap()
1669 });
1670 let completions = editor.update_in(cx, |editor, window, cx| {
1671 editor.set_text("Hello @file ", window, cx);
1672 let buffer = editor.buffer().read(cx).as_singleton().unwrap();
1673 let completion_provider = editor.completion_provider().unwrap();
1674 completion_provider.completions(
1675 excerpt_id,
1676 &buffer,
1677 text::Anchor::MAX,
1678 CompletionContext {
1679 trigger_kind: CompletionTriggerKind::TRIGGER_CHARACTER,
1680 trigger_character: Some("@".into()),
1681 },
1682 window,
1683 cx,
1684 )
1685 });
1686 let [_, completion]: [_; 2] = completions
1687 .await
1688 .unwrap()
1689 .into_iter()
1690 .flat_map(|response| response.completions)
1691 .collect::<Vec<_>>()
1692 .try_into()
1693 .unwrap();
1694
1695 editor.update_in(cx, |editor, window, cx| {
1696 let snapshot = editor.buffer().read(cx).snapshot(cx);
1697 let start = snapshot
1698 .anchor_in_excerpt(excerpt_id, completion.replace_range.start)
1699 .unwrap();
1700 let end = snapshot
1701 .anchor_in_excerpt(excerpt_id, completion.replace_range.end)
1702 .unwrap();
1703 editor.edit([(start..end, completion.new_text)], cx);
1704 (completion.confirm.unwrap())(CompletionIntent::Complete, window, cx);
1705 });
1706
1707 cx.run_until_parked();
1708
1709 // Backspace over the inserted crease (and the following space).
1710 editor.update_in(cx, |editor, window, cx| {
1711 editor.backspace(&Default::default(), window, cx);
1712 editor.backspace(&Default::default(), window, cx);
1713 });
1714
1715 let (content, _) = message_editor
1716 .update(cx, |message_editor, cx| message_editor.contents(false, cx))
1717 .await
1718 .unwrap();
1719
1720 // We don't send a resource link for the deleted crease.
1721 pretty_assertions::assert_matches!(content.as_slice(), [acp::ContentBlock::Text { .. }]);
1722 }
1723
1724 #[gpui::test]
1725 async fn test_slash_command_validation(cx: &mut gpui::TestAppContext) {
1726 init_test(cx);
1727 let fs = FakeFs::new(cx.executor());
1728 fs.insert_tree(
1729 "/test",
1730 json!({
1731 ".zed": {
1732 "tasks.json": r#"[{"label": "test", "command": "echo"}]"#
1733 },
1734 "src": {
1735 "main.rs": "fn main() {}",
1736 },
1737 }),
1738 )
1739 .await;
1740
1741 let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
1742 let context_store = cx.new(|cx| ContextStore::fake(project.clone(), cx));
1743 let history_store = cx.new(|cx| HistoryStore::new(context_store, cx));
1744 let prompt_capabilities = Rc::new(RefCell::new(acp::PromptCapabilities::default()));
1745 // Start with no available commands - simulating Claude which doesn't support slash commands
1746 let available_commands = Rc::new(RefCell::new(vec![]));
1747
1748 let (workspace, cx) =
1749 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
1750 let workspace_handle = workspace.downgrade();
1751 let message_editor = workspace.update_in(cx, |_, window, cx| {
1752 cx.new(|cx| {
1753 MessageEditor::new(
1754 workspace_handle.clone(),
1755 project.clone(),
1756 history_store.clone(),
1757 None,
1758 prompt_capabilities.clone(),
1759 available_commands.clone(),
1760 "Claude Code".into(),
1761 "Test",
1762 EditorMode::AutoHeight {
1763 min_lines: 1,
1764 max_lines: None,
1765 },
1766 window,
1767 cx,
1768 )
1769 })
1770 });
1771 let editor = message_editor.update(cx, |message_editor, _| message_editor.editor.clone());
1772
1773 // Test that slash commands fail when no available_commands are set (empty list means no commands supported)
1774 editor.update_in(cx, |editor, window, cx| {
1775 editor.set_text("/file test.txt", window, cx);
1776 });
1777
1778 let contents_result = message_editor
1779 .update(cx, |message_editor, cx| message_editor.contents(false, cx))
1780 .await;
1781
1782 // Should fail because available_commands is empty (no commands supported)
1783 assert!(contents_result.is_err());
1784 let error_message = contents_result.unwrap_err().to_string();
1785 assert!(error_message.contains("not supported by Claude Code"));
1786 assert!(error_message.contains("Available commands: none"));
1787
1788 // Now simulate Claude providing its list of available commands (which doesn't include file)
1789 available_commands.replace(vec![acp::AvailableCommand {
1790 name: "help".to_string(),
1791 description: "Get help".to_string(),
1792 input: None,
1793 meta: None,
1794 }]);
1795
1796 // Test that unsupported slash commands trigger an error when we have a list of available commands
1797 editor.update_in(cx, |editor, window, cx| {
1798 editor.set_text("/file test.txt", window, cx);
1799 });
1800
1801 let contents_result = message_editor
1802 .update(cx, |message_editor, cx| message_editor.contents(false, cx))
1803 .await;
1804
1805 assert!(contents_result.is_err());
1806 let error_message = contents_result.unwrap_err().to_string();
1807 assert!(error_message.contains("not supported by Claude Code"));
1808 assert!(error_message.contains("/file"));
1809 assert!(error_message.contains("Available commands: /help"));
1810
1811 // Test that supported commands work fine
1812 editor.update_in(cx, |editor, window, cx| {
1813 editor.set_text("/help", window, cx);
1814 });
1815
1816 let contents_result = message_editor
1817 .update(cx, |message_editor, cx| message_editor.contents(false, cx))
1818 .await;
1819
1820 // Should succeed because /help is in available_commands
1821 assert!(contents_result.is_ok());
1822
1823 // Test that regular text works fine
1824 editor.update_in(cx, |editor, window, cx| {
1825 editor.set_text("Hello Claude!", window, cx);
1826 });
1827
1828 let (content, _) = message_editor
1829 .update(cx, |message_editor, cx| message_editor.contents(false, cx))
1830 .await
1831 .unwrap();
1832
1833 assert_eq!(content.len(), 1);
1834 if let acp::ContentBlock::Text(text) = &content[0] {
1835 assert_eq!(text.text, "Hello Claude!");
1836 } else {
1837 panic!("Expected ContentBlock::Text");
1838 }
1839
1840 // Test that @ mentions still work
1841 editor.update_in(cx, |editor, window, cx| {
1842 editor.set_text("Check this @", window, cx);
1843 });
1844
1845 // The @ mention functionality should not be affected
1846 let (content, _) = message_editor
1847 .update(cx, |message_editor, cx| message_editor.contents(false, cx))
1848 .await
1849 .unwrap();
1850
1851 assert_eq!(content.len(), 1);
1852 if let acp::ContentBlock::Text(text) = &content[0] {
1853 assert_eq!(text.text, "Check this @");
1854 } else {
1855 panic!("Expected ContentBlock::Text");
1856 }
1857 }
1858
1859 struct MessageEditorItem(Entity<MessageEditor>);
1860
1861 impl Item for MessageEditorItem {
1862 type Event = ();
1863
1864 fn include_in_nav_history() -> bool {
1865 false
1866 }
1867
1868 fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString {
1869 "Test".into()
1870 }
1871 }
1872
1873 impl EventEmitter<()> for MessageEditorItem {}
1874
1875 impl Focusable for MessageEditorItem {
1876 fn focus_handle(&self, cx: &App) -> FocusHandle {
1877 self.0.read(cx).focus_handle(cx)
1878 }
1879 }
1880
1881 impl Render for MessageEditorItem {
1882 fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
1883 self.0.clone().into_any_element()
1884 }
1885 }
1886
1887 #[gpui::test]
1888 async fn test_completion_provider_commands(cx: &mut TestAppContext) {
1889 init_test(cx);
1890
1891 let app_state = cx.update(AppState::test);
1892
1893 cx.update(|cx| {
1894 language::init(cx);
1895 editor::init(cx);
1896 workspace::init(app_state.clone(), cx);
1897 Project::init_settings(cx);
1898 });
1899
1900 let project = Project::test(app_state.fs.clone(), [path!("/dir").as_ref()], cx).await;
1901 let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
1902 let workspace = window.root(cx).unwrap();
1903
1904 let mut cx = VisualTestContext::from_window(*window, cx);
1905
1906 let context_store = cx.new(|cx| ContextStore::fake(project.clone(), cx));
1907 let history_store = cx.new(|cx| HistoryStore::new(context_store, cx));
1908 let prompt_capabilities = Rc::new(RefCell::new(acp::PromptCapabilities::default()));
1909 let available_commands = Rc::new(RefCell::new(vec![
1910 acp::AvailableCommand {
1911 name: "quick-math".to_string(),
1912 description: "2 + 2 = 4 - 1 = 3".to_string(),
1913 input: None,
1914 meta: None,
1915 },
1916 acp::AvailableCommand {
1917 name: "say-hello".to_string(),
1918 description: "Say hello to whoever you want".to_string(),
1919 input: Some(acp::AvailableCommandInput::Unstructured {
1920 hint: "<name>".to_string(),
1921 }),
1922 meta: None,
1923 },
1924 ]));
1925
1926 let editor = workspace.update_in(&mut cx, |workspace, window, cx| {
1927 let workspace_handle = cx.weak_entity();
1928 let message_editor = cx.new(|cx| {
1929 MessageEditor::new(
1930 workspace_handle,
1931 project.clone(),
1932 history_store.clone(),
1933 None,
1934 prompt_capabilities.clone(),
1935 available_commands.clone(),
1936 "Test Agent".into(),
1937 "Test",
1938 EditorMode::AutoHeight {
1939 max_lines: None,
1940 min_lines: 1,
1941 },
1942 window,
1943 cx,
1944 )
1945 });
1946 workspace.active_pane().update(cx, |pane, cx| {
1947 pane.add_item(
1948 Box::new(cx.new(|_| MessageEditorItem(message_editor.clone()))),
1949 true,
1950 true,
1951 None,
1952 window,
1953 cx,
1954 );
1955 });
1956 message_editor.read(cx).focus_handle(cx).focus(window);
1957 message_editor.read(cx).editor().clone()
1958 });
1959
1960 cx.simulate_input("/");
1961
1962 editor.update_in(&mut cx, |editor, window, cx| {
1963 assert_eq!(editor.text(cx), "/");
1964 assert!(editor.has_visible_completions_menu());
1965
1966 assert_eq!(
1967 current_completion_labels_with_documentation(editor),
1968 &[
1969 ("quick-math".into(), "2 + 2 = 4 - 1 = 3".into()),
1970 ("say-hello".into(), "Say hello to whoever you want".into())
1971 ]
1972 );
1973 editor.set_text("", window, cx);
1974 });
1975
1976 cx.simulate_input("/qui");
1977
1978 editor.update_in(&mut cx, |editor, window, cx| {
1979 assert_eq!(editor.text(cx), "/qui");
1980 assert!(editor.has_visible_completions_menu());
1981
1982 assert_eq!(
1983 current_completion_labels_with_documentation(editor),
1984 &[("quick-math".into(), "2 + 2 = 4 - 1 = 3".into())]
1985 );
1986 editor.set_text("", window, cx);
1987 });
1988
1989 editor.update_in(&mut cx, |editor, window, cx| {
1990 assert!(editor.has_visible_completions_menu());
1991 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
1992 });
1993
1994 cx.run_until_parked();
1995
1996 editor.update_in(&mut cx, |editor, window, cx| {
1997 assert_eq!(editor.display_text(cx), "/quick-math ");
1998 assert!(!editor.has_visible_completions_menu());
1999 editor.set_text("", window, cx);
2000 });
2001
2002 cx.simulate_input("/say");
2003
2004 editor.update_in(&mut cx, |editor, _window, cx| {
2005 assert_eq!(editor.display_text(cx), "/say");
2006 assert!(editor.has_visible_completions_menu());
2007
2008 assert_eq!(
2009 current_completion_labels_with_documentation(editor),
2010 &[("say-hello".into(), "Say hello to whoever you want".into())]
2011 );
2012 });
2013
2014 editor.update_in(&mut cx, |editor, window, cx| {
2015 assert!(editor.has_visible_completions_menu());
2016 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2017 });
2018
2019 cx.run_until_parked();
2020
2021 editor.update_in(&mut cx, |editor, _window, cx| {
2022 assert_eq!(editor.text(cx), "/say-hello ");
2023 assert_eq!(editor.display_text(cx), "/say-hello <name>");
2024 assert!(!editor.has_visible_completions_menu());
2025 });
2026
2027 cx.simulate_input("GPT5");
2028
2029 cx.run_until_parked();
2030
2031 editor.update_in(&mut cx, |editor, window, cx| {
2032 assert_eq!(editor.text(cx), "/say-hello GPT5");
2033 assert_eq!(editor.display_text(cx), "/say-hello GPT5");
2034 assert!(!editor.has_visible_completions_menu());
2035
2036 // Delete argument
2037 for _ in 0..5 {
2038 editor.backspace(&editor::actions::Backspace, window, cx);
2039 }
2040 });
2041
2042 cx.run_until_parked();
2043
2044 editor.update_in(&mut cx, |editor, window, cx| {
2045 assert_eq!(editor.text(cx), "/say-hello");
2046 // Hint is visible because argument was deleted
2047 assert_eq!(editor.display_text(cx), "/say-hello <name>");
2048
2049 // Delete last command letter
2050 editor.backspace(&editor::actions::Backspace, window, cx);
2051 });
2052
2053 cx.run_until_parked();
2054
2055 editor.update_in(&mut cx, |editor, _window, cx| {
2056 // Hint goes away once command no longer matches an available one
2057 assert_eq!(editor.text(cx), "/say-hell");
2058 assert_eq!(editor.display_text(cx), "/say-hell");
2059 assert!(!editor.has_visible_completions_menu());
2060 });
2061 }
2062
2063 #[gpui::test]
2064 async fn test_context_completion_provider_mentions(cx: &mut TestAppContext) {
2065 init_test(cx);
2066
2067 let app_state = cx.update(AppState::test);
2068
2069 cx.update(|cx| {
2070 language::init(cx);
2071 editor::init(cx);
2072 workspace::init(app_state.clone(), cx);
2073 Project::init_settings(cx);
2074 });
2075
2076 app_state
2077 .fs
2078 .as_fake()
2079 .insert_tree(
2080 path!("/dir"),
2081 json!({
2082 "editor": "",
2083 "a": {
2084 "one.txt": "1",
2085 "two.txt": "2",
2086 "three.txt": "3",
2087 "four.txt": "4"
2088 },
2089 "b": {
2090 "five.txt": "5",
2091 "six.txt": "6",
2092 "seven.txt": "7",
2093 "eight.txt": "8",
2094 },
2095 "x.png": "",
2096 }),
2097 )
2098 .await;
2099
2100 let project = Project::test(app_state.fs.clone(), [path!("/dir").as_ref()], cx).await;
2101 let window = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
2102 let workspace = window.root(cx).unwrap();
2103
2104 let worktree = project.update(cx, |project, cx| {
2105 let mut worktrees = project.worktrees(cx).collect::<Vec<_>>();
2106 assert_eq!(worktrees.len(), 1);
2107 worktrees.pop().unwrap()
2108 });
2109 let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id());
2110
2111 let mut cx = VisualTestContext::from_window(*window, cx);
2112
2113 let paths = vec![
2114 rel_path("a/one.txt"),
2115 rel_path("a/two.txt"),
2116 rel_path("a/three.txt"),
2117 rel_path("a/four.txt"),
2118 rel_path("b/five.txt"),
2119 rel_path("b/six.txt"),
2120 rel_path("b/seven.txt"),
2121 rel_path("b/eight.txt"),
2122 ];
2123
2124 let slash = PathStyle::local().separator();
2125
2126 let mut opened_editors = Vec::new();
2127 for path in paths {
2128 let buffer = workspace
2129 .update_in(&mut cx, |workspace, window, cx| {
2130 workspace.open_path(
2131 ProjectPath {
2132 worktree_id,
2133 path: path.into(),
2134 },
2135 None,
2136 false,
2137 window,
2138 cx,
2139 )
2140 })
2141 .await
2142 .unwrap();
2143 opened_editors.push(buffer);
2144 }
2145
2146 let context_store = cx.new(|cx| ContextStore::fake(project.clone(), cx));
2147 let history_store = cx.new(|cx| HistoryStore::new(context_store, cx));
2148 let prompt_capabilities = Rc::new(RefCell::new(acp::PromptCapabilities::default()));
2149
2150 let (message_editor, editor) = workspace.update_in(&mut cx, |workspace, window, cx| {
2151 let workspace_handle = cx.weak_entity();
2152 let message_editor = cx.new(|cx| {
2153 MessageEditor::new(
2154 workspace_handle,
2155 project.clone(),
2156 history_store.clone(),
2157 None,
2158 prompt_capabilities.clone(),
2159 Default::default(),
2160 "Test Agent".into(),
2161 "Test",
2162 EditorMode::AutoHeight {
2163 max_lines: None,
2164 min_lines: 1,
2165 },
2166 window,
2167 cx,
2168 )
2169 });
2170 workspace.active_pane().update(cx, |pane, cx| {
2171 pane.add_item(
2172 Box::new(cx.new(|_| MessageEditorItem(message_editor.clone()))),
2173 true,
2174 true,
2175 None,
2176 window,
2177 cx,
2178 );
2179 });
2180 message_editor.read(cx).focus_handle(cx).focus(window);
2181 let editor = message_editor.read(cx).editor().clone();
2182 (message_editor, editor)
2183 });
2184
2185 cx.simulate_input("Lorem @");
2186
2187 editor.update_in(&mut cx, |editor, window, cx| {
2188 assert_eq!(editor.text(cx), "Lorem @");
2189 assert!(editor.has_visible_completions_menu());
2190
2191 assert_eq!(
2192 current_completion_labels(editor),
2193 &[
2194 format!("eight.txt dir{slash}b{slash}"),
2195 format!("seven.txt dir{slash}b{slash}"),
2196 format!("six.txt dir{slash}b{slash}"),
2197 format!("five.txt dir{slash}b{slash}"),
2198 ]
2199 );
2200 editor.set_text("", window, cx);
2201 });
2202
2203 prompt_capabilities.replace(acp::PromptCapabilities {
2204 image: true,
2205 audio: true,
2206 embedded_context: true,
2207 meta: None,
2208 });
2209
2210 cx.simulate_input("Lorem ");
2211
2212 editor.update(&mut cx, |editor, cx| {
2213 assert_eq!(editor.text(cx), "Lorem ");
2214 assert!(!editor.has_visible_completions_menu());
2215 });
2216
2217 cx.simulate_input("@");
2218
2219 editor.update(&mut cx, |editor, cx| {
2220 assert_eq!(editor.text(cx), "Lorem @");
2221 assert!(editor.has_visible_completions_menu());
2222 assert_eq!(
2223 current_completion_labels(editor),
2224 &[
2225 format!("eight.txt dir{slash}b{slash}"),
2226 format!("seven.txt dir{slash}b{slash}"),
2227 format!("six.txt dir{slash}b{slash}"),
2228 format!("five.txt dir{slash}b{slash}"),
2229 "Files & Directories".into(),
2230 "Symbols".into(),
2231 "Threads".into(),
2232 "Fetch".into()
2233 ]
2234 );
2235 });
2236
2237 // Select and confirm "File"
2238 editor.update_in(&mut cx, |editor, window, cx| {
2239 assert!(editor.has_visible_completions_menu());
2240 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
2241 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
2242 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
2243 editor.context_menu_next(&editor::actions::ContextMenuNext, window, cx);
2244 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2245 });
2246
2247 cx.run_until_parked();
2248
2249 editor.update(&mut cx, |editor, cx| {
2250 assert_eq!(editor.text(cx), "Lorem @file ");
2251 assert!(editor.has_visible_completions_menu());
2252 });
2253
2254 cx.simulate_input("one");
2255
2256 editor.update(&mut cx, |editor, cx| {
2257 assert_eq!(editor.text(cx), "Lorem @file one");
2258 assert!(editor.has_visible_completions_menu());
2259 assert_eq!(
2260 current_completion_labels(editor),
2261 vec![format!("one.txt dir{slash}a{slash}")]
2262 );
2263 });
2264
2265 editor.update_in(&mut cx, |editor, window, cx| {
2266 assert!(editor.has_visible_completions_menu());
2267 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2268 });
2269
2270 let url_one = MentionUri::File {
2271 abs_path: path!("/dir/a/one.txt").into(),
2272 }
2273 .to_uri()
2274 .to_string();
2275 editor.update(&mut cx, |editor, cx| {
2276 let text = editor.text(cx);
2277 assert_eq!(text, format!("Lorem [@one.txt]({url_one}) "));
2278 assert!(!editor.has_visible_completions_menu());
2279 assert_eq!(fold_ranges(editor, cx).len(), 1);
2280 });
2281
2282 let all_prompt_capabilities = acp::PromptCapabilities {
2283 image: true,
2284 audio: true,
2285 embedded_context: true,
2286 meta: None,
2287 };
2288
2289 let contents = message_editor
2290 .update(&mut cx, |message_editor, cx| {
2291 message_editor.mention_set().contents(
2292 &all_prompt_capabilities,
2293 false,
2294 project.clone(),
2295 cx,
2296 )
2297 })
2298 .await
2299 .unwrap()
2300 .into_values()
2301 .collect::<Vec<_>>();
2302
2303 {
2304 let [(uri, Mention::Text { content, .. })] = contents.as_slice() else {
2305 panic!("Unexpected mentions");
2306 };
2307 pretty_assertions::assert_eq!(content, "1");
2308 pretty_assertions::assert_eq!(uri, &url_one.parse::<MentionUri>().unwrap());
2309 }
2310
2311 let contents = message_editor
2312 .update(&mut cx, |message_editor, cx| {
2313 message_editor.mention_set().contents(
2314 &acp::PromptCapabilities::default(),
2315 false,
2316 project.clone(),
2317 cx,
2318 )
2319 })
2320 .await
2321 .unwrap()
2322 .into_values()
2323 .collect::<Vec<_>>();
2324
2325 {
2326 let [(uri, Mention::UriOnly)] = contents.as_slice() else {
2327 panic!("Unexpected mentions");
2328 };
2329 pretty_assertions::assert_eq!(uri, &url_one.parse::<MentionUri>().unwrap());
2330 }
2331
2332 cx.simulate_input(" ");
2333
2334 editor.update(&mut cx, |editor, cx| {
2335 let text = editor.text(cx);
2336 assert_eq!(text, format!("Lorem [@one.txt]({url_one}) "));
2337 assert!(!editor.has_visible_completions_menu());
2338 assert_eq!(fold_ranges(editor, cx).len(), 1);
2339 });
2340
2341 cx.simulate_input("Ipsum ");
2342
2343 editor.update(&mut cx, |editor, cx| {
2344 let text = editor.text(cx);
2345 assert_eq!(text, format!("Lorem [@one.txt]({url_one}) Ipsum "),);
2346 assert!(!editor.has_visible_completions_menu());
2347 assert_eq!(fold_ranges(editor, cx).len(), 1);
2348 });
2349
2350 cx.simulate_input("@file ");
2351
2352 editor.update(&mut cx, |editor, cx| {
2353 let text = editor.text(cx);
2354 assert_eq!(text, format!("Lorem [@one.txt]({url_one}) Ipsum @file "),);
2355 assert!(editor.has_visible_completions_menu());
2356 assert_eq!(fold_ranges(editor, cx).len(), 1);
2357 });
2358
2359 editor.update_in(&mut cx, |editor, window, cx| {
2360 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2361 });
2362
2363 cx.run_until_parked();
2364
2365 let contents = message_editor
2366 .update(&mut cx, |message_editor, cx| {
2367 message_editor.mention_set().contents(
2368 &all_prompt_capabilities,
2369 false,
2370 project.clone(),
2371 cx,
2372 )
2373 })
2374 .await
2375 .unwrap()
2376 .into_values()
2377 .collect::<Vec<_>>();
2378
2379 let url_eight = MentionUri::File {
2380 abs_path: path!("/dir/b/eight.txt").into(),
2381 }
2382 .to_uri()
2383 .to_string();
2384
2385 {
2386 let [_, (uri, Mention::Text { content, .. })] = contents.as_slice() else {
2387 panic!("Unexpected mentions");
2388 };
2389 pretty_assertions::assert_eq!(content, "8");
2390 pretty_assertions::assert_eq!(uri, &url_eight.parse::<MentionUri>().unwrap());
2391 }
2392
2393 editor.update(&mut cx, |editor, cx| {
2394 assert_eq!(
2395 editor.text(cx),
2396 format!("Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) ")
2397 );
2398 assert!(!editor.has_visible_completions_menu());
2399 assert_eq!(fold_ranges(editor, cx).len(), 2);
2400 });
2401
2402 let plain_text_language = Arc::new(language::Language::new(
2403 language::LanguageConfig {
2404 name: "Plain Text".into(),
2405 matcher: language::LanguageMatcher {
2406 path_suffixes: vec!["txt".to_string()],
2407 ..Default::default()
2408 },
2409 ..Default::default()
2410 },
2411 None,
2412 ));
2413
2414 // Register the language and fake LSP
2415 let language_registry = project.read_with(&cx, |project, _| project.languages().clone());
2416 language_registry.add(plain_text_language);
2417
2418 let mut fake_language_servers = language_registry.register_fake_lsp(
2419 "Plain Text",
2420 language::FakeLspAdapter {
2421 capabilities: lsp::ServerCapabilities {
2422 workspace_symbol_provider: Some(lsp::OneOf::Left(true)),
2423 ..Default::default()
2424 },
2425 ..Default::default()
2426 },
2427 );
2428
2429 // Open the buffer to trigger LSP initialization
2430 let buffer = project
2431 .update(&mut cx, |project, cx| {
2432 project.open_local_buffer(path!("/dir/a/one.txt"), cx)
2433 })
2434 .await
2435 .unwrap();
2436
2437 // Register the buffer with language servers
2438 let _handle = project.update(&mut cx, |project, cx| {
2439 project.register_buffer_with_language_servers(&buffer, cx)
2440 });
2441
2442 cx.run_until_parked();
2443
2444 let fake_language_server = fake_language_servers.next().await.unwrap();
2445 fake_language_server.set_request_handler::<lsp::WorkspaceSymbolRequest, _, _>(
2446 move |_, _| async move {
2447 Ok(Some(lsp::WorkspaceSymbolResponse::Flat(vec![
2448 #[allow(deprecated)]
2449 lsp::SymbolInformation {
2450 name: "MySymbol".into(),
2451 location: lsp::Location {
2452 uri: lsp::Uri::from_file_path(path!("/dir/a/one.txt")).unwrap(),
2453 range: lsp::Range::new(
2454 lsp::Position::new(0, 0),
2455 lsp::Position::new(0, 1),
2456 ),
2457 },
2458 kind: lsp::SymbolKind::CONSTANT,
2459 tags: None,
2460 container_name: None,
2461 deprecated: None,
2462 },
2463 ])))
2464 },
2465 );
2466
2467 cx.simulate_input("@symbol ");
2468
2469 editor.update(&mut cx, |editor, cx| {
2470 assert_eq!(
2471 editor.text(cx),
2472 format!("Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) @symbol ")
2473 );
2474 assert!(editor.has_visible_completions_menu());
2475 assert_eq!(current_completion_labels(editor), &["MySymbol"]);
2476 });
2477
2478 editor.update_in(&mut cx, |editor, window, cx| {
2479 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2480 });
2481
2482 let symbol = MentionUri::Symbol {
2483 abs_path: path!("/dir/a/one.txt").into(),
2484 name: "MySymbol".into(),
2485 line_range: 0..=0,
2486 };
2487
2488 let contents = message_editor
2489 .update(&mut cx, |message_editor, cx| {
2490 message_editor.mention_set().contents(
2491 &all_prompt_capabilities,
2492 false,
2493 project.clone(),
2494 cx,
2495 )
2496 })
2497 .await
2498 .unwrap()
2499 .into_values()
2500 .collect::<Vec<_>>();
2501
2502 {
2503 let [_, _, (uri, Mention::Text { content, .. })] = contents.as_slice() else {
2504 panic!("Unexpected mentions");
2505 };
2506 pretty_assertions::assert_eq!(content, "1");
2507 pretty_assertions::assert_eq!(uri, &symbol);
2508 }
2509
2510 cx.run_until_parked();
2511
2512 editor.read_with(&cx, |editor, cx| {
2513 assert_eq!(
2514 editor.text(cx),
2515 format!(
2516 "Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) [@MySymbol]({}) ",
2517 symbol.to_uri(),
2518 )
2519 );
2520 });
2521
2522 // Try to mention an "image" file that will fail to load
2523 cx.simulate_input("@file x.png");
2524
2525 editor.update(&mut cx, |editor, cx| {
2526 assert_eq!(
2527 editor.text(cx),
2528 format!("Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) [@MySymbol]({}) @file x.png", symbol.to_uri())
2529 );
2530 assert!(editor.has_visible_completions_menu());
2531 assert_eq!(current_completion_labels(editor), &[format!("x.png dir{slash}")]);
2532 });
2533
2534 editor.update_in(&mut cx, |editor, window, cx| {
2535 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2536 });
2537
2538 // Getting the message contents fails
2539 message_editor
2540 .update(&mut cx, |message_editor, cx| {
2541 message_editor.mention_set().contents(
2542 &all_prompt_capabilities,
2543 false,
2544 project.clone(),
2545 cx,
2546 )
2547 })
2548 .await
2549 .expect_err("Should fail to load x.png");
2550
2551 cx.run_until_parked();
2552
2553 // Mention was removed
2554 editor.read_with(&cx, |editor, cx| {
2555 assert_eq!(
2556 editor.text(cx),
2557 format!(
2558 "Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) [@MySymbol]({}) ",
2559 symbol.to_uri()
2560 )
2561 );
2562 });
2563
2564 // Once more
2565 cx.simulate_input("@file x.png");
2566
2567 editor.update(&mut cx, |editor, cx| {
2568 assert_eq!(
2569 editor.text(cx),
2570 format!("Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) [@MySymbol]({}) @file x.png", symbol.to_uri())
2571 );
2572 assert!(editor.has_visible_completions_menu());
2573 assert_eq!(current_completion_labels(editor), &[format!("x.png dir{slash}")]);
2574 });
2575
2576 editor.update_in(&mut cx, |editor, window, cx| {
2577 editor.confirm_completion(&editor::actions::ConfirmCompletion::default(), window, cx);
2578 });
2579
2580 // This time don't immediately get the contents, just let the confirmed completion settle
2581 cx.run_until_parked();
2582
2583 // Mention was removed
2584 editor.read_with(&cx, |editor, cx| {
2585 assert_eq!(
2586 editor.text(cx),
2587 format!(
2588 "Lorem [@one.txt]({url_one}) Ipsum [@eight.txt]({url_eight}) [@MySymbol]({}) ",
2589 symbol.to_uri()
2590 )
2591 );
2592 });
2593
2594 // Now getting the contents succeeds, because the invalid mention was removed
2595 let contents = message_editor
2596 .update(&mut cx, |message_editor, cx| {
2597 message_editor.mention_set().contents(
2598 &all_prompt_capabilities,
2599 false,
2600 project.clone(),
2601 cx,
2602 )
2603 })
2604 .await
2605 .unwrap();
2606 assert_eq!(contents.len(), 3);
2607 }
2608
2609 fn fold_ranges(editor: &Editor, cx: &mut App) -> Vec<Range<Point>> {
2610 let snapshot = editor.buffer().read(cx).snapshot(cx);
2611 editor.display_map.update(cx, |display_map, cx| {
2612 display_map
2613 .snapshot(cx)
2614 .folds_in_range(0..snapshot.len())
2615 .map(|fold| fold.range.to_point(&snapshot))
2616 .collect()
2617 })
2618 }
2619
2620 fn current_completion_labels(editor: &Editor) -> Vec<String> {
2621 let completions = editor.current_completions().expect("Missing completions");
2622 completions
2623 .into_iter()
2624 .map(|completion| completion.label.text)
2625 .collect::<Vec<_>>()
2626 }
2627
2628 fn current_completion_labels_with_documentation(editor: &Editor) -> Vec<(String, String)> {
2629 let completions = editor.current_completions().expect("Missing completions");
2630 completions
2631 .into_iter()
2632 .map(|completion| {
2633 (
2634 completion.label.text,
2635 completion
2636 .documentation
2637 .map(|d| d.text().to_string())
2638 .unwrap_or_default(),
2639 )
2640 })
2641 .collect::<Vec<_>>()
2642 }
2643
2644 #[gpui::test]
2645 async fn test_large_file_mention_uses_outline(cx: &mut TestAppContext) {
2646 init_test(cx);
2647
2648 let fs = FakeFs::new(cx.executor());
2649
2650 // Create a large file that exceeds AUTO_OUTLINE_SIZE
2651 const LINE: &str = "fn example_function() { /* some code */ }\n";
2652 let large_content = LINE.repeat(2 * (outline::AUTO_OUTLINE_SIZE / LINE.len()));
2653 assert!(large_content.len() > outline::AUTO_OUTLINE_SIZE);
2654
2655 // Create a small file that doesn't exceed AUTO_OUTLINE_SIZE
2656 let small_content = "fn small_function() { /* small */ }\n";
2657 assert!(small_content.len() < outline::AUTO_OUTLINE_SIZE);
2658
2659 fs.insert_tree(
2660 "/project",
2661 json!({
2662 "large_file.rs": large_content.clone(),
2663 "small_file.rs": small_content,
2664 }),
2665 )
2666 .await;
2667
2668 let project = Project::test(fs, [Path::new(path!("/project"))], cx).await;
2669
2670 let (workspace, cx) =
2671 cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
2672
2673 let context_store = cx.new(|cx| ContextStore::fake(project.clone(), cx));
2674 let history_store = cx.new(|cx| HistoryStore::new(context_store, cx));
2675
2676 let message_editor = cx.update(|window, cx| {
2677 cx.new(|cx| {
2678 let editor = MessageEditor::new(
2679 workspace.downgrade(),
2680 project.clone(),
2681 history_store.clone(),
2682 None,
2683 Default::default(),
2684 Default::default(),
2685 "Test Agent".into(),
2686 "Test",
2687 EditorMode::AutoHeight {
2688 min_lines: 1,
2689 max_lines: None,
2690 },
2691 window,
2692 cx,
2693 );
2694 // Enable embedded context so files are actually included
2695 editor.prompt_capabilities.replace(acp::PromptCapabilities {
2696 embedded_context: true,
2697 meta: None,
2698 ..Default::default()
2699 });
2700 editor
2701 })
2702 });
2703
2704 // Test large file mention
2705 // Get the absolute path using the project's worktree
2706 let large_file_abs_path = project.read_with(cx, |project, cx| {
2707 let worktree = project.worktrees(cx).next().unwrap();
2708 let worktree_root = worktree.read(cx).abs_path();
2709 worktree_root.join("large_file.rs")
2710 });
2711 let large_file_task = message_editor.update(cx, |editor, cx| {
2712 editor.confirm_mention_for_file(large_file_abs_path, cx)
2713 });
2714
2715 let large_file_mention = large_file_task.await.unwrap();
2716 match large_file_mention {
2717 Mention::Text { content, .. } => {
2718 // Should contain outline header for large files
2719 assert!(content.contains("File outline for"));
2720 assert!(content.contains("file too large to show full content"));
2721 // Should not contain the full repeated content
2722 assert!(!content.contains(&LINE.repeat(100)));
2723 }
2724 _ => panic!("Expected Text mention for large file"),
2725 }
2726
2727 // Test small file mention
2728 // Get the absolute path using the project's worktree
2729 let small_file_abs_path = project.read_with(cx, |project, cx| {
2730 let worktree = project.worktrees(cx).next().unwrap();
2731 let worktree_root = worktree.read(cx).abs_path();
2732 worktree_root.join("small_file.rs")
2733 });
2734 let small_file_task = message_editor.update(cx, |editor, cx| {
2735 editor.confirm_mention_for_file(small_file_abs_path, cx)
2736 });
2737
2738 let small_file_mention = small_file_task.await.unwrap();
2739 match small_file_mention {
2740 Mention::Text { content, .. } => {
2741 // Should contain the actual content
2742 assert_eq!(content, small_content);
2743 // Should not contain outline header
2744 assert!(!content.contains("File outline for"));
2745 }
2746 _ => panic!("Expected Text mention for small file"),
2747 }
2748 }
2749}