@oh-my-pi/pi-coding-agent 6.1.0 → 6.7.0

package/src/core/tools/lsp/index.ts

@@ -1,7 +1,7 @@
 import type { Dirent } from "node:fs";
 import { existsSync, statSync } from "node:fs";
 import path from "node:path";
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { BunFile } from "bun";
 import { type Theme, theme } from "../../../modes/interactive/theme/theme";
 import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
@@ -667,6 +667,7 @@ export type WritethroughCallback = (
 	content: string,
 	signal?: AbortSignal,
 	file?: BunFile,
+	batch?: LspWritethroughBatchRequest,
 ) => Promise<FileDiagnosticsResult | undefined>;
 
 /** No-op writethrough callback */
@@ -684,772 +685,956 @@ export async function writethroughNoop(
 	return undefined;
 }
 
-/** Create a writethrough callback for LSP aware write operations */
-export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
-	const { enableFormat = false, enableDiagnostics = false } = options ?? {};
-	if (!enableFormat && !enableDiagnostics) {
-		return writethroughNoop;
+interface PendingWritethrough {
+	dst: string;
+	content: string;
+	file?: BunFile;
+}
+
+interface LspWritethroughBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+interface LspWritethroughBatchState {
+	entries: Map<string, PendingWritethrough>;
+	options: Required<WritethroughOptions>;
+}
+
+const writethroughBatches = new Map<string, LspWritethroughBatchState>();
+
+function getOrCreateWritethroughBatch(id: string, options: Required<WritethroughOptions>): LspWritethroughBatchState {
+	const existing = writethroughBatches.get(id);
+	if (existing) {
+		existing.options.enableFormat ||= options.enableFormat;
+		existing.options.enableDiagnostics ||= options.enableDiagnostics;
+		return existing;
 	}
-	return async (dst: string, content: string, signal?: AbortSignal, file?: BunFile) => {
-		const config = await getConfig(cwd);
-		const servers = getServersForFile(config, dst);
-		if (servers.length === 0) {
-			return writethroughNoop(dst, content, signal, file);
+	const batch: LspWritethroughBatchState = {
+		entries: new Map<string, PendingWritethrough>(),
+		options: { ...options },
+	};
+	writethroughBatches.set(id, batch);
+	return batch;
+}
+
+export async function flushLspWritethroughBatch(
+	id: string,
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<FileDiagnosticsResult | undefined> {
+	const state = writethroughBatches.get(id);
+	if (!state) {
+		return undefined;
+	}
+	writethroughBatches.delete(id);
+	return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal);
+}
+
+function summarizeDiagnosticMessages(messages: string[]): { summary: string; errored: boolean } {
+	const counts = { error: 0, warning: 0, info: 0, hint: 0 };
+	for (const message of messages) {
+		const match = message.match(/\[(error|warning|info|hint)\]/i);
+		if (!match) continue;
+		const key = match[1].toLowerCase() as keyof typeof counts;
+		counts[key] += 1;
+	}
+
+	const parts: string[] = [];
+	if (counts.error > 0) parts.push(`${counts.error} error(s)`);
+	if (counts.warning > 0) parts.push(`${counts.warning} warning(s)`);
+	if (counts.info > 0) parts.push(`${counts.info} info(s)`);
+	if (counts.hint > 0) parts.push(`${counts.hint} hint(s)`);
+
+	return {
+		summary: parts.length > 0 ? parts.join(", ") : "no issues",
+		errored: counts.error > 0,
+	};
+}
+
+function mergeDiagnostics(
+	results: Array<FileDiagnosticsResult | undefined>,
+	options: Required<WritethroughOptions>,
+): FileDiagnosticsResult | undefined {
+	const messages: string[] = [];
+	const servers = new Set<string>();
+	let hasResults = false;
+	let hasFormatter = false;
+	let formatted = false;
+
+	for (const result of results) {
+		if (!result) continue;
+		hasResults = true;
+		if (result.server) {
+			for (const server of result.server.split(",")) {
+				const trimmed = server.trim();
+				if (trimmed) {
+					servers.add(trimmed);
+				}
+			}
 		}
-		const { lspServers, customLinterServers } = splitServers(servers);
+		if (result.messages.length > 0) {
+			messages.push(...result.messages);
+		}
+		if (result.formatter !== undefined) {
+			hasFormatter = true;
+			if (result.formatter === FileFormatResult.FORMATTED) {
+				formatted = true;
+			}
+		}
+	}
+
+	if (!hasResults && !hasFormatter) {
+		return undefined;
+	}
 
-		let finalContent = content;
-		const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
-		const getWritePromise = once(() => writeContent(finalContent));
-		const useCustomFormatter = enableFormat && customLinterServers.length > 0;
+	let summary = options.enableDiagnostics ? "no issues" : "OK";
+	let errored = false;
+	if (messages.length > 0) {
+		const summaryInfo = summarizeDiagnosticMessages(messages);
+		summary = summaryInfo.summary;
+		errored = summaryInfo.errored;
+	}
+	const formatter = hasFormatter ? (formatted ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED) : undefined;
 
-		// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
-		const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+	return {
+		server: servers.size > 0 ? Array.from(servers).join(", ") : undefined,
+		messages,
+		summary,
+		errored,
+		formatter,
+	};
+}
 
-		let formatter: FileFormatResult | undefined;
-		let diagnostics: FileDiagnosticsResult | undefined;
-		try {
-			const timeoutSignal = AbortSignal.timeout(10_000);
-			const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			await untilAborted(operationSignal, async () => {
-				if (useCustomFormatter) {
-					// Custom linters (e.g. Biome CLI) require on-disk input.
-					await writeContent(content);
-					finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+async function runLspWritethrough(
+	dst: string,
+	content: string,
+	cwd: string,
+	options: Required<WritethroughOptions>,
+	signal?: AbortSignal,
+	file?: BunFile,
+): Promise<FileDiagnosticsResult | undefined> {
+	const { enableFormat, enableDiagnostics } = options;
+	const config = await getConfig(cwd);
+	const servers = getServersForFile(config, dst);
+	if (servers.length === 0) {
+		return writethroughNoop(dst, content, signal, file);
+	}
+	const { lspServers, customLinterServers } = splitServers(servers);
+
+	let finalContent = content;
+	const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
+	const getWritePromise = once(() => writeContent(finalContent));
+	const useCustomFormatter = enableFormat && customLinterServers.length > 0;
+
+	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
+	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+
+	let formatter: FileFormatResult | undefined;
+	let diagnostics: FileDiagnosticsResult | undefined;
+	try {
+		const timeoutSignal = AbortSignal.timeout(10_000);
+		const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+		await untilAborted(operationSignal, async () => {
+			if (useCustomFormatter) {
+				// Custom linters (e.g. Biome CLI) require on-disk input.
+				await writeContent(content);
+				finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+				formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
+				await writeContent(finalContent);
+				await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
+			} else {
+				// 1. Sync original content to LSP servers
+				await syncFileContent(dst, content, cwd, lspServers, operationSignal);
+
+				// 2. Format in-memory via LSP
+				if (enableFormat) {
+					finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
 					formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-					await writeContent(finalContent);
+				}
+
+				// 3. If formatted, sync formatted content to LSP servers
+				if (finalContent !== content) {
 					await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
-				} else {
-					// 1. Sync original content to LSP servers
-					await syncFileContent(dst, content, cwd, lspServers, operationSignal);
+				}
 
-					// 2. Format in-memory via LSP
-					if (enableFormat) {
-						finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
-						formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-					}
+				// 4. Write to disk
+				await getWritePromise();
+			}
 
-					// 3. If formatted, sync formatted content to LSP servers
-					if (finalContent !== content) {
-						await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
-					}
+			// 5. Notify saved to LSP servers
+			await notifyFileSaved(dst, cwd, lspServers, operationSignal);
 
-					// 4. Write to disk
-					await getWritePromise();
-				}
+			// 6. Get diagnostics from all servers (wait for fresh results)
+			if (enableDiagnostics) {
+				diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
+			}
+		});
+	} catch {
+		await getWritePromise();
+	}
 
-				// 5. Notify saved to LSP servers
-				await notifyFileSaved(dst, cwd, lspServers, operationSignal);
+	if (formatter !== undefined) {
+		diagnostics ??= {
+			server: servers.map(([name]) => name).join(", "),
+			messages: [],
+			summary: "OK",
+			errored: false,
+		};
+		diagnostics.formatter = formatter;
+	}
 
-				// 6. Get diagnostics from all servers (wait for fresh results)
-				if (enableDiagnostics) {
-					diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
-				}
-			});
-		} catch {
-			await getWritePromise();
+	return diagnostics;
+}
+
+async function flushWritethroughBatch(
+	batch: PendingWritethrough[],
+	cwd: string,
+	options: Required<WritethroughOptions>,
+	signal?: AbortSignal,
+): Promise<FileDiagnosticsResult | undefined> {
+	if (batch.length === 0) {
+		return undefined;
+	}
+	const results: Array<FileDiagnosticsResult | undefined> = [];
+	for (const entry of batch) {
+		results.push(await runLspWritethrough(entry.dst, entry.content, cwd, options, signal, entry.file));
+	}
+	return mergeDiagnostics(results, options);
+}
+
+/** Create a writethrough callback for LSP aware write operations */
+export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
+	const resolvedOptions: Required<WritethroughOptions> = {
+		enableFormat: options?.enableFormat ?? false,
+		enableDiagnostics: options?.enableDiagnostics ?? false,
+	};
+	if (!resolvedOptions.enableFormat && !resolvedOptions.enableDiagnostics) {
+		return writethroughNoop;
+	}
+	return async (
+		dst: string,
+		content: string,
+		signal?: AbortSignal,
+		file?: BunFile,
+		batch?: LspWritethroughBatchRequest,
+	) => {
+		if (!batch) {
+			return runLspWritethrough(dst, content, cwd, resolvedOptions, signal, file);
 		}
 
-		if (formatter !== undefined) {
-			diagnostics ??= {
-				server: servers.map(([name]) => name).join(", "),
-				messages: [],
-				summary: "OK",
-				errored: false,
-			};
-			diagnostics.formatter = formatter;
+		const state = getOrCreateWritethroughBatch(batch.id, resolvedOptions);
+		state.entries.set(dst, { dst, content, file });
+
+		if (!batch.flush) {
+			await writethroughNoop(dst, content, signal, file);
+			return undefined;
 		}
 
-		return diagnostics;
+		writethroughBatches.delete(batch.id);
+		return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal);
 	};
 }
 
-/** Create an LSP tool */
-export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema, LspToolDetails, Theme> | null {
-	if (session.enableLsp === false) {
-		return null;
+/**
+ * LSP tool for language server protocol operations.
+ */
+export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Theme> {
+	public readonly name = "lsp";
+	public readonly label = "LSP";
+	public readonly description: string;
+	public readonly parameters = lspSchema;
+	public readonly renderCall = renderCall;
+	public readonly renderResult = renderResult;
+
+	private readonly session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.session = session;
+		this.description = renderPromptTemplate(lspDescription);
 	}
-	return {
-		name: "lsp",
-		label: "LSP",
-		description: renderPromptTemplate(lspDescription),
-		parameters: lspSchema,
-		renderCall,
-		renderResult,
-		execute: async (_toolCallId, params: LspParams, _signal) => {
-			const {
-				action,
-				file,
-				files,
-				line,
-				column,
-				end_line,
-				end_character,
-				query,
-				new_name,
-				replacement,
-				kind,
-				apply,
-				action_index,
-				include_declaration,
-			} = params;
-
-			const config = await getConfig(session.cwd);
-
-			// Status action doesn't need a file
-			if (action === "status") {
-				const servers = Object.keys(config.servers);
-				const lspmuxState = await detectLspmux();
-				const lspmuxStatus = lspmuxState.available
-					? lspmuxState.running
-						? "lspmux: active (multiplexing enabled)"
-						: "lspmux: installed but server not running"
-					: "";
-
-				const serverStatus =
-					servers.length > 0
-						? `Active language servers: ${servers.join(", ")}`
-						: "No language servers configured for this project";
-
-				const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;
-				return {
-					content: [{ type: "text", text: output }],
-					details: { action, success: true },
-				};
-			}
 
-			// Workspace diagnostics - check entire project
-			if (action === "workspace_diagnostics") {
-				const result = await runWorkspaceDiagnostics(session.cwd, config);
+	static createIf(session: ToolSession): LspTool | null {
+		return session.enableLsp === false ? null : new LspTool(session);
+	}
+
+	public async execute(
+		_toolCallId: string,
+		params: LspParams,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<LspToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<LspToolDetails>> {
+		const {
+			action,
+			file,
+			files,
+			line,
+			column,
+			end_line,
+			end_character,
+			query,
+			new_name,
+			replacement,
+			kind,
+			apply,
+			action_index,
+			include_declaration,
+		} = params;
+
+		const config = await getConfig(this.session.cwd);
+
+		// Status action doesn't need a file
+		if (action === "status") {
+			const servers = Object.keys(config.servers);
+			const lspmuxState = await detectLspmux();
+			const lspmuxStatus = lspmuxState.available
+				? lspmuxState.running
+					? "lspmux: active (multiplexing enabled)"
+					: "lspmux: installed but server not running"
+				: "";
+
+			const serverStatus =
+				servers.length > 0
+					? `Active language servers: ${servers.join(", ")}`
+					: "No language servers configured for this project";
+
+			const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;
+			return {
+				content: [{ type: "text", text: output }],
+				details: { action, success: true },
+			};
+		}
+
+		// Workspace diagnostics - check entire project
+		if (action === "workspace_diagnostics") {
+			const result = await runWorkspaceDiagnostics(this.session.cwd, config);
+			return {
+				content: [
+					{
+						type: "text",
+						text: `Workspace diagnostics (${result.projectType.description}):\n${result.output}`,
+					},
+				],
+				details: { action, success: true },
+			};
+		}
+
+		// Diagnostics can be batch or single-file - queries all applicable servers
+		if (action === "diagnostics") {
+			const targets = files?.length ? files : file ? [file] : null;
+			if (!targets) {
 				return {
-					content: [
-						{
-							type: "text",
-							text: `Workspace diagnostics (${result.projectType.description}):\n${result.output}`,
-						},
-					],
-					details: { action, success: true },
+					content: [{ type: "text", text: "Error: file or files parameter required for diagnostics" }],
+					details: { action, success: false },
 				};
 			}
 
-			// Diagnostics can be batch or single-file - queries all applicable servers
-			if (action === "diagnostics") {
-				const targets = files?.length ? files : file ? [file] : null;
-				if (!targets) {
-					return {
-						content: [{ type: "text", text: "Error: file or files parameter required for diagnostics" }],
-						details: { action, success: false },
-					};
-				}
-
-				const detailed = Boolean(files?.length);
-				const results: string[] = [];
-				const allServerNames = new Set<string>();
+			const detailed = Boolean(files?.length);
+			const results: string[] = [];
+			const allServerNames = new Set<string>();
 
-				for (const target of targets) {
-					const resolved = resolveToCwd(target, session.cwd);
-					const servers = getServersForFile(config, resolved);
-					if (servers.length === 0) {
-						results.push(`${theme.status.error} ${target}: No language server found`);
-						continue;
-					}
+			for (const target of targets) {
+				const resolved = resolveToCwd(target, this.session.cwd);
+				const servers = getServersForFile(config, resolved);
+				if (servers.length === 0) {
+					results.push(`${theme.status.error} ${target}: No language server found`);
+					continue;
+				}
 
-					const uri = fileToUri(resolved);
-					const relPath = path.relative(session.cwd, resolved);
-					const allDiagnostics: Diagnostic[] = [];
-
-					// Query all applicable servers for this file
-					for (const [serverName, serverConfig] of servers) {
-						allServerNames.add(serverName);
-						try {
-							if (serverConfig.createClient) {
-								const linterClient = getLinterClient(serverName, serverConfig, session.cwd);
-								const diagnostics = await linterClient.lint(resolved);
-								allDiagnostics.push(...diagnostics);
-								continue;
-							}
-							const client = await getOrCreateClient(serverConfig, session.cwd);
-							const minVersion = client.diagnosticsVersion;
-							await refreshFile(client, resolved);
-							const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, minVersion);
+				const uri = fileToUri(resolved);
+				const relPath = path.relative(this.session.cwd, resolved);
+				const allDiagnostics: Diagnostic[] = [];
+
+				// Query all applicable servers for this file
+				for (const [serverName, serverConfig] of servers) {
+					allServerNames.add(serverName);
+					try {
+						if (serverConfig.createClient) {
+							const linterClient = getLinterClient(serverName, serverConfig, this.session.cwd);
+							const diagnostics = await linterClient.lint(resolved);
 							allDiagnostics.push(...diagnostics);
-						} catch {
-							// Server failed, continue with others
+							continue;
 						}
+						const client = await getOrCreateClient(serverConfig, this.session.cwd);
+						const minVersion = client.diagnosticsVersion;
+						await refreshFile(client, resolved);
+						const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, minVersion);
+						allDiagnostics.push(...diagnostics);
+					} catch {
+						// Server failed, continue with others
 					}
+				}
 
-					// Deduplicate diagnostics
-					const seen = new Set<string>();
-					const uniqueDiagnostics: Diagnostic[] = [];
-					for (const d of allDiagnostics) {
-						const key = `${d.range.start.line}:${d.range.start.character}:${d.range.end.line}:${d.range.end.character}:${d.message}`;
-						if (!seen.has(key)) {
-							seen.add(key);
-							uniqueDiagnostics.push(d);
-						}
+				// Deduplicate diagnostics
+				const seen = new Set<string>();
+				const uniqueDiagnostics: Diagnostic[] = [];
+				for (const d of allDiagnostics) {
+					const key = `${d.range.start.line}:${d.range.start.character}:${d.range.end.line}:${d.range.end.character}:${d.message}`;
+					if (!seen.has(key)) {
+						seen.add(key);
+						uniqueDiagnostics.push(d);
 					}
+				}
 
-					if (!detailed && targets.length === 1) {
-						if (uniqueDiagnostics.length === 0) {
-							return {
-								content: [{ type: "text", text: "No diagnostics" }],
-								details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
-							};
-						}
-
-						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
-						const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
-						const output = `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}`;
+				if (!detailed && targets.length === 1) {
+					if (uniqueDiagnostics.length === 0) {
 						return {
-							content: [{ type: "text", text: output }],
+							content: [{ type: "text", text: "No diagnostics" }],
 							details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 						};
 					}
 
-					if (uniqueDiagnostics.length === 0) {
-						results.push(`${theme.status.success} ${relPath}: no issues`);
-					} else {
-						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
-						results.push(`${theme.status.error} ${relPath}: ${summary}`);
-						for (const diag of uniqueDiagnostics) {
-							results.push(`  ${formatDiagnostic(diag, relPath)}`);
-						}
-					}
+					const summary = formatDiagnosticsSummary(uniqueDiagnostics);
+					const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
+					const output = `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}`;
+					return {
+						content: [{ type: "text", text: output }],
+						details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
+					};
 				}
 
-				return {
-					content: [{ type: "text", text: results.join("\n") }],
-					details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
-				};
+				if (uniqueDiagnostics.length === 0) {
+					results.push(`${theme.status.success} ${relPath}: no issues`);
+				} else {
+					const summary = formatDiagnosticsSummary(uniqueDiagnostics);
+					results.push(`${theme.status.error} ${relPath}: ${summary}`);
+					for (const diag of uniqueDiagnostics) {
+						results.push(`  ${formatDiagnostic(diag, relPath)}`);
+					}
+				}
 			}
 
-			const requiresFile =
-				!file &&
-				action !== "workspace_symbols" &&
-				action !== "flycheck" &&
-				action !== "ssr" &&
-				action !== "runnables" &&
-				action !== "reload_workspace";
+			return {
+				content: [{ type: "text", text: results.join("\n") }],
+				details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
+			};
+		}
 
-			if (requiresFile) {
-				return {
-					content: [{ type: "text", text: "Error: file parameter required for this action" }],
-					details: { action, success: false },
-				};
-			}
+		const requiresFile =
+			!file &&
+			action !== "workspace_symbols" &&
+			action !== "flycheck" &&
+			action !== "ssr" &&
+			action !== "runnables" &&
+			action !== "reload_workspace";
+
+		if (requiresFile) {
+			return {
+				content: [{ type: "text", text: "Error: file parameter required for this action" }],
+				details: { action, success: false },
+			};
+		}
 
-			const resolvedFile = file ? resolveToCwd(file, session.cwd) : null;
-			const serverInfo = resolvedFile
-				? getLspServerForFile(config, resolvedFile)
-				: getServerForWorkspaceAction(config, action);
+		const resolvedFile = file ? resolveToCwd(file, this.session.cwd) : null;
+		const serverInfo = resolvedFile
+			? getLspServerForFile(config, resolvedFile)
+			: getServerForWorkspaceAction(config, action);
 
-			if (!serverInfo) {
-				return {
-					content: [{ type: "text", text: "No language server found for this action" }],
-					details: { action, success: false },
-				};
-			}
+		if (!serverInfo) {
+			return {
+				content: [{ type: "text", text: "No language server found for this action" }],
+				details: { action, success: false },
+			};
+		}
 
-			const [serverName, serverConfig] = serverInfo;
+		const [serverName, serverConfig] = serverInfo;
 
-			try {
-				const client = await getOrCreateClient(serverConfig, session.cwd);
-				let targetFile = resolvedFile;
-				if (action === "runnables" && !targetFile) {
-					targetFile = findFileForServer(session.cwd, serverConfig);
-					if (!targetFile) {
-						return {
-							content: [{ type: "text", text: "Error: no matching files found for runnables" }],
-							details: { action, serverName, success: false },
-						};
-					}
+		try {
+			const client = await getOrCreateClient(serverConfig, this.session.cwd);
+			let targetFile = resolvedFile;
+			if (action === "runnables" && !targetFile) {
+				targetFile = findFileForServer(this.session.cwd, serverConfig);
+				if (!targetFile) {
+					return {
+						content: [{ type: "text", text: "Error: no matching files found for runnables" }],
+						details: { action, serverName, success: false },
+					};
 				}
+			}
 
-				if (targetFile) {
-					await ensureFileOpen(client, targetFile);
-				}
+			if (targetFile) {
+				await ensureFileOpen(client, targetFile);
+			}
+
+			const uri = targetFile ? fileToUri(targetFile) : "";
+			const position = { line: (line || 1) - 1, character: (column || 1) - 1 };
 
-				const uri = targetFile ? fileToUri(targetFile) : "";
-				const position = { line: (line || 1) - 1, character: (column || 1) - 1 };
+			let output: string;
 
-				let output: string;
+			switch (action) {
+				// =====================================================================
+				// Standard LSP Operations
+				// =====================================================================
 
-				switch (action) {
-					// =====================================================================
-					// Standard LSP Operations
-					// =====================================================================
+				case "definition": {
+					const result = (await sendRequest(client, "textDocument/definition", {
+						textDocument: { uri },
+						position,
+					})) as Location | Location[] | LocationLink | LocationLink[] | null;
 
-					case "definition": {
-						const result = (await sendRequest(client, "textDocument/definition", {
-							textDocument: { uri },
-							position,
-						})) as Location | Location[] | LocationLink | LocationLink[] | null;
+					if (!result) {
+						output = "No definition found";
+					} else {
+						const raw = Array.isArray(result) ? result : [result];
+						const locations = raw.flatMap((loc) => {
+							if ("uri" in loc) {
+								return [loc as Location];
+							}
+							if ("targetUri" in loc) {
+								// Use targetSelectionRange (the precise identifier range) with fallback to targetRange
+								const link = loc as LocationLink;
+								return [{ uri: link.targetUri, range: link.targetSelectionRange ?? link.targetRange }];
+							}
+							return [];
+						});
 
-						if (!result) {
+						if (locations.length === 0) {
 							output = "No definition found";
 						} else {
-							const raw = Array.isArray(result) ? result : [result];
-							const locations = raw.flatMap((loc) => {
-								if ("uri" in loc) {
-									return [loc as Location];
-								}
-								if ("targetUri" in loc) {
-									// Use targetSelectionRange (the precise identifier range) with fallback to targetRange
-									const link = loc as LocationLink;
-									return [{ uri: link.targetUri, range: link.targetSelectionRange ?? link.targetRange }];
-								}
-								return [];
-							});
-
-							if (locations.length === 0) {
-								output = "No definition found";
-							} else {
-								output = `Found ${locations.length} definition(s):\n${locations
-									.map((loc) => `  ${formatLocation(loc, session.cwd)}`)
-									.join("\n")}`;
-							}
+							output = `Found ${locations.length} definition(s):\n${locations
+								.map((loc) => `  ${formatLocation(loc, this.session.cwd)}`)
+								.join("\n")}`;
 						}
-						break;
 					}
+					break;
+				}
 
-					case "references": {
-						const result = (await sendRequest(client, "textDocument/references", {
-							textDocument: { uri },
-							position,
-							context: { includeDeclaration: include_declaration ?? true },
-						})) as Location[] | null;
+				case "references": {
+					const result = (await sendRequest(client, "textDocument/references", {
+						textDocument: { uri },
+						position,
+						context: { includeDeclaration: include_declaration ?? true },
+					})) as Location[] | null;
 
-						if (!result || result.length === 0) {
-							output = "No references found";
-						} else {
-							const lines = result.map((loc) => `  ${formatLocation(loc, session.cwd)}`);
-							output = `Found ${result.length} reference(s):\n${lines.join("\n")}`;
-						}
-						break;
+					if (!result || result.length === 0) {
+						output = "No references found";
+					} else {
+						const lines = result.map((loc) => `  ${formatLocation(loc, this.session.cwd)}`);
+						output = `Found ${result.length} reference(s):\n${lines.join("\n")}`;
 					}
+					break;
+				}
 
-					case "hover": {
-						const result = (await sendRequest(client, "textDocument/hover", {
-							textDocument: { uri },
-							position,
-						})) as Hover | null;
+				case "hover": {
+					const result = (await sendRequest(client, "textDocument/hover", {
+						textDocument: { uri },
+						position,
+					})) as Hover | null;
 
-						if (!result || !result.contents) {
-							output = "No hover information";
-						} else {
-							output = extractHoverText(result.contents);
-						}
-						break;
+					if (!result || !result.contents) {
+						output = "No hover information";
+					} else {
+						output = extractHoverText(result.contents);
 					}
+					break;
+				}
 
-					case "symbols": {
-						const result = (await sendRequest(client, "textDocument/documentSymbol", {
-							textDocument: { uri },
-						})) as (DocumentSymbol | SymbolInformation)[] | null;
+				case "symbols": {
+					const result = (await sendRequest(client, "textDocument/documentSymbol", {
+						textDocument: { uri },
+					})) as (DocumentSymbol | SymbolInformation)[] | null;
 
-						if (!result || result.length === 0) {
-							output = "No symbols found";
-						} else if (!targetFile) {
-							return {
-								content: [{ type: "text", text: "Error: file parameter required for symbols" }],
-								details: { action, serverName, success: false },
-							};
+					if (!result || result.length === 0) {
+						output = "No symbols found";
+					} else if (!targetFile) {
+						return {
+							content: [{ type: "text", text: "Error: file parameter required for symbols" }],
+							details: { action, serverName, success: false },
+						};
+					} else {
+						const relPath = path.relative(this.session.cwd, targetFile);
+						// Check if hierarchical (DocumentSymbol) or flat (SymbolInformation)
+						if ("selectionRange" in result[0]) {
+							// Hierarchical
+							const lines = (result as DocumentSymbol[]).flatMap((s) => formatDocumentSymbol(s));
+							output = `Symbols in ${relPath}:\n${lines.join("\n")}`;
 						} else {
-							const relPath = path.relative(session.cwd, targetFile);
-							// Check if hierarchical (DocumentSymbol) or flat (SymbolInformation)
-							if ("selectionRange" in result[0]) {
-								// Hierarchical
-								const lines = (result as DocumentSymbol[]).flatMap((s) => formatDocumentSymbol(s));
-								output = `Symbols in ${relPath}:\n${lines.join("\n")}`;
-							} else {
-								// Flat
-								const lines = (result as SymbolInformation[]).map((s) => {
-									const line = s.location.range.start.line + 1;
-									const icon = symbolKindToIcon(s.kind);
-									return `${icon} ${s.name} @ line ${line}`;
-								});
-								output = `Symbols in ${relPath}:\n${lines.join("\n")}`;
-							}
+							// Flat
+							const lines = (result as SymbolInformation[]).map((s) => {
+								const line = s.location.range.start.line + 1;
+								const icon = symbolKindToIcon(s.kind);
+								return `${icon} ${s.name} @ line ${line}`;
+							});
+							output = `Symbols in ${relPath}:\n${lines.join("\n")}`;
 						}
-						break;
 					}
+					break;
+				}
 
-					case "workspace_symbols": {
-						if (!query) {
-							return {
-								content: [{ type: "text", text: "Error: query parameter required for workspace_symbols" }],
-								details: { action, serverName, success: false },
-							};
-						}
+				case "workspace_symbols": {
+					if (!query) {
+						return {
+							content: [{ type: "text", text: "Error: query parameter required for workspace_symbols" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						const result = (await sendRequest(client, "workspace/symbol", { query })) as
-							| SymbolInformation[]
-							| null;
+					const result = (await sendRequest(client, "workspace/symbol", { query })) as SymbolInformation[] | null;
 
-						if (!result || result.length === 0) {
-							output = `No symbols matching "${query}"`;
-						} else {
-							const lines = result.map((s) => formatSymbolInformation(s, session.cwd));
-							output = `Found ${result.length} symbol(s) matching "${query}":\n${lines.map((l) => `  ${l}`).join("\n")}`;
-						}
-						break;
+					if (!result || result.length === 0) {
+						output = `No symbols matching "${query}"`;
+					} else {
+						const lines = result.map((s) => formatSymbolInformation(s, this.session.cwd));
+						output = `Found ${result.length} symbol(s) matching "${query}":\n${lines.map((l) => `  ${l}`).join("\n")}`;
 					}
+					break;
+				}
 
-					case "rename": {
-						if (!new_name) {
-							return {
-								content: [{ type: "text", text: "Error: new_name parameter required for rename" }],
-								details: { action, serverName, success: false },
-							};
-						}
+				case "rename": {
+					if (!new_name) {
+						return {
+							content: [{ type: "text", text: "Error: new_name parameter required for rename" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						const result = (await sendRequest(client, "textDocument/rename", {
-							textDocument: { uri },
-							position,
-							newName: new_name,
-						})) as WorkspaceEdit | null;
+					const result = (await sendRequest(client, "textDocument/rename", {
+						textDocument: { uri },
+						position,
+						newName: new_name,
+					})) as WorkspaceEdit | null;
 
-						if (!result) {
-							output = "Rename returned no edits";
+					if (!result) {
+						output = "Rename returned no edits";
+					} else {
+						const shouldApply = apply !== false;
+						if (shouldApply) {
+							const applied = await applyWorkspaceEdit(result, this.session.cwd);
+							output = `Applied rename:\n${applied.map((a) => `  ${a}`).join("\n")}`;
 						} else {
-							const shouldApply = apply !== false;
-							if (shouldApply) {
-								const applied = await applyWorkspaceEdit(result, session.cwd);
-								output = `Applied rename:\n${applied.map((a) => `  ${a}`).join("\n")}`;
-							} else {
-								const preview = formatWorkspaceEdit(result, session.cwd);
-								output = `Rename preview:\n${preview.map((p) => `  ${p}`).join("\n")}`;
-							}
+							const preview = formatWorkspaceEdit(result, this.session.cwd);
+							output = `Rename preview:\n${preview.map((p) => `  ${p}`).join("\n")}`;
 						}
-						break;
+					}
+					break;
+				}
+
+				case "actions": {
+					if (!targetFile) {
+						return {
+							content: [{ type: "text", text: "Error: file parameter required for actions" }],
+							details: { action, serverName, success: false },
+						};
+					}
+
+					const actionsMinVersion = client.diagnosticsVersion;
+					await refreshFile(client, targetFile);
+					const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, actionsMinVersion);
+					const endLine = (end_line ?? line ?? 1) - 1;
+					const endCharacter = (end_character ?? column ?? 1) - 1;
+					const range = { start: position, end: { line: endLine, character: endCharacter } };
+					const relevantDiagnostics = diagnostics.filter(
+						(d) => d.range.start.line <= range.end.line && d.range.end.line >= range.start.line,
+					);
+
+					const codeActionContext: { diagnostics: Diagnostic[]; only?: string[] } = {
+						diagnostics: relevantDiagnostics,
+					};
+					if (kind) {
+						codeActionContext.only = [kind];
 					}
 
-					case "actions": {
-						if (!targetFile) {
+					const result = (await sendRequest(client, "textDocument/codeAction", {
+						textDocument: { uri },
+						range,
+						context: codeActionContext,
+					})) as Array<CodeAction | Command> | null;
+
+					if (!result || result.length === 0) {
+						output = "No code actions available";
+					} else if (action_index !== undefined) {
+						// Apply specific action
+						if (action_index < 0 || action_index >= result.length) {
 							return {
-								content: [{ type: "text", text: "Error: file parameter required for actions" }],
+								content: [
+									{
+										type: "text",
+										text: `Error: action_index ${action_index} out of range (0-${result.length - 1})`,
+									},
+								],
 								details: { action, serverName, success: false },
 							};
 						}
 
-						const actionsMinVersion = client.diagnosticsVersion;
-						await refreshFile(client, targetFile);
-						const diagnostics = await waitForDiagnostics(client, uri, 3000, undefined, actionsMinVersion);
-						const endLine = (end_line ?? line ?? 1) - 1;
-						const endCharacter = (end_character ?? column ?? 1) - 1;
-						const range = { start: position, end: { line: endLine, character: endCharacter } };
-						const relevantDiagnostics = diagnostics.filter(
-							(d) => d.range.start.line <= range.end.line && d.range.end.line >= range.start.line,
-						);
-
-						const codeActionContext: { diagnostics: Diagnostic[]; only?: string[] } = {
-							diagnostics: relevantDiagnostics,
-						};
-						if (kind) {
-							codeActionContext.only = [kind];
-						}
-
-						const result = (await sendRequest(client, "textDocument/codeAction", {
-							textDocument: { uri },
-							range,
-							context: codeActionContext,
-						})) as Array<CodeAction | Command> | null;
-
-						if (!result || result.length === 0) {
-							output = "No code actions available";
-						} else if (action_index !== undefined) {
-							// Apply specific action
-							if (action_index < 0 || action_index >= result.length) {
-								return {
-									content: [
-										{
-											type: "text",
-											text: `Error: action_index ${action_index} out of range (0-${result.length - 1})`,
-										},
-									],
-									details: { action, serverName, success: false },
-								};
+						const isCommand = (candidate: CodeAction | Command): candidate is Command =>
+							typeof (candidate as Command).command === "string";
+						const isCodeAction = (candidate: CodeAction | Command): candidate is CodeAction =>
+							!isCommand(candidate);
+						const getCommandPayload = (
+							candidate: CodeAction | Command,
+						): { command: string; arguments?: unknown[] } | null => {
+							if (isCommand(candidate)) {
+								return { command: candidate.command, arguments: candidate.arguments };
 							}
-
-							const isCommand = (candidate: CodeAction | Command): candidate is Command =>
-								typeof (candidate as Command).command === "string";
-							const isCodeAction = (candidate: CodeAction | Command): candidate is CodeAction =>
-								!isCommand(candidate);
-							const getCommandPayload = (
-								candidate: CodeAction | Command,
-							): { command: string; arguments?: unknown[] } | null => {
-								if (isCommand(candidate)) {
-									return { command: candidate.command, arguments: candidate.arguments };
-								}
-								if (candidate.command) {
-									return { command: candidate.command.command, arguments: candidate.command.arguments };
-								}
-								return null;
-							};
-
-							const codeAction = result[action_index];
-
-							// Resolve if needed
-							let resolvedAction = codeAction;
-							if (
-								isCodeAction(codeAction) &&
-								!codeAction.edit &&
-								codeAction.data &&
-								client.serverCapabilities?.codeActionProvider
-							) {
-								const provider = client.serverCapabilities.codeActionProvider;
-								if (typeof provider === "object" && provider.resolveProvider) {
-									resolvedAction = (await sendRequest(client, "codeAction/resolve", codeAction)) as CodeAction;
-								}
+							if (candidate.command) {
+								return { command: candidate.command.command, arguments: candidate.command.arguments };
 							}
+							return null;
+						};
 
-							if (isCodeAction(resolvedAction) && resolvedAction.edit) {
-								const applied = await applyWorkspaceEdit(resolvedAction.edit, session.cwd);
-								output = `Applied "${codeAction.title}":\n${applied.map((a) => `  ${a}`).join("\n")}`;
-							} else {
-								const commandPayload = getCommandPayload(resolvedAction);
-								if (commandPayload) {
-									await sendRequest(client, "workspace/executeCommand", commandPayload);
-									output = `Executed "${codeAction.title}"`;
-								} else {
-									output = `Code action "${codeAction.title}" has no edits or command to apply`;
-								}
+						const codeAction = result[action_index];
+
+						// Resolve if needed
+						let resolvedAction = codeAction;
+						if (
+							isCodeAction(codeAction) &&
+							!codeAction.edit &&
+							codeAction.data &&
+							client.serverCapabilities?.codeActionProvider
+						) {
+							const provider = client.serverCapabilities.codeActionProvider;
+							if (typeof provider === "object" && provider.resolveProvider) {
+								resolvedAction = (await sendRequest(client, "codeAction/resolve", codeAction)) as CodeAction;
 							}
-						} else {
-							// List available actions
-							const lines = result.map((actionItem, i) => {
-								if ("kind" in actionItem || "isPreferred" in actionItem || "edit" in actionItem) {
-									const actionDetails = actionItem as CodeAction;
-									const preferred = actionDetails.isPreferred ? " (preferred)" : "";
-									const kindInfo = actionDetails.kind ? ` [${actionDetails.kind}]` : "";
-									return `  [${i}] ${actionDetails.title}${kindInfo}${preferred}`;
-								}
-								return `  [${i}] ${actionItem.title}`;
-							});
-							output = `Available code actions:\n${lines.join("\n")}\n\nUse action_index parameter to apply a specific action.`;
 						}
-						break;
-					}
 
-					case "incoming_calls":
-					case "outgoing_calls": {
-						// First, prepare the call hierarchy item at the cursor position
-						const prepareResult = (await sendRequest(client, "textDocument/prepareCallHierarchy", {
-							textDocument: { uri },
-							position,
-						})) as CallHierarchyItem[] | null;
-
-						if (!prepareResult || prepareResult.length === 0) {
-							output = "No callable symbol found at this position";
-							break;
-						}
-
-						const item = prepareResult[0];
-
-						if (action === "incoming_calls") {
-							const calls = (await sendRequest(client, "callHierarchy/incomingCalls", { item })) as
-								| CallHierarchyIncomingCall[]
-								| null;
-
-							if (!calls || calls.length === 0) {
-								output = `No callers found for "${item.name}"`;
-							} else {
-								const lines = calls.map((call) => {
-									const loc = { uri: call.from.uri, range: call.from.selectionRange };
-									const detail = call.from.detail ? ` (${call.from.detail})` : "";
-									return `  ${call.from.name}${detail} @ ${formatLocation(loc, session.cwd)}`;
-								});
-								output = `Found ${calls.length} caller(s) of "${item.name}":\n${lines.join("\n")}`;
-							}
+						if (isCodeAction(resolvedAction) && resolvedAction.edit) {
+							const applied = await applyWorkspaceEdit(resolvedAction.edit, this.session.cwd);
+							output = `Applied "${codeAction.title}":\n${applied.map((a) => `  ${a}`).join("\n")}`;
 						} else {
-							const calls = (await sendRequest(client, "callHierarchy/outgoingCalls", { item })) as
-								| CallHierarchyOutgoingCall[]
-								| null;
-
-							if (!calls || calls.length === 0) {
-								output = `"${item.name}" doesn't call any functions`;
+							const commandPayload = getCommandPayload(resolvedAction);
+							if (commandPayload) {
+								await sendRequest(client, "workspace/executeCommand", commandPayload);
+								output = `Executed "${codeAction.title}"`;
 							} else {
-								const lines = calls.map((call) => {
-									const loc = { uri: call.to.uri, range: call.to.selectionRange };
-									const detail = call.to.detail ? ` (${call.to.detail})` : "";
-									return `  ${call.to.name}${detail} @ ${formatLocation(loc, session.cwd)}`;
-								});
-								output = `"${item.name}" calls ${calls.length} function(s):\n${lines.join("\n")}`;
+								output = `Code action "${codeAction.title}" has no edits or command to apply`;
 							}
 						}
+					} else {
+						// List available actions
+						const lines = result.map((actionItem, i) => {
+							if ("kind" in actionItem || "isPreferred" in actionItem || "edit" in actionItem) {
+								const actionDetails = actionItem as CodeAction;
+								const preferred = actionDetails.isPreferred ? " (preferred)" : "";
+								const kindInfo = actionDetails.kind ? ` [${actionDetails.kind}]` : "";
+								return `  [${i}] ${actionDetails.title}${kindInfo}${preferred}`;
+							}
+							return `  [${i}] ${actionItem.title}`;
+						});
+						output = `Available code actions:\n${lines.join("\n")}\n\nUse action_index parameter to apply a specific action.`;
+					}
+					break;
+				}
+
+				case "incoming_calls":
+				case "outgoing_calls": {
+					// First, prepare the call hierarchy item at the cursor position
+					const prepareResult = (await sendRequest(client, "textDocument/prepareCallHierarchy", {
+						textDocument: { uri },
+						position,
+					})) as CallHierarchyItem[] | null;
+
+					if (!prepareResult || prepareResult.length === 0) {
+						output = "No callable symbol found at this position";
 						break;
 					}
 
-					// =====================================================================
-					// Rust-Analyzer Specific Operations
-					// =====================================================================
+					const item = prepareResult[0];
 
-					case "flycheck": {
-						if (!hasCapability(serverConfig, "flycheck")) {
-							return {
-								content: [{ type: "text", text: "Error: flycheck requires rust-analyzer" }],
-								details: { action, serverName, success: false },
-							};
-						}
+					if (action === "incoming_calls") {
+						const calls = (await sendRequest(client, "callHierarchy/incomingCalls", { item })) as
+							| CallHierarchyIncomingCall[]
+							| null;
 
-						await rustAnalyzer.flycheck(client, resolvedFile ?? undefined);
-						const collected: Array<{ filePath: string; diagnostic: Diagnostic }> = [];
-						for (const [diagUri, diags] of client.diagnostics.entries()) {
-							const relPath = path.relative(session.cwd, uriToFile(diagUri));
-							for (const diag of diags) {
-								collected.push({ filePath: relPath, diagnostic: diag });
-							}
+						if (!calls || calls.length === 0) {
+							output = `No callers found for "${item.name}"`;
+						} else {
+							const lines = calls.map((call) => {
+								const loc = { uri: call.from.uri, range: call.from.selectionRange };
+								const detail = call.from.detail ? ` (${call.from.detail})` : "";
+								return `  ${call.from.name}${detail} @ ${formatLocation(loc, this.session.cwd)}`;
+							});
+							output = `Found ${calls.length} caller(s) of "${item.name}":\n${lines.join("\n")}`;
 						}
+					} else {
+						const calls = (await sendRequest(client, "callHierarchy/outgoingCalls", { item })) as
+							| CallHierarchyOutgoingCall[]
+							| null;
 
-						if (collected.length === 0) {
-							output = "Flycheck: no issues found";
+						if (!calls || calls.length === 0) {
+							output = `"${item.name}" doesn't call any functions`;
 						} else {
-							const summary = formatDiagnosticsSummary(collected.map((d) => d.diagnostic));
-							const formatted = collected.slice(0, 20).map((d) => formatDiagnostic(d.diagnostic, d.filePath));
-							const more = collected.length > 20 ? `\n  ... and ${collected.length - 20} more` : "";
-							output = `Flycheck ${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}${more}`;
+							const lines = calls.map((call) => {
+								const loc = { uri: call.to.uri, range: call.to.selectionRange };
+								const detail = call.to.detail ? ` (${call.to.detail})` : "";
+								return `  ${call.to.name}${detail} @ ${formatLocation(loc, this.session.cwd)}`;
+							});
+							output = `"${item.name}" calls ${calls.length} function(s):\n${lines.join("\n")}`;
 						}
-						break;
 					}
+					break;
+				}
 
-					case "expand_macro": {
-						if (!hasCapability(serverConfig, "expandMacro")) {
-							return {
-								content: [{ type: "text", text: "Error: expand_macro requires rust-analyzer" }],
-								details: { action, serverName, success: false },
-							};
-						}
+				// =====================================================================
+				// Rust-Analyzer Specific Operations
+				// =====================================================================
 
-						if (!targetFile) {
-							return {
-								content: [{ type: "text", text: "Error: file parameter required for expand_macro" }],
-								details: { action, serverName, success: false },
-							};
-						}
+				case "flycheck": {
+					if (!hasCapability(serverConfig, "flycheck")) {
+						return {
+							content: [{ type: "text", text: "Error: flycheck requires rust-analyzer" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						const result = await rustAnalyzer.expandMacro(client, targetFile, line || 1, column || 1);
-						if (!result) {
-							output = "No macro expansion at this position";
-						} else {
-							output = `Macro: ${result.name}\n\nExpansion:\n${result.expansion}`;
+					await rustAnalyzer.flycheck(client, resolvedFile ?? undefined);
+					const collected: Array<{ filePath: string; diagnostic: Diagnostic }> = [];
+					for (const [diagUri, diags] of client.diagnostics.entries()) {
+						const relPath = path.relative(this.session.cwd, uriToFile(diagUri));
+						for (const diag of diags) {
+							collected.push({ filePath: relPath, diagnostic: diag });
 						}
-						break;
 					}
 
-					case "ssr": {
-						if (!hasCapability(serverConfig, "ssr")) {
-							return {
-								content: [{ type: "text", text: "Error: ssr requires rust-analyzer" }],
-								details: { action, serverName, success: false },
-							};
-						}
+					if (collected.length === 0) {
+						output = "Flycheck: no issues found";
+					} else {
+						const summary = formatDiagnosticsSummary(collected.map((d) => d.diagnostic));
+						const formatted = collected.slice(0, 20).map((d) => formatDiagnostic(d.diagnostic, d.filePath));
+						const more = collected.length > 20 ? `\n  ... and ${collected.length - 20} more` : "";
+						output = `Flycheck ${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}${more}`;
+					}
+					break;
+				}
 
-						if (!query) {
-							return {
-								content: [{ type: "text", text: "Error: query parameter (pattern) required for ssr" }],
-								details: { action, serverName, success: false },
-							};
-						}
+				case "expand_macro": {
+					if (!hasCapability(serverConfig, "expandMacro")) {
+						return {
+							content: [{ type: "text", text: "Error: expand_macro requires rust-analyzer" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						if (!replacement) {
-							return {
-								content: [{ type: "text", text: "Error: replacement parameter required for ssr" }],
-								details: { action, serverName, success: false },
-							};
-						}
+					if (!targetFile) {
+						return {
+							content: [{ type: "text", text: "Error: file parameter required for expand_macro" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						const shouldApply = apply === true;
-						const result = await rustAnalyzer.ssr(client, query, replacement, !shouldApply);
+					const result = await rustAnalyzer.expandMacro(client, targetFile, line || 1, column || 1);
+					if (!result) {
+						output = "No macro expansion at this position";
+					} else {
+						output = `Macro: ${result.name}\n\nExpansion:\n${result.expansion}`;
+					}
+					break;
+				}
 
-						if (shouldApply) {
-							const applied = await applyWorkspaceEdit(result, session.cwd);
-							output =
-								applied.length > 0
-									? `Applied SSR:\n${applied.map((a) => `  ${a}`).join("\n")}`
-									: "SSR: no matches found";
-						} else {
-							const preview = formatWorkspaceEdit(result, session.cwd);
-							output =
-								preview.length > 0
-									? `SSR preview:\n${preview.map((p) => `  ${p}`).join("\n")}`
-									: "SSR: no matches found";
-						}
-						break;
+				case "ssr": {
+					if (!hasCapability(serverConfig, "ssr")) {
+						return {
+							content: [{ type: "text", text: "Error: ssr requires rust-analyzer" }],
+							details: { action, serverName, success: false },
+						};
 					}
 
-					case "runnables": {
-						if (!hasCapability(serverConfig, "runnables")) {
-							return {
-								content: [{ type: "text", text: "Error: runnables requires rust-analyzer" }],
-								details: { action, serverName, success: false },
-							};
-						}
+					if (!query) {
+						return {
+							content: [{ type: "text", text: "Error: query parameter (pattern) required for ssr" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						if (!targetFile) {
-							return {
-								content: [{ type: "text", text: "Error: file parameter required for runnables" }],
-								details: { action, serverName, success: false },
-							};
-						}
+					if (!replacement) {
+						return {
+							content: [{ type: "text", text: "Error: replacement parameter required for ssr" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						const result = await rustAnalyzer.runnables(client, targetFile, line);
-						if (result.length === 0) {
-							output = "No runnables found";
-						} else {
-							const lines = result.map((r) => {
-								const args = r.args?.cargoArgs?.join(" ") || "";
-								return `  [${r.kind}] ${r.label}${args ? ` (cargo ${args})` : ""}`;
-							});
-							output = `Found ${result.length} runnable(s):\n${lines.join("\n")}`;
-						}
-						break;
+					const shouldApply = apply === true;
+					const result = await rustAnalyzer.ssr(client, query, replacement, !shouldApply);
+
+					if (shouldApply) {
+						const applied = await applyWorkspaceEdit(result, this.session.cwd);
+						output =
+							applied.length > 0
+								? `Applied SSR:\n${applied.map((a) => `  ${a}`).join("\n")}`
+								: "SSR: no matches found";
+					} else {
+						const preview = formatWorkspaceEdit(result, this.session.cwd);
+						output =
+							preview.length > 0
+								? `SSR preview:\n${preview.map((p) => `  ${p}`).join("\n")}`
+								: "SSR: no matches found";
 					}
+					break;
+				}
 
-					case "related_tests": {
-						if (!hasCapability(serverConfig, "relatedTests")) {
-							return {
-								content: [{ type: "text", text: "Error: related_tests requires rust-analyzer" }],
-								details: { action, serverName, success: false },
-							};
-						}
+				case "runnables": {
+					if (!hasCapability(serverConfig, "runnables")) {
+						return {
+							content: [{ type: "text", text: "Error: runnables requires rust-analyzer" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						if (!targetFile) {
-							return {
-								content: [{ type: "text", text: "Error: file parameter required for related_tests" }],
-								details: { action, serverName, success: false },
-							};
-						}
+					if (!targetFile) {
+						return {
+							content: [{ type: "text", text: "Error: file parameter required for runnables" }],
+							details: { action, serverName, success: false },
+						};
+					}
 
-						const result = await rustAnalyzer.relatedTests(client, targetFile, line || 1, column || 1);
-						if (result.length === 0) {
-							output = "No related tests found";
-						} else {
-							output = `Found ${result.length} related test(s):\n${result.map((t) => `  ${t}`).join("\n")}`;
-						}
-						break;
+					const result = await rustAnalyzer.runnables(client, targetFile, line);
+					if (result.length === 0) {
+						output = "No runnables found";
+					} else {
+						const lines = result.map((r) => {
+							const args = r.args?.cargoArgs?.join(" ") || "";
+							return `  [${r.kind}] ${r.label}${args ? ` (cargo ${args})` : ""}`;
+						});
+						output = `Found ${result.length} runnable(s):\n${lines.join("\n")}`;
 					}
+					break;
+				}
 
-					case "reload_workspace": {
-						await rustAnalyzer.reloadWorkspace(client);
-						output = "Workspace reloaded successfully";
-						break;
+				case "related_tests": {
+					if (!hasCapability(serverConfig, "relatedTests")) {
+						return {
+							content: [{ type: "text", text: "Error: related_tests requires rust-analyzer" }],
+							details: { action, serverName, success: false },
+						};
+					}
+
+					if (!targetFile) {
+						return {
+							content: [{ type: "text", text: "Error: file parameter required for related_tests" }],
+							details: { action, serverName, success: false },
+						};
 					}
 
-					default:
-						output = `Unknown action: ${action}`;
+					const result = await rustAnalyzer.relatedTests(client, targetFile, line || 1, column || 1);
+					if (result.length === 0) {
+						output = "No related tests found";
+					} else {
+						output = `Found ${result.length} related test(s):\n${result.map((t) => `  ${t}`).join("\n")}`;
+					}
+					break;
 				}
 
-				return {
-					content: [{ type: "text", text: output }],
-					details: { serverName, action, success: true },
-				};
-			} catch (err) {
-				const errorMessage = err instanceof Error ? err.message : String(err);
-				return {
-					content: [{ type: "text", text: `LSP error: ${errorMessage}` }],
-					details: { serverName, action, success: false },
-				};
+				case "reload_workspace": {
+					await rustAnalyzer.reloadWorkspace(client);
+					output = "Workspace reloaded successfully";
+					break;
+				}
+
+				default:
+					output = `Unknown action: ${action}`;
 			}
-		},
-	};
+
+			return {
+				content: [{ type: "text", text: output }],
+				details: { serverName, action, success: true },
+			};
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			return {
+				content: [{ type: "text", text: `LSP error: ${errorMessage}` }],
+				details: { serverName, action, success: false },
+			};
+		}
+	}
 }