@elyracode/lsp-rust 0.9.18

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+## [0.9.18] - 2026-07-18
+
+### Added
+- Initial release: Rust LSP integration for Elyra. Starts a Rust language server (rust-analyzer) per session in projects containing a `Cargo.toml`, and exposes `rust_definitions`, `rust_references`, `rust_diagnostics`, and `rust_hover` as agent tools. Also proactively resolves referenced type/struct/trait names via hover after an edit, appending a short summary to the edit's own tool result.

package/README.md

@@ -0,0 +1,38 @@
+# @elyracode/lsp-rust
+
+Rust LSP integration for Elyra. Starts a [rust-analyzer](https://rust-analyzer.github.io/) process per session and exposes semantic code navigation and diagnostics as agent tools — go-to-definition, find references, hover, and diagnostics for Rust and Cargo projects.
+
+## Prerequisites
+
+`rust-analyzer` must be on your `PATH` (or installed via rustup, which places it in `~/.cargo/bin/`).
+
+```bash
+rustup component add rust-analyzer
+```
+
+…or install a standalone binary from the [rust-analyzer releases](https://github.com/rust-lang/rust-analyzer/releases).
+
+A `Cargo.toml` must exist in the project root. The extension does nothing if one is not found.
+
+> Note: rust-analyzer indexes the workspace on first use, which can take longer on large crates. The first `rust_diagnostics`/`rust_hover` call after a session starts may need a moment.
+
+## Installation
+
+```bash
+elyra install npm:@elyracode/lsp-rust
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `rust_definitions` | Go to the definition of a Rust symbol at a given file position |
+| `rust_references` | Find all references to a Rust symbol across the project |
+| `rust_diagnostics` | Get Rust compiler/clippy-derived errors and warnings for a file |
+| `rust_hover` | Get type information and documentation for a symbol |
+
+All tools accept 1-based line and column numbers and return human-readable text results.
+
+## Symbol-aware auto-context
+
+After a successful `edit` to a `.rs` file, the extension proactively resolves unfamiliar-looking type/struct/trait names referenced in the new code via `rust_analyzer`'s hover, and appends a short summary directly to the edit's own tool result — no extra `rust_hover` round trip needed to check "is this the shape I think it is".

package/extensions/index.ts

@@ -0,0 +1,616 @@
+import {
+	type EditToolDetails,
+	type EditToolInput,
+	type ExtensionAPI,
+	isEditToolResult,
+} from "@elyracode/coding-agent";
+import { type ChildProcess, execSync, spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+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 whichBinary(name: string): string | undefined {
+	try {
+		const found = execSync(`which ${name}`, {
+			encoding: "utf-8",
+			timeout: 5000,
+			stdio: ["pipe", "pipe", "pipe"],
+		}).trim();
+		return found || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Locate rust-analyzer: PATH first, then the default rustup install location. */
+function findLanguageServer(): string | undefined {
+	const onPath = whichBinary("rust-analyzer");
+	if (onPath) return onPath;
+
+	const rustupDefault = join(homedir(), ".cargo", "bin", "rust-analyzer");
+	if (existsSync(rustupDefault)) return rustupDefault;
+
+	return undefined;
+}
+
+// ── Symbol-aware auto-context ────────────────────────────────────────────────
+// After an edit, proactively resolve unfamiliar-looking type/struct/trait names
+// referenced in the new code via hover, and append a short summary to the
+// edit's own tool result. Saves a definitions/hover round trip for the common
+// case of "I just referenced a type, is this the shape I think it is".
+
+/** Common built-ins that rarely need an explanation. */
+const RUST_SYMBOL_STOPLIST = new Set([
+	"String",
+	"Vec",
+	"Option",
+	"Result",
+	"Box",
+	"Arc",
+	"Rc",
+	"Weak",
+	"RefCell",
+	"Cell",
+	"Mutex",
+	"RwLock",
+	"HashMap",
+	"HashSet",
+	"BTreeMap",
+	"BTreeSet",
+	"Cow",
+	"Path",
+	"PathBuf",
+	"Duration",
+	"Instant",
+	"Self",
+	"Ok",
+	"Err",
+	"Some",
+	"None",
+]);
+
+/** Extract candidate PascalCase type/struct/trait identifiers from a snippet of code. */
+function extractCandidateSymbols(text: string, stoplist: Set<string>, max: number): string[] {
+	const found = new Set<string>();
+	const re = /\b[A-Z][A-Za-z0-9_]*\b/g;
+	let m: RegExpExecArray | null = re.exec(text);
+	while (m && found.size < max * 3) {
+		if (!stoplist.has(m[0])) found.add(m[0]);
+		m = re.exec(text);
+	}
+	return [...found].slice(0, max);
+}
+
+/** Find the (1-based) line/column of the first whole-word match of `symbol`, searching from `fromLine` first. */
+function findSymbolPosition(
+	fileText: string,
+	symbol: string,
+	fromLine: number,
+): { line: number; column: number } | undefined {
+	const lines = fileText.split("\n");
+	const re = new RegExp(`\\b${symbol}\\b`);
+	const start = Math.max(0, fromLine - 1);
+	for (let i = start; i < lines.length; i++) {
+		const idx = lines[i].search(re);
+		if (idx >= 0) return { line: i + 1, column: idx + 1 };
+	}
+	for (let i = 0; i < start; i++) {
+		const idx = lines[i].search(re);
+		if (idx >= 0) return { line: i + 1, column: idx + 1 };
+	}
+	return undefined;
+}
+
+/** Reduce a hover result to a short, single-line summary. */
+function summarizeHover(result: unknown): string | undefined {
+	if (!result) return undefined;
+	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");
+	} else text = hover.contents.value;
+
+	const firstLine = text
+		.split("\n")
+		.map((l) => l.trim())
+		.find((l) => l && !l.startsWith("```"));
+	if (!firstLine) return undefined;
+	return firstLine.length > 160 ? `${firstLine.slice(0, 160)}…` : firstLine;
+}
+
+// ── 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 20s`));
+			}, 20_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: "rust",
+				version: 1,
+				text,
+			},
+		});
+		openedFiles.add(uri);
+	}
+
+	/** Force the server to see the current on-disk content (e.g. right after our own edit). */
+	function syncFile(filePath: string): void {
+		const absPath = resolve(cwd, filePath);
+		const uri = fileUri(absPath);
+		if (openedFiles.has(uri)) {
+			sendNotification("textDocument/didClose", { textDocument: { uri } });
+			openedFiles.delete(uri);
+		}
+		openFile(filePath);
+	}
+
+	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;
+
+		// Rust/Cargo projects are identified by Cargo.toml.
+		if (!existsSync(join(cwd, "Cargo.toml"))) return;
+
+		const serverPath = findLanguageServer();
+		if (!serverPath) return;
+
+		lspProcess = spawn(serverPath, [], { 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: rust_definitions ──────────────────────────────────────
+
+		elyra.registerTool({
+			name: "rust_definitions",
+			label: "Rust Go to Definition",
+			description:
+				"Go to the definition of a Rust symbol at a given position. Returns the file path and " +
+				"line where the symbol is defined. More precise than grep for finding where structs, " +
+				"enums, traits, functions, and modules are declared.",
+			promptSnippet: "Go to definition of a Rust 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: Rust language 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: rust_references ───────────────────────────────────────
+
+		elyra.registerTool({
+			name: "rust_references",
+			label: "Rust Find References",
+			description:
+				"Find all references to a Rust symbol at a given position. Returns every location where " +
+				"the symbol is used across the project. More precise than grep for understanding how a " +
+				"struct, trait, or function is used in a Rust/Cargo codebase.",
+			promptSnippet: "Find all references to a Rust 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: Rust language 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: rust_diagnostics ──────────────────────────────────────
+
+		elyra.registerTool({
+			name: "rust_diagnostics",
+			label: "Rust Diagnostics",
+			description:
+				"Get Rust compiler and clippy-derived errors and warnings for a file from the language " +
+				"server (type errors, borrow-checker issues, unused imports, and more). Returns diagnostics " +
+				"with line numbers, severity, and messages.",
+			promptSnippet: "Get Rust 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: Rust language server is not running." }], details: {} };
+				}
+
+				const absPath = resolve(cwd, params.file);
+				openFile(params.file);
+
+				const uri = fileUri(absPath);
+
+				// rust-analyzer indexes the workspace on first use, and diagnostics
+				// (especially clippy/cargo check based ones) can take a while on
+				// larger crates. Give it a moment before reading published diagnostics.
+				await new Promise<void>((r) => setTimeout(r, 2000));
+
+				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: rust_hover ─────────────────────────────────────────────
+
+		elyra.registerTool({
+			name: "rust_hover",
+			label: "Rust Hover",
+			description:
+				"Get type information and documentation for a Rust symbol at a given position. Shows the " +
+				"resolved signature and doc comments for structs, enums, traits, and functions.",
+			promptSnippet: "Get type info and docs for a Rust 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: Rust language 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: {} };
+				}
+			},
+		});
+
+		// ── Hook: auto-context on edit (see "Symbol-aware auto-context" above) ──
+		elyra.on("tool_result", async (event) => {
+			if (!initialized || !isEditToolResult(event) || event.isError) return undefined;
+
+			const input = event.input as unknown as EditToolInput;
+			if (typeof input?.path !== "string" || !Array.isArray(input.edits)) return undefined;
+			if (!input.path.endsWith(".rs")) return undefined;
+
+			try {
+				syncFile(input.path);
+				const absPath = resolve(cwd, input.path);
+				const fileText = readFileSync(absPath, "utf-8");
+				const details = event.details as EditToolDetails | undefined;
+				const fromLine = details?.firstChangedLine ?? 1;
+
+				const candidates = new Set<string>();
+				for (const edit of input.edits) {
+					for (const s of extractCandidateSymbols(edit.newText, RUST_SYMBOL_STOPLIST, 4)) candidates.add(s);
+				}
+				if (candidates.size === 0) return undefined;
+
+				const uri = fileUri(absPath);
+				const lookups = [...candidates].slice(0, 5).map(async (symbol) => {
+					const pos = findSymbolPosition(fileText, symbol, fromLine);
+					if (!pos) return undefined;
+					try {
+						const result = await sendRequest("textDocument/hover", {
+							textDocument: { uri },
+							position: positionFromLineCol(pos.line, pos.column),
+						});
+						const summary = summarizeHover(result);
+						return summary ? `- ${symbol}: ${summary}` : undefined;
+					} catch {
+						return undefined;
+					}
+				});
+
+				const lines = (await Promise.all(lookups)).filter((l): l is string => !!l);
+				if (lines.length === 0) return undefined;
+
+				const contextBlock = `\n\n[Related symbols — auto-resolved via LSP, no extra tool call needed]\n${lines.join("\n")}`;
+				return { content: [...event.content, { type: "text" as const, text: contextBlock }] };
+			} catch {
+				return undefined;
+			}
+		});
+	});
+
+	// ── 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,34 @@
+{
+  "name": "@elyracode/lsp-rust",
+  "version": "0.9.18",
+  "description": "Rust LSP integration for Elyra — semantic code navigation and diagnostics via rust-analyzer",
+  "type": "module",
+  "keywords": [
+    "elyra-package",
+    "lsp",
+    "rust",
+    "cargo",
+    "rust-analyzer"
+  ],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/lsp-rust"
+  },
+  "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'"
+  }
+}