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