gsd-pi 2.34.0-dev.bbb5216 → 2.34.0-dev.e6d9bed

package/packages/pi-coding-agent/src/core/lock-utils.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared file-locking utilities built on `proper-lockfile`.
+ *
+ * Centralises the synchronous retry-loop and async lock/release patterns
+ * that were previously duplicated across auth-storage, session-manager,
+ * settings-manager, and models-json-writer.
+ */
+
+import lockfile from "proper-lockfile";
+
+const DEFAULT_MAX_ATTEMPTS = 10;
+const DEFAULT_DELAY_MS = 20;
+
+/**
+ * Acquire a synchronous file lock with retry.
+ *
+ * Retries up to `maxAttempts` times when the lock is held by another process
+ * (ELOCKED), using a busy-wait between attempts.
+ *
+ * @returns A release function to unlock.
+ * @throws On non-ELOCKED errors or when all attempts are exhausted.
+ */
+export function acquireLockSyncWithRetry(
+	lockPath: string,
+	maxAttempts: number = DEFAULT_MAX_ATTEMPTS,
+	delayMs: number = DEFAULT_DELAY_MS,
+): () => void {
+	let lastError: unknown;
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			return lockfile.lockSync(lockPath, { realpath: false });
+		} catch (error) {
+			const code =
+				typeof error === "object" && error !== null && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ELOCKED" || attempt === maxAttempts) {
+				throw error;
+			}
+			lastError = error;
+			const start = Date.now();
+			while (Date.now() - start < delayMs) {
+				// Busy-wait to avoid changing callers to async.
+			}
+		}
+	}
+
+	throw (lastError as Error) ?? new Error("Failed to acquire file lock");
+}
+
+/**
+ * Non-throwing variant of {@link acquireLockSyncWithRetry}.
+ *
+ * Returns `undefined` instead of throwing when the lock cannot be acquired,
+ * allowing callers to proceed without the lock rather than losing data.
+ */
+export function tryAcquireLockSync(
+	lockPath: string,
+	maxAttempts: number = DEFAULT_MAX_ATTEMPTS,
+	delayMs: number = DEFAULT_DELAY_MS,
+): (() => void) | undefined {
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			return lockfile.lockSync(lockPath, { realpath: false });
+		} catch (error) {
+			const code =
+				typeof error === "object" && error !== null && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ELOCKED" || attempt === maxAttempts) {
+				// Non-fatal: proceed without lock rather than losing data
+				return undefined;
+			}
+			const start = Date.now();
+			while (Date.now() - start < delayMs) {
+				// Busy-wait to avoid changing callers to async.
+			}
+		}
+	}
+	return undefined;
+}
+
+export interface AsyncLockOptions {
+	/** Maximum staleness in ms before the lock is considered stale. */
+	staleMs?: number;
+	/** Called if the lock is compromised while held. */
+	onCompromised?: (err: Error) => void;
+}
+
+/**
+ * Acquire an async file lock with retries and optional staleness detection.
+ *
+ * Uses `proper-lockfile`'s async API with exponential-backoff retries.
+ *
+ * @returns A release function (async) to unlock.
+ */
+export async function acquireLockAsync(
+	lockPath: string,
+	options?: AsyncLockOptions,
+): Promise<() => Promise<void>> {
+	return lockfile.lock(lockPath, {
+		retries: {
+			retries: 10,
+			factor: 2,
+			minTimeout: 100,
+			maxTimeout: 10000,
+			randomize: true,
+		},
+		stale: options?.staleMs,
+		onCompromised: options?.onCompromised,
+	});
+}

package/packages/pi-coding-agent/src/core/lsp/client.ts

@@ -618,76 +618,6 @@ export async function ensureFileOpen(client: LspClient, filePath: string, signal
 	}
 }
 
