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