@oh-my-pi/pi-coding-agent 0.1.0

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

@@ -0,0 +1,560 @@
+/**
+ * LSP Tool TUI Rendering
+ *
+ * Renders LSP tool calls and results in the TUI with:
+ * - Syntax-highlighted hover information
+ * - Color-coded diagnostics by severity
+ * - Grouped references and symbols
+ * - Collapsible/expandable views
+ */
+
+import type { AgentToolResult, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
+import { Text } from "@oh-my-pi/pi-tui";
+import { highlight, supportsLanguage } from "cli-highlight";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import type { LspParams, LspToolDetails } from "./types";
+
+// =============================================================================
+// Call Rendering
+// =============================================================================
+
+/**
+ * Render the LSP tool call in the TUI.
+ * Shows: "lsp <operation> <file/filecount>"
+ */
+export function renderCall(args: unknown, theme: Theme): Text {
+	const p = args as LspParams & { file?: string; files?: string[] };
+
+	let text = theme.fg("toolTitle", theme.bold("LSP "));
+	text += theme.fg("accent", p.action || "?");
+
+	if (p.file) {
+		text += ` ${theme.fg("muted", p.file)}`;
+	} else if (p.files?.length) {
+		text += ` ${theme.fg("muted", `${p.files.length} file(s)`)}`;
+	}
+
+	return new Text(text, 0, 0);
+}
+
+// =============================================================================
+// Result Rendering
+// =============================================================================
+
+/**
+ * Render LSP tool result with intelligent formatting based on result type.
+ * Detects hover, diagnostics, references, symbols, etc. and formats accordingly.
+ */
+export function renderResult(
+	result: AgentToolResult<LspToolDetails>,
+	options: RenderResultOptions,
+	theme: Theme,
+): Text {
+	const content = result.content?.[0];
+	if (!content || content.type !== "text" || !("text" in content) || !content.text) {
+		return new Text(theme.fg("error", "No result"), 0, 0);
+	}
+
+	const text = content.text;
+	const lines = text.split("\n").filter((l) => l.trim());
+	const expanded = options.expanded;
+
+	// Detect result type and render accordingly
+	const codeBlockMatch = text.match(/```(\w*)\n([\s\S]*?)```/);
+	if (codeBlockMatch) {
+		return renderHover(codeBlockMatch, text, lines, expanded, theme);
+	}
+
+	const errorMatch = text.match(/(\d+)\s+error\(s\)/);
+	const warningMatch = text.match(/(\d+)\s+warning\(s\)/);
+	if (errorMatch || warningMatch || text.includes(theme.status.error)) {
+		return renderDiagnostics(errorMatch, warningMatch, lines, expanded, theme);
+	}
+
+	const refMatch = text.match(/(\d+)\s+reference\(s\)/);
+	if (refMatch) {
+		return renderReferences(refMatch, lines, expanded, theme);
+	}
+
+	const symbolsMatch = text.match(/Symbols in (.+):/);
+	if (symbolsMatch) {
+		return renderSymbols(symbolsMatch, lines, expanded, theme);
+	}
+
+	// Default fallback rendering
+	return renderGeneric(text, lines, expanded, theme);
+}
+
+// =============================================================================
+// Hover Rendering
+// =============================================================================
+
+/**
+ * Render hover information with syntax-highlighted code blocks.
+ */
+function renderHover(
+	codeBlockMatch: RegExpMatchArray,
+	fullText: string,
+	_lines: string[],
+	expanded: boolean,
+	theme: Theme,
+): Text {
+	const lang = codeBlockMatch[1] || "";
+	const code = codeBlockMatch[2].trim();
+	const afterCode = fullText.slice(fullText.indexOf("```", 3) + 3).trim();
+
+	const codeLines = highlightCode(code, lang, theme);
+	const icon = theme.styledSymbol("status.info", "accent");
+	const langLabel = lang ? theme.fg("mdCodeBlockBorder", ` ${lang}`) : "";
+
+	if (expanded) {
+		const h = theme.boxSharp.horizontal;
+		const v = theme.boxSharp.vertical;
+		const top = `${theme.boxSharp.topLeft}${h.repeat(3)}`;
+		const bottom = `${theme.boxSharp.bottomLeft}${h.repeat(3)}`;
+		let output = `${icon} ${theme.fg("toolTitle", "Hover")}${langLabel}`;
+		output += `\n ${theme.fg("mdCodeBlockBorder", top)}`;
+		for (const line of codeLines) {
+			output += `\n ${theme.fg("mdCodeBlockBorder", v)} ${line}`;
+		}
+		output += `\n ${theme.fg("mdCodeBlockBorder", bottom)}`;
+		if (afterCode) {
+			output += `\n ${theme.fg("muted", afterCode)}`;
+		}
+		return new Text(output, 0, 0);
+	}
+
+	// Collapsed view
+	const firstCodeLine = codeLines[0] || "";
+	const expandHint = theme.fg("dim", " (Ctrl+O to expand)");
+
+	let output = `${icon} ${theme.fg("toolTitle", "Hover")}${langLabel}${expandHint}`;
+	const h = theme.boxSharp.horizontal;
+	const v = theme.boxSharp.vertical;
+	const bottom = `${theme.boxSharp.bottomLeft}${h.repeat(3)}`;
+	output += `\n ${theme.fg("mdCodeBlockBorder", v)} ${firstCodeLine}`;
+
+	if (codeLines.length > 1) {
+		output += `\n ${theme.fg("mdCodeBlockBorder", v)} ${theme.fg(
+			"muted",
+			`${theme.format.ellipsis} ${codeLines.length - 1} more lines`,
+		)}`;
+	}
+
+	if (afterCode) {
+		const ellipsis = theme.format.ellipsis;
+		const sliceLen = Math.max(0, 60 - ellipsis.length);
+		const docPreview = afterCode.length > 60 ? `${afterCode.slice(0, sliceLen)}${ellipsis}` : afterCode;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", docPreview)}`;
+	} else {
+		output += `\n ${theme.fg("mdCodeBlockBorder", bottom)}`;
+	}
+
+	return new Text(output, 0, 0);
+}
+
+/**
+ * Syntax highlight code using highlight.ts.
+ */
+function highlightCode(codeText: string, language: string, theme: Theme): string[] {
+	const validLang = language && supportsLanguage(language) ? language : undefined;
+	try {
+		const cliTheme = {
+			keyword: (s: string) => theme.fg("syntaxKeyword", s),
+			built_in: (s: string) => theme.fg("syntaxType", s),
+			literal: (s: string) => theme.fg("syntaxNumber", s),
+			number: (s: string) => theme.fg("syntaxNumber", s),
+			string: (s: string) => theme.fg("syntaxString", s),
+			comment: (s: string) => theme.fg("syntaxComment", s),
+			function: (s: string) => theme.fg("syntaxFunction", s),
+			title: (s: string) => theme.fg("syntaxFunction", s),
+			class: (s: string) => theme.fg("syntaxType", s),
+			type: (s: string) => theme.fg("syntaxType", s),
+			attr: (s: string) => theme.fg("syntaxVariable", s),
+			variable: (s: string) => theme.fg("syntaxVariable", s),
+			params: (s: string) => theme.fg("syntaxVariable", s),
+			operator: (s: string) => theme.fg("syntaxOperator", s),
+			punctuation: (s: string) => theme.fg("syntaxPunctuation", s),
+		};
+		return highlight(codeText, { language: validLang, ignoreIllegals: true, theme: cliTheme }).split("\n");
+	} catch {
+		return codeText.split("\n");
+	}
+}
+
+// =============================================================================
+// Diagnostics Rendering
+// =============================================================================
+
+/**
+ * Render diagnostics with color-coded severity.
+ */
+function renderDiagnostics(
+	errorMatch: RegExpMatchArray | null,
+	warningMatch: RegExpMatchArray | null,
+	lines: string[],
+	expanded: boolean,
+	theme: Theme,
+): Text {
+	const errorCount = errorMatch ? Number.parseInt(errorMatch[1], 10) : 0;
+	const warnCount = warningMatch ? Number.parseInt(warningMatch[1], 10) : 0;
+
+	const icon =
+		errorCount > 0
+			? theme.styledSymbol("status.error", "error")
+			: warnCount > 0
+				? theme.styledSymbol("status.warning", "warning")
+				: theme.styledSymbol("status.success", "success");
+
+	const meta: string[] = [];
+	if (errorCount > 0) meta.push(`${errorCount} error${errorCount !== 1 ? "s" : ""}`);
+	if (warnCount > 0) meta.push(`${warnCount} warning${warnCount !== 1 ? "s" : ""}`);
+	if (meta.length === 0) meta.push("No issues");
+
+	const diagLines = lines.filter((l) => l.includes(theme.status.error) || /:\d+:\d+/.test(l));
+	const parsedDiagnostics = diagLines
+		.map((line) => parseDiagnosticLine(line))
+		.filter((diag): diag is ParsedDiagnostic => diag !== null);
+	const fallbackDiagnostics: RawDiagnostic[] = diagLines.map((line) => ({ raw: line.trim() }));
+
+	if (expanded) {
+		let output = `${icon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", meta.join(", "))}`;
+		const items: DiagnosticItem[] = parsedDiagnostics.length > 0 ? parsedDiagnostics : fallbackDiagnostics;
+		for (let i = 0; i < items.length; i++) {
+			const item = items[i];
+			const isLast = i === items.length - 1;
+			const branch = isLast ? theme.tree.last : theme.tree.branch;
+			const detailPrefix = isLast ? "   " : `${theme.tree.vertical}  `;
+			if ("raw" in item) {
+				output += `\n ${theme.fg("dim", branch)} ${theme.fg("muted", item.raw)}`;
+				continue;
+			}
+			const severityColor = severityToColor(item.severity);
+			const location = `${item.file}:${item.line}:${item.col}`;
+			output += `\n ${theme.fg("dim", branch)} ${theme.fg(severityColor, location)} ${theme.fg(
+				"dim",
+				`[${item.severity}]`,
+			)}`;
+			if (item.message) {
+				output += `\n ${theme.fg("dim", detailPrefix)}${theme.fg("muted", trimTo(item.message, 120, theme))}`;
+			}
+		}
+		return new Text(output, 0, 0);
+	}
+
+	// Collapsed view
+	const expandHint = theme.fg("dim", " (Ctrl+O to expand)");
+	let output = `${icon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", meta.join(", "))}${expandHint}`;
+
+	const previewItems: DiagnosticItem[] =
+		parsedDiagnostics.length > 0 ? parsedDiagnostics.slice(0, 3) : fallbackDiagnostics.slice(0, 3);
+	const remaining =
+		(parsedDiagnostics.length > 0 ? parsedDiagnostics.length : fallbackDiagnostics.length) - previewItems.length;
+	for (let i = 0; i < previewItems.length; i++) {
+		const item = previewItems[i];
+		const isLast = i === previewItems.length - 1 && remaining <= 0;
+		const branch = isLast ? theme.tree.last : theme.tree.branch;
+		if ("raw" in item) {
+			output += `\n ${theme.fg("dim", branch)} ${theme.fg("muted", item.raw)}`;
+			continue;
+		}
+		const severityColor = severityToColor(item.severity);
+		const location = `${item.file}:${item.line}:${item.col}`;
+		const message = item.message ? ` ${theme.fg("muted", trimTo(item.message, 80, theme))}` : "";
+		output += `\n ${theme.fg("dim", branch)} ${theme.fg(severityColor, location)}${message}`;
+	}
+	if (remaining > 0) {
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+			"muted",
+			`${theme.format.ellipsis} ${remaining} more`,
+		)}`;
+	}
+
+	return new Text(output, 0, 0);
+}
+
+// =============================================================================
+// References Rendering
+// =============================================================================
+
+/**
+ * Render references grouped by file.
+ */
+function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded: boolean, theme: Theme): Text {
+	const refCount = Number.parseInt(refMatch[1], 10);
+	const icon =
+		refCount > 0 ? theme.styledSymbol("status.success", "success") : theme.styledSymbol("status.warning", "warning");
+
+	const locLines = lines.filter((l) => /^\s*\S+:\d+:\d+/.test(l));
+
+	// Group by file
+	const byFile = new Map<string, Array<[string, string]>>();
+	for (const loc of locLines) {
+		const match = loc.trim().match(/^(.+):(\d+):(\d+)$/);
+		if (match) {
+			const [, file, line, col] = match;
+			if (!byFile.has(file)) byFile.set(file, []);
+			byFile.get(file)!.push([line, col]);
+		}
+	}
+
+	const files = Array.from(byFile.keys());
+
+	const renderGrouped = (maxFiles: number, maxLocsPerFile: number, showHint: boolean): string => {
+		const expandHint = showHint ? theme.fg("dim", " (Ctrl+O to expand)") : "";
+		let output = `${icon} ${theme.fg("toolTitle", "References")} ${theme.fg("dim", `${refCount} found`)}${expandHint}`;
+
+		const filesToShow = files.slice(0, maxFiles);
+		for (let fi = 0; fi < filesToShow.length; fi++) {
+			const file = filesToShow[fi];
+			const locs = byFile.get(file)!;
+			const isLastFile = fi === filesToShow.length - 1 && files.length <= maxFiles;
+			const fileBranch = isLastFile ? theme.tree.last : theme.tree.branch;
+			const fileCont = isLastFile ? "   " : `${theme.tree.vertical}  `;
+
+			const fileMeta = `${locs.length} reference${locs.length !== 1 ? "s" : ""}`;
+			output += `\n ${theme.fg("dim", fileBranch)} ${theme.fg("accent", file)} ${theme.fg("dim", fileMeta)}`;
+
+			if (maxLocsPerFile > 0) {
+				const locsToShow = locs.slice(0, maxLocsPerFile);
+				for (let li = 0; li < locsToShow.length; li++) {
+					const [line, col] = locsToShow[li];
+					const isLastLoc = li === locsToShow.length - 1 && locs.length <= maxLocsPerFile;
+					const locBranch = isLastLoc ? theme.tree.last : theme.tree.branch;
+					const locCont = isLastLoc ? "   " : `${theme.tree.vertical}  `;
+					output += `\n ${theme.fg("dim", fileCont)}${theme.fg("dim", locBranch)} ${theme.fg(
+						"muted",
+						`line ${line}, col ${col}`,
+					)}`;
+					if (expanded) {
+						const context = `at ${file}:${line}:${col}`;
+						output += `\n ${theme.fg("dim", fileCont)}${theme.fg("dim", locCont)}${theme.fg(
+							"muted",
+							trimTo(context, 120, theme),
+						)}`;
+					}
+				}
+				if (locs.length > maxLocsPerFile) {
+					output += `\n ${theme.fg("dim", fileCont)}${theme.fg("dim", theme.tree.last)} ${theme.fg(
+						"muted",
+						`${theme.format.ellipsis} ${locs.length - maxLocsPerFile} more`,
+					)}`;
+				}
+			}
+		}
+
+		if (files.length > maxFiles) {
+			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+				"muted",
+				`${theme.format.ellipsis} ${files.length - maxFiles} more files`,
+			)}`;
+		}
+
+		return output;
+	};
+
+	if (expanded) {
+		return new Text(renderGrouped(files.length, 3, false), 0, 0);
+	}
+
+	return new Text(renderGrouped(3, 1, true), 0, 0);
+}
+
+// =============================================================================
+// Symbols Rendering
+// =============================================================================
+
+/**
+ * Render document symbols in a hierarchical tree.
+ */
+function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded: boolean, theme: Theme): Text {
+	const fileName = symbolsMatch[1];
+	const icon = theme.styledSymbol("status.info", "accent");
+
+	interface SymbolInfo {
+		name: string;
+		line: string;
+		indent: number;
+		icon: string;
+	}
+
+	const symbolLines = lines.filter((l) => l.includes("@") && l.includes("line"));
+	const symbols: SymbolInfo[] = [];
+
+	for (const line of symbolLines) {
+		const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+		const symMatch = line.trim().match(/^(\S+)\s+(.+?)\s*@\s*line\s*(\d+)/);
+		if (symMatch) {
+			symbols.push({ icon: symMatch[1], name: symMatch[2], line: symMatch[3], indent });
+		}
+	}
+
+	const isLastSibling = (i: number): boolean => {
+		const myIndent = symbols[i].indent;
+		for (let j = i + 1; j < symbols.length; j++) {
+			const nextIndent = symbols[j].indent;
+			if (nextIndent === myIndent) return false;
+			if (nextIndent < myIndent) return true;
+		}
+		return true;
+	};
+
+	const getPrefix = (i: number): string => {
+		const myIndent = symbols[i].indent;
+		if (myIndent === 0) return " ";
+
+		let prefix = " ";
+		for (let level = 2; level <= myIndent; level += 2) {
+			let ancestorIdx = -1;
+			for (let j = i - 1; j >= 0; j--) {
+				if (symbols[j].indent === level - 2) {
+					ancestorIdx = j;
+					break;
+				}
+			}
+			if (ancestorIdx >= 0 && isLastSibling(ancestorIdx)) {
+				prefix += "   ";
+			} else {
+				prefix += `${theme.tree.vertical}  `;
+			}
+		}
+		return prefix;
+	};
+
+	const topLevelCount = symbols.filter((s) => s.indent === 0).length;
+
+	if (expanded) {
+		let output = `${icon} ${theme.fg("toolTitle", "Symbols")} ${theme.fg("dim", `in ${fileName}`)}`;
+
+		for (let i = 0; i < symbols.length; i++) {
+			const sym = symbols[i];
+			const prefix = getPrefix(i);
+			const isLast = isLastSibling(i);
+			const branch = isLast ? theme.tree.last : theme.tree.branch;
+			const detailPrefix = isLast ? "   " : `${theme.tree.vertical}  `;
+			output += `\n${prefix}${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg(
+				"accent",
+				sym.name,
+			)}`;
+			output += `\n${prefix}${theme.fg("dim", detailPrefix)}${theme.fg("muted", `line ${sym.line}`)}`;
+		}
+		return new Text(output, 0, 0);
+	}
+
+	// Collapsed: show first 3 top-level symbols
+	const expandHint = theme.fg("dim", " (Ctrl+O to expand)");
+	let output = `${icon} ${theme.fg("toolTitle", "Symbols")} ${theme.fg("dim", `in ${fileName}`)}${expandHint}`;
+
+	const topLevel = symbols.filter((s) => s.indent === 0).slice(0, 3);
+	for (let i = 0; i < topLevel.length; i++) {
+		const sym = topLevel[i];
+		const isLast = i === topLevel.length - 1 && topLevelCount <= 3;
+		const branch = isLast ? theme.tree.last : theme.tree.branch;
+		output += `\n ${theme.fg("dim", branch)} ${theme.fg("accent", sym.icon)} ${theme.fg(
+			"accent",
+			sym.name,
+		)} ${theme.fg("muted", `line ${sym.line}`)}`;
+	}
+	if (topLevelCount > 3) {
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+			"muted",
+			`${theme.format.ellipsis} ${topLevelCount - 3} more`,
+		)}`;
+	}
+
+	return new Text(output, 0, 0);
+}
+
+// =============================================================================
+// Generic Rendering
+// =============================================================================
+
+/**
+ * Generic fallback rendering for unknown result types.
+ */
+function renderGeneric(text: string, lines: string[], expanded: boolean, theme: Theme): Text {
+	const hasError = text.includes("Error:") || text.includes(theme.status.error);
+	const hasSuccess = text.includes(theme.status.success) || text.includes("Applied");
+
+	const icon =
+		hasError && !hasSuccess
+			? theme.styledSymbol("status.error", "error")
+			: hasSuccess && !hasError
+				? theme.styledSymbol("status.success", "success")
+				: theme.styledSymbol("status.info", "accent");
+
+	if (expanded) {
+		let output = `${icon} ${theme.fg("toolTitle", "LSP")} ${theme.fg("dim", "Output")}`;
+		for (let i = 0; i < lines.length; i++) {
+			const isLast = i === lines.length - 1;
+			const branch = isLast ? theme.tree.last : theme.tree.branch;
+			output += `\n ${theme.fg("dim", branch)} ${lines[i]}`;
+		}
+		return new Text(output, 0, 0);
+	}
+
+	const firstLine = lines[0] || "No output";
+	const expandHint = lines.length > 1 ? theme.fg("dim", " (Ctrl+O to expand)") : "";
+	let output = `${icon} ${theme.fg("toolTitle", "LSP")} ${theme.fg("dim", firstLine.slice(0, 60))}${expandHint}`;
+
+	if (lines.length > 1) {
+		const previewLines = lines.slice(1, 4);
+		for (let i = 0; i < previewLines.length; i++) {
+			const isLast = i === previewLines.length - 1 && lines.length <= 4;
+			const branch = isLast ? theme.tree.last : theme.tree.branch;
+			output += `\n ${theme.fg("dim", branch)} ${theme.fg("dim", previewLines[i].trim().slice(0, 80))}`;
+		}
+		if (lines.length > 4) {
+			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
+				"muted",
+				`${theme.format.ellipsis} ${lines.length - 4} more lines`,
+			)}`;
+		}
+	}
+
+	return new Text(output, 0, 0);
+}
+
+// =============================================================================
+// Parsing Helpers
+// =============================================================================
+
+interface ParsedDiagnostic {
+	file: string;
+	line: string;
+	col: string;
+	severity: string;
+	message: string;
+}
+
+interface RawDiagnostic {
+	raw: string;
+}
+
+type DiagnosticItem = ParsedDiagnostic | RawDiagnostic;
+
+function parseDiagnosticLine(line: string): ParsedDiagnostic | null {
+	const match = line.trim().match(/^(.*):(\d+):(\d+)\s+\[(\w+)\]\s*(.*)$/);
+	if (!match) return null;
+	const [, file, lineNum, colNum, severity, message] = match;
+	return { file, line: lineNum, col: colNum, severity: severity.toLowerCase(), message };
+}
+
+function severityToColor(severity: string): "error" | "warning" | "accent" | "dim" {
+	switch (severity) {
+		case "error":
+			return "error";
+		case "warning":
+			return "warning";
+		case "info":
+			return "accent";
+		default:
+			return "dim";
+	}
+}
+
+function trimTo(value: string, maxLength: number, theme: Theme): string {
+	if (value.length <= maxLength) return value;
+	const sliceLen = Math.max(0, maxLength - theme.format.ellipsis.length);
+	return `${value.slice(0, sliceLen)}${theme.format.ellipsis}`;
+}

