tenant.openagents/omega

1use anyhow::Result;
2use async_trait::async_trait;
3use collections::HashMap;
4use gpui::AsyncApp;
5use language::{LanguageName, LspAdapter, LspAdapterDelegate, LspInstaller, Toolchain};
6use lsp::{LanguageServerBinary, LanguageServerName, Uri};
7use node_runtime::{NodeRuntime, VersionStrategy};
8use project::lsp_store::language_server_settings;
9use semver::Version;
10use serde_json::{Value, json};
11use std::{
12    ffi::OsString,
13    future::Future,
14    path::{Path, PathBuf},
15    sync::Arc,
16};
17use util::{ResultExt, maybe};
18
19#[cfg(target_os = "windows")]
20const SERVER_PATH: &str =
21    "node_modules/@tailwindcss/language-server/bin/tailwindcss-language-server";
22#[cfg(not(target_os = "windows"))]
23const SERVER_PATH: &str = "node_modules/.bin/tailwindcss-language-server";
24
25fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
26    vec![server_path.into(), "--stdio".into()]
27}
28
29pub struct TailwindLspAdapter {
30    node: NodeRuntime,
31}
32
33impl TailwindLspAdapter {
34    const SERVER_NAME: LanguageServerName =
35        LanguageServerName::new_static("tailwindcss-language-server");
36    const PACKAGE_NAME: &str = "@tailwindcss/language-server";
37
38    pub fn new(node: NodeRuntime) -> Self {
39        TailwindLspAdapter { node }
40    }
41}
42
43impl LspInstaller for TailwindLspAdapter {
44    type BinaryVersion = Version;
45
46    async fn fetch_latest_server_version(
47        &self,
48        _: &Arc<dyn LspAdapterDelegate>,
49        _: bool,
50        _: &mut AsyncApp,
51    ) -> Result<Self::BinaryVersion> {
52        self.node
53            .npm_package_latest_version(Self::PACKAGE_NAME)
54            .await
55    }
56
57    async fn check_if_user_installed(
58        &self,
59        delegate: &Arc<dyn LspAdapterDelegate>,
60        _: Option<Toolchain>,
61        _: &AsyncApp,
62    ) -> Option<LanguageServerBinary> {
63        let path = delegate.which(Self::SERVER_NAME.as_ref()).await?;
64        let env = delegate.shell_env().await;
65
66        Some(LanguageServerBinary {
67            path,
68            env: Some(env),
69            arguments: vec!["--stdio".into()],
70        })
71    }
72
73    fn fetch_server_binary(
74        &self,
75        _latest_version: Self::BinaryVersion,
76        container_dir: PathBuf,
77        _: &Arc<dyn LspAdapterDelegate>,
78    ) -> impl Send + Future<Output = Result<LanguageServerBinary>> + use<> {
79        let node = self.node.clone();
80
81        async move {
82            let server_path = container_dir.join(SERVER_PATH);
83
84            node.npm_install_latest_packages(&container_dir, &[Self::PACKAGE_NAME])
85                .await?;
86
87            Ok(LanguageServerBinary {
88                path: node.binary_path().await?,
89                env: None,
90                arguments: server_binary_arguments(&server_path),
91            })
92        }
93    }
94
95    fn check_if_version_installed(
96        &self,
97        version: &Self::BinaryVersion,
98        container_dir: &PathBuf,
99        _: &Arc<dyn LspAdapterDelegate>,
100    ) -> impl Send + Future<Output = Option<LanguageServerBinary>> + use<> {
101        let node = self.node.clone();
102        let version = version.clone();
103        let container_dir = container_dir.clone();
104
105        async move {
106            let server_path = container_dir.join(SERVER_PATH);
107
108            let should_install_language_server = node
109                .should_install_npm_package(
110                    Self::PACKAGE_NAME,
111                    &server_path,
112                    &container_dir,
113                    VersionStrategy::Latest(&version),
114                )
115                .await;
116
117            if should_install_language_server {
118                None
119            } else {
120                Some(LanguageServerBinary {
121                    path: node.binary_path().await.ok()?,
122                    env: None,
123                    arguments: server_binary_arguments(&server_path),
124                })
125            }
126        }
127    }
128
129    async fn cached_server_binary(
130        &self,
131        container_dir: PathBuf,
132        _: &dyn LspAdapterDelegate,
133    ) -> Option<LanguageServerBinary> {
134        get_cached_server_binary(container_dir, &self.node).await
135    }
136}
137
138#[async_trait(?Send)]
139impl LspAdapter for TailwindLspAdapter {
140    fn name(&self) -> LanguageServerName {
141        Self::SERVER_NAME
142    }
143
144    async fn initialization_options(
145        self: Arc<Self>,
146        _: &Arc<dyn LspAdapterDelegate>,
147        _: &mut AsyncApp,
148    ) -> Result<Option<serde_json::Value>> {
149        Ok(Some(json!({
150            "provideFormatter": true,
151        })))
152    }
153
154    async fn workspace_configuration(
155        self: Arc<Self>,
156        delegate: &Arc<dyn LspAdapterDelegate>,
157        _: Option<Toolchain>,
158        _: Option<Uri>,
159        cx: &mut AsyncApp,
160    ) -> Result<Value> {
161        let mut tailwind_user_settings = cx.update(|cx| {
162            language_server_settings(delegate.as_ref(), &Self::SERVER_NAME, cx)
163                .and_then(|s| s.settings.clone())
164                .unwrap_or_default()
165        });
166
167        if tailwind_user_settings.get("emmetCompletions").is_none() {
168            tailwind_user_settings["emmetCompletions"] = Value::Bool(true);
169        }
170
171        if tailwind_user_settings.get("includeLanguages").is_none() {
172            tailwind_user_settings["includeLanguages"] = json!({
173                "html": "html",
174                "css": "css",
175                "javascript": "javascript",
176                "typescript": "typescript",
177                "typescriptreact": "typescriptreact",
178            });
179        }
180
181        Ok(json!({
182            "tailwindCSS": tailwind_user_settings
183        }))
184    }
185
186    fn language_ids(&self) -> HashMap<LanguageName, String> {
187        HashMap::from_iter([
188            (LanguageName::new_static("Astro"), "astro".to_string()),
189            (LanguageName::new_static("HTML"), "html".to_string()),
190            (LanguageName::new_static("Gleam"), "html".to_string()),
191            (LanguageName::new_static("CSS"), "css".to_string()),
192            (
193                LanguageName::new_static("JavaScript"),
194                "javascript".to_string(),
195            ),
196            (
197                LanguageName::new_static("TypeScript"),
198                "typescript".to_string(),
199            ),
200            (
201                LanguageName::new_static("TSX"),
202                "typescriptreact".to_string(),
203            ),
204            (LanguageName::new_static("Svelte"), "svelte".to_string()),
205            (LanguageName::new_static("Elixir"), "elixir".to_string()),
206            (LanguageName::new_static("HEEx"), "heex".to_string()),
207            (LanguageName::new_static("ERB"), "erb".to_string()),
208            (LanguageName::new_static("HTML+ERB"), "erb".to_string()),
209            (LanguageName::new_static("PHP"), "php".to_string()),
210            (LanguageName::new_static("Vue.js"), "vue".to_string()),
211        ])
212    }
213}
214
215async fn get_cached_server_binary(
216    container_dir: PathBuf,
217    node: &NodeRuntime,
218) -> Option<LanguageServerBinary> {
219    maybe!(async {
220        let server_path = container_dir.join(SERVER_PATH);
221        anyhow::ensure!(
222            server_path.exists(),
223            "missing executable in directory {server_path:?}"
224        );
225        Ok(LanguageServerBinary {
226            path: node.binary_path().await?,
227            env: None,
228            arguments: server_binary_arguments(&server_path),
229        })
230    })
231    .await
232    .log_err()
233}
234