1use crate::{
2 assistant_settings::{AssistantDockPosition, AssistantSettings, ZedDotDevModel},
3 codegen::{self, Codegen, CodegenKind},
4 embedded_scope::EmbeddedScope,
5 prompts::generate_content_prompt,
6 Assist, CompletionProvider, CycleMessageRole, InlineAssist, LanguageModel,
7 LanguageModelRequest, LanguageModelRequestMessage, MessageId, MessageMetadata, MessageStatus,
8 NewConversation, QuoteSelection, ResetKey, Role, SavedConversation, SavedConversationMetadata,
9 SavedMessage, Split, ToggleFocus, ToggleIncludeConversation,
10};
11use anyhow::{anyhow, Result};
12use chrono::{DateTime, Local};
13use collections::{hash_map, HashMap, HashSet, VecDeque};
14use editor::{
15 actions::{MoveDown, MoveUp},
16 display_map::{
17 BlockContext, BlockDisposition, BlockId, BlockProperties, BlockStyle, ToDisplayPoint,
18 },
19 scroll::{Autoscroll, AutoscrollStrategy},
20 Anchor, Editor, EditorElement, EditorEvent, EditorStyle, MultiBuffer, MultiBufferSnapshot,
21 ToOffset as _, ToPoint,
22};
23use file_icons::FileIcons;
24use fs::Fs;
25use futures::StreamExt;
26use gpui::{
27 canvas, div, point, relative, rems, uniform_list, Action, AnyElement, AnyView, AppContext,
28 AsyncAppContext, AsyncWindowContext, AvailableSpace, ClipboardItem, Context, EventEmitter,
29 FocusHandle, FocusableView, FontStyle, FontWeight, HighlightStyle, InteractiveElement,
30 IntoElement, Model, ModelContext, ParentElement, Pixels, Render, SharedString,
31 StatefulInteractiveElement, Styled, Subscription, Task, TextStyle, UniformListScrollHandle,
32 View, ViewContext, VisualContext, WeakModel, WeakView, WhiteSpace, WindowContext,
33};
34use language::{language_settings::SoftWrap, Buffer, LanguageRegistry, ToOffset as _};
35use parking_lot::Mutex;
36use project::Project;
37use search::{buffer_search::DivRegistrar, BufferSearchBar};
38use settings::Settings;
39use std::{cmp, fmt::Write, iter, ops::Range, path::PathBuf, sync::Arc, time::Duration};
40use telemetry_events::AssistantKind;
41use theme::ThemeSettings;
42use ui::{
43 prelude::*,
44 utils::{DateTimeType, FormatDistance},
45 ButtonLike, Tab, TabBar, Tooltip,
46};
47use util::{paths::CONVERSATIONS_DIR, post_inc, ResultExt, TryFutureExt};
48use uuid::Uuid;
49use workspace::notifications::NotificationId;
50use workspace::{
51 dock::{DockPosition, Panel, PanelEvent},
52 searchable::Direction,
53 Event as WorkspaceEvent, Save, Toast, ToggleZoom, Toolbar, Workspace,
54};
55
56pub fn init(cx: &mut AppContext) {
57 cx.observe_new_views(
58 |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {
59 workspace
60 .register_action(|workspace, _: &ToggleFocus, cx| {
61 let settings = AssistantSettings::get_global(cx);
62 if !settings.enabled {
63 return;
64 }
65
66 workspace.toggle_panel_focus::<AssistantPanel>(cx);
67 })
68 .register_action(AssistantPanel::inline_assist)
69 .register_action(AssistantPanel::cancel_last_inline_assist)
70 .register_action(ConversationEditor::quote_selection);
71 },
72 )
73 .detach();
74}
75
76pub struct AssistantPanel {
77 workspace: WeakView<Workspace>,
78 width: Option<Pixels>,
79 height: Option<Pixels>,
80 active_conversation_editor: Option<ActiveConversationEditor>,
81 show_saved_conversations: bool,
82 saved_conversations: Vec<SavedConversationMetadata>,
83 saved_conversations_scroll_handle: UniformListScrollHandle,
84 zoomed: bool,
85 focus_handle: FocusHandle,
86 toolbar: View<Toolbar>,
87 languages: Arc<LanguageRegistry>,
88 fs: Arc<dyn Fs>,
89 _subscriptions: Vec<Subscription>,
90 next_inline_assist_id: usize,
91 pending_inline_assists: HashMap<usize, PendingInlineAssist>,
92 pending_inline_assist_ids_by_editor: HashMap<WeakView<Editor>, Vec<usize>>,
93 include_conversation_in_next_inline_assist: bool,
94 inline_prompt_history: VecDeque<String>,
95 _watch_saved_conversations: Task<Result<()>>,
96 model: LanguageModel,
97 authentication_prompt: Option<AnyView>,
98}
99
100struct ActiveConversationEditor {
101 editor: View<ConversationEditor>,
102 _subscriptions: Vec<Subscription>,
103}
104
105impl AssistantPanel {
106 const INLINE_PROMPT_HISTORY_MAX_LEN: usize = 20;
107
108 pub fn load(
109 workspace: WeakView<Workspace>,
110 cx: AsyncWindowContext,
111 ) -> Task<Result<View<Self>>> {
112 cx.spawn(|mut cx| async move {
113 let fs = workspace.update(&mut cx, |workspace, _| workspace.app_state().fs.clone())?;
114 let saved_conversations = SavedConversationMetadata::list(fs.clone())
115 .await
116 .log_err()
117 .unwrap_or_default();
118
119 // TODO: deserialize state.
120 let workspace_handle = workspace.clone();
121 workspace.update(&mut cx, |workspace, cx| {
122 cx.new_view::<Self>(|cx| {
123 const CONVERSATION_WATCH_DURATION: Duration = Duration::from_millis(100);
124 let _watch_saved_conversations = cx.spawn(move |this, mut cx| async move {
125 let mut events = fs
126 .watch(&CONVERSATIONS_DIR, CONVERSATION_WATCH_DURATION)
127 .await;
128 while events.next().await.is_some() {
129 let saved_conversations = SavedConversationMetadata::list(fs.clone())
130 .await
131 .log_err()
132 .unwrap_or_default();
133 this.update(&mut cx, |this, cx| {
134 this.saved_conversations = saved_conversations;
135 cx.notify();
136 })
137 .ok();
138 }
139
140 anyhow::Ok(())
141 });
142
143 let toolbar = cx.new_view(|cx| {
144 let mut toolbar = Toolbar::new();
145 toolbar.set_can_navigate(false, cx);
146 toolbar.add_item(cx.new_view(BufferSearchBar::new), cx);
147 toolbar
148 });
149
150 let focus_handle = cx.focus_handle();
151 let subscriptions = vec![
152 cx.on_focus_in(&focus_handle, Self::focus_in),
153 cx.on_focus_out(&focus_handle, Self::focus_out),
154 cx.observe_global::<CompletionProvider>({
155 let mut prev_settings_version =
156 CompletionProvider::global(cx).settings_version();
157 move |this, cx| {
158 this.completion_provider_changed(prev_settings_version, cx);
159 prev_settings_version =
160 CompletionProvider::global(cx).settings_version();
161 }
162 }),
163 ];
164 let model = CompletionProvider::global(cx).default_model();
165
166 cx.observe_global::<FileIcons>(|_, cx| {
167 cx.notify();
168 })
169 .detach();
170
171 Self {
172 workspace: workspace_handle,
173 active_conversation_editor: None,
174 show_saved_conversations: false,
175 saved_conversations,
176 saved_conversations_scroll_handle: Default::default(),
177 zoomed: false,
178 focus_handle,
179 toolbar,
180 languages: workspace.app_state().languages.clone(),
181 fs: workspace.app_state().fs.clone(),
182 width: None,
183 height: None,
184 _subscriptions: subscriptions,
185 next_inline_assist_id: 0,
186 pending_inline_assists: Default::default(),
187 pending_inline_assist_ids_by_editor: Default::default(),
188 include_conversation_in_next_inline_assist: false,
189 inline_prompt_history: Default::default(),
190 _watch_saved_conversations,
191 model,
192 authentication_prompt: None,
193 }
194 })
195 })
196 })
197 }
198
199 fn focus_in(&mut self, cx: &mut ViewContext<Self>) {
200 self.toolbar
201 .update(cx, |toolbar, cx| toolbar.focus_changed(true, cx));
202 cx.notify();
203 if self.focus_handle.is_focused(cx) {
204 if let Some(editor) = self.active_conversation_editor() {
205 cx.focus_view(editor);
206 }
207 }
208 }
209
210 fn focus_out(&mut self, cx: &mut ViewContext<Self>) {
211 self.toolbar
212 .update(cx, |toolbar, cx| toolbar.focus_changed(false, cx));
213 cx.notify();
214 }
215
216 fn completion_provider_changed(
217 &mut self,
218 prev_settings_version: usize,
219 cx: &mut ViewContext<Self>,
220 ) {
221 if self.is_authenticated(cx) {
222 self.authentication_prompt = None;
223
224 let model = CompletionProvider::global(cx).default_model();
225 self.set_model(model, cx);
226
227 if self.active_conversation_editor().is_none() {
228 self.new_conversation(cx);
229 }
230 } else if self.authentication_prompt.is_none()
231 || prev_settings_version != CompletionProvider::global(cx).settings_version()
232 {
233 self.authentication_prompt =
234 Some(cx.update_global::<CompletionProvider, _>(|provider, cx| {
235 provider.authentication_prompt(cx)
236 }));
237 }
238 }
239
240 pub fn inline_assist(
241 workspace: &mut Workspace,
242 _: &InlineAssist,
243 cx: &mut ViewContext<Workspace>,
244 ) {
245 let settings = AssistantSettings::get_global(cx);
246 if !settings.enabled {
247 return;
248 }
249
250 let Some(assistant) = workspace.panel::<AssistantPanel>(cx) else {
251 return;
252 };
253 let active_editor = if let Some(active_editor) = workspace
254 .active_item(cx)
255 .and_then(|item| item.act_as::<Editor>(cx))
256 {
257 active_editor
258 } else {
259 return;
260 };
261 let project = workspace.project().clone();
262
263 if assistant.update(cx, |assistant, cx| assistant.is_authenticated(cx)) {
264 assistant.update(cx, |assistant, cx| {
265 assistant.new_inline_assist(&active_editor, cx, &project)
266 });
267 } else {
268 let assistant = assistant.downgrade();
269 cx.spawn(|workspace, mut cx| async move {
270 assistant
271 .update(&mut cx, |assistant, cx| assistant.authenticate(cx))?
272 .await?;
273 if assistant.update(&mut cx, |assistant, cx| assistant.is_authenticated(cx))? {
274 assistant.update(&mut cx, |assistant, cx| {
275 assistant.new_inline_assist(&active_editor, cx, &project)
276 })?;
277 } else {
278 workspace.update(&mut cx, |workspace, cx| {
279 workspace.focus_panel::<AssistantPanel>(cx)
280 })?;
281 }
282
283 anyhow::Ok(())
284 })
285 .detach_and_log_err(cx)
286 }
287 }
288
289 fn new_inline_assist(
290 &mut self,
291 editor: &View<Editor>,
292 cx: &mut ViewContext<Self>,
293 project: &Model<Project>,
294 ) {
295 let selection = editor.read(cx).selections.newest_anchor().clone();
296 if selection.start.excerpt_id != selection.end.excerpt_id {
297 return;
298 }
299 let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
300
301 // Extend the selection to the start and the end of the line.
302 let mut point_selection = selection.map(|selection| selection.to_point(&snapshot));
303 if point_selection.end > point_selection.start {
304 point_selection.start.column = 0;
305 // If the selection ends at the start of the line, we don't want to include it.
306 if point_selection.end.column == 0 {
307 point_selection.end.row -= 1;
308 }
309 point_selection.end.column = snapshot.line_len(point_selection.end.row);
310 }
311
312 let codegen_kind = if point_selection.start == point_selection.end {
313 CodegenKind::Generate {
314 position: snapshot.anchor_after(point_selection.start),
315 }
316 } else {
317 CodegenKind::Transform {
318 range: snapshot.anchor_before(point_selection.start)
319 ..snapshot.anchor_after(point_selection.end),
320 }
321 };
322
323 let inline_assist_id = post_inc(&mut self.next_inline_assist_id);
324
325 let codegen =
326 cx.new_model(|cx| Codegen::new(editor.read(cx).buffer().clone(), codegen_kind, cx));
327
328 let measurements = Arc::new(Mutex::new(BlockMeasurements::default()));
329 let inline_assistant = cx.new_view(|cx| {
330 InlineAssistant::new(
331 inline_assist_id,
332 measurements.clone(),
333 self.include_conversation_in_next_inline_assist,
334 self.inline_prompt_history.clone(),
335 codegen.clone(),
336 self.workspace.clone(),
337 cx,
338 )
339 });
340 let block_id = editor.update(cx, |editor, cx| {
341 editor.change_selections(None, cx, |selections| {
342 selections.select_anchor_ranges([selection.head()..selection.head()])
343 });
344 editor.insert_blocks(
345 [BlockProperties {
346 style: BlockStyle::Flex,
347 position: snapshot.anchor_before(point_selection.head()),
348 height: 2,
349 render: Box::new({
350 let inline_assistant = inline_assistant.clone();
351 move |cx: &mut BlockContext| {
352 *measurements.lock() = BlockMeasurements {
353 anchor_x: cx.anchor_x,
354 gutter_width: cx.gutter_dimensions.width,
355 };
356 inline_assistant.clone().into_any_element()
357 }
358 }),
359 disposition: if selection.reversed {
360 BlockDisposition::Above
361 } else {
362 BlockDisposition::Below
363 },
364 }],
365 Some(Autoscroll::Strategy(AutoscrollStrategy::Newest)),
366 cx,
367 )[0]
368 });
369
370 self.pending_inline_assists.insert(
371 inline_assist_id,
372 PendingInlineAssist {
373 editor: editor.downgrade(),
374 inline_assistant: Some((block_id, inline_assistant.clone())),
375 codegen: codegen.clone(),
376 project: project.downgrade(),
377 _subscriptions: vec![
378 cx.subscribe(&inline_assistant, Self::handle_inline_assistant_event),
379 cx.subscribe(editor, {
380 let inline_assistant = inline_assistant.downgrade();
381 move |_, editor, event, cx| {
382 if let Some(inline_assistant) = inline_assistant.upgrade() {
383 if let EditorEvent::SelectionsChanged { local } = event {
384 if *local
385 && inline_assistant.focus_handle(cx).contains_focused(cx)
386 {
387 cx.focus_view(&editor);
388 }
389 }
390 }
391 }
392 }),
393 cx.observe(&codegen, {
394 let editor = editor.downgrade();
395 move |this, _, cx| {
396 if let Some(editor) = editor.upgrade() {
397 this.update_highlights_for_editor(&editor, cx);
398 }
399 }
400 }),
401 cx.subscribe(&codegen, move |this, codegen, event, cx| match event {
402 codegen::Event::Undone => {
403 this.finish_inline_assist(inline_assist_id, false, cx)
404 }
405 codegen::Event::Finished => {
406 let pending_assist = if let Some(pending_assist) =
407 this.pending_inline_assists.get(&inline_assist_id)
408 {
409 pending_assist
410 } else {
411 return;
412 };
413
414 let error = codegen
415 .read(cx)
416 .error()
417 .map(|error| format!("Inline assistant error: {}", error));
418 if let Some(error) = error {
419 if pending_assist.inline_assistant.is_none() {
420 if let Some(workspace) = this.workspace.upgrade() {
421 workspace.update(cx, |workspace, cx| {
422 struct InlineAssistantError;
423
424 let id =
425 NotificationId::identified::<InlineAssistantError>(
426 inline_assist_id,
427 );
428
429 workspace.show_toast(Toast::new(id, error), cx);
430 })
431 }
432
433 this.finish_inline_assist(inline_assist_id, false, cx);
434 }
435 } else {
436 this.finish_inline_assist(inline_assist_id, false, cx);
437 }
438 }
439 }),
440 ],
441 },
442 );
443 self.pending_inline_assist_ids_by_editor
444 .entry(editor.downgrade())
445 .or_default()
446 .push(inline_assist_id);
447 self.update_highlights_for_editor(editor, cx);
448 }
449
450 fn handle_inline_assistant_event(
451 &mut self,
452 inline_assistant: View<InlineAssistant>,
453 event: &InlineAssistantEvent,
454 cx: &mut ViewContext<Self>,
455 ) {
456 let assist_id = inline_assistant.read(cx).id;
457 match event {
458 InlineAssistantEvent::Confirmed {
459 prompt,
460 include_conversation,
461 } => {
462 self.confirm_inline_assist(assist_id, prompt, *include_conversation, cx);
463 }
464 InlineAssistantEvent::Canceled => {
465 self.finish_inline_assist(assist_id, true, cx);
466 }
467 InlineAssistantEvent::Dismissed => {
468 self.hide_inline_assist(assist_id, cx);
469 }
470 InlineAssistantEvent::IncludeConversationToggled {
471 include_conversation,
472 } => {
473 self.include_conversation_in_next_inline_assist = *include_conversation;
474 }
475 }
476 }
477
478 fn cancel_last_inline_assist(
479 workspace: &mut Workspace,
480 _: &editor::actions::Cancel,
481 cx: &mut ViewContext<Workspace>,
482 ) {
483 if let Some(panel) = workspace.panel::<AssistantPanel>(cx) {
484 if let Some(editor) = workspace
485 .active_item(cx)
486 .and_then(|item| item.downcast::<Editor>())
487 {
488 let handled = panel.update(cx, |panel, cx| {
489 if let Some(assist_id) = panel
490 .pending_inline_assist_ids_by_editor
491 .get(&editor.downgrade())
492 .and_then(|assist_ids| assist_ids.last().copied())
493 {
494 panel.finish_inline_assist(assist_id, true, cx);
495 true
496 } else {
497 false
498 }
499 });
500 if handled {
501 return;
502 }
503 }
504 }
505
506 cx.propagate();
507 }
508
509 fn finish_inline_assist(&mut self, assist_id: usize, undo: bool, cx: &mut ViewContext<Self>) {
510 self.hide_inline_assist(assist_id, cx);
511
512 if let Some(pending_assist) = self.pending_inline_assists.remove(&assist_id) {
513 if let hash_map::Entry::Occupied(mut entry) = self
514 .pending_inline_assist_ids_by_editor
515 .entry(pending_assist.editor.clone())
516 {
517 entry.get_mut().retain(|id| *id != assist_id);
518 if entry.get().is_empty() {
519 entry.remove();
520 }
521 }
522
523 if let Some(editor) = pending_assist.editor.upgrade() {
524 self.update_highlights_for_editor(&editor, cx);
525
526 if undo {
527 pending_assist
528 .codegen
529 .update(cx, |codegen, cx| codegen.undo(cx));
530 }
531 }
532 }
533 }
534
535 fn hide_inline_assist(&mut self, assist_id: usize, cx: &mut ViewContext<Self>) {
536 if let Some(pending_assist) = self.pending_inline_assists.get_mut(&assist_id) {
537 if let Some(editor) = pending_assist.editor.upgrade() {
538 if let Some((block_id, inline_assistant)) = pending_assist.inline_assistant.take() {
539 editor.update(cx, |editor, cx| {
540 editor.remove_blocks(HashSet::from_iter([block_id]), None, cx);
541 if inline_assistant.focus_handle(cx).contains_focused(cx) {
542 editor.focus(cx);
543 }
544 });
545 }
546 }
547 }
548 }
549
550 fn confirm_inline_assist(
551 &mut self,
552 inline_assist_id: usize,
553 user_prompt: &str,
554 include_conversation: bool,
555 cx: &mut ViewContext<Self>,
556 ) {
557 let conversation = if include_conversation {
558 self.active_conversation_editor()
559 .map(|editor| editor.read(cx).conversation.clone())
560 } else {
561 None
562 };
563
564 let pending_assist =
565 if let Some(pending_assist) = self.pending_inline_assists.get_mut(&inline_assist_id) {
566 pending_assist
567 } else {
568 return;
569 };
570
571 let editor = if let Some(editor) = pending_assist.editor.upgrade() {
572 editor
573 } else {
574 return;
575 };
576
577 let project = pending_assist.project.clone();
578
579 let project_name = project.upgrade().map(|project| {
580 project
581 .read(cx)
582 .worktree_root_names(cx)
583 .collect::<Vec<&str>>()
584 .join("/")
585 });
586
587 self.inline_prompt_history
588 .retain(|prompt| prompt != user_prompt);
589 self.inline_prompt_history.push_back(user_prompt.into());
590 if self.inline_prompt_history.len() > Self::INLINE_PROMPT_HISTORY_MAX_LEN {
591 self.inline_prompt_history.pop_front();
592 }
593
594 let codegen = pending_assist.codegen.clone();
595 let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
596 let range = codegen.read(cx).range();
597 let start = snapshot.point_to_buffer_offset(range.start);
598 let end = snapshot.point_to_buffer_offset(range.end);
599 let (buffer, range) = if let Some((start, end)) = start.zip(end) {
600 let (start_buffer, start_buffer_offset) = start;
601 let (end_buffer, end_buffer_offset) = end;
602 if start_buffer.remote_id() == end_buffer.remote_id() {
603 (start_buffer.clone(), start_buffer_offset..end_buffer_offset)
604 } else {
605 self.finish_inline_assist(inline_assist_id, false, cx);
606 return;
607 }
608 } else {
609 self.finish_inline_assist(inline_assist_id, false, cx);
610 return;
611 };
612
613 let language = buffer.language_at(range.start);
614 let language_name = if let Some(language) = language.as_ref() {
615 if Arc::ptr_eq(language, &language::PLAIN_TEXT) {
616 None
617 } else {
618 Some(language.name())
619 }
620 } else {
621 None
622 };
623
624 // Higher Temperature increases the randomness of model outputs.
625 // If Markdown or No Language is Known, increase the randomness for more creative output
626 // If Code, decrease temperature to get more deterministic outputs
627 let temperature = if let Some(language) = language_name.clone() {
628 if language.as_ref() == "Markdown" {
629 1.0
630 } else {
631 0.5
632 }
633 } else {
634 1.0
635 };
636
637 let user_prompt = user_prompt.to_string();
638
639 let prompt = cx.background_executor().spawn(async move {
640 let language_name = language_name.as_deref();
641 generate_content_prompt(user_prompt, language_name, buffer, range, project_name)
642 });
643
644 let mut messages = Vec::new();
645 if let Some(conversation) = conversation {
646 let conversation = conversation.read(cx);
647 let buffer = conversation.buffer.read(cx);
648 messages.extend(
649 conversation
650 .messages(cx)
651 .map(|message| message.to_open_ai_message(buffer)),
652 );
653 }
654 let model = self.model.clone();
655
656 cx.spawn(|_, mut cx| async move {
657 // I Don't know if we want to return a ? here.
658 let prompt = prompt.await?;
659
660 messages.push(LanguageModelRequestMessage {
661 role: Role::User,
662 content: prompt,
663 });
664
665 let request = LanguageModelRequest {
666 model,
667 messages,
668 stop: vec!["|END|>".to_string()],
669 temperature,
670 };
671
672 codegen.update(&mut cx, |codegen, cx| codegen.start(request, cx))?;
673 anyhow::Ok(())
674 })
675 .detach();
676 }
677
678 fn update_highlights_for_editor(&self, editor: &View<Editor>, cx: &mut ViewContext<Self>) {
679 let mut background_ranges = Vec::new();
680 let mut foreground_ranges = Vec::new();
681 let empty_inline_assist_ids = Vec::new();
682 let inline_assist_ids = self
683 .pending_inline_assist_ids_by_editor
684 .get(&editor.downgrade())
685 .unwrap_or(&empty_inline_assist_ids);
686
687 for inline_assist_id in inline_assist_ids {
688 if let Some(pending_assist) = self.pending_inline_assists.get(inline_assist_id) {
689 let codegen = pending_assist.codegen.read(cx);
690 background_ranges.push(codegen.range());
691 foreground_ranges.extend(codegen.last_equal_ranges().iter().cloned());
692 }
693 }
694
695 let snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);
696 merge_ranges(&mut background_ranges, &snapshot);
697 merge_ranges(&mut foreground_ranges, &snapshot);
698 editor.update(cx, |editor, cx| {
699 if background_ranges.is_empty() {
700 editor.clear_background_highlights::<PendingInlineAssist>(cx);
701 } else {
702 editor.highlight_background::<PendingInlineAssist>(
703 &background_ranges,
704 |theme| theme.editor_active_line_background, // TODO use the appropriate color
705 cx,
706 );
707 }
708
709 if foreground_ranges.is_empty() {
710 editor.clear_highlights::<PendingInlineAssist>(cx);
711 } else {
712 editor.highlight_text::<PendingInlineAssist>(
713 foreground_ranges,
714 HighlightStyle {
715 fade_out: Some(0.6),
716 ..Default::default()
717 },
718 cx,
719 );
720 }
721 });
722 }
723
724 fn new_conversation(&mut self, cx: &mut ViewContext<Self>) -> Option<View<ConversationEditor>> {
725 let workspace = self.workspace.upgrade()?;
726
727 let editor = cx.new_view(|cx| {
728 ConversationEditor::new(
729 self.model.clone(),
730 self.languages.clone(),
731 self.fs.clone(),
732 workspace,
733 cx,
734 )
735 });
736 self.show_conversation(editor.clone(), cx);
737 Some(editor)
738 }
739
740 fn show_conversation(
741 &mut self,
742 conversation_editor: View<ConversationEditor>,
743 cx: &mut ViewContext<Self>,
744 ) {
745 let mut subscriptions = Vec::new();
746 subscriptions
747 .push(cx.subscribe(&conversation_editor, Self::handle_conversation_editor_event));
748
749 let conversation = conversation_editor.read(cx).conversation.clone();
750 subscriptions.push(cx.observe(&conversation, |_, _, cx| cx.notify()));
751
752 let editor = conversation_editor.read(cx).editor.clone();
753 self.toolbar.update(cx, |toolbar, cx| {
754 toolbar.set_active_item(Some(&editor), cx);
755 });
756 if self.focus_handle.contains_focused(cx) {
757 cx.focus_view(&editor);
758 }
759 self.active_conversation_editor = Some(ActiveConversationEditor {
760 editor: conversation_editor,
761 _subscriptions: subscriptions,
762 });
763 self.show_saved_conversations = false;
764
765 cx.notify();
766 }
767
768 fn cycle_model(&mut self, cx: &mut ViewContext<Self>) {
769 let next_model = match &self.model {
770 LanguageModel::OpenAi(model) => LanguageModel::OpenAi(match &model {
771 open_ai::Model::ThreePointFiveTurbo => open_ai::Model::Four,
772 open_ai::Model::Four => open_ai::Model::FourTurbo,
773 open_ai::Model::FourTurbo => open_ai::Model::ThreePointFiveTurbo,
774 }),
775 LanguageModel::ZedDotDev(model) => LanguageModel::ZedDotDev(match &model {
776 ZedDotDevModel::Gpt3Point5Turbo => ZedDotDevModel::Gpt4,
777 ZedDotDevModel::Gpt4 => ZedDotDevModel::Gpt4Turbo,
778 ZedDotDevModel::Gpt4Turbo => ZedDotDevModel::Claude3Opus,
779 ZedDotDevModel::Claude3Opus => ZedDotDevModel::Claude3Sonnet,
780 ZedDotDevModel::Claude3Sonnet => ZedDotDevModel::Claude3Haiku,
781 ZedDotDevModel::Claude3Haiku => {
782 match CompletionProvider::global(cx).default_model() {
783 LanguageModel::ZedDotDev(custom) => custom,
784 _ => ZedDotDevModel::Gpt3Point5Turbo,
785 }
786 }
787 ZedDotDevModel::Custom(_) => ZedDotDevModel::Gpt3Point5Turbo,
788 }),
789 };
790
791 self.set_model(next_model, cx);
792 }
793
794 fn set_model(&mut self, model: LanguageModel, cx: &mut ViewContext<Self>) {
795 self.model = model.clone();
796 if let Some(editor) = self.active_conversation_editor() {
797 editor.update(cx, |active_conversation, cx| {
798 active_conversation
799 .conversation
800 .update(cx, |conversation, cx| {
801 conversation.set_model(model, cx);
802 })
803 })
804 }
805 cx.notify();
806 }
807
808 fn handle_conversation_editor_event(
809 &mut self,
810 _: View<ConversationEditor>,
811 event: &ConversationEditorEvent,
812 cx: &mut ViewContext<Self>,
813 ) {
814 match event {
815 ConversationEditorEvent::TabContentChanged => cx.notify(),
816 }
817 }
818
819 fn toggle_zoom(&mut self, _: &workspace::ToggleZoom, cx: &mut ViewContext<Self>) {
820 if self.zoomed {
821 cx.emit(PanelEvent::ZoomOut)
822 } else {
823 cx.emit(PanelEvent::ZoomIn)
824 }
825 }
826
827 fn deploy(&mut self, action: &search::buffer_search::Deploy, cx: &mut ViewContext<Self>) {
828 let mut propagate = true;
829 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
830 search_bar.update(cx, |search_bar, cx| {
831 if search_bar.show(cx) {
832 search_bar.search_suggested(cx);
833 if action.focus {
834 let focus_handle = search_bar.focus_handle(cx);
835 search_bar.select_query(cx);
836 cx.focus(&focus_handle);
837 }
838 propagate = false
839 }
840 });
841 }
842 if propagate {
843 cx.propagate();
844 }
845 }
846
847 fn handle_editor_cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
848 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
849 if !search_bar.read(cx).is_dismissed() {
850 search_bar.update(cx, |search_bar, cx| {
851 search_bar.dismiss(&Default::default(), cx)
852 });
853 return;
854 }
855 }
856 cx.propagate();
857 }
858
859 fn select_next_match(&mut self, _: &search::SelectNextMatch, cx: &mut ViewContext<Self>) {
860 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
861 search_bar.update(cx, |bar, cx| bar.select_match(Direction::Next, 1, cx));
862 }
863 }
864
865 fn select_prev_match(&mut self, _: &search::SelectPrevMatch, cx: &mut ViewContext<Self>) {
866 if let Some(search_bar) = self.toolbar.read(cx).item_of_type::<BufferSearchBar>() {
867 search_bar.update(cx, |bar, cx| bar.select_match(Direction::Prev, 1, cx));
868 }
869 }
870
871 fn reset_credentials(&mut self, _: &ResetKey, cx: &mut ViewContext<Self>) {
872 CompletionProvider::global(cx)
873 .reset_credentials(cx)
874 .detach_and_log_err(cx);
875 }
876
877 fn active_conversation_editor(&self) -> Option<&View<ConversationEditor>> {
878 Some(&self.active_conversation_editor.as_ref()?.editor)
879 }
880
881 fn render_hamburger_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
882 IconButton::new("hamburger_button", IconName::Menu)
883 .on_click(cx.listener(|this, _event, cx| {
884 this.show_saved_conversations = !this.show_saved_conversations;
885 cx.notify();
886 }))
887 .tooltip(|cx| Tooltip::text("Conversation History", cx))
888 }
889
890 fn render_editor_tools(&self, cx: &mut ViewContext<Self>) -> Vec<AnyElement> {
891 if self.active_conversation_editor().is_some() {
892 vec![
893 Self::render_split_button(cx).into_any_element(),
894 Self::render_quote_button(cx).into_any_element(),
895 Self::render_assist_button(cx).into_any_element(),
896 ]
897 } else {
898 Default::default()
899 }
900 }
901
902 fn render_split_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
903 IconButton::new("split_button", IconName::Snip)
904 .on_click(cx.listener(|this, _event, cx| {
905 if let Some(active_editor) = this.active_conversation_editor() {
906 active_editor.update(cx, |editor, cx| editor.split(&Default::default(), cx));
907 }
908 }))
909 .icon_size(IconSize::Small)
910 .tooltip(|cx| Tooltip::for_action("Split Message", &Split, cx))
911 }
912
913 fn render_assist_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
914 IconButton::new("assist_button", IconName::MagicWand)
915 .on_click(cx.listener(|this, _event, cx| {
916 if let Some(active_editor) = this.active_conversation_editor() {
917 active_editor.update(cx, |editor, cx| editor.assist(&Default::default(), cx));
918 }
919 }))
920 .icon_size(IconSize::Small)
921 .tooltip(|cx| Tooltip::for_action("Assist", &Assist, cx))
922 }
923
924 fn render_quote_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
925 IconButton::new("quote_button", IconName::Quote)
926 .on_click(cx.listener(|this, _event, cx| {
927 if let Some(workspace) = this.workspace.upgrade() {
928 cx.window_context().defer(move |cx| {
929 workspace.update(cx, |workspace, cx| {
930 ConversationEditor::quote_selection(workspace, &Default::default(), cx)
931 });
932 });
933 }
934 }))
935 .icon_size(IconSize::Small)
936 .tooltip(|cx| Tooltip::for_action("Quote Selection", &QuoteSelection, cx))
937 }
938
939 fn render_plus_button(cx: &mut ViewContext<Self>) -> impl IntoElement {
940 IconButton::new("plus_button", IconName::Plus)
941 .on_click(cx.listener(|this, _event, cx| {
942 this.new_conversation(cx);
943 }))
944 .icon_size(IconSize::Small)
945 .tooltip(|cx| Tooltip::for_action("New Conversation", &NewConversation, cx))
946 }
947
948 fn render_zoom_button(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
949 let zoomed = self.zoomed;
950 IconButton::new("zoom_button", IconName::Maximize)
951 .on_click(cx.listener(|this, _event, cx| {
952 this.toggle_zoom(&ToggleZoom, cx);
953 }))
954 .selected(zoomed)
955 .selected_icon(IconName::Minimize)
956 .icon_size(IconSize::Small)
957 .tooltip(move |cx| {
958 Tooltip::for_action(if zoomed { "Zoom Out" } else { "Zoom In" }, &ToggleZoom, cx)
959 })
960 }
961
962 fn render_saved_conversation(
963 &mut self,
964 index: usize,
965 cx: &mut ViewContext<Self>,
966 ) -> impl IntoElement {
967 let conversation = &self.saved_conversations[index];
968 let path = conversation.path.clone();
969
970 ButtonLike::new(index)
971 .on_click(cx.listener(move |this, _, cx| {
972 this.open_conversation(path.clone(), cx)
973 .detach_and_log_err(cx)
974 }))
975 .full_width()
976 .child(
977 div()
978 .flex()
979 .w_full()
980 .gap_2()
981 .child(
982 Label::new(conversation.mtime.format("%F %I:%M%p").to_string())
983 .color(Color::Muted)
984 .size(LabelSize::Small),
985 )
986 .child(Label::new(conversation.title.clone()).size(LabelSize::Small)),
987 )
988 }
989
990 fn open_conversation(&mut self, path: PathBuf, cx: &mut ViewContext<Self>) -> Task<Result<()>> {
991 cx.focus(&self.focus_handle);
992
993 let fs = self.fs.clone();
994 let workspace = self.workspace.clone();
995 let languages = self.languages.clone();
996 cx.spawn(|this, mut cx| async move {
997 let saved_conversation = SavedConversation::load(&path, fs.as_ref()).await?;
998 let model = this.update(&mut cx, |this, _| this.model.clone())?;
999 let conversation = Conversation::deserialize(
1000 saved_conversation,
1001 model,
1002 path.clone(),
1003 languages,
1004 &mut cx,
1005 )
1006 .await?;
1007
1008 this.update(&mut cx, |this, cx| {
1009 let workspace = workspace
1010 .upgrade()
1011 .ok_or_else(|| anyhow!("workspace dropped"))?;
1012 let editor = cx.new_view(|cx| {
1013 ConversationEditor::for_conversation(conversation, fs, workspace, cx)
1014 });
1015 this.show_conversation(editor, cx);
1016 anyhow::Ok(())
1017 })??;
1018 Ok(())
1019 })
1020 }
1021
1022 fn is_authenticated(&mut self, cx: &mut ViewContext<Self>) -> bool {
1023 CompletionProvider::global(cx).is_authenticated()
1024 }
1025
1026 fn authenticate(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<()>> {
1027 cx.update_global::<CompletionProvider, _>(|provider, cx| provider.authenticate(cx))
1028 }
1029
1030 fn render_signed_in(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1031 let header = TabBar::new("assistant_header")
1032 .start_child(
1033 h_flex().gap_1().child(Self::render_hamburger_button(cx)), // .children(title),
1034 )
1035 .children(self.active_conversation_editor().map(|editor| {
1036 h_flex()
1037 .h(rems(Tab::CONTAINER_HEIGHT_IN_REMS))
1038 .flex_1()
1039 .px_2()
1040 .child(Label::new(editor.read(cx).title(cx)).into_element())
1041 }))
1042 .when(self.focus_handle.contains_focused(cx), |this| {
1043 this.end_child(
1044 h_flex()
1045 .gap_2()
1046 .when(self.active_conversation_editor().is_some(), |this| {
1047 this.child(h_flex().gap_1().children(self.render_editor_tools(cx)))
1048 .child(
1049 ui::Divider::vertical()
1050 .inset()
1051 .color(ui::DividerColor::Border),
1052 )
1053 })
1054 .child(
1055 h_flex()
1056 .gap_1()
1057 .child(Self::render_plus_button(cx))
1058 .child(self.render_zoom_button(cx)),
1059 ),
1060 )
1061 });
1062
1063 let contents = if self.active_conversation_editor().is_some() {
1064 let mut registrar = DivRegistrar::new(
1065 |panel, cx| panel.toolbar.read(cx).item_of_type::<BufferSearchBar>(),
1066 cx,
1067 );
1068 BufferSearchBar::register(&mut registrar);
1069 registrar.into_div()
1070 } else {
1071 div()
1072 };
1073 v_flex()
1074 .key_context("AssistantPanel")
1075 .size_full()
1076 .on_action(cx.listener(|this, _: &workspace::NewFile, cx| {
1077 this.new_conversation(cx);
1078 }))
1079 .on_action(cx.listener(AssistantPanel::toggle_zoom))
1080 .on_action(cx.listener(AssistantPanel::deploy))
1081 .on_action(cx.listener(AssistantPanel::select_next_match))
1082 .on_action(cx.listener(AssistantPanel::select_prev_match))
1083 .on_action(cx.listener(AssistantPanel::handle_editor_cancel))
1084 .on_action(cx.listener(AssistantPanel::reset_credentials))
1085 .track_focus(&self.focus_handle)
1086 .child(header)
1087 .children(if self.toolbar.read(cx).hidden() {
1088 None
1089 } else {
1090 Some(self.toolbar.clone())
1091 })
1092 .child(contents.flex_1().child(
1093 if self.show_saved_conversations || self.active_conversation_editor().is_none() {
1094 let view = cx.view().clone();
1095 let scroll_handle = self.saved_conversations_scroll_handle.clone();
1096 let conversation_count = self.saved_conversations.len();
1097 canvas(
1098 move |bounds, cx| {
1099 let mut saved_conversations = uniform_list(
1100 view,
1101 "saved_conversations",
1102 conversation_count,
1103 |this, range, cx| {
1104 range
1105 .map(|ix| this.render_saved_conversation(ix, cx))
1106 .collect()
1107 },
1108 )
1109 .track_scroll(scroll_handle)
1110 .into_any_element();
1111 saved_conversations.prepaint_as_root(
1112 bounds.origin,
1113 bounds.size.map(AvailableSpace::Definite),
1114 cx,
1115 );
1116 saved_conversations
1117 },
1118 |_bounds, mut saved_conversations, cx| saved_conversations.paint(cx),
1119 )
1120 .size_full()
1121 .into_any_element()
1122 } else if let Some(editor) = self.active_conversation_editor() {
1123 let editor = editor.clone();
1124 let conversation = editor.read(cx).conversation.clone();
1125 div()
1126 .size_full()
1127 .child(editor.clone())
1128 .child(
1129 h_flex()
1130 .absolute()
1131 .gap_1()
1132 .top_3()
1133 .right_5()
1134 .child(self.render_model(&conversation, cx))
1135 .children(self.render_remaining_tokens(&conversation, cx)),
1136 )
1137 .into_any_element()
1138 } else {
1139 div().into_any_element()
1140 },
1141 ))
1142 }
1143
1144 fn render_model(
1145 &self,
1146 conversation: &Model<Conversation>,
1147 cx: &mut ViewContext<Self>,
1148 ) -> impl IntoElement {
1149 Button::new("current_model", conversation.read(cx).model.display_name())
1150 .style(ButtonStyle::Filled)
1151 .tooltip(move |cx| Tooltip::text("Change Model", cx))
1152 .on_click(cx.listener(|this, _, cx| this.cycle_model(cx)))
1153 }
1154
1155 fn render_remaining_tokens(
1156 &self,
1157 conversation: &Model<Conversation>,
1158 cx: &mut ViewContext<Self>,
1159 ) -> Option<impl IntoElement> {
1160 let remaining_tokens = conversation.read(cx).remaining_tokens()?;
1161 let remaining_tokens_color = if remaining_tokens <= 0 {
1162 Color::Error
1163 } else if remaining_tokens <= 500 {
1164 Color::Warning
1165 } else {
1166 Color::Default
1167 };
1168 Some(Label::new(remaining_tokens.to_string()).color(remaining_tokens_color))
1169 }
1170}
1171
1172impl Render for AssistantPanel {
1173 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
1174 if let Some(authentication_prompt) = self.authentication_prompt.as_ref() {
1175 authentication_prompt.clone().into_any()
1176 } else {
1177 self.render_signed_in(cx).into_any_element()
1178 }
1179 }
1180}
1181
1182impl Panel for AssistantPanel {
1183 fn persistent_name() -> &'static str {
1184 "AssistantPanel"
1185 }
1186
1187 fn position(&self, cx: &WindowContext) -> DockPosition {
1188 match AssistantSettings::get_global(cx).dock {
1189 AssistantDockPosition::Left => DockPosition::Left,
1190 AssistantDockPosition::Bottom => DockPosition::Bottom,
1191 AssistantDockPosition::Right => DockPosition::Right,
1192 }
1193 }
1194
1195 fn position_is_valid(&self, _: DockPosition) -> bool {
1196 true
1197 }
1198
1199 fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext<Self>) {
1200 settings::update_settings_file::<AssistantSettings>(self.fs.clone(), cx, move |settings| {
1201 let dock = match position {
1202 DockPosition::Left => AssistantDockPosition::Left,
1203 DockPosition::Bottom => AssistantDockPosition::Bottom,
1204 DockPosition::Right => AssistantDockPosition::Right,
1205 };
1206 settings.set_dock(dock);
1207 });
1208 }
1209
1210 fn size(&self, cx: &WindowContext) -> Pixels {
1211 let settings = AssistantSettings::get_global(cx);
1212 match self.position(cx) {
1213 DockPosition::Left | DockPosition::Right => {
1214 self.width.unwrap_or(settings.default_width)
1215 }
1216 DockPosition::Bottom => self.height.unwrap_or(settings.default_height),
1217 }
1218 }
1219
1220 fn set_size(&mut self, size: Option<Pixels>, cx: &mut ViewContext<Self>) {
1221 match self.position(cx) {
1222 DockPosition::Left | DockPosition::Right => self.width = size,
1223 DockPosition::Bottom => self.height = size,
1224 }
1225 cx.notify();
1226 }
1227
1228 fn is_zoomed(&self, _: &WindowContext) -> bool {
1229 self.zoomed
1230 }
1231
1232 fn set_zoomed(&mut self, zoomed: bool, cx: &mut ViewContext<Self>) {
1233 self.zoomed = zoomed;
1234 cx.notify();
1235 }
1236
1237 fn set_active(&mut self, active: bool, cx: &mut ViewContext<Self>) {
1238 if active {
1239 let load_credentials = self.authenticate(cx);
1240 cx.spawn(|this, mut cx| async move {
1241 load_credentials.await?;
1242 this.update(&mut cx, |this, cx| {
1243 if this.is_authenticated(cx) && this.active_conversation_editor().is_none() {
1244 this.new_conversation(cx);
1245 }
1246 })
1247 })
1248 .detach_and_log_err(cx);
1249 }
1250 }
1251
1252 fn icon(&self, cx: &WindowContext) -> Option<IconName> {
1253 let settings = AssistantSettings::get_global(cx);
1254 if !settings.enabled || !settings.button {
1255 return None;
1256 }
1257
1258 Some(IconName::Ai)
1259 }
1260
1261 fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
1262 Some("Assistant Panel")
1263 }
1264
1265 fn toggle_action(&self) -> Box<dyn Action> {
1266 Box::new(ToggleFocus)
1267 }
1268}
1269
1270impl EventEmitter<PanelEvent> for AssistantPanel {}
1271
1272impl FocusableView for AssistantPanel {
1273 fn focus_handle(&self, _cx: &AppContext) -> FocusHandle {
1274 self.focus_handle.clone()
1275 }
1276}
1277
1278enum ConversationEvent {
1279 MessagesEdited,
1280 SummaryChanged,
1281 StreamedCompletion,
1282}
1283
1284#[derive(Default)]
1285struct Summary {
1286 text: String,
1287 done: bool,
1288}
1289
1290pub struct Conversation {
1291 id: Option<String>,
1292 buffer: Model<Buffer>,
1293 embedded_scope: EmbeddedScope,
1294 message_anchors: Vec<MessageAnchor>,
1295 messages_metadata: HashMap<MessageId, MessageMetadata>,
1296 next_message_id: MessageId,
1297 summary: Option<Summary>,
1298 pending_summary: Task<Option<()>>,
1299 completion_count: usize,
1300 pending_completions: Vec<PendingCompletion>,
1301 model: LanguageModel,
1302 token_count: Option<usize>,
1303 pending_token_count: Task<Option<()>>,
1304 pending_save: Task<Result<()>>,
1305 path: Option<PathBuf>,
1306 _subscriptions: Vec<Subscription>,
1307}
1308
1309impl EventEmitter<ConversationEvent> for Conversation {}
1310
1311impl Conversation {
1312 fn new(
1313 model: LanguageModel,
1314 language_registry: Arc<LanguageRegistry>,
1315 embedded_scope: EmbeddedScope,
1316 cx: &mut ModelContext<Self>,
1317 ) -> Self {
1318 let markdown = language_registry.language_for_name("Markdown");
1319 let buffer = cx.new_model(|cx| {
1320 let mut buffer = Buffer::local("", cx);
1321 buffer.set_language_registry(language_registry);
1322 cx.spawn(|buffer, mut cx| async move {
1323 let markdown = markdown.await?;
1324 buffer.update(&mut cx, |buffer: &mut Buffer, cx| {
1325 buffer.set_language(Some(markdown), cx)
1326 })?;
1327 anyhow::Ok(())
1328 })
1329 .detach_and_log_err(cx);
1330 buffer
1331 });
1332
1333 let mut this = Self {
1334 id: Some(Uuid::new_v4().to_string()),
1335 message_anchors: Default::default(),
1336 messages_metadata: Default::default(),
1337 next_message_id: Default::default(),
1338 summary: None,
1339 pending_summary: Task::ready(None),
1340 completion_count: Default::default(),
1341 pending_completions: Default::default(),
1342 token_count: None,
1343 pending_token_count: Task::ready(None),
1344 model,
1345 _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)],
1346 pending_save: Task::ready(Ok(())),
1347 path: None,
1348 buffer,
1349 embedded_scope,
1350 };
1351
1352 let message = MessageAnchor {
1353 id: MessageId(post_inc(&mut this.next_message_id.0)),
1354 start: language::Anchor::MIN,
1355 };
1356 this.message_anchors.push(message.clone());
1357 this.messages_metadata.insert(
1358 message.id,
1359 MessageMetadata {
1360 role: Role::User,
1361 sent_at: Local::now(),
1362 status: MessageStatus::Done,
1363 },
1364 );
1365
1366 this.count_remaining_tokens(cx);
1367 this
1368 }
1369
1370 fn serialize(&self, cx: &AppContext) -> SavedConversation {
1371 SavedConversation {
1372 id: self.id.clone(),
1373 zed: "conversation".into(),
1374 version: SavedConversation::VERSION.into(),
1375 text: self.buffer.read(cx).text(),
1376 message_metadata: self.messages_metadata.clone(),
1377 messages: self
1378 .messages(cx)
1379 .map(|message| SavedMessage {
1380 id: message.id,
1381 start: message.offset_range.start,
1382 })
1383 .collect(),
1384 summary: self
1385 .summary
1386 .as_ref()
1387 .map(|summary| summary.text.clone())
1388 .unwrap_or_default(),
1389 }
1390 }
1391
1392 async fn deserialize(
1393 saved_conversation: SavedConversation,
1394 model: LanguageModel,
1395 path: PathBuf,
1396 language_registry: Arc<LanguageRegistry>,
1397 cx: &mut AsyncAppContext,
1398 ) -> Result<Model<Self>> {
1399 let id = match saved_conversation.id {
1400 Some(id) => Some(id),
1401 None => Some(Uuid::new_v4().to_string()),
1402 };
1403
1404 let markdown = language_registry.language_for_name("Markdown");
1405 let mut message_anchors = Vec::new();
1406 let mut next_message_id = MessageId(0);
1407 let buffer = cx.new_model(|cx| {
1408 let mut buffer = Buffer::local(saved_conversation.text, cx);
1409 for message in saved_conversation.messages {
1410 message_anchors.push(MessageAnchor {
1411 id: message.id,
1412 start: buffer.anchor_before(message.start),
1413 });
1414 next_message_id = cmp::max(next_message_id, MessageId(message.id.0 + 1));
1415 }
1416 buffer.set_language_registry(language_registry);
1417 cx.spawn(|buffer, mut cx| async move {
1418 let markdown = markdown.await?;
1419 buffer.update(&mut cx, |buffer: &mut Buffer, cx| {
1420 buffer.set_language(Some(markdown), cx)
1421 })?;
1422 anyhow::Ok(())
1423 })
1424 .detach_and_log_err(cx);
1425 buffer
1426 })?;
1427
1428 cx.new_model(|cx| {
1429 let mut this = Self {
1430 id,
1431 message_anchors,
1432 messages_metadata: saved_conversation.message_metadata,
1433 next_message_id,
1434 summary: Some(Summary {
1435 text: saved_conversation.summary,
1436 done: true,
1437 }),
1438 pending_summary: Task::ready(None),
1439 completion_count: Default::default(),
1440 pending_completions: Default::default(),
1441 token_count: None,
1442 pending_token_count: Task::ready(None),
1443 model,
1444 _subscriptions: vec![cx.subscribe(&buffer, Self::handle_buffer_event)],
1445 pending_save: Task::ready(Ok(())),
1446 path: Some(path),
1447 buffer,
1448 embedded_scope: EmbeddedScope::new(),
1449 };
1450 this.count_remaining_tokens(cx);
1451 this
1452 })
1453 }
1454
1455 fn handle_buffer_event(
1456 &mut self,
1457 _: Model<Buffer>,
1458 event: &language::Event,
1459 cx: &mut ModelContext<Self>,
1460 ) {
1461 if *event == language::Event::Edited {
1462 self.count_remaining_tokens(cx);
1463 cx.emit(ConversationEvent::MessagesEdited);
1464 }
1465 }
1466
1467 pub(crate) fn count_remaining_tokens(&mut self, cx: &mut ModelContext<Self>) {
1468 let request = self.to_completion_request(cx);
1469 self.pending_token_count = cx.spawn(|this, mut cx| {
1470 async move {
1471 cx.background_executor()
1472 .timer(Duration::from_millis(200))
1473 .await;
1474
1475 let token_count = cx
1476 .update(|cx| CompletionProvider::global(cx).count_tokens(request, cx))?
1477 .await?;
1478
1479 this.update(&mut cx, |this, cx| {
1480 this.token_count = Some(token_count);
1481 cx.notify()
1482 })?;
1483 anyhow::Ok(())
1484 }
1485 .log_err()
1486 });
1487 }
1488
1489 fn remaining_tokens(&self) -> Option<isize> {
1490 Some(self.model.max_token_count() as isize - self.token_count? as isize)
1491 }
1492
1493 fn set_model(&mut self, model: LanguageModel, cx: &mut ModelContext<Self>) {
1494 self.model = model;
1495 self.count_remaining_tokens(cx);
1496 }
1497
1498 fn assist(
1499 &mut self,
1500 selected_messages: HashSet<MessageId>,
1501 cx: &mut ModelContext<Self>,
1502 ) -> Vec<MessageAnchor> {
1503 let mut user_messages = Vec::new();
1504
1505 let last_message_id = if let Some(last_message_id) =
1506 self.message_anchors.iter().rev().find_map(|message| {
1507 message
1508 .start
1509 .is_valid(self.buffer.read(cx))
1510 .then_some(message.id)
1511 }) {
1512 last_message_id
1513 } else {
1514 return Default::default();
1515 };
1516
1517 let mut should_assist = false;
1518 for selected_message_id in selected_messages {
1519 let selected_message_role =
1520 if let Some(metadata) = self.messages_metadata.get(&selected_message_id) {
1521 metadata.role
1522 } else {
1523 continue;
1524 };
1525
1526 if selected_message_role == Role::Assistant {
1527 if let Some(user_message) = self.insert_message_after(
1528 selected_message_id,
1529 Role::User,
1530 MessageStatus::Done,
1531 cx,
1532 ) {
1533 user_messages.push(user_message);
1534 }
1535 } else {
1536 should_assist = true;
1537 }
1538 }
1539
1540 if should_assist {
1541 if !CompletionProvider::global(cx).is_authenticated() {
1542 log::info!("completion provider has no credentials");
1543 return Default::default();
1544 }
1545
1546 let request = self.to_completion_request(cx);
1547 let stream = CompletionProvider::global(cx).complete(request);
1548 let assistant_message = self
1549 .insert_message_after(last_message_id, Role::Assistant, MessageStatus::Pending, cx)
1550 .unwrap();
1551
1552 // Queue up the user's next reply.
1553 let user_message = self
1554 .insert_message_after(assistant_message.id, Role::User, MessageStatus::Done, cx)
1555 .unwrap();
1556 user_messages.push(user_message);
1557
1558 let task = cx.spawn({
1559 |this, mut cx| async move {
1560 let assistant_message_id = assistant_message.id;
1561 let stream_completion = async {
1562 let mut messages = stream.await?;
1563
1564 while let Some(message) = messages.next().await {
1565 let text = message?;
1566
1567 this.update(&mut cx, |this, cx| {
1568 let message_ix = this
1569 .message_anchors
1570 .iter()
1571 .position(|message| message.id == assistant_message_id)?;
1572 this.buffer.update(cx, |buffer, cx| {
1573 let offset = this.message_anchors[message_ix + 1..]
1574 .iter()
1575 .find(|message| message.start.is_valid(buffer))
1576 .map_or(buffer.len(), |message| {
1577 message.start.to_offset(buffer).saturating_sub(1)
1578 });
1579 buffer.edit([(offset..offset, text)], None, cx);
1580 });
1581 cx.emit(ConversationEvent::StreamedCompletion);
1582
1583 Some(())
1584 })?;
1585 smol::future::yield_now().await;
1586 }
1587
1588 this.update(&mut cx, |this, cx| {
1589 this.pending_completions
1590 .retain(|completion| completion.id != this.completion_count);
1591 this.summarize(cx);
1592 })?;
1593
1594 anyhow::Ok(())
1595 };
1596
1597 let result = stream_completion.await;
1598
1599 this.update(&mut cx, |this, cx| {
1600 if let Some(metadata) =
1601 this.messages_metadata.get_mut(&assistant_message.id)
1602 {
1603 match result {
1604 Ok(_) => {
1605 metadata.status = MessageStatus::Done;
1606 }
1607 Err(error) => {
1608 metadata.status = MessageStatus::Error(SharedString::from(
1609 error.to_string().trim().to_string(),
1610 ));
1611 }
1612 }
1613 cx.emit(ConversationEvent::MessagesEdited);
1614 }
1615 })
1616 .ok();
1617 }
1618 });
1619
1620 self.pending_completions.push(PendingCompletion {
1621 id: post_inc(&mut self.completion_count),
1622 _task: task,
1623 });
1624 }
1625
1626 user_messages
1627 }
1628
1629 fn to_completion_request(&self, cx: &mut ModelContext<Conversation>) -> LanguageModelRequest {
1630 let mut request = LanguageModelRequest {
1631 model: self.model.clone(),
1632 messages: self
1633 .messages(cx)
1634 .filter(|message| matches!(message.status, MessageStatus::Done))
1635 .map(|message| message.to_open_ai_message(self.buffer.read(cx)))
1636 .collect(),
1637 stop: vec![],
1638 temperature: 1.0,
1639 };
1640
1641 let context_message = self.embedded_scope.message(cx);
1642 request.messages.extend(context_message);
1643 request
1644 }
1645
1646 fn cancel_last_assist(&mut self) -> bool {
1647 self.pending_completions.pop().is_some()
1648 }
1649
1650 fn cycle_message_roles(&mut self, ids: HashSet<MessageId>, cx: &mut ModelContext<Self>) {
1651 for id in ids {
1652 if let Some(metadata) = self.messages_metadata.get_mut(&id) {
1653 metadata.role.cycle();
1654 cx.emit(ConversationEvent::MessagesEdited);
1655 cx.notify();
1656 }
1657 }
1658 }
1659
1660 fn insert_message_after(
1661 &mut self,
1662 message_id: MessageId,
1663 role: Role,
1664 status: MessageStatus,
1665 cx: &mut ModelContext<Self>,
1666 ) -> Option<MessageAnchor> {
1667 if let Some(prev_message_ix) = self
1668 .message_anchors
1669 .iter()
1670 .position(|message| message.id == message_id)
1671 {
1672 // Find the next valid message after the one we were given.
1673 let mut next_message_ix = prev_message_ix + 1;
1674 while let Some(next_message) = self.message_anchors.get(next_message_ix) {
1675 if next_message.start.is_valid(self.buffer.read(cx)) {
1676 break;
1677 }
1678 next_message_ix += 1;
1679 }
1680
1681 let start = self.buffer.update(cx, |buffer, cx| {
1682 let offset = self
1683 .message_anchors
1684 .get(next_message_ix)
1685 .map_or(buffer.len(), |message| message.start.to_offset(buffer) - 1);
1686 buffer.edit([(offset..offset, "\n")], None, cx);
1687 buffer.anchor_before(offset + 1)
1688 });
1689 let message = MessageAnchor {
1690 id: MessageId(post_inc(&mut self.next_message_id.0)),
1691 start,
1692 };
1693 self.message_anchors
1694 .insert(next_message_ix, message.clone());
1695 self.messages_metadata.insert(
1696 message.id,
1697 MessageMetadata {
1698 role,
1699 sent_at: Local::now(),
1700 status,
1701 },
1702 );
1703 cx.emit(ConversationEvent::MessagesEdited);
1704 Some(message)
1705 } else {
1706 None
1707 }
1708 }
1709
1710 fn split_message(
1711 &mut self,
1712 range: Range<usize>,
1713 cx: &mut ModelContext<Self>,
1714 ) -> (Option<MessageAnchor>, Option<MessageAnchor>) {
1715 let start_message = self.message_for_offset(range.start, cx);
1716 let end_message = self.message_for_offset(range.end, cx);
1717 if let Some((start_message, end_message)) = start_message.zip(end_message) {
1718 // Prevent splitting when range spans multiple messages.
1719 if start_message.id != end_message.id {
1720 return (None, None);
1721 }
1722
1723 let message = start_message;
1724 let role = message.role;
1725 let mut edited_buffer = false;
1726
1727 let mut suffix_start = None;
1728 if range.start > message.offset_range.start && range.end < message.offset_range.end - 1
1729 {
1730 if self.buffer.read(cx).chars_at(range.end).next() == Some('\n') {
1731 suffix_start = Some(range.end + 1);
1732 } else if self.buffer.read(cx).reversed_chars_at(range.end).next() == Some('\n') {
1733 suffix_start = Some(range.end);
1734 }
1735 }
1736
1737 let suffix = if let Some(suffix_start) = suffix_start {
1738 MessageAnchor {
1739 id: MessageId(post_inc(&mut self.next_message_id.0)),
1740 start: self.buffer.read(cx).anchor_before(suffix_start),
1741 }
1742 } else {
1743 self.buffer.update(cx, |buffer, cx| {
1744 buffer.edit([(range.end..range.end, "\n")], None, cx);
1745 });
1746 edited_buffer = true;
1747 MessageAnchor {
1748 id: MessageId(post_inc(&mut self.next_message_id.0)),
1749 start: self.buffer.read(cx).anchor_before(range.end + 1),
1750 }
1751 };
1752
1753 self.message_anchors
1754 .insert(message.index_range.end + 1, suffix.clone());
1755 self.messages_metadata.insert(
1756 suffix.id,
1757 MessageMetadata {
1758 role,
1759 sent_at: Local::now(),
1760 status: MessageStatus::Done,
1761 },
1762 );
1763
1764 let new_messages =
1765 if range.start == range.end || range.start == message.offset_range.start {
1766 (None, Some(suffix))
1767 } else {
1768 let mut prefix_end = None;
1769 if range.start > message.offset_range.start
1770 && range.end < message.offset_range.end - 1
1771 {
1772 if self.buffer.read(cx).chars_at(range.start).next() == Some('\n') {
1773 prefix_end = Some(range.start + 1);
1774 } else if self.buffer.read(cx).reversed_chars_at(range.start).next()
1775 == Some('\n')
1776 {
1777 prefix_end = Some(range.start);
1778 }
1779 }
1780
1781 let selection = if let Some(prefix_end) = prefix_end {
1782 cx.emit(ConversationEvent::MessagesEdited);
1783 MessageAnchor {
1784 id: MessageId(post_inc(&mut self.next_message_id.0)),
1785 start: self.buffer.read(cx).anchor_before(prefix_end),
1786 }
1787 } else {
1788 self.buffer.update(cx, |buffer, cx| {
1789 buffer.edit([(range.start..range.start, "\n")], None, cx)
1790 });
1791 edited_buffer = true;
1792 MessageAnchor {
1793 id: MessageId(post_inc(&mut self.next_message_id.0)),
1794 start: self.buffer.read(cx).anchor_before(range.end + 1),
1795 }
1796 };
1797
1798 self.message_anchors
1799 .insert(message.index_range.end + 1, selection.clone());
1800 self.messages_metadata.insert(
1801 selection.id,
1802 MessageMetadata {
1803 role,
1804 sent_at: Local::now(),
1805 status: MessageStatus::Done,
1806 },
1807 );
1808 (Some(selection), Some(suffix))
1809 };
1810
1811 if !edited_buffer {
1812 cx.emit(ConversationEvent::MessagesEdited);
1813 }
1814 new_messages
1815 } else {
1816 (None, None)
1817 }
1818 }
1819
1820 fn summarize(&mut self, cx: &mut ModelContext<Self>) {
1821 if self.message_anchors.len() >= 2 && self.summary.is_none() {
1822 if !CompletionProvider::global(cx).is_authenticated() {
1823 return;
1824 }
1825
1826 let messages = self
1827 .messages(cx)
1828 .take(2)
1829 .map(|message| message.to_open_ai_message(self.buffer.read(cx)))
1830 .chain(Some(LanguageModelRequestMessage {
1831 role: Role::User,
1832 content: "Summarize the conversation into a short title without punctuation"
1833 .into(),
1834 }));
1835 let request = LanguageModelRequest {
1836 model: self.model.clone(),
1837 messages: messages.collect(),
1838 stop: vec![],
1839 temperature: 1.0,
1840 };
1841
1842 let stream = CompletionProvider::global(cx).complete(request);
1843 self.pending_summary = cx.spawn(|this, mut cx| {
1844 async move {
1845 let mut messages = stream.await?;
1846
1847 while let Some(message) = messages.next().await {
1848 let text = message?;
1849 this.update(&mut cx, |this, cx| {
1850 this.summary
1851 .get_or_insert(Default::default())
1852 .text
1853 .push_str(&text);
1854 cx.emit(ConversationEvent::SummaryChanged);
1855 })?;
1856 }
1857
1858 this.update(&mut cx, |this, cx| {
1859 if let Some(summary) = this.summary.as_mut() {
1860 summary.done = true;
1861 cx.emit(ConversationEvent::SummaryChanged);
1862 }
1863 })?;
1864
1865 anyhow::Ok(())
1866 }
1867 .log_err()
1868 });
1869 }
1870 }
1871
1872 fn message_for_offset(&self, offset: usize, cx: &AppContext) -> Option<Message> {
1873 self.messages_for_offsets([offset], cx).pop()
1874 }
1875
1876 fn messages_for_offsets(
1877 &self,
1878 offsets: impl IntoIterator<Item = usize>,
1879 cx: &AppContext,
1880 ) -> Vec<Message> {
1881 let mut result = Vec::new();
1882
1883 let mut messages = self.messages(cx).peekable();
1884 let mut offsets = offsets.into_iter().peekable();
1885 let mut current_message = messages.next();
1886 while let Some(offset) = offsets.next() {
1887 // Locate the message that contains the offset.
1888 while current_message.as_ref().map_or(false, |message| {
1889 !message.offset_range.contains(&offset) && messages.peek().is_some()
1890 }) {
1891 current_message = messages.next();
1892 }
1893 let Some(message) = current_message.as_ref() else {
1894 break;
1895 };
1896
1897 // Skip offsets that are in the same message.
1898 while offsets.peek().map_or(false, |offset| {
1899 message.offset_range.contains(offset) || messages.peek().is_none()
1900 }) {
1901 offsets.next();
1902 }
1903
1904 result.push(message.clone());
1905 }
1906 result
1907 }
1908
1909 fn messages<'a>(&'a self, cx: &'a AppContext) -> impl 'a + Iterator<Item = Message> {
1910 let buffer = self.buffer.read(cx);
1911 let mut message_anchors = self.message_anchors.iter().enumerate().peekable();
1912 iter::from_fn(move || {
1913 if let Some((start_ix, message_anchor)) = message_anchors.next() {
1914 let metadata = self.messages_metadata.get(&message_anchor.id)?;
1915 let message_start = message_anchor.start.to_offset(buffer);
1916 let mut message_end = None;
1917 let mut end_ix = start_ix;
1918 while let Some((_, next_message)) = message_anchors.peek() {
1919 if next_message.start.is_valid(buffer) {
1920 message_end = Some(next_message.start);
1921 break;
1922 } else {
1923 end_ix += 1;
1924 message_anchors.next();
1925 }
1926 }
1927 let message_end = message_end
1928 .unwrap_or(language::Anchor::MAX)
1929 .to_offset(buffer);
1930 return Some(Message {
1931 index_range: start_ix..end_ix,
1932 offset_range: message_start..message_end,
1933 id: message_anchor.id,
1934 anchor: message_anchor.start,
1935 role: metadata.role,
1936 sent_at: metadata.sent_at,
1937 status: metadata.status.clone(),
1938 });
1939 }
1940 None
1941 })
1942 }
1943
1944 fn save(
1945 &mut self,
1946 debounce: Option<Duration>,
1947 fs: Arc<dyn Fs>,
1948 cx: &mut ModelContext<Conversation>,
1949 ) {
1950 self.pending_save = cx.spawn(|this, mut cx| async move {
1951 if let Some(debounce) = debounce {
1952 cx.background_executor().timer(debounce).await;
1953 }
1954
1955 let (old_path, summary) = this.read_with(&cx, |this, _| {
1956 let path = this.path.clone();
1957 let summary = if let Some(summary) = this.summary.as_ref() {
1958 if summary.done {
1959 Some(summary.text.clone())
1960 } else {
1961 None
1962 }
1963 } else {
1964 None
1965 };
1966 (path, summary)
1967 })?;
1968
1969 if let Some(summary) = summary {
1970 let conversation = this.read_with(&cx, |this, cx| this.serialize(cx))?;
1971 let path = if let Some(old_path) = old_path {
1972 old_path
1973 } else {
1974 let mut discriminant = 1;
1975 let mut new_path;
1976 loop {
1977 new_path = CONVERSATIONS_DIR.join(&format!(
1978 "{} - {}.zed.json",
1979 summary.trim(),
1980 discriminant
1981 ));
1982 if fs.is_file(&new_path).await {
1983 discriminant += 1;
1984 } else {
1985 break;
1986 }
1987 }
1988 new_path
1989 };
1990
1991 fs.create_dir(CONVERSATIONS_DIR.as_ref()).await?;
1992 fs.atomic_write(path.clone(), serde_json::to_string(&conversation).unwrap())
1993 .await?;
1994 this.update(&mut cx, |this, _| this.path = Some(path))?;
1995 }
1996
1997 Ok(())
1998 });
1999 }
2000}
2001
2002struct PendingCompletion {
2003 id: usize,
2004 _task: Task<()>,
2005}
2006
2007enum ConversationEditorEvent {
2008 TabContentChanged,
2009}
2010
2011#[derive(Copy, Clone, Debug, PartialEq)]
2012struct ScrollPosition {
2013 offset_before_cursor: gpui::Point<f32>,
2014 cursor: Anchor,
2015}
2016
2017struct ConversationEditor {
2018 conversation: Model<Conversation>,
2019 fs: Arc<dyn Fs>,
2020 workspace: WeakView<Workspace>,
2021 editor: View<Editor>,
2022 blocks: HashSet<BlockId>,
2023 scroll_position: Option<ScrollPosition>,
2024 _subscriptions: Vec<Subscription>,
2025}
2026
2027impl ConversationEditor {
2028 fn new(
2029 model: LanguageModel,
2030 language_registry: Arc<LanguageRegistry>,
2031 fs: Arc<dyn Fs>,
2032 workspace: View<Workspace>,
2033 cx: &mut ViewContext<Self>,
2034 ) -> Self {
2035 let conversation = cx
2036 .new_model(|cx| Conversation::new(model, language_registry, EmbeddedScope::new(), cx));
2037 Self::for_conversation(conversation, fs, workspace, cx)
2038 }
2039
2040 fn for_conversation(
2041 conversation: Model<Conversation>,
2042 fs: Arc<dyn Fs>,
2043 workspace: View<Workspace>,
2044 cx: &mut ViewContext<Self>,
2045 ) -> Self {
2046 let editor = cx.new_view(|cx| {
2047 let mut editor = Editor::for_buffer(conversation.read(cx).buffer.clone(), None, cx);
2048 editor.set_soft_wrap_mode(SoftWrap::EditorWidth, cx);
2049 editor.set_show_gutter(false, cx);
2050 editor.set_show_wrap_guides(false, cx);
2051 editor
2052 });
2053
2054 let _subscriptions = vec![
2055 cx.observe(&conversation, |_, _, cx| cx.notify()),
2056 cx.subscribe(&conversation, Self::handle_conversation_event),
2057 cx.subscribe(&editor, Self::handle_editor_event),
2058 cx.subscribe(&workspace, Self::handle_workspace_event),
2059 ];
2060
2061 let mut this = Self {
2062 conversation,
2063 editor,
2064 blocks: Default::default(),
2065 scroll_position: None,
2066 fs,
2067 workspace: workspace.downgrade(),
2068 _subscriptions,
2069 };
2070 cx.defer(|this, cx| this.update_active_buffer(workspace, cx));
2071 this.update_message_headers(cx);
2072 this
2073 }
2074
2075 fn assist(&mut self, _: &Assist, cx: &mut ViewContext<Self>) {
2076 self.conversation.update(cx, |conversation, cx| {
2077 report_assistant_event(
2078 self.workspace.clone(),
2079 Some(conversation),
2080 AssistantKind::Panel,
2081 cx,
2082 )
2083 });
2084
2085 let cursors = self.cursors(cx);
2086
2087 let user_messages = self.conversation.update(cx, |conversation, cx| {
2088 let selected_messages = conversation
2089 .messages_for_offsets(cursors, cx)
2090 .into_iter()
2091 .map(|message| message.id)
2092 .collect();
2093 conversation.assist(selected_messages, cx)
2094 });
2095 let new_selections = user_messages
2096 .iter()
2097 .map(|message| {
2098 let cursor = message
2099 .start
2100 .to_offset(self.conversation.read(cx).buffer.read(cx));
2101 cursor..cursor
2102 })
2103 .collect::<Vec<_>>();
2104 if !new_selections.is_empty() {
2105 self.editor.update(cx, |editor, cx| {
2106 editor.change_selections(
2107 Some(Autoscroll::Strategy(AutoscrollStrategy::Fit)),
2108 cx,
2109 |selections| selections.select_ranges(new_selections),
2110 );
2111 });
2112 // Avoid scrolling to the new cursor position so the assistant's output is stable.
2113 cx.defer(|this, _| this.scroll_position = None);
2114 }
2115 }
2116
2117 fn cancel_last_assist(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
2118 if !self
2119 .conversation
2120 .update(cx, |conversation, _| conversation.cancel_last_assist())
2121 {
2122 cx.propagate();
2123 }
2124 }
2125
2126 fn cycle_message_role(&mut self, _: &CycleMessageRole, cx: &mut ViewContext<Self>) {
2127 let cursors = self.cursors(cx);
2128 self.conversation.update(cx, |conversation, cx| {
2129 let messages = conversation
2130 .messages_for_offsets(cursors, cx)
2131 .into_iter()
2132 .map(|message| message.id)
2133 .collect();
2134 conversation.cycle_message_roles(messages, cx)
2135 });
2136 }
2137
2138 fn cursors(&self, cx: &AppContext) -> Vec<usize> {
2139 let selections = self.editor.read(cx).selections.all::<usize>(cx);
2140 selections
2141 .into_iter()
2142 .map(|selection| selection.head())
2143 .collect()
2144 }
2145
2146 fn handle_conversation_event(
2147 &mut self,
2148 _: Model<Conversation>,
2149 event: &ConversationEvent,
2150 cx: &mut ViewContext<Self>,
2151 ) {
2152 match event {
2153 ConversationEvent::MessagesEdited => {
2154 self.update_message_headers(cx);
2155 self.conversation.update(cx, |conversation, cx| {
2156 conversation.save(Some(Duration::from_millis(500)), self.fs.clone(), cx);
2157 });
2158 }
2159 ConversationEvent::SummaryChanged => {
2160 cx.emit(ConversationEditorEvent::TabContentChanged);
2161 self.conversation.update(cx, |conversation, cx| {
2162 conversation.save(None, self.fs.clone(), cx);
2163 });
2164 }
2165 ConversationEvent::StreamedCompletion => {
2166 self.editor.update(cx, |editor, cx| {
2167 if let Some(scroll_position) = self.scroll_position {
2168 let snapshot = editor.snapshot(cx);
2169 let cursor_point = scroll_position.cursor.to_display_point(&snapshot);
2170 let scroll_top =
2171 cursor_point.row() as f32 - scroll_position.offset_before_cursor.y;
2172 editor.set_scroll_position(
2173 point(scroll_position.offset_before_cursor.x, scroll_top),
2174 cx,
2175 );
2176 }
2177 });
2178 }
2179 }
2180 }
2181
2182 fn handle_editor_event(
2183 &mut self,
2184 _: View<Editor>,
2185 event: &EditorEvent,
2186 cx: &mut ViewContext<Self>,
2187 ) {
2188 match event {
2189 EditorEvent::ScrollPositionChanged { autoscroll, .. } => {
2190 let cursor_scroll_position = self.cursor_scroll_position(cx);
2191 if *autoscroll {
2192 self.scroll_position = cursor_scroll_position;
2193 } else if self.scroll_position != cursor_scroll_position {
2194 self.scroll_position = None;
2195 }
2196 }
2197 EditorEvent::SelectionsChanged { .. } => {
2198 self.scroll_position = self.cursor_scroll_position(cx);
2199 }
2200 _ => {}
2201 }
2202 }
2203
2204 fn handle_workspace_event(
2205 &mut self,
2206 workspace: View<Workspace>,
2207 event: &WorkspaceEvent,
2208 cx: &mut ViewContext<Self>,
2209 ) {
2210 if let WorkspaceEvent::ActiveItemChanged = event {
2211 self.update_active_buffer(workspace, cx);
2212 }
2213 }
2214
2215 fn update_active_buffer(
2216 &mut self,
2217 workspace: View<Workspace>,
2218 cx: &mut ViewContext<'_, ConversationEditor>,
2219 ) {
2220 let active_buffer = workspace
2221 .read(cx)
2222 .active_item(cx)
2223 .and_then(|item| Some(item.act_as::<Editor>(cx)?.read(cx).buffer().clone()));
2224
2225 self.conversation.update(cx, |conversation, cx| {
2226 conversation
2227 .embedded_scope
2228 .set_active_buffer(active_buffer.clone(), cx);
2229
2230 conversation.count_remaining_tokens(cx);
2231 cx.notify();
2232 });
2233 }
2234
2235 fn cursor_scroll_position(&self, cx: &mut ViewContext<Self>) -> Option<ScrollPosition> {
2236 self.editor.update(cx, |editor, cx| {
2237 let snapshot = editor.snapshot(cx);
2238 let cursor = editor.selections.newest_anchor().head();
2239 let cursor_row = cursor.to_display_point(&snapshot.display_snapshot).row() as f32;
2240 let scroll_position = editor
2241 .scroll_manager
2242 .anchor()
2243 .scroll_position(&snapshot.display_snapshot);
2244
2245 let scroll_bottom = scroll_position.y + editor.visible_line_count().unwrap_or(0.);
2246 if (scroll_position.y..scroll_bottom).contains(&cursor_row) {
2247 Some(ScrollPosition {
2248 cursor,
2249 offset_before_cursor: point(scroll_position.x, cursor_row - scroll_position.y),
2250 })
2251 } else {
2252 None
2253 }
2254 })
2255 }
2256
2257 fn update_message_headers(&mut self, cx: &mut ViewContext<Self>) {
2258 self.editor.update(cx, |editor, cx| {
2259 let buffer = editor.buffer().read(cx).snapshot(cx);
2260 let excerpt_id = *buffer.as_singleton().unwrap().0;
2261 let old_blocks = std::mem::take(&mut self.blocks);
2262 let new_blocks = self
2263 .conversation
2264 .read(cx)
2265 .messages(cx)
2266 .map(|message| BlockProperties {
2267 position: buffer
2268 .anchor_in_excerpt(excerpt_id, message.anchor)
2269 .unwrap(),
2270 height: 2,
2271 style: BlockStyle::Sticky,
2272 render: Box::new({
2273 let conversation = self.conversation.clone();
2274 move |_cx| {
2275 let message_id = message.id;
2276 let sender = ButtonLike::new("role")
2277 .style(ButtonStyle::Filled)
2278 .child(match message.role {
2279 Role::User => Label::new("You").color(Color::Default),
2280 Role::Assistant => Label::new("Assistant").color(Color::Info),
2281 Role::System => Label::new("System").color(Color::Warning),
2282 })
2283 .tooltip(|cx| {
2284 Tooltip::with_meta(
2285 "Toggle message role",
2286 None,
2287 "Available roles: You (User), Assistant, System",
2288 cx,
2289 )
2290 })
2291 .on_click({
2292 let conversation = conversation.clone();
2293 move |_, cx| {
2294 conversation.update(cx, |conversation, cx| {
2295 conversation.cycle_message_roles(
2296 HashSet::from_iter(Some(message_id)),
2297 cx,
2298 )
2299 })
2300 }
2301 });
2302
2303 h_flex()
2304 .id(("message_header", message_id.0))
2305 .h_11()
2306 .relative()
2307 .gap_1()
2308 .child(sender)
2309 // TODO: Only show this if the message if the message has been sent
2310 .child(
2311 Label::new(
2312 FormatDistance::from_now(DateTimeType::Local(
2313 message.sent_at,
2314 ))
2315 .hide_prefix(true)
2316 .add_suffix(true)
2317 .to_string(),
2318 )
2319 .size(LabelSize::XSmall)
2320 .color(Color::Muted),
2321 )
2322 .children(
2323 if let MessageStatus::Error(error) = message.status.clone() {
2324 Some(
2325 div()
2326 .id("error")
2327 .tooltip(move |cx| Tooltip::text(error.clone(), cx))
2328 .child(Icon::new(IconName::XCircle)),
2329 )
2330 } else {
2331 None
2332 },
2333 )
2334 .into_any_element()
2335 }
2336 }),
2337 disposition: BlockDisposition::Above,
2338 })
2339 .collect::<Vec<_>>();
2340
2341 editor.remove_blocks(old_blocks, None, cx);
2342 let ids = editor.insert_blocks(new_blocks, None, cx);
2343 self.blocks = HashSet::from_iter(ids);
2344 });
2345 }
2346
2347 fn quote_selection(
2348 workspace: &mut Workspace,
2349 _: &QuoteSelection,
2350 cx: &mut ViewContext<Workspace>,
2351 ) {
2352 let Some(panel) = workspace.panel::<AssistantPanel>(cx) else {
2353 return;
2354 };
2355 let Some(editor) = workspace
2356 .active_item(cx)
2357 .and_then(|item| item.act_as::<Editor>(cx))
2358 else {
2359 return;
2360 };
2361
2362 let editor = editor.read(cx);
2363 let range = editor.selections.newest::<usize>(cx).range();
2364 let buffer = editor.buffer().read(cx).snapshot(cx);
2365 let start_language = buffer.language_at(range.start);
2366 let end_language = buffer.language_at(range.end);
2367 let language_name = if start_language == end_language {
2368 start_language.map(|language| language.code_fence_block_name())
2369 } else {
2370 None
2371 };
2372 let language_name = language_name.as_deref().unwrap_or("");
2373
2374 let selected_text = buffer.text_for_range(range).collect::<String>();
2375 let text = if selected_text.is_empty() {
2376 None
2377 } else {
2378 Some(if language_name == "markdown" {
2379 selected_text
2380 .lines()
2381 .map(|line| format!("> {}", line))
2382 .collect::<Vec<_>>()
2383 .join("\n")
2384 } else {
2385 format!("```{language_name}\n{selected_text}\n```")
2386 })
2387 };
2388
2389 // Activate the panel
2390 if !panel.focus_handle(cx).contains_focused(cx) {
2391 workspace.toggle_panel_focus::<AssistantPanel>(cx);
2392 }
2393
2394 if let Some(text) = text {
2395 panel.update(cx, |panel, cx| {
2396 if let Some(conversation) = panel
2397 .active_conversation_editor()
2398 .cloned()
2399 .or_else(|| panel.new_conversation(cx))
2400 {
2401 conversation.update(cx, |conversation, cx| {
2402 conversation
2403 .editor
2404 .update(cx, |editor, cx| editor.insert(&text, cx))
2405 });
2406 };
2407 });
2408 }
2409 }
2410
2411 fn copy(&mut self, _: &editor::actions::Copy, cx: &mut ViewContext<Self>) {
2412 let editor = self.editor.read(cx);
2413 let conversation = self.conversation.read(cx);
2414 if editor.selections.count() == 1 {
2415 let selection = editor.selections.newest::<usize>(cx);
2416 let mut copied_text = String::new();
2417 let mut spanned_messages = 0;
2418 for message in conversation.messages(cx) {
2419 if message.offset_range.start >= selection.range().end {
2420 break;
2421 } else if message.offset_range.end >= selection.range().start {
2422 let range = cmp::max(message.offset_range.start, selection.range().start)
2423 ..cmp::min(message.offset_range.end, selection.range().end);
2424 if !range.is_empty() {
2425 spanned_messages += 1;
2426 write!(&mut copied_text, "## {}\n\n", message.role).unwrap();
2427 for chunk in conversation.buffer.read(cx).text_for_range(range) {
2428 copied_text.push_str(chunk);
2429 }
2430 copied_text.push('\n');
2431 }
2432 }
2433 }
2434
2435 if spanned_messages > 1 {
2436 cx.write_to_clipboard(ClipboardItem::new(copied_text));
2437 return;
2438 }
2439 }
2440
2441 cx.propagate();
2442 }
2443
2444 fn split(&mut self, _: &Split, cx: &mut ViewContext<Self>) {
2445 self.conversation.update(cx, |conversation, cx| {
2446 let selections = self.editor.read(cx).selections.disjoint_anchors();
2447 for selection in selections.as_ref() {
2448 let buffer = self.editor.read(cx).buffer().read(cx).snapshot(cx);
2449 let range = selection
2450 .map(|endpoint| endpoint.to_offset(&buffer))
2451 .range();
2452 conversation.split_message(range, cx);
2453 }
2454 });
2455 }
2456
2457 fn save(&mut self, _: &Save, cx: &mut ViewContext<Self>) {
2458 self.conversation.update(cx, |conversation, cx| {
2459 conversation.save(None, self.fs.clone(), cx)
2460 });
2461 }
2462
2463 fn title(&self, cx: &AppContext) -> String {
2464 self.conversation
2465 .read(cx)
2466 .summary
2467 .as_ref()
2468 .map(|summary| summary.text.clone())
2469 .unwrap_or_else(|| "New Conversation".into())
2470 }
2471
2472 fn render_embedded_scope(&self, cx: &mut ViewContext<Self>) -> Option<impl Element> {
2473 let active_buffer = self
2474 .conversation
2475 .read(cx)
2476 .embedded_scope
2477 .active_buffer()?
2478 .clone();
2479
2480 Some(
2481 div()
2482 .p_4()
2483 .v_flex()
2484 .child(
2485 div()
2486 .h_flex()
2487 .items_center()
2488 .child(Icon::new(IconName::File))
2489 .child(
2490 div()
2491 .h_6()
2492 .child(Label::new("File Contexts"))
2493 .ml_1()
2494 .font_weight(FontWeight::SEMIBOLD),
2495 ),
2496 )
2497 .child(
2498 div()
2499 .ml_4()
2500 .child(self.render_active_buffer(active_buffer, cx)),
2501 ),
2502 )
2503 }
2504
2505 fn render_active_buffer(
2506 &self,
2507 buffer: Model<MultiBuffer>,
2508 cx: &mut ViewContext<Self>,
2509 ) -> impl Element {
2510 let buffer = buffer.read(cx);
2511 let icon_path;
2512 let path;
2513 if let Some(singleton) = buffer.as_singleton() {
2514 let singleton = singleton.read(cx);
2515
2516 path = singleton.file().map(|file| file.full_path(cx));
2517
2518 icon_path = path
2519 .as_ref()
2520 .and_then(|path| FileIcons::get_icon(path.as_path(), cx))
2521 .map(SharedString::from)
2522 .unwrap_or_else(|| SharedString::from("icons/file_icons/file.svg"));
2523 } else {
2524 icon_path = SharedString::from("icons/file_icons/file.svg");
2525 path = None;
2526 }
2527
2528 let file_name = path.map_or("Untitled".to_string(), |path| {
2529 path.to_string_lossy().to_string()
2530 });
2531
2532 let enabled = self
2533 .conversation
2534 .read(cx)
2535 .embedded_scope
2536 .active_buffer_enabled();
2537
2538 let file_name_text_color = if enabled {
2539 Color::Default
2540 } else {
2541 Color::Disabled
2542 };
2543
2544 div()
2545 .id("active-buffer")
2546 .h_flex()
2547 .cursor_pointer()
2548 .child(Icon::from_path(icon_path).color(file_name_text_color))
2549 .child(
2550 div()
2551 .h_6()
2552 .child(Label::new(file_name).color(file_name_text_color))
2553 .ml_1(),
2554 )
2555 .children(enabled.then(|| {
2556 div()
2557 .child(Icon::new(IconName::Check).color(file_name_text_color))
2558 .ml_1()
2559 }))
2560 .on_click(cx.listener(move |this, _, cx| {
2561 this.conversation.update(cx, |conversation, cx| {
2562 conversation
2563 .embedded_scope
2564 .set_active_buffer_enabled(!enabled);
2565 cx.notify();
2566 })
2567 }))
2568 }
2569}
2570
2571impl EventEmitter<ConversationEditorEvent> for ConversationEditor {}
2572
2573impl Render for ConversationEditor {
2574 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element {
2575 //
2576 // The ConversationEditor has two main segments
2577 //
2578 // 1. Messages Editor
2579 // 2. Context
2580 // - File Context (currently only the active file)
2581 // - Project Diagnostics (Planned)
2582 // - Deep Code Context (Planned, for query and other tools for the model)
2583 //
2584
2585 div()
2586 .key_context("ConversationEditor")
2587 .capture_action(cx.listener(ConversationEditor::cancel_last_assist))
2588 .capture_action(cx.listener(ConversationEditor::save))
2589 .capture_action(cx.listener(ConversationEditor::copy))
2590 .capture_action(cx.listener(ConversationEditor::cycle_message_role))
2591 .on_action(cx.listener(ConversationEditor::assist))
2592 .on_action(cx.listener(ConversationEditor::split))
2593 .size_full()
2594 .v_flex()
2595 .child(
2596 div()
2597 .flex_grow()
2598 .pl_4()
2599 .bg(cx.theme().colors().editor_background)
2600 .child(self.editor.clone()),
2601 )
2602 .child(div().flex_shrink().children(self.render_embedded_scope(cx)))
2603 }
2604}
2605
2606impl FocusableView for ConversationEditor {
2607 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
2608 self.editor.focus_handle(cx)
2609 }
2610}
2611
2612#[derive(Clone, Debug)]
2613struct MessageAnchor {
2614 id: MessageId,
2615 start: language::Anchor,
2616}
2617
2618#[derive(Clone, Debug)]
2619pub struct Message {
2620 offset_range: Range<usize>,
2621 index_range: Range<usize>,
2622 id: MessageId,
2623 anchor: language::Anchor,
2624 role: Role,
2625 sent_at: DateTime<Local>,
2626 status: MessageStatus,
2627}
2628
2629impl Message {
2630 fn to_open_ai_message(&self, buffer: &Buffer) -> LanguageModelRequestMessage {
2631 let content = buffer
2632 .text_for_range(self.offset_range.clone())
2633 .collect::<String>();
2634 LanguageModelRequestMessage {
2635 role: self.role,
2636 content: content.trim_end().into(),
2637 }
2638 }
2639}
2640
2641enum InlineAssistantEvent {
2642 Confirmed {
2643 prompt: String,
2644 include_conversation: bool,
2645 },
2646 Canceled,
2647 Dismissed,
2648 IncludeConversationToggled {
2649 include_conversation: bool,
2650 },
2651}
2652
2653struct InlineAssistant {
2654 id: usize,
2655 prompt_editor: View<Editor>,
2656 workspace: WeakView<Workspace>,
2657 confirmed: bool,
2658 include_conversation: bool,
2659 measurements: Arc<Mutex<BlockMeasurements>>,
2660 prompt_history: VecDeque<String>,
2661 prompt_history_ix: Option<usize>,
2662 pending_prompt: String,
2663 codegen: Model<Codegen>,
2664 _subscriptions: Vec<Subscription>,
2665}
2666
2667impl EventEmitter<InlineAssistantEvent> for InlineAssistant {}
2668
2669impl Render for InlineAssistant {
2670 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl Element {
2671 let measurements = *self.measurements.lock();
2672 h_flex()
2673 .w_full()
2674 .py_2()
2675 .border_y_1()
2676 .border_color(cx.theme().colors().border)
2677 .on_action(cx.listener(Self::confirm))
2678 .on_action(cx.listener(Self::cancel))
2679 .on_action(cx.listener(Self::toggle_include_conversation))
2680 .on_action(cx.listener(Self::move_up))
2681 .on_action(cx.listener(Self::move_down))
2682 .child(
2683 h_flex()
2684 .justify_center()
2685 .w(measurements.gutter_width)
2686 .child(
2687 IconButton::new("include_conversation", IconName::Ai)
2688 .on_click(cx.listener(|this, _, cx| {
2689 this.toggle_include_conversation(&ToggleIncludeConversation, cx)
2690 }))
2691 .selected(self.include_conversation)
2692 .tooltip(|cx| {
2693 Tooltip::for_action(
2694 "Include Conversation",
2695 &ToggleIncludeConversation,
2696 cx,
2697 )
2698 }),
2699 )
2700 .children(if let Some(error) = self.codegen.read(cx).error() {
2701 let error_message = SharedString::from(error.to_string());
2702 Some(
2703 div()
2704 .id("error")
2705 .tooltip(move |cx| Tooltip::text(error_message.clone(), cx))
2706 .child(Icon::new(IconName::XCircle).color(Color::Error)),
2707 )
2708 } else {
2709 None
2710 }),
2711 )
2712 .child(
2713 h_flex()
2714 .w_full()
2715 .ml(measurements.anchor_x - measurements.gutter_width)
2716 .child(self.render_prompt_editor(cx)),
2717 )
2718 }
2719}
2720
2721impl FocusableView for InlineAssistant {
2722 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
2723 self.prompt_editor.focus_handle(cx)
2724 }
2725}
2726
2727impl InlineAssistant {
2728 fn new(
2729 id: usize,
2730 measurements: Arc<Mutex<BlockMeasurements>>,
2731 include_conversation: bool,
2732 prompt_history: VecDeque<String>,
2733 codegen: Model<Codegen>,
2734 workspace: WeakView<Workspace>,
2735 cx: &mut ViewContext<Self>,
2736 ) -> Self {
2737 let prompt_editor = cx.new_view(|cx| {
2738 let mut editor = Editor::single_line(cx);
2739 let placeholder = match codegen.read(cx).kind() {
2740 CodegenKind::Transform { .. } => "Enter transformation prompt…",
2741 CodegenKind::Generate { .. } => "Enter generation prompt…",
2742 };
2743 editor.set_placeholder_text(placeholder, cx);
2744 editor
2745 });
2746 cx.focus_view(&prompt_editor);
2747
2748 let subscriptions = vec![
2749 cx.observe(&codegen, Self::handle_codegen_changed),
2750 cx.subscribe(&prompt_editor, Self::handle_prompt_editor_events),
2751 ];
2752
2753 Self {
2754 id,
2755 prompt_editor,
2756 workspace,
2757 confirmed: false,
2758 include_conversation,
2759 measurements,
2760 prompt_history,
2761 prompt_history_ix: None,
2762 pending_prompt: String::new(),
2763 codegen,
2764 _subscriptions: subscriptions,
2765 }
2766 }
2767
2768 fn handle_prompt_editor_events(
2769 &mut self,
2770 _: View<Editor>,
2771 event: &EditorEvent,
2772 cx: &mut ViewContext<Self>,
2773 ) {
2774 if let EditorEvent::Edited = event {
2775 self.pending_prompt = self.prompt_editor.read(cx).text(cx);
2776 cx.notify();
2777 }
2778 }
2779
2780 fn handle_codegen_changed(&mut self, _: Model<Codegen>, cx: &mut ViewContext<Self>) {
2781 let is_read_only = !self.codegen.read(cx).idle();
2782 self.prompt_editor.update(cx, |editor, cx| {
2783 let was_read_only = editor.read_only(cx);
2784 if was_read_only != is_read_only {
2785 if is_read_only {
2786 editor.set_read_only(true);
2787 } else {
2788 self.confirmed = false;
2789 editor.set_read_only(false);
2790 }
2791 }
2792 });
2793 cx.notify();
2794 }
2795
2796 fn cancel(&mut self, _: &editor::actions::Cancel, cx: &mut ViewContext<Self>) {
2797 cx.emit(InlineAssistantEvent::Canceled);
2798 }
2799
2800 fn confirm(&mut self, _: &menu::Confirm, cx: &mut ViewContext<Self>) {
2801 if self.confirmed {
2802 cx.emit(InlineAssistantEvent::Dismissed);
2803 } else {
2804 report_assistant_event(self.workspace.clone(), None, AssistantKind::Inline, cx);
2805
2806 let prompt = self.prompt_editor.read(cx).text(cx);
2807 self.prompt_editor
2808 .update(cx, |editor, _cx| editor.set_read_only(true));
2809 cx.emit(InlineAssistantEvent::Confirmed {
2810 prompt,
2811 include_conversation: self.include_conversation,
2812 });
2813 self.confirmed = true;
2814 cx.notify();
2815 }
2816 }
2817
2818 fn toggle_include_conversation(
2819 &mut self,
2820 _: &ToggleIncludeConversation,
2821 cx: &mut ViewContext<Self>,
2822 ) {
2823 self.include_conversation = !self.include_conversation;
2824 cx.emit(InlineAssistantEvent::IncludeConversationToggled {
2825 include_conversation: self.include_conversation,
2826 });
2827 cx.notify();
2828 }
2829
2830 fn move_up(&mut self, _: &MoveUp, cx: &mut ViewContext<Self>) {
2831 if let Some(ix) = self.prompt_history_ix {
2832 if ix > 0 {
2833 self.prompt_history_ix = Some(ix - 1);
2834 let prompt = self.prompt_history[ix - 1].clone();
2835 self.set_prompt(&prompt, cx);
2836 }
2837 } else if !self.prompt_history.is_empty() {
2838 self.prompt_history_ix = Some(self.prompt_history.len() - 1);
2839 let prompt = self.prompt_history[self.prompt_history.len() - 1].clone();
2840 self.set_prompt(&prompt, cx);
2841 }
2842 }
2843
2844 fn move_down(&mut self, _: &MoveDown, cx: &mut ViewContext<Self>) {
2845 if let Some(ix) = self.prompt_history_ix {
2846 if ix < self.prompt_history.len() - 1 {
2847 self.prompt_history_ix = Some(ix + 1);
2848 let prompt = self.prompt_history[ix + 1].clone();
2849 self.set_prompt(&prompt, cx);
2850 } else {
2851 self.prompt_history_ix = None;
2852 let pending_prompt = self.pending_prompt.clone();
2853 self.set_prompt(&pending_prompt, cx);
2854 }
2855 }
2856 }
2857
2858 fn set_prompt(&mut self, prompt: &str, cx: &mut ViewContext<Self>) {
2859 self.prompt_editor.update(cx, |editor, cx| {
2860 editor.buffer().update(cx, |buffer, cx| {
2861 let len = buffer.len(cx);
2862 buffer.edit([(0..len, prompt)], None, cx);
2863 });
2864 });
2865 }
2866
2867 fn render_prompt_editor(&self, cx: &mut ViewContext<Self>) -> impl IntoElement {
2868 let settings = ThemeSettings::get_global(cx);
2869 let text_style = TextStyle {
2870 color: if self.prompt_editor.read(cx).read_only(cx) {
2871 cx.theme().colors().text_disabled
2872 } else {
2873 cx.theme().colors().text
2874 },
2875 font_family: settings.ui_font.family.clone(),
2876 font_features: settings.ui_font.features,
2877 font_size: rems(0.875).into(),
2878 font_weight: FontWeight::NORMAL,
2879 font_style: FontStyle::Normal,
2880 line_height: relative(1.3),
2881 background_color: None,
2882 underline: None,
2883 strikethrough: None,
2884 white_space: WhiteSpace::Normal,
2885 };
2886 EditorElement::new(
2887 &self.prompt_editor,
2888 EditorStyle {
2889 background: cx.theme().colors().editor_background,
2890 local_player: cx.theme().players().local(),
2891 text: text_style,
2892 ..Default::default()
2893 },
2894 )
2895 }
2896}
2897
2898// This wouldn't need to exist if we could pass parameters when rendering child views.
2899#[derive(Copy, Clone, Default)]
2900struct BlockMeasurements {
2901 anchor_x: Pixels,
2902 gutter_width: Pixels,
2903}
2904
2905struct PendingInlineAssist {
2906 editor: WeakView<Editor>,
2907 inline_assistant: Option<(BlockId, View<InlineAssistant>)>,
2908 codegen: Model<Codegen>,
2909 _subscriptions: Vec<Subscription>,
2910 project: WeakModel<Project>,
2911}
2912
2913fn merge_ranges(ranges: &mut Vec<Range<Anchor>>, buffer: &MultiBufferSnapshot) {
2914 ranges.sort_unstable_by(|a, b| {
2915 a.start
2916 .cmp(&b.start, buffer)
2917 .then_with(|| b.end.cmp(&a.end, buffer))
2918 });
2919
2920 let mut ix = 0;
2921 while ix + 1 < ranges.len() {
2922 let b = ranges[ix + 1].clone();
2923 let a = &mut ranges[ix];
2924 if a.end.cmp(&b.start, buffer).is_gt() {
2925 if a.end.cmp(&b.end, buffer).is_lt() {
2926 a.end = b.end;
2927 }
2928 ranges.remove(ix + 1);
2929 } else {
2930 ix += 1;
2931 }
2932 }
2933}
2934
2935fn report_assistant_event(
2936 workspace: WeakView<Workspace>,
2937 conversation: Option<&Conversation>,
2938 assistant_kind: AssistantKind,
2939 cx: &mut AppContext,
2940) {
2941 let Some(workspace) = workspace.upgrade() else {
2942 return;
2943 };
2944
2945 let client = workspace.read(cx).project().read(cx).client();
2946 let telemetry = client.telemetry();
2947
2948 let conversation_id = conversation.and_then(|conversation| conversation.id.clone());
2949 let model_id = conversation
2950 .map(|c| c.model.telemetry_id())
2951 .unwrap_or_else(|| {
2952 CompletionProvider::global(cx)
2953 .default_model()
2954 .telemetry_id()
2955 });
2956 telemetry.report_assistant_event(conversation_id, assistant_kind, model_id)
2957}
2958
2959#[cfg(test)]
2960mod tests {
2961 use super::*;
2962 use crate::{FakeCompletionProvider, MessageId};
2963 use gpui::{AppContext, TestAppContext};
2964 use settings::SettingsStore;
2965
2966 #[gpui::test]
2967 fn test_inserting_and_removing_messages(cx: &mut AppContext) {
2968 let settings_store = SettingsStore::test(cx);
2969 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
2970 cx.set_global(settings_store);
2971 init(cx);
2972 let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
2973
2974 let conversation = cx.new_model(|cx| {
2975 Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
2976 });
2977 let buffer = conversation.read(cx).buffer.clone();
2978
2979 let message_1 = conversation.read(cx).message_anchors[0].clone();
2980 assert_eq!(
2981 messages(&conversation, cx),
2982 vec![(message_1.id, Role::User, 0..0)]
2983 );
2984
2985 let message_2 = conversation.update(cx, |conversation, cx| {
2986 conversation
2987 .insert_message_after(message_1.id, Role::Assistant, MessageStatus::Done, cx)
2988 .unwrap()
2989 });
2990 assert_eq!(
2991 messages(&conversation, cx),
2992 vec![
2993 (message_1.id, Role::User, 0..1),
2994 (message_2.id, Role::Assistant, 1..1)
2995 ]
2996 );
2997
2998 buffer.update(cx, |buffer, cx| {
2999 buffer.edit([(0..0, "1"), (1..1, "2")], None, cx)
3000 });
3001 assert_eq!(
3002 messages(&conversation, cx),
3003 vec![
3004 (message_1.id, Role::User, 0..2),
3005 (message_2.id, Role::Assistant, 2..3)
3006 ]
3007 );
3008
3009 let message_3 = conversation.update(cx, |conversation, cx| {
3010 conversation
3011 .insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx)
3012 .unwrap()
3013 });
3014 assert_eq!(
3015 messages(&conversation, cx),
3016 vec![
3017 (message_1.id, Role::User, 0..2),
3018 (message_2.id, Role::Assistant, 2..4),
3019 (message_3.id, Role::User, 4..4)
3020 ]
3021 );
3022
3023 let message_4 = conversation.update(cx, |conversation, cx| {
3024 conversation
3025 .insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx)
3026 .unwrap()
3027 });
3028 assert_eq!(
3029 messages(&conversation, cx),
3030 vec![
3031 (message_1.id, Role::User, 0..2),
3032 (message_2.id, Role::Assistant, 2..4),
3033 (message_4.id, Role::User, 4..5),
3034 (message_3.id, Role::User, 5..5),
3035 ]
3036 );
3037
3038 buffer.update(cx, |buffer, cx| {
3039 buffer.edit([(4..4, "C"), (5..5, "D")], None, cx)
3040 });
3041 assert_eq!(
3042 messages(&conversation, cx),
3043 vec![
3044 (message_1.id, Role::User, 0..2),
3045 (message_2.id, Role::Assistant, 2..4),
3046 (message_4.id, Role::User, 4..6),
3047 (message_3.id, Role::User, 6..7),
3048 ]
3049 );
3050
3051 // Deleting across message boundaries merges the messages.
3052 buffer.update(cx, |buffer, cx| buffer.edit([(1..4, "")], None, cx));
3053 assert_eq!(
3054 messages(&conversation, cx),
3055 vec![
3056 (message_1.id, Role::User, 0..3),
3057 (message_3.id, Role::User, 3..4),
3058 ]
3059 );
3060
3061 // Undoing the deletion should also undo the merge.
3062 buffer.update(cx, |buffer, cx| buffer.undo(cx));
3063 assert_eq!(
3064 messages(&conversation, cx),
3065 vec![
3066 (message_1.id, Role::User, 0..2),
3067 (message_2.id, Role::Assistant, 2..4),
3068 (message_4.id, Role::User, 4..6),
3069 (message_3.id, Role::User, 6..7),
3070 ]
3071 );
3072
3073 // Redoing the deletion should also redo the merge.
3074 buffer.update(cx, |buffer, cx| buffer.redo(cx));
3075 assert_eq!(
3076 messages(&conversation, cx),
3077 vec![
3078 (message_1.id, Role::User, 0..3),
3079 (message_3.id, Role::User, 3..4),
3080 ]
3081 );
3082
3083 // Ensure we can still insert after a merged message.
3084 let message_5 = conversation.update(cx, |conversation, cx| {
3085 conversation
3086 .insert_message_after(message_1.id, Role::System, MessageStatus::Done, cx)
3087 .unwrap()
3088 });
3089 assert_eq!(
3090 messages(&conversation, cx),
3091 vec![
3092 (message_1.id, Role::User, 0..3),
3093 (message_5.id, Role::System, 3..4),
3094 (message_3.id, Role::User, 4..5)
3095 ]
3096 );
3097 }
3098
3099 #[gpui::test]
3100 fn test_message_splitting(cx: &mut AppContext) {
3101 let settings_store = SettingsStore::test(cx);
3102 cx.set_global(settings_store);
3103 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
3104 init(cx);
3105 let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
3106
3107 let conversation = cx.new_model(|cx| {
3108 Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
3109 });
3110 let buffer = conversation.read(cx).buffer.clone();
3111
3112 let message_1 = conversation.read(cx).message_anchors[0].clone();
3113 assert_eq!(
3114 messages(&conversation, cx),
3115 vec![(message_1.id, Role::User, 0..0)]
3116 );
3117
3118 buffer.update(cx, |buffer, cx| {
3119 buffer.edit([(0..0, "aaa\nbbb\nccc\nddd\n")], None, cx)
3120 });
3121
3122 let (_, message_2) =
3123 conversation.update(cx, |conversation, cx| conversation.split_message(3..3, cx));
3124 let message_2 = message_2.unwrap();
3125
3126 // We recycle newlines in the middle of a split message
3127 assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc\nddd\n");
3128 assert_eq!(
3129 messages(&conversation, cx),
3130 vec![
3131 (message_1.id, Role::User, 0..4),
3132 (message_2.id, Role::User, 4..16),
3133 ]
3134 );
3135
3136 let (_, message_3) =
3137 conversation.update(cx, |conversation, cx| conversation.split_message(3..3, cx));
3138 let message_3 = message_3.unwrap();
3139
3140 // We don't recycle newlines at the end of a split message
3141 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\nccc\nddd\n");
3142 assert_eq!(
3143 messages(&conversation, cx),
3144 vec![
3145 (message_1.id, Role::User, 0..4),
3146 (message_3.id, Role::User, 4..5),
3147 (message_2.id, Role::User, 5..17),
3148 ]
3149 );
3150
3151 let (_, message_4) =
3152 conversation.update(cx, |conversation, cx| conversation.split_message(9..9, cx));
3153 let message_4 = message_4.unwrap();
3154 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\nccc\nddd\n");
3155 assert_eq!(
3156 messages(&conversation, cx),
3157 vec![
3158 (message_1.id, Role::User, 0..4),
3159 (message_3.id, Role::User, 4..5),
3160 (message_2.id, Role::User, 5..9),
3161 (message_4.id, Role::User, 9..17),
3162 ]
3163 );
3164
3165 let (_, message_5) =
3166 conversation.update(cx, |conversation, cx| conversation.split_message(9..9, cx));
3167 let message_5 = message_5.unwrap();
3168 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\n\nccc\nddd\n");
3169 assert_eq!(
3170 messages(&conversation, cx),
3171 vec![
3172 (message_1.id, Role::User, 0..4),
3173 (message_3.id, Role::User, 4..5),
3174 (message_2.id, Role::User, 5..9),
3175 (message_4.id, Role::User, 9..10),
3176 (message_5.id, Role::User, 10..18),
3177 ]
3178 );
3179
3180 let (message_6, message_7) = conversation.update(cx, |conversation, cx| {
3181 conversation.split_message(14..16, cx)
3182 });
3183 let message_6 = message_6.unwrap();
3184 let message_7 = message_7.unwrap();
3185 assert_eq!(buffer.read(cx).text(), "aaa\n\nbbb\n\nccc\ndd\nd\n");
3186 assert_eq!(
3187 messages(&conversation, cx),
3188 vec![
3189 (message_1.id, Role::User, 0..4),
3190 (message_3.id, Role::User, 4..5),
3191 (message_2.id, Role::User, 5..9),
3192 (message_4.id, Role::User, 9..10),
3193 (message_5.id, Role::User, 10..14),
3194 (message_6.id, Role::User, 14..17),
3195 (message_7.id, Role::User, 17..19),
3196 ]
3197 );
3198 }
3199
3200 #[gpui::test]
3201 fn test_messages_for_offsets(cx: &mut AppContext) {
3202 let settings_store = SettingsStore::test(cx);
3203 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
3204 cx.set_global(settings_store);
3205 init(cx);
3206 let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
3207 let conversation = cx.new_model(|cx| {
3208 Conversation::new(LanguageModel::default(), registry, EmbeddedScope::new(), cx)
3209 });
3210 let buffer = conversation.read(cx).buffer.clone();
3211
3212 let message_1 = conversation.read(cx).message_anchors[0].clone();
3213 assert_eq!(
3214 messages(&conversation, cx),
3215 vec![(message_1.id, Role::User, 0..0)]
3216 );
3217
3218 buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "aaa")], None, cx));
3219 let message_2 = conversation
3220 .update(cx, |conversation, cx| {
3221 conversation.insert_message_after(message_1.id, Role::User, MessageStatus::Done, cx)
3222 })
3223 .unwrap();
3224 buffer.update(cx, |buffer, cx| buffer.edit([(4..4, "bbb")], None, cx));
3225
3226 let message_3 = conversation
3227 .update(cx, |conversation, cx| {
3228 conversation.insert_message_after(message_2.id, Role::User, MessageStatus::Done, cx)
3229 })
3230 .unwrap();
3231 buffer.update(cx, |buffer, cx| buffer.edit([(8..8, "ccc")], None, cx));
3232
3233 assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc");
3234 assert_eq!(
3235 messages(&conversation, cx),
3236 vec![
3237 (message_1.id, Role::User, 0..4),
3238 (message_2.id, Role::User, 4..8),
3239 (message_3.id, Role::User, 8..11)
3240 ]
3241 );
3242
3243 assert_eq!(
3244 message_ids_for_offsets(&conversation, &[0, 4, 9], cx),
3245 [message_1.id, message_2.id, message_3.id]
3246 );
3247 assert_eq!(
3248 message_ids_for_offsets(&conversation, &[0, 1, 11], cx),
3249 [message_1.id, message_3.id]
3250 );
3251
3252 let message_4 = conversation
3253 .update(cx, |conversation, cx| {
3254 conversation.insert_message_after(message_3.id, Role::User, MessageStatus::Done, cx)
3255 })
3256 .unwrap();
3257 assert_eq!(buffer.read(cx).text(), "aaa\nbbb\nccc\n");
3258 assert_eq!(
3259 messages(&conversation, cx),
3260 vec![
3261 (message_1.id, Role::User, 0..4),
3262 (message_2.id, Role::User, 4..8),
3263 (message_3.id, Role::User, 8..12),
3264 (message_4.id, Role::User, 12..12)
3265 ]
3266 );
3267 assert_eq!(
3268 message_ids_for_offsets(&conversation, &[0, 4, 8, 12], cx),
3269 [message_1.id, message_2.id, message_3.id, message_4.id]
3270 );
3271
3272 fn message_ids_for_offsets(
3273 conversation: &Model<Conversation>,
3274 offsets: &[usize],
3275 cx: &AppContext,
3276 ) -> Vec<MessageId> {
3277 conversation
3278 .read(cx)
3279 .messages_for_offsets(offsets.iter().copied(), cx)
3280 .into_iter()
3281 .map(|message| message.id)
3282 .collect()
3283 }
3284 }
3285
3286 #[gpui::test]
3287 async fn test_serialization(cx: &mut TestAppContext) {
3288 let settings_store = cx.update(SettingsStore::test);
3289 cx.set_global(settings_store);
3290 cx.set_global(CompletionProvider::Fake(FakeCompletionProvider::default()));
3291 cx.update(init);
3292 let registry = Arc::new(LanguageRegistry::test(cx.executor()));
3293 let conversation = cx.new_model(|cx| {
3294 Conversation::new(
3295 LanguageModel::default(),
3296 registry.clone(),
3297 EmbeddedScope::new(),
3298 cx,
3299 )
3300 });
3301 let buffer = conversation.read_with(cx, |conversation, _| conversation.buffer.clone());
3302 let message_0 =
3303 conversation.read_with(cx, |conversation, _| conversation.message_anchors[0].id);
3304 let message_1 = conversation.update(cx, |conversation, cx| {
3305 conversation
3306 .insert_message_after(message_0, Role::Assistant, MessageStatus::Done, cx)
3307 .unwrap()
3308 });
3309 let message_2 = conversation.update(cx, |conversation, cx| {
3310 conversation
3311 .insert_message_after(message_1.id, Role::System, MessageStatus::Done, cx)
3312 .unwrap()
3313 });
3314 buffer.update(cx, |buffer, cx| {
3315 buffer.edit([(0..0, "a"), (1..1, "b\nc")], None, cx);
3316 buffer.finalize_last_transaction();
3317 });
3318 let _message_3 = conversation.update(cx, |conversation, cx| {
3319 conversation
3320 .insert_message_after(message_2.id, Role::System, MessageStatus::Done, cx)
3321 .unwrap()
3322 });
3323 buffer.update(cx, |buffer, cx| buffer.undo(cx));
3324 assert_eq!(buffer.read_with(cx, |buffer, _| buffer.text()), "a\nb\nc\n");
3325 assert_eq!(
3326 cx.read(|cx| messages(&conversation, cx)),
3327 [
3328 (message_0, Role::User, 0..2),
3329 (message_1.id, Role::Assistant, 2..6),
3330 (message_2.id, Role::System, 6..6),
3331 ]
3332 );
3333
3334 let deserialized_conversation = Conversation::deserialize(
3335 conversation.read_with(cx, |conversation, cx| conversation.serialize(cx)),
3336 LanguageModel::default(),
3337 Default::default(),
3338 registry.clone(),
3339 &mut cx.to_async(),
3340 )
3341 .await
3342 .unwrap();
3343 let deserialized_buffer =
3344 deserialized_conversation.read_with(cx, |conversation, _| conversation.buffer.clone());
3345 assert_eq!(
3346 deserialized_buffer.read_with(cx, |buffer, _| buffer.text()),
3347 "a\nb\nc\n"
3348 );
3349 assert_eq!(
3350 cx.read(|cx| messages(&deserialized_conversation, cx)),
3351 [
3352 (message_0, Role::User, 0..2),
3353 (message_1.id, Role::Assistant, 2..6),
3354 (message_2.id, Role::System, 6..6),
3355 ]
3356 );
3357 }
3358
3359 fn messages(
3360 conversation: &Model<Conversation>,
3361 cx: &AppContext,
3362 ) -> Vec<(MessageId, Role, Range<usize>)> {
3363 conversation
3364 .read(cx)
3365 .messages(cx)
3366 .map(|message| (message.id, message.role, message.offset_range))
3367 .collect()
3368 }
3369}