fix(coding-agent): queue file mutations across edit and write

closes #2327
2026-03-20 01:10:56 +01:00
parent 527c2af5e7
commit 74a46fc7ea
12 changed files with 481 additions and 220 deletions
--- a/packages/coding-agent/test/file-mutation-queue.test.ts
+++ b/packages/coding-agent/test/file-mutation-queue.test.ts
@@ -0,0 +1,164 @@
+import { access, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { createEditTool } from "../src/core/tools/edit.js";
+import { withFileMutationQueue } from "../src/core/tools/file-mutation-queue.js";
+import { createWriteTool } from "../src/core/tools/write.js";
+
+function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+const tempDirs: string[] = [];
+
+async function createTempDir(): Promise<string> {
+	const dir = await mkdtemp(join(tmpdir(), "pi-file-mutation-queue-"));
+	tempDirs.push(dir);
+	return dir;
+}
+
+afterEach(async () => {
+	await Promise.all(tempDirs.splice(0, tempDirs.length).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("withFileMutationQueue", () => {
+	it("serializes operations for the same file", async () => {
+		const order: string[] = [];
+		const path = "/tmp/file-mutation-queue-same";
+
+		const first = withFileMutationQueue(path, async () => {
+			order.push("first:start");
+			await delay(30);
+			order.push("first:end");
+		});
+		const second = withFileMutationQueue(path, async () => {
+			order.push("second:start");
+			order.push("second:end");
+		});
+
+		await Promise.all([first, second]);
+		expect(order).toEqual(["first:start", "first:end", "second:start", "second:end"]);
+	});
+
+	it("allows different files to proceed in parallel", async () => {
+		const order: string[] = [];
+
+		await Promise.all([
+			withFileMutationQueue("/tmp/file-mutation-queue-a", async () => {
+				order.push("a:start");
+				await delay(30);
+				order.push("a:end");
+			}),
+			withFileMutationQueue("/tmp/file-mutation-queue-b", async () => {
+				order.push("b:start");
+				await delay(30);
+				order.push("b:end");
+			}),
+		]);
+
+		expect(order.indexOf("a:start")).toBeLessThan(order.indexOf("a:end"));
+		expect(order.indexOf("b:start")).toBeLessThan(order.indexOf("b:end"));
+		expect(order.indexOf("b:start")).toBeLessThan(order.indexOf("a:end"));
+	});
+
+	it("uses the same queue for symlink aliases", async () => {
+		const dir = await createTempDir();
+		const targetPath = join(dir, "target.txt");
+		const symlinkPath = join(dir, "alias.txt");
+		await writeFile(targetPath, "hello\n", "utf8");
+		await symlink(targetPath, symlinkPath);
+
+		const order: string[] = [];
+		await Promise.all([
+			withFileMutationQueue(targetPath, async () => {
+				order.push("target:start");
+				await delay(30);
+				order.push("target:end");
+			}),
+			withFileMutationQueue(symlinkPath, async () => {
+				order.push("alias:start");
+				order.push("alias:end");
+			}),
+		]);
+
+		expect(order).toEqual(["target:start", "target:end", "alias:start", "alias:end"]);
+	});
+});
+
+describe("built-in edit and write tools", () => {
+	it("preserves both parallel edits on the same file", async () => {
+		const dir = await createTempDir();
+		const filePath = join(dir, "parallel-edit.txt");
+		await writeFile(filePath, "alpha\nbeta\ngamma\n", "utf8");
+
+		const editTool = createEditTool(dir, {
+			operations: {
+				access,
+				readFile: async (path) => {
+					const buffer = await readFile(path);
+					await delay(30);
+					return buffer;
+				},
+				writeFile: async (path, content) => {
+					await delay(30);
+					await writeFile(path, content, "utf8");
+				},
+			},
+		});
+
+		await Promise.all([
+			editTool.execute("call-1", { path: filePath, oldText: "alpha", newText: "ALPHA" }),
+			editTool.execute("call-2", { path: filePath, oldText: "beta", newText: "BETA" }),
+		]);
+
+		const content = await readFile(filePath, "utf8");
+		expect(content).toBe("ALPHA\nBETA\ngamma\n");
+	});
+
+	it("shares the queue between edit and write", async () => {
+		const dir = await createTempDir();
+		const filePath = join(dir, "mixed.txt");
+		await writeFile(filePath, "original\n", "utf8");
+
+		const editTool = createEditTool(dir, {
+			operations: {
+				access,
+				readFile: async (path) => {
+					const buffer = await readFile(path);
+					await delay(30);
+					return buffer;
+				},
+				writeFile: async (path, content) => {
+					await delay(30);
+					await writeFile(path, content, "utf8");
+				},
+			},
+		});
+		const writeTool = createWriteTool(dir, {
+			operations: {
+				mkdir: async () => {},
+				writeFile: async (path, content) => {
+					await delay(10);
+					await writeFile(path, content, "utf8");
+				},
+			},
+		});
+
+		const editPromise = editTool.execute("call-1", {
+			path: filePath,
+			oldText: "original",
+			newText: "edited",
+		});
+		await delay(5);
+		const writePromise = writeTool.execute("call-2", {
+			path: filePath,
+			content: "replacement\n",
+		});
+
+		await Promise.all([editPromise, writePromise]);
+
+		const content = await readFile(filePath, "utf8");
+		expect(content).toBe("replacement\n");
+	});
+});