@tabnas/lsp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tabnas
+
+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,51 @@
+# @tabnas/lsp
+
+The tabnas language server and language-server generator.
+
+One LSP server serves **every** tabnas grammar — fleet plugins,
+serialized `GrammarSpec` data, or BNF-dialect text added dynamically
+through workspace configuration — and the same machinery **generates**
+standalone single-language servers (Node packages or Go binaries) plus
+the editor plugins to use them, from one parser module or grammar.
+
+```bash
+# the unified server, over stdio
+npx --package=@tabnas/lsp tabnas-lsp --stdio
+
+# a branded single-language server + editor plugins
+npx --package=@tabnas/lsp tabnas-lsp-gen \
+  --spec my-grammar.json --language-id mydsl --out mydsl-tools
+```
+
+`--package` is required either way: this package ships two binaries and
+neither is named `@tabnas/lsp`, so the package-name form of `npx` cannot
+pick one, and a bare `npx tabnas-lsp-gen` would fetch an unrelated
+registry package.
+
+## What it provides
+
+Diagnostics, semantic tokens, document symbols (outline) and completion,
+over incremental `didChange` sync, for any grammar the registry can
+reach. Grammars can be added without rebuilding the server: an installed
+plugin module, a serialized `GrammarSpec`, or a BNF dialect compiled at
+load time, declared per workspace folder and reloaded when the file
+changes.
+
+## Engine
+
+Requires a `@tabnas/parser` providing the LSP engine contract —
+recovery, `ruleDone` and `continuations`. The peer range is open by fleet
+convention, but the contract is newer than the current published engine;
+see `AGENTS.md` in the repository for the release constraint that
+applies before this package is published.
+
+## Documentation
+
+Full design, the dynamism ladder, the generator matrix and the security
+model are in [`doc/design.md`](https://github.com/tabnas/lsp/blob/main/doc/design.md).
+Contributor and agent guidance is in
+[`AGENTS.md`](https://github.com/tabnas/lsp/blob/main/AGENTS.md).
+
+## License
+
+MIT

package/bin/tabnas-lsp-gen.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+'use strict'
+
+// tabnas-lsp-gen: generate a standalone single-language LSP server —
+// Node package or Go module — plus editor plugins, from one grammar
+// (design §7). A deliberately separate bin from tabnas-lsp: a
+// generator argument bug must never break editor launches.
+
+const { generate, ALL_EDITORS } = require('../src/generate')
+
+const USAGE = `usage: tabnas-lsp-gen --out <dir> <input> [options]
+
+input (exactly one):
+  --entry <languageId>     a bundled fleet registry entry
+  --module <npm-name>      a tabnas plugin module (Node runtime only)
+  --spec <file.json>       a serialized GrammarSpec (pure data)
+  --grammar <file>         BNF-dialect text (.abnf | .ebnf | .gbnf)
+
+options:
+  --out <dir>              target directory (required)
+  --language-id <id>       served language id (derived when omitted)
+  --extensions <.a,.b>     file extensions (default: .<language-id>)
+  --runtime <node|go>      server runtime (default: node)
+  --editors <list|none>    ${ALL_EDITORS.join(',')} (default: all)
+  --unified                editor plugins for the whole bundled
+                           registry over tabnas-lsp itself (no server)
+
+go runtime:
+  --go-module <path>          generated module path
+  --go-plugin <import>        Go plugin package (closure/imperative grammars)
+  --go-plugin-func <Name>     plugin function (default: id CamelCased with
+                              non-identifier characters removed)
+  --go-plugin-version <vX.Y.Z> pin the plugin require (otherwise
+                              \`go mod tidy\` resolves it from the import)
+  --go-lsp-version <vX.Y.Z>   pin the github.com/tabnas/lsp/go require
+  --go-parser-version <vX.Y.Z> pin the github.com/tabnas/parser/go require
+  --go-replace <mod=dir>      replace directive for local dev (repeatable)
+`
+
+function parseArgs(argv) {
+  const opts = { input: {}, goReplace: [] }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    const next = () => {
+      if (i + 1 >= argv.length) throw new Error(a + ' needs a value')
+      return argv[++i]
+    }
+    switch (a) {
+      case '--out': opts.out = next(); break
+      case '--entry': opts.input.entry = next(); break
+      case '--module': opts.input.module = next(); break
+      case '--spec': opts.input.spec = next(); break
+      case '--grammar': opts.input.grammar = next(); break
+      case '--language-id': opts.languageId = next(); break
+      case '--extensions':
+        opts.extensions = next().split(',').map((x) =>
+          x.startsWith('.') ? x : '.' + x)
+        break
+      case '--runtime': opts.runtime = next(); break
+      case '--editors': {
+        const v = next()
+        opts.editors = 'none' === v ? [] : v.split(',')
+        break
+      }
+      case '--unified': opts.unified = true; break
+      case '--go-module': opts.goModule = next(); break
+      case '--go-plugin': opts.goPlugin = next(); break
+      case '--go-plugin-func': opts.goPluginFunc = next(); break
+      case '--go-plugin-version': opts.goPluginVersion = next(); break
+      case '--go-lsp-version': opts.goLspVersion = next(); break
+      case '--go-parser-version': opts.goParserVersion = next(); break
+      case '--go-replace': opts.goReplace.push(next()); break
+      case '--help': case '-h':
+        console.log(USAGE)
+        process.exit(0)
+        break
+      default:
+        throw new Error('unknown option: ' + a + '\n\n' + USAGE)
+    }
+  }
+  return opts
+}
+
+try {
+  const opts = parseArgs(process.argv.slice(2))
+  if (!opts.out) throw new Error('--out is required\n\n' + USAGE)
+  const inputs = Object.keys(opts.input).length
+  if (!opts.unified && 1 !== inputs) {
+    throw new Error('exactly one input is required\n\n' + USAGE)
+  }
+  const { files, out } = generate(opts)
+  console.log('generated ' + files.length + ' files under ' + out + ':')
+  for (const f of files) console.log('  ' + f)
+} catch (e) {
+  console.error('tabnas-lsp-gen: ' + e.message)
+  process.exitCode = 1
+}

package/bin/tabnas-lsp.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/* Copyright (c) 2026 Richard Rodger, MIT License */
+'use strict'
+
+// tabnas-lsp --stdio : the unified tabnas language server.
+const { startServer } = require('../src/server')
+startServer()