@oh-my-pi/pi-coding-agent 15.10.9 → 15.10.11

package/src/lsp/edits.ts

@@ -24,27 +24,7 @@ import { uriToFile } from "./utils";
  */
 export function applyTextEditsToString(content: string, edits: TextEdit[]): string {
 	const lines = content.split("\n");
-
-	// Sort edits in reverse order (bottom-to-top, right-to-left)
-	const sortedEdits = [...edits].sort((a, b) => {
-		if (a.range.start.line !== b.range.start.line) {
-			return b.range.start.line - a.range.start.line;
-		}
-		return b.range.start.character - a.range.start.character;
-	});
-
-	// Detect overlapping ranges: in reverse-sorted order, each edit's start
-	// must be >= the next edit's end. If not, the edits would clobber each other
-	// once applied bottom-up (typically a multi-server rename with stale positions).
-	for (let i = 0; i < sortedEdits.length - 1; i++) {
-		const later = sortedEdits[i].range;
-		const earlier = sortedEdits[i + 1].range;
-		if (comparePosition(earlier.end, later.start) > 0) {
-			throw new ToolError(
-				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; multi-server rename produced inconsistent edits`,
-			);
-		}
-	}
+	const sortedEdits = sortAndValidateTextEdits(edits);
 
 	for (const edit of sortedEdits) {
 		const { start, end } = edit.range;
@@ -78,6 +58,42 @@ export function rangesOverlap(a: Range, b: Range): boolean {
 	return comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0;
 }
 
+/**
+ * Sort edits bottom-to-top for in-place application and reject overlaps.
+ * Equal start positions tiebreak by original array index descending so that,
+ * applied bottom-up, inserts at the same position land in array order
+ * (LSP spec: the order of edits in the array defines the order in the result).
+ */
+export function sortAndValidateTextEdits(edits: TextEdit[]): TextEdit[] {
+	const sorted = edits
+		.map((edit, index) => ({ edit, index }))
+		.sort((a, b) => {
+			if (a.edit.range.start.line !== b.edit.range.start.line) {
+				return b.edit.range.start.line - a.edit.range.start.line;
+			}
+			if (a.edit.range.start.character !== b.edit.range.start.character) {
+				return b.edit.range.start.character - a.edit.range.start.character;
+			}
+			return b.index - a.index;
+		})
+		.map(entry => entry.edit);
+
+	// Detect overlapping ranges: in reverse-sorted order, each edit's start
+	// must be >= the next edit's end. If not, the edits would clobber each other
+	// once applied bottom-up (typically a multi-server rename with stale positions).
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const later = sorted[i].range;
+		const earlier = sorted[i + 1].range;
+		if (comparePosition(earlier.end, later.start) > 0) {
+			throw new ToolError(
+				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; multi-server rename produced inconsistent edits`,
+			);
+		}
+	}
+
+	return sorted;
+}
+
 /**
  * Flatten a WorkspaceEdit's text edits into a Map<uri, TextEdit[]>.
  * Resource operations (create/rename/delete) are ignored — callers handle them separately.
@@ -120,92 +136,124 @@ export async function applyTextEdits(filePath: string, edits: TextEdit[]): Promi
 // Workspace Edit Application
 // =============================================================================
 
+type WorkspaceEditOp =
+	| { kind: "text"; uri: string; edits: TextEdit[] }
+	| { kind: "create"; uri: string }
+	| { kind: "rename"; oldUri: string; newUri: string }
+	| { kind: "delete"; uri: string };
+
+/**
+ * Flatten documentChanges into an ordered op list. Text edits are accumulated
+ * per-URI and flushed before any resource op that touches the same URI (or,
+ * for folder rename/delete, any descendant URI) so that renames, creates, and
+ * deletes always see the correct prior file state.
+ */
+function planDocumentChanges(documentChanges: NonNullable<WorkspaceEdit["documentChanges"]>): WorkspaceEditOp[] {
+	const ops: WorkspaceEditOp[] = [];
+	const pending = new Map<string, TextEdit[]>();
+
+	const flushUri = (uri: string) => {
+		const edits = pending.get(uri);
+		if (!edits) return;
+		pending.delete(uri);
+		ops.push({ kind: "text", uri, edits });
+	};
+
+	// Flush the exact URI plus every pending descendant (for folder-level
+	// resource ops where the queued edits target child files of the target).
+	const flushSubtree = (uri: string) => {
+		const prefix = uri.endsWith("/") ? uri : `${uri}/`;
+		const matches: string[] = [];
+		for (const candidate of pending.keys()) {
+			if (candidate === uri || candidate.startsWith(prefix)) matches.push(candidate);
+		}
+		for (const target of matches) {
+			flushUri(target);
+		}
+	};
+
+	for (const change of documentChanges) {
+		if ("textDocument" in change && change.textDocument && "edits" in change && change.edits) {
+			const tdc = change as TextDocumentEdit;
+			const uri = tdc.textDocument.uri;
+			const textEdits = tdc.edits.filter((e): e is TextEdit => "range" in e && "newText" in e);
+			if (textEdits.length > 0) {
+				const prev = pending.get(uri);
+				if (prev) prev.push(...textEdits);
+				else pending.set(uri, [...textEdits]);
+			}
+		} else if ("kind" in change && change.kind) {
+			if (change.kind === "create") {
+				const createOp = change as CreateFile;
+				flushUri(createOp.uri);
+				ops.push({ kind: "create", uri: createOp.uri });
+			} else if (change.kind === "rename") {
+				const renameOp = change as RenameFile;
+				// Per LSP §3.16.2 documentChanges are applied in declared order.
+				// Flush both the source subtree (so prior edits land before the move)
+				// AND the destination subtree (so prior edits land on whatever exists
+				// at newUri before the rename overwrites/replaces it — relevant under
+				// `options.overwrite` and `options.ignoreIfExists`).
+				flushSubtree(renameOp.oldUri);
+				flushSubtree(renameOp.newUri);
+				ops.push({ kind: "rename", oldUri: renameOp.oldUri, newUri: renameOp.newUri });
+			} else if (change.kind === "delete") {
+				const deleteOp = change as DeleteFile;
+				flushSubtree(deleteOp.uri);
+				ops.push({ kind: "delete", uri: deleteOp.uri });
+			}
+		}
+	}
+
+	// Flush text edits not followed by a resource op.
+	for (const uri of [...pending.keys()]) {
+		flushUri(uri);
+	}
+
+	return ops;
+}
+
 /**
  * Apply a workspace edit (collection of file changes).
+ * All text-edit batches are overlap-validated before anything is written so a
+ * conflict throws without leaving the workspace half-applied.
  * Returns array of applied change descriptions.
  */
 export async function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Promise<string[]> {
 	const applied: string[] = [];
 
 	if (edit.documentChanges) {
-		// Walk documentChanges in original order. Accumulate text edits per-URI and
-		// flush them before any resource op that touches the same URI (or, for folder
-		// rename/delete, any descendant URI) so that renames, creates, and deletes
-		// always see the correct prior file state.
-		const pending = new Map<string, TextEdit[]>();
-
-		const flushUri = async (uri: string) => {
-			const edits = pending.get(uri);
-			if (!edits) return;
-			pending.delete(uri);
-			const filePath = uriToFile(uri);
-			await applyTextEdits(filePath, edits);
-			applied.push(`Applied ${edits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
-		};
-
-		// Flush the exact URI plus every pending descendant (for folder-level
-		// resource ops where the queued edits target child files of the target).
-		const flushSubtree = async (uri: string) => {
-			const prefix = uri.endsWith("/") ? uri : `${uri}/`;
-			const matches: string[] = [];
-			for (const candidate of pending.keys()) {
-				if (candidate === uri || candidate.startsWith(prefix)) matches.push(candidate);
-			}
-			for (const target of matches) {
-				await flushUri(target);
-			}
-		};
-
-		for (const change of edit.documentChanges) {
-			if ("textDocument" in change && change.textDocument && "edits" in change && change.edits) {
-				const tdc = change as TextDocumentEdit;
-				const uri = tdc.textDocument.uri;
-				const textEdits = tdc.edits.filter((e): e is TextEdit => "range" in e && "newText" in e);
-				if (textEdits.length > 0) {
-					const prev = pending.get(uri);
-					if (prev) prev.push(...textEdits);
-					else pending.set(uri, [...textEdits]);
-				}
-			} else if ("kind" in change && change.kind) {
-				if (change.kind === "create") {
-					const createOp = change as CreateFile;
-					await flushUri(createOp.uri);
-					const filePath = uriToFile(createOp.uri);
-					await Bun.write(filePath, "");
-					applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
-				} else if (change.kind === "rename") {
-					const renameOp = change as RenameFile;
-					// Per LSP §3.16.2 documentChanges are applied in declared order.
-					// Flush both the source subtree (so prior edits land before the move)
-					// AND the destination subtree (so prior edits land on whatever exists
-					// at newUri before the rename overwrites/replaces it — relevant under
-					// `options.overwrite` and `options.ignoreIfExists`).
-					await flushSubtree(renameOp.oldUri);
-					await flushSubtree(renameOp.newUri);
-					const oldPath = uriToFile(renameOp.oldUri);
-					const newPath = uriToFile(renameOp.newUri);
-					await fs.mkdir(path.dirname(newPath), { recursive: true });
-					await fs.rename(oldPath, newPath);
-					applied.push(
-						`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`,
-					);
-				} else if (change.kind === "delete") {
-					const deleteOp = change as DeleteFile;
-					await flushSubtree(deleteOp.uri);
-					const filePath = uriToFile(deleteOp.uri);
-					await fs.rm(filePath, { recursive: true });
-					applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
-				}
-			}
+		const ops = planDocumentChanges(edit.documentChanges);
+		for (const op of ops) {
+			if (op.kind === "text") sortAndValidateTextEdits(op.edits);
 		}
-
-		// Flush text edits not followed by a resource op.
-		for (const [uri] of pending) {
-			await flushUri(uri);
+		for (const op of ops) {
+			if (op.kind === "text") {
+				const filePath = uriToFile(op.uri);
+				await applyTextEdits(filePath, op.edits);
+				applied.push(`Applied ${op.edits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
+			} else if (op.kind === "create") {
+				const filePath = uriToFile(op.uri);
+				await Bun.write(filePath, "");
+				applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
+			} else if (op.kind === "rename") {
+				const oldPath = uriToFile(op.oldUri);
+				const newPath = uriToFile(op.newUri);
+				await fs.mkdir(path.dirname(newPath), { recursive: true });
+				await fs.rename(oldPath, newPath);
+				applied.push(`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`);
+			} else {
+				const filePath = uriToFile(op.uri);
+				await fs.rm(filePath, { recursive: true });
+				applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
+			}
 		}
 	} else if (edit.changes) {
-		// Legacy changes-map path: apply all text edits in one pass.
+		// Legacy changes-map path: validate every file's edits before writing any.
 		const changes = edit.changes;
+		for (const uri in changes) {
+			sortAndValidateTextEdits(changes[uri]);
+		}
 		for (const uri in changes) {
 			const textEdits = changes[uri];
 			if (textEdits.length === 0) continue;

package/src/lsp/index.ts

@@ -105,7 +105,7 @@ export const LSP_READONLY_ACTIONS: ReadonlySet<string> = new Set([
 
 export interface LspStartupServerInfo {
 	name: string;
-	status: "connecting" | "ready" | "error";
+	status: "connecting" | "ready" | "error" | "available";
 	fileTypes: string[];
 	error?: string;
 }
@@ -121,11 +121,14 @@ export interface LspWarmupOptions {
 	onConnecting?: (serverNames: string[]) => void;
 }
 
-export function discoverStartupLspServers(cwd: string): LspStartupServerInfo[] {
+export function discoverStartupLspServers(
+	cwd: string,
+	status: LspStartupServerInfo["status"] = "connecting",
+): LspStartupServerInfo[] {
 	const config = loadConfig(cwd);
 	return getLspServers(config).map(([name, serverConfig]) => ({
 		name,
-		status: "connecting",
+		status,
 		fileTypes: serverConfig.fileTypes,
 	}));
 }
@@ -454,21 +457,23 @@ function isMethodNotFoundError(err: unknown): boolean {
 }
 
 async function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string> {
-	let 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, signal);
-			output = `Reloaded ${serverName}`;
-			break;
-		} catch {
-			// Method not supported, try next
-		}
+	// rust-analyzer exposes a real reload request.
+	try {
+		await sendRequest(client, "rust-analyzer/reloadWorkspace", null, signal);
+		return `Reloaded ${serverName}`;
+	} catch {
+		// Method not supported — fall through.
 	}
-	if (output.startsWith("Restarted")) {
+	// workspace/didChangeConfiguration is a notification per spec; sending it
+	// as a request hangs until the tool deadline on servers that route it to
+	// the notification handler and never respond.
+	try {
+		await sendNotification(client, "workspace/didChangeConfiguration", { settings: {} });
+		return `Reloaded ${serverName}`;
+	} catch {
 		client.proc.kill();
+		return `Restarted ${serverName}`;
 	}
-	return output;
 }
 
 interface WaitForDiagnosticsOptions {
@@ -636,12 +641,13 @@ interface GetDiagnosticsForFileOptions {
 async function captureDiagnosticVersions(
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
+	initTimeoutMs?: number,
 ): Promise<ServerVersionMap> {
 	const versions = new Map<string, number>();
 	await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
 			if (serverConfig.createClient) return;
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, initTimeoutMs);
 			versions.set(serverName, client.diagnosticsVersion);
 		}),
 	);
@@ -1118,7 +1124,9 @@ async function runLspWritethrough(
 	const useCustomFormatter = enableFormat && customLinterServers.length > 0;
 
 	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
-	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+	// Bound client creation by the writethrough budget: a hung/broken server
+	// must not add its full init wait (30s default) to every edit.
+	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers, 5_000) : undefined;
 	let expectedDocumentVersions: ServerVersionMap | undefined;
 
 	let formatter: FileFormatResult | undefined;
@@ -2311,11 +2319,12 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 							break;
 						}
 						const parsedIndex = /^\d+$/.test(normalizedQuery) ? Number.parseInt(normalizedQuery, 10) : null;
-						const selectedAction = result.find(
-							(actionItem, index) =>
-								(parsedIndex !== null && index === parsedIndex) ||
-								actionItem.title.toLowerCase().includes(normalizedQuery.toLowerCase()),
-						);
+						const selectedAction =
+							parsedIndex !== null
+								? result[parsedIndex]
+								: result.find(actionItem =>
+										actionItem.title.toLowerCase().includes(normalizedQuery.toLowerCase()),
+									);
 
 						if (!selectedAction) {
 							const actionLines = result.map((actionItem, index) => `  ${formatCodeAction(actionItem, index)}`);

package/src/lsp/render.ts

@@ -139,7 +139,7 @@ export function renderResult(
 	const outputBlock = new CachedOutputBlock();
 
 	return markFramedBlockComponent({
-		render(width: number): string[] {
+		render(width: number): readonly string[] {
 			// Read mutable state at render time
 			const { expanded, isPartial, spinnerFrame } = options;
 

package/src/lsp/types.ts

@@ -416,6 +416,8 @@ export interface LspClient {
 	pendingRequests: Map<number, PendingRequest>;
 	messageBuffer: Uint8Array;
 	isReading: boolean;
+	/** Lifecycle state: "connecting" until initialize completes, then "ready"; "error" on init failure or reader death. */
+	status: "connecting" | "ready" | "error";
 	serverCapabilities?: LspServerCapabilities;
 	lastActivity: number;
 	/** Serializes outbound JSON-RPC writes to the server process. */

package/src/lsp/utils.ts

@@ -27,22 +27,17 @@ export { detectLanguageId } from "../utils/lang-from-path";
 
 /**
  * Convert a file path to a file:// URI.
+ * Uses the URL machinery so special characters (`%`, `#`, `?`, spaces) are
+ * percent-encoded; plain concatenation produced URIs that broke round-trips.
  * Handles Windows drive letters correctly.
  */
 export function fileToUri(filePath: string): string {
-	const resolved = path.resolve(filePath);
-
-	if (process.platform === "win32") {
-		// Windows: file:///C:/path/to/file
-		return `file:///${resolved.replace(/\\/g, "/")}`;
-	}
-
-	// Unix: file:///path/to/file
-	return `file://${resolved}`;
+	return Bun.pathToFileURL(path.resolve(filePath)).href;
 }
 
 /**
  * Convert a file:// URI to a file path.
+ * Tolerates both percent-encoded URIs and lax servers that send raw paths.
  * Handles Windows drive letters correctly.
  */
 export function uriToFile(uri: string): string {
@@ -50,7 +45,30 @@ export function uriToFile(uri: string): string {
 		return uri;
 	}
 
-	let filePath = decodeURIComponent(uri.slice(7));
+	// A raw `#`/`?` parses *successfully* as fragment/query and silently
+	// truncates the path — it never reaches the catch below. LSP servers do
+	// not use fragments or queries on file URIs (encoded forms are %23/%3F),
+	// so raw occurrences mean a lax server sent an unencoded path.
+	if (uri.includes("#") || uri.includes("?")) {
+		return laxUriToFile(uri);
+	}
+
+	try {
+		return Bun.fileURLToPath(uri);
+	} catch {
+		// Not a well-formed file URL (unencoded characters, stray `%`, host
+		// component). Fall back to a lenient manual conversion.
+		return laxUriToFile(uri);
+	}
+}
+
+function laxUriToFile(uri: string): string {
+	let filePath = uri.slice(7);
+	try {
+		filePath = decodeURIComponent(filePath);
+	} catch {
+		// Invalid percent-encoding — treat as a literal path.
+	}
 
 	// Windows: file:///C:/path → C:/path (strip leading slash before drive letter)
 	if (process.platform === "win32" && filePath.startsWith("/") && /^[A-Za-z]:/.test(filePath.slice(1))) {