@gram-data/tree-sitter-gram 0.3.5 → 0.3.7

package/editors/zed/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "gram_zed_extension"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+publish = false
+repository = "https://github.com/gram-data/tree-sitter-gram"
+build = "build.rs"
+
+[lib]
+path = "src/lib.rs"
+crate-type = ["cdylib"]
+
+[dependencies]
+zed_extension_api = "0.7"
+
+# Standalone workspace root so this crate is not treated as a stray member of the
+# repository workspace (see root `Cargo.toml` `[workspace]`).
+[workspace]
+members = ["."]

package/editors/zed/README.md

@@ -5,6 +5,7 @@ A [Zed](https://zed.dev) extension providing syntax highlighting and language su
 ## Features
 
 - **Syntax Highlighting**: Full syntax highlighting for all Gram constructs including subjects, nodes, relationships, and data types
+- **Language server**: When [`gram-lsp`](../../tools/lsp/) is on your `PATH`, Zed starts it for `.gram` files (diagnostics, hover, definitions, references, completions)
 - **Subject Pattern Matching**: Automatic matching for `()`, `[]`, and `{}`
 - **File Type Detection**: Automatic recognition of `.gram` files
 - **Smart Indentation**: Proper indentation handling for nested structures
@@ -40,7 +41,7 @@ Then restart Zed.
 
 ## Usage
 
-Once installed, the extension automatically provides syntax highlighting for any file with a `.gram` extension.
+Once installed, the extension provides syntax highlighting for `.gram` files. With `gram-lsp` installed and on `PATH`, Zed also attaches the language server automatically.
 
 ### Example Gram Syntax
 
@@ -108,14 +109,25 @@ To work on this extension:
    - Select the `editors/zed` directory
    - Restart Zed
 
-3. Make changes to the extension files
-4. Restart Zed to see changes
+3. Build the Wasm extension once after Rust changes (Zed loads the cdylib):
+
+   ```bash
+   rustup target add wasm32-wasip1
+   cd editors/zed && cargo check --target wasm32-wasip1
+   ```
+
+4. Make changes to the extension files
+5. Restart Zed to see changes
 
 ### Extension Structure
 
 ```
 editors/zed/
-├── extension.toml          # Extension metadata; points at grammar repo (repository + rev)
+├── Cargo.toml              # Wasm extension crate (zed_extension_api)
+├── build.rs                # Embeds `extension.toml` version for release asset lookup
+├── Cargo.lock
+├── src/lib.rs              # `language_server_command`: PATH, then GitHub release download
+├── extension.toml          # Extension metadata; grammar repo + `[language_servers.gram-lsp]`
 ├── languages/
 │   └── gram/
 │       ├── config.toml     # Zed language config (brackets, suffixes, etc.)
@@ -144,6 +156,12 @@ After either command, `extension.toml` is updated in place. For local dev you ty
 
 **If Zed shows an old version (e.g. 0.1.11) after installing the dev extension:** Zed may be using a cached clone of the grammar (at an old rev) or an older copy of the extension. Try: (1) Uninstall the Gram extension from Zed’s Extensions panel. (2) Delete the grammar cache: remove `editors/zed/grammars/` if it exists (Zed recreates it when needed). (3) Run `npm run zed:dev` again so `extension.toml` has the current version and rev. (4) In Zed, run “Install Dev Extension” and select `editors/zed` again. Restart Zed and recheck the extension version.
 
+### Bundled `gram-lsp` (GitHub Releases)
+
+Zed extensions ship a **Wasm** adapter only; native `gram-lsp` binaries cannot be embedded in that bundle. Instead, when `gram-lsp` is **not** on `PATH`, the extension downloads a platform archive from **this repo’s GitHub Release** whose tag is **`v` + `version` from `extension.toml`** (for example `v0.3.5` for `version = "0.3.5"`).
+
+Maintainers: pushing a **`v*`** tag runs **`.github/workflows/gram-lsp-release-assets.yml`**, which builds `gram-lsp` for common targets and uploads `gram-lsp-{target}.tar.gz` to the matching GitHub Release. Filenames must stay in sync with `editors/zed/src/lib.rs`. Keep `extension.toml`’s `version` aligned with the tag you ship to the Zed extension registry (for example tag `v0.3.5` and `version = "0.3.5"`) so installs download the intended binaries.
+
 ## Contributing
 
 Contributions are welcome! Please see the main [repository](https://github.com/gram-data/tree-sitter-gram) for contribution guidelines.
@@ -156,7 +174,7 @@ To improve syntax highlighting and editor behavior:
 
 ## License
 
-This extension is part of the tree-sitter-gram project and is licensed under the ISC License. See the main repository's [LICENSE](../../LICENSE) file for details.
+This extension is part of the tree-sitter-gram project and is licensed under the MIT License. See the main repository's [LICENSE](../../LICENSE) file for details.
 
 ## Learn More
 

package/editors/zed/build.rs

@@ -0,0 +1,26 @@
+//! Expose `extension.toml`'s `version = "…"` as `env!("GRAM_EXT_VERSION")` for release lookups.
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR"));
+    let ext_toml = manifest_dir.join("extension.toml");
+    println!("cargo:rerun-if-changed={}", ext_toml.display());
+
+    let content = fs::read_to_string(&ext_toml).unwrap_or_else(|e| panic!("read {}: {e}", ext_toml.display()));
+    let version = parse_version(&content)
+        .unwrap_or_else(|| panic!("{}: missing `version = \"…\"` line", ext_toml.display()));
+    println!("cargo:rustc-env=GRAM_EXT_VERSION={version}");
+}
+
+fn parse_version(toml: &str) -> Option<String> {
+    for line in toml.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("version = \"") {
+            return rest.split('"').next().map(str::to_string);
+        }
+    }
+    None
+}

