@oh-my-pi/pi-coding-agent 10.2.2 → 10.3.0

package/src/lsp/index.ts

@@ -22,17 +22,11 @@ import {
 	WARMUP_TIMEOUT_MS,
 } from "./client";
 import { getLinterClient } from "./clients";
-import { getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
+import { getServersForFile, type LspConfig, loadConfig } from "./config";
 import { applyTextEditsToString, applyWorkspaceEdit } from "./edits";
 import { detectLspmux } from "./lspmux";
 import { renderCall, renderResult } from "./render";
-import * as rustAnalyzer from "./rust-analyzer";
 import {
-	type CallHierarchyIncomingCall,
-	type CallHierarchyItem,
-	type CallHierarchyOutgoingCall,
-	type CodeAction,
-	type Command,
 	type Diagnostic,
 	type DocumentSymbol,
 	type Hover,
@@ -57,7 +51,6 @@ import {
 	formatSymbolInformation,
 	formatWorkspaceEdit,
 	symbolKindToIcon,
-	uriToFile,
 } from "./utils";
 
 export type { LspServerStatus } from "./client";
@@ -243,8 +236,6 @@ function getLspServerForFile(config: LspConfig, filePath: string): [string, Serv
 	return servers.length > 0 ? servers[0] : null;
 }
 
-const FILE_SEARCH_MAX_DEPTH = 5;
-const IGNORED_DIRS = new Set(["node_modules", "target", "dist", "build", ".git"]);
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 
 function limitDiagnosticMessages(messages: string[]): string[] {
@@ -254,84 +245,14 @@ function limitDiagnosticMessages(messages: string[]): string[] {
 	return messages.slice(0, DIAGNOSTIC_MESSAGE_LIMIT);
 }
 
-function findFileByExtensions(baseDir: string, extensions: string[], maxDepth: number): string | null {
-	const normalized = extensions.map(ext => ext.toLowerCase());
-	const search = (dir: string, depth: number): string | null => {
-		if (depth > maxDepth) return null;
-		const entries: fs.Dirent[] = [];
-		try {
-			const names = Array.from(new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: false }));
-			for (const name of names) {
-				const fullPath = path.join(dir, name);
-				let isDir = false;
-				try {
-					isDir = fs.statSync(fullPath).isDirectory();
-				} catch {
-					continue;
-				}
-				entries.push({ name, isFile: () => !isDir, isDirectory: () => isDir } as fs.Dirent);
-			}
-		} catch {
-			return null;
-		}
-
-		for (const entry of entries) {
-			if (entry.name.startsWith(".")) continue;
-			if (entry.isDirectory() && IGNORED_DIRS.has(entry.name)) continue;
-			const fullPath = path.join(dir, entry.name);
-
-			if (entry.isFile()) {
-				const lowerName = entry.name.toLowerCase();
-				if (normalized.some(ext => lowerName.endsWith(ext))) {
-					return fullPath;
-				}
-			} else if (entry.isDirectory()) {
-				const found = search(fullPath, depth + 1);
-				if (found) return found;
-			}
-		}
-		return null;
-	};
-
-	return search(baseDir, 0);
-}
-
-function findFileForServer(cwd: string, serverConfig: ServerConfig): string | null {
-	return findFileByExtensions(cwd, serverConfig.fileTypes, FILE_SEARCH_MAX_DEPTH);
-}
-
-function getRustServer(config: LspConfig): [string, ServerConfig] | null {
-	const entries = getLspServers(config);
-	const byName = entries.find(([name, server]) => name === "rust-analyzer" || server.command === "rust-analyzer");
-	if (byName) return byName;
-
-	for (const [name, server] of entries) {
-		if (
-			hasCapability(server, "flycheck") ||
-			hasCapability(server, "ssr") ||
-			hasCapability(server, "runnables") ||
-			hasCapability(server, "expandMacro") ||
-			hasCapability(server, "relatedTests")
-		) {
-			return [name, server];
-		}
-	}
-
-	return null;
-}
-
 function getServerForWorkspaceAction(config: LspConfig, action: string): [string, ServerConfig] | null {
 	const entries = getLspServers(config);
 	if (entries.length === 0) return null;
 
-	if (action === "workspace_symbols") {
+	if (action === "symbols" || action === "reload") {
 		return entries[0];
 	}
 
-	if (action === "flycheck" || action === "ssr" || action === "runnables" || action === "reload_workspace") {
-		return getRustServer(config);
-	}
-
 	return null;
 }
 
@@ -386,45 +307,9 @@ function detectProjectType(cwd: string): ProjectType {
 }
 
 /** Run workspace diagnostics command and parse output */
-async function runWorkspaceDiagnostics(
-	cwd: string,
-	config: LspConfig,
-): Promise<{ output: string; projectType: ProjectType }> {
+async function runWorkspaceDiagnostics(cwd: string): Promise<{ output: string; projectType: ProjectType }> {
 	const projectType = detectProjectType(cwd);
 
-	// For Rust, use flycheck via rust-analyzer if available
-	if (projectType.type === "rust") {
-		const rustServer = getRustServer(config);
-		if (rustServer && hasCapability(rustServer[1], "flycheck")) {
-			const [_serverName, serverConfig] = rustServer;
-			try {
-				const client = await getOrCreateClient(serverConfig, cwd);
-				await rustAnalyzer.flycheck(client);
-
-				const collected: Array<{ filePath: string; diagnostic: Diagnostic }> = [];
-				for (const [diagUri, diags] of client.diagnostics.entries()) {
-					const relPath = path.relative(cwd, uriToFile(diagUri));
-					for (const diag of diags) {
-						collected.push({ filePath: relPath, diagnostic: diag });
-					}
-				}
-
-				if (collected.length === 0) {
-					return { output: "No issues found", projectType };
-				}
-
-				const summary = formatDiagnosticsSummary(collected.map(d => d.diagnostic));
-				const formatted = collected.slice(0, 50).map(d => formatDiagnostic(d.diagnostic, d.filePath));
-				const more = collected.length > 50 ? `\n  ... and ${collected.length - 50} more` : "";
-				return { output: `${summary}:\n${formatted.map(f => `  ${f}`).join("\n")}${more}`, projectType };
-			} catch (err) {
-				logger.debug("LSP diagnostics failed, falling back to shell", { error: String(err) });
-				// Fall through to shell command
-			}
-		}
-	}
-
-	// Fall back to shell command
 	if (!projectType.command) {
 		return {
 			output: `Cannot detect project type. Supported: Rust (Cargo.toml), TypeScript (tsconfig.json), Go (go.mod), Python (pyproject.toml)`,
@@ -979,22 +864,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		_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 { action, file, files, line, column, query, new_name, apply, include_declaration } = params;
 
 		const config = getConfig(this.session.cwd);
 
@@ -1020,27 +890,20 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			};
 		}
 
-		// 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, request: params },
-			};
-		}
-
 		// Diagnostics can be batch or single-file - queries all applicable servers
 		if (action === "diagnostics") {
 			const targets = files?.length ? files : file ? [file] : null;
 			if (!targets) {
+				// No file specified - run workspace diagnostics
+				const result = await runWorkspaceDiagnostics(this.session.cwd);
 				return {
-					content: [{ type: "text", text: "Error: file or files parameter required for diagnostics" }],
-					details: { action, success: false },
+					content: [
+						{
+							type: "text",
+							text: `Workspace diagnostics (${result.projectType.description}):\n${result.output}`,
+						},
+					],
+					details: { action, success: true, request: params },
 				};
 			}
 
@@ -1125,13 +988,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			};
 		}
 
-		const requiresFile =
-			!file &&
-			action !== "workspace_symbols" &&
-			action !== "flycheck" &&
-			action !== "ssr" &&
-			action !== "runnables" &&
-			action !== "reload_workspace";
+		const requiresFile = !file && action !== "symbols" && action !== "reload";
 
 		if (requiresFile) {
 			return {
@@ -1156,16 +1013,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 		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 },
-					};
-				}
-			}
+			const targetFile = resolvedFile;
 
 			if (targetFile) {
 				await ensureFileOpen(client, targetFile);
@@ -1245,52 +1093,47 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				}
 
 				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 },
