@blokjs/lsp-server 0.2.0

package/dist/server.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const node_1 = require("vscode-languageserver/node");
+const completion_1 = require("./completion");
+const diagnostics_1 = require("./diagnostics");
+const hover_1 = require("./hover");
+/**
+ * Blok Workflow Language Server
+ *
+ * Provides workflow intelligence for any LSP-compatible editor:
+ * - Diagnostics: Real-time validation of workflow JSON files
+ * - Completion: Contextual auto-completion for triggers, steps, runtimes, etc.
+ * - Hover: Rich documentation on hover for workflow fields and values
+ *
+ * Communication: stdio (default) or TCP
+ * File types: JSON files matching `**​/workflows/**​/*.json` or `blok.workflow.json`
+ */
+// Create connection and document manager
+const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
+let hasConfigurationCapability = false;
+let hasWorkspaceFolderCapability = false;
+const defaultSettings = {
+    workflowGlob: "**/workflows/**/*.json",
+    maxDiagnostics: 100,
+};
+let globalSettings = defaultSettings;
+const documentSettings = new Map();
+connection.onInitialize((params) => {
+    const capabilities = params.capabilities;
+    hasConfigurationCapability = !!(capabilities.workspace && capabilities.workspace.configuration);
+    hasWorkspaceFolderCapability = !!(capabilities.workspace && capabilities.workspace.workspaceFolders);
+    const result = {
+        capabilities: {
+            textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
+            completionProvider: {
+                resolveProvider: false,
+                triggerCharacters: ['"', ":"],
+            },
+            hoverProvider: true,
+        },
+    };
+    if (hasWorkspaceFolderCapability) {
+        result.capabilities.workspace = {
+            workspaceFolders: {
+                supported: true,
+            },
+        };
+    }
+    return result;
+});
+connection.onInitialized(() => {
+    if (hasConfigurationCapability) {
+        connection.client.register(node_1.DidChangeConfigurationNotification.type, undefined);
+    }
+});
+// Configuration handling
+connection.onDidChangeConfiguration((change) => {
+    if (hasConfigurationCapability) {
+        documentSettings.clear();
+    }
+    else {
+        globalSettings = change.settings?.blok || defaultSettings;
+    }
+    // Revalidate all open documents
+    for (const doc of documents.all()) {
+        validateDocument(doc);
+    }
+});
+function getDocumentSettings(resource) {
+    if (!hasConfigurationCapability) {
+        return globalSettings;
+    }
+    let result = documentSettings.get(resource);
+    if (!result) {
+        result = globalSettings;
+        documentSettings.set(resource, result);
+    }
+    return result;
+}
+// Document validation
+function isWorkflowFile(uri) {
+    // Match workflow files by path pattern
+    return /workflows?[/\\].*\.json$/i.test(uri) || /\.workflow\.json$/i.test(uri) || /blok\.json$/i.test(uri);
+}
+function validateDocument(document) {
+    if (!isWorkflowFile(document.uri))
+        return;
+    const text = document.getText();
+    const diagnostics = (0, diagnostics_1.validateWorkflow)(text);
+    const settings = getDocumentSettings(document.uri);
+    // Limit diagnostics if configured
+    const limited = diagnostics.slice(0, settings.maxDiagnostics);
+    connection.sendDiagnostics({ uri: document.uri, diagnostics: limited });
+}
+// Validate on open and change
+documents.onDidChangeContent((change) => {
+    validateDocument(change.document);
+});
+documents.onDidClose((event) => {
+    documentSettings.delete(event.document.uri);
+    connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+});
+// Completion
+connection.onCompletion((params) => {
+    const document = documents.get(params.textDocument.uri);
+    if (!document)
+        return [];
+    if (!isWorkflowFile(document.uri))
+        return [];
+    const text = document.getText();
+    const offset = document.offsetAt(params.position);
+    return (0, completion_1.getCompletions)(text, offset);
+});
+// Hover
+connection.onHover((params) => {
+    const document = documents.get(params.textDocument.uri);
+    if (!document)
+        return null;
+    if (!isWorkflowFile(document.uri))
+        return null;
+    const text = document.getText();
+    return (0, hover_1.getHover)(text, params.position.line, params.position.character);
+});
+// Start listening
+documents.listen(connection);
+connection.listen();
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/editors/emacs-lsp.el

