1610 lines
65 KiB
Rust
1610 lines
65 KiB
Rust
use anyhow::Result;
|
|
use client::{UserStore, zed_urls};
|
|
use copilot::{Copilot, Status};
|
|
use editor::{
|
|
Editor, SelectionEffects,
|
|
actions::{ShowEditPrediction, ToggleEditPrediction},
|
|
scroll::Autoscroll,
|
|
};
|
|
use feature_flags::{FeatureFlagAppExt, PredictEditsRateCompletionsFeatureFlag};
|
|
use fs::Fs;
|
|
use gpui::{
|
|
Action, Animation, AnimationExt, App, AsyncWindowContext, Corner, Entity, FocusHandle,
|
|
Focusable, IntoElement, ParentElement, Render, Subscription, WeakEntity, actions, div,
|
|
pulsating_between,
|
|
};
|
|
|
|
use indoc::indoc;
|
|
use language::{
|
|
EditPredictionsMode, File, Language,
|
|
language_settings::{self, AllLanguageSettings, EditPredictionProvider, all_language_settings},
|
|
};
|
|
use language_models::AllLanguageModelSettings;
|
|
|
|
use paths;
|
|
use regex::Regex;
|
|
use settings::{Settings, SettingsStore, update_settings_file};
|
|
use std::{
|
|
sync::{Arc, LazyLock},
|
|
time::Duration,
|
|
};
|
|
use supermaven::{AccountStatus, Supermaven};
|
|
use ui::{
|
|
Clickable, ContextMenu, ContextMenuEntry, DocumentationSide, IconButton, IconButtonShape,
|
|
Indicator, PopoverMenu, PopoverMenuHandle, ProgressBar, Tooltip, prelude::*,
|
|
};
|
|
use workspace::{
|
|
StatusItemView, Toast, Workspace, create_and_open_local_file, item::ItemHandle,
|
|
notifications::NotificationId,
|
|
};
|
|
use zed_actions::OpenBrowser;
|
|
use zed_llm_client::UsageLimit;
|
|
use zeta::RateCompletions;
|
|
|
|
actions!(edit_prediction, [ToggleMenu]);
|
|
|
|
const COPILOT_SETTINGS_URL: &str = "https://github.com/settings/copilot";
|
|
|
|
struct CopilotErrorToast;
|
|
|
|
pub struct InlineCompletionButton {
|
|
editor_subscription: Option<(Subscription, usize)>,
|
|
editor_enabled: Option<bool>,
|
|
editor_show_predictions: bool,
|
|
editor_focus_handle: Option<FocusHandle>,
|
|
language: Option<Arc<Language>>,
|
|
file: Option<Arc<dyn File>>,
|
|
edit_prediction_provider: Option<Arc<dyn inline_completion::InlineCompletionProviderHandle>>,
|
|
fs: Arc<dyn Fs>,
|
|
user_store: Entity<UserStore>,
|
|
popover_menu_handle: PopoverMenuHandle<ContextMenu>,
|
|
}
|
|
|
|
enum SupermavenButtonStatus {
|
|
Ready,
|
|
Errored(String),
|
|
NeedsActivation(String),
|
|
Initializing,
|
|
}
|
|
|
|
impl Render for InlineCompletionButton {
|
|
fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let all_language_settings = all_language_settings(None, cx);
|
|
|
|
match all_language_settings.edit_predictions.provider {
|
|
EditPredictionProvider::None => div(),
|
|
|
|
EditPredictionProvider::Copilot => {
|
|
let Some(copilot) = Copilot::global(cx) else {
|
|
return div();
|
|
};
|
|
let status = copilot.read(cx).status();
|
|
|
|
let enabled = self.editor_enabled.unwrap_or(false);
|
|
|
|
let icon = match status {
|
|
Status::Error(_) => IconName::CopilotError,
|
|
Status::Authorized => {
|
|
if enabled {
|
|
IconName::Copilot
|
|
} else {
|
|
IconName::CopilotDisabled
|
|
}
|
|
}
|
|
_ => IconName::CopilotInit,
|
|
};
|
|
|
|
if let Status::Error(e) = status {
|
|
return div().child(
|
|
IconButton::new("copilot-error", icon)
|
|
.icon_size(IconSize::Small)
|
|
.on_click(cx.listener(move |_, _, window, cx| {
|
|
if let Some(workspace) = window.root::<Workspace>().flatten() {
|
|
workspace.update(cx, |workspace, cx| {
|
|
workspace.show_toast(
|
|
Toast::new(
|
|
NotificationId::unique::<CopilotErrorToast>(),
|
|
format!("Copilot can't be started: {}", e),
|
|
)
|
|
.on_click(
|
|
"Reinstall Copilot",
|
|
|window, cx| {
|
|
copilot::reinstall_and_sign_in(window, cx)
|
|
},
|
|
),
|
|
cx,
|
|
);
|
|
});
|
|
}
|
|
}))
|
|
.tooltip(|window, cx| {
|
|
Tooltip::for_action("GitHub Copilot", &ToggleMenu, window, cx)
|
|
}),
|
|
);
|
|
}
|
|
let this = cx.entity().clone();
|
|
|
|
div().child(
|
|
PopoverMenu::new("copilot")
|
|
.menu(move |window, cx| {
|
|
Some(match status {
|
|
Status::Authorized => this.update(cx, |this, cx| {
|
|
this.build_copilot_context_menu(window, cx)
|
|
}),
|
|
_ => this.update(cx, |this, cx| {
|
|
this.build_copilot_start_menu(window, cx)
|
|
}),
|
|
})
|
|
})
|
|
.anchor(Corner::BottomRight)
|
|
.trigger_with_tooltip(
|
|
IconButton::new("copilot-icon", icon),
|
|
|window, cx| {
|
|
Tooltip::for_action("GitHub Copilot", &ToggleMenu, window, cx)
|
|
},
|
|
)
|
|
.with_handle(self.popover_menu_handle.clone()),
|
|
)
|
|
}
|
|
|
|
EditPredictionProvider::Supermaven => {
|
|
let Some(supermaven) = Supermaven::global(cx) else {
|
|
return div();
|
|
};
|
|
|
|
let supermaven = supermaven.read(cx);
|
|
|
|
let status = match supermaven {
|
|
Supermaven::Starting => SupermavenButtonStatus::Initializing,
|
|
Supermaven::FailedDownload { error } => {
|
|
SupermavenButtonStatus::Errored(error.to_string())
|
|
}
|
|
Supermaven::Spawned(agent) => {
|
|
let account_status = agent.account_status.clone();
|
|
match account_status {
|
|
AccountStatus::NeedsActivation { activate_url } => {
|
|
SupermavenButtonStatus::NeedsActivation(activate_url.clone())
|
|
}
|
|
AccountStatus::Unknown => SupermavenButtonStatus::Initializing,
|
|
AccountStatus::Ready => SupermavenButtonStatus::Ready,
|
|
}
|
|
}
|
|
Supermaven::Error { error } => {
|
|
SupermavenButtonStatus::Errored(error.to_string())
|
|
}
|
|
};
|
|
|
|
let icon = status.to_icon();
|
|
let tooltip_text = status.to_tooltip();
|
|
let has_menu = status.has_menu();
|
|
let this = cx.entity().clone();
|
|
let fs = self.fs.clone();
|
|
|
|
return div().child(
|
|
PopoverMenu::new("supermaven")
|
|
.menu(move |window, cx| match &status {
|
|
SupermavenButtonStatus::NeedsActivation(activate_url) => {
|
|
Some(ContextMenu::build(window, cx, |menu, _, _| {
|
|
let fs = fs.clone();
|
|
let activate_url = activate_url.clone();
|
|
menu.entry("Sign In", None, move |_, cx| {
|
|
cx.open_url(activate_url.as_str())
|
|
})
|
|
.entry(
|
|
"Use Copilot",
|
|
None,
|
|
move |_, cx| {
|
|
set_completion_provider(
|
|
fs.clone(),
|
|
cx,
|
|
EditPredictionProvider::Copilot,
|
|
)
|
|
},
|
|
)
|
|
}))
|
|
}
|
|
SupermavenButtonStatus::Ready => Some(this.update(cx, |this, cx| {
|
|
this.build_supermaven_context_menu(window, cx)
|
|
})),
|
|
_ => None,
|
|
})
|
|
.anchor(Corner::BottomRight)
|
|
.trigger_with_tooltip(
|
|
IconButton::new("supermaven-icon", icon),
|
|
move |window, cx| {
|
|
if has_menu {
|
|
Tooltip::for_action(
|
|
tooltip_text.clone(),
|
|
&ToggleMenu,
|
|
window,
|
|
cx,
|
|
)
|
|
} else {
|
|
Tooltip::text(tooltip_text.clone())(window, cx)
|
|
}
|
|
},
|
|
)
|
|
.with_handle(self.popover_menu_handle.clone()),
|
|
);
|
|
}
|
|
|
|
EditPredictionProvider::Zed => {
|
|
let enabled = self.editor_enabled.unwrap_or(true);
|
|
|
|
let zeta_icon = if enabled {
|
|
IconName::ZedPredict
|
|
} else {
|
|
IconName::ZedPredictDisabled
|
|
};
|
|
|
|
let current_user_terms_accepted =
|
|
self.user_store.read(cx).current_user_has_accepted_terms();
|
|
let has_subscription = self.user_store.read(cx).current_plan().is_some()
|
|
&& self.user_store.read(cx).subscription_period().is_some();
|
|
|
|
if !has_subscription || !current_user_terms_accepted.unwrap_or(false) {
|
|
let signed_in = current_user_terms_accepted.is_some();
|
|
let tooltip_meta = if signed_in {
|
|
if has_subscription {
|
|
"Read Terms of Service"
|
|
} else {
|
|
"Choose a Plan"
|
|
}
|
|
} else {
|
|
"Sign in to use"
|
|
};
|
|
|
|
return div().child(
|
|
IconButton::new("zed-predict-pending-button", zeta_icon)
|
|
.shape(IconButtonShape::Square)
|
|
.indicator(Indicator::dot().color(Color::Muted))
|
|
.indicator_border_color(Some(cx.theme().colors().status_bar_background))
|
|
.tooltip(move |window, cx| {
|
|
Tooltip::with_meta(
|
|
"Edit Predictions",
|
|
None,
|
|
tooltip_meta,
|
|
window,
|
|
cx,
|
|
)
|
|
})
|
|
.on_click(cx.listener(move |_, _, window, cx| {
|
|
telemetry::event!(
|
|
"Pending ToS Clicked",
|
|
source = "Edit Prediction Status Button"
|
|
);
|
|
window.dispatch_action(
|
|
zed_actions::OpenZedPredictOnboarding.boxed_clone(),
|
|
cx,
|
|
);
|
|
})),
|
|
);
|
|
}
|
|
|
|
let mut over_limit = false;
|
|
|
|
if let Some(usage) = self
|
|
.edit_prediction_provider
|
|
.as_ref()
|
|
.and_then(|provider| provider.usage(cx))
|
|
{
|
|
over_limit = usage.over_limit()
|
|
}
|
|
|
|
let show_editor_predictions = self.editor_show_predictions;
|
|
|
|
let icon_button = IconButton::new("zed-predict-pending-button", zeta_icon)
|
|
.shape(IconButtonShape::Square)
|
|
.when(
|
|
enabled && (!show_editor_predictions || over_limit),
|
|
|this| {
|
|
this.indicator(Indicator::dot().when_else(
|
|
over_limit,
|
|
|dot| dot.color(Color::Error),
|
|
|dot| dot.color(Color::Muted),
|
|
))
|
|
.indicator_border_color(Some(cx.theme().colors().status_bar_background))
|
|
},
|
|
)
|
|
.when(!self.popover_menu_handle.is_deployed(), |element| {
|
|
element.tooltip(move |window, cx| {
|
|
if enabled {
|
|
if show_editor_predictions {
|
|
Tooltip::for_action("Edit Prediction", &ToggleMenu, window, cx)
|
|
} else {
|
|
Tooltip::with_meta(
|
|
"Edit Prediction",
|
|
Some(&ToggleMenu),
|
|
"Hidden For This File",
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
} else {
|
|
Tooltip::with_meta(
|
|
"Edit Prediction",
|
|
Some(&ToggleMenu),
|
|
"Disabled For This File",
|
|
window,
|
|
cx,
|
|
)
|
|
}
|
|
})
|
|
});
|
|
|
|
let this = cx.entity().clone();
|
|
|
|
let mut popover_menu = PopoverMenu::new("zeta")
|
|
.menu(move |window, cx| {
|
|
Some(this.update(cx, |this, cx| this.build_zeta_context_menu(window, cx)))
|
|
})
|
|
.anchor(Corner::BottomRight)
|
|
.with_handle(self.popover_menu_handle.clone());
|
|
|
|
let is_refreshing = self
|
|
.edit_prediction_provider
|
|
.as_ref()
|
|
.map_or(false, |provider| provider.is_refreshing(cx));
|
|
|
|
if is_refreshing {
|
|
popover_menu = popover_menu.trigger(
|
|
icon_button.with_animation(
|
|
"pulsating-label",
|
|
Animation::new(Duration::from_secs(2))
|
|
.repeat()
|
|
.with_easing(pulsating_between(0.2, 1.0)),
|
|
|icon_button, delta| icon_button.alpha(delta),
|
|
),
|
|
);
|
|
} else {
|
|
popover_menu = popover_menu.trigger(icon_button);
|
|
}
|
|
|
|
div().child(popover_menu.into_any_element())
|
|
}
|
|
|
|
EditPredictionProvider::Ollama => {
|
|
let enabled = self.editor_enabled.unwrap_or(false);
|
|
let icon = if enabled {
|
|
IconName::AiOllama
|
|
} else {
|
|
IconName::AiOllama // Could add disabled variant
|
|
};
|
|
|
|
let this = cx.entity().clone();
|
|
|
|
div().child(
|
|
PopoverMenu::new("ollama")
|
|
.menu(move |window, cx| {
|
|
Some(
|
|
this.update(cx, |this, cx| {
|
|
this.build_ollama_context_menu(window, cx)
|
|
}),
|
|
)
|
|
})
|
|
.trigger(
|
|
IconButton::new("ollama-completion", icon)
|
|
.icon_size(IconSize::Small)
|
|
.tooltip(|window, cx| {
|
|
Tooltip::for_action(
|
|
"Ollama Completion",
|
|
&ToggleMenu,
|
|
window,
|
|
cx,
|
|
)
|
|
}),
|
|
)
|
|
.with_handle(self.popover_menu_handle.clone()),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl InlineCompletionButton {
|
|
pub fn new(
|
|
fs: Arc<dyn Fs>,
|
|
user_store: Entity<UserStore>,
|
|
popover_menu_handle: PopoverMenuHandle<ContextMenu>,
|
|
cx: &mut Context<Self>,
|
|
) -> Self {
|
|
if let Some(copilot) = Copilot::global(cx) {
|
|
cx.observe(&copilot, |_, _, cx| cx.notify()).detach()
|
|
}
|
|
|
|
cx.observe_global::<SettingsStore>(move |_, cx| cx.notify())
|
|
.detach();
|
|
|
|
Self {
|
|
editor_subscription: None,
|
|
editor_enabled: None,
|
|
editor_show_predictions: false,
|
|
editor_focus_handle: None,
|
|
language: None,
|
|
file: None,
|
|
edit_prediction_provider: None,
|
|
popover_menu_handle,
|
|
fs,
|
|
user_store,
|
|
}
|
|
}
|
|
|
|
pub fn build_copilot_start_menu(
|
|
&mut self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Entity<ContextMenu> {
|
|
let fs = self.fs.clone();
|
|
ContextMenu::build(window, cx, |menu, _, _| {
|
|
menu.entry("Sign In", None, copilot::initiate_sign_in)
|
|
.entry("Disable Copilot", None, {
|
|
let fs = fs.clone();
|
|
move |_window, cx| hide_copilot(fs.clone(), cx)
|
|
})
|
|
.entry("Use Supermaven", None, {
|
|
let fs = fs.clone();
|
|
move |_window, cx| {
|
|
set_completion_provider(fs.clone(), cx, EditPredictionProvider::Supermaven)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
pub fn build_language_settings_menu(
|
|
&self,
|
|
mut menu: ContextMenu,
|
|
window: &Window,
|
|
cx: &mut App,
|
|
) -> ContextMenu {
|
|
let fs = self.fs.clone();
|
|
let line_height = window.line_height();
|
|
|
|
menu = menu.header("Show Edit Predictions For");
|
|
|
|
let language_state = self.language.as_ref().map(|language| {
|
|
(
|
|
language.clone(),
|
|
language_settings::language_settings(Some(language.name()), None, cx)
|
|
.show_edit_predictions,
|
|
)
|
|
});
|
|
|
|
if let Some(editor_focus_handle) = self.editor_focus_handle.clone() {
|
|
let entry = ContextMenuEntry::new("This Buffer")
|
|
.toggleable(IconPosition::Start, self.editor_show_predictions)
|
|
.action(Box::new(ToggleEditPrediction))
|
|
.handler(move |window, cx| {
|
|
editor_focus_handle.dispatch_action(&ToggleEditPrediction, window, cx);
|
|
});
|
|
|
|
match language_state.clone() {
|
|
Some((language, false)) => {
|
|
menu = menu.item(
|
|
entry
|
|
.disabled(true)
|
|
.documentation_aside(DocumentationSide::Left, move |_cx| {
|
|
Label::new(format!("Edit predictions cannot be toggled for this buffer because they are disabled for {}", language.name()))
|
|
.into_any_element()
|
|
})
|
|
);
|
|
}
|
|
Some(_) | None => menu = menu.item(entry),
|
|
}
|
|
}
|
|
|
|
if let Some((language, language_enabled)) = language_state {
|
|
let fs = fs.clone();
|
|
|
|
menu = menu.toggleable_entry(
|
|
language.name(),
|
|
language_enabled,
|
|
IconPosition::Start,
|
|
None,
|
|
move |_, cx| {
|
|
toggle_show_inline_completions_for_language(language.clone(), fs.clone(), cx)
|
|
},
|
|
);
|
|
}
|
|
|
|
let settings = AllLanguageSettings::get_global(cx);
|
|
|
|
let globally_enabled = settings.show_edit_predictions(None, cx);
|
|
menu = menu.toggleable_entry("All Files", globally_enabled, IconPosition::Start, None, {
|
|
let fs = fs.clone();
|
|
move |_, cx| toggle_inline_completions_globally(fs.clone(), cx)
|
|
});
|
|
|
|
let provider = settings.edit_predictions.provider;
|
|
let current_mode = settings.edit_predictions_mode();
|
|
let subtle_mode = matches!(current_mode, EditPredictionsMode::Subtle);
|
|
let eager_mode = matches!(current_mode, EditPredictionsMode::Eager);
|
|
|
|
if matches!(
|
|
provider,
|
|
EditPredictionProvider::Zed | EditPredictionProvider::Ollama
|
|
) {
|
|
menu = menu
|
|
.separator()
|
|
.header("Display Modes")
|
|
.item(
|
|
ContextMenuEntry::new("Eager")
|
|
.toggleable(IconPosition::Start, eager_mode)
|
|
.documentation_aside(DocumentationSide::Left, move |_| {
|
|
Label::new("Display predictions inline when there are no language server completions available.").into_any_element()
|
|
})
|
|
.handler({
|
|
let fs = fs.clone();
|
|
move |_, cx| {
|
|
toggle_edit_prediction_mode(fs.clone(), EditPredictionsMode::Eager, cx)
|
|
}
|
|
}),
|
|
)
|
|
.item(
|
|
ContextMenuEntry::new("Subtle")
|
|
.toggleable(IconPosition::Start, subtle_mode)
|
|
.documentation_aside(DocumentationSide::Left, move |_| {
|
|
Label::new("Display predictions inline only when holding a modifier key (alt by default).").into_any_element()
|
|
})
|
|
.handler({
|
|
let fs = fs.clone();
|
|
move |_, cx| {
|
|
toggle_edit_prediction_mode(fs.clone(), EditPredictionsMode::Subtle, cx)
|
|
}
|
|
}),
|
|
);
|
|
}
|
|
|
|
menu = menu.separator().header("Privacy Settings");
|
|
if let Some(provider) = &self.edit_prediction_provider {
|
|
let data_collection = provider.data_collection_state(cx);
|
|
if data_collection.is_supported() {
|
|
let provider = provider.clone();
|
|
let enabled = data_collection.is_enabled();
|
|
let is_open_source = data_collection.is_project_open_source();
|
|
let is_collecting = data_collection.is_enabled();
|
|
let (icon_name, icon_color) = if is_open_source && is_collecting {
|
|
(IconName::Check, Color::Success)
|
|
} else {
|
|
(IconName::Check, Color::Accent)
|
|
};
|
|
|
|
menu = menu.item(
|
|
ContextMenuEntry::new("Training Data Collection")
|
|
.toggleable(IconPosition::Start, data_collection.is_enabled())
|
|
.icon(icon_name)
|
|
.icon_color(icon_color)
|
|
.documentation_aside(DocumentationSide::Left, move |cx| {
|
|
let (msg, label_color, icon_name, icon_color) = match (is_open_source, is_collecting) {
|
|
(true, true) => (
|
|
"Project identified as open source, and you're sharing data.",
|
|
Color::Default,
|
|
IconName::Check,
|
|
Color::Success,
|
|
),
|
|
(true, false) => (
|
|
"Project identified as open source, but you're not sharing data.",
|
|
Color::Muted,
|
|
IconName::Close,
|
|
Color::Muted,
|
|
),
|
|
(false, true) => (
|
|
"Project not identified as open source. No data captured.",
|
|
Color::Muted,
|
|
IconName::Close,
|
|
Color::Muted,
|
|
),
|
|
(false, false) => (
|
|
"Project not identified as open source, and setting turned off.",
|
|
Color::Muted,
|
|
IconName::Close,
|
|
Color::Muted,
|
|
),
|
|
};
|
|
v_flex()
|
|
.gap_2()
|
|
.child(
|
|
Label::new(indoc!{
|
|
"Help us improve our open dataset model by sharing data from open source repositories. \
|
|
Zed must detect a license file in your repo for this setting to take effect."
|
|
})
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.items_start()
|
|
.pt_2()
|
|
.flex_1()
|
|
.gap_1p5()
|
|
.border_t_1()
|
|
.border_color(cx.theme().colors().border_variant)
|
|
.child(h_flex().flex_shrink_0().h(line_height).child(Icon::new(icon_name).size(IconSize::XSmall).color(icon_color)))
|
|
.child(div().child(msg).w_full().text_sm().text_color(label_color.color(cx)))
|
|
)
|
|
.into_any_element()
|
|
})
|
|
.handler(move |_, cx| {
|
|
provider.toggle_data_collection(cx);
|
|
|
|
if !enabled {
|
|
telemetry::event!(
|
|
"Data Collection Enabled",
|
|
source = "Edit Prediction Status Menu"
|
|
);
|
|
} else {
|
|
telemetry::event!(
|
|
"Data Collection Disabled",
|
|
source = "Edit Prediction Status Menu"
|
|
);
|
|
}
|
|
})
|
|
);
|
|
|
|
if is_collecting && !is_open_source {
|
|
menu = menu.item(
|
|
ContextMenuEntry::new("No data captured.")
|
|
.disabled(true)
|
|
.icon(IconName::Close)
|
|
.icon_color(Color::Error)
|
|
.icon_size(IconSize::Small),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
menu = menu.item(
|
|
ContextMenuEntry::new("Configure Excluded Files")
|
|
.icon(IconName::LockOutlined)
|
|
.icon_color(Color::Muted)
|
|
.documentation_aside(DocumentationSide::Left, |_| {
|
|
Label::new(indoc!{"
|
|
Open your settings to add sensitive paths for which Zed will never predict edits."}).into_any_element()
|
|
})
|
|
.handler(move |window, cx| {
|
|
if let Some(workspace) = window.root().flatten() {
|
|
let workspace = workspace.downgrade();
|
|
window
|
|
.spawn(cx, async |cx| {
|
|
open_disabled_globs_setting_in_editor(
|
|
workspace,
|
|
cx,
|
|
).await
|
|
})
|
|
.detach_and_log_err(cx);
|
|
}
|
|
}),
|
|
);
|
|
|
|
if !self.editor_enabled.unwrap_or(true) {
|
|
menu = menu.item(
|
|
ContextMenuEntry::new("This file is excluded.")
|
|
.disabled(true)
|
|
.icon(IconName::ZedPredictDisabled)
|
|
.icon_size(IconSize::Small),
|
|
);
|
|
}
|
|
|
|
if let Some(editor_focus_handle) = self.editor_focus_handle.clone() {
|
|
menu = menu
|
|
.separator()
|
|
.entry(
|
|
"Predict Edit at Cursor",
|
|
Some(Box::new(ShowEditPrediction)),
|
|
{
|
|
let editor_focus_handle = editor_focus_handle.clone();
|
|
move |window, cx| {
|
|
editor_focus_handle.dispatch_action(&ShowEditPrediction, window, cx);
|
|
}
|
|
},
|
|
)
|
|
.context(editor_focus_handle);
|
|
}
|
|
|
|
menu
|
|
}
|
|
|
|
fn build_copilot_context_menu(
|
|
&self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Entity<ContextMenu> {
|
|
ContextMenu::build(window, cx, |menu, window, cx| {
|
|
self.build_language_settings_menu(menu, window, cx)
|
|
.separator()
|
|
.link(
|
|
"Go to Copilot Settings",
|
|
OpenBrowser {
|
|
url: COPILOT_SETTINGS_URL.to_string(),
|
|
}
|
|
.boxed_clone(),
|
|
)
|
|
.action("Sign Out", copilot::SignOut.boxed_clone())
|
|
})
|
|
}
|
|
|
|
fn build_supermaven_context_menu(
|
|
&self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Entity<ContextMenu> {
|
|
ContextMenu::build(window, cx, |menu, window, cx| {
|
|
self.build_language_settings_menu(menu, window, cx)
|
|
.separator()
|
|
.action("Sign Out", supermaven::SignOut.boxed_clone())
|
|
})
|
|
}
|
|
|
|
fn build_zeta_context_menu(
|
|
&self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Entity<ContextMenu> {
|
|
ContextMenu::build(window, cx, |mut menu, window, cx| {
|
|
if let Some(usage) = self
|
|
.edit_prediction_provider
|
|
.as_ref()
|
|
.and_then(|provider| provider.usage(cx))
|
|
{
|
|
menu = menu.header("Usage");
|
|
menu = menu
|
|
.custom_entry(
|
|
move |_window, cx| {
|
|
let used_percentage = match usage.limit {
|
|
UsageLimit::Limited(limit) => {
|
|
Some((usage.amount as f32 / limit as f32) * 100.)
|
|
}
|
|
UsageLimit::Unlimited => None,
|
|
};
|
|
|
|
h_flex()
|
|
.flex_1()
|
|
.gap_1p5()
|
|
.children(
|
|
used_percentage.map(|percent| {
|
|
ProgressBar::new("usage", percent, 100., cx)
|
|
}),
|
|
)
|
|
.child(
|
|
Label::new(match usage.limit {
|
|
UsageLimit::Limited(limit) => {
|
|
format!("{} / {limit}", usage.amount)
|
|
}
|
|
UsageLimit::Unlimited => format!("{} / ∞", usage.amount),
|
|
})
|
|
.size(LabelSize::Small)
|
|
.color(Color::Muted),
|
|
)
|
|
.into_any_element()
|
|
},
|
|
move |_, cx| cx.open_url(&zed_urls::account_url(cx)),
|
|
)
|
|
.when(usage.over_limit(), |menu| -> ContextMenu {
|
|
menu.entry("Subscribe to increase your limit", None, |_window, cx| {
|
|
cx.open_url(&zed_urls::account_url(cx))
|
|
})
|
|
})
|
|
.separator();
|
|
} else if self.user_store.read(cx).account_too_young() {
|
|
menu = menu
|
|
.custom_entry(
|
|
|_window, _cx| {
|
|
h_flex()
|
|
.gap_1()
|
|
.child(
|
|
Icon::new(IconName::Warning)
|
|
.size(IconSize::Small)
|
|
.color(Color::Warning),
|
|
)
|
|
.child(
|
|
Label::new("Your GitHub account is less than 30 days old")
|
|
.size(LabelSize::Small)
|
|
.color(Color::Warning),
|
|
)
|
|
.into_any_element()
|
|
},
|
|
|_window, cx| cx.open_url(&zed_urls::account_url(cx)),
|
|
)
|
|
.entry(
|
|
"You need to upgrade to Zed Pro or contact us.",
|
|
None,
|
|
|_window, cx| cx.open_url(&zed_urls::account_url(cx)),
|
|
)
|
|
.separator();
|
|
} else if self.user_store.read(cx).has_overdue_invoices() {
|
|
menu = menu
|
|
.custom_entry(
|
|
|_window, _cx| {
|
|
h_flex()
|
|
.gap_1()
|
|
.child(
|
|
Icon::new(IconName::Warning)
|
|
.size(IconSize::Small)
|
|
.color(Color::Warning),
|
|
)
|
|
.child(
|
|
Label::new("You have an outstanding invoice")
|
|
.size(LabelSize::Small)
|
|
.color(Color::Warning),
|
|
)
|
|
.into_any_element()
|
|
},
|
|
|_window, cx| {
|
|
cx.open_url(&zed_urls::account_url(cx))
|
|
},
|
|
)
|
|
.entry(
|
|
"Check your payment status or contact us at billing-support@zed.dev to continue using this feature.",
|
|
None,
|
|
|_window, cx| {
|
|
cx.open_url(&zed_urls::account_url(cx))
|
|
},
|
|
)
|
|
.separator();
|
|
}
|
|
|
|
self.build_language_settings_menu(menu, window, cx).when(
|
|
cx.has_flag::<PredictEditsRateCompletionsFeatureFlag>(),
|
|
|this| this.action("Rate Completions", RateCompletions.boxed_clone()),
|
|
)
|
|
})
|
|
}
|
|
|
|
/// Builds a simplified context menu for Ollama with essential features:
|
|
/// - API URL configuration that opens settings at the correct location
|
|
/// - Model selection from available models
|
|
/// - Common language settings (buffer/language/global toggles, privacy settings)
|
|
///
|
|
/// The menu focuses on core functionality without connection status or external links.
|
|
fn build_ollama_context_menu(
|
|
&self,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Entity<ContextMenu> {
|
|
let fs = self.fs.clone();
|
|
ContextMenu::build(window, cx, |menu, window, cx| {
|
|
let settings = AllLanguageModelSettings::get_global(cx);
|
|
let ollama_settings = &settings.ollama;
|
|
|
|
// Clone needed values to avoid borrowing issues
|
|
let available_models = ollama_settings.available_models.clone();
|
|
|
|
// API URL configuration - only show if Ollama settings exist in the user's config
|
|
let menu = if Self::ollama_settings_exist(cx) {
|
|
menu.entry("Configure API URL", None, {
|
|
let fs = fs.clone();
|
|
move |window, cx| {
|
|
Self::open_ollama_settings(fs.clone(), window, cx);
|
|
}
|
|
})
|
|
} else {
|
|
menu
|
|
};
|
|
|
|
// Model selection section
|
|
let menu = if !available_models.is_empty() {
|
|
let menu = menu.separator().header("Available Models");
|
|
|
|
// Add each available model as a menu entry
|
|
available_models.iter().fold(menu, |menu, model| {
|
|
let model_name = model.display_name.as_ref().unwrap_or(&model.name);
|
|
let is_current = available_models
|
|
.first()
|
|
.map(|m| &m.name == &model.name)
|
|
.unwrap_or(false);
|
|
|
|
menu.toggleable_entry(
|
|
model_name.clone(),
|
|
is_current,
|
|
IconPosition::Start,
|
|
None,
|
|
{
|
|
let model_name = model.name.clone();
|
|
let fs = fs.clone();
|
|
move |_window, cx| {
|
|
Self::switch_ollama_model(fs.clone(), model_name.clone(), cx);
|
|
}
|
|
},
|
|
)
|
|
})
|
|
} else {
|
|
menu.separator()
|
|
.header("No Models Configured")
|
|
.entry("Configure Models", None, {
|
|
let fs = fs.clone();
|
|
move |window, cx| {
|
|
Self::open_ollama_settings(fs.clone(), window, cx);
|
|
}
|
|
})
|
|
};
|
|
|
|
// Use the common language settings menu
|
|
self.build_language_settings_menu(menu, window, cx)
|
|
})
|
|
}
|
|
|
|
/// Opens Zed settings and navigates directly to the Ollama models configuration.
|
|
/// Uses improved regex patterns to locate the exact setting in the JSON structure.
|
|
fn open_ollama_settings(_fs: Arc<dyn Fs>, window: &mut Window, cx: &mut App) {
|
|
if let Some(workspace) = window.root::<Workspace>().flatten() {
|
|
let workspace = workspace.downgrade();
|
|
window
|
|
.spawn(cx, async move |cx| {
|
|
let settings_editor = workspace
|
|
.update_in(cx, |_, window, cx| {
|
|
create_and_open_local_file(paths::settings_file(), window, cx, || {
|
|
settings::initial_user_settings_content().as_ref().into()
|
|
})
|
|
})?
|
|
.await?
|
|
.downcast::<Editor>()
|
|
.unwrap();
|
|
|
|
let _ = settings_editor
|
|
.downgrade()
|
|
.update_in(cx, |item, window, cx| {
|
|
let text = item.buffer().read(cx).snapshot(cx).text();
|
|
|
|
// Look for language_models.ollama section with precise pattern
|
|
// This matches the full nested structure to avoid false matches
|
|
let ollama_pattern = r#""language_models"\s*:\s*\{[\s\S]*?"ollama"\s*:\s*\{[\s\S]*?"available_models"\s*:\s*\[\s*\]"#;
|
|
let regex = regex::Regex::new(ollama_pattern).unwrap();
|
|
|
|
if let Some(captures) = regex.captures(&text) {
|
|
let full_match = captures.get(0).unwrap();
|
|
|
|
// Position cursor after the opening bracket of available_models array
|
|
let bracket_pos = full_match.as_str().rfind('[').unwrap();
|
|
let cursor_pos = full_match.start() + bracket_pos + 1;
|
|
|
|
// Place cursor inside the available_models array
|
|
item.change_selections(
|
|
SelectionEffects::scroll(Autoscroll::newest()),
|
|
window,
|
|
cx,
|
|
|selections| {
|
|
selections.select_ranges(vec![cursor_pos..cursor_pos]);
|
|
},
|
|
);
|
|
return Ok::<(), anyhow::Error>(());
|
|
}
|
|
|
|
Ok::<(), anyhow::Error>(())
|
|
})?;
|
|
|
|
Ok::<(), anyhow::Error>(())
|
|
})
|
|
.detach_and_log_err(cx);
|
|
}
|
|
}
|
|
|
|
fn ollama_settings_exist(_cx: &mut App) -> bool {
|
|
// Check if there's an ollama section in the settings file
|
|
let settings_content = std::fs::read_to_string(paths::settings_file()).unwrap_or_default();
|
|
Self::ollama_settings_exist_in_content(&settings_content)
|
|
}
|
|
|
|
fn ollama_settings_exist_in_content(content: &str) -> bool {
|
|
let api_url_pattern = r#""language_models"\s*:\s*\{[\s\S]*?"ollama"\s*:\s*\{[\s\S]*?"api_url"\s*:\s*"([^"]*)"#;
|
|
let regex = regex::Regex::new(api_url_pattern).unwrap();
|
|
regex.is_match(content)
|
|
}
|
|
|
|
fn switch_ollama_model(fs: Arc<dyn Fs>, model_name: String, cx: &mut App) {
|
|
update_settings_file::<AllLanguageModelSettings>(fs, cx, move |settings, _cx| {
|
|
// Move the selected model to the front of the list to make it the active model
|
|
// The Ollama provider uses the first model in the available_models list
|
|
if let Some(ollama_settings) = &mut settings.ollama {
|
|
if let Some(models) = &mut ollama_settings.available_models {
|
|
if let Some(index) = models.iter().position(|m| m.name == model_name) {
|
|
let selected_model = models.remove(index);
|
|
models.insert(0, selected_model);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
pub fn update_enabled(&mut self, editor: Entity<Editor>, cx: &mut Context<Self>) {
|
|
let editor = editor.read(cx);
|
|
let snapshot = editor.buffer().read(cx).snapshot(cx);
|
|
let suggestion_anchor = editor.selections.newest_anchor().start;
|
|
let language = snapshot.language_at(suggestion_anchor);
|
|
let file = snapshot.file_at(suggestion_anchor).cloned();
|
|
self.editor_enabled = {
|
|
let file = file.as_ref();
|
|
Some(
|
|
file.map(|file| {
|
|
all_language_settings(Some(file), cx)
|
|
.edit_predictions_enabled_for_file(file, cx)
|
|
})
|
|
.unwrap_or(true),
|
|
)
|
|
};
|
|
self.editor_show_predictions = editor.edit_predictions_enabled();
|
|
self.edit_prediction_provider = editor.edit_prediction_provider();
|
|
self.language = language.cloned();
|
|
self.file = file;
|
|
self.editor_focus_handle = Some(editor.focus_handle(cx));
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
pub fn toggle_menu(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
|
self.popover_menu_handle.toggle(window, cx);
|
|
}
|
|
}
|
|
|
|
impl StatusItemView for InlineCompletionButton {
|
|
fn set_active_pane_item(
|
|
&mut self,
|
|
item: Option<&dyn ItemHandle>,
|
|
_: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
if let Some(editor) = item.and_then(|item| item.act_as::<Editor>(cx)) {
|
|
self.editor_subscription = Some((
|
|
cx.observe(&editor, Self::update_enabled),
|
|
editor.entity_id().as_u64() as usize,
|
|
));
|
|
self.update_enabled(editor, cx);
|
|
} else {
|
|
self.language = None;
|
|
self.editor_subscription = None;
|
|
self.editor_enabled = None;
|
|
}
|
|
cx.notify();
|
|
}
|
|
}
|
|
|
|
impl SupermavenButtonStatus {
|
|
fn to_icon(&self) -> IconName {
|
|
match self {
|
|
SupermavenButtonStatus::Ready => IconName::Supermaven,
|
|
SupermavenButtonStatus::Errored(_) => IconName::SupermavenError,
|
|
SupermavenButtonStatus::NeedsActivation(_) => IconName::SupermavenInit,
|
|
SupermavenButtonStatus::Initializing => IconName::SupermavenInit,
|
|
}
|
|
}
|
|
|
|
fn to_tooltip(&self) -> String {
|
|
match self {
|
|
SupermavenButtonStatus::Ready => "Supermaven is ready".to_string(),
|
|
SupermavenButtonStatus::Errored(error) => format!("Supermaven error: {}", error),
|
|
SupermavenButtonStatus::NeedsActivation(_) => "Supermaven needs activation".to_string(),
|
|
SupermavenButtonStatus::Initializing => "Supermaven initializing".to_string(),
|
|
}
|
|
}
|
|
|
|
fn has_menu(&self) -> bool {
|
|
match self {
|
|
SupermavenButtonStatus::Ready | SupermavenButtonStatus::NeedsActivation(_) => true,
|
|
SupermavenButtonStatus::Errored(_) | SupermavenButtonStatus::Initializing => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn open_disabled_globs_setting_in_editor(
|
|
workspace: WeakEntity<Workspace>,
|
|
cx: &mut AsyncWindowContext,
|
|
) -> Result<()> {
|
|
let settings_editor = workspace
|
|
.update_in(cx, |_, window, cx| {
|
|
create_and_open_local_file(paths::settings_file(), window, cx, || {
|
|
settings::initial_user_settings_content().as_ref().into()
|
|
})
|
|
})?
|
|
.await?
|
|
.downcast::<Editor>()
|
|
.unwrap();
|
|
|
|
settings_editor
|
|
.downgrade()
|
|
.update_in(cx, |item, window, cx| {
|
|
let text = item.buffer().read(cx).snapshot(cx).text();
|
|
|
|
let settings = cx.global::<SettingsStore>();
|
|
|
|
// Ensure that we always have "inline_completions { "disabled_globs": [] }"
|
|
let edits = settings.edits_for_update::<AllLanguageSettings>(&text, |file| {
|
|
file.edit_predictions
|
|
.get_or_insert_with(Default::default)
|
|
.disabled_globs
|
|
.get_or_insert_with(Vec::new);
|
|
});
|
|
|
|
if !edits.is_empty() {
|
|
item.edit(edits, cx);
|
|
}
|
|
|
|
let text = item.buffer().read(cx).snapshot(cx).text();
|
|
|
|
static DISABLED_GLOBS_REGEX: LazyLock<Regex> = LazyLock::new(|| {
|
|
Regex::new(r#""disabled_globs":\s*\[\s*(?P<content>(?:.|\n)*?)\s*\]"#).unwrap()
|
|
});
|
|
// Only capture [...]
|
|
let range = DISABLED_GLOBS_REGEX.captures(&text).and_then(|captures| {
|
|
captures
|
|
.name("content")
|
|
.map(|inner_match| inner_match.start()..inner_match.end())
|
|
});
|
|
if let Some(range) = range {
|
|
item.change_selections(
|
|
SelectionEffects::scroll(Autoscroll::newest()),
|
|
window,
|
|
cx,
|
|
|selections| {
|
|
selections.select_ranges(vec![range]);
|
|
},
|
|
);
|
|
}
|
|
})?;
|
|
|
|
anyhow::Ok(())
|
|
}
|
|
|
|
fn toggle_inline_completions_globally(fs: Arc<dyn Fs>, cx: &mut App) {
|
|
let show_edit_predictions = all_language_settings(None, cx).show_edit_predictions(None, cx);
|
|
update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
|
|
file.defaults.show_edit_predictions = Some(!show_edit_predictions)
|
|
});
|
|
}
|
|
|
|
fn set_completion_provider(fs: Arc<dyn Fs>, cx: &mut App, provider: EditPredictionProvider) {
|
|
update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
|
|
file.features
|
|
.get_or_insert(Default::default())
|
|
.edit_prediction_provider = Some(provider);
|
|
});
|
|
}
|
|
|
|
fn toggle_show_inline_completions_for_language(
|
|
language: Arc<Language>,
|
|
fs: Arc<dyn Fs>,
|
|
cx: &mut App,
|
|
) {
|
|
let show_edit_predictions =
|
|
all_language_settings(None, cx).show_edit_predictions(Some(&language), cx);
|
|
update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
|
|
file.languages
|
|
.entry(language.name())
|
|
.or_default()
|
|
.show_edit_predictions = Some(!show_edit_predictions);
|
|
});
|
|
}
|
|
|
|
fn hide_copilot(fs: Arc<dyn Fs>, cx: &mut App) {
|
|
update_settings_file::<AllLanguageSettings>(fs, cx, move |file, _| {
|
|
file.features
|
|
.get_or_insert(Default::default())
|
|
.edit_prediction_provider = Some(EditPredictionProvider::None);
|
|
});
|
|
}
|
|
|
|
fn toggle_edit_prediction_mode(fs: Arc<dyn Fs>, mode: EditPredictionsMode, cx: &mut App) {
|
|
let settings = AllLanguageSettings::get_global(cx);
|
|
let current_mode = settings.edit_predictions_mode();
|
|
|
|
if current_mode != mode {
|
|
update_settings_file::<AllLanguageSettings>(fs, cx, move |settings, _cx| {
|
|
if let Some(edit_predictions) = settings.edit_predictions.as_mut() {
|
|
edit_predictions.mode = mode;
|
|
} else {
|
|
settings.edit_predictions =
|
|
Some(language_settings::EditPredictionSettingsContent {
|
|
mode,
|
|
..Default::default()
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use client::{Client, UserStore};
|
|
use clock::FakeSystemClock;
|
|
use fs::{FakeFs, Fs};
|
|
use gpui::TestAppContext;
|
|
use http_client::FakeHttpClient;
|
|
use language_model;
|
|
use language_models::AllLanguageModelSettings;
|
|
use settings::SettingsStore;
|
|
use std::sync::Arc;
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_context_menu_functionality(cx: &mut TestAppContext) {
|
|
let fs: Arc<dyn Fs> = FakeFs::new(cx.executor());
|
|
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
let clock = Arc::new(FakeSystemClock::new());
|
|
let http = FakeHttpClient::with_404_response();
|
|
let client = Client::new(clock, http.clone(), cx);
|
|
let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
|
|
let popover_menu_handle = PopoverMenuHandle::default();
|
|
|
|
let button = cx.new(|cx| {
|
|
InlineCompletionButton::new(fs.clone(), user_store, popover_menu_handle, cx)
|
|
});
|
|
|
|
// Verify that the button was created successfully
|
|
assert!(button.entity_id().as_u64() > 0);
|
|
|
|
// Test that accessing Ollama settings doesn't panic
|
|
let settings = AllLanguageModelSettings::get_global(cx);
|
|
let ollama_settings = &settings.ollama;
|
|
|
|
// Verify connection status is properly determined
|
|
let is_connected = !ollama_settings.available_models.is_empty();
|
|
assert!(!is_connected); // Should be disconnected in test environment
|
|
|
|
// Verify API URL is accessible
|
|
assert!(ollama_settings.api_url.contains("localhost"));
|
|
|
|
// Verify the button has access to build_language_settings_menu method
|
|
// This indirectly tests that Ollama menu can use the common functionality
|
|
button.read(cx);
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_settings_access(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test that Ollama settings can be accessed
|
|
let settings = AllLanguageModelSettings::get_global(cx);
|
|
let ollama_settings = &settings.ollama;
|
|
|
|
// Verify default settings structure
|
|
assert!(ollama_settings.api_url.contains("localhost"));
|
|
assert!(ollama_settings.available_models.is_empty());
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_menu_structure(cx: &mut TestAppContext) {
|
|
let fs: Arc<dyn Fs> = FakeFs::new(cx.executor());
|
|
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
let clock = Arc::new(FakeSystemClock::new());
|
|
let http = FakeHttpClient::with_404_response();
|
|
let client = Client::new(clock, http.clone(), cx);
|
|
let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
|
|
let popover_menu_handle = PopoverMenuHandle::default();
|
|
|
|
let button = cx.new(|cx| {
|
|
InlineCompletionButton::new(fs.clone(), user_store, popover_menu_handle, cx)
|
|
});
|
|
|
|
// Test that the menu includes expected sections
|
|
let settings = AllLanguageModelSettings::get_global(cx);
|
|
let ollama_settings = &settings.ollama;
|
|
|
|
// Verify default connection status (should be disconnected in test)
|
|
let is_connected = !ollama_settings.available_models.is_empty();
|
|
assert!(!is_connected); // No models available in test environment
|
|
|
|
// Verify API URL is accessible and has default value
|
|
assert!(ollama_settings.api_url.contains("localhost"));
|
|
|
|
// Verify button can be created and read without panicking
|
|
button.read(cx);
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_default_settings(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test default Ollama settings structure
|
|
let settings = AllLanguageModelSettings::get_global(cx);
|
|
let ollama_settings = &settings.ollama;
|
|
|
|
// Verify default configuration
|
|
assert!(ollama_settings.api_url.contains("localhost"));
|
|
assert!(ollama_settings.available_models.is_empty());
|
|
|
|
// Test that menu creation would work with these defaults
|
|
// (We don't actually create the menu to avoid UI complexity in tests)
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_api_url_navigation_regex(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test the regex patterns used for API URL navigation
|
|
let test_settings_content = r#"{
|
|
"language_models": {
|
|
"ollama": {
|
|
"api_url": "http://localhost:11434",
|
|
"available_models": []
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
// Test the precise regex pattern
|
|
let api_url_pattern =
|
|
r#""language_models"\s*:\s*\{[\s\S]*?"ollama"\s*:\s*\{[\s\S]*?"api_url"\s*:\s*"([^"]*)"#;
|
|
let regex = regex::Regex::new(api_url_pattern).unwrap();
|
|
|
|
if let Some(captures) = regex.captures(test_settings_content) {
|
|
let value_capture = captures.get(1).unwrap();
|
|
assert_eq!(value_capture.as_str(), "http://localhost:11434");
|
|
|
|
// Verify the capture positions are correct
|
|
assert!(value_capture.start() > 0);
|
|
assert!(value_capture.end() > value_capture.start());
|
|
} else {
|
|
panic!("Regex should match the test content");
|
|
}
|
|
|
|
// Test with settings that include other providers to ensure we don't match them
|
|
let test_settings_with_openai = r#"{
|
|
"language_models": {
|
|
"openai": {
|
|
"api_url": "https://api.openai.com/v1",
|
|
"available_models": []
|
|
},
|
|
"ollama": {
|
|
"api_url": "http://localhost:11434",
|
|
"available_models": []
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
// Ensure our regex only matches Ollama's API URL, not OpenAI's
|
|
if let Some(captures) = regex.captures(test_settings_with_openai) {
|
|
let value_capture = captures.get(1).unwrap();
|
|
assert_eq!(value_capture.as_str(), "http://localhost:11434");
|
|
// Verify it's not matching OpenAI's URL
|
|
assert_ne!(value_capture.as_str(), "https://api.openai.com/v1");
|
|
} else {
|
|
panic!("Regex should match Ollama's API URL even when other providers are present");
|
|
}
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_settings_navigation_with_other_providers(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test scenario: User has OpenAI configured but no Ollama settings
|
|
// The regex should not match OpenAI's api_url
|
|
let settings_with_openai_only = r#"{
|
|
"language_models": {
|
|
"openai": {
|
|
"api_url": "https://api.openai.com/v1",
|
|
"available_models": []
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
let api_url_pattern = r#""language_models"\s*:\s*\{[\s\S]*?"ollama"\s*:\s*\{[\s\S]*?"api_url"\s*:\s*"([^"]*)"#;
|
|
let regex = regex::Regex::new(api_url_pattern).unwrap();
|
|
|
|
// Should not match OpenAI's API URL
|
|
assert!(regex.captures(settings_with_openai_only).is_none());
|
|
|
|
// Test when both providers exist
|
|
let settings_with_both = r#"{
|
|
"language_models": {
|
|
"openai": {
|
|
"api_url": "https://api.openai.com/v1",
|
|
"available_models": []
|
|
},
|
|
"ollama": {
|
|
"api_url": "http://localhost:11434",
|
|
"available_models": []
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
// Should match only Ollama's API URL
|
|
if let Some(captures) = regex.captures(settings_with_both) {
|
|
let value_capture = captures.get(1).unwrap();
|
|
assert_eq!(value_capture.as_str(), "http://localhost:11434");
|
|
} else {
|
|
panic!("Should match Ollama's API URL when it exists");
|
|
}
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_configure_api_url_menu_visibility(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test that ollama_settings_exist returns false when no settings file exists
|
|
// or when ollama section doesn't exist
|
|
assert!(!InlineCompletionButton::ollama_settings_exist_in_content(
|
|
""
|
|
));
|
|
|
|
// Test with a settings file that has no ollama section
|
|
let settings_without_ollama = r#"{
|
|
"language_models": {
|
|
"openai": {
|
|
"api_url": "https://api.openai.com/v1"
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
// Test that the function correctly identifies when ollama section is missing
|
|
assert!(!InlineCompletionButton::ollama_settings_exist_in_content(
|
|
settings_without_ollama
|
|
));
|
|
|
|
// Test with a settings file that has ollama section
|
|
let settings_with_ollama = r#"{
|
|
"language_models": {
|
|
"openai": {
|
|
"api_url": "https://api.openai.com/v1"
|
|
},
|
|
"ollama": {
|
|
"api_url": "http://localhost:11434"
|
|
}
|
|
}
|
|
}"#;
|
|
|
|
assert!(InlineCompletionButton::ollama_settings_exist_in_content(
|
|
settings_with_ollama
|
|
));
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_no_models_configured(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test menu behavior when no models are configured
|
|
let settings = AllLanguageModelSettings::get_global(cx);
|
|
let ollama_settings = &settings.ollama;
|
|
|
|
// Verify that available_models is empty by default
|
|
assert!(ollama_settings.available_models.is_empty());
|
|
|
|
// This simulates the condition that would trigger the "Configure Models" menu
|
|
let should_show_configure = ollama_settings.available_models.is_empty();
|
|
assert!(should_show_configure);
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_eager_subtle_options_visibility(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
AllLanguageSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test that eager/subtle options are available for Ollama provider
|
|
|
|
// Verify that when provider is Ollama, the eager/subtle logic should be triggered
|
|
// This tests the condition: matches!(provider, EditPredictionProvider::Zed | EditPredictionProvider::Ollama)
|
|
assert!(matches!(
|
|
EditPredictionProvider::Ollama,
|
|
EditPredictionProvider::Zed | EditPredictionProvider::Ollama
|
|
));
|
|
|
|
// Verify that when provider is NOT Zed or Ollama, the eager/subtle logic should NOT be triggered
|
|
assert!(!matches!(
|
|
EditPredictionProvider::Copilot,
|
|
EditPredictionProvider::Zed | EditPredictionProvider::Ollama
|
|
));
|
|
|
|
assert!(!matches!(
|
|
EditPredictionProvider::Supermaven,
|
|
EditPredictionProvider::Zed | EditPredictionProvider::Ollama
|
|
));
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_edit_predictions_mode_setting(cx: &mut TestAppContext) {
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
AllLanguageSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test that edit predictions mode setting is read correctly
|
|
let settings = AllLanguageSettings::get_global(cx);
|
|
|
|
// Default mode should be Eager
|
|
assert_eq!(settings.edit_predictions_mode(), EditPredictionsMode::Eager);
|
|
|
|
// Test that the setting affects the preview_requires_modifier flag
|
|
let preview_requires_modifier_eager =
|
|
settings.edit_predictions_mode() == EditPredictionsMode::Subtle;
|
|
assert!(!preview_requires_modifier_eager);
|
|
|
|
// Simulate changing to subtle mode by checking the condition
|
|
let subtle_mode_check = EditPredictionsMode::Subtle == EditPredictionsMode::Subtle;
|
|
assert!(subtle_mode_check);
|
|
});
|
|
}
|
|
|
|
#[gpui::test]
|
|
async fn test_ollama_model_switching_logic(cx: &mut TestAppContext) {
|
|
let _fs: Arc<dyn Fs> = FakeFs::new(cx.executor());
|
|
|
|
cx.update(|cx| {
|
|
let store = SettingsStore::test(cx);
|
|
cx.set_global(store);
|
|
AllLanguageModelSettings::register(cx);
|
|
language_model::LanguageModelRegistry::test(cx);
|
|
|
|
// Test the model switching function logic
|
|
// This tests the internal logic without actually modifying settings
|
|
let test_models = [
|
|
language_models::provider::ollama::AvailableModel {
|
|
name: "llama3.2:3b".to_string(),
|
|
display_name: Some("Llama 3.2 3B".to_string()),
|
|
max_tokens: 4096,
|
|
keep_alive: None,
|
|
supports_tools: Some(false),
|
|
supports_images: Some(false),
|
|
supports_thinking: Some(false),
|
|
},
|
|
language_models::provider::ollama::AvailableModel {
|
|
name: "codellama:7b".to_string(),
|
|
display_name: Some("CodeLlama 7B".to_string()),
|
|
max_tokens: 8192,
|
|
keep_alive: None,
|
|
supports_tools: Some(true),
|
|
supports_images: Some(false),
|
|
supports_thinking: Some(false),
|
|
},
|
|
];
|
|
|
|
// Verify we can access the model data
|
|
assert_eq!(test_models.len(), 2);
|
|
assert_eq!(test_models[0].name, "llama3.2:3b");
|
|
assert_eq!(test_models[1].name, "codellama:7b");
|
|
|
|
// Test model display name logic
|
|
let first_model_display = test_models[0]
|
|
.display_name
|
|
.as_ref()
|
|
.unwrap_or(&test_models[0].name);
|
|
assert_eq!(first_model_display, "Llama 3.2 3B");
|
|
|
|
// Verify the switch_ollama_model function exists and can be called
|
|
// (We don't actually call it to avoid file system operations in tests)
|
|
});
|
|
}
|
|
}
|