Supermaven (#10788)

Adds a supermaven provider for completions. There are various other
refactors amidst this branch, primarily to make copilot no longer a
dependency of project as well as show LSP Logs for global LSPs like
copilot properly.

This feature is not enabled by default. We're going to seek to refine it
in the coming weeks.

Release Notes:

- N/A

---------

Co-authored-by: Antonio Scandurra <me@as-cii.com>
Co-authored-by: Nathan Sobo <nathan@zed.dev>
Co-authored-by: Max <max@zed.dev>
Co-authored-by: Max Brunsfeld <maxbrunsfeld@gmail.com>

crates/copilot/Cargo.toml

@@ -27,28 +27,38 @@ anyhow.workspace = true
 async-compression.workspace = true
 async-tar.workspace = true
 collections.workspace = true
+client.workspace = true
 command_palette_hooks.workspace = true
+editor.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 lsp.workspace = true
+menu.workspace = true
 node_runtime.workspace = true
 parking_lot.workspace = true
+project.workspace = true
 serde.workspace = true
 settings.workspace = true
 smol.workspace = true
+ui.workspace = true
 util.workspace = true
+workspace.workspace = true
 
 [target.'cfg(windows)'.dependencies]
 async-std = { version = "1.12.0", features = ["unstable"] }
 
 [dev-dependencies]
 clock.workspace = true
+indoc.workspace = true
+serde_json.workspace = true
 collections = { workspace = true, features = ["test-support"] }
 fs = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, features = ["test-support"] }
 language = { workspace = true, features = ["test-support"] }
 lsp = { workspace = true, features = ["test-support"] }
+project = { workspace = true, features = ["test-support"] }
 rpc = { workspace = true, features = ["test-support"] }
 settings = { workspace = true, features = ["test-support"] }
+theme = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }

crates/copilot/src/copilot.rs

@@ -1,4 +1,7 @@
+mod copilot_completion_provider;
 pub mod request;
