tenant.openagents/omega

1use gpui::{App, SharedString, UpdateGlobal};
2use node_runtime::NodeRuntime;
3use project::Fs;
4use python::PyprojectTomlManifestProvider;
5use rust::CargoManifestProvider;
6use settings::{SemanticTokenRules, SettingsStore};
7use smol::stream::StreamExt;
8use std::sync::Arc;
9use util::ResultExt;
10
11pub use language::*;
12
13use crate::{
14    json::JsonTaskProvider,
15    python::{BasedPyrightLspAdapter, RuffLspAdapter},
16};
17
18mod bash;
19mod c;
20mod cpp;
21mod css;
22mod eslint;
23mod go;
24mod json;
25mod package_json;
26mod python;
27mod rust;
28mod tailwind;
29mod tailwindcss;
30mod typescript;
31mod vtsls;
32mod yaml;
33
34pub(crate) use package_json::{PackageJson, PackageJsonData};
35
36/// A shared grammar for plain text, exposed for reuse by downstream crates.
37#[cfg(feature = "tree-sitter-gitcommit")]
38pub static LANGUAGE_GIT_COMMIT: std::sync::LazyLock<Arc<Language>> =
39    std::sync::LazyLock::new(|| {
40        Arc::new(Language::new(
41            LanguageConfig {
42                name: "Git Commit".into(),
43                soft_wrap: Some(language::SoftWrap::EditorWidth),
44                matcher: (LanguageMatcher {
45                    path_suffixes: vec!["COMMIT_EDITMSG".to_owned()],
46                    first_line_pattern: None,
47                    ..LanguageMatcher::default()
48                })
49                .into(),
50                line_comments: vec![Arc::from("#")],
51                ..LanguageConfig::default()
52            },
53            Some(tree_sitter_gitcommit::LANGUAGE.into()),
54        ))
55    });
56
57pub fn init(languages: Arc<LanguageRegistry>, fs: Arc<dyn Fs>, node: NodeRuntime, cx: &mut App) {
58    #[cfg(feature = "load-grammars")]
59    languages.register_native_grammars(grammars::native_grammars());
60
61    let bash_lsp_adapter = Arc::new(bash::BashLspAdapter::new(node.clone()));
62    let c_lsp_adapter = Arc::new(c::CLspAdapter);
63    let css_lsp_adapter = Arc::new(css::CssLspAdapter::new(node.clone()));
64    let eslint_adapter = Arc::new(eslint::EsLintLspAdapter::new(node.clone(), fs.clone()));
65    let go_context_provider = Arc::new(go::GoContextProvider);
66    let go_lsp_adapter = Arc::new(go::GoLspAdapter);
67    let json_context_provider = Arc::new(JsonTaskProvider);
68    let json_lsp_adapter = Arc::new(json::JsonLspAdapter::new(languages.clone(), node.clone()));
69    let node_version_lsp_adapter = Arc::new(json::NodeVersionAdapter);
70    let py_lsp_adapter = Arc::new(python::PyLspAdapter::new());
71    let ty_lsp_adapter = Arc::new(python::TyLspAdapter::new(fs.clone()));
72    let python_context_provider = Arc::new(python::PythonContextProvider);
73    let python_lsp_adapter = Arc::new(python::PyrightLspAdapter::new(node.clone()));
74    let basedpyright_lsp_adapter = Arc::new(BasedPyrightLspAdapter::new(node.clone()));
75    let ruff_lsp_adapter = Arc::new(RuffLspAdapter::new(fs.clone()));
76    let python_toolchain_provider = Arc::new(python::PythonToolchainProvider::new(fs.clone()));
77    let rust_context_provider = Arc::new(rust::RustContextProvider);
78    let rust_lsp_adapter = Arc::new(rust::RustLspAdapter);
79    let tailwind_adapter = Arc::new(tailwind::TailwindLspAdapter::new(node.clone()));
80    let tailwindcss_adapter = Arc::new(tailwindcss::TailwindCssLspAdapter::new(node.clone()));
81    let typescript_context = Arc::new(typescript::TypeScriptContextProvider::new(fs.clone()));
82    let typescript_lsp_adapter = Arc::new(typescript::TypeScriptLspAdapter::new(
83        node.clone(),
84        fs.clone(),
85    ));
86    let vtsls_adapter = Arc::new(vtsls::VtslsLspAdapter::new(node.clone(), fs.clone()));
87    let yaml_lsp_adapter = Arc::new(yaml::YamlLspAdapter::new(node));
88
89    let built_in_languages = [
90        LanguageInfo {
91            name: "bash",
92            context: Some(Arc::new(bash::bash_task_context())),
93            adapters: vec![bash_lsp_adapter],
94            ..Default::default()
95        },
96        LanguageInfo {
97            name: "c",
98            adapters: vec![c_lsp_adapter.clone()],
99            ..Default::default()
100        },
101        LanguageInfo {
102            name: "cpp",
103            adapters: vec![c_lsp_adapter],
104            semantic_token_rules: Some(cpp::semantic_token_rules()),
105            ..Default::default()
106        },
107        LanguageInfo {
108            name: "css",
109            adapters: vec![css_lsp_adapter],
110            ..Default::default()
111        },
112        LanguageInfo {
113            name: "diff",
114            adapters: vec![],
115            ..Default::default()
116        },
117        LanguageInfo {
118            name: "go",
119            adapters: vec![go_lsp_adapter.clone()],
120            context: Some(go_context_provider.clone()),
121            semantic_token_rules: Some(go::semantic_token_rules()),
122            ..Default::default()
123        },
124        LanguageInfo {
125            name: "gomod",
126            adapters: vec![go_lsp_adapter.clone()],
127            context: Some(go_context_provider.clone()),
128            ..Default::default()
129        },
130        LanguageInfo {
131            name: "gowork",
132            adapters: vec![go_lsp_adapter],
133            context: Some(go_context_provider),
134            ..Default::default()
135        },
136        LanguageInfo {
137            name: "json",
138            adapters: vec![json_lsp_adapter.clone(), node_version_lsp_adapter],
139            context: Some(json_context_provider.clone()),
140            ..Default::default()
141        },
142        LanguageInfo {
143            name: "jsonc",
144            adapters: vec![json_lsp_adapter],
145            context: Some(json_context_provider),
146            ..Default::default()
147        },
148        LanguageInfo {
149            name: "markdown",
150            adapters: vec![],
151            ..Default::default()
152        },
153        LanguageInfo {
154            name: "markdown-inline",
155            adapters: vec![],
156            ..Default::default()
157        },
158        LanguageInfo {
159            name: "python",
160            adapters: vec![
161                basedpyright_lsp_adapter,
162                ruff_lsp_adapter,
163                ty_lsp_adapter,
164                py_lsp_adapter,
165                python_lsp_adapter,
166            ],
167            context: Some(python_context_provider),
168            toolchain: Some(python_toolchain_provider),
169            manifest_name: Some(SharedString::new_static("pyproject.toml").into()),
170            semantic_token_rules: Some(python::semantic_token_rules()),
171        },
172        LanguageInfo {
173            name: "rust",
174            adapters: vec![rust_lsp_adapter],
175            context: Some(rust_context_provider),
176            manifest_name: Some(SharedString::new_static("Cargo.toml").into()),
177            semantic_token_rules: Some(rust::semantic_token_rules()),
178            ..Default::default()
179        },
180        LanguageInfo {
181            name: "tsx",
182            adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
183            context: Some(typescript_context.clone()),
184            ..Default::default()
185        },
186        LanguageInfo {
187            name: "typescript",
188            adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
189            context: Some(typescript_context.clone()),
190            ..Default::default()
191        },
192        LanguageInfo {
193            name: "javascript",
194            adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
195            context: Some(typescript_context),
196            ..Default::default()
197        },
198        LanguageInfo {
199            name: "jsdoc",
200            adapters: vec![typescript_lsp_adapter.clone(), vtsls_adapter.clone()],
201            ..Default::default()
202        },
203        LanguageInfo {
204            name: "regex",
205            adapters: vec![],
206            ..Default::default()
207        },
208        LanguageInfo {
209            name: "yaml",
210            adapters: vec![yaml_lsp_adapter],
211            ..Default::default()
212        },
213        LanguageInfo {
214            name: "gitcommit",
215            ..Default::default()
216        },
217        LanguageInfo {
218            name: "keybind-context",
219            ..Default::default()
220        },
221    ];
222
223    for registration in built_in_languages {
224        register_language(
225            &languages,
226            registration.name,
227            registration.adapters,
228            registration.context,
229            registration.toolchain,
230            registration.manifest_name,
231            registration.semantic_token_rules,
232            cx,
233        );
234    }
235
236    // Register globally available language servers.
237    //
238    // This will allow users to add support for a built-in language server (e.g., Tailwind)
239    // for a given language via the `language_servers` setting:
240    //
241    // ```json
242    // {
243    //   "languages": {
244    //     "My Language": {
245    //       "language_servers": ["tailwindcss-language-server", "..."]
246    //     }
247    //   }
248    // }
249    // ```
250    languages.register_available_lsp_adapter(
251        LanguageServerName("tailwindcss-language-server".into()),
252        tailwind_adapter.clone(),
253    );
254    languages.register_available_lsp_adapter(
255        LanguageServerName("tailwindcss-intellisense-css".into()),
256        tailwindcss_adapter,
257    );
258    languages.register_available_lsp_adapter(
259        LanguageServerName("eslint".into()),
260        eslint_adapter.clone(),
261    );
262    languages.register_available_lsp_adapter(LanguageServerName("vtsls".into()), vtsls_adapter);
263    languages.register_available_lsp_adapter(
264        LanguageServerName("typescript-language-server".into()),
265        typescript_lsp_adapter,
266    );
267
268    // Register Tailwind for the existing languages that should have it by default.
269    //
270    // This can be driven by the `language_servers` setting once we have a way for
271    // extensions to provide their own default value for that setting.
272    let tailwind_languages = [
273        "Astro",
274        "CSS",
275        "ERB",
276        "HTML+ERB",
277        "HEEx",
278        "HTML",
279        "JavaScript",
280        "TypeScript",
281        "PHP",
282        "Svelte",
283        "TSX",
284        "Vue.js",
285    ];
286
287    for language in tailwind_languages {
288        languages.register_lsp_adapter(language.into(), tailwind_adapter.clone());
289    }
290
291    let eslint_languages = ["TSX", "TypeScript", "JavaScript", "Vue.js", "Svelte"];
292    for language in eslint_languages {
293        languages.register_lsp_adapter(language.into(), eslint_adapter.clone());
294    }
295
296    let mut subscription = languages.subscribe();
297    let mut prev_language_settings = languages.language_settings();
298
299    cx.spawn(async move |cx| {
300        while subscription.next().await.is_some() {
301            let language_settings = languages.language_settings();
302            if language_settings != prev_language_settings {
303                cx.update(|cx| {
304                    SettingsStore::update_global(cx, |settings, cx| {
305                        settings
306                            .set_extension_settings(
307                                settings::ExtensionsSettingsContent {
308                                    all_languages: language_settings.clone(),
309                                },
310                                cx,
311                            )
312                            .log_err();
313                    });
314                });
315                prev_language_settings = language_settings;
316            }
317        }
318        anyhow::Ok(())
319    })
320    .detach();
321    let manifest_providers: [Arc<dyn ManifestProvider>; 2] = [
322        Arc::from(CargoManifestProvider),
323        Arc::from(PyprojectTomlManifestProvider),
324    ];
325    for provider in manifest_providers {
326        project::ManifestProvidersStore::global(cx).register(provider);
327    }
328}
329
330#[derive(Default)]
331struct LanguageInfo {
332    name: &'static str,
333    adapters: Vec<Arc<dyn LspAdapter>>,
334    context: Option<Arc<dyn ContextProvider>>,
335    toolchain: Option<Arc<dyn ToolchainLister>>,
336    manifest_name: Option<ManifestName>,
337    semantic_token_rules: Option<SemanticTokenRules>,
338}
339
340fn register_language(
341    languages: &LanguageRegistry,
342    name: &'static str,
343    adapters: Vec<Arc<dyn LspAdapter>>,
344    context: Option<Arc<dyn ContextProvider>>,
345    toolchain: Option<Arc<dyn ToolchainLister>>,
346    manifest_name: Option<ManifestName>,
347    semantic_token_rules: Option<SemanticTokenRules>,
348    cx: &mut App,
349) {
350    let config = load_config(name);
351    if let Some(rules) = &semantic_token_rules {
352        SettingsStore::update_global(cx, |store, cx| {
353            store.set_language_semantic_token_rules(config.name.0.clone(), rules.clone(), cx);
354        });
355    }
356    for adapter in adapters {
357        languages.register_lsp_adapter(config.name.clone(), adapter);
358    }
359    languages.register_language(
360        config.name.clone(),
361        config.grammar.clone(),
362        config.matcher.clone(),
363        config.hidden,
364        manifest_name.clone(),
365        Arc::new(move || {
366            Ok(LoadedLanguage {
367                config: config.clone(),
368                queries: grammars::load_queries(name),
369                context_provider: context.clone(),
370                toolchain_provider: toolchain.clone(),
371                manifest_name: manifest_name.clone(),
372            })
373        }),
374    );
375}
376
377#[cfg(any(test, feature = "test-support"))]
378pub fn language(name: &str, grammar: tree_sitter::Language) -> Arc<Language> {
379    Arc::new(
380        Language::new(grammars::load_config(name), Some(grammar))
381            .with_queries(grammars::load_queries(name))
382            .unwrap(),
383    )
384}
385
386fn load_config(name: &str) -> LanguageConfig {
387    let grammars_loaded = cfg!(any(feature = "load-grammars", test));
388    grammars::load_config_for_feature(name, grammars_loaded)
389}
390