lazycodex-ai 5.1.48 → 5.1.54

package/packages/lsp-core/src/lsp/transport.ts

@@ -0,0 +1,339 @@
+import { reportBestEffortCleanupError } from "./cleanup-errors.js";
+import { realTimerProvider } from "./timer-provider.js";
+import type { TimerProvider } from "./timer-provider.js";
+import { INIT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, STOP_HARD_KILL_TIMEOUT_MS, STOP_SIGKILL_GRACE_MS } from "./constants.js";
+import { LspConnectionClosedError, LspProcessExitedError, LspRequestTimeoutError } from "./errors.js";
+import { JsonRpcConnection } from "./json-rpc-connection.js";
+import { type SpawnedProcess, spawnProcess } from "./process.js";
+import { createLspSpawnEnv, parseConfigurationItems, parseDiagnosticsParams } from "./transport-protocol.js";
+import type { Diagnostic, ResolvedServer } from "./types.js";
+import type { WorkspaceApplyEditResponse } from "./workspace-mutation-controller.js";
+
+export { createLspSpawnEnv } from "./transport-protocol.js";
+
+export interface LspClientTimeoutOptions {
+	requestTimeoutMs?: number;
+	initializeTimeoutMs?: number;
+	timerProvider?: TimerProvider;
+}
+
+type WorkspaceApplyEditHandler = (params: unknown) => Promise<WorkspaceApplyEditResponse>;
+
+class LspClientNotStartedError extends Error {
+	override readonly name = "LspClientNotStartedError";
+
+	constructor(
+		readonly serverId: string,
+		readonly root: string,
+	) {
+		super("LSP client not started");
+	}
+}
+
+export class LspClientTransport {
+	protected proc: SpawnedProcess | null = null;
+	protected connection: JsonRpcConnection | null = null;
+	protected readonly stderrBuffer: string[] = [];
+	protected processExited = false;
+	protected readonly diagnosticsStore = new Map<string, Diagnostic[]>();
+	protected readonly requestTimeoutMs: number;
+	protected readonly initializeTimeoutMs: number;
+	protected readonly timerProvider: TimerProvider;
+	private workspaceApplyEditHandler: WorkspaceApplyEditHandler | null = null;
+	private diagnosticPullSupported = false;
+	private documentFormattingSupported = false;
+
+	constructor(
+		protected readonly root: string,
+		protected readonly server: ResolvedServer,
+		timeouts: LspClientTimeoutOptions = {},
+	) {
+		this.requestTimeoutMs = timeouts.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
+		this.initializeTimeoutMs = timeouts.initializeTimeoutMs ?? INIT_TIMEOUT_MS;
+		this.timerProvider = timeouts.timerProvider ?? realTimerProvider;
+	}
+
+	pid(): number | undefined {
+		return this.proc?.pid;
+	}
+
+	command(): string[] {
+		return [...this.server.command];
+	}
+
+	protected setWorkspaceApplyEditHandler(handler: WorkspaceApplyEditHandler): void {
+		this.workspaceApplyEditHandler = handler;
+	}
+
+	protected hasWorkspaceApplyEditHandler(): boolean {
+		return this.workspaceApplyEditHandler !== null;
+	}
+
+	protected setDiagnosticPullSupported(supported: boolean): void {
+		this.diagnosticPullSupported = supported;
+	}
+
+	protected isDiagnosticPullSupported(): boolean {
+		return this.diagnosticPullSupported;
+	}
+
+	protected setDocumentFormattingSupported(supported: boolean): void {
+		this.documentFormattingSupported = supported;
+	}
+
+	isDocumentFormattingSupported(): boolean {
+		return this.documentFormattingSupported;
+	}
+
+	protected handlePublishDiagnostics(params: {
+		readonly uri: string;
+		readonly diagnostics: readonly Diagnostic[];
+		readonly version?: number;
+	}): void {
+		this.diagnosticsStore.set(params.uri, [...params.diagnostics]);
+	}
+
+	async start(): Promise<void> {
+		const env = createLspSpawnEnv(this.root, {
+			...process.env,
+			...this.server.env,
+		});
+
+		this.proc = spawnProcess(this.server.command, {
+			cwd: this.root,
+			env,
+		});
+		this.startStderrReading();
+
+		if (this.proc.exitCode !== null) {
+			const stderr = this.stderrBuffer.join("\n");
+			throw new LspProcessExitedError(this.server.id, this.root, this.proc.exitCode, stderr.slice(-2000));
+		}
+
+		this.connection = new JsonRpcConnection(this.proc.stdout, this.proc.stdin);
+
+		this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+			const diagnosticsParams = parseDiagnosticsParams(params);
+			if (diagnosticsParams?.uri) {
+				this.handlePublishDiagnostics(diagnosticsParams);
+			}
+		});
+
+		this.connection.onRequest("workspace/configuration", (params) => {
+			const items = parseConfigurationItems(params);
+			return items.map((item) => {
+				if (item.section === "json") return { validate: { enable: true } };
+				return {};
+			});
+		});
+
+		this.connection.onRequest("client/registerCapability", () => null);
+		this.connection.onRequest("window/workDoneProgress/create", () => null);
+		if (this.workspaceApplyEditHandler) {
+			this.connection.onRequest("workspace/applyEdit", this.workspaceApplyEditHandler);
+		}
+
+		this.connection.onClose(() => {
+			this.processExited = true;
+		});
+
+		this.connection.onError((error) => {
+			reportBestEffortCleanupError("connection error notification", error);
+		});
+
+		this.connection.listen();
+	}
+
+	protected startStderrReading(): void {
+		if (!this.proc) return;
+		this.proc.stderr.setEncoding("utf-8");
+		this.proc.stderr.on("data", (chunk: string) => {
+			this.stderrBuffer.push(chunk);
+			if (this.stderrBuffer.length > 100) {
+				this.stderrBuffer.shift();
+			}
+		});
+	}
+
+	private isConnectionClosedError(error: unknown): error is Error {
+		if (!(error instanceof Error)) {
+			return false;
+		}
+		const code = "code" in error && typeof error.code === "string" ? error.code : undefined;
+		return (
+			code === "ERR_STREAM_DESTROYED" ||
+			/connection closed|connection is disposed|stream was destroyed/i.test(error.message)
+		);
+	}
+
+	protected sendRequest<T>(method: string): Promise<T>;
+	protected sendRequest<T>(method: string, params: unknown): Promise<T>;
+	protected sendRequest<T>(
+		method: string,
+		params: unknown,
+		options: { timeoutMs?: number; signal?: AbortSignal },
+	): Promise<T>;
+	protected async sendRequest<T>(
+		method: string,
+		...args: [] | [unknown] | [unknown, { timeoutMs?: number; signal?: AbortSignal }]
+	): Promise<T> {
+		if (!this.connection) throw new LspClientNotStartedError(this.server.id, this.root);
+
+		if (this.processExited || (this.proc && this.proc.exitCode !== null)) {
+			const stderrTail = this.stderrBuffer.slice(-10).join("\n");
+			throw new LspProcessExitedError(
+				this.server.id,
+				this.root,
+				this.proc?.exitCode ?? null,
+				stderrTail || undefined,
+			);
+		}
+
+		const options = args[1];
+		const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
+		const timeoutController = new AbortController();
+		const timeoutHandle = this.timerProvider.setTimeout(() => {
+			const stderrTail = this.stderrBuffer.slice(-5).join("\n");
+			timeoutController.abort(new LspRequestTimeoutError(method, stderrTail || undefined));
+		}, timeoutMs);
+		const combinedSignal = combineAbortSignals(options?.signal, timeoutController.signal);
+
+		try {
+			const result =
+				args.length === 0
+					? await this.connection.sendRequest<T>(method, undefined, { signal: combinedSignal.signal })
+					: await this.connection.sendRequest<T>(method, args[0], { signal: combinedSignal.signal });
+			return result;
+		} catch (error) {
+			if (this.processExited || (this.proc && this.proc.exitCode !== null)) {
+				throw new LspProcessExitedError(
+					this.server.id,
+					this.root,
+					this.proc?.exitCode ?? null,
+					this.stderrBuffer.slice(-10).join("\n") || undefined,
+				);
+			}
+			if (this.isConnectionClosedError(error)) {
+				throw new LspConnectionClosedError(this.server.id, this.root, error.message);
+			}
+			throw error;
+		} finally {
+			this.timerProvider.clearTimeout(timeoutHandle);
+			combinedSignal.dispose();
+		}
+	}
+
+	protected sendNotification(method: string): Promise<void>;
+	protected sendNotification(method: string, params: unknown): Promise<void>;
+	protected async sendNotification(method: string, ...args: [] | [unknown]): Promise<void> {
+		if (!this.connection) return;
+		if (this.processExited || (this.proc && this.proc.exitCode !== null)) return;
+		try {
+			if (args.length === 0) {
+				await this.connection.sendNotification(method);
+			} else {
+				await this.connection.sendNotification(method, args[0]);
+			}
+		} catch (error) {
+			if (this.isConnectionClosedError(error)) {
+				throw new LspConnectionClosedError(this.server.id, this.root, error.message);
+			}
+			throw error;
+		}
+	}
+
+	isAlive(): boolean {
+		return this.proc !== null && !this.processExited && this.proc.exitCode === null;
+	}
+
+	async stop(): Promise<void> {
+		if (this.connection) {
+			try {
+				await this.sendRequest<null>("shutdown");
+			} catch (error) {
+				reportBestEffortCleanupError("shutdown request", error instanceof Error ? error : String(error));
+			}
+			try {
+				await this.sendNotification("exit");
+			} catch (error) {
+				reportBestEffortCleanupError("exit notification", error instanceof Error ? error : String(error));
+			}
+			try {
+				this.connection.dispose();
+			} catch (error) {
+				reportBestEffortCleanupError("connection dispose", error instanceof Error ? error : String(error));
+			}
+			this.connection = null;
+		}
+
+		const proc = this.proc;
+		if (proc) {
+			this.proc = null;
+			let exitedBeforeTimeout = false;
+			try {
+				proc.kill();
+				let timeoutId: NodeJS.Timeout | undefined;
+				const timeoutPromise = new Promise<void>((resolve) => {
+					timeoutId = setTimeout(resolve, STOP_HARD_KILL_TIMEOUT_MS);
+				});
+				await Promise.race([
+					proc.exited
+						.then(() => {
+							exitedBeforeTimeout = true;
+						})
+						.finally(() => {
+							if (timeoutId) clearTimeout(timeoutId);
+						}),
+					timeoutPromise,
+				]);
+				if (!exitedBeforeTimeout) {
+					try {
+						proc.kill("SIGKILL");
+						await Promise.race([
+							proc.exited,
+							new Promise<void>((resolve) => setTimeout(resolve, STOP_SIGKILL_GRACE_MS)),
+						]);
+					} catch (error) {
+						reportBestEffortCleanupError("hard process kill", error instanceof Error ? error : String(error));
+					}
+				}
+			} catch (error) {
+				reportBestEffortCleanupError("process stop", error instanceof Error ? error : String(error));
+			}
+		}
+
+		this.processExited = true;
+		this.diagnosticsStore.clear();
+	}
+
+	getStoredDiagnostics(uri: string): Diagnostic[] {
+		return this.diagnosticsStore.get(uri) ?? [];
+	}
+}
+
+function combineAbortSignals(
+	primary: AbortSignal | undefined,
+	secondary: AbortSignal,
+): { readonly signal: AbortSignal; readonly dispose: () => void } {
+	const controller = new AbortController();
+	const abortFrom = (signal: AbortSignal): void => {
+		if (!controller.signal.aborted) controller.abort(signal.reason);
+	};
+	const onPrimaryAbort = (): void => {
+		if (primary) abortFrom(primary);
+	};
+	const onSecondaryAbort = (): void => abortFrom(secondary);
+
+	if (primary?.aborted) abortFrom(primary);
+	else primary?.addEventListener("abort", onPrimaryAbort, { once: true });
+	if (secondary.aborted) abortFrom(secondary);
+	else secondary.addEventListener("abort", onSecondaryAbort, { once: true });
+
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			primary?.removeEventListener("abort", onPrimaryAbort);
+			secondary.removeEventListener("abort", onSecondaryAbort);
+		},
+	};
+}