-/**
- * Sync in-memory content to the LSP client without reading from disk.
- */
-export async function syncContent(
-	client: LspClient,
-	filePath: string,
-	content: string,
-	signal?: AbortSignal,
-): Promise<void> {
-	const uri = fileToUri(filePath);
-	const lockKey = `${client.name}:${uri}`;
-	throwIfAborted(signal);
-
-	const existingLock = fileOperationLocks.get(lockKey);
-	if (existingLock) {
-		await untilAborted(signal, () => existingLock);
-	}
-
-	const syncPromise = (async () => {
-		client.diagnostics.delete(uri);
-
-		const info = client.openFiles.get(uri);
-
-		if (!info) {
-			const languageId = detectLanguageId(filePath);
-			throwIfAborted(signal);
-			await sendNotification(client, "textDocument/didOpen", {
-				textDocument: {
-					uri,
-					languageId,
-					version: 1,
-					text: content,
-				},
-			});
-			client.openFiles.set(uri, { version: 1, languageId });
-			client.lastActivity = Date.now();
-			return;
-		}
-
-		const version = ++info.version;
-		throwIfAborted(signal);
-		await sendNotification(client, "textDocument/didChange", {
-			textDocument: { uri, version },
-			contentChanges: [{ text: content }],
-		});
-		client.lastActivity = Date.now();
-	})();
-
-	fileOperationLocks.set(lockKey, syncPromise);
-	try {
-		await syncPromise;
-	} finally {
-		fileOperationLocks.delete(lockKey);
-	}
-}
-
-/**
- * Notify LSP that a file was saved.
- */
-export async function notifySaved(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void> {
-	const uri = fileToUri(filePath);
-	const info = client.openFiles.get(uri);
-	if (!info) return;
-
-	throwIfAborted(signal);
-	await sendNotification(client, "textDocument/didSave", {
-		textDocument: { uri },
-	});
-	client.lastActivity = Date.now();
-}
 
 /**
  * Refresh a file in the LSP client.
@@ -761,7 +691,7 @@ export function notifyFileChanged(filePath: string): void {
 /**
  * Shutdown a specific client by key.
  */
-export function shutdownClient(key: string): void {
+function shutdownClient(key: string): void {
 	const client = clients.get(key);
 	if (!client) return;
 
@@ -865,7 +795,7 @@ export async function sendRequest(
 	return promise;
 }
 
-export async function sendNotification(client: LspClient, method: string, params: unknown): Promise<void> {
+async function sendNotification(client: LspClient, method: string, params: unknown): Promise<void> {
 	const notification: LspJsonRpcNotification = {
 		jsonrpc: "2.0",
 		method,
@@ -889,7 +819,7 @@ export async function sendNotification(client: LspClient, method: string, params
 /**
  * Shutdown all LSP clients.
  */
-export function shutdownAll(): void {
+function shutdownAll(): void {
 	const clientsToShutdown = Array.from(clients.values());
 	clients.clear();
 

package/packages/pi-coding-agent/src/core/lsp/config.ts

@@ -176,7 +176,7 @@ const LOCAL_BIN_PATHS: Array<{ markers: string[]; binDir: string }> = [
 	{ markers: ["go.mod", "go.sum"], binDir: "bin" },
 ];
 
-function which(command: string): string | null {
+export function which(command: string): string | null {
 	// On Windows, prefer `where.exe` over `which` — MSYS/Git Bash's `which`
 	// returns POSIX paths (/c/Users/...) that Node's spawn() can't execute.
 	// `where.exe` returns native Windows paths (C:\Users\...).
@@ -320,13 +320,5 @@ export function getServersForFile(config: LspConfig, filePath: string): Array<[s
 }
 
 export function getServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null {
-	const servers = getServersForFile(config, filePath);
-	return servers.length > 0 ? servers[0] : null;
-}
-
-export function hasCapability(
-	config: ServerConfig,
-	capability: keyof NonNullable<ServerConfig["capabilities"]>,
-): boolean {
-	return config.capabilities?.[capability] === true;
+	return getServersForFile(config, filePath)[0] ?? null;
 }

package/packages/pi-coding-agent/src/core/lsp/edits.ts

@@ -11,7 +11,7 @@ import { uriToFile } from "./utils.js";
  * Apply text edits to a string in-memory.
  * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
  */
-export function applyTextEditsToString(content: string, edits: TextEdit[]): string {
+function applyTextEditsToString(content: string, edits: TextEdit[]): string {
 	const lines = content.split("\n");
 
 	// Sort edits in reverse order (bottom-to-top, right-to-left)

package/packages/pi-coding-agent/src/core/lsp/index.ts

@@ -14,7 +14,7 @@ import {
 	setIdleTimeout,
 	WARMUP_TIMEOUT_MS,
 } from "./client.js";
-import { getServersForFile, type LspConfig, loadConfig, hasRootMarkers, resolveCommand } from "./config.js";
+import { getServerForFile, getServersForFile, type LspConfig, loadConfig, hasRootMarkers, resolveCommand } from "./config.js";
 import { applyTextEdits, applyWorkspaceEdit } from "./edits.js";
 import { ToolAbortError, clampTimeout, throwIfAborted } from "./helpers.js";
 import { detectLspmux } from "./lspmux.js";
@@ -144,15 +144,6 @@ function getLspServers(config: LspConfig): Array<[string, ServerConfig]> {
 	return Object.entries(config.servers) as Array<[string, ServerConfig]>;
 }
 
-function getLspServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]> {
-	return getServersForFile(config, filePath);
-}
-
-function getLspServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null {
-	const servers = getLspServersForFile(config, filePath);
-	return servers.length > 0 ? servers[0] : null;
-}
-
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
 const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
@@ -197,6 +188,73 @@ async function formatLocationWithContext(location: Location, cwd: string): Promi
 	return `${header}\n${context.map(lineText => `    ${lineText}`).join("\n")}`;
 }
 
+async function formatLocationResults(
+	result: Location | Location[] | LocationLink | LocationLink[] | null,
+	label: string,
+	cwd: string,
+): Promise<string> {
+	const locations = normalizeLocationResult(result);
+	if (locations.length === 0) {
+		return `No ${label} found`;
+	}
+	const lines = await Promise.all(locations.map(location => formatLocationWithContext(location, cwd)));
+	return `Found ${locations.length} ${label}(s):\n${lines.join("\n")}`;
+}
+
+async function formatCallHierarchyResults(
+	client: LspClient,
+	position: { line: number; character: number },
+	uri: string,
+	direction: "incoming" | "outgoing",
+	cwd: string,
+	signal?: AbortSignal,
+): Promise<string> {
+	const prepareResult = (await sendRequest(
+		client,
+		"textDocument/prepareCallHierarchy",
+		{ textDocument: { uri }, position },
+		signal,
+	)) as CallHierarchyItem[] | null;
+
+	if (!prepareResult || prepareResult.length === 0) {
+		return "No call hierarchy item found at this position";
+	}
+
+	const method = direction === "incoming" ? "callHierarchy/incomingCalls" : "callHierarchy/outgoingCalls";
+	const callResult = (await sendRequest(client, method, { item: prepareResult[0] }, signal)) as
+		| CallHierarchyIncomingCall[]
+		| CallHierarchyOutgoingCall[]
+		| null;
+
+	if (!callResult || callResult.length === 0) {
+		const verb = direction === "incoming" ? "incoming calls" : "outgoing calls";
+		const prep = direction === "incoming" ? "for" : "from";
+		return `No ${verb} found ${prep} ${prepareResult[0].name}`;
+	}
+
+	const lines: string[] = [];
+	const limited = callResult.slice(0, REFERENCE_CONTEXT_LIMIT);
+	for (const call of limited) {
+		const item = "from" in call ? call.from : call.to;
+		const header = formatCallHierarchyItem(item, cwd);
+		const filePath = uriToFile(item.uri);
+		const callLine = ("from" in call ? call.fromRanges[0]?.start.line : undefined) ?? item.selectionRange.start.line;
+		const context = await readLocationContext(filePath, callLine + 1, LOCATION_CONTEXT_LINES);
+		if (context.length > 0) {
+			lines.push(`  ${header}\n${context.map(l => `    ${l}`).join("\n")}`);
+		} else {
+			lines.push(`  ${header}`);
+		}
+	}
+
+	const noun = direction === "incoming" ? "caller" : "callee";
+	const prep = direction === "incoming" ? "of" : "from";
+	const truncation = callResult.length > REFERENCE_CONTEXT_LIMIT
+		? `\n  ... ${callResult.length - REFERENCE_CONTEXT_LIMIT} additional ${noun}(s) omitted`
+		: "";
+	return `${callResult.length} ${noun}(s) ${prep} ${prepareResult[0].name}:\n${lines.join("\n")}${truncation}`;
+}
+
 async function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string> {
 	let output = `Restarted ${serverName}`;
 	const reloadMethods = ["rust-analyzer/reloadWorkspace", "workspace/didChangeConfiguration"];
@@ -647,7 +705,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 			}
 
 			// File-specific actions
-			const serverInfo = resolvedFile ? getLspServerForFile(config, resolvedFile) : null;
+			const serverInfo = resolvedFile ? getServerForFile(config, resolvedFile) : null;
 			if (!serverInfo) {
 				return {
 					content: [{ type: "text", text: "No language server found for this action" }],
@@ -676,74 +734,35 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 
 				switch (action) {
 					case "definition": {
-						const result = (await sendRequest(
+						const result = await sendRequest(
 							client,
 							"textDocument/definition",
-							{
-								textDocument: { uri },
-								position,
-							},
+							{ textDocument: { uri }, position },
 							signal,
-						)) as Location | Location[] | LocationLink | LocationLink[] | null;
-
-						const locations = normalizeLocationResult(result);
-
-						if (locations.length === 0) {
-							output = "No definition found";
-						} else {
-							const lines = await Promise.all(
-								locations.map(location => formatLocationWithContext(location, cwd)),
-							);
-							output = `Found ${locations.length} definition(s):\n${lines.join("\n")}`;
-						}
+						);
+						output = await formatLocationResults(result as Location | Location[] | LocationLink | LocationLink[] | null, "definition", cwd);
 						break;
 					}
 
 					case "type_definition": {
-						const result = (await sendRequest(
+						const result = await sendRequest(
 							client,
 							"textDocument/typeDefinition",
-							{
-								textDocument: { uri },
-								position,
-							},
+							{ textDocument: { uri }, position },
 							signal,
-						)) as Location | Location[] | LocationLink | LocationLink[] | null;
-
-						const locations = normalizeLocationResult(result);
-
-						if (locations.length === 0) {
-							output = "No type definition found";
-						} else {
-							const lines = await Promise.all(
-								locations.map(location => formatLocationWithContext(location, cwd)),
-							);
-							output = `Found ${locations.length} type definition(s):\n${lines.join("\n")}`;
-						}
+						);
+						output = await formatLocationResults(result as Location | Location[] | LocationLink | LocationLink[] | null, "type definition", cwd);
 						break;
 					}
 
 					case "implementation": {
-						const result = (await sendRequest(
+						const result = await sendRequest(
 							client,
 							"textDocument/implementation",
-							{
-								textDocument: { uri },
-								position,
-							},
+							{ textDocument: { uri }, position },
 							signal,
-						)) as Location | Location[] | LocationLink | LocationLink[] | null;
-
-						const locations = normalizeLocationResult(result);
-
-						if (locations.length === 0) {
-							output = "No implementation found";
-						} else {
-							const lines = await Promise.all(
-								locations.map(location => formatLocationWithContext(location, cwd)),
-							);
-							output = `Found ${locations.length} implementation(s):\n${lines.join("\n")}`;
-						}
+						);
+						output = await formatLocationResults(result as Location | Location[] | LocationLink | LocationLink[] | null, "implementation", cwd);
 						break;
 					}
 
@@ -917,100 +936,12 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 					}
 
 					case "incoming_calls": {
-						const prepareResult = (await sendRequest(
-							client,
-							"textDocument/prepareCallHierarchy",
-							{
-								textDocument: { uri },
-								position,
-							},
-							signal,
-						)) as CallHierarchyItem[] | null;
-
-						if (!prepareResult || prepareResult.length === 0) {
-							output = "No call hierarchy item found at this position";
-							break;
-						}
-
-						const incomingResult = (await sendRequest(
-							client,
-							"callHierarchy/incomingCalls",
-							{ item: prepareResult[0] },
-							signal,
-						)) as CallHierarchyIncomingCall[] | null;
-
-						if (!incomingResult || incomingResult.length === 0) {
-							output = `No incoming calls found for ${prepareResult[0].name}`;
-							break;
-						}
-
-						const incomingLines: string[] = [];
-						const limitedIncoming = incomingResult.slice(0, REFERENCE_CONTEXT_LIMIT);
-						for (const call of limitedIncoming) {
-							const header = formatCallHierarchyItem(call.from, cwd);
-							const filePath = uriToFile(call.from.uri);
-							const callLine = call.fromRanges[0]?.start.line ?? call.from.selectionRange.start.line;
-							const context = await readLocationContext(filePath, callLine + 1, LOCATION_CONTEXT_LINES);
-							if (context.length > 0) {
-								incomingLines.push(`  ${header}\n${context.map(l => `    ${l}`).join("\n")}`);
-							} else {
-								incomingLines.push(`  ${header}`);
-							}
-						}
-
-						const truncation = incomingResult.length > REFERENCE_CONTEXT_LIMIT
-							? `\n  ... ${incomingResult.length - REFERENCE_CONTEXT_LIMIT} additional caller(s) omitted`
-							: "";
-						output = `${incomingResult.length} caller(s) of ${prepareResult[0].name}:\n${incomingLines.join("\n")}${truncation}`;
+						output = await formatCallHierarchyResults(client, position, uri, "incoming", cwd, signal);
 						break;
 					}
 
 					case "outgoing_calls": {
-						const prepareResult = (await sendRequest(
-							client,
-							"textDocument/prepareCallHierarchy",
-							{
-								textDocument: { uri },
-								position,
-							},
-							signal,
-						)) as CallHierarchyItem[] | null;
-
-						if (!prepareResult || prepareResult.length === 0) {
-							output = "No call hierarchy item found at this position";
-							break;
-						}
-
-						const outgoingResult = (await sendRequest(
-							client,
-							"callHierarchy/outgoingCalls",
-							{ item: prepareResult[0] },
-							signal,
-						)) as CallHierarchyOutgoingCall[] | null;
-
-						if (!outgoingResult || outgoingResult.length === 0) {
-							output = `No outgoing calls found from ${prepareResult[0].name}`;
-							break;
-						}
-
-						const outgoingLines: string[] = [];
-						const limitedOutgoing = outgoingResult.slice(0, REFERENCE_CONTEXT_LIMIT);
-						for (const call of limitedOutgoing) {
-							const header = formatCallHierarchyItem(call.to, cwd);
-							const filePath = uriToFile(call.to.uri);
-							const callLine = call.to.selectionRange.start.line;
-							const context = await readLocationContext(filePath, callLine + 1, LOCATION_CONTEXT_LINES);
-							if (context.length > 0) {
-								outgoingLines.push(`  ${header}\n${context.map(l => `    ${l}`).join("\n")}`);
-							} else {
-								outgoingLines.push(`  ${header}`);
-							}
-						}
-
-						const outTruncation = outgoingResult.length > REFERENCE_CONTEXT_LIMIT
-							? `\n  ... ${outgoingResult.length - REFERENCE_CONTEXT_LIMIT} additional callee(s) omitted`
-							: "";
-						output = `${outgoingResult.length} callee(s) from ${prepareResult[0].name}:\n${outgoingLines.join("\n")}${outTruncation}`;
+						output = await formatCallHierarchyResults(client, position, uri, "outgoing", cwd, signal);
 						break;
 					}
 

package/packages/pi-coding-agent/src/core/lsp/lspmux.ts

@@ -1,8 +1,9 @@
-import { execSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import * as fsPromises from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { LSP_LIVENESS_TIMEOUT_MS, LSP_STATE_CACHE_TTL_MS } from "../constants.js";
+import { which } from "./config.js";
 
 /**
  * lspmux integration for LSP server multiplexing.
@@ -43,27 +44,6 @@ const DEFAULT_SUPPORTED_SERVERS = new Set([
 ]);
 
 
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function which(command: string): string | null {
-	try {
-		// On Windows, prefer `where.exe` over `which` — MSYS/Git Bash's `which`
-		// returns POSIX paths (/c/Users/...) that Node's spawn() can't execute (#1121).
-		const isWindows = process.platform === "win32";
-		const cmd = isWindows ? "where.exe" : "which";
-		const result = isWindows
-			? execSync(`${cmd} ${command}`, { encoding: "utf-8" })
-			: execSync(`which ${command}`, { encoding: "utf-8" });
-		// `where.exe` may return multiple lines — take the first
-		const resolved = result.trim().split(/\r?\n/)[0]?.trim();
-		return resolved || null;
-	} catch {
-		return null;
-	}
-}
-
 // =============================================================================
 // Config Path
 // =============================================================================
@@ -172,7 +152,7 @@ export interface LspmuxWrappedCommand {
 	env?: Record<string, string>;
 }
 
-export function wrapWithLspmux(
+function wrapWithLspmux(
 	originalCommand: string,
 	originalArgs: string[] | undefined,
 	state: LspmuxState,

package/packages/pi-coding-agent/src/core/lsp/types.ts

@@ -256,35 +256,6 @@ export type SymbolKind =
 	| 25 // Operator
 	| 26; // TypeParameter
 
-export const SYMBOL_KIND_NAMES: Record<SymbolKind, string> = {
-	1: "File",
-	2: "Module",
-	3: "Namespace",
-	4: "Package",
-	5: "Class",
-	6: "Method",
-	7: "Property",
-	8: "Field",
-	9: "Constructor",
-	10: "Enum",
-	11: "Interface",
-	12: "Function",
-	13: "Variable",
-	14: "Constant",
-	15: "String",
-	16: "Number",
-	17: "Boolean",
-	18: "Array",
-	19: "Object",
-	20: "Key",
-	21: "Null",
-	22: "EnumMember",
-	23: "Struct",
-	24: "Event",
-	25: "Operator",
-	26: "TypeParameter",
-};
-
 export interface DocumentSymbol {
 	name: string;
 	detail?: string;

package/packages/pi-coding-agent/src/core/lsp/utils.ts

@@ -192,7 +192,7 @@ const SEVERITY_NAMES: Record<DiagnosticSeverity, string> = {
 	4: "hint",
 };
 
-export function severityToString(severity?: DiagnosticSeverity): string {
+function severityToString(severity?: DiagnosticSeverity): string {
 	return SEVERITY_NAMES[severity ?? 1] ?? "unknown";
 }
 
@@ -211,21 +211,6 @@ export function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[] {
 	});
 }
 
-export function severityToIcon(severity?: DiagnosticSeverity): string {
-	switch (severity ?? 1) {
-		case 1:
-			return "[E]";
-		case 2:
-			return "[W]";
-		case 3:
-			return "[I]";
-		case 4:
-			return "[H]";
-		default:
-			return "[E]";
-	}
-}
-
 function stripDiagnosticNoise(message: string): string {
 	return message
 		.split("\n")
@@ -353,10 +338,6 @@ export function formatLocation(location: Location, cwd: string): string {
 	return `${file}:${line}:${col}`;
 }
 
-export function formatPosition(line: number, col: number): string {
-	return `${line}:${col}`;
-}
-
 // =============================================================================
 // WorkspaceEdit Formatting
 // =============================================================================
@@ -397,15 +378,6 @@ export function formatWorkspaceEdit(edit: WorkspaceEdit, cwd: string): string[]
 	return results;
 }
 
-export function formatTextEdit(edit: TextEdit, maxLength = 50): string {
-	const range = `${edit.range.start.line + 1}:${edit.range.start.character + 1}`;
-	const preview =
-		edit.newText.length > maxLength
-			? `${edit.newText.slice(0, maxLength).replace(/\n/g, "\\n")}…`
-			: edit.newText.replace(/\n/g, "\\n");
-	return `line ${range} -> "${preview}"`;
-}
-
 // =============================================================================
 // Symbol Formatting
 // =============================================================================
@@ -443,10 +415,6 @@ export function symbolKindToIcon(kind: SymbolKind): string {
 	return `[${SYMBOL_KIND_LABELS[kind] ?? "?"}]`;
 }
 
-export function symbolKindToName(kind: SymbolKind): string {
-	return SYMBOL_KIND_LABELS[kind] ?? "Unknown";
-}
-
 export function formatDocumentSymbol(symbol: DocumentSymbol, indent = 0): string[] {
 	const prefix = "  ".repeat(indent);
 	const icon = symbolKindToIcon(symbol.kind);