package/editors/zed/extension.toml

@@ -1,11 +1,16 @@
 id = "gram"
 name = "Gram Language Support"
-version = "0.3.5"
+version = "0.3.7"
 schema_version = 1
 authors = ["Gram Data Contributors"]
 description = "Support for Gram notation - composable data patterns"
 
+capabilities = [
+  { kind = "process:exec", command = "*", args = ["stdio"] },
+  { kind = "download_file", host = "github.com", path = ["gram-data", "tree-sitter-gram", "**"] },
+]
+
 # path = "grammars/tree-sitter-gram"
 [grammars.gram]
 repository = "https://github.com/gram-data/tree-sitter-gram"
-rev = "869488b6bbea325b4c4153a7a6bee97df7931a58"
+rev = "746afa9e990c3deca83dc2a2638877aef4bef4fa"

package/editors/zed/languages/gram/config.toml

@@ -12,5 +12,5 @@ word_characters = ["_"]
 [prettier]
 allowed = false
 
-# [language_servers]
-# Add language server configuration here if you develop one for Gram
+# Language servers are declared in extension.toml (`[language_servers.gram-lsp]`)
+# and started from `src/lib.rs`. Per-server options go in Zed settings.json under `lsp`.

package/editors/zed/src/lib.rs

@@ -0,0 +1,156 @@
+//! Zed extension host glue: starts `gram-lsp` from `PATH` or downloads a release asset.
+
+use zed_extension_api::{
+    self as zed,
+    github_release_by_tag_name,
+    set_language_server_installation_status,
+    Architecture, Command, DownloadedFileType, Extension, LanguageServerId,
+    LanguageServerInstallationStatus, Os, Result, Worktree, current_platform, download_file,
+    make_file_executable,
+};
+
+const GRAM_REPO: &str = "gram-data/tree-sitter-gram";
+
+struct GramExtension {
+    /// Relative path (under the extension work dir) or absolute path from `which`.
+    cached_binary: Option<String>,
+}
+
+impl GramExtension {
+    fn rust_target_triple() -> Result<&'static str> {
+        match current_platform() {
+            (Os::Mac, Architecture::Aarch64) => Ok("aarch64-apple-darwin"),
+            (Os::Mac, Architecture::X8664) => Ok("x86_64-apple-darwin"),
+            (Os::Linux, Architecture::Aarch64) => Ok("aarch64-unknown-linux-gnu"),
+            (Os::Linux, Architecture::X8664) => Ok("x86_64-unknown-linux-gnu"),
+            (Os::Windows, Architecture::Aarch64) => Ok("aarch64-pc-windows-msvc"),
+            (Os::Windows, Architecture::X8664) => Ok("x86_64-pc-windows-msvc"),
+            (Os::Linux, Architecture::X86) | (Os::Windows, Architecture::X86) => Err(
+                "gram-lsp: 32-bit platforms are not supported; install gram-lsp on PATH manually"
+                    .into(),
+            ),
+            (Os::Mac, Architecture::X86) => Err(
+                "gram-lsp: unexpected macOS x86 architecture; install gram-lsp on PATH manually"
+                    .into(),
+            ),
+        }
+    }
+
+    fn gram_lsp_bin_name(os: Os) -> &'static str {
+        match os {
+            Os::Windows => "gram-lsp.exe",
+            Os::Mac | Os::Linux => "gram-lsp",
+        }
+    }
+
+    fn ensure_downloaded(
+        &mut self,
+        language_server_id: &LanguageServerId,
+    ) -> Result<String> {
+        let version = env!("GRAM_EXT_VERSION");
+        let extract_dir = format!("gram-lsp-{version}");
+        let (os, _) = current_platform();
+        let bin_name = Self::gram_lsp_bin_name(os);
+        let relative_binary = format!("{extract_dir}/{bin_name}");
+
+        let triple = Self::rust_target_triple()?;
+        let asset_name = format!("gram-lsp-{triple}.tar.gz");
+        let tag = format!("v{version}");
+
+        set_language_server_installation_status(
+            language_server_id,
+            &LanguageServerInstallationStatus::Downloading,
+        );
+
+        let release = match github_release_by_tag_name(GRAM_REPO, &tag) {
+            Ok(r) => r,
+            Err(e) => {
+                let detail = format!(
+                    "GitHub release {tag}: {e}. Install `gram-lsp` on PATH or publish release assets (see .github/workflows/gram-lsp-release-assets.yml)."
+                );
+                set_language_server_installation_status(
+                    language_server_id,
+                    &LanguageServerInstallationStatus::Failed(detail.clone()),
+                );
+                return Err(format!("gram-lsp: no GitHub release for {tag}: {e}"));
+            }
+        };
+
+        let asset = match release.assets.iter().find(|a| a.name == asset_name) {
+            Some(a) => a,
+            None => {
+                let msg = format!(
+                    "gram-lsp: release {tag} has no asset {asset_name}. Build with the gram-lsp-release-assets workflow."
+                );
+                set_language_server_installation_status(
+                    language_server_id,
+                    &LanguageServerInstallationStatus::Failed(msg.clone()),
+                );
+                return Err(msg);
+            }
+        };
+
+        if let Err(e) = download_file(
+            &asset.download_url,
+            &extract_dir,
+            DownloadedFileType::GzipTar,
+        ) {
+            set_language_server_installation_status(
+                language_server_id,
+                &LanguageServerInstallationStatus::Failed(e.clone()),
+            );
+            return Err(format!("gram-lsp: download failed: {e}"));
+        }
+
+        if let Err(e) = make_file_executable(&relative_binary) {
+            set_language_server_installation_status(
+                language_server_id,
+                &LanguageServerInstallationStatus::Failed(e.clone()),
+            );
+            return Err(format!("gram-lsp: chmod failed: {e}"));
+        }
+
+        set_language_server_installation_status(
+            language_server_id,
+            &LanguageServerInstallationStatus::None,
+        );
+
+        self.cached_binary = Some(relative_binary.clone());
+        Ok(relative_binary)
+    }
+}
+
+impl Extension for GramExtension {
+    fn new() -> Self {
+        Self {
+            cached_binary: None,
+        }
+    }
+
+    fn language_server_command(
+        &mut self,
+        language_server_id: &LanguageServerId,
+        worktree: &Worktree,
+    ) -> Result<Command> {
+        if language_server_id.as_ref() != "gram-lsp" {
+            return Err(format!(
+                "unsupported language server id: {}",
+                language_server_id.as_ref()
+            ));
+        }
+
+        if let Some(path) = &self.cached_binary {
+            return Ok(Command::new(path).arg("stdio"));
+        }
+
+        if let Some(path) = worktree.which("gram-lsp") {
+            self.cached_binary = Some(path.clone());
+            return Ok(Command::new(path).arg("stdio"));
+        }
+
+        let path = self.ensure_downloaded(language_server_id)?;
+        Ok(Command::new(path).arg("stdio"))
+    }
+}
+
+zed::register_extension!(GramExtension);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gram-data/tree-sitter-gram",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "subject-oriented notation for structured data",
   "homepage": "https://gram-data.github.io",
   "repository": {

package/src/parser.c

@@ -4368,7 +4368,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_gram(void) {
     .metadata = {
       .major_version = 0,
       .minor_version = 3,
-      .patch_version = 5,
+      .patch_version = 7,
     },
   };
   return &language;

package/tree-sitter.json

@@ -12,7 +12,7 @@
     }
   ],
   "metadata": {
-    "version": "0.3.5",
+    "version": "0.3.7",
     "license": "ISC",
     "description": "subject-oriented notation for structured data",
     "links": {