package/packages/lsp-core/src/lsp/types.ts

@@ -0,0 +1,134 @@
+export interface LspServerConfig {
+	id: string;
+	command: string[];
+	extensions: string[];
+	disabled?: boolean;
+	env?: Record<string, string>;
+	initialization?: Record<string, unknown>;
+}
+
+export interface ResolvedServer {
+	id: string;
+	command: string[];
+	extensions: string[];
+	priority: number;
+	env?: Record<string, string>;
+	initialization?: Record<string, unknown>;
+}
+
+export interface ServerLookupInfo {
+	id: string;
+	command: string[];
+	extensions: string[];
+}
+
+export type ServerLookupResult =
+	| { status: "found"; server: ResolvedServer }
+	| { status: "not_configured"; extension: string; availableServers: string[] }
+	| { status: "not_installed"; server: ServerLookupInfo; installHint: string };
+
+export interface Position {
+	line: number;
+	character: number;
+}
+
+export interface Range {
+	start: Position;
+	end: Position;
+}
+
+export interface Location {
+	uri: string;
+	range: Range;
+}
+
+export interface LocationLink {
+	targetUri: string;
+	targetRange: Range;
+	targetSelectionRange: Range;
+	originSelectionRange?: Range;
+}
+
+export interface SymbolInfo {
+	name: string;
+	kind: number;
+	location: Location;
+	containerName?: string;
+}
+
+export interface DocumentSymbol {
+	name: string;
+	kind: number;
+	range: Range;
+	selectionRange: Range;
+	children?: DocumentSymbol[];
+}
+
+export interface Diagnostic {
+	range: Range;
+	severity?: number;
+	code?: string | number;
+	source?: string;
+	message: string;
+}
+
+export interface FormattingOptions {
+	tabSize: number;
+	insertSpaces: boolean;
+	trimTrailingWhitespace?: boolean;
+	insertFinalNewline?: boolean;
+	trimFinalNewlines?: boolean;
+}
+
+export interface TextDocumentIdentifier {
+	uri: string;
+}
+
+export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+	version: number | null;
+}
+
+export interface TextEdit {
+	range: Range;
+	newText: string;
+}
+
+export interface TextDocumentEdit {
+	textDocument: VersionedTextDocumentIdentifier;
+	edits: TextEdit[];
+}
+
+export interface CreateFile {
+	kind: "create";
+	uri: string;
+	options?: { overwrite?: boolean; ignoreIfExists?: boolean };
+}
+
+export interface RenameFile {
+	kind: "rename";
+	oldUri: string;
+	newUri: string;
+	options?: { overwrite?: boolean; ignoreIfExists?: boolean };
+}
+
+export interface DeleteFile {
+	kind: "delete";
+	uri: string;
+	options?: { recursive?: boolean; ignoreIfNotExists?: boolean };
+}
+
+export interface WorkspaceEdit {
+	changes?: { [uri: string]: TextEdit[] };
+	documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[];
+}
+
+export interface PrepareRenameResult {
+	range: Range;
+	placeholder?: string;
+}
+
+export interface PrepareRenameDefaultBehavior {
+	defaultBehavior: boolean;
+}
+
+export type SeverityFilter = "error" | "warning" | "information" | "hint" | "all";

