@elyracode/lsp-typescript 0.9.16 → 0.9.18

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.9.18] - 2026-07-18
+
+### Added
+- Proactive symbol-aware auto-context: after an `edit` tool call, referenced type/interface identifiers in the edited code are resolved via `textDocument/hover` and appended to the tool result, so the agent sees relevant type information without a separate lookup round trip
+
+## [0.9.17] - 2026-07-18
+
 ## [0.9.16] - 2026-07-15
 
 ## [0.9.15] - 2026-07-12

package/extensions/index.ts

@@ -1,4 +1,9 @@
-import type { ExtensionAPI } from "@elyracode/coding-agent";
+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 { join, resolve } from "node:path";
@@ -67,6 +72,92 @@ function languageIdForPath(filePath: string): string {
 	return "typescript";
 }
 
+// ── Symbol-aware auto-context ────────────────────────────────────────────
+// After an edit, proactively resolve unfamiliar-looking type/class 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 TS_SYMBOL_STOPLIST = new Set([
+	"String",
+	"Number",
+	"Boolean",
+	"Array",
+	"Object",
+	"Promise",
+	"Error",
+	"Map",
+	"Set",
+	"Date",
+	"RegExp",
+	"JSON",
+	"Symbol",
+	"Math",
+	"Function",
+	"Record",
+	"Partial",
+	"Readonly",
+	"Pick",
+	"Omit",
+	"Required",
+	"Awaited",
+	"Buffer",
+	"ArrayBuffer",
+	"Uint8Array",
+	"Console",
+]);
+
+/** Extract candidate PascalCase type/class 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)}\u2026` : firstLine;
+}
+
 function findBinary(workingDir: string): string | undefined {
 	const local = join(workingDir, "node_modules", ".bin", "typescript-language-server");
 	if (existsSync(local)) return local;
@@ -214,6 +305,17 @@ export default function (elyra: ExtensionAPI): void {
 		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.";
 
@@ -432,9 +534,56 @@ export default function (elyra: ExtensionAPI): void {
 				}
 			},
 		});
+
+		// ── 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 (!/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(input.path)) 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, TS_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 \u2014 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 ────────────────────────────────────────────────────────
+	// ── Shutdown ────────────────────────────────────────────
 
 	elyra.on("session_shutdown", async () => {
 		if (lspProcess && initialized) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyracode/lsp-typescript",
-  "version": "0.9.16",
+  "version": "0.9.18",
   "description": "TypeScript LSP integration for Elyra — semantic code navigation and diagnostics",
   "type": "module",
   "keywords": [