@elyracode/lsp-typescript 0.9.19 → 0.9.20

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.9.20] - 2026-07-19
+
+### Added
+- Auto-diagnostics and blast radius on edit: after an `edit`, the extension now also reports fresh TypeScript errors for the edited file (via LSP publishDiagnostics, skipped when the core edit tool already ran tsc) and lists call sites of the edited function/class in other files (via `textDocument/documentSymbol` + `references`), alongside the existing related-symbol summaries
+
 ## [0.9.19] - 2026-07-18
 
 ## [0.9.18] - 2026-07-18

package/extensions/index.ts

@@ -158,6 +158,82 @@ function summarizeHover(result: unknown): string | undefined {
 	return firstLine.length > 160 ? `${firstLine.slice(0, 160)}\u2026` : firstLine;
 }
 
+// LSP SymbolKind values that can meaningfully own a blast radius:
+// Class, Method, Constructor, Enum, Interface, Function, Variable, Constant, Struct.
+const BLAST_SYMBOL_KINDS = new Set([5, 6, 9, 10, 11, 12, 13, 14, 23]);
+
+interface FlatSymbol {
+	name: string;
+	kind: number;
+	startLine: number;
+	endLine: number;
+	depth: number;
+	/** 0-based position of the symbol's name (for references lookups). */
+	selLine: number;
+	selChar: number;
+}
+
+/** Flatten a documentSymbol response (hierarchical DocumentSymbol[] or flat SymbolInformation[]). */
+function flattenSymbols(result: unknown): FlatSymbol[] {
+	if (!Array.isArray(result)) return [];
+	const out: FlatSymbol[] = [];
+	const walk = (nodes: unknown[], depth: number): void => {
+		for (const n of nodes) {
+			if (!n || typeof n !== "object") continue;
+			const sym = n as {
+				name?: unknown;
+				kind?: unknown;
+				range?: LspRange;
+				selectionRange?: LspRange;
+				location?: { range?: LspRange };
+				children?: unknown[];
+			};
+			const range = sym.range ?? sym.location?.range;
+			if (typeof sym.name === "string" && typeof sym.kind === "number" && range) {
+				const sel = sym.selectionRange ?? range;
+				out.push({
+					name: sym.name,
+					kind: sym.kind,
+					startLine: range.start.line,
+					endLine: range.end.line,
+					depth,
+					selLine: sel.start.line,
+					selChar: sel.start.character,
+				});
+			}
+			if (Array.isArray(sym.children)) walk(sym.children, depth + 1);
+		}
+	};
+	walk(result, 0);
+	return out;
+}
+
+/** Find the innermost symbol (by line span, then nesting depth) containing a 0-based line. */
+function findEnclosingSymbol(symbols: FlatSymbol[], line0: number): FlatSymbol | undefined {
+	let best: FlatSymbol | undefined;
+	for (const s of symbols) {
+		if (!BLAST_SYMBOL_KINDS.has(s.kind)) continue;
+		if (line0 < s.startLine || line0 > s.endLine) continue;
+		if (!best) {
+			best = s;
+			continue;
+		}
+		const bestSpan = best.endLine - best.startLine;
+		const span = s.endLine - s.startLine;
+		if (span < bestSpan || (span === bestSpan && s.depth > best.depth)) best = s;
+	}
+	return best;
+}
+
+/** True when the edit tool's own result already contains a diagnostics section. */
+function hasExistingDiagnostics(content: ReadonlyArray<unknown>): boolean {
+	return content.some((c) => {
+		if (!c || typeof c !== "object") return false;
+		const item = c as { type?: unknown; text?: unknown };
+		return item.type === "text" && typeof item.text === "string" && item.text.includes("\nDiagnostics (");
+	});
+}
+
 function findBinary(workingDir: string): string | undefined {
 	const local = join(workingDir, "node_modules", ".bin", "typescript-language-server");
 	if (existsSync(local)) return local;
@@ -187,6 +263,7 @@ export default function (elyra: ExtensionAPI): void {
 	let cwd = "";
 	const openedFiles = new Set<string>();
 	const diagnosticsByUri = new Map<string, LspDiagnostic[]>();
+	const diagnosticsWaiters = new Map<string, Array<() => void>>();
 
 	// ── JSON-RPC Client ─────────────────────────────────────────────────
 
@@ -275,6 +352,11 @@ export default function (elyra: ExtensionAPI): void {
 				if (msg.method === "textDocument/publishDiagnostics" && msg.params) {
 					const p = msg.params as { uri: string; diagnostics: LspDiagnostic[] };
 					diagnosticsByUri.set(p.uri, p.diagnostics);
+					const waiters = diagnosticsWaiters.get(p.uri);
+					if (waiters) {
+						diagnosticsWaiters.delete(p.uri);
+						for (const w of waiters) w();
+					}
 				}
 			}
 		}
@@ -316,6 +398,28 @@ export default function (elyra: ExtensionAPI): void {
 		openFile(filePath);
 	}
 
+	/** Resolve when the server publishes diagnostics for `uri`, or after `timeoutMs`. */
+	function waitForDiagnostics(uri: string, timeoutMs: number): Promise<void> {
+		return new Promise<void>((resolveWait) => {
+			const waiter = () => {
+				clearTimeout(timer);
+				resolveWait();
+			};
+			const timer = setTimeout(() => {
+				const arr = diagnosticsWaiters.get(uri);
+				if (arr) {
+					const remaining = arr.filter((w) => w !== waiter);
+					if (remaining.length > 0) diagnosticsWaiters.set(uri, remaining);
+					else diagnosticsWaiters.delete(uri);
+				}
+				resolveWait();
+			}, timeoutMs);
+			const list = diagnosticsWaiters.get(uri) ?? [];
+			list.push(waiter);
+			diagnosticsWaiters.set(uri, list);
+		});
+	}
+
 	function formatLocations(result: unknown, workingDir: string): string {
 		if (!result) return "No results found.";
 
@@ -535,7 +639,7 @@ export default function (elyra: ExtensionAPI): void {
 			},
 		});
 