package/packages/lsp-core/src/lsp/typescript-server-defaults.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runWithRequestContext, type LspRequestContext } from "../request-context.js";
+import { getMergedServers } from "./config-loader.js";
+import { BUILTIN_SERVERS } from "./server-definitions.js";
+
+const LEAN_TYPESCRIPT_INITIALIZATION = {
+	tsserver: { useSyntaxServer: "never" },
+	disableAutomaticTypingAcquisition: true,
+};
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function contextWithConfigs(configs: { project?: unknown; user?: unknown }): LspRequestContext {
+	const directory = mkdtempSync(join(tmpdir(), "lsp-ts-defaults-"));
+	tempDirectories.push(directory);
+	const projectPath = join(directory, "project-lsp.json");
+	const userPath = join(directory, "user-lsp.json");
+	if (configs.project !== undefined) writeFileSync(projectPath, JSON.stringify(configs.project));
+	if (configs.user !== undefined) writeFileSync(userPath, JSON.stringify(configs.user));
+	return {
+		cwd: directory,
+		projectConfigPaths: [projectPath],
+		userConfigPath: userPath,
+		installDecisionsPath: join(directory, "install-decisions.json"),
+		capabilities: { installDecisionTool: false },
+	};
+}
+
+function mergedTypescript(configs: { project?: unknown; user?: unknown }) {
+	const servers = runWithRequestContext(contextWithConfigs(configs), () => getMergedServers());
+	return servers.find((server) => server.id === "typescript");
+}
+
+describe("TypeScript language server defaults", () => {
+	it("#given the builtin definition #then its default config turns off the syntax server and automatic typings", () => {
+		expect(BUILTIN_SERVERS["typescript"]?.initialization).toEqual(LEAN_TYPESCRIPT_INITIALIZATION);
+	});
+
+	it("#given no config #when merging servers #then the builtin typescript server carries the defaults", () => {
+		expect(mergedTypescript({})?.initialization).toEqual(LEAN_TYPESCRIPT_INITIALIZATION);
+	});
+
+	it("#given a user entry that only changes priority #then the defaults survive", () => {
+		const server = mergedTypescript({ user: { lsp: { typescript: { priority: 5 } } } });
+		expect(server?.source).toBe("user");
+		expect(server?.initialization).toEqual(LEAN_TYPESCRIPT_INITIALIZATION);
+	});
+
+	it("#given a project entry with its own initialization #then its keys win over the defaults", () => {
+		const server = mergedTypescript({
+			project: { lsp: { typescript: { initialization: { tsserver: { useSyntaxServer: "auto" }, hostInfo: "x" } } } },
+		});
+		expect(server?.source).toBe("project");
+		expect(server?.initialization).toEqual({
+			tsserver: { useSyntaxServer: "auto" },
+			disableAutomaticTypingAcquisition: true,
+			hostInfo: "x",
+		});
+	});
+
+	it("#given a user entry with only a custom command #then no builtin defaults are injected", () => {
+		const server = mergedTypescript({ user: { lsp: { typescript: { command: ["vtsls", "--stdio"] } } } });
+		expect(server?.command).toEqual(["vtsls", "--stdio"]);
+		expect(server?.initialization).toBeUndefined();
+	});
+
+	it("#given a user entry with a custom command #then no builtin defaults are injected", () => {
+		const server = mergedTypescript({
+			user: { lsp: { typescript: { command: ["custom-ts-ls", "--stdio"], extensions: [".ts"] } } },
+		});
+		expect(server?.command).toEqual(["custom-ts-ls", "--stdio"]);
+		expect(server?.initialization).toBeUndefined();
+	});
+});

