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