tenant.openagents/omega

1use anyhow::Result;
2use async_trait::async_trait;
3use gpui::AsyncApp;
4use language::{
5    LspAdapter, LspAdapterDelegate, LspInstaller, Toolchain, language_settings::AllLanguageSettings,
6};
7use lsp::{LanguageServerBinary, LanguageServerName, Uri};
8use node_runtime::{NodeRuntime, VersionStrategy};
9use project::lsp_store::language_server_settings;
10use semver::Version;
11use serde_json::Value;
12use settings::{Settings, SettingsLocation};
13use std::{
14    ffi::OsString,
15    future::Future,
16    path::{Path, PathBuf},
17    sync::Arc,
18};
19use util::{ResultExt, maybe, merge_json_value_into, rel_path::RelPath};
20
21const SERVER_PATH: &str = "node_modules/yaml-language-server/bin/yaml-language-server";
22
23fn server_binary_arguments(server_path: &Path) -> Vec<OsString> {
24    vec![server_path.into(), "--stdio".into()]
25}
26
27pub struct YamlLspAdapter {
28    node: NodeRuntime,
29}
30
31impl YamlLspAdapter {
32    const SERVER_NAME: LanguageServerName = LanguageServerName::new_static("yaml-language-server");
33    const PACKAGE_NAME: &str = "yaml-language-server";
34    pub fn new(node: NodeRuntime) -> Self {
35        YamlLspAdapter { node }
36    }
37}
38
39impl LspInstaller for YamlLspAdapter {
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("yaml-language-server")
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 YamlLspAdapter {
136    fn name(&self) -> LanguageServerName {
137        Self::SERVER_NAME
138    }
139
140    async fn workspace_configuration(
141        self: Arc<Self>,
142        delegate: &Arc<dyn LspAdapterDelegate>,
143        _: Option<Toolchain>,
144        _: Option<Uri>,
145        cx: &mut AsyncApp,
146    ) -> Result<Value> {
147        let location = SettingsLocation {
148            worktree_id: delegate.worktree_id(),
149            path: RelPath::empty(),
150        };
151
152        let tab_size = cx.update(|cx| {
153            AllLanguageSettings::get(Some(location), cx)
154                .language(Some(location), Some(&"YAML".into()), cx)
155                .tab_size
156        });
157
158        let mut options = serde_json::json!({
159            "[yaml]": {"editor.tabSize": tab_size},
160            "yaml": {"format": {"enable": true}}
161        });
162
163        let project_options = cx.update(|cx| {
164            language_server_settings(delegate.as_ref(), &Self::SERVER_NAME, cx)
165                .and_then(|s| worktree_root(delegate, s.settings.clone()))
166        });
167        if let Some(override_options) = project_options {
168            merge_json_value_into(override_options, &mut options);
169        }
170        Ok(options)
171    }
172}
173
174fn worktree_root(delegate: &Arc<dyn LspAdapterDelegate>, settings: Option<Value>) -> Option<Value> {
175    let Some(Value::Object(mut settings_map)) = settings else {
176        return settings;
177    };
178
179    let Some(Value::Object(yaml_config)) = settings_map.get_mut("yaml") else {
180        return Some(Value::Object(settings_map));
181    };
182
183    let Some(Value::Object(schemas)) = yaml_config.remove("schemas") else {
184        return Some(Value::Object(settings_map));
185    };
186
187    let schemas = schemas
188        .into_iter()
189        .map(|(url, v)| {
190            if !url.starts_with(".") && !url.starts_with("~") {
191                (url, v)
192            } else {
193                let resolved_url = delegate
194                    .resolve_relative_path(url.into())
195                    .to_string_lossy()
196                    .into_owned();
197                (resolved_url, v)
198            }
199        })
200        .collect::<serde_json::Map<String, Value>>();
201
202    yaml_config.insert("schemas".into(), Value::Object(schemas));
203    Some(Value::Object(settings_map))
204}
205
206async fn get_cached_server_binary(
207    container_dir: PathBuf,
208    node: &NodeRuntime,
209) -> Option<LanguageServerBinary> {
210    maybe!(async {
211        let server_path = container_dir.join(SERVER_PATH);
212        anyhow::ensure!(
213            server_path.exists(),
214            "missing executable in directory {server_path:?}"
215        );
216        Ok(LanguageServerBinary {
217            path: node.binary_path().await?,
218            env: None,
219            arguments: server_binary_arguments(&server_path),
220        })
221    })
222    .await
223    .log_err()
224}
225