package/packages/lsp-core/src/lsp/utils.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+
+import { LspProcessExitedError } from "./errors.js";
+import { formatKnownLspStartupFailure, handleMissingDependencyError } from "./utils.js";
+
+describe("formatKnownLspStartupFailure", () => {
+	test("#given rust-src component conflict #when formatting startup failure #then returns repair guidance", () => {
+		// given
+		const error = new LspProcessExitedError(
+			"rust",
+			"/repo",
+			1,
+			"failed to install component: 'rust-src', detected conflict: 'lib/rustlib/src/rust/library/Cargo.lock'",
+		);
+
+		// when
+		const message = formatKnownLspStartupFailure(error);
+
+		// then
+		expect(message).toContain("rust-analyzer");
+		expect(message).toContain("rustup component remove rust-src");
+		expect(message).toContain("rustup component add rust-src");
+		expect(message).toContain("detected conflict");
+		expect(message).toContain("Cargo.lock");
+		expect(message).not.toContain("automatic repair");
+	});
+
+	test("#given rust-analyzer sysroot error #when handling missing dependency #then returns repair guidance", () => {
+		// given
+		const error = new LspProcessExitedError(
+			"rust",
+			"/repo",
+			1,
+			"can't load standard library from sysroot\ntry installing `rust-src` the same way you installed `rustc`",
+		);
+
+		// when
+		const message = handleMissingDependencyError(error);
+
+		// then
+		expect(message).toContain("rustup component remove rust-src");
+		expect(message).toContain("rustup component add rust-src");
+		expect(message).toContain("can't load standard library");
+	});
+
+	test("#given unrelated process exits #when formatting startup failure #then returns null", () => {
+		// given
+		const typescriptError = new LspProcessExitedError(
+			"typescript",
+			"/repo",
+			1,
+			"failed to install component: 'rust-src', detected conflict",
+		);
+		const rustPanic = new LspProcessExitedError("rust", "/repo", 1, "thread panicked while loading crate graph");
+
+		// when / then
+		expect(formatKnownLspStartupFailure(typescriptError)).toBeNull();
+		expect(formatKnownLspStartupFailure(rustPanic)).toBeNull();
+	});
+});
+
+describe("handleMissingDependencyError", () => {
+	test("#given existing dependency messages #when handling error #then preserves current messages", () => {
+		// given
+		const notInstalled = new Error("LSP server 'typescript' is configured but NOT INSTALLED.");
+		const notConfigured = new Error("No LSP server configured for extension: .md");
+
+		// when / then
+		expect(handleMissingDependencyError(notInstalled)).toBe(notInstalled.message);
+		expect(handleMissingDependencyError(notConfigured)).toBe(notConfigured.message);
+	});
+});