@@ -0,0 +1,21 @@
+;;; blok-lsp.el --- Blok Workflow LSP integration for Emacs
+;;
+;; Add this to your Emacs config (init.el or .emacs)
+;; Requires: lsp-mode (https://emacs-lsp.github.io/lsp-mode/)
+;; Install: npm install -g @blok/lsp-server
+
+(with-eval-after-load 'lsp-mode
+  ;; Register the Blok LSP server
+  (lsp-register-client
+   (make-lsp-client
+    :new-connection (lsp-stdio-connection '("blok-lsp" "--stdio"))
+    :activation-fn (lsp-activate-on "json")
+    :server-id 'blok-lsp
+    :priority -1
+    :initialization-options
+    '((blok
+       (workflowGlob . "**/workflows/**/*.json")
+       (maxDiagnostics . 100)))))
+
+  ;; Add to the auto-start list
+  (add-to-list 'lsp-language-id-configuration '(json-mode . "json")))

package/editors/helix-languages.toml

@@ -0,0 +1,12 @@
+# Blok Workflow LSP - Helix Editor Configuration
+#
+# Add this to your Helix config: ~/.config/helix/languages.toml
+# Requires: npm install -g @blok/lsp-server
+
+[[language]]
+name = "json"
+language-servers = ["blok-lsp"]
+
+[language-server.blok-lsp]
+command = "blok-lsp"
+args = ["--stdio"]

package/editors/neovim.lua

