@elyracode/lsp-typescript 0.7.7

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## [0.7.7] - 2026-05-23
+
+### Added
+- Initial release with LSP tools: `lsp_definitions`, `lsp_references`, `lsp_diagnostics`, `lsp_hover`

package/README.md

@@ -0,0 +1,32 @@
+# @elyracode/lsp-typescript
+
+TypeScript LSP integration for Elyra. Starts a `typescript-language-server` process per session and exposes semantic code navigation and diagnostics as agent tools.
+
+## Prerequisites
+
+The project must have both packages installed:
+
+```bash
+npm install -D typescript typescript-language-server
+```
+
+The extension looks for `typescript-language-server` in the project's `node_modules/.bin/` first, then falls back to a global installation.
+
+A `tsconfig.json` must exist in the project root. The extension does nothing if one is not found.
+
+## Installation
+
+```bash
+elyra install @elyracode/lsp-typescript
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `lsp_definitions` | Go to the definition of a symbol at a given file position |
+| `lsp_references` | Find all references to a symbol across the project |
+| `lsp_diagnostics` | Get TypeScript errors and warnings for a file |
+| `lsp_hover` | Get type information and documentation for a symbol |
+
+All tools accept 1-based line and column numbers and return human-readable text results.

package/extensions/index.ts

@@ -0,0 +1,462 @@
+import type { ExtensionAPI } from "@elyracode/coding-agent";
+import { type ChildProcess, execSync, spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Type } from "typebox";
+
+// ── LSP Types ───────────────────────────────────────────────────────────────
+
+interface LspPosition {
+	line: number;
+	character: number;
+}
+
+interface LspRange {
+	start: LspPosition;
+	end: LspPosition;
+}
+
+interface LspLocation {
+	uri: string;
+	range: LspRange;
+}
+
+interface LspDiagnostic {
+	range: LspRange;
+	severity?: number;
+	message: string;
+	source?: string;
+	code?: string | number;
+}
+
+interface LspHoverResult {
+	contents: string | { kind: string; value: string } | Array<string | { kind: string; value: string }>;
+	range?: LspRange;
+}
+
+interface PendingRequest {
+	resolve: (value: unknown) => void;
+	reject: (reason: unknown) => void;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+const SEVERITY_LABELS: Record<number, string> = {
+	1: "Error",
+	2: "Warning",
+	3: "Information",
+	4: "Hint",
+};
+
+function fileUri(filePath: string): string {
+	return `file://${filePath}`;
+}
+
+function uriToPath(uri: string): string {
+	return uri.replace(/^file:\/\//, "");
+}
+
+function positionFromLineCol(line: number, col: number): LspPosition {
+	return { line: line - 1, character: col - 1 };
+}
+
+function languageIdForPath(filePath: string): string {
+	if (filePath.endsWith(".tsx")) return "typescriptreact";
+	if (filePath.endsWith(".jsx")) return "javascriptreact";
+	if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs")) return "javascript";
+	return "typescript";
+}
+
+function findBinary(workingDir: string): string | undefined {
+	const local = join(workingDir, "node_modules", ".bin", "typescript-language-server");
+	if (existsSync(local)) return local;
+
+	try {
+		const global = execSync("which typescript-language-server", {
+			encoding: "utf-8",
+			timeout: 5000,
+			stdio: ["pipe", "pipe", "pipe"],
+		}).trim();
+		if (global) return global;
+	} catch {
+		// not found globally
+	}
+
+	return undefined;
+}
+
+// ── Extension ───────────────────────────────────────────────────────────────
+
+export default function (elyra: ExtensionAPI): void {
+	let lspProcess: ChildProcess | null = null;
+	let requestId = 0;
+	const pendingRequests = new Map<number, PendingRequest>();
+	let buffer = Buffer.alloc(0);
+	let initialized = false;
+	let cwd = "";
+	const openedFiles = new Set<string>();
+	const diagnosticsByUri = new Map<string, LspDiagnostic[]>();
+
+	// ── JSON-RPC Client ─────────────────────────────────────────────────
+
+	function sendRequest(method: string, params: unknown): Promise<unknown> {
+		if (!lspProcess?.stdin) {
+			return Promise.reject(new Error("LSP server not running"));
+		}
+		const id = ++requestId;
+		const body = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+		const message = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+		lspProcess.stdin.write(message);
+
+		return new Promise<unknown>((res, rej) => {
+			const timer = setTimeout(() => {
+				pendingRequests.delete(id);
+				rej(new Error(`LSP request "${method}" timed out after 10s`));
+			}, 10_000);
+
+			pendingRequests.set(id, {
+				resolve: (value: unknown) => {
+					clearTimeout(timer);
+					res(value);
+				},
+				reject: (reason: unknown) => {
+					clearTimeout(timer);
+					rej(reason);
+				},
+			});
+		});
+	}
+
+	function sendNotification(method: string, params: unknown): void {
+		if (!lspProcess?.stdin) return;
+		const body = JSON.stringify({ jsonrpc: "2.0", method, params });
+		const message = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
+		lspProcess.stdin.write(message);
+	}
+
+	function handleData(chunk: Buffer): void {
+		buffer = Buffer.concat([buffer, chunk]);
+
+		for (;;) {
+			const headerEnd = buffer.indexOf("\r\n\r\n");
+			if (headerEnd === -1) break;
+
+			const header = buffer.subarray(0, headerEnd).toString("utf-8");
+			const match = /Content-Length:\s*(\d+)/i.exec(header);
+			if (!match) {
+				buffer = buffer.subarray(headerEnd + 4);
+				continue;
+			}
+
+			const contentLength = parseInt(match[1], 10);
+			const bodyStart = headerEnd + 4;
+			if (buffer.length < bodyStart + contentLength) break;
+
+			const bodyStr = buffer.subarray(bodyStart, bodyStart + contentLength).toString("utf-8");
+			buffer = buffer.subarray(bodyStart + contentLength);
+
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(bodyStr);
+			} catch {
+				continue;
+			}
+
+			if (!parsed || typeof parsed !== "object") continue;
+			const msg = parsed as Record<string, unknown>;
+
+			// Response to a request
+			if ("id" in msg && typeof msg.id === "number") {
+				const pending = pendingRequests.get(msg.id);
+				if (pending) {
+					pendingRequests.delete(msg.id);
+					if ("error" in msg && msg.error) {
+						const err = msg.error as { code: number; message: string };
+						pending.reject(new Error(`LSP error ${err.code}: ${err.message}`));
+					} else {
+						pending.resolve(msg.result);
+					}
+				}
+			}
+
+			// Server notification
+			if ("method" in msg && typeof msg.method === "string") {
+				if (msg.method === "textDocument/publishDiagnostics" && msg.params) {
+					const p = msg.params as { uri: string; diagnostics: LspDiagnostic[] };
+					diagnosticsByUri.set(p.uri, p.diagnostics);
+				}
+			}
+		}
+	}
+
+	// ── File helpers ────────────────────────────────────────────────────
+
+	function openFile(filePath: string): void {
+		const absPath = resolve(cwd, filePath);
+		const uri = fileUri(absPath);
+		if (openedFiles.has(uri)) return;
+
+		let text: string;
+		try {
+			text = readFileSync(absPath, "utf-8");
+		} catch {
+			return;
+		}
+
+		sendNotification("textDocument/didOpen", {
+			textDocument: {
+				uri,
+				languageId: languageIdForPath(filePath),
+				version: 1,
+				text,
+			},
+		});
+		openedFiles.add(uri);
+	}
+
+	function formatLocations(result: unknown, workingDir: string): string {
+		if (!result) return "No results found.";
+
+		const locations: LspLocation[] = Array.isArray(result) ? result : [result as LspLocation];
+		if (locations.length === 0) return "No results found.";
+
+		const prefix = workingDir + "/";
+		return locations
+			.map((loc) => {
+				const p = uriToPath(loc.uri);
+				const rel = p.startsWith(prefix) ? p.slice(prefix.length) : p;
+				return `${rel}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+			})
+			.join("\n");
+	}
+
+	// ── Lifecycle ───────────────────────────────────────────────────────
+
+	elyra.on("session_start", async (_event, ctx) => {
+		cwd = ctx.cwd;
+
+		if (!existsSync(join(cwd, "tsconfig.json"))) return;
+
+		const binary = findBinary(cwd);
+		if (!binary) return;
+
+		lspProcess = spawn(binary, ["--stdio"], { cwd });
+
+		lspProcess.stdout?.on("data", (chunk: Buffer) => handleData(chunk));
+		lspProcess.stderr?.on("data", () => {
+			/* ignore stderr */
+		});
+		lspProcess.on("exit", () => {
+			lspProcess = null;
+			initialized = false;
+		});
+
+		try {
+			await sendRequest("initialize", {
+				processId: process.pid,
+				capabilities: {},
+				rootUri: fileUri(cwd),
+				workspaceFolders: [{ uri: fileUri(cwd), name: "workspace" }],
+			});
+			sendNotification("initialized", {});
+			initialized = true;
+		} catch {
+			lspProcess?.kill();
+			lspProcess = null;
+			return;
+		}
+
+		// ── Tool: lsp_definitions ───────────────────────────────────────
+
+		elyra.registerTool({
+			name: "lsp_definitions",
+			label: "LSP Go to Definition",
+			description:
+				"Go to the definition of a symbol at a given position. Returns the file path and " +
+				"line where the symbol is defined. More precise than grep for finding where functions, " +
+				"classes, types, and variables are declared.",
+			promptSnippet: "Go to definition of a symbol at a file position",
+			parameters: Type.Object({
+				file: Type.String({ description: "Relative file path from project root" }),
+				line: Type.Number({ description: "Line number (1-based)" }),
+				column: Type.Number({ description: "Column number (1-based)" }),
+			}),
+			execute: async (_toolCallId, params) => {
+				if (!initialized) {
+					return { content: [{ type: "text", text: "Error: LSP server is not running." }], details: {} };
+				}
+
+				const absPath = resolve(cwd, params.file);
+				openFile(params.file);
+
+				try {
+					const result = await sendRequest("textDocument/definition", {
+						textDocument: { uri: fileUri(absPath) },
+						position: positionFromLineCol(params.line, params.column),
+					});
+					return { content: [{ type: "text", text: formatLocations(result, cwd) }], details: {} };
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					return { content: [{ type: "text", text: `Error: ${message}` }], details: {} };
+				}
+			},
+		});
+
+		// ── Tool: lsp_references ────────────────────────────────────────
+
+		elyra.registerTool({
+			name: "lsp_references",
+			label: "LSP Find References",
+			description:
+				"Find all references to a symbol at a given position. Returns every location where " +
+				"the symbol is used across the project. More precise than grep for understanding usage patterns.",
+			promptSnippet: "Find all references to a symbol at a file position",
+			parameters: Type.Object({
+				file: Type.String({ description: "Relative file path from project root" }),
+				line: Type.Number({ description: "Line number (1-based)" }),
+				column: Type.Number({ description: "Column number (1-based)" }),
+			}),
+			execute: async (_toolCallId, params) => {
+				if (!initialized) {
+					return { content: [{ type: "text", text: "Error: LSP server is not running." }], details: {} };
+				}
+
+				const absPath = resolve(cwd, params.file);
+				openFile(params.file);
+
+				try {
+					const result = await sendRequest("textDocument/references", {
+						textDocument: { uri: fileUri(absPath) },
+						position: positionFromLineCol(params.line, params.column),
+						context: { includeDeclaration: true },
+					});
+					return { content: [{ type: "text", text: formatLocations(result, cwd) }], details: {} };
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					return { content: [{ type: "text", text: `Error: ${message}` }], details: {} };
+				}
+			},
+		});
+
+		// ── Tool: lsp_diagnostics ───────────────────────────────────────
+
+		elyra.registerTool({
+			name: "lsp_diagnostics",
+			label: "LSP Diagnostics",
+			description:
+				"Get TypeScript compilation errors and warnings for a file without running the full " +
+				"type checker. Returns diagnostics with line numbers, severity, and messages.",
+			promptSnippet: "Get TypeScript errors and warnings for a file",
+			parameters: Type.Object({
+				file: Type.String({ description: "Relative file path from project root" }),
+			}),
+			execute: async (_toolCallId, params) => {
+				if (!initialized) {
+					return { content: [{ type: "text", text: "Error: LSP server is not running." }], details: {} };
+				}
+
+				const absPath = resolve(cwd, params.file);
+				openFile(params.file);
+
+				const uri = fileUri(absPath);
+
+				// Allow the server time to publish diagnostics after opening the file
+				await new Promise<void>((r) => setTimeout(r, 1000));
+
+				const diagnostics = diagnosticsByUri.get(uri) ?? [];
+				if (diagnostics.length === 0) {
+					return { content: [{ type: "text", text: "No diagnostics found." }], details: {} };
+				}
+
+				const lines = diagnostics.map((d) => {
+					const severity = SEVERITY_LABELS[d.severity ?? 1] ?? "Unknown";
+					const loc = `${params.file}:${d.range.start.line + 1}:${d.range.start.character + 1}`;
+					const code = d.code ? ` [${d.code}]` : "";
+					return `${severity}${code} ${loc}: ${d.message}`;
+				});
+
+				return { content: [{ type: "text", text: lines.join("\n") }], details: {} };
+			},
+		});
+
+		// ── Tool: lsp_hover ─────────────────────────────────────────────
+
+		elyra.registerTool({
+			name: "lsp_hover",
+			label: "LSP Hover",
+			description:
+				"Get type information and documentation for a symbol at a given position. Shows the " +
+				"resolved type signature and JSDoc comments.",
+			promptSnippet: "Get type info and docs for a symbol at a file position",
+			parameters: Type.Object({
+				file: Type.String({ description: "Relative file path from project root" }),
+				line: Type.Number({ description: "Line number (1-based)" }),
+				column: Type.Number({ description: "Column number (1-based)" }),
+			}),
+			execute: async (_toolCallId, params) => {
+				if (!initialized) {
+					return { content: [{ type: "text", text: "Error: LSP server is not running." }], details: {} };
+				}
+
+				const absPath = resolve(cwd, params.file);
+				openFile(params.file);
+
+				try {
+					const result = await sendRequest("textDocument/hover", {
+						textDocument: { uri: fileUri(absPath) },
+						position: positionFromLineCol(params.line, params.column),
+					});
+
+					if (!result) {
+						return { content: [{ type: "text", text: "No hover information available." }], details: {} };
+					}
+
+					const hover = result as LspHoverResult;
+					let text: string;
+
+					if (typeof hover.contents === "string") {
+						text = hover.contents;
+					} else if (Array.isArray(hover.contents)) {
+						text = hover.contents.map((c) => (typeof c === "string" ? c : c.value)).join("\n\n");
+					} else {
+						text = hover.contents.value;
+					}
+
+					return {
+						content: [{ type: "text", text: text || "No hover information available." }],
+						details: {},
+					};
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					return { content: [{ type: "text", text: `Error: ${message}` }], details: {} };
+				}
+			},
+		});
+	});
+
+	// ── Shutdown ────────────────────────────────────────────────────────
+
+	elyra.on("session_shutdown", async () => {
+		if (lspProcess && initialized) {
+			try {
+				await sendRequest("shutdown", null);
+				sendNotification("exit", null);
+			} catch {
+				// ignore errors during shutdown
+			}
+		}
+		if (lspProcess) {
+			lspProcess.kill();
+			lspProcess = null;
+		}
+		initialized = false;
+		openedFiles.clear();
+		diagnosticsByUri.clear();
+		buffer = Buffer.alloc(0);
+		requestId = 0;
+		for (const pending of pendingRequests.values()) {
+			pending.reject(new Error("LSP server shutting down"));
+		}
+		pendingRequests.clear();
+	});
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@elyracode/lsp-typescript",
+  "version": "0.7.7",
+  "description": "TypeScript LSP integration for Elyra — semantic code navigation and diagnostics",
+  "type": "module",
+  "keywords": [
+    "elyra-package",
+    "lsp",
+    "typescript"
+  ],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/lsp-typescript"
+  },
+  "elyra": {
+    "extensions": [
+      "./extensions/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@elyracode/coding-agent": "*",
+    "typebox": "*"
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'"
+  }
+}