-						};
-					} 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")}`;
+					// If no file, do workspace symbol search (requires query)
+					if (!targetFile) {
+						if (!query) {
+							return {
+								content: [
+									{ type: "text", text: "Error: query parameter required for workspace symbol search" },
+								],
+								details: { action, serverName, success: false },
+							};
+						}
+						const result = (await sendRequest(client, "workspace/symbol", { query })) as
+							| SymbolInformation[]
+							| null;
+						if (!result || result.length === 0) {
+							output = `No symbols matching "${query}"`;
 						} 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")}`;
+							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 "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;
-
-					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")}`;
+						// File-based document symbols
+						const result = (await sendRequest(client, "textDocument/documentSymbol", {
+							textDocument: { uri },
+						})) as (DocumentSymbol | SymbolInformation)[] | null;
+
+						if (!result || result.length === 0) {
+							output = "No symbols found";
+						} else {
+							const relPath = path.relative(this.session.cwd, targetFile);
+							if ("selectionRange" in result[0]) {
+								const lines = (result as DocumentSymbol[]).flatMap(s => formatDocumentSymbol(s));
+								output = `Symbols in ${relPath}:\n${lines.join("\n")}`;
+							} else {
+								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;
 				}
@@ -1324,314 +1167,22 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 					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];
-					}
-
-					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 },
-							};
+				case "reload": {
+					// Try graceful reload first, fall back to kill
+					output = `Restarted ${serverName}`;
+					const reloadMethods = ["rust-analyzer/reloadWorkspace", "workspace/didChangeConfiguration"];
+					for (const method of reloadMethods) {
+						try {
+							await sendRequest(client, method, method.includes("Configuration") ? { settings: {} } : null);
+							output = `Reloaded ${serverName}`;
+							break;
+						} catch {
+							// Method not supported, try next
 						}
-
-						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 (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 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`;
-							}
-						}
-					} 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, 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 (!calls || calls.length === 0) {
-							output = `"${item.name}" doesn't call any functions`;
-						} 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, this.session.cwd)}`;
-							});
-							output = `"${item.name}" calls ${calls.length} function(s):\n${lines.join("\n")}`;
-						}
-					}
-					break;
-				}
-
-				// =====================================================================
-				// Rust-Analyzer Specific Operations
-				// =====================================================================
-
-				case "flycheck": {
-					if (!hasCapability(serverConfig, "flycheck")) {
-						return {
-							content: [{ type: "text", text: "Error: flycheck requires rust-analyzer" }],
-							details: { action, serverName, success: false },
-						};
+					if (output.startsWith("Restarted")) {
+						client.proc.kill();
 					}
-
-					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 });
-						}
-					}
-
-					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;
-				}
-
-				case "expand_macro": {
-					if (!hasCapability(serverConfig, "expandMacro")) {
-						return {
-							content: [{ type: "text", text: "Error: expand_macro requires rust-analyzer" }],
-							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 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;
-				}
-
-				case "ssr": {
-					if (!hasCapability(serverConfig, "ssr")) {
-						return {
-							content: [{ type: "text", text: "Error: ssr 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 (!replacement) {
-						return {
-							content: [{ type: "text", text: "Error: replacement parameter required for ssr" }],
-							details: { action, serverName, success: false },
-						};
-					}
-
-					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 "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 runnables" }],
-							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;
-				}
-
-				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 },
-						};
-					}
-
-					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;
-				}
-
-				case "reload_workspace": {
-					await rustAnalyzer.reloadWorkspace(client);
-					output = "Workspace reloaded successfully";
 					break;
 				}