@tsuzuri-lab/sed-language-server 0.1.2 → 0.3.0

package/README.md

@@ -2,13 +2,7 @@
 
 [![CI](https://github.com/tsuzuri-lab/sed-language-server/actions/workflows/ci.yml/badge.svg)](https://github.com/tsuzuri-lab/sed-language-server/actions/workflows/ci.yml)
 
-A [Language Server Protocol](https://microsoft.github.io/language-server-protocol/)
-implementation for
-[POSIX `sed`](https://pubs.opengroup.org/onlinepubs/9799919799.2024edition/utilities/sed.html)
-with opt-in GNU sed 4.10 syntax support.
-
-The default profile is POSIX with basic regular expressions. BSD and
-other implementation-specific extensions are outside the current scope.
+A Language Server Protocol implementation for POSIX and GNU `sed`.
 
 ## Installation
 
@@ -18,7 +12,7 @@ Requires Node.js 22 or later.
 npm install --global @tsuzuri-lab/sed-language-server
 ```
 
-Configure the LSP client to start the server with:
+Start the server with:
 
 ```sh
 sed-language-server --stdio
@@ -26,49 +20,60 @@ sed-language-server --stdio
 
 ## Features
 
-The server provides:
-
-- profile-aware diagnostics for supported POSIX and GNU sed syntax
-- profile-aware command, substitute-flag, and branch-label completion
+- Tree-sitter-based diagnostics
 - go to definition from `b`, `t`, and GNU `T` label references
+- document formatting for command lists and nested blocks
 
-It analyzes scripts without executing them, running shell commands, or
-accessing referenced files.
-
-## Syntax profiles
+Scripts are analyzed without executing them or accessing referenced files.
 
-The supported profile values are:
+## Configuration
 
-- `dialect`: `posix` or `gnu`
-- `regexpMode`: `bre` or `ere`
-
-Clients can select a profile during initialization:
+The default dialect is `posix`. To use GNU syntax, pass the following LSP
+initialization options:
 
 ```json
 {
-  "initializationOptions": {
-    "dialect": "gnu",
-    "regexpMode": "bre"
-  }
+  "dialect": "gnu"
 }
 ```
 
-They can change it for all open documents through
-`workspace/didChangeConfiguration`:
+The supported dialects are `posix` and `gnu`.
 
-```json
-{
-  "settings": {
-    "sedLanguageServer": {
-      "dialect": "gnu",
-      "regexpMode": "ere"
-    }
-  }
-}
+## Editor setup
+
+Configure the LSP client to use:
+
+- command: `sed-language-server --stdio`
+- language ID or filetype: `sed`
+- initialization options: `{"dialect":"gnu"}` when using GNU syntax
+
+For example, with Emacs and Eglot:
+
+```elisp
+(require 'eglot)
+
+(add-to-list 'eglot-server-programs
+             '((sed-ts-mode sed-mode) .
+               ("sed-language-server" "--stdio"
+                :initializationOptions (:dialect "gnu"))))
+```
+
+Run `M-x eglot` in a `sed-ts-mode` or `sed-mode` buffer. Omit
+`:initializationOptions` to use the default POSIX dialect.
+
+For Neovim 0.11 or later:
+
+```lua
+vim.lsp.config("sed_language_server", {
+  cmd = { "sed-language-server", "--stdio" },
+  filetypes = { "sed" },
+  init_options = { dialect = "gnu" },
+})
+
+vim.lsp.enable("sed_language_server")
 ```
 
-Omitted settings select `posix` and `bre`. The server does not infer a dialect
-from document contents.
+Omit `init_options` to use the default POSIX dialect.
 
 ## Development
 
@@ -76,7 +81,13 @@ from document contents.
 npm ci
 npm run check
 npm test
-npm start
+```
+
+The published package includes prebuilt POSIX and GNU grammar Wasm files.
+Rebuild them from the pinned `tree-sitter-sed` revision with:
+
+```sh
+npm run build:grammar -- /path/to/tree-sitter-sed
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsuzuri-lab/sed-language-server",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Language server for POSIX sed with opt-in GNU syntax support.",
   "keywords": [
     "sed",
@@ -9,12 +9,14 @@
   ],
   "type": "module",
   "files": [
-    "src"
+    "src",
+    "vendor"
   ],
   "bin": {
     "sed-language-server": "src/server.js"
   },
   "scripts": {
+    "build:grammar": "node scripts/build-tree-sitter-sed-wasm.js",
     "check": "biome check .",
     "check:write": "biome check --write .",
     "prepublishOnly": "npm run check && npm test",
@@ -38,9 +40,11 @@
   },
   "dependencies": {
     "vscode-languageserver": "10.1.0",
-    "vscode-languageserver-textdocument": "1.0.12"
+    "vscode-languageserver-textdocument": "1.0.12",
+    "web-tree-sitter": "0.26.11"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.5"
+    "@biomejs/biome": "2.5.5",
+    "tree-sitter-cli": "0.26.11"
   }
 }

package/src/definition.js

@@ -1,46 +1,44 @@
-import { getDocumentStructure } from "./document-structure.js";
-import { defaultSyntaxProfile } from "./syntax-profile.js";
+import { rangeForNode, syntaxTreeFor } from "./syntax.js";
 
-export const definitionProvider = true;
+function collectLabels(rootNode, offset) {
+  const definitions = [];
+  let reference;
+  const stack = [rootNode];
 
-function containsCursor(range, offset) {
-  return range.startOffset <= offset && offset <= range.endOffset;
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "label_definition") {
+      definitions.push(node);
+    } else if (
+      node.type === "label_reference" &&
+      node.startIndex <= offset &&
+      offset < node.endIndex
+    ) {
+      reference = node;
+    }
+    stack.push(...node.children.toReversed());
+  }
+
+  return { definitions, reference };
 }
 
-export function createDefinitionLocations(
-  document,
-  position,
-  syntaxProfile = defaultSyntaxProfile,
-) {
-  const structure = getDocumentStructure(document, syntaxProfile);
-  const offset = document.offsetAt(position);
-  const reference = structure.labelReferences.find(({ range }) =>
-    containsCursor(range, offset),
+export function createDefinitionLocations(document, position, dialect) {
+  const tree = syntaxTreeFor(document, dialect);
+  const { definitions, reference } = collectLabels(
+    tree.rootNode,
+    document.offsetAt(position),
   );
 
   if (reference === undefined) {
-    return [];
+    return null;
   }
 
-  return structure.labelDefinitions
-    .filter((definition) => definition.name === reference.name)
+  const locations = definitions
+    .filter((definition) => definition.text === reference.text)
     .map((definition) => ({
       uri: document.uri,
-      range: {
-        start: document.positionAt(definition.range.startOffset),
-        end: document.positionAt(definition.range.endOffset),
-      },
+      range: rangeForNode(document, definition),
     }));
-}
 
-export function createDefinitionHandler(
-  documents,
-  getSyntaxProfile = () => defaultSyntaxProfile,
-) {
-  return ({ textDocument, position }) => {
-    const document = documents.get(textDocument.uri);
-    return document === undefined
-      ? null
-      : createDefinitionLocations(document, position, getSyntaxProfile());
-  };
+  return locations.length === 0 ? null : locations;
 }