WIP

Cargo.lock

@@ -1779,6 +1779,32 @@ dependencies = [
  "util",
 ]
 
+[[package]]
+name = "copilot2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-compression",
+ "async-tar",
+ "clock",
+ "collections",
+ "context_menu",
+ "fs",
+ "futures 0.3.28",
+ "gpui2",
+ "language2",
+ "log",
+ "lsp2",
+ "node_runtime",
+ "rpc",
+ "serde",
+ "serde_derive",
+ "settings2",
+ "smol",
+ "theme",
+ "util",
+]
+
 [[package]]
 name = "copilot_button"
 version = "0.1.0"
@@ -10606,6 +10632,7 @@ dependencies = [
  "cli",
  "client2",
  "collections",
+ "copilot2",
  "ctor",
  "db2",
  "env_logger 0.9.3",
@@ -10620,6 +10647,7 @@ dependencies = [
  "indexmap 1.9.3",
  "install_cli",
  "isahc",
+ "language2",
  "language_tools",
  "lazy_static",
  "libc",

Cargo.toml

@@ -19,6 +19,7 @@ members = [
     "crates/component_test",
     "crates/context_menu",
     "crates/copilot",
+    "crates/copilot2",
     "crates/copilot_button",
     "crates/db",
     "crates/db2",

crates/copilot2/Cargo.toml

@@ -0,0 +1,49 @@
+[package]
+name = "copilot2"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+path = "src/copilot2.rs"
+doctest = false
+
+[features]
+test-support = [
+    "collections/test-support",
+    "gpui2/test-support",
+    "language2/test-support",
+    "lsp2/test-support",
+    "settings2/test-support",
+    "util/test-support",
+]
+
+[dependencies]
+collections = { path = "../collections" }
+context_menu = { path = "../context_menu" }
+gpui2 = { path = "../gpui2" }
+language2 = { path = "../language2" }
+settings2 = { path = "../settings2" }
+theme = { path = "../theme" }
+lsp2 = { path = "../lsp2" }
+node_runtime = { path = "../node_runtime"}
+util = { path = "../util" }
+async-compression = { version = "0.3", features = ["gzip", "futures-bufread"] }
+async-tar = "0.4.2"
+anyhow.workspace = true
+log.workspace = true
+serde.workspace = true
+serde_derive.workspace = true
+smol.workspace = true
+futures.workspace = true
+
+[dev-dependencies]
+clock = { path = "../clock" }
+collections = { path = "../collections", features = ["test-support"] }
+fs = { path = "../fs", features = ["test-support"] }
+gpui2 = { path = "../gpui2", features = ["test-support"] }
+language2 = { path = "../language2", features = ["test-support"] }
+lsp2 = { path = "../lsp2", features = ["test-support"] }
+rpc = { path = "../rpc", features = ["test-support"] }
+settings2 = { path = "../settings2", features = ["test-support"] }
+util = { path = "../util", features = ["test-support"] }

crates/copilot2/src/request.rs

@@ -0,0 +1,225 @@
+use serde::{Deserialize, Serialize};
+
+pub enum CheckStatus {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CheckStatusParams {
+    pub local_checks_only: bool,
+}
+
+impl lsp2::request::Request for CheckStatus {
+    type Params = CheckStatusParams;
+    type Result = SignInStatus;
+    const METHOD: &'static str = "checkStatus";
+}
+
+pub enum SignInInitiate {}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SignInInitiateParams {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "status")]
+pub enum SignInInitiateResult {
+    AlreadySignedIn { user: String },
+    PromptUserDeviceFlow(PromptUserDeviceFlow),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PromptUserDeviceFlow {
+    pub user_code: String,
+    pub verification_uri: String,
+}
+
+impl lsp2::request::Request for SignInInitiate {
+    type Params = SignInInitiateParams;
+    type Result = SignInInitiateResult;
+    const METHOD: &'static str = "signInInitiate";
+}
+
+pub enum SignInConfirm {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SignInConfirmParams {
+    pub user_code: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "status")]
+pub enum SignInStatus {
+    #[serde(rename = "OK")]
+    Ok {
+        user: String,
+    },
+    MaybeOk {
+        user: String,
+    },
+    AlreadySignedIn {
+        user: String,
+    },
+    NotAuthorized {
+        user: String,
+    },
+    NotSignedIn,
+}
+
+impl lsp2::request::Request for SignInConfirm {
+    type Params = SignInConfirmParams;
+    type Result = SignInStatus;
+    const METHOD: &'static str = "signInConfirm";
+}
+
+pub enum SignOut {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SignOutParams {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SignOutResult {}
+
+impl lsp2::request::Request for SignOut {
+    type Params = SignOutParams;
+    type Result = SignOutResult;
+    const METHOD: &'static str = "signOut";
+}
+
+pub enum GetCompletions {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetCompletionsParams {
+    pub doc: GetCompletionsDocument,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetCompletionsDocument {
+    pub tab_size: u32,
+    pub indent_size: u32,
+    pub insert_spaces: bool,
+    pub uri: lsp2::Url,
+    pub relative_path: String,
+    pub position: lsp2::Position,
+    pub version: usize,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetCompletionsResult {
+    pub completions: Vec<Completion>,
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Completion {
+    pub text: String,
+    pub position: lsp2::Position,
+    pub uuid: String,
+    pub range: lsp2::Range,
+    pub display_text: String,
+}
+
+impl lsp2::request::Request for GetCompletions {
+    type Params = GetCompletionsParams;
+    type Result = GetCompletionsResult;
+    const METHOD: &'static str = "getCompletions";
+}
+
+pub enum GetCompletionsCycling {}
+
+impl lsp2::request::Request for GetCompletionsCycling {
+    type Params = GetCompletionsParams;
+    type Result = GetCompletionsResult;
+    const METHOD: &'static str = "getCompletionsCycling";
+}
+
+pub enum LogMessage {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LogMessageParams {
+    pub level: u8,
+    pub message: String,
+    pub metadata_str: String,
+    pub extra: Vec<String>,
+}
+
+impl lsp2::notification::Notification for LogMessage {
+    type Params = LogMessageParams;
+    const METHOD: &'static str = "LogMessage";
+}
+
+pub enum StatusNotification {}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct StatusNotificationParams {
+    pub message: String,
+    pub status: String, // One of Normal/InProgress
+}
+
+impl lsp2::notification::Notification for StatusNotification {
+    type Params = StatusNotificationParams;
+    const METHOD: &'static str = "statusNotification";
+}
+
+pub enum SetEditorInfo {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SetEditorInfoParams {
+    pub editor_info: EditorInfo,
+    pub editor_plugin_info: EditorPluginInfo,
+}
+
+impl lsp2::request::Request for SetEditorInfo {
+    type Params = SetEditorInfoParams;
+    type Result = String;
+    const METHOD: &'static str = "setEditorInfo";
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorInfo {
+    pub name: String,
+    pub version: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditorPluginInfo {
+    pub name: String,
+    pub version: String,
+}
+
+pub enum NotifyAccepted {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NotifyAcceptedParams {
+    pub uuid: String,
+}
+
+impl lsp2::request::Request for NotifyAccepted {
+    type Params = NotifyAcceptedParams;
+    type Result = String;
+    const METHOD: &'static str = "notifyAccepted";
+}
+
+pub enum NotifyRejected {}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NotifyRejectedParams {
+    pub uuids: Vec<String>,
+}
+
+impl lsp2::request::Request for NotifyRejected {
+    type Params = NotifyRejectedParams;
+    type Result = String;
+    const METHOD: &'static str = "notifyRejected";
+}

crates/copilot2/src/sign_in.rs

@@ -0,0 +1,376 @@
+// TODO add logging in
+// use crate::{request::PromptUserDeviceFlow, Copilot, Status};
+// use gpui::{
+//     elements::*,
+//     geometry::rect::RectF,
+//     platform::{WindowBounds, WindowKind, WindowOptions},
+//     AnyElement, AnyViewHandle, AppContext, ClipboardItem, Element, Entity, View, ViewContext,
+//     WindowHandle,
+// };
+// use theme::ui::modal;
+
+// #[derive(PartialEq, Eq, Debug, Clone)]
+// struct CopyUserCode;
+
+// #[derive(PartialEq, Eq, Debug, Clone)]
+// struct OpenGithub;
+
+// const COPILOT_SIGN_UP_URL: &'static str = "https://github.com/features/copilot";
+
+// pub fn init(cx: &mut AppContext) {
+//     if let Some(copilot) = Copilot::global(cx) {
+//         let mut verification_window: Option<WindowHandle<CopilotCodeVerification>> = None;
+//         cx.observe(&copilot, move |copilot, cx| {
+//             let status = copilot.read(cx).status();
+
+//             match &status {
+//                 crate::Status::SigningIn { prompt } => {
+//                     if let Some(window) = verification_window.as_mut() {
+//                         let updated = window
+//                             .root(cx)
+//                             .map(|root| {
+//                                 root.update(cx, |verification, cx| {
+//                                     verification.set_status(status.clone(), cx);
+//                                     cx.activate_window();
+//                                 })
+//                             })
+//                             .is_some();
+//                         if !updated {
+//                             verification_window = Some(create_copilot_auth_window(cx, &status));
+//                         }
+//                     } else if let Some(_prompt) = prompt {
+//                         verification_window = Some(create_copilot_auth_window(cx, &status));
+//                     }
+//                 }
+//                 Status::Authorized | Status::Unauthorized => {
+//                     if let Some(window) = verification_window.as_ref() {
+//                         if let Some(verification) = window.root(cx) {
+//                             verification.update(cx, |verification, cx| {
+//                                 verification.set_status(status, cx);
+//                                 cx.platform().activate(true);
+//                                 cx.activate_window();
+//                             });
+//                         }
+//                     }
+//                 }
+//                 _ => {
+//                     if let Some(code_verification) = verification_window.take() {
+//                         code_verification.update(cx, |cx| cx.remove_window());
+//                     }
+//                 }
+//             }
+//         })
+//         .detach();
+//     }
+// }
+
+// fn create_copilot_auth_window(
+//     cx: &mut AppContext,
+//     status: &Status,
+// ) -> WindowHandle<CopilotCodeVerification> {
+//     let window_size = theme::current(cx).copilot.modal.dimensions();
+//     let window_options = WindowOptions {
+//         bounds: WindowBounds::Fixed(RectF::new(Default::default(), window_size)),
+//         titlebar: None,
+//         center: true,
+//         focus: true,
+//         show: true,
+//         kind: WindowKind::Normal,
+//         is_movable: true,
+//         screen: None,
+//     };
+//     cx.add_window(window_options, |_cx| {
+//         CopilotCodeVerification::new(status.clone())
+//     })
+// }
+
+// pub struct CopilotCodeVerification {
+//     status: Status,
+//     connect_clicked: bool,
+// }
+
+// impl CopilotCodeVerification {
+//     pub fn new(status: Status) -> Self {
+//         Self {
+//             status,
+//             connect_clicked: false,
+//         }
+//     }
+
+//     pub fn set_status(&mut self, status: Status, cx: &mut ViewContext<Self>) {
+//         self.status = status;
+//         cx.notify();
+//     }
+
+//     fn render_device_code(
+//         data: &PromptUserDeviceFlow,
+//         style: &theme::Copilot,
+//         cx: &mut ViewContext<Self>,
+//     ) -> impl Element<Self> {
+//         let copied = cx
+//             .read_from_clipboard()
+//             .map(|item| item.text() == &data.user_code)
+//             .unwrap_or(false);
+
+//         let device_code_style = &style.auth.prompting.device_code;
+
+//         MouseEventHandler::new::<Self, _>(0, cx, |state, _cx| {
+//             Flex::row()
+//                 .with_child(
+//                     Label::new(data.user_code.clone(), device_code_style.text.clone())
+//                         .aligned()
+//                         .contained()
+//                         .with_style(device_code_style.left_container)
+//                         .constrained()
+//                         .with_width(device_code_style.left),
+//                 )
+//                 .with_child(
+//                     Label::new(
+//                         if copied { "Copied!" } else { "Copy" },
+//                         device_code_style.cta.style_for(state).text.clone(),
+//                     )
+//                     .aligned()
+//                     .contained()
+//                     .with_style(*device_code_style.right_container.style_for(state))
+//                     .constrained()
+//                     .with_width(device_code_style.right),
+//                 )
+//                 .contained()
+//                 .with_style(device_code_style.cta.style_for(state).container)
+//         })
+//         .on_click(gpui::platform::MouseButton::Left, {
+//             let user_code = data.user_code.clone();
+//             move |_, _, cx| {
+//                 cx.platform()
+//                     .write_to_clipboard(ClipboardItem::new(user_code.clone()));
+//                 cx.notify();
+//             }
+//         })
+//         .with_cursor_style(gpui::platform::CursorStyle::PointingHand)
+//     }
+
+//     fn render_prompting_modal(
+//         connect_clicked: bool,
+//         data: &PromptUserDeviceFlow,
+//         style: &theme::Copilot,
+//         cx: &mut ViewContext<Self>,
+//     ) -> AnyElement<Self> {
+//         enum ConnectButton {}
+
+//         Flex::column()
+//             .with_child(
+//                 Flex::column()
+//                     .with_children([
+//                         Label::new(
+//                             "Enable Copilot by connecting",
+//                             style.auth.prompting.subheading.text.clone(),
+//                         )
+//                         .aligned(),
+//                         Label::new(
+//                             "your existing license.",
+//                             style.auth.prompting.subheading.text.clone(),
+//                         )
+//                         .aligned(),
+//                     ])
+//                     .align_children_center()
+//                     .contained()
+//                     .with_style(style.auth.prompting.subheading.container),
+//             )
+//             .with_child(Self::render_device_code(data, &style, cx))
+//             .with_child(
+//                 Flex::column()
+//                     .with_children([
+//                         Label::new(
+//                             "Paste this code into GitHub after",
+//                             style.auth.prompting.hint.text.clone(),
+//                         )
+//                         .aligned(),
+//                         Label::new(
+//                             "clicking the button below.",
+//                             style.auth.prompting.hint.text.clone(),
+//                         )
+//                         .aligned(),
+//                     ])
+//                     .align_children_center()
+//                     .contained()
+//                     .with_style(style.auth.prompting.hint.container.clone()),
+//             )
+//             .with_child(theme::ui::cta_button::<ConnectButton, _, _, _>(
+//                 if connect_clicked {
+//                     "Waiting for connection..."
+//                 } else {
+//                     "Connect to GitHub"
+//                 },
+//                 style.auth.content_width,
+//                 &style.auth.cta_button,
+//                 cx,
+//                 {
+//                     let verification_uri = data.verification_uri.clone();
+//                     move |_, verification, cx| {
+//                         cx.platform().open_url(&verification_uri);
+//                         verification.connect_clicked = true;
+//                     }
+//                 },
+//             ))
+//             .align_children_center()
+//             .into_any()
+//     }
+
+//     fn render_enabled_modal(
+//         style: &theme::Copilot,
+//         cx: &mut ViewContext<Self>,
+//     ) -> AnyElement<Self> {
+//         enum DoneButton {}
+
+//         let enabled_style = &style.auth.authorized;
+//         Flex::column()
+//             .with_child(
+//                 Label::new("Copilot Enabled!", enabled_style.subheading.text.clone())
+//                     .contained()
+//                     .with_style(enabled_style.subheading.container)
+//                     .aligned(),
+//             )
+//             .with_child(
+//                 Flex::column()
+//                     .with_children([
+//                         Label::new(
+//                             "You can update your settings or",
+//                             enabled_style.hint.text.clone(),
+//                         )
+//                         .aligned(),
+//                         Label::new(
+//                             "sign out from the Copilot menu in",
+//                             enabled_style.hint.text.clone(),
+//                         )
+//                         .aligned(),
+//                         Label::new("the status bar.", enabled_style.hint.text.clone()).aligned(),
+//                     ])
+//                     .align_children_center()
+//                     .contained()
+//                     .with_style(enabled_style.hint.container),
+//             )
+//             .with_child(theme::ui::cta_button::<DoneButton, _, _, _>(
+//                 "Done",
+//                 style.auth.content_width,
+//                 &style.auth.cta_button,
+//                 cx,
+//                 |_, _, cx| cx.remove_window(),
+//             ))
+//             .align_children_center()
+//             .into_any()
+//     }
+
+//     fn render_unauthorized_modal(
+//         style: &theme::Copilot,
+//         cx: &mut ViewContext<Self>,
+//     ) -> AnyElement<Self> {
+//         let unauthorized_style = &style.auth.not_authorized;
+
+//         Flex::column()
+//             .with_child(
+//                 Flex::column()
+//                     .with_children([
+//                         Label::new(
+//                             "Enable Copilot by connecting",
+//                             unauthorized_style.subheading.text.clone(),
+//                         )
+//                         .aligned(),
+//                         Label::new(
+//                             "your existing license.",
+//                             unauthorized_style.subheading.text.clone(),
+//                         )
+//                         .aligned(),
+//                     ])
+//                     .align_children_center()
+//                     .contained()
+//                     .with_style(unauthorized_style.subheading.container),
+//             )
+//             .with_child(
+//                 Flex::column()
+//                     .with_children([
+//                         Label::new(
+//                             "You must have an active copilot",
+//                             unauthorized_style.warning.text.clone(),
+//                         )
+//                         .aligned(),
+//                         Label::new(
+//                             "license to use it in Zed.",
+//                             unauthorized_style.warning.text.clone(),
+//                         )
+//                         .aligned(),
+//                     ])
+//                     .align_children_center()
+//                     .contained()
+//                     .with_style(unauthorized_style.warning.container),
+//             )
+//             .with_child(theme::ui::cta_button::<Self, _, _, _>(
+//                 "Subscribe on GitHub",
+//                 style.auth.content_width,
+//                 &style.auth.cta_button,
+//                 cx,
+//                 |_, _, cx| {
+//                     cx.remove_window();
+//                     cx.platform().open_url(COPILOT_SIGN_UP_URL)
+//                 },
+//             ))
+//             .align_children_center()
+//             .into_any()
+//     }
+// }
+
+// impl Entity for CopilotCodeVerification {
+//     type Event = ();
+// }
+
+// impl View for CopilotCodeVerification {
+//     fn ui_name() -> &'static str {
+//         "CopilotCodeVerification"
+//     }
+
+//     fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+//         cx.notify()
+//     }
+
+//     fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+//         cx.notify()
+//     }
+
+//     fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+//         enum ConnectModal {}
+
+//         let style = theme::current(cx).clone();
+
+//         modal::<ConnectModal, _, _, _, _>(
+//             "Connect Copilot to Zed",
+//             &style.copilot.modal,
+//             cx,
+//             |cx| {
+//                 Flex::column()
+//                     .with_children([
+//                         theme::ui::icon(&style.copilot.auth.header).into_any(),
+//                         match &self.status {
+//                             Status::SigningIn {
+//                                 prompt: Some(prompt),
+//                             } => Self::render_prompting_modal(
+//                                 self.connect_clicked,
+//                                 &prompt,
+//                                 &style.copilot,
+//                                 cx,
+//                             ),
+//                             Status::Unauthorized => {
+//                                 self.connect_clicked = false;
+//                                 Self::render_unauthorized_modal(&style.copilot, cx)
+//                             }
+//                             Status::Authorized => {
+//                                 self.connect_clicked = false;
+//                                 Self::render_enabled_modal(&style.copilot, cx)
+//                             }
+//                             _ => Empty::new().into_any(),
+//                         },
+//                     ])
+//                     .align_children_center()
+//             },
+//         )
+//         .into_any()
+//     }
+// }

crates/gpui2/src/app/model_context.rs

@@ -87,7 +87,7 @@ impl<'a, T: Send + Sync + 'static> ModelContext<'a, T> {
 
     pub fn on_app_quit<Fut>(
         &mut self,
-        on_quit: impl Fn(&mut T, &mut AppContext) -> Fut + Send + Sync + 'static,
+        on_quit: impl Fn(&mut T, &mut ModelContext<T>) -> Fut + Send + Sync + 'static,
     ) -> Subscription
     where
         Fut: 'static + Future<Output = ()> + Send,

crates/project2/src/project2.rs

@@ -26,8 +26,7 @@ use futures::{
 };
 use globset::{Glob, GlobSet, GlobSetBuilder};
 use gpui2::{
-    AnyHandle, AppContext, AsyncAppContext, EventEmitter, Executor, Handle, ModelContext, Task,
+    AnyHandle, AppContext, AsyncAppContext, EventEmitter, Handle, ModelContext, Task, WeakHandle,
-    WeakHandle,
 };
 use itertools::Itertools;
 use language2::{
@@ -821,7 +820,10 @@ impl Project {
         }
     }
 
-    fn shutdown_language_servers(&mut self) -> impl Future<Output = ()> {
+    fn shutdown_language_servers(
+        &mut self,
+        cx: &mut ModelContext<Self>,
+    ) -> impl Future<Output = ()> {
         let shutdown_futures = self
             .language_servers
             .drain()
@@ -5683,7 +5685,7 @@ impl Project {
     async fn background_search(
         unnamed_buffers: Vec<Handle<Buffer>>,
         opened_buffers: HashMap<Arc<Path>, (Handle<Buffer>, BufferSnapshot)>,
-        executor: Executor,
+        executor: Arc<Background>,
         fs: Arc<dyn Fs>,
         workers: usize,
         query: SearchQuery,

crates/project2/src/terminals.rs

@@ -116,7 +116,7 @@ impl Project {
         }
     }
 
-    pub fn local_terminal_handles(&self) -> &Vec<WeakModelHandle<terminal::Terminal>> {
+    pub fn local_terminal_handles(&self) -> &Vec<WeakHandle<terminal::Terminal>> {
         &self.terminals.local_handles
     }
 }

crates/zed2/Cargo.toml

@@ -29,7 +29,7 @@ collections = { path = "../collections" }
 # context_menu = { path = "../context_menu" }
 client2 = { path = "../client2" }
 # clock = { path = "../clock" }
-# copilot = { path = "../copilot" }
+copilot2 = { path = "../copilot2" }
 # copilot_button = { path = "../copilot_button" }
 # diagnostics = { path = "../diagnostics" }
 db2 = { path = "../db2" }
@@ -44,7 +44,7 @@ fuzzy = { path = "../fuzzy" }
 gpui2 = { path = "../gpui2" }
 install_cli = { path = "../install_cli" }
 # journal = { path = "../journal" }
-# language = { path = "../language" }
+language2 = { path = "../language2" }
 # language_selector = { path = "../language_selector" }
 lsp = { path = "../lsp" }
 language_tools = { path = "../language_tools" }

crates/zed2/src/main.rs

@@ -109,8 +109,8 @@ fn main() {
         // handle_keymap_file_changes(user_keymap_file_rx, cx);
 
         // let client = client2::Client::new(http.clone(), cx);
-        // let mut languages = LanguageRegistry::new(login_shell_env_loaded);
+        let mut languages = LanguageRegistry::new(login_shell_env_loaded);
-        // let copilot_language_server_id = languages.next_language_server_id();
+        let copilot_language_server_id = languages.next_language_server_id();
         // languages.set_executor(cx.background().clone());
         // languages.set_language_server_download_dir(paths::LANGUAGES_DIR.clone());
         // let languages = Arc::new(languages);
@@ -140,12 +140,12 @@ fn main() {
         // semantic_index::init(fs.clone(), http.clone(), languages.clone(), cx);
         // vim::init(cx);
         // terminal_view::init(cx);
-        // copilot::init(
+        copilot2::init(
-        //     copilot_language_server_id,
+            copilot_language_server_id,
-        //     http.clone(),
+            http.clone(),
-        //     node_runtime.clone(),
+            node_runtime.clone(),
-        //     cx,
+            cx,
-        // );
+        );
         // assistant::init(cx);
         // component_test::init(cx);