1use anyhow::Result;
2use client::{UserStore, zed_urls};
3use copilot::{Copilot, Status};
4use editor::{
5 Editor,
6 actions::{ShowEditPrediction, ToggleEditPrediction},
7 scroll::Autoscroll,
8};
9use feature_flags::{FeatureFlagAppExt, PredictEditsRateCompletionsFeatureFlag};
10use fs::Fs;
11use gpui::{
12 Action, Animation, AnimationExt, App, AsyncWindowContext, Corner, Entity, FocusHandle,
13 Focusable, IntoElement, ParentElement, Render, Subscription, WeakEntity, actions, div,
14 pulsating_between,
15};
16use indoc::indoc;
17use language::{
18 EditPredictionsMode, File, Language,
19 language_settings::{self, AllLanguageSettings, EditPredictionProvider, all_language_settings},
20};
21use regex::Regex;
22use settings::{Settings, SettingsStore, update_settings_file};
23use std::{
24 sync::{Arc, LazyLock},
25 time::Duration,
26};
27use supermaven::{AccountStatus, Supermaven};
28use ui::{
29 Clickable, ContextMenu, ContextMenuEntry, IconButton, IconButtonShape, Indicator, PopoverMenu,
30 PopoverMenuHandle, ProgressBar, Tooltip, prelude::*,
31};
32use workspace::{
33 StatusItemView, Toast, Workspace, create_and_open_local_file, item::ItemHandle,
34 notifications::NotificationId,
35};
36use zed_actions::OpenBrowser;
37use zed_llm_client::{Plan, UsageLimit};
38use zeta::RateCompletions;
39
40actions!(edit_prediction, [ToggleMenu]);
41
42const COPILOT_SETTINGS_URL: &str = "https://github.com/settings/copilot";
43
44struct CopilotErrorToast;
45
46pub struct InlineCompletionButton {
47 editor_subscription: Option<(Subscription, usize)>,
48 editor_enabled: Option<bool>,
49 editor_show_predictions: bool,
50 editor_focus_handle: Option<FocusHandle>,
51 language: Option<Arc<Language>>,
52 file: Option<Arc<dyn File>>,
53 edit_prediction_provider: Option<Arc<dyn inline_completion::InlineCompletionProviderHandle>>,
54 fs: Arc<dyn Fs>,
55 user_store: Entity<UserStore>,
56 popover_menu_handle: PopoverMenuHandle<ContextMenu>,
57}
58
59enum SupermavenButtonStatus {
60 Ready,
61 Errored(String),
62 NeedsActivation(String),
63 Initializing,
64}
65
66impl Render for InlineCompletionButton {
67 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
68 let all_language_settings = all_language_settings(None, cx);
69
70 match all_language_settings.edit_predictions.provider {
71 EditPredictionProvider::None => div(),
72
73 EditPredictionProvider::Copilot => {
74 let Some(copilot) = Copilot::global(cx) else {
75 return div();
76 };
77 let status = copilot.read(cx).status();
78
79 let enabled = self.editor_enabled.unwrap_or(false);
80
81 let icon = match status {
82 Status::Error(_) => IconName::CopilotError,
83 Status::Authorized => {
84 if enabled {
85 IconName::Copilot
86 } else {
87 IconName::CopilotDisabled
88 }
89 }
90 _ => IconName::CopilotInit,
91 };
92
93 if let Status::Error(e) = status {
94 return div().child(
95 IconButton::new("copilot-error", icon)
96 .icon_size(IconSize::Small)
97 .on_click(cx.listener(move |_, _, window, cx| {
98 if let Some(workspace) = window.root::<Workspace>().flatten() {
99 workspace.update(cx, |workspace, cx| {
100 workspace.show_toast(
101 Toast::new(
102 NotificationId::unique::<CopilotErrorToast>(),
103 format!("Copilot can't be started: {}", e),
104 )
105 .on_click(
106 "Reinstall Copilot",
107 |_, cx| {
108 if let Some(copilot) = Copilot::global(cx) {
109 copilot
110 .update(cx, |copilot, cx| {
111 copilot.reinstall(cx)
112 })
113 .detach();
114 }
115 },
116 ),
117 cx,
118 );
119 });
120 }
121 }))
122 .tooltip(|window, cx| {
123 Tooltip::for_action("GitHub Copilot", &ToggleMenu, window, cx)
124 }),
125 );
126 }
127 let this = cx.entity().clone();
128
129 div().child(
130 PopoverMenu::new("copilot")
131 .menu(move |window, cx| {
132 Some(match status {
133 Status::Authorized => this.update(cx, |this, cx| {
134 this.build_copilot_context_menu(window, cx)
135 }),
136 _ => this.update(cx, |this, cx| {
137 this.build_copilot_start_menu(window, cx)
138 }),
139 })
140 })
141 .anchor(Corner::BottomRight)
142 .trigger_with_tooltip(
143 IconButton::new("copilot-icon", icon),
144 |window, cx| {
145 Tooltip::for_action("GitHub Copilot", &ToggleMenu, window, cx)
146 },
147 )
148 .with_handle(self.popover_menu_handle.clone()),
149 )
150 }
151
152 EditPredictionProvider::Supermaven => {
153 let Some(supermaven) = Supermaven::global(cx) else {
154 return div();
155 };
156
157 let supermaven = supermaven.read(cx);
158
159 let status = match supermaven {
160 Supermaven::Starting => SupermavenButtonStatus::Initializing,
161 Supermaven::FailedDownload { error } => {
162 SupermavenButtonStatus::Errored(error.to_string())
163 }
164 Supermaven::Spawned(agent) => {
165 let account_status = agent.account_status.clone();
166 match account_status {
167 AccountStatus::NeedsActivation { activate_url } => {
168 SupermavenButtonStatus::NeedsActivation(activate_url.clone())
169 }
170 AccountStatus::Unknown => SupermavenButtonStatus::Initializing,
171 AccountStatus::Ready => SupermavenButtonStatus::Ready,
172 }
173 }
174 Supermaven::Error { error } => {
175 SupermavenButtonStatus::Errored(error.to_string())
176 }
177 };
178
179 let icon = status.to_icon();
180 let tooltip_text = status.to_tooltip();
181 let has_menu = status.has_menu();
182 let this = cx.entity().clone();
183 let fs = self.fs.clone();
184
185 return div().child(
186 PopoverMenu::new("supermaven")
187 .menu(move |window, cx| match &status {
188 SupermavenButtonStatus::NeedsActivation(activate_url) => {
189 Some(ContextMenu::build(window, cx, |menu, _, _| {
190 let fs = fs.clone();
191 let activate_url = activate_url.clone();
192 menu.entry("Sign In", None, move |_, cx| {
193 cx.open_url(activate_url.as_str())
194 })
195 .entry(
196 "Use Copilot",
197 None,
198 move |_, cx| {
199 set_completion_provider(
200 fs.clone(),
201 cx,
202 EditPredictionProvider::Copilot,
203 )
204 },
205 )
206 }))
207 }
208 SupermavenButtonStatus::Ready => Some(this.update(cx, |this, cx| {
209 this.build_supermaven_context_menu(window, cx)
210 })),
211 _ => None,
212 })
213 .anchor(Corner::BottomRight)
214 .trigger_with_tooltip(
215 IconButton::new("supermaven-icon", icon),
216 move |window, cx| {
217 if has_menu {
218 Tooltip::for_action(
219 tooltip_text.clone(),
220 &ToggleMenu,
221 window,
222 cx,
223 )
224 } else {
225 Tooltip::text(tooltip_text.clone())(window, cx)
226 }
227 },
228 )
229 .with_handle(self.popover_menu_handle.clone()),
230 );
231 }
232
233 EditPredictionProvider::Zed => {
234 let enabled = self.editor_enabled.unwrap_or(true);
235
236 let zeta_icon = if enabled {
237 IconName::ZedPredict
238 } else {
239 IconName::ZedPredictDisabled
240 };
241
242 let current_user_terms_accepted =
243 self.user_store.read(cx).current_user_has_accepted_terms();
244
245 if !current_user_terms_accepted.unwrap_or(false) {
246 let signed_in = current_user_terms_accepted.is_some();
247 let tooltip_meta = if signed_in {
248 "Read Terms of Service"
249 } else {
250 "Sign in to use"
251 };
252
253 return div().child(
254 IconButton::new("zed-predict-pending-button", zeta_icon)
255 .shape(IconButtonShape::Square)
256 .indicator(Indicator::dot().color(Color::Muted))
257 .indicator_border_color(Some(cx.theme().colors().status_bar_background))
258 .tooltip(move |window, cx| {
259 Tooltip::with_meta(
260 "Edit Predictions",
261 None,
262 tooltip_meta,
263 window,
264 cx,
265 )
266 })
267 .on_click(cx.listener(move |_, _, window, cx| {
268 telemetry::event!(
269 "Pending ToS Clicked",
270 source = "Edit Prediction Status Button"
271 );
272 window.dispatch_action(
273 zed_actions::OpenZedPredictOnboarding.boxed_clone(),
274 cx,
275 );
276 })),
277 );
278 }
279
280 let show_editor_predictions = self.editor_show_predictions;
281
282 let icon_button = IconButton::new("zed-predict-pending-button", zeta_icon)
283 .shape(IconButtonShape::Square)
284 .when(enabled && !show_editor_predictions, |this| {
285 this.indicator(Indicator::dot().color(Color::Muted))
286 .indicator_border_color(Some(cx.theme().colors().status_bar_background))
287 })
288 .when(!self.popover_menu_handle.is_deployed(), |element| {
289 element.tooltip(move |window, cx| {
290 if enabled {
291 if show_editor_predictions {
292 Tooltip::for_action("Edit Prediction", &ToggleMenu, window, cx)
293 } else {
294 Tooltip::with_meta(
295 "Edit Prediction",
296 Some(&ToggleMenu),
297 "Hidden For This File",
298 window,
299 cx,
300 )
301 }
302 } else {
303 Tooltip::with_meta(
304 "Edit Prediction",
305 Some(&ToggleMenu),
306 "Disabled For This File",
307 window,
308 cx,
309 )
310 }
311 })
312 });
313
314 let this = cx.entity().clone();
315
316 let mut popover_menu = PopoverMenu::new("zeta")
317 .menu(move |window, cx| {
318 Some(this.update(cx, |this, cx| this.build_zeta_context_menu(window, cx)))
319 })
320 .anchor(Corner::BottomRight)
321 .with_handle(self.popover_menu_handle.clone());
322
323 let is_refreshing = self
324 .edit_prediction_provider
325 .as_ref()
326 .map_or(false, |provider| provider.is_refreshing(cx));
327
328 if is_refreshing {
329 popover_menu = popover_menu.trigger(
330 icon_button.with_animation(
331 "pulsating-label",
332 Animation::new(Duration::from_secs(2))
333 .repeat()
334 .with_easing(pulsating_between(0.2, 1.0)),
335 |icon_button, delta| icon_button.alpha(delta),
336 ),
337 );
338 } else {
339 popover_menu = popover_menu.trigger(icon_button);
340 }
341
342 div().child(popover_menu.into_any_element())
343 }
344 }
345 }
346}
347
348impl InlineCompletionButton {
349 pub fn new(
350 fs: Arc<dyn Fs>,
351 user_store: Entity<UserStore>,
352 popover_menu_handle: PopoverMenuHandle<ContextMenu>,
353 cx: &mut Context<Self>,
354 ) -> Self {
355 if let Some(copilot) = Copilot::global(cx) {
356 cx.observe(&copilot, |_, _, cx| cx.notify()).detach()
357 }
358
359 cx.observe_global::<SettingsStore>(move |_, cx| cx.notify())
360 .detach();
361
362 Self {
363 editor_subscription: None,
364 editor_enabled: None,
365 editor_show_predictions: true,
366 editor_focus_handle: None,
367 language: None,
368 file: None,
369 edit_prediction_provider: None,
370 popover_menu_handle,
371 fs,
372 user_store,
373 }
374 }
375
376 pub fn build_copilot_start_menu(
377 &mut self,
378 window: &mut Window,
379 cx: &mut Context<Self>,
380 ) -> Entity<ContextMenu> {
381 let fs = self.fs.clone();
382 ContextMenu::build(window, cx, |menu, _, _| {
383 menu.entry("Sign In", None, copilot::initiate_sign_in)
384 .entry("Disable Copilot", None, {
385 let fs = fs.clone();
386 move |_window, cx| hide_copilot(fs.clone(), cx)
387 })
388 .entry("Use Supermaven", None, {
389 let fs = fs.clone();
390 move |_window, cx| {
391 set_completion_provider(fs.clone(), cx, EditPredictionProvider::Supermaven)
392 }
393 })
394 })
395 }
396
397 pub fn build_language_settings_menu(
398 &self,
399 mut menu: ContextMenu,
400 window: &Window,
401 cx: &mut App,
402 ) -> ContextMenu {
403 let fs = self.fs.clone();
404 let line_height = window.line_height();
405
406 if let Some(provider) = self.edit_prediction_provider.as_ref() {
407 if let Some(usage) = provider.usage(cx) {
408 menu = menu.header("Usage");
409 menu = menu.custom_entry(
410 move |_window, cx| {
411 let plan = Plan::ZedProTrial;
412 let edit_predictions_limit = plan.edit_predictions_limit();
413
414 let used_percentage = match edit_predictions_limit {
415 UsageLimit::Limited(limit) => {
416 Some((usage.amount as f32 / limit as f32) * 100.)
417 }
418 UsageLimit::Unlimited => None,
419 };
420
421 h_flex()
422 .flex_1()
423 .gap_1p5()
424 .children(
425 used_percentage
426 .map(|percent| ProgressBar::new("usage", percent, 100., cx)),
427 )
428 .child(
429 Label::new(match edit_predictions_limit {
430 UsageLimit::Limited(limit) => {
431 format!("{} / {limit}", usage.amount)
432 }
433 UsageLimit::Unlimited => format!("{} / ∞", usage.amount),
434 })
435 .size(LabelSize::Small)
436 .color(Color::Muted),
437 )
438 .into_any_element()
439 },
440 move |_, cx| cx.open_url(&zed_urls::account_url(cx)),
441 );
442 }
443 }
444
445 menu = menu.header("Show Edit Predictions For");
446
447 let language_state = self.language.as_ref().map(|language| {
448 (
449 language.clone(),
450 language_settings::language_settings(Some(language.name()), None, cx)
451 .show_edit_predictions,
452 )
453 });
454
455 if let Some(editor_focus_handle) = self.editor_focus_handle.clone() {
456 let entry = ContextMenuEntry::new("This Buffer")
457 .toggleable(IconPosition::Start, self.editor_show_predictions)
458 .action(Box::new(ToggleEditPrediction))
459 .handler(move |window, cx| {
460 editor_focus_handle.dispatch_action(&ToggleEditPrediction, window, cx);
461 });
462
463 match language_state.clone() {
464 Some((language, false)) => {
465 menu = menu.item(
466 entry
467 .disabled(true)
468 .documentation_aside(move |_cx| {
469 Label::new(format!("Edit predictions cannot be toggled for this buffer because they are disabled for {}", language.name()))
470 .into_any_element()
471 })
472 );
473 }
474 Some(_) | None => menu = menu.item(entry),
475 }
476 }
477
478 if let Some((language, language_enabled)) = language_state {
479 let fs = fs.clone();
480
481 menu = menu.toggleable_entry(
482 language.name(),
483 language_enabled,
484 IconPosition::Start,
485 None,
486 move |_, cx| {
487 toggle_show_inline_completions_for_language(language.clone(), fs.clone(), cx)
488 },
489 );
490 }
491
492 let settings = AllLanguageSettings::get_global(cx);
493
494 let globally_enabled = settings.show_edit_predictions(None, cx);
495 menu = menu.toggleable_entry("All Files", globally_enabled, IconPosition::Start, None, {
496 let fs = fs.clone();
497 move |_, cx| toggle_inline_completions_globally(fs.clone(), cx)
498 });
499
500 let provider = settings.edit_predictions.provider;
501 let current_mode = settings.edit_predictions_mode();
502 let subtle_mode = matches!(current_mode, EditPredictionsMode::Subtle);
503 let eager_mode = matches!(current_mode, EditPredictionsMode::Eager);
504
505 if matches!(provider, EditPredictionProvider::Zed) {
506 menu = menu
507 .separator()
508 .header("Display Modes")
509 .item(
510 ContextMenuEntry::new("Eager")
511 .toggleable(IconPosition::Start, eager_mode)
512 .documentation_aside(move |_| {
513 Label::new("Display predictions inline when there are no language server completions available.").into_any_element()
514 })
515 .handler({
516 let fs = fs.clone();
517 move |_, cx| {
518 toggle_edit_prediction_mode(fs.clone(), EditPredictionsMode::Eager, cx)
519 }
520 }),
521 )
522 .item(
523 ContextMenuEntry::new("Subtle")
524 .toggleable(IconPosition::Start, subtle_mode)
525 .documentation_aside(move |_| {
526 Label::new("Display predictions inline only when holding a modifier key (alt by default).").into_any_element()
527 })
528 .handler({
529 let fs = fs.clone();
530 move |_, cx| {
531 toggle_edit_prediction_mode(fs.clone(), EditPredictionsMode::Subtle, cx)
532 }
533 }),
534 );
535 }
536
537 menu = menu.separator().header("Privacy Settings");
538 if let Some(provider) = &self.edit_prediction_provider {
539 let data_collection = provider.data_collection_state(cx);
540 if data_collection.is_supported() {
541 let provider = provider.clone();
542 let enabled = data_collection.is_enabled();
543 let is_open_source = data_collection.is_project_open_source();
544 let is_collecting = data_collection.is_enabled();
545 let (icon_name, icon_color) = if is_open_source && is_collecting {
546 (IconName::Check, Color::Success)
547 } else {
548 (IconName::Check, Color::Accent)
549 };
550
551 menu = menu.item(
552 ContextMenuEntry::new("Training Data Collection")
553 .toggleable(IconPosition::Start, data_collection.is_enabled())
554 .icon(icon_name)
555 .icon_color(icon_color)
556 .documentation_aside(move |cx| {
557 let (msg, label_color, icon_name, icon_color) = match (is_open_source, is_collecting) {
558 (true, true) => (
559 "Project identified as open source, and you're sharing data.",
560 Color::Default,
561 IconName::Check,
562 Color::Success,
563 ),
564 (true, false) => (
565 "Project identified as open source, but you're not sharing data.",
566 Color::Muted,
567 IconName::Close,
568 Color::Muted,
569 ),
570 (false, true) => (
571 "Project not identified as open source. No data captured.",
572 Color::Muted,
573 IconName::Close,
574 Color::Muted,
575 ),
576 (false, false) => (
577 "Project not identified as open source, and setting turned off.",
578 Color::Muted,
579 IconName::Close,
580 Color::Muted,
581 ),
582 };
583 v_flex()
584 .gap_2()
585 .child(
586 Label::new(indoc!{
587 "Help us improve our open dataset model by sharing data from open source repositories. \
588 Zed must detect a license file in your repo for this setting to take effect."
589 })
590 )
591 .child(
592 h_flex()
593 .items_start()
594 .pt_2()
595 .flex_1()
596 .gap_1p5()
597 .border_t_1()
598 .border_color(cx.theme().colors().border_variant)
599 .child(h_flex().flex_shrink_0().h(line_height).child(Icon::new(icon_name).size(IconSize::XSmall).color(icon_color)))
600 .child(div().child(msg).w_full().text_sm().text_color(label_color.color(cx)))
601 )
602 .into_any_element()
603 })
604 .handler(move |_, cx| {
605 provider.toggle_data_collection(cx);
606
607 if !enabled {
608 telemetry::event!(
609 "Data Collection Enabled",
610 source = "Edit Prediction Status Menu"
611 );
612 } else {
613 telemetry::event!(
614 "Data Collection Disabled",
615 source = "Edit Prediction Status Menu"
616 );
617 }
618 })
619 );
620
621 if is_collecting && !is_open_source {
622 menu = menu.item(
623 ContextMenuEntry::new("No data captured.")
624 .disabled(true)
625 .icon(IconName::Close)
626 .icon_color(Color::Error)
627 .icon_size(IconSize::Small),
628 );
629 }
630 }
631 }
632
633 menu = menu.item(
634 ContextMenuEntry::new("Configure Excluded Files")
635 .icon(IconName::LockOutlined)
636 .icon_color(Color::Muted)
637 .documentation_aside(|_| {
638 Label::new(indoc!{"
639 Open your settings to add sensitive paths for which Zed will never predict edits."}).into_any_element()
640 })
641 .handler(move |window, cx| {
642 if let Some(workspace) = window.root().flatten() {
643 let workspace = workspace.downgrade();
644 window
645 .spawn(cx, async |cx| {
646 open_disabled_globs_setting_in_editor(
647 workspace,
648 cx,
649 ).await
650 })
651 .detach_and_log_err(cx);
652 }
653 }),
654 );
655
656 if !self.editor_enabled.unwrap_or(true) {
657 menu = menu.item(
658 ContextMenuEntry::new("This file is excluded.")
659 .disabled(true)
660 .icon(IconName::ZedPredictDisabled)
661 .icon_size(IconSize::Small),
662 );
663 }
664
665 if let Some(editor_focus_handle) = self.editor_focus_handle.clone() {
666 menu = menu
667 .separator()
668 .entry(
669 "Predict Edit at Cursor",
670 Some(Box::new(ShowEditPrediction)),
671 {
672 let editor_focus_handle = editor_focus_handle.clone();
673 move |window, cx| {
674 editor_focus_handle.dispatch_action(&ShowEditPrediction, window, cx);
675 }
676 },
677 )
678 .context(editor_focus_handle);
679 }
680
681 menu
682 }
683
684 fn build_copilot_context_menu(
685 &self,
686 window: &mut Window,
687 cx: &mut Context<Self>,
688 ) -> Entity<ContextMenu> {
689 ContextMenu::build(window, cx, |menu, window, cx| {
690 self.build_language_settings_menu(menu, window, cx)
691 .separator()
692 .link(
693 "Go to Copilot Settings",
694 OpenBrowser {
695 url: COPILOT_SETTINGS_URL.to_string(),
696 }
697 .boxed_clone(),
698 )
699 .action("Sign Out", copilot::SignOut.boxed_clone())
700 })
701 }
702
703 fn build_supermaven_context_menu(
704 &self,
705 window: &mut Window,
706 cx: &mut Context<Self>,
707 ) -> Entity<ContextMenu> {
708 ContextMenu::build(window, cx, |menu, window, cx| {
709 self.build_language_settings_menu(menu, window, cx)
710 .separator()
711 .action("Sign Out", supermaven::SignOut.boxed_clone())
712 })
713 }
714
715 fn build_zeta_context_menu(
716 &self,
717 window: &mut Window,
718 cx: &mut Context<Self>,
719 ) -> Entity<ContextMenu> {
720 ContextMenu::build(window, cx, |menu, window, cx| {
721 self.build_language_settings_menu(menu, window, cx).when(
722 cx.has_flag::<PredictEditsRateCompletionsFeatureFlag>(),
723 |this| this.action("Rate Completions", RateCompletions.boxed_clone()),
724 )
725 })
726 }
727
728 pub fn update_enabled(&mut self, editor: Entity<Editor>, cx: &mut Context<Self>) {
729 let editor = editor.read(cx);
730 let snapshot = editor.buffer().read(cx).snapshot(cx);
731 let suggestion_anchor = editor.selections.newest_anchor().start;
732 let language = snapshot.language_at(suggestion_anchor);
733 let file = snapshot.file_at(suggestion_anchor).cloned();
734 self.editor_enabled = {
735 let file = file.as_ref();
736 Some(
737 file.map(|file| {
738 all_language_settings(Some(file), cx)
739 .edit_predictions_enabled_for_file(file, cx)
740 })
741 .unwrap_or(true),
742 )
743 };
744 self.editor_show_predictions = editor.edit_predictions_enabled();
745 self.edit_prediction_provider = editor.edit_prediction_provider();
746 self.language = language.cloned();
747 self.file = file;
748 self.editor_focus_handle = Some(editor.focus_handle(cx));
749
750 cx.notify();
751 }
752
753 pub fn toggle_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) {
754 self.popover_menu_handle.toggle(window, cx);
755 }
756}
757
758impl StatusItemView for InlineCompletionButton {
759 fn set_active_pane_item(
760 &mut self,
761 item: Option<&dyn ItemHandle>,
762 _: &mut Window,
763 cx: &mut Context<Self>,
764 ) {
765 if let Some(editor) = item.and_then(|item| item.act_as::<Editor>(cx)) {
766 self.editor_subscription = Some((
767 cx.observe(&editor, Self::update_enabled),
768 editor.entity_id().as_u64() as usize,
769 ));
770 self.update_enabled(editor, cx);
771 } else {
772 self.language = None;
773 self.editor_subscription = None;
774 self.editor_enabled = None;
775 }
776 cx.notify();
777 }
778}
779
780impl SupermavenButtonStatus {
781 fn to_icon(&self) -> IconName {
782 match self {
783 SupermavenButtonStatus::Ready => IconName::Supermaven,
784 SupermavenButtonStatus::Errored(_) => IconName::SupermavenError,
785 SupermavenButtonStatus::NeedsActivation(_) => IconName::SupermavenInit,
786 SupermavenButtonStatus::Initializing => IconName::SupermavenInit,
787 }
788 }
789
790 fn to_tooltip(&self) -> String {
791 match self {
792 SupermavenButtonStatus::Ready => "Supermaven is ready".to_string(),
793 SupermavenButtonStatus::Errored(error) => format!("Supermaven error: {}", error),
794 SupermavenButtonStatus::NeedsActivation(_) => "Supermaven needs activation".to_string(),
795 SupermavenButtonStatus::Initializing => "Supermaven initializing".to_string(),
796 }
797 }
798
799 fn has_menu(&self) -> bool {
800 match self {
801 SupermavenButtonStatus::Ready | SupermavenButtonStatus::NeedsActivation(_) => true,
802 SupermavenButtonStatus::Errored(_) | SupermavenButtonStatus::Initializing => false,
803 }
804 }
805}
806
807async fn open_disabled_globs_setting_in_editor(
808 workspace: WeakEntity<Workspace>,
809 cx: &mut AsyncWindowContext,
810) -> Result<()> {
811 let settings_editor = workspace
812 .update_in(cx, |_, window, cx| {
813 create_and_open_local_file(paths::settings_file(), window, cx, || {
814 settings::initial_user_settings_content().as_ref().into()
815 })
816 })?
817 .await?
818 .downcast::<Editor>()
819 .unwrap();
820
821 settings_editor
822 .downgrade()
823 .update_in(cx, |item, window, cx| {
824 let text = item.buffer().read(cx).snapshot(cx).text();
825
826 let settings = cx.global::<SettingsStore>();
827
828 // Ensure that we always have "inline_completions { "disabled_globs": [] }"
829 let edits = settings.edits_for_update::<AllLanguageSettings>(&text, |file| {
830 file.edit_predictions
831 .get_or_insert_with(Default::default)
832 .disabled_globs
833 .get_or_insert_with(Vec::new);
834 });
835
836 if !edits.is_empty() {
837 item.edit(edits.iter().cloned(), cx);
838 }
839
840 let text = item.buffer().read(cx).snapshot(cx).text();
841
842 static DISABLED_GLOBS_REGEX: LazyLock<Regex> = LazyLock::new(|| {
843 Regex::new(r#""disabled_globs":\s*\[\s*(?P<content>(?:.|\n)*?)\s*\]"#).unwrap()
844 });
845 // Only capture [...]
846 let range = DISABLED_GLOBS_REGEX.captures(&text).and_then(|captures| {
847 captures
848 .name("content")
849 .map(|inner_match| inner_match.start()..inner_match.end())
850 });
851 if let Some(range) = range {
852 item.change_selections(Some(Autoscroll::newest()), window, cx, |selections| {
853 selections.select_ranges(vec![range]);
854 });
855 }
856 })?;
857
858 anyhow::Ok(())
859}
860
861fn toggle_inline_completions_globally(fs: Arc<dyn Fs>, cx: &mut App) {
862 let show_edit_predictions = all_language_settings(None, cx).show_edit_predictions(None, cx);
863 update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
864 file.defaults.show_edit_predictions = Some(!show_edit_predictions)
865 });
866}
867
868fn set_completion_provider(fs: Arc<dyn Fs>, cx: &mut App, provider: EditPredictionProvider) {
869 update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
870 file.features
871 .get_or_insert(Default::default())
872 .edit_prediction_provider = Some(provider);
873 });
874}
875
876fn toggle_show_inline_completions_for_language(
877 language: Arc<Language>,
878 fs: Arc<dyn Fs>,
879 cx: &mut App,
880) {
881 let show_edit_predictions =
882 all_language_settings(None, cx).show_edit_predictions(Some(&language), cx);
883 update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
884 file.languages
885 .entry(language.name())
886 .or_default()
887 .show_edit_predictions = Some(!show_edit_predictions);
888 });
889}
890
891fn hide_copilot(fs: Arc<dyn Fs>, cx: &mut App) {
892 update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
893 file.features
894 .get_or_insert(Default::default())
895 .edit_prediction_provider = Some(EditPredictionProvider::None);
896 });
897}
898
899fn toggle_edit_prediction_mode(fs: Arc<dyn Fs>, mode: EditPredictionsMode, cx: &mut App) {
900 let settings = AllLanguageSettings::get_global(cx);
901 let current_mode = settings.edit_predictions_mode();
902
903 if current_mode != mode {
904 update_settings_file::<AllLanguageSettings>(fs, cx, move |settings, _cx| {
905 if let Some(edit_predictions) = settings.edit_predictions.as_mut() {
906 edit_predictions.mode = mode;
907 } else {
908 settings.edit_predictions =
909 Some(language_settings::EditPredictionSettingsContent {
910 mode,
911 ..Default::default()
912 });
913 }
914 });
915 }
916}