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