@elyracode/lsp-php 0.9.19 → 0.9.21

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.9.21] - 2026-07-19
+
+## [0.9.20] - 2026-07-19
+
+### Added
+- Auto-diagnostics and blast radius on edit: after an `edit`, the extension now also reports fresh PHP compiler errors for the edited file 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

@@ -148,6 +148,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 whichBinary(name: string): string | undefined {
 	try {
 		const found = execSync(`which ${name}`, {
@@ -195,6 +271,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 ─────────────────────────────────────────────────
 
@@ -283,6 +360,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();
+					}
 				}
 			}
 		}
@@ -324,6 +406,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.";
 
@@ -547,7 +651,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;
 
@@ -561,14 +665,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, PHP_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;
@@ -584,10 +688,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 reported diagnostics).
+					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-php",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "PHP LSP integration for Elyra — semantic code navigation and diagnostics for Laravel and PHP projects",
   "type": "module",
   "keywords": [