@@ -0,0 +1,59 @@
+-- Blok Workflow LSP - Neovim Configuration
+--
+-- Add this to your Neovim config (init.lua or lua/plugins/blok.lua)
+-- Requires: nvim-lspconfig (https://github.com/neovim/nvim-lspconfig)
+--
+-- Option 1: Install globally
+--   npm install -g @blok/lsp-server
+--
+-- Option 2: Use from project
+--   npx blok-lsp (runs from node_modules)
+
+local lspconfig = require("lspconfig")
+local configs = require("lspconfig.configs")
+
+-- Register the Blok LSP server if not already registered
+if not configs.blok_lsp then
+	configs.blok_lsp = {
+		default_config = {
+			-- Use global install or npx
+			cmd = { "blok-lsp", "--stdio" },
+			-- Alternative: use npx (slower startup, no global install needed)
+			-- cmd = { "npx", "blok-lsp", "--stdio" },
+			filetypes = { "json" },
+			root_dir = lspconfig.util.root_pattern(
+				"blok.json",
+				"blokctl.config.ts",
+				"blokctl.config.js",
+				"package.json"
+			),
+			settings = {
+				blok = {
+					workflowGlob = "**/workflows/**/*.json",
+					maxDiagnostics = 100,
+				},
+			},
+			-- Only activate for workflow JSON files
+			on_new_config = function(new_config, new_root_dir)
+				-- The LSP server itself filters by file path pattern
+			end,
+		},
+	}
+end
+
+-- Setup the LSP server
+lspconfig.blok_lsp.setup({
+	on_attach = function(client, bufnr)
+		-- Enable completion triggered by <c-x><c-o>
+		vim.bo[bufnr].omnifunc = "v:lua.vim.lsp.omnifunc"
+
+		-- Keybindings for LSP features
+		local opts = { buffer = bufnr, noremap = true, silent = true }
+		vim.keymap.set("n", "K", vim.lsp.buf.hover, opts)
+		vim.keymap.set("n", "<leader>ca", vim.lsp.buf.code_action, opts)
+		vim.keymap.set("n", "[d", vim.diagnostic.goto_prev, opts)
+		vim.keymap.set("n", "]d", vim.diagnostic.goto_next, opts)
+		vim.keymap.set("n", "<leader>e", vim.diagnostic.open_float, opts)
+	end,
+	capabilities = vim.lsp.protocol.make_client_capabilities(),
+})

package/editors/sublime-lsp.json

@@ -0,0 +1,16 @@
+{
+	"clients": {
+		"blok-lsp": {
+			"enabled": true,
+			"command": ["blok-lsp", "--stdio"],
+			"selector": "source.json",
+			"initializationOptions": {
+				"blok": {
+					"workflowGlob": "**/workflows/**/*.json",
+					"maxDiagnostics": 100
+				}
+			},
+			"settings": {}
+		}
+	}
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@blokjs/lsp-server",
+	"version": "0.2.0",
+	"description": "Language Server Protocol server for Blok workflow files - provides diagnostics, completion, and hover documentation for any LSP-compatible editor",
+	"license": "Apache-2.0",
+	"main": "./dist/server.js",
+	"bin": {
+		"blok-lsp": "./dist/server.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"watch": "tsc --watch",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	},
+	"dependencies": {
+		"vscode-languageserver": "^9.0.1",
+		"vscode-languageserver-textdocument": "^1.0.12"
+	},
+	"devDependencies": {
+		"@types/node": "^22.15.21",
+		"typescript": "^5.8.3",
+		"vitest": "^4.0.18"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"keywords": [
+		"blok",
+		"lsp",
+		"language-server",
+		"workflow",
+		"json",
+		"blok"
+	],
+	"private": false,
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/src/__tests__/completion.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from "vitest";
+import { CompletionItemKind } from "vscode-languageserver";
+import { getCompletions } from "../completion";
+
+function getOffset(text: string): number {
+	// Returns the offset at the end of the text
+	return text.length;
+}
+
+describe("WorkflowCompletionProvider (LSP)", () => {
+	describe("trigger type completions", () => {
+		it("should provide trigger type completions inside trigger object", () => {
+			const content = '{\n  "trigger": {\n    "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("http");
+			expect(labels).toContain("grpc");
+			expect(labels).toContain("cron");
+			expect(labels).toContain("queue");
+			expect(labels).toContain("pubsub");
+			expect(labels).toContain("worker");
+			expect(labels).toContain("webhook");
+			expect(labels).toContain("websocket");
+			expect(labels).toContain("sse");
+		});
+	});
+
+	describe("HTTP method completions", () => {
+		it("should provide HTTP method completions for method key in trigger", () => {
+			const content = '{\n  "trigger": {\n    "http": {\n      "method": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("GET");
+			expect(labels).toContain("POST");
+			expect(labels).toContain("PUT");
+			expect(labels).toContain("DELETE");
+			expect(labels).toContain("PATCH");
+			expect(labels).toContain("ANY");
+		});
+	});
+
+	describe("step type completions", () => {
+		it("should provide step type completions inside steps", () => {
+			const content = '{\n  "steps": [\n    {\n      "type": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("module");
+			expect(labels).toContain("local");
+			expect(labels).toContain("runtime.nodejs");
+			expect(labels).toContain("runtime.python3");
+			expect(labels).toContain("runtime.go");
+			expect(labels).toContain("runtime.java");
+			expect(labels).toContain("runtime.rust");
+		});
+	});
+
+	describe("runtime completions", () => {
+		it("should provide runtime completions", () => {
+			const content = '{\n  "steps": [\n    {\n      "runtime": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("nodejs");
+			expect(labels).toContain("python3");
+			expect(labels).toContain("go");
+			expect(labels).toContain("java");
+			expect(labels).toContain("rust");
+			expect(labels).toContain("docker");
+			expect(labels).toContain("wasm");
+		});
+	});
+
+	describe("node package completions", () => {
+		it("should provide node completions for node key", () => {
+			const content = '{\n  "steps": [\n    {\n      "node": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("@blokjs/api-call");
+			expect(labels).toContain("@blokjs/if-else");
+			expect(labels).toContain("@blokjs/react");
+		});
+
+		it("should use Module kind for node packages", () => {
+			const content = '{\n  "steps": [\n    {\n      "node": "';
+			const items = getCompletions(content, getOffset(content));
+			const apiCall = items.find((i) => i.label === "@blokjs/api-call");
+			expect(apiCall?.kind).toBe(CompletionItemKind.Module);
+		});
+	});
+
+	describe("queue provider completions", () => {
+		it("should provide queue provider completions", () => {
+			const content = '{\n  "trigger": {\n    "queue": {\n      "provider": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("kafka");
+			expect(labels).toContain("rabbitmq");
+			expect(labels).toContain("sqs");
+			expect(labels).toContain("redis");
+		});
+	});
+
+	describe("pubsub provider completions", () => {
+		it("should provide pubsub provider completions", () => {
+			const content = '{\n  "trigger": {\n    "pubsub": {\n      "provider": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("gcp");
+			expect(labels).toContain("aws");
+			expect(labels).toContain("azure");
+			expect(labels).toContain("nats");
+		});
+	});
+
+	describe("webhook source completions", () => {
+		it("should provide webhook source completions", () => {
+			const content = '{\n  "trigger": {\n    "webhook": {\n      "source": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("github");
+			expect(labels).toContain("stripe");
+			expect(labels).toContain("shopify");
+			expect(labels).toContain("custom");
+		});
+	});
+
+	describe("condition type completions", () => {
+		it("should provide condition type completions", () => {
+			const content = '{\n  "nodes": {\n    "filter": {\n      "conditions": [\n        {\n          "type": "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("if");
+			expect(labels).toContain("else");
+		});
+
+		it("should use Keyword kind for condition types", () => {
+			const content = '{\n  "nodes": {\n    "filter": {\n      "conditions": [\n        {\n          "type": "';
+			const items = getCompletions(content, getOffset(content));
+			const ifItem = items.find((i) => i.label === "if");
+			expect(ifItem?.kind).toBe(CompletionItemKind.Keyword);
+		});
+	});
+
+	describe("top-level key completions", () => {
+		it("should provide top-level key completions at root", () => {
+			const content = '{\n  "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("name");
+			expect(labels).toContain("version");
+			expect(labels).toContain("trigger");
+			expect(labels).toContain("steps");
+			expect(labels).toContain("nodes");
+		});
+
+		it("should provide HTTP-specific keys inside http object", () => {
+			const content = '{\n  "trigger": {\n    "http": {\n      "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("method");
+			expect(labels).toContain("path");
+		});
+
+		it("should provide step-specific keys inside steps array", () => {
+			const content = '{\n  "steps": [\n    {\n      "';
+			const items = getCompletions(content, getOffset(content));
+			const labels = items.map((i) => i.label);
+			expect(labels).toContain("name");
+			expect(labels).toContain("node");
+			expect(labels).toContain("type");
+			expect(labels).toContain("runtime");
+		});
+	});
+
+	describe("empty results", () => {
+		it("should return empty for unknown context", () => {
+			const content = '{\n  "unknown": {\n    "provider": "';
+			const items = getCompletions(content, getOffset(content));
+			// Should not provide queue/pubsub providers in unknown context
+			const labels = items.map((i) => i.label);
+			expect(labels).not.toContain("kafka");
+			expect(labels).not.toContain("gcp");
+		});
+	});
+});

package/src/__tests__/constants.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from "vitest";
+import {
+	FIELD_DOCS,
+	NODE_PACKAGES,
+	PUBSUB_PROVIDERS,
+	QUEUE_PROVIDERS,
+	STEP_FIELD_DOCS,
+	TRIGGER_DOCS,
+	VALID_HTTP_METHODS,
+	VALID_RUNTIMES,
+	VALID_STEP_TYPES,
+	VALID_TRIGGERS,
+	WEBHOOK_SOURCES,
+} from "../constants";
+
+describe("LSP Constants", () => {
+	describe("VALID_TRIGGERS", () => {
+		it("should have all 10 trigger types", () => {
+			expect(VALID_TRIGGERS).toHaveLength(10);
+			expect(VALID_TRIGGERS).toContain("http");
+			expect(VALID_TRIGGERS).toContain("grpc");
+			expect(VALID_TRIGGERS).toContain("manual");
+			expect(VALID_TRIGGERS).toContain("cron");
+			expect(VALID_TRIGGERS).toContain("queue");
+			expect(VALID_TRIGGERS).toContain("pubsub");
+			expect(VALID_TRIGGERS).toContain("worker");
+			expect(VALID_TRIGGERS).toContain("webhook");
+			expect(VALID_TRIGGERS).toContain("websocket");
+			expect(VALID_TRIGGERS).toContain("sse");
+		});
+	});
+
+	describe("VALID_HTTP_METHODS", () => {
+		it("should include standard HTTP methods and ANY", () => {
+			expect(VALID_HTTP_METHODS).toContain("GET");
+			expect(VALID_HTTP_METHODS).toContain("POST");
+			expect(VALID_HTTP_METHODS).toContain("PUT");
+			expect(VALID_HTTP_METHODS).toContain("DELETE");
+			expect(VALID_HTTP_METHODS).toContain("PATCH");
+			expect(VALID_HTTP_METHODS).toContain("ANY");
+		});
+	});
+
+	describe("VALID_STEP_TYPES", () => {
+		it("should include local, module, and runtime types", () => {
+			expect(VALID_STEP_TYPES).toContain("local");
+			expect(VALID_STEP_TYPES).toContain("module");
+			expect(VALID_STEP_TYPES).toContain("runtime.nodejs");
+			expect(VALID_STEP_TYPES).toContain("runtime.python3");
+			expect(VALID_STEP_TYPES).toContain("runtime.go");
+			expect(VALID_STEP_TYPES).toContain("runtime.java");
+			expect(VALID_STEP_TYPES).toContain("runtime.rust");
+		});
+	});
+
+	describe("VALID_RUNTIMES", () => {
+		it("should include all 11 runtime kinds", () => {
+			expect(VALID_RUNTIMES).toHaveLength(11);
+			expect(VALID_RUNTIMES).toContain("nodejs");
+			expect(VALID_RUNTIMES).toContain("bun");
+			expect(VALID_RUNTIMES).toContain("python3");
+			expect(VALID_RUNTIMES).toContain("go");
+			expect(VALID_RUNTIMES).toContain("java");
+			expect(VALID_RUNTIMES).toContain("rust");
+			expect(VALID_RUNTIMES).toContain("docker");
+			expect(VALID_RUNTIMES).toContain("wasm");
+		});
+	});
+
+	describe("TRIGGER_DOCS", () => {
+		it("should have documentation for all triggers", () => {
+			for (const trigger of VALID_TRIGGERS) {
+				expect(TRIGGER_DOCS).toHaveProperty(trigger);
+				expect(TRIGGER_DOCS[trigger].title).toBeTruthy();
+				expect(TRIGGER_DOCS[trigger].description).toBeTruthy();
+			}
+		});
+
+		it("should include examples for all trigger docs", () => {
+			for (const trigger of VALID_TRIGGERS) {
+				expect(TRIGGER_DOCS[trigger].example).toBeTruthy();
+			}
+		});
+	});
+
+	describe("FIELD_DOCS", () => {
+		it("should have documentation for core workflow fields", () => {
+			expect(FIELD_DOCS).toHaveProperty("name");
+			expect(FIELD_DOCS).toHaveProperty("version");
+			expect(FIELD_DOCS).toHaveProperty("trigger");
+			expect(FIELD_DOCS).toHaveProperty("steps");
+			expect(FIELD_DOCS).toHaveProperty("nodes");
+			expect(FIELD_DOCS).toHaveProperty("inputs");
+			expect(FIELD_DOCS).toHaveProperty("conditions");
+			expect(FIELD_DOCS).toHaveProperty("set_var");
+		});
+	});
+
+	describe("STEP_FIELD_DOCS", () => {
+		it("should have documentation for step fields", () => {
+			expect(STEP_FIELD_DOCS).toHaveProperty("node");
+			expect(STEP_FIELD_DOCS).toHaveProperty("type");
+			expect(STEP_FIELD_DOCS).toHaveProperty("runtime");
+		});
+	});
+
+	describe("NODE_PACKAGES", () => {
+		it("should include core node packages", () => {
+			const names = NODE_PACKAGES.map((n) => n.name);
+			expect(names).toContain("@blokjs/api-call");
+			expect(names).toContain("@blokjs/if-else");
+			expect(names).toContain("@blokjs/react");
+		});
+	});
+
+	describe("QUEUE_PROVIDERS", () => {
+		it("should include all queue providers", () => {
+			expect(QUEUE_PROVIDERS).toContain("kafka");
+			expect(QUEUE_PROVIDERS).toContain("rabbitmq");
+			expect(QUEUE_PROVIDERS).toContain("sqs");
+			expect(QUEUE_PROVIDERS).toContain("redis");
+		});
+	});
+
+	describe("PUBSUB_PROVIDERS", () => {
+		it("should include all pubsub providers", () => {
+			expect(PUBSUB_PROVIDERS).toContain("gcp");
+			expect(PUBSUB_PROVIDERS).toContain("aws");
+			expect(PUBSUB_PROVIDERS).toContain("azure");
+			expect(PUBSUB_PROVIDERS).toContain("nats");
+		});
+	});
+
+	describe("WEBHOOK_SOURCES", () => {
+		it("should include all webhook sources", () => {
+			expect(WEBHOOK_SOURCES).toContain("github");
+			expect(WEBHOOK_SOURCES).toContain("stripe");
+			expect(WEBHOOK_SOURCES).toContain("shopify");
+			expect(WEBHOOK_SOURCES).toContain("custom");
+		});
+	});
+});