@tsuzuri-lab/sed-language-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tsuzuri-lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# sed-language-server
+
+[![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.
+
+## Features
+
+The server provides:
+
+- profile-aware diagnostics for supported POSIX and GNU sed syntax
+- profile-aware command, substitute-flag, and branch-label completion
+- go to definition from `b`, `t`, and GNU `T` label references
+
+It analyzes scripts without executing them, running shell commands, or
+accessing referenced files.
+
+## Syntax profiles
+
+The supported profile values are:
+
+- `dialect`: `posix` or `gnu`
+- `regexpMode`: `bre` or `ere`
+
+Clients can select a profile during initialization:
+
+```json
+{
+  "initializationOptions": {
+    "dialect": "gnu",
+    "regexpMode": "bre"
+  }
+}
+```
+
+They can change it for all open documents through
+`workspace/didChangeConfiguration`:
+
+```json
+{
+  "settings": {
+    "sedLanguageServer": {
+      "dialect": "gnu",
+      "regexpMode": "ere"
+    }
+  }
+}
+```
+
+Omitted settings select `posix` and `bre`. The server does not infer a dialect
+from document contents.
+
+## Development
+
+```sh
+npm ci
+npm run check
+npm test
+npm start
+```
+
+## License
+
+[MIT](LICENSE)

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@tsuzuri-lab/sed-language-server",
+  "version": "0.1.0",
+  "description": "Language server for POSIX sed with opt-in GNU syntax support.",
+  "keywords": [
+    "sed",
+    "language-server",
+    "lsp"
+  ],
+  "type": "module",
+  "files": [
+    "src"
+  ],
+  "bin": {
+    "sed-language-server": "src/server.js"
+  },
+  "scripts": {
+    "check": "biome check .",
+    "check:write": "biome check --write .",
+    "prepublishOnly": "npm run check && npm test",
+    "start": "node src/server.js --stdio",
+    "test": "node --test"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tsuzuri-lab/sed-language-server.git"
+  },
+  "homepage": "https://github.com/tsuzuri-lab/sed-language-server#readme",
+  "bugs": {
+    "url": "https://github.com/tsuzuri-lab/sed-language-server/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "vscode-languageserver": "^10.1.0",
+    "vscode-languageserver-textdocument": "^1.0.12"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.5"
+  }
+}

package/src/completion.js

@@ -0,0 +1,148 @@
+import {
+  CompletionItemKind,
+  InsertTextFormat,
+} from "vscode-languageserver/node";
+import { getDocumentStructure } from "./document-structure.js";
+import {
+  commandSpecificationsFor,
+  substituteFlagSpecificationsFor,
+} from "./sed-syntax.js";
+import {
+  defaultSyntaxProfile,
+  requireSyntaxProfile,
+} from "./syntax-profile.js";
+
+function plainCompletion(label, kind, documentation) {
+  return {
+    label,
+    kind,
+    insertText: label,
+    insertTextFormat: InsertTextFormat.PlainText,
+    documentation,
+  };
+}
+
+const commandCompletionsByProfile = new Map();
+const substituteFlagCompletionsByProfile = new Map();
+
+function commandCompletionsFor(syntaxProfile) {
+  let completions = commandCompletionsByProfile.get(syntaxProfile);
+  if (completions !== undefined) {
+    return completions;
+  }
+
+  completions = [
+    plainCompletion(
+      ";",
+      CompletionItemKind.Keyword,
+      "Insert an empty command and begin the next command.",
+    ),
+    ...commandSpecificationsFor(syntaxProfile).map(
+      ({ command, documentation }) =>
+        plainCompletion(command, CompletionItemKind.Keyword, documentation),
+    ),
+  ];
+  commandCompletionsByProfile.set(syntaxProfile, completions);
+  return completions;
+}
+
+function substituteFlagCompletionsFor(syntaxProfile) {
+  let completions = substituteFlagCompletionsByProfile.get(syntaxProfile);
+  if (completions !== undefined) {
+    return completions;
+  }
+
+  completions = [
+    ...Array.from({ length: 9 }, (_, index) => {
+      const occurrence = String(index + 1);
+      return plainCompletion(
+        occurrence,
+        CompletionItemKind.Value,
+        `Replace only occurrence number ${occurrence}.`,
+      );
+    }),
+    ...substituteFlagSpecificationsFor(syntaxProfile).map(
+      ({ flag, documentation }) =>
+        plainCompletion(flag, CompletionItemKind.Keyword, documentation),
+    ),
+  ];
+  substituteFlagCompletionsByProfile.set(syntaxProfile, completions);
+  return completions;
+}
+
+export const completionProviderOptions = Object.freeze({});
+
+function branchLabelEditRange(document, context, offset) {
+  const replacementRange = context.replacementRange ?? {
+    startOffset: offset,
+    endOffset: offset,
+  };
+  const startOffset = Math.min(replacementRange.startOffset, offset);
+  const endOffset = Math.max(replacementRange.endOffset, offset);
+
+  return {
+    start: document.positionAt(startOffset),
+    end: document.positionAt(endOffset),
+  };
+}
+
+export function createCompletions(
+  document,
+  position,
+  options = defaultSyntaxProfile,
+) {
+  const syntaxProfile = requireSyntaxProfile(options);
+  const structure = getDocumentStructure(document, syntaxProfile);
+  const offset = document.offsetAt(position);
+  const context = structure.contextDetailsAt(offset);
+
+  if (context?.kind === "command") {
+    return commandCompletionsFor(syntaxProfile).map((completion) => ({
+      ...completion,
+    }));
+  }
+
+  if (context?.kind === "substitute-flag") {
+    return substituteFlagCompletionsFor(syntaxProfile).map((completion) => ({
+      ...completion,
+    }));
+  }
+
+  if (context?.kind !== "branch-label") {
+    return [];
+  }
+
+  const names = new Set();
+  const completions = [];
+  const editRange = branchLabelEditRange(document, context, offset);
+  for (const definition of structure.labelDefinitions) {
+    if (names.has(definition.name)) {
+      continue;
+    }
+
+    names.add(definition.name);
+    completions.push({
+      label: definition.name,
+      kind: CompletionItemKind.Reference,
+      insertTextFormat: InsertTextFormat.PlainText,
+      documentation: "Branch label defined in this document.",
+      textEdit: {
+        range: editRange,
+        newText: definition.name,
+      },
+    });
+  }
+  return completions;
+}
+
+export function createCompletionHandler(
+  documents,
+  getSyntaxProfile = () => defaultSyntaxProfile,
+) {
+  return ({ textDocument, position }) => {
+    const document = documents.get(textDocument.uri);
+    return document === undefined
+      ? null
+      : createCompletions(document, position, getSyntaxProfile());
+  };
+}

package/src/definition.js

@@ -0,0 +1,46 @@
+import { getDocumentStructure } from "./document-structure.js";
+import { defaultSyntaxProfile } from "./syntax-profile.js";
+
+export const definitionProvider = true;
+
+function containsCursor(range, offset) {
+  return range.startOffset <= offset && offset <= range.endOffset;
+}
+
+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),
+  );
+
+  if (reference === undefined) {
+    return [];
+  }
+
+  return structure.labelDefinitions
+    .filter((definition) => definition.name === reference.name)
+    .map((definition) => ({
+      uri: document.uri,
+      range: {
+        start: document.positionAt(definition.range.startOffset),
+        end: document.positionAt(definition.range.endOffset),
+      },
+    }));
+}
+
+export function createDefinitionHandler(
+  documents,
+  getSyntaxProfile = () => defaultSyntaxProfile,
+) {
+  return ({ textDocument, position }) => {
+    const document = documents.get(textDocument.uri);
+    return document === undefined
+      ? null
+      : createDefinitionLocations(document, position, getSyntaxProfile());
+  };
+}