-		// ── Hook: auto-context on edit (see "Symbol-aware auto-context" above) ──
+		// ── Hook: auto-context, auto-diagnostics, and blast radius on edit ──
 		elyra.on("tool_result", async (event) => {
 			if (!initialized || !isEditToolResult(event) || event.isError) return undefined;
 
@@ -549,14 +653,14 @@ export default function (elyra: ExtensionAPI): void {
 				const fileText = readFileSync(absPath, "utf-8");
 				const details = event.details as EditToolDetails | undefined;
 				const fromLine = details?.firstChangedLine ?? 1;
+				const uri = fileUri(absPath);
+				const sections: string[] = [];
 
+				// 1. Related symbols: hover summaries for referenced types.
 				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;
@@ -572,10 +676,67 @@ export default function (elyra: ExtensionAPI): void {
 					}
 				});
 
-				const lines = (await Promise.all(lookups)).filter((l): l is string => !!l);
-				if (lines.length === 0) return undefined;
+				// 2. Blast radius: references to the edited symbol outside this file.
+				const blastRadius = (async () => {
+					try {
+						const symbolResult = await sendRequest("textDocument/documentSymbol", {
+							textDocument: { uri },
+						});
+						const enclosing = findEnclosingSymbol(flattenSymbols(symbolResult), fromLine - 1);
+						if (!enclosing) return undefined;
+
+						const refsResult = await sendRequest("textDocument/references", {
+							textDocument: { uri },
+							position: { line: enclosing.selLine, character: enclosing.selChar },
+							context: { includeDeclaration: false },
+						});
+						if (!Array.isArray(refsResult)) return undefined;
+
+						const external = (refsResult as LspLocation[]).filter((loc) => uriToPath(loc.uri) !== absPath);
+						if (external.length === 0) return undefined;
+
+						const prefix = `${cwd}/`;
+						const shown = external.slice(0, 8).map((loc) => {
+							const p = uriToPath(loc.uri);
+							const rel = p.startsWith(prefix) ? p.slice(prefix.length) : p;
+							return `${rel}:${loc.range.start.line + 1}`;
+						});
+						const more = external.length > shown.length ? ` (+${external.length - shown.length} more)` : "";
+						return `${enclosing.name} is referenced in ${external.length} place${external.length === 1 ? "" : "s"} outside this file:\n${shown.map((s) => `- ${s}`).join("\n")}${more}`;
+					} catch {
+						return undefined;
+					}
+				})();
+
+				// 3. Fresh diagnostics for the edited file (skip if the edit tool already ran tsc).
+				const freshDiagnostics = (async () => {
+					if (hasExistingDiagnostics(event.content)) return undefined;
+					try {
+						await waitForDiagnostics(uri, 1500);
+						const errors = (diagnosticsByUri.get(uri) ?? []).filter((d) => (d.severity ?? 1) === 1);
+						if (errors.length === 0) return undefined;
+						const shown = errors.slice(0, 8).map((d) => {
+							const code = d.code ? ` [${d.code}]` : "";
+							return `- ${input.path}:${d.range.start.line + 1}:${d.range.start.character + 1}${code}: ${d.message.split("\n")[0]}`;
+						});
+						const more = errors.length > shown.length ? ` (+${errors.length - shown.length} more)` : "";
+						return `${errors.length} error${errors.length === 1 ? "" : "s"} in this file after the edit:\n${shown.join("\n")}${more}`;
+					} catch {
+						return undefined;
+					}
+				})();
+
+				const [hoverLines, blast, diag] = await Promise.all([Promise.all(lookups), blastRadius, freshDiagnostics]);
+
+				const related = hoverLines.filter((l): l is string => !!l);
+				if (diag) sections.push(`[Diagnostics \u2014 auto-checked via LSP]\n${diag}`);
+				if (blast) sections.push(`[Blast radius \u2014 auto-resolved via LSP]\n${blast}`);
+				if (related.length > 0) {
+					sections.push(`[Related symbols \u2014 auto-resolved via LSP, no extra tool call needed]\n${related.join("\n")}`);
+				}
+				if (sections.length === 0) return undefined;
 
-				const contextBlock = `\n\n[Related symbols \u2014 auto-resolved via LSP, no extra tool call needed]\n${lines.join("\n")}`;
+				const contextBlock = `\n\n${sections.join("\n\n")}`;
 				return { content: [...event.content, { type: "text" as const, text: contextBlock }] };
 			} catch {
 				return undefined;

package/package.json

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