package/src/core/tools/lsp/rust-analyzer.ts

@@ -0,0 +1,145 @@
+import { sendNotification, sendRequest } from "./client";
+import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types";
+import { fileToUri } from "./utils";
+
+/**
+ * Wait for specified milliseconds.
+ */
+async function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Run flycheck (cargo check) and collect diagnostics.
+ * Sends rust-analyzer/runFlycheck notification and waits for diagnostics to accumulate.
+ *
+ * @param client - LSP client instance
+ * @param file - Optional file path to check (if not provided, checks entire workspace)
+ * @returns Array of all collected diagnostics
+ */
+export async function flycheck(client: LspClient, file?: string): Promise<Diagnostic[]> {
+	const textDocument = file ? { uri: fileToUri(file) } : null;
+	await sendNotification(client, "rust-analyzer/runFlycheck", { textDocument });
+
+	// Wait for diagnostics to accumulate (2 seconds as per reference)
+	await sleep(2000);
+
+	// Collect all diagnostics from client
+	const allDiags: Diagnostic[] = [];
+	for (const diags of Array.from(client.diagnostics.values())) {
+		allDiags.push(...diags);
+	}
+
+	return allDiags;
+}
+
+/**
+ * Expand macro at the given position.
+ *
+ * @param client - LSP client instance
+ * @param file - File path containing the macro
+ * @param line - 1-based line number
+ * @param character - 1-based character offset
+ * @returns ExpandMacroResult with macro name and expansion, or null if no macro at position
+ */
+export async function expandMacro(
+	client: LspClient,
+	file: string,
+	line: number,
+	character: number,
+): Promise<ExpandMacroResult | null> {
+	const result = (await sendRequest(client, "rust-analyzer/expandMacro", {
+		textDocument: { uri: fileToUri(file) },
+		position: { line: line - 1, character: character - 1 },
+	})) as ExpandMacroResult | null;
+
+	return result;
+}
+
+/**
+ * Perform structural search and replace (SSR).
+ *
+ * @param client - LSP client instance
+ * @param pattern - Search pattern
+ * @param replacement - Replacement pattern
+ * @param parseOnly - If true, returns matches only; if false, returns WorkspaceEdit to apply
+ * @returns WorkspaceEdit containing matches or changes to apply
+ */
+export async function ssr(
+	client: LspClient,
+	pattern: string,
+	replacement: string,
+	parseOnly = true,
+): Promise<WorkspaceEdit> {
+	const result = (await sendRequest(client, "experimental/ssr", {
+		query: `${pattern} ==>> ${replacement}`,
+		parseOnly,
+		textDocument: { uri: "" }, // SSR searches workspace-wide
+		position: { line: 0, character: 0 },
+		selections: [],
+	})) as WorkspaceEdit;
+
+	return result;
+}
+
+/**
+ * Get runnables (tests, binaries, examples) for a file.
+ *
+ * @param client - LSP client instance
+ * @param file - File path to query
+ * @param line - Optional 1-based line number to get runnables at specific position
+ * @returns Array of Runnable items
+ */
+export async function runnables(client: LspClient, file: string, line?: number): Promise<Runnable[]> {
+	const params: { textDocument: { uri: string }; position?: { line: number; character: number } } = {
+		textDocument: { uri: fileToUri(file) },
+	};
+
+	if (line !== undefined) {
+		params.position = { line: line - 1, character: 0 };
+	}
+
+	const result = (await sendRequest(client, "experimental/runnables", params)) as Runnable[];
+	return result ?? [];
+}
+
+/**
+ * Get related tests for a position (e.g., tests for a function).
+ *
+ * @param client - LSP client instance
+ * @param file - File path
+ * @param line - 1-based line number
+ * @param character - 1-based character offset
+ * @returns Array of test runnable labels
+ */
+export async function relatedTests(
+	client: LspClient,
+	file: string,
+	line: number,
+	character: number,
+): Promise<string[]> {
+	const tests = (await sendRequest(client, "rust-analyzer/relatedTests", {
+		textDocument: { uri: fileToUri(file) },
+		position: { line: line - 1, character: character - 1 },
+	})) as RelatedTest[];
+
+	if (!tests?.length) return [];
+
+	const labels: string[] = [];
+	for (const t of tests) {
+		if (t.runnable?.label) {
+			labels.push(t.runnable.label);
+		}
+	}
+
+	return labels;
+}
+
+/**
+ * Reload workspace (re-index Cargo projects).
+ *
+ * @param client - LSP client instance
+ */
+export async function reloadWorkspace(client: LspClient): Promise<void> {
+	await sendRequest(client, "rust-analyzer/reloadWorkspace", null);
+}