+mod sign_in;
+
 use anyhow::{anyhow, Context as _, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
@@ -10,9 +13,9 @@ use gpui::{
     ModelContext, Task, WeakModel,
 };
 use language::{
-    language_settings::{all_language_settings, language_settings},
-    point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language,
-    LanguageServerName, PointUtf16, ToPointUtf16,
+    language_settings::{all_language_settings, language_settings, InlineCompletionProvider},
+    point_from_lsp, point_to_lsp, Anchor, Bias, Buffer, BufferSnapshot, Language, PointUtf16,
+    ToPointUtf16,
 };
 use lsp::{LanguageServer, LanguageServerBinary, LanguageServerId};
 use node_runtime::NodeRuntime;
@@ -32,6 +35,9 @@ use util::{
     fs::remove_matching, github::latest_github_release, http::HttpClient, maybe, paths, ResultExt,
 };
 
+pub use copilot_completion_provider::CopilotCompletionProvider;
+pub use sign_in::CopilotCodeVerification;
+
 actions!(
     copilot,
     [
@@ -144,7 +150,6 @@ impl CopilotServer {
 }
 
 struct RunningCopilotServer {
-    name: LanguageServerName,
     lsp: Arc<LanguageServer>,
     sign_in_status: SignInStatus,
     registered_buffers: HashMap<EntityId, RegisteredBuffer>,
@@ -354,7 +359,9 @@ impl Copilot {
         let server_id = self.server_id;
         let http = self.http.clone();
         let node_runtime = self.node_runtime.clone();
-        if all_language_settings(None, cx).copilot_enabled(None, None) {
+        if all_language_settings(None, cx).inline_completions.provider
+            == InlineCompletionProvider::Copilot
+        {
             if matches!(self.server, CopilotServer::Disabled) {
                 let start_task = cx
                     .spawn(move |this, cx| {
@@ -393,7 +400,6 @@ impl Copilot {
             http: http.clone(),
             node_runtime,
             server: CopilotServer::Running(RunningCopilotServer {
-                name: LanguageServerName(Arc::from("copilot")),
                 lsp: Arc::new(server),
                 sign_in_status: SignInStatus::Authorized,
                 registered_buffers: Default::default(),
@@ -467,7 +473,6 @@ impl Copilot {
                 match server {
                     Ok((server, status)) => {
                         this.server = CopilotServer::Running(RunningCopilotServer {
-                            name: LanguageServerName(Arc::from("copilot")),
                             lsp: server,
                             sign_in_status: SignInStatus::SignedOut,
                             registered_buffers: Default::default(),
@@ -607,9 +612,9 @@ impl Copilot {
         cx.background_executor().spawn(start_task)
     }
 
-    pub fn language_server(&self) -> Option<(&LanguageServerName, &Arc<LanguageServer>)> {
+    pub fn language_server(&self) -> Option<&Arc<LanguageServer>> {
         if let CopilotServer::Running(server) = &self.server {
-            Some((&server.name, &server.lsp))
+            Some(&server.lsp)
         } else {
             None
         }

crates/copilot/src/sign_in.rs

@@ -0,0 +1,210 @@
+use crate::{request::PromptUserDeviceFlow, Copilot, Status};
+use gpui::{
+    div, svg, AppContext, ClipboardItem, DismissEvent, Element, EventEmitter, FocusHandle,
+    FocusableView, InteractiveElement, IntoElement, Model, MouseDownEvent, ParentElement, Render,
+    Styled, Subscription, ViewContext,
+};
+use ui::{prelude::*, Button, IconName, Label};
+use workspace::ModalView;
+
+const COPILOT_SIGN_UP_URL: &str = "https://github.com/features/copilot";
+
+pub struct CopilotCodeVerification {
+    status: Status,
+    connect_clicked: bool,
+    focus_handle: FocusHandle,
+    _subscription: Subscription,
+}
+
+impl FocusableView for CopilotCodeVerification {
+    fn focus_handle(&self, _: &AppContext) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl EventEmitter<DismissEvent> for CopilotCodeVerification {}
+impl ModalView for CopilotCodeVerification {}
+
+impl CopilotCodeVerification {
+    pub fn new(copilot: &Model<Copilot>, cx: &mut ViewContext<Self>) -> Self {
+        let status = copilot.read(cx).status();
+        Self {
+            status,
+            connect_clicked: false,
+            focus_handle: cx.focus_handle(),
+            _subscription: cx.observe(copilot, |this, copilot, cx| {
+                let status = copilot.read(cx).status();
+                match status {
+                    Status::Authorized | Status::Unauthorized | Status::SigningIn { .. } => {
+                        this.set_status(status, cx)
+                    }
+                    _ => cx.emit(DismissEvent),
+                }
+            }),
+        }
+    }
+
+    pub fn set_status(&mut self, status: Status, cx: &mut ViewContext<Self>) {
+        self.status = status;
+        cx.notify();
+    }
+
+    fn render_device_code(
+        data: &PromptUserDeviceFlow,
+        cx: &mut ViewContext<Self>,
+    ) -> impl IntoElement {
+        let copied = cx
+            .read_from_clipboard()
+            .map(|item| item.text() == &data.user_code)
+            .unwrap_or(false);
+        h_flex()
+            .w_full()
+            .p_1()
+            .border()
+            .border_muted(cx)
+            .rounded_md()
+            .cursor_pointer()
+            .justify_between()
+            .on_mouse_down(gpui::MouseButton::Left, {
+                let user_code = data.user_code.clone();
+                move |_, cx| {
+                    cx.write_to_clipboard(ClipboardItem::new(user_code.clone()));
+                    cx.refresh();
+                }
+            })
+            .child(div().flex_1().child(Label::new(data.user_code.clone())))
+            .child(div().flex_none().px_1().child(Label::new(if copied {
+                "Copied!"
+            } else {
+                "Copy"
+            })))
+    }
+
+    fn render_prompting_modal(
+        connect_clicked: bool,
+        data: &PromptUserDeviceFlow,
+        cx: &mut ViewContext<Self>,
+    ) -> impl Element {
+        let connect_button_label = if connect_clicked {
+            "Waiting for connection..."
+        } else {
+            "Connect to GitHub"
+        };
+        v_flex()
+            .flex_1()
+            .gap_2()
+            .items_center()
+            .child(Headline::new("Use GitHub Copilot in Zed.").size(HeadlineSize::Large))
+            .child(
+                Label::new("Using Copilot requires an active subscription on GitHub.")
+                    .color(Color::Muted),
+            )
+            .child(Self::render_device_code(data, cx))
+            .child(
+                Label::new("Paste this code into GitHub after clicking the button below.")
+                    .size(ui::LabelSize::Small),
+            )
+            .child(
+                Button::new("connect-button", connect_button_label)
+                    .on_click({
+                        let verification_uri = data.verification_uri.clone();
+                        cx.listener(move |this, _, cx| {
+                            cx.open_url(&verification_uri);
+                            this.connect_clicked = true;
+                        })
+                    })
+                    .full_width()
+                    .style(ButtonStyle::Filled),
+            )
+            .child(
+                Button::new("copilot-enable-cancel-button", "Cancel")
+                    .full_width()
+                    .on_click(cx.listener(|_, _, cx| cx.emit(DismissEvent))),
+            )
+    }
+    fn render_enabled_modal(cx: &mut ViewContext<Self>) -> impl Element {
+        v_flex()
+            .gap_2()
+            .child(Headline::new("Copilot Enabled!").size(HeadlineSize::Large))
+            .child(Label::new(
+                "You can update your settings or sign out from the Copilot menu in the status bar.",
+            ))
+            .child(
+                Button::new("copilot-enabled-done-button", "Done")
+                    .full_width()
+                    .on_click(cx.listener(|_, _, cx| cx.emit(DismissEvent))),
+            )
+    }
+
+    fn render_unauthorized_modal(cx: &mut ViewContext<Self>) -> impl Element {
+        v_flex()
+            .child(Headline::new("You must have an active GitHub Copilot subscription.").size(HeadlineSize::Large))
+
+            .child(Label::new(
+                "You can enable Copilot by connecting your existing license once you have subscribed or renewed your subscription.",
+            ).color(Color::Warning))
+            .child(
+                Button::new("copilot-subscribe-button", "Subscribe on GitHub")
+                    .full_width()
+                    .on_click(|_, cx| cx.open_url(COPILOT_SIGN_UP_URL)),
+            )
+            .child(
+                Button::new("copilot-subscribe-cancel-button", "Cancel")
+                    .full_width()
+                    .on_click(cx.listener(|_, _, cx| cx.emit(DismissEvent))),
+            )
+    }
+
+    fn render_disabled_modal() -> impl Element {
+        v_flex()
+            .child(Headline::new("Copilot is disabled").size(HeadlineSize::Large))
+            .child(Label::new("You can enable Copilot in your settings."))
+    }
+}
+
+impl Render for CopilotCodeVerification {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let prompt = match &self.status {
+            Status::SigningIn {
+                prompt: Some(prompt),
+            } => Self::render_prompting_modal(self.connect_clicked, &prompt, cx).into_any_element(),
+            Status::Unauthorized => {
+                self.connect_clicked = false;
+                Self::render_unauthorized_modal(cx).into_any_element()
+            }
+            Status::Authorized => {
+                self.connect_clicked = false;
+                Self::render_enabled_modal(cx).into_any_element()
+            }
+            Status::Disabled => {
+                self.connect_clicked = false;
+                Self::render_disabled_modal().into_any_element()
+            }
+            _ => div().into_any_element(),
+        };
+
+        v_flex()
+            .id("copilot code verification")
+            .track_focus(&self.focus_handle)
+            .elevation_3(cx)
+            .w_96()
+            .items_center()
+            .p_4()
+            .gap_2()
+            .on_action(cx.listener(|_, _: &menu::Cancel, cx| {
+                cx.emit(DismissEvent);
+            }))
+            .on_any_mouse_down(cx.listener(|this, _: &MouseDownEvent, cx| {
+                cx.focus(&this.focus_handle);
+            }))
+            .child(
+                svg()
+                    .w_32()
+                    .h_16()
+                    .flex_none()
+                    .path(IconName::ZedXCopilot.path())
+                    .text_color(cx.theme().colors().icon),
+            )
+            .child(prompt)
+    }
+}