package/packages/lsp-core/src/lsp/utils.ts

@@ -0,0 +1,40 @@
+import { LspProcessExitedError } from "./errors.js";
+
+const RUST_SRC_REPAIR_MESSAGE = [
+	"rust-analyzer exited while loading Rust standard library sources.",
+	"",
+	"Repair rust-src for the active toolchain:",
+	"  rustup component remove rust-src",
+	"  rustup component add rust-src",
+];
+
+export function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export function formatKnownLspStartupFailure(error: unknown): string | null {
+	if (!(error instanceof LspProcessExitedError)) return null;
+	if (error.serverId !== "rust") return null;
+
+	const details = error.stderrTail ?? error.message;
+	const lowerDetails = details.toLowerCase();
+	const isRustSrcFailure =
+		lowerDetails.includes("rust-src") &&
+		(lowerDetails.includes("failed to install component") ||
+			lowerDetails.includes("detected conflict") ||
+			lowerDetails.includes("can't load standard library") ||
+			lowerDetails.includes("try installing") ||
+			lowerDetails.includes("sysroot"));
+
+	if (!isRustSrcFailure) return null;
+
+	return [...RUST_SRC_REPAIR_MESSAGE, "", "Original stderr tail:", details].join("\n");
+}
+
+export function handleMissingDependencyError(error: unknown): string | null {
+	const knownStartupFailure = formatKnownLspStartupFailure(error);
+	if (knownStartupFailure) return knownStartupFailure;
+
+	const message = errorMessage(error);
+	return message.includes("NOT INSTALLED") || message.includes("No LSP server configured") ? message : null;
+}

package/packages/lsp-core/src/lsp/workspace-apply-edit-failure.ts

@@ -0,0 +1,19 @@
+export type WorkspaceApplyEditConcurrentPhase = "applying" | "settled";
+
+const CONCURRENT_FAILURE_REASON_BY_PHASE: Readonly<Record<WorkspaceApplyEditConcurrentPhase, string>> = {
+	applying: "workspace/applyEdit is already in progress for this workspace mutation",
+	settled: "workspace/applyEdit was already handled for this workspace mutation",
+};
+
+export const CANONICAL_CONCURRENT_WORKSPACE_APPLY_EDIT_FAILURE_REASON =
+	"workspace/applyEdit concurrent for this workspace mutation";
+
+export function workspaceApplyEditConcurrentFailureReason(phase: WorkspaceApplyEditConcurrentPhase): string {
+	return CONCURRENT_FAILURE_REASON_BY_PHASE[phase];
+}
+
+export function canonicalizeWorkspaceApplyEditFailureReason(reason: string): string {
+	return Object.values(CONCURRENT_FAILURE_REASON_BY_PHASE).includes(reason)
+		? CANONICAL_CONCURRENT_WORKSPACE_APPLY_EDIT_FAILURE_REASON
+		: reason;
+}