🎉initial commit

Author: cowboyd

.github/workflows/verify.yaml

@@ -0,0 +1,55 @@
+name: Verify
+
+on:
+  push:
+    branches: main
+  pull_request:
+    branches: main
+
+permissions:
+  contents: read
+
+jobs:
+  fmt:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v3
+
+      - name: setup deno
+        uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
+
+      - name: format
+        run: deno fmt --check
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v3
+
+      - name: setup deno
+        uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
+
+      - name: lint
+        run: deno lint
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: checkout
+        uses: actions/checkout@v3
+
+      - name: setup deno
+        uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
+
+      - name: test
+        run: deno task test

.gitignore

@@ -0,0 +1 @@
+/lspx

README.md

@@ -0,0 +1,62 @@
+# lspx
+
+`lspx` is a language server multiplexer, supervisor, and interactive shell.
+
+```
+Usage: lspx [options]
+
+Options:
+  -h, --help              Show help
+  -i, --interactive       start an interactive session with a multiplexed system (default: false)
+      --lsp <string ...>  start and muliplex a server with specified command string                [required]
+```
+
+## multiplexer
+
+There are often many language servers active for a given file. For example, if
+you are editing some TypeScript for the web, you might want to run some
+combination of the following:
+
+- __typescript_ (ts) resolve symbols, provide refactorings
+- _tailwind_ (css) provides completion for tailwind utility clases
+- _eslint_ (ts) highlight warnings and errors based on project linting settings
+
+In order to provide this union of functionality, IDEs like VSCode must manage
+four separate language server processes and then handle the dispatch and
+synchronization of all edits and user inputs to each one. What this means in
+practice is that in the example above, if you hover over a symbol, that hover
+should be sent to each of the typescript, tailwind, htmx, and eslint servers.
+Then any hints, overlays that any of them have should be collated and displayed
+at that point. This is a complex process, and furthermore it is required that it
+be duplicated inside every single IDE that wants to use more than one language
+server per buffer.
+
+`lspx` combines the capabilities of any number language servers into one, so
+that each IDE only needs to interact with a single LSP connection.
+
+To run the three language servers above in unison:
+
+```
+lspx --lsp "typescript-language-server --stdio" --lsp "tailwindcss-intellisense" --lsp "eslint-lsp --stdio"
+```
+
+## supervisor
+
+`lspx` manages the language server processes that it proxies and will attempt to
+restart them if they fail. How many times and at what interval is configurable.
+
+## shell
+
+`lspx` allows you to send commands by to the set of lsp, and print their
+responses
+
+```
+lspx --lsp "deno lsp" --lsp "tailwindcss-intellisense"
+
+lspx
+|
++-> deno lsp
++-> tailwindcss-intellisense
+
+LSP> initialize({ "capabilities": {} })
+```

completions.json

@@ -0,0 +1,69 @@
+[
+  "textDocument/implementation",
+  "textDocument/typeDefinition",
+  "workspace/workspaceFolders",
+  "workspace/configuration",
+  "textDocument/documentColor",
+  "textDocument/colorPresentation",
+  "textDocument/foldingRange",
+  "workspace/foldingRange/refresh",
+  "textDocument/declaration",
+  "textDocument/selectionRange",
+  "window/workDoneProgress/create",
+  "textDocument/prepareCallHierarchy",
+  "callHierarchy/incomingCalls",
+  "callHierarchy/outgoingCalls",
+  "textDocument/semanticTokens/full",
+  "textDocument/semanticTokens/full/delta",
+  "textDocument/semanticTokens/range",
+  "workspace/semanticTokens/refresh",
+  "window/showDocument",
+  "textDocument/linkedEditingRange",
+  "workspace/willCreateFiles",
+  "workspace/willRenameFiles",
+  "workspace/willDeleteFiles",
+  "textDocument/moniker",
+  "textDocument/prepareTypeHierarchy",
+  "typeHierarchy/supertypes",
+  "typeHierarchy/subtypes",
+  "textDocument/inlineValue",
+  "workspace/inlineValue/refresh",
+  "textDocument/inlayHint",
+  "inlayHint/resolve",
+  "workspace/inlayHint/refresh",
+  "textDocument/diagnostic",
+  "workspace/diagnostic",
+  "workspace/diagnostic/refresh",
+  "textDocument/inlineCompletion",
+  "client/registerCapability",
+  "client/unregisterCapability",
+  "initialize",
+  "shutdown",
+  "window/showMessageRequest",
+  "textDocument/willSaveWaitUntil",
+  "textDocument/completion",
+  "completionItem/resolve",
+  "textDocument/hover",
+  "textDocument/signatureHelp",
+  "textDocument/definition",
+  "textDocument/references",
+  "textDocument/documentHighlight",
+  "textDocument/documentSymbol",
+  "textDocument/codeAction",
+  "codeAction/resolve",
+  "workspace/symbol",
+  "workspaceSymbol/resolve",
+  "textDocument/codeLens",
+  "codeLens/resolve",
+  "workspace/codeLens/refresh",
+  "textDocument/documentLink",
+  "documentLink/resolve",
+  "textDocument/formatting",
+  "textDocument/rangeFormatting",
+  "textDocument/rangesFormatting",
+  "textDocument/onTypeFormatting",
+  "textDocument/rename",
+  "textDocument/prepareRename",
+  "workspace/executeCommand",
+  "workspace/applyEdit"
+]

