use editor::Editor;use gpui::{    AnyElement, App, Entity, EventEmitter, FocusHandle, Focusable, Subscription, TaskExt, actions,    prelude::*,};use language::{Buffer, BufferEvent};use project::{Project, ProjectItem as _};use ui::{ButtonLike, ElevationIndex, KeyBinding, prelude::*};use util::ResultExt as _;use workspace::item::ItemEvent;use workspace::{Workspace, item::Item}; use crate::jupyter_settings::JupyterSettings;use crate::repl_store::ReplStore; fn refresh_python_kernelspecs_for_buffer(    buffer: &Entity<Buffer>,    project: &Entity<Project>,    cx: &mut App,) {    let buffer = buffer.read(cx);     if buffer        .language()        .is_none_or(|language| language.name() != "Python")    {        return;    };     let Some(project_path) = buffer.project_path(cx) else {        return;    };    let store = ReplStore::global(cx);    store.update(cx, |store, cx| {        store            .refresh_python_kernelspecs(project_path.worktree_id, project, cx)            .detach_and_log_err(cx);    });} actions!(    repl,    [        /// Runs the current cell and advances to the next one.        Run,        /// Runs the current cell without advancing.        RunInPlace,        /// Clears all outputs in the REPL.        ClearOutputs,        /// Clears the output of the cell at the current cursor position.        ClearCurrentOutput,        /// Opens the REPL sessions panel.        Sessions,        /// Interrupts the currently running kernel.        Interrupt,        /// Shuts down the current kernel.        Shutdown,        /// Restarts the current kernel.        Restart,        /// Refreshes the list of available kernelspecs.        RefreshKernelspecs    ]); pub fn init(cx: &mut App) {    cx.observe_new(        |workspace: &mut Workspace, _window, _cx: &mut Context<Workspace>| {            workspace.register_action(|workspace, _: &Sessions, window, cx| {                let existing = workspace                    .active_pane()                    .read(cx)                    .items()                    .find_map(|item| item.downcast::<ReplSessionsPage>());                 if let Some(existing) = existing {                    workspace.activate_item(&existing, true, true, window, cx);                } else {                    let repl_sessions_page = ReplSessionsPage::new(window, cx);                    workspace.add_item_to_active_pane(                        Box::new(repl_sessions_page),                        None,                        true,                        window,                        cx,                    )                }            });             workspace.register_action(|_workspace, _: &RefreshKernelspecs, _, cx| {                let store = ReplStore::global(cx);                store.update(cx, |store, cx| {                    store.refresh_kernelspecs(cx).detach();                });            });        },    )    .detach();     cx.observe_new(        move |editor: &mut Editor, window, cx: &mut Context<Editor>| {            let Some(window) = window else {                return;            };             if !editor.use_modal_editing() || !editor.buffer().read(cx).is_singleton() {                return;            }             cx.defer_in(window, |editor, _window, cx| {                let project = editor.project().cloned();                 let is_valid_project = project                    .as_ref()                    .map(|project| {                        let p = project.read(cx);                        !p.is_via_collab()                    })                    .unwrap_or(false);                 if !is_valid_project {                    return;                }                 let buffer = editor.buffer().read(cx).as_singleton();                 let editor_handle = cx.entity().downgrade();                 // Subscribe to the buffer's `LanguageChanged` events so remote projects,                // where language detection can complete after the editor is observed,                // still trigger a kernelspec refresh. Without this the REPL UI stays                // hidden until something else populates the global kernel list.                if let Some((buffer, project)) = buffer.zip(project) {                    refresh_python_kernelspecs_for_buffer(&buffer, &project, cx);                     cx.subscribe(&buffer, move |_editor, buffer, event, cx| {                        if let BufferEvent::LanguageChanged(_) = event {                            refresh_python_kernelspecs_for_buffer(&buffer, &project, cx);                        }                    })                    .detach();                }                 editor                    .register_action({                        let editor_handle = editor_handle.clone();                        move |_: &Run, window, cx| {                            if !JupyterSettings::enabled(cx) {                                return;                            }                             crate::run(editor_handle.clone(), true, window, cx).log_err();                        }                    })                    .detach();                 editor                    .register_action({                        move |_: &RunInPlace, window, cx| {                            if !JupyterSettings::enabled(cx) {                                return;                            }                             crate::run(editor_handle.clone(), false, window, cx).log_err();                        }                    })                    .detach();            });        },    )    .detach();} pub struct ReplSessionsPage {    focus_handle: FocusHandle,    _subscriptions: Vec<Subscription>,} impl ReplSessionsPage {    pub fn new(window: &mut Window, cx: &mut Context<Workspace>) -> Entity<Self> {        cx.new(|cx| {            let focus_handle = cx.focus_handle();             let subscriptions = vec![                cx.on_focus_in(&focus_handle, window, |_this, _window, cx| cx.notify()),                cx.on_focus_out(&focus_handle, window, |_this, _event, _window, cx| {                    cx.notify()                }),            ];             Self {                focus_handle,                _subscriptions: subscriptions,            }        })    }} impl EventEmitter<ItemEvent> for ReplSessionsPage {} impl Focusable for ReplSessionsPage {    fn focus_handle(&self, _cx: &App) -> FocusHandle {        self.focus_handle.clone()    }} impl Item for ReplSessionsPage {    type Event = ItemEvent;     fn tab_content_text(&self, _detail: usize, _cx: &App) -> SharedString {        "REPL Sessions".into()    }     fn telemetry_event_text(&self) -> Option<&'static str> {        Some("REPL Session Started")    }     fn show_toolbar(&self) -> bool {        false    }     fn to_item_events(event: &Self::Event, f: &mut dyn FnMut(workspace::item::ItemEvent)) {        f(*event)    }} impl Render for ReplSessionsPage {    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {        let store = ReplStore::global(cx);         let (kernel_specifications, sessions) = store.update(cx, |store, cx| {            store.ensure_kernelspecs(cx);            (                store                    .pure_jupyter_kernel_specifications()                    .cloned()                    .collect::<Vec<_>>(),                store.sessions().cloned().collect::<Vec<_>>(),            )        });         // When there are no kernel specifications, show a link to the Zed docs explaining how to        // install kernels. It can be assumed they don't have a running kernel if we have no        // specifications.        if kernel_specifications.is_empty() {            let instructions = "To start interactively running code in your editor, you need to install and configure Jupyter kernels.";             return ReplSessionsContainer::new("No Jupyter Kernels Available")                .child(Label::new(instructions))                .child(                    h_flex().w_full().p_4().justify_center().gap_2().child(                        ButtonLike::new("install-kernels")                            .style(ButtonStyle::Filled)                            .size(ButtonSize::Large)                            .layer(ElevationIndex::ModalSurface)                            .child(Label::new("Install Kernels"))                            .on_click(move |_, _, cx| {                                cx.open_url(                                    "https://zed.dev/docs/repl#language-specific-instructions",                                )                            }),                    ),                );        }         // When there are no sessions, show the command to run code in an editor        if sessions.is_empty() {            let instructions = "To run code in a Jupyter kernel, select some code and use the 'repl::Run' command.";             return ReplSessionsContainer::new("No Jupyter Kernel Sessions").child(                v_flex()                    .child(Label::new(instructions))                    .child(KeyBinding::for_action(&Run, cx)),            );        }         ReplSessionsContainer::new("Jupyter Kernel Sessions").children(sessions)    }} #[derive(IntoElement)]struct ReplSessionsContainer {    title: SharedString,    children: Vec<AnyElement>,} impl ReplSessionsContainer {    pub fn new(title: impl Into<SharedString>) -> Self {        Self {            title: title.into(),            children: Vec::new(),        }    }} impl ParentElement for ReplSessionsContainer {    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {        self.children.extend(elements)    }} impl RenderOnce for ReplSessionsContainer {    fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {        v_flex()            .p_4()            .gap_2()            .size_full()            .child(Label::new(self.title).size(LabelSize::Large))            .children(self.children)    }} #[cfg(test)]mod tests {    use super::*;     use std::{path::PathBuf, sync::Arc};     use async_trait::async_trait;    use collections::HashMap;    use editor::EditorMode;    use gpui::TestAppContext;    use language::{        Language, LanguageConfig, LanguageMatcher, LanguageName, ManifestName, Toolchain,        ToolchainList, ToolchainLister, ToolchainMetadata,    };    use multi_buffer::MultiBuffer;    use task::ShellKind;    use util::path;     struct TestPythonToolchainLister;     #[async_trait]    impl ToolchainLister for TestPythonToolchainLister {        async fn list(            &self,            _worktree_root: PathBuf,            _subroot_relative_path: Arc<util::rel_path::RelPath>,            _project_env: Option<HashMap<String, String>>,        ) -> ToolchainList {            ToolchainList {                toolchains: vec![Toolchain {                    name: SharedString::new_static("Test Python"),                    path: SharedString::new_static("/test/python"),                    language_name: LanguageName::new_static("Python"),                    as_json: serde_json::Value::Null,                }],                ..Default::default()            }        }         async fn resolve(            &self,            _path: PathBuf,            _project_env: Option<HashMap<String, String>>,        ) -> anyhow::Result<Toolchain> {            anyhow::bail!("not implemented")        }         fn activation_script(            &self,            _toolchain: &Toolchain,            _shell: ShellKind,            _cx: &App,        ) -> futures::future::BoxFuture<'static, Vec<String>> {            Box::pin(async { Vec::new() })        }         fn meta(&self) -> ToolchainMetadata {            ToolchainMetadata {                term: SharedString::new_static("Python"),                new_toolchain_placeholder: SharedString::default(),                manifest_name: ManifestName::from(SharedString::new_static("pyproject.toml")),            }        }    }     #[gpui::test]    async fn test_refreshes_python_kernelspecs_when_buffer_language_changes(        cx: &mut TestAppContext,    ) {        cx.update(|cx| {            settings::init(cx);            theme_settings::init(theme::LoadThemes::JustBase, cx);            editor::init(cx);        });         let fs = project::FakeFs::new(cx.background_executor.clone());        fs.insert_tree(            path!("/project"),            serde_json::json!({                "main.txt": "print('hi')",            }),        )        .await;         let project = project::Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;        let python = Arc::new(            Language::new(                LanguageConfig {                    name: "Python".into(),                    matcher: (LanguageMatcher {                        path_suffixes: vec!["py".to_string()],                        ..Default::default()                    })                    .into(),                    ..Default::default()                },                None,            )            .with_manifest(Some(ManifestName::from(SharedString::new_static(                "pyproject.toml",            ))))            .with_toolchain_lister(Some(Arc::new(TestPythonToolchainLister))),        );        project.read_with(cx, |project, _cx| {            project.languages().add(python.clone());        });         cx.update(|cx| crate::init(fs, cx));         let buffer = project            .update(cx, |project, cx| {                project.open_local_buffer(path!("/project/main.txt"), cx)            })            .await            .expect("failed to open buffer");         let worktree_id = buffer            .read_with(cx, |buffer, cx| {                buffer.project_path(cx).map(|path| path.worktree_id)            })            .expect("buffer should have a project path");         cx.add_window(|window, cx| {            let multi_buffer = MultiBuffer::build_from_buffer(buffer.clone(), cx);            Editor::new(                EditorMode::full(),                multi_buffer,                Some(project.clone()),                window,                cx,            )        });        cx.run_until_parked();         let store = cx.update(|cx| ReplStore::global(cx));        assert!(!cx.update(|cx| store.read(cx).has_python_kernelspecs(worktree_id)));         buffer.update(cx, |buffer, cx| {            buffer.set_language(Some(python), cx);        });        cx.run_until_parked();         assert!(cx.update(|cx| store.read(cx).has_python_kernelspecs(worktree_id)));    }}