treelsp 0.0.1

package/dist/server/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * LSP server transport for Node.js stdio
+ *
+ * Provides startStdioServer() that wires a LanguageService to a
+ * vscode-languageserver connection over stdio. Separate from treelsp/runtime
+ * to keep the runtime browser-compatible.
+ */
+import type { LanguageDefinition } from '../definition/index.js';
+/**
+ * Options for starting a stdio LSP server
+ */
+export interface StdioServerOptions {
+    /** Language definition from defineLanguage() */
+    definition: LanguageDefinition;
+    /** Absolute path to grammar.wasm file */
+    wasmPath: string;
+}
+/**
+ * Start an LSP server over stdio transport
+ *
+ * Creates a vscode-languageserver connection, wires all LSP protocol handlers
+ * to a LanguageService, and starts listening. This is the main entry point
+ * for generated LSP servers.
+ */
+export declare function startStdioServer(options: StdioServerOptions): void;

package/dist/server/index.js

@@ -0,0 +1,230 @@
+import { COMPLETION_KIND_MAP, SEMANTIC_TOKEN_MODIFIERS, SEMANTIC_TOKEN_TYPES, createDocumentState, createServer } from "../runtime-CnCx2QS4.js";
+import { DiagnosticSeverity, ProposedFeatures, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/lib/node/main.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+//#region src/server/index.ts
+/**
+* Convert internal CompletionItem to LSP protocol CompletionItem
+*/
+function toLspCompletionItem(item) {
+	const lspItem = { label: item.label };
+	if (item.kind) lspItem.kind = COMPLETION_KIND_MAP[item.kind];
+	if (item.detail) lspItem.detail = item.detail;
+	if (item.documentation) lspItem.documentation = item.documentation;
+	if (item.insertText) lspItem.insertText = item.insertText;
+	return lspItem;
+}
+function getRangeStr(start, end) {
+	return `${start.line}:${start.character}-${end.line}:${end.character}`;
+}
+/**
+* Start an LSP server over stdio transport
+*
+* Creates a vscode-languageserver connection, wires all LSP protocol handlers
+* to a LanguageService, and starts listening. This is the main entry point
+* for generated LSP servers.
+*/
+function startStdioServer(options) {
+	const { definition, wasmPath } = options;
+	const langId = definition.name.toLowerCase();
+	const connection = createConnection(ProposedFeatures.all);
+	const textDocuments = new TextDocuments(TextDocument);
+	const service = createServer(definition);
+	const documentStates = /* @__PURE__ */ new Map();
+	const pendingInits = /* @__PURE__ */ new Map();
+	async function getDocumentState(textDoc) {
+		const existing = documentStates.get(textDoc.uri);
+		if (existing) return existing;
+		let promise = pendingInits.get(textDoc.uri);
+		if (!promise) {
+			promise = createDocumentState(wasmPath, {
+				uri: textDoc.uri,
+				version: textDoc.version,
+				languageId: langId
+			}, textDoc.getText());
+			pendingInits.set(textDoc.uri, promise);
+		}
+		const state = await promise;
+		documentStates.set(textDoc.uri, state);
+		pendingInits.delete(textDoc.uri);
+		return state;
+	}
+	const severityMap = {
+		error: DiagnosticSeverity.Error,
+		warning: DiagnosticSeverity.Warning,
+		info: DiagnosticSeverity.Information,
+		hint: DiagnosticSeverity.Hint
+	};
+	async function validateDocument(textDoc) {
+		const state = await getDocumentState(textDoc);
+		const diagnostics = service.computeDiagnostics(state);
+		connection.console.log(`[validation] ${diagnostics.map((d) => `range=${getRangeStr(d.range.start, d.range.end)} message=${d.message}`).join(", ")}`);
+		connection.sendDiagnostics({
+			uri: textDoc.uri,
+			version: textDoc.version,
+			diagnostics: diagnostics.map((d) => {
+				const lspDiag = {
+					range: d.range,
+					severity: severityMap[d.severity],
+					message: d.message,
+					source: d.source ?? langId
+				};
+				if (d.code) lspDiag.code = d.code;
+				return lspDiag;
+			})
+		});
+	}
+	connection.onInitialize(() => ({ capabilities: {
+		textDocumentSync: TextDocumentSyncKind.Full,
+		hoverProvider: true,
+		definitionProvider: true,
+		referencesProvider: true,
+		completionProvider: { resolveProvider: false },
+		renameProvider: { prepareProvider: true },
+		documentSymbolProvider: true,
+		semanticTokensProvider: {
+			legend: {
+				tokenTypes: [...SEMANTIC_TOKEN_TYPES],
+				tokenModifiers: [...SEMANTIC_TOKEN_MODIFIERS]
+			},
+			full: true
+		}
+	} }));
+	textDocuments.onDidOpen(async (event) => {
+		connection.console.log(`[open] ${event.document.uri} v${event.document.version}`);
+		await validateDocument(event.document);
+		connection.console.log(`[open] done ${event.document.uri}`);
+	});
+	textDocuments.onDidChangeContent(async (event) => {
+		connection.console.log(`[change] ${event.document.uri} v${event.document.version}`);
+		const state = await getDocumentState(event.document);
+		state.update(event.document.getText(), event.document.version);
+		service.documents.change(state);
+		await validateDocument(event.document);
+	});
+	textDocuments.onDidClose((event) => {
+		const state = documentStates.get(event.document.uri);
+		if (state) {
+			service.documents.close(event.document.uri);
+			state.dispose();
+			documentStates.delete(event.document.uri);
+		}
+		connection.sendDiagnostics({
+			uri: event.document.uri,
+			diagnostics: []
+		});
+	});
+	connection.onHover(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) return null;
+		const state = await getDocumentState(textDoc);
+		const result = service.provideHover(state, params.position);
+		if (!result) return null;
+		return {
+			contents: {
+				kind: "markdown",
+				value: result.contents
+			},
+			range: result.range
+		};
+	});
+	connection.onDefinition(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) {
+			connection.console.log(`[definition] no textDoc for ${params.textDocument.uri}`);
+			return null;
+		}
+		try {
+			const state = await getDocumentState(textDoc);
+			const pos = params.position;
+			const node = state.root.descendantForPosition(pos);
+			connection.console.log(`[definition] pos=${pos.line}:${pos.character} node=${node.type} "${node.text}" range=${getRangeStr(node.startPosition, node.endPosition)}`);
+			const result = service.provideDefinition(state, params.position);
+			connection.console.log(`[definition] result=${result ? `${result.uri} ${result.range.start.line}:${result.range.start.character}` : "null"}`);
+			if (!result) return null;
+			return {
+				uri: result.uri,
+				range: result.range
+			};
+		} catch (e) {
+			connection.console.error(`[definition] error: ${String(e)}`);
+			return null;
+		}
+	});
+	connection.onReferences(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) {
+			connection.console.log(`[references] no textDoc for ${params.textDocument.uri}`);
+			return [];
+		}
+		try {
+			const state = await getDocumentState(textDoc);
+			const pos = params.position;
+			const node = state.root.descendantForPosition(pos);
+			connection.console.log(`[references] pos=${pos.line}:${pos.character} node=${node.type} "${node.text}" range=${node.startPosition.line}:${node.startPosition.character}-${node.endPosition.line}:${node.endPosition.character}`);
+			const results = service.provideReferences(state, params.position);
+			connection.console.log(`[references] found ${results.length} references`);
+			return results.map((r) => ({
+				uri: r.uri,
+				range: r.range
+			}));
+		} catch (e) {
+			connection.console.error(`[references] error: ${String(e)}`);
+			return [];
+		}
+	});
+	connection.onCompletion(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) return [];
+		const state = await getDocumentState(textDoc);
+		const items = service.provideCompletion(state, params.position);
+		return items.map(toLspCompletionItem);
+	});
+	connection.onPrepareRename(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) return null;
+		const state = await getDocumentState(textDoc);
+		return service.prepareRename(state, params.position);
+	});
+	connection.onRenameRequest(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) return null;
+		const state = await getDocumentState(textDoc);
+		const result = service.provideRename(state, params.position, params.newName);
+		if (!result) return null;
+		const changes = {};
+		for (const [uri, edits] of Object.entries(result.changes)) changes[uri] = edits.map((e) => ({
+			range: e.range,
+			newText: e.newText
+		}));
+		return { changes };
+	});
+	connection.onDocumentSymbol(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) return [];
+		const state = await getDocumentState(textDoc);
+		const symbols = service.provideSymbols(state);
+		return symbols.map((s) => {
+			const sym = {
+				name: s.name,
+				kind: s.kindNumber,
+				range: s.range,
+				selectionRange: s.selectionRange,
+				children: []
+			};
+			if (s.detail) sym.detail = s.detail;
+			return sym;
+		});
+	});
+	connection.languages.semanticTokens.on(async (params) => {
+		const textDoc = textDocuments.get(params.textDocument.uri);
+		if (!textDoc) return { data: [] };
+		const state = await getDocumentState(textDoc);
+		return service.provideSemanticTokensFull(state);
+	});
+	textDocuments.listen(connection);
+	connection.listen();
+}
+
+//#endregion
+export { startStdioServer };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "treelsp",
+  "version": "0.0.1",
+  "description": "A Langium-style LSP generator using Tree-sitter as the parsing backend",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./codegen": {
+      "types": "./dist/codegen/index.d.ts",
+      "import": "./dist/codegen/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "lsp",
+    "language-server",
+    "tree-sitter",
+    "parser",
+    "typescript"
+  ],
+  "author": "Dhrubomoy Das Gupta",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dhrubomoy/treelsp.git",
+    "directory": "packages/treelsp"
+  },
+  "homepage": "https://github.com/dhrubomoy/treelsp#readme",
+  "bugs": "https://github.com/dhrubomoy/treelsp/issues",
+  "dependencies": {
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "web-tree-sitter": "^0.24.4"
+  },
+  "devDependencies": {
+    "tsdown": "^0.2.17",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
+}