deno.json

@@ -0,0 +1,20 @@
+{
+  "name": "@frontside/lspx",
+  "tasks": {
+    "dev": "deno run --allow-env --allow-run main.ts",
+    "compile": "deno compile -o lspx --allow-env --allow-run main.ts"
+  },
+  "imports": {
+    "effection": "jsr:@effection/effection@^4.0.0-alpha.7",
+    "@std/assert": "jsr:@std/assert@1",
+    "vscode-jsonrpc": "npm:vscode-jsonrpc@^8.2.1",
+    "zod": "npm:zod@^3.24.2",
+    "zod-opts": "npm:zod-opts@^0.1.8"
+  },
+  "exports": "./mod.ts",
+  "lint": {
+    "rules": {
+      "exclude": ["prefer-const", "require-yield"]
+    }
+  }
+}

deno.lock

@@ -0,0 +1,98 @@
+import {
+  call,
+  createSignal,
+  main,
+  type Operation,
+  resource,
+  type Stream,
+} from "effection";
+
+import * as rpc from "vscode-jsonrpc/node.js";
+import { Readable, Writable } from "node:stream";
+import { createInterface } from "node:readline";
+import * as z from "zod";
+import { parser } from "zod-opts";
+
+await main(function* (argv) {
+  let opts = parser()
+    .name("lspx")
+    .options({
+      "interactive": {
+        type: z.boolean().default(false),
+        alias: "i",
+        description: "start an interactive session with a multiplexed system",
+      },
+      "lsp": {
+        type: z.array(z.string()),
+        description: "start and muliplex a server with specified command string",
+      },
+    }).parse(argv);
+  console.log(opts);
+});
+
+export function useCommand(
+  ...params: ConstructorParameters<typeof Deno.Command>
+): Operation<Deno.ChildProcess> {
+  let [name, options] = params;
+  return resource(function* (provide) {
+    let controller = new AbortController();
+    let { signal } = controller;
+    let command = new Deno.Command(name, {
+      ...options,
+      signal,
+    });
+    let process = command.spawn();
+    try {
+      yield* provide(process);
+    } finally {
+      controller.abort();
+      yield* call(() => process.status);
+    }
+  });
+}
+
+export interface ConnectionOptions {
+  write: WritableStream<Uint8Array>;
+  read: ReadableStream<Uint8Array>;
+}
+
+export function useConnection(
+  options: ConnectionOptions,
+): Operation<rpc.MessageConnection> {
+  return resource(function* (provide) {
+    const connection = rpc.createMessageConnection(
+      //@ts-expect-error 🤷
+      new rpc.StreamMessageReader(Readable.fromWeb(options.read)),
+      new rpc.StreamMessageWriter(Writable.fromWeb(options.write)),
+    );
+    connection.listen();
+    try {
+      yield* provide(connection);
+    } finally {
+      connection.dispose();
+    }
+  });
+}
+
+export function useReadline(
+  ...args: Parameters<typeof createInterface>
+): Stream<string, never> {
+  return resource(function* (provide) {
+    let rl = createInterface(...args);
+    let lines = createSignal<string, never>();
+
+    let subscription = yield* lines;
+    try {
+      rl.on("line", lines.send);
+      yield* provide({
+        *next() {
+          rl.prompt();
+          return yield* subscription.next();
+        },
+      });
+    } finally {
+      rl.off("line", lines.send);
+      rl.close();
+    }
+  });
+}