tenant.openagents/omega

1use anyhow::Result;
2use async_trait::async_trait;
3use gpui::AsyncApp;
4use language::{LspAdapter, LspAdapterDelegate, LspInstaller, Toolchain};
5use lsp::{LanguageServerBinary, LanguageServerName, Uri};
6use node_runtime::{NodeRuntime, VersionStrategy};
7use project::lsp_store::language_server_settings;
8use semver::Version;
9use serde_json::json;
10use std::{
11    ffi::OsString,
12    future::Future,
13    path::{Path, PathBuf},
14    sync::Arc,
15};
16use util::{ResultExt, maybe, merge_json_value_into};
17
18const SERVER_PATH: &str = "node_modules/@tailwindcss/language-server/bin/css-language-server";
19
20fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
21    vec![server_path.into(), "--stdio".into()]
22}
23
24pub struct TailwindCssLspAdapter {
25    node: NodeRuntime,
26}
27
28// Implements the LSP adapter for the Tailwind CSS LSP fork: https://github.com/zed-industries/zed/pull/39517#issuecomment-3368206678
29impl TailwindCssLspAdapter {
30    const SERVER_NAME: LanguageServerName =
31        LanguageServerName::new_static("tailwindcss-intellisense-css");
32    const PACKAGE_NAME: &str = "@tailwindcss/language-server";
33
34    pub fn new(node: NodeRuntime) -> Self {
35        TailwindCssLspAdapter { node }
36    }
37}
38
39impl LspInstaller for TailwindCssLspAdapter {
40    type BinaryVersion = Version;
41
42    async fn fetch_latest_server_version(
43        &self,
44        _: &Arc<dyn LspAdapterDelegate>,
45        _: bool,
46        _: &mut AsyncApp,
47    ) -> Result<Self::BinaryVersion> {
48        self.node
49            .npm_package_latest_version(Self::PACKAGE_NAME)
50            .await
51    }
52
53    async fn check_if_user_installed(
54        &self,
55        delegate: &Arc<dyn LspAdapterDelegate>,
56        _: Option<Toolchain>,
57        _: &AsyncApp,
58    ) -> Option<LanguageServerBinary> {
59        let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
60        let env = delegate.shell_env().await;
61
62        Some(LanguageServerBinary {
63            path,
64            env: Some(env),
65            arguments: vec!["--stdio".into()],
66        })
67    }
68
69    fn fetch_server_binary(
70        &self,
71        _latest_version: Self::BinaryVersion,
72        container_dir: PathBuf,
73        _: &Arc<dyn LspAdapterDelegate>,
74    ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
75        let node = self.node.clone();
76
77        async move {
78            let server_path = container_dir.join(SERVER_PATH);
79
80            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
81                .await?;
82
83            Ok(LanguageServerBinary {
84                path: node.binary_path().await?,
85                env: None,
86                arguments: server_binary_arguments(&server_path),
87            })
88        }
89    }
90
91    fn check_if_version_installed(
92        &self,
93        version: &Self::BinaryVersion,
94        container_dir: &PathBuf,
95        _: &Arc<dyn LspAdapterDelegate>,
96    ) -> impl Send + Future<Output = Option<LanguageServerBinary>> + use<> {
97        let node = self.node.clone();
98        let version = version.clone();
99        let container_dir = container_dir.clone();
100
101        async move {
102            let server_path = container_dir.join(SERVER_PATH);
103
104            let should_install_language_server = node
105                .should_install_npm_package(
106                    Self::PACKAGE_NAME,
107                    &server_path,
108                    &container_dir,
109                    VersionStrategy::Latest(&version),
110                )
111                .await;
112
113            if should_install_language_server {
114                None
115            } else {
116                Some(LanguageServerBinary {
117                    path: node.binary_path().await.ok()?,
118                    env: None,
119                    arguments: server_binary_arguments(&server_path),
120                })
121            }
122        }
123    }
124
125    async fn cached_server_binary(
126        &self,
127        container_dir: PathBuf,
128        _: &dyn LspAdapterDelegate,
129    ) -> Option<LanguageServerBinary> {
130        get_cached_server_binary(container_dir, &self.node).await
131    }
132}
133
134#[async_trait(?Send)]
135impl LspAdapter for TailwindCssLspAdapter {
136    fn name(&self) -> LanguageServerName {
137        Self::SERVER_NAME
138    }
139
140    async fn initialization_options(
141        self: Arc<Self>,
142        _: &Arc<dyn LspAdapterDelegate>,
143        _: &mut AsyncApp,
144    ) -> Result<Option<serde_json::Value>> {
145        Ok(Some(json!({
146            "provideFormatter": true
147        })))
148    }
149
150    async fn workspace_configuration(
151        self: Arc<Self>,
152        delegate: &Arc<dyn LspAdapterDelegate>,
153        _: Option<Toolchain>,
154        _: Option<Uri>,
155        cx: &mut AsyncApp,
156    ) -> Result<serde_json::Value> {
157        let mut default_config = json!({
158            "css": {
159                "lint": {}
160            },
161            "less": {
162                "lint": {}
163            },
164            "scss": {
165                "lint": {}
166            }
167        });
168
169        let project_options = cx.update(|cx| {
170            language_server_settings(delegate.as_ref(), &self.name(), cx)
171                .and_then(|s| s.settings.clone())
172        });
173
174        if let Some(override_options) = project_options {
175            merge_json_value_into(override_options, &mut default_config);
176        }
177
178        Ok(default_config)
179    }
180}
181
182async fn get_cached_server_binary(
183    container_dir: PathBuf,
184    node: &NodeRuntime,
185) -> Option<LanguageServerBinary> {
186    maybe!(async {
187        let server_path = container_dir.join(SERVER_PATH);
188        anyhow::ensure!(
189            server_path.exists(),
190            "missing executable in directory {server_path:?}"
191        );
192        Ok(LanguageServerBinary {
193            path: node.binary_path().await?,
194            env: None,
195            arguments: server_binary_arguments(&server_path),
196        })
197    })
198    .await
199    .log_err()
200}
201