@warlock.js/ai-workspace 5.39.2 → 5.40.1

package/esm/patch/apply-hunks.mjs

@@ -0,0 +1,89 @@
+import { WorkspaceEditError } from "../errors.mjs";
+
+//#region ../../packages/ai-workspace/src/patch/apply-hunks.ts
+/** The text of a line without a trailing carriage return. */
+const bare = (line) => line.endsWith("\r") ? line.slice(0, -1) : line;
+/** Same, and ignoring trailing blanks (a second, looser matching pass). */
+const loose = (line) => bare(line).trimEnd();
+/** Split file content into lines (carriage returns kept) and note the final newline. */
+function split(content) {
+	if (content === "") return {
+		lines: [],
+		trailingNewline: false
+	};
+	const parts = content.split("\n");
+	const trailingNewline = parts[parts.length - 1] === "";
+	if (trailingNewline) parts.pop();
+	return {
+		lines: parts,
+		trailingNewline
+	};
+}
+/** Whether most of the file's lines end in CRLF. */
+function usesCrlf(lines) {
+	const crlf = lines.filter((line) => line.endsWith("\r")).length;
+	return crlf > 0 && crlf * 2 >= lines.length;
+}
+/** First index at or after `from` (searching outward from `expected`) where `old` matches. */
+function findMatch(lines, old, expected, from, normalize) {
+	if (old.length === 0) return Math.min(Math.max(expected, from), lines.length);
+	const last = lines.length - old.length;
+	const wanted = old.map(normalize);
+	const matches = (start) => start >= from && start <= last && wanted.every((line, offset) => normalize(lines[start + offset]) === line);
+	for (let distance = 0; distance <= lines.length; distance++) {
+		if (matches(expected + distance)) return expected + distance;
+		if (distance > 0 && matches(expected - distance)) return expected - distance;
+	}
+	return -1;
+}
+/**
+* Apply a file's hunks to its content, in memory. Hunks are located by their
+* context (not only by line number, so a few lines of drift are fine), must
+* not overlap, and keep the file's line endings: untouched lines are
+* byte-for-byte as they were and added lines use the file's CRLF/LF style.
+*
+* Throws a `WorkspaceEditError` (`hunk-failed`) naming the first hunk whose
+* context is not in the file; nothing is returned in that case.
+*/
+function applyHunks(content, hunks, displayPath) {
+	const { lines, trailingNewline: initialTrailing } = split(content);
+	const wasEmpty = lines.length === 0;
+	const eol = usesCrlf(lines) ? "\r" : "";
+	let trailingNewline = initialTrailing;
+	let cursor = 0;
+	let delta = 0;
+	hunks.forEach((hunk, hunkIndex) => {
+		const old = hunk.lines.filter((line) => line.op !== "+").map((line) => line.text);
+		const expected = (old.length === 0 ? hunk.oldStart : hunk.oldStart - 1) + delta;
+		let start = findMatch(lines, old, expected, cursor, bare);
+		if (start === -1) start = findMatch(lines, old, expected, cursor, loose);
+		if (start === -1) {
+			const probe = old.find((line) => line.trim() !== "") ?? old[0] ?? "";
+			throw new WorkspaceEditError(`Hunk ${hunkIndex + 1} of ${displayPath} does not apply: its context was not found in the file${probe === "" ? "" : ` (looked for a line like ${JSON.stringify(probe.slice(0, 80))})`}. Re-read the file and regenerate the patch.`, {
+				type: "hunk-failed",
+				path: displayPath,
+				hunkIndex
+			});
+		}
+		const replacement = [];
+		let consumed = start;
+		for (const line of hunk.lines) if (line.op === " ") {
+			replacement.push(lines[consumed]);
+			consumed++;
+		} else if (line.op === "-") consumed++;
+		else replacement.push(line.text + eol);
+		lines.splice(start, old.length, ...replacement);
+		cursor = start + replacement.length;
+		delta += replacement.length - old.length;
+		if (cursor >= lines.length) {
+			if (hunk.newNoNewline) trailingNewline = false;
+			else if (hunk.oldNoNewline || wasEmpty) trailingNewline = true;
+		}
+	});
+	if (lines.length === 0) return "";
+	return lines.join("\n") + (trailingNewline ? "\n" : "");
+}
+
+//#endregion
+export { applyHunks };
+//# sourceMappingURL=apply-hunks.mjs.map

package/esm/patch/apply-hunks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-hunks.mjs","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/patch/apply-hunks.ts"],"sourcesContent":["import { WorkspaceEditError } from \"../errors\";\nimport type { PatchHunk } from \"./parse-patch\";\n\n/** The text of a line without a trailing carriage return. */\nconst bare = (line: string): string => (line.endsWith(\"\\r\") ? line.slice(0, -1) : line);\n\n/** Same, and ignoring trailing blanks (a second, looser matching pass). */\nconst loose = (line: string): string => bare(line).trimEnd();\n\n/** Split file content into lines (carriage returns kept) and note the final newline. */\nfunction split(content: string): { lines: string[]; trailingNewline: boolean } {\n  if (content === \"\") {\n    return { lines: [], trailingNewline: false };\n  }\n\n  const parts = content.split(\"\\n\");\n  const trailingNewline = parts[parts.length - 1] === \"\";\n\n  if (trailingNewline) {\n    parts.pop();\n  }\n\n  return { lines: parts, trailingNewline };\n}\n\n/** Whether most of the file's lines end in CRLF. */\nfunction usesCrlf(lines: string[]): boolean {\n  const crlf = lines.filter((line) => line.endsWith(\"\\r\")).length;\n\n  return crlf > 0 && crlf * 2 >= lines.length;\n}\n\n/** First index at or after `from` (searching outward from `expected`) where `old` matches. */\nfunction findMatch(\n  lines: string[],\n  old: string[],\n  expected: number,\n  from: number,\n  normalize: (line: string) => string,\n): number {\n  if (old.length === 0) {\n    return Math.min(Math.max(expected, from), lines.length);\n  }\n\n  const last = lines.length - old.length;\n  const wanted = old.map(normalize);\n  const matches = (start: number): boolean =>\n    start >= from &&\n    start <= last &&\n    wanted.every((line, offset) => normalize(lines[start + offset] as string) === line);\n\n  for (let distance = 0; distance <= lines.length; distance++) {\n    if (matches(expected + distance)) {\n      return expected + distance;\n    }\n\n    if (distance > 0 && matches(expected - distance)) {\n      return expected - distance;\n    }\n  }\n\n  return -1;\n}\n\n/**\n * Apply a file's hunks to its content, in memory. Hunks are located by their\n * context (not only by line number, so a few lines of drift are fine), must\n * not overlap, and keep the file's line endings: untouched lines are\n * byte-for-byte as they were and added lines use the file's CRLF/LF style.\n *\n * Throws a `WorkspaceEditError` (`hunk-failed`) naming the first hunk whose\n * context is not in the file; nothing is returned in that case.\n */\nexport function applyHunks(content: string, hunks: PatchHunk[], displayPath: string): string {\n  const { lines, trailingNewline: initialTrailing } = split(content);\n  const wasEmpty = lines.length === 0;\n  const eol = usesCrlf(lines) ? \"\\r\" : \"\";\n  let trailingNewline = initialTrailing;\n  let cursor = 0;\n  let delta = 0;\n\n  hunks.forEach((hunk, hunkIndex) => {\n    const old = hunk.lines.filter((line) => line.op !== \"+\").map((line) => line.text);\n    // For a hunk with no old lines `oldStart` is the line *after which* to insert.\n    const expected = (old.length === 0 ? hunk.oldStart : hunk.oldStart - 1) + delta;\n    let start = findMatch(lines, old, expected, cursor, bare);\n\n    if (start === -1) {\n      start = findMatch(lines, old, expected, cursor, loose);\n    }\n\n    if (start === -1) {\n      const probe = old.find((line) => line.trim() !== \"\") ?? old[0] ?? \"\";\n\n      throw new WorkspaceEditError(\n        `Hunk ${hunkIndex + 1} of ${displayPath} does not apply: its context was not found in the file${probe === \"\" ? \"\" : ` (looked for a line like ${JSON.stringify(probe.slice(0, 80))})`}. Re-read the file and regenerate the patch.`,\n        { type: \"hunk-failed\", path: displayPath, hunkIndex },\n      );\n    }\n\n    const replacement: string[] = [];\n    let consumed = start;\n\n    for (const line of hunk.lines) {\n      if (line.op === \" \") {\n        replacement.push(lines[consumed] as string);\n        consumed++;\n      } else if (line.op === \"-\") {\n        consumed++;\n      } else {\n        replacement.push(line.text + eol);\n      }\n    }\n\n    lines.splice(start, old.length, ...replacement);\n    cursor = start + replacement.length;\n    delta += replacement.length - old.length;\n\n    if (cursor >= lines.length) {\n      if (hunk.newNoNewline) {\n        trailingNewline = false;\n      } else if (hunk.oldNoNewline || wasEmpty) {\n        trailingNewline = true;\n      }\n    }\n  });\n\n  if (lines.length === 0) {\n    return \"\";\n  }\n\n  // A final line that kept its \"\\r\" but now ends the file without a newline\n  // is left alone; only the newline itself is toggled.\n  return lines.join(\"\\n\") + (trailingNewline ? \"\\n\" : \"\");\n}\n"],"mappings":"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"}

package/esm/patch/apply-patch-generic.d.mts

@@ -0,0 +1,14 @@
+import { ApplyPatchInput, ApplyPatchResult } from "../contracts/tool-io.type.mjs";
+import { WorkspaceOps } from "../contracts/workspace-ops.contract.mjs";
+import "../contracts/index.mjs";
+//#region ../../packages/ai-workspace/src/patch/apply-patch-generic.d.ts
+/**
+ * `applyPatch` for a custom {@link WorkspaceOps} that does not provide its
+ * own: the same engine and the same all-or-nothing behaviour, built on the
+ * ops it does have (`exists`, `readFile`, `writeFile`, `remove`). Every
+ * hunk of every file is checked in memory first; the writes then run, and if
+ * one fails the ones already done are put back.
+ */
+export declare function applyPatchWithOps(ops: WorkspaceOps, input: ApplyPatchInput): Promise<ApplyPatchResult>;
+//#endregion
+//# sourceMappingURL=apply-patch-generic.d.mts.map

package/esm/patch/apply-patch-generic.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patch-generic.d.mts","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/patch/apply-patch-generic.ts"],"mappings":";;;;;;;;;;;wBAiDgB,kBACd,KAAK,cACL,OAAO,kBACN,QAAQ"}

package/esm/patch/apply-patch-generic.mjs

@@ -0,0 +1,68 @@
+import { WorkspaceEditError } from "../errors.mjs";
+import { executePatch } from "./execute-patch.mjs";
+import path from "node:path";
+import { fs } from "@warlock.js/fs";
+
+//#region ../../packages/ai-workspace/src/patch/apply-patch-generic.ts
+/** Most lines the generic reader asks `readFile` for. */
+const MAX_READ_LINES = 1e6;
+/**
+* Raw content of a file through `ops.readFile`, which returns numbered lines.
+* The numbering is stripped and the trailing newline restored by checking the
+* result against the file's hash, so the content is exact or the read fails.
+*/
+async function readRaw(ops, filePath) {
+	const result = await ops.readFile(filePath, {
+		offset: 1,
+		limit: MAX_READ_LINES
+	});
+	if (result.truncated || result.bytesCapped) throw new WorkspaceEditError(`"${filePath}" is too large to read in full; it cannot be patched.`, {
+		type: "patch-invalid",
+		path: filePath
+	});
+	const joined = (result.totalLines === 0 ? [] : result.content.split("\n").map((line) => line.replace(/^ *\d+\t/, ""))).join("\n");
+	for (const candidate of [
+		joined + "\n",
+		joined,
+		""
+	]) if (fs.hash.string(candidate) === result.hash) return candidate;
+	throw new WorkspaceEditError(`Could not read "${filePath}" exactly; it cannot be patched.`, {
+		type: "patch-invalid",
+		path: filePath
+	});
+}
+/**
+* `applyPatch` for a custom {@link WorkspaceOps} that does not provide its
+* own: the same engine and the same all-or-nothing behaviour, built on the
+* ops it does have (`exists`, `readFile`, `writeFile`, `remove`). Every
+* hunk of every file is checked in memory first; the writes then run, and if
+* one fails the ones already done are put back.
+*/
+function applyPatchWithOps(ops, input) {
+	const chain = /* @__PURE__ */ new Map();
+	return executePatch(input, {
+		resolve: async (inputPath) => {
+			const key = path.posix.normalize(inputPath.replace(/\\/g, "/"));
+			return {
+				absolutePath: key,
+				relativePath: key
+			};
+		},
+		exists: (key) => ops.exists(key),
+		read: (key) => readRaw(ops, key),
+		write: async (key, content) => {
+			await ops.writeFile(key, content);
+		},
+		remove: (key) => ops.remove(key),
+		withLock: async (key, task) => {
+			const current = (chain.get(key) ?? Promise.resolve()).then(task, task);
+			chain.set(key, current.catch(() => void 0));
+			return current;
+		},
+		display: (key) => key
+	});
+}
+
+//#endregion
+export { applyPatchWithOps };
+//# sourceMappingURL=apply-patch-generic.mjs.map

package/esm/patch/apply-patch-generic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patch-generic.mjs","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/patch/apply-patch-generic.ts"],"sourcesContent":["import path from \"node:path\";\nimport { fs } from \"@warlock.js/fs\";\nimport { WorkspaceEditError } from \"../errors\";\nimport type { ApplyPatchInput, ApplyPatchResult, WorkspaceOps } from \"../contracts\";\nimport { executePatch } from \"./execute-patch\";\n\n/** Most lines the generic reader asks `readFile` for. */\nconst MAX_READ_LINES = 1_000_000;\n\n/**\n * Raw content of a file through `ops.readFile`, which returns numbered lines.\n * The numbering is stripped and the trailing newline restored by checking the\n * result against the file's hash, so the content is exact or the read fails.\n */\nasync function readRaw(ops: WorkspaceOps, filePath: string): Promise<string> {\n  const result = await ops.readFile(filePath, { offset: 1, limit: MAX_READ_LINES });\n\n  if (result.truncated || result.bytesCapped) {\n    throw new WorkspaceEditError(\n      `\"${filePath}\" is too large to read in full; it cannot be patched.`,\n      { type: \"patch-invalid\", path: filePath },\n    );\n  }\n\n  const lines =\n    result.totalLines === 0\n      ? []\n      : result.content.split(\"\\n\").map((line) => line.replace(/^ *\\d+\\t/, \"\"));\n  const joined = lines.join(\"\\n\");\n\n  for (const candidate of [joined + \"\\n\", joined, \"\"]) {\n    if (fs.hash.string(candidate) === result.hash) {\n      return candidate;\n    }\n  }\n\n  throw new WorkspaceEditError(`Could not read \"${filePath}\" exactly; it cannot be patched.`, {\n    type: \"patch-invalid\",\n    path: filePath,\n  });\n}\n\n/**\n * `applyPatch` for a custom {@link WorkspaceOps} that does not provide its\n * own: the same engine and the same all-or-nothing behaviour, built on the\n * ops it does have (`exists`, `readFile`, `writeFile`, `remove`). Every\n * hunk of every file is checked in memory first; the writes then run, and if\n * one fails the ones already done are put back.\n */\nexport function applyPatchWithOps(\n  ops: WorkspaceOps,\n  input: ApplyPatchInput,\n): Promise<ApplyPatchResult> {\n  // Keys are normalised relative paths; the ops enforce their own jail on each call.\n  const chain = new Map<string, Promise<unknown>>();\n\n  return executePatch(input, {\n    resolve: async (inputPath) => {\n      const key = path.posix.normalize(inputPath.replace(/\\\\/g, \"/\"));\n\n      return { absolutePath: key, relativePath: key };\n    },\n    exists: (key) => ops.exists(key),\n    read: (key) => readRaw(ops, key),\n    write: async (key, content) => {\n      await ops.writeFile(key, content);\n    },\n    remove: (key) => ops.remove(key),\n    withLock: async (key, task) => {\n      const previous = chain.get(key) ?? Promise.resolve();\n      const current = previous.then(task, task);\n\n      chain.set(\n        key,\n        current.catch(() => undefined),\n      );\n\n      return current;\n    },\n    display: (key) => key,\n  });\n}\n"],"mappings":";;;;;;;AAOA,MAAM,iBAAiB;;;;;;AAOvB,eAAe,QAAQ,KAAmB,UAAmC;CAC3E,MAAM,SAAS,MAAM,IAAI,SAAS,UAAU;EAAE,QAAQ;EAAG,OAAO;CAAe,CAAC;CAEhF,IAAI,OAAO,aAAa,OAAO,aAC7B,MAAM,IAAI,mBACR,IAAI,SAAS,wDACb;EAAE,MAAM;EAAiB,MAAM;CAAS,CAC1C;CAOF,MAAM,UAHJ,OAAO,eAAe,IAClB,CAAC,IACD,OAAO,QAAQ,MAAM,IAAI,CAAC,CAAC,KAAK,SAAS,KAAK,QAAQ,YAAY,EAAE,CAAC,EACvD,CAAC,KAAK,IAAI;CAE9B,KAAK,MAAM,aAAa;EAAC,SAAS;EAAM;EAAQ;CAAE,GAChD,IAAI,GAAG,KAAK,OAAO,SAAS,MAAM,OAAO,MACvC,OAAO;CAIX,MAAM,IAAI,mBAAmB,mBAAmB,SAAS,mCAAmC;EAC1F,MAAM;EACN,MAAM;CACR,CAAC;AACH;;;;;;;;AASA,SAAgB,kBACd,KACA,OAC2B;CAE3B,MAAM,wBAAQ,IAAI,IAA8B;CAEhD,OAAO,aAAa,OAAO;EACzB,SAAS,OAAO,cAAc;GAC5B,MAAM,MAAM,KAAK,MAAM,UAAU,UAAU,QAAQ,OAAO,GAAG,CAAC;GAE9D,OAAO;IAAE,cAAc;IAAK,cAAc;GAAI;EAChD;EACA,SAAS,QAAQ,IAAI,OAAO,GAAG;EAC/B,OAAO,QAAQ,QAAQ,KAAK,GAAG;EAC/B,OAAO,OAAO,KAAK,YAAY;GAC7B,MAAM,IAAI,UAAU,KAAK,OAAO;EAClC;EACA,SAAS,QAAQ,IAAI,OAAO,GAAG;EAC/B,UAAU,OAAO,KAAK,SAAS;GAE7B,MAAM,WADW,MAAM,IAAI,GAAG,KAAK,QAAQ,QAAQ,EAC3B,CAAC,KAAK,MAAM,IAAI;GAExC,MAAM,IACJ,KACA,QAAQ,YAAY,MAAS,CAC/B;GAEA,OAAO;EACT;EACA,UAAU,QAAQ;CACpB,CAAC;AACH"}

package/esm/patch/execute-patch.mjs

@@ -0,0 +1,151 @@
+import { WorkspaceEditError } from "../errors.mjs";
+import { applyHunks } from "./apply-hunks.mjs";
+import { parsePatch } from "./parse-patch.mjs";
+import { fs } from "@warlock.js/fs";
+
+//#region ../../packages/ai-workspace/src/patch/execute-patch.ts
+/** Largest file, in UTF-8 bytes, `applyPatch` will read and rewrite. */
+const MAX_PATCH_FILE_BYTES = 10485760;
+async function executePatch(input, io) {
+	{
+		const filePatches = parsePatch(input.patch);
+		const targets = await Promise.all(filePatches.map(async (filePatch) => ({
+			filePatch,
+			from: filePatch.oldPath === null ? null : await io.resolve(filePatch.oldPath),
+			to: filePatch.newPath === null ? null : await io.resolve(filePatch.newPath)
+		})));
+		const lockPaths = [...new Set(targets.flatMap((target) => [target.from?.absolutePath, target.to?.absolutePath].filter((value) => value !== void 0)))].sort();
+		const run = async () => {
+			const staged = /* @__PURE__ */ new Map();
+			const original = /* @__PURE__ */ new Map();
+			const results = [];
+			const load = async (absolutePath, shown) => {
+				if (staged.has(absolutePath)) return staged.get(absolutePath) ?? null;
+				if (!await io.exists(absolutePath)) {
+					original.set(absolutePath, null);
+					return null;
+				}
+				const stat = io.stat ? await io.stat(absolutePath) : void 0;
+				if (stat !== void 0 && stat.type !== "file") throw new WorkspaceEditError(`"${shown}" is not a regular file; it cannot be patched.`, {
+					type: "file-missing",
+					path: shown
+				});
+				if (stat !== void 0 && stat.size > MAX_PATCH_FILE_BYTES) throw new WorkspaceEditError(`"${shown}" is larger than ${MAX_PATCH_FILE_BYTES} bytes; it cannot be patched.`, {
+					type: "patch-invalid",
+					path: shown
+				});
+				const content = await io.read(absolutePath);
+				if (content.includes("\0")) throw new WorkspaceEditError(`"${shown}" is a binary file; binary files cannot be patched.`, {
+					type: "binary-file",
+					path: shown
+				});
+				original.set(absolutePath, content);
+				return content;
+			};
+			for (const { filePatch, from, to } of targets) {
+				const shownFrom = from?.relativePath || filePatch.oldPath || "";
+				const shownTo = to?.relativePath || filePatch.newPath || "";
+				if (filePatch.kind === "create") {
+					const absolutePath = to.absolutePath;
+					if (await load(absolutePath, shownTo) !== null) throw new WorkspaceEditError(`"${shownTo}" already exists; the patch cannot create it.`, {
+						type: "file-exists",
+						path: shownTo
+					});
+					const content = applyHunks("", filePatch.hunks, shownTo);
+					staged.set(absolutePath, content);
+					results.push({
+						path: shownTo,
+						action: "created",
+						hunks: filePatch.hunks.length,
+						hash: fs.hash.string(content)
+					});
+					continue;
+				}
+				const source = from.absolutePath;
+				const current = await load(source, shownFrom);
+				if (current === null) throw new WorkspaceEditError(`"${shownFrom}" does not exist; the patch cannot change it.`, {
+					type: "file-missing",
+					path: shownFrom
+				});
+				const updated = applyHunks(current, filePatch.hunks, shownFrom);
+				if (filePatch.kind === "delete") {
+					if (updated !== "") throw new WorkspaceEditError(`The patch deletes "${shownFrom}" but its hunks do not remove all of the file's content.`, {
+						type: "hunk-failed",
+						path: shownFrom,
+						hunkIndex: Math.max(filePatch.hunks.length - 1, 0)
+					});
+					staged.set(source, null);
+					results.push({
+						path: shownFrom,
+						action: "deleted",
+						hunks: filePatch.hunks.length
+					});
+					continue;
+				}
+				if (filePatch.kind === "rename") {
+					const destination = to.absolutePath;
+					if (destination !== source && await load(destination, shownTo) !== null) throw new WorkspaceEditError(`"${shownTo}" already exists; the patch cannot rename "${shownFrom}" onto it.`, {
+						type: "file-exists",
+						path: shownTo
+					});
+					staged.set(source, null);
+					staged.set(destination, updated);
+					results.push({
+						path: shownTo,
+						action: "renamed",
+						oldPath: shownFrom,
+						hunks: filePatch.hunks.length,
+						hash: fs.hash.string(updated)
+					});
+					continue;
+				}
+				staged.set(source, updated);
+				results.push({
+					path: shownFrom,
+					action: "modified",
+					hunks: filePatch.hunks.length,
+					hash: fs.hash.string(updated)
+				});
+			}
+			if (input.dryRun === true) return {
+				files: results,
+				dryRun: true
+			};
+			const touched = [];
+			try {
+				for (const [absolutePath, content] of staged) if (content !== null && content !== (original.get(absolutePath) ?? null)) {
+					await io.write(absolutePath, content);
+					touched.push(absolutePath);
+				}
+				for (const [absolutePath, content] of staged) if (content === null && original.get(absolutePath) !== null && original.has(absolutePath)) {
+					await io.remove(absolutePath);
+					touched.push(absolutePath);
+				}
+			} catch (error) {
+				const failures = [];
+				for (const absolutePath of touched.reverse()) try {
+					const before = original.get(absolutePath) ?? null;
+					if (before === null) {
+						if (await io.exists(absolutePath)) await io.remove(absolutePath);
+					} else await io.write(absolutePath, before);
+				} catch {
+					failures.push(io.display(absolutePath));
+				}
+				const reason = error instanceof Error ? error.message : String(error);
+				throw new WorkspaceEditError(`Writing the patch failed (${reason}); ${failures.length === 0 ? "every change was rolled back" : `could not restore: ${failures.join(", ")}`}.`, {
+					type: "patch-invalid",
+					path: ""
+				});
+			}
+			return {
+				files: results,
+				dryRun: false
+			};
+		};
+		return lockPaths.reduceRight((inner, lockPath) => () => io.withLock(lockPath, inner), run)();
+	}
+}
+
+//#endregion
+export { executePatch };
+//# sourceMappingURL=execute-patch.mjs.map

package/esm/patch/execute-patch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-patch.mjs","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/patch/execute-patch.ts"],"sourcesContent":["import { fs } from \"@warlock.js/fs\";\nimport { WorkspaceEditError } from \"../errors\";\nimport type { ApplyPatchFileResult, ApplyPatchInput, ApplyPatchResult } from \"../contracts\";\nimport { applyHunks } from \"./apply-hunks\";\nimport { parsePatch } from \"./parse-patch\";\n\n/** Largest file, in UTF-8 bytes, `applyPatch` will read and rewrite. */\nconst MAX_PATCH_FILE_BYTES = 10 * 1024 * 1024;\n\n/** The file operations the patch engine runs on; the workspace ops layer and the generic fallback each provide one. */\nexport interface PatchIO {\n  /** Turn a patch path into a stable key plus a display path (and refuse a path outside the workspace). */\n  resolve(inputPath: string): Promise<{ absolutePath: string; relativePath: string }>;\n  exists(key: string): Promise<boolean>;\n  stat?(key: string): Promise<{ type: string; size: number }>;\n  /** Raw file content. */\n  read(key: string): Promise<string>;\n  /** Write content, creating parent directories. */\n  write(key: string, content: string): Promise<void>;\n  remove(key: string): Promise<void>;\n  withLock<T>(key: string, task: () => Promise<T>): Promise<T>;\n  display(key: string): string;\n}\n\nexport async function executePatch(input: ApplyPatchInput, io: PatchIO): Promise<ApplyPatchResult> {\n  {\n    const filePatches = parsePatch(input.patch);\n\n    // Resolve every path through the jail first (symlinks, `..`, deny globs).\n    const targets = await Promise.all(\n      filePatches.map(async (filePatch) => ({\n        filePatch,\n        from: filePatch.oldPath === null ? null : await io.resolve(filePatch.oldPath),\n        to: filePatch.newPath === null ? null : await io.resolve(filePatch.newPath),\n      })),\n    );\n\n    const lockPaths = [\n      ...new Set(\n        targets.flatMap((target) =>\n          [target.from?.absolutePath, target.to?.absolutePath].filter(\n            (value): value is string => value !== undefined,\n          ),\n        ),\n      ),\n    ].sort();\n\n    const run = async (): Promise<ApplyPatchResult> => {\n      // Virtual tree: absolute path -> content (null = removed). Later file\n      // patches see the result of earlier ones.\n      const staged = new Map<string, string | null>();\n      const original = new Map<string, string | null>();\n      const results: ApplyPatchFileResult[] = [];\n\n      const load = async (absolutePath: string, shown: string): Promise<string | null> => {\n        if (staged.has(absolutePath)) {\n          return staged.get(absolutePath) ?? null;\n        }\n\n        if (!(await io.exists(absolutePath))) {\n          original.set(absolutePath, null);\n\n          return null;\n        }\n\n        const stat = io.stat ? await io.stat(absolutePath) : undefined;\n\n        if (stat !== undefined && stat.type !== \"file\") {\n          throw new WorkspaceEditError(`\"${shown}\" is not a regular file; it cannot be patched.`, {\n            type: \"file-missing\",\n            path: shown,\n          });\n        }\n\n        if (stat !== undefined && stat.size > MAX_PATCH_FILE_BYTES) {\n          throw new WorkspaceEditError(\n            `\"${shown}\" is larger than ${MAX_PATCH_FILE_BYTES} bytes; it cannot be patched.`,\n            { type: \"patch-invalid\", path: shown },\n          );\n        }\n\n        const content = await io.read(absolutePath);\n\n        if (content.includes(\"\\0\")) {\n          throw new WorkspaceEditError(\n            `\"${shown}\" is a binary file; binary files cannot be patched.`,\n            {\n              type: \"binary-file\",\n              path: shown,\n            },\n          );\n        }\n\n        original.set(absolutePath, content);\n\n        return content;\n      };\n\n      for (const { filePatch, from, to } of targets) {\n        const shownFrom = from?.relativePath || filePatch.oldPath || \"\";\n        const shownTo = to?.relativePath || filePatch.newPath || \"\";\n\n        if (filePatch.kind === \"create\") {\n          const absolutePath = (to as NonNullable<typeof to>).absolutePath;\n\n          if ((await load(absolutePath, shownTo)) !== null) {\n            throw new WorkspaceEditError(\n              `\"${shownTo}\" already exists; the patch cannot create it.`,\n              {\n                type: \"file-exists\",\n                path: shownTo,\n              },\n            );\n          }\n\n          const content = applyHunks(\"\", filePatch.hunks, shownTo);\n\n          staged.set(absolutePath, content);\n          results.push({\n            path: shownTo,\n            action: \"created\",\n            hunks: filePatch.hunks.length,\n            hash: fs.hash.string(content),\n          });\n\n          continue;\n        }\n\n        const source = (from as NonNullable<typeof from>).absolutePath;\n        const current = await load(source, shownFrom);\n\n        if (current === null) {\n          throw new WorkspaceEditError(\n            `\"${shownFrom}\" does not exist; the patch cannot change it.`,\n            {\n              type: \"file-missing\",\n              path: shownFrom,\n            },\n          );\n        }\n\n        const updated = applyHunks(current, filePatch.hunks, shownFrom);\n\n        if (filePatch.kind === \"delete\") {\n          if (updated !== \"\") {\n            throw new WorkspaceEditError(\n              `The patch deletes \"${shownFrom}\" but its hunks do not remove all of the file's content.`,\n              {\n                type: \"hunk-failed\",\n                path: shownFrom,\n                hunkIndex: Math.max(filePatch.hunks.length - 1, 0),\n              },\n            );\n          }\n\n          staged.set(source, null);\n          results.push({ path: shownFrom, action: \"deleted\", hunks: filePatch.hunks.length });\n\n          continue;\n        }\n\n        if (filePatch.kind === \"rename\") {\n          const destination = (to as NonNullable<typeof to>).absolutePath;\n\n          if (destination !== source && (await load(destination, shownTo)) !== null) {\n            throw new WorkspaceEditError(\n              `\"${shownTo}\" already exists; the patch cannot rename \"${shownFrom}\" onto it.`,\n              { type: \"file-exists\", path: shownTo },\n            );\n          }\n\n          staged.set(source, null);\n          staged.set(destination, updated);\n          results.push({\n            path: shownTo,\n            action: \"renamed\",\n            oldPath: shownFrom,\n            hunks: filePatch.hunks.length,\n            hash: fs.hash.string(updated),\n          });\n\n          continue;\n        }\n\n        staged.set(source, updated);\n        results.push({\n          path: shownFrom,\n          action: \"modified\",\n          hunks: filePatch.hunks.length,\n          hash: fs.hash.string(updated),\n        });\n      }\n\n      if (input.dryRun === true) {\n        return { files: results, dryRun: true };\n      }\n\n      // Commit. Anything that fails part-way is rolled back to the original state.\n      const touched: string[] = [];\n\n      try {\n        for (const [absolutePath, content] of staged) {\n          if (content !== null && content !== (original.get(absolutePath) ?? null)) {\n            await io.write(absolutePath, content);\n            touched.push(absolutePath);\n          }\n        }\n\n        for (const [absolutePath, content] of staged) {\n          if (\n            content === null &&\n            original.get(absolutePath) !== null &&\n            original.has(absolutePath)\n          ) {\n            await io.remove(absolutePath);\n            touched.push(absolutePath);\n          }\n        }\n      } catch (error) {\n        const failures: string[] = [];\n\n        for (const absolutePath of touched.reverse()) {\n          try {\n            const before = original.get(absolutePath) ?? null;\n\n            if (before === null) {\n              if (await io.exists(absolutePath)) {\n                await io.remove(absolutePath);\n              }\n            } else {\n              await io.write(absolutePath, before);\n            }\n          } catch {\n            failures.push(io.display(absolutePath));\n          }\n        }\n\n        const reason = error instanceof Error ? error.message : String(error);\n\n        throw new WorkspaceEditError(\n          `Writing the patch failed (${reason}); ${failures.length === 0 ? \"every change was rolled back\" : `could not restore: ${failures.join(\", \")}`}.`,\n          { type: \"patch-invalid\", path: \"\" },\n        );\n      }\n\n      return { files: results, dryRun: false };\n    };\n\n    // Hold every touched path's lock (sorted, so concurrent patches cannot deadlock).\n    const locked = lockPaths.reduceRight<() => Promise<ApplyPatchResult>>(\n      (inner, lockPath) => () => io.withLock(lockPath, inner),\n      run,\n    );\n\n    return locked();\n  }\n}\n"],"mappings":"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"}

package/esm/patch/parse-patch.d.mts

@@ -0,0 +1,45 @@
+//#region ../../packages/ai-workspace/src/patch/parse-patch.d.ts
+/** One line of a hunk: context (`" "`), removal (`"-"`) or addition (`"+"`). */
+export interface PatchLine {
+  /** What the line does. */
+  op: " " | "-" | "+";
+  /** The line's text, without its line ending. */
+  text: string;
+}
+/** One `@@ … @@` block of a file's patch. */
+export interface PatchHunk {
+  /** 1-based first line in the old file (the line *after* which text is inserted when `oldCount` is 0). */
+  oldStart: number;
+  /** Number of old-file lines the hunk covers. */
+  oldCount: number;
+  /** The hunk body. */
+  lines: PatchLine[];
+  /** The old side ends without a trailing newline. */
+  oldNoNewline: boolean;
+  /** The new side ends without a trailing newline. */
+  newNoNewline: boolean;
+}
+/** What a file's patch does to the tree. */
+export type FilePatchKind = "modify" | "create" | "delete" | "rename";
+/** Everything a unified diff says about one file. */
+export interface FilePatch {
+  kind: FilePatchKind;
+  /** Path before the change (`null` for a create). */
+  oldPath: string | null;
+  /** Path after the change (`null` for a delete). */
+  newPath: string | null;
+  hunks: PatchHunk[];
+}
+/**
+ * Parse a unified diff (plain or `git diff` style) into per-file patches:
+ * modifications, creates (`--- /dev/null`), deletes (`+++ /dev/null`) and
+ * renames (`rename from` / `rename to`). A binary patch, a copy, or text that
+ * is not a diff throws a `WorkspaceEditError` (`patch-invalid` /
+ * `binary-file`) naming the problem.
+ *
+ * A CRLF-wrapped patch is accepted: one trailing `\r` is dropped from every
+ * line.
+ */
+export declare function parsePatch(text: string): FilePatch[];
+//#endregion
+//# sourceMappingURL=parse-patch.d.mts.map

package/esm/patch/parse-patch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-patch.d.mts","names":[],"sources":["../../../../../../../../packages/ai-workspace/src/patch/parse-patch.ts"],"mappings":";;iBAGiB;;EAEf;;EAEA;;;iBAIe;;EAEf;;EAEA;;EAEA,OAAO;;EAEP;;EAEA;;;YAIU;;iBAGK;EACf,MAAM;;EAEN;;EAEA;EACA,OAAO;;;;;;;;;;;;wBA2DO,WAAW,eAAe"}

package/esm/patch/parse-patch.mjs

@@ -0,0 +1,201 @@
+import { WorkspaceEditError } from "../errors.mjs";
+
+//#region ../../packages/ai-workspace/src/patch/parse-patch.ts
+/** Longest patch text accepted, in characters. */
+const MAX_PATCH_CHARS = 2097152;
+/** Most files one patch may touch. */
+const MAX_PATCH_FILES = 200;
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+function invalid(message, path = "") {
+	return new WorkspaceEditError(message, {
+		type: "patch-invalid",
+		path
+	});
+}
+/** Unquote a git-quoted path (`"a/with\ttab"`) and strip a trailing timestamp. */
+function cleanPath(raw) {
+	let value = raw.trim();
+	if (value.startsWith("\"")) {
+		const end = value.lastIndexOf("\"");
+		return (end > 0 ? value.slice(1, end) : value.slice(1)).replace(/\\(["\\tn])/g, (_match, char) => char === "t" ? "	" : char === "n" ? "\n" : char);
+	}
+	const tab = value.indexOf("	");
+	if (tab !== -1) value = value.slice(0, tab);
+	return value.trimEnd();
+}
+/** `a/x` → `x`; `/dev/null` → `null`. */
+function stripPrefix(raw, git) {
+	const value = cleanPath(raw);
+	if (value === "/dev/null") return null;
+	return git && /^[ab]\//.test(value) ? value.slice(2) : value;
+}
+/**
+* Parse a unified diff (plain or `git diff` style) into per-file patches:
+* modifications, creates (`--- /dev/null`), deletes (`+++ /dev/null`) and
+* renames (`rename from` / `rename to`). A binary patch, a copy, or text that
+* is not a diff throws a `WorkspaceEditError` (`patch-invalid` /
+* `binary-file`) naming the problem.
+*
+* A CRLF-wrapped patch is accepted: one trailing `\r` is dropped from every
+* line.
+*/
+function parsePatch(text) {
+	if (text.length > 2097152) throw invalid(`The patch is larger than ${MAX_PATCH_CHARS} characters; split it up.`);
+	const lines = text.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+	const files = [];
+	let current;
+	const finish = () => {
+		if (current === void 0) return;
+		const state = current;
+		current = void 0;
+		let dashOld = state.oldPath;
+		let dashNew = state.newPath;
+		if (!state.git) {
+			const oldOk = dashOld === void 0 || dashOld === null || dashOld.startsWith("a/");
+			const newOk = dashNew === void 0 || dashNew === null || dashNew.startsWith("b/");
+			if (oldOk && newOk) {
+				dashOld = typeof dashOld === "string" ? dashOld.slice(2) : dashOld;
+				dashNew = typeof dashNew === "string" ? dashNew.slice(2) : dashNew;
+			}
+		}
+		let oldPath = state.renameFrom ?? dashOld;
+		let newPath = state.renameTo ?? dashNew;
+		if (state.isNew) oldPath = null;
+		if (state.isDeleted) newPath = null;
+		if (oldPath === void 0 && newPath === void 0) throw invalid("A file section of the patch names no file.");
+		if (oldPath === void 0) oldPath = newPath ?? null;
+		if (newPath === void 0) newPath = oldPath;
+		const kind = oldPath === null ? "create" : newPath === null ? "delete" : oldPath !== newPath ? "rename" : "modify";
+		if (state.hunks.length === 0 && kind === "modify") return;
+		files.push({
+			kind,
+			oldPath,
+			newPath,
+			hunks: state.hunks
+		});
+	};
+	const open = (git) => {
+		finish();
+		current = {
+			git,
+			oldPath: void 0,
+			newPath: void 0,
+			isNew: false,
+			isDeleted: false,
+			hunks: []
+		};
+		return current;
+	};
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		if (line.startsWith("diff --git ")) {
+			const section = open(true);
+			const rest = line.slice(11);
+			const split = rest.indexOf(" b/");
+			if (rest.startsWith("a/") && split !== -1) {
+				section.oldPath = rest.slice(2, split);
+				section.newPath = rest.slice(split + 3);
+			}
+			continue;
+		}
+		if (line.startsWith("--- ") && lines[index + 1]?.startsWith("+++ ") === true && (current === void 0 || !current.git && current.hunks.length > 0)) open(false);
+		else if (current === void 0) {
+			if (line.startsWith("*** Begin Patch")) throw invalid("This is the \"*** Begin Patch\" format, not a unified diff. Send a unified diff (`--- a/file` / `+++ b/file` / `@@` hunks).");
+			continue;
+		}
+		const section = current;
+		if (line.startsWith("GIT binary patch") || /^Binary files .* differ$/.test(line)) {
+			const shown = section.newPath ?? section.oldPath ?? "a file";
+			throw new WorkspaceEditError(`The patch changes a binary file (${shown}); binary files cannot be patched.`, {
+				type: "binary-file",
+				path: shown ?? ""
+			});
+		}
+		if (line.startsWith("copy from ") || line.startsWith("copy to ")) throw invalid("Copies are not supported in a patch; create the new file instead.");
+		if (line.startsWith("rename from ")) {
+			section.renameFrom = cleanPath(line.slice(12));
+			continue;
+		}
+		if (line.startsWith("rename to ")) {
+			section.renameTo = cleanPath(line.slice(10));
+			continue;
+		}
+		if (line.startsWith("new file mode")) {
+			section.isNew = true;
+			continue;
+		}
+		if (line.startsWith("deleted file mode")) {
+			section.isDeleted = true;
+			continue;
+		}
+		if (line.startsWith("--- ") && section.hunks.length === 0) {
+			section.oldPath = stripPrefix(line.slice(4), section.git);
+			if (section.oldPath === null) section.isNew = true;
+			continue;
+		}
+		if (line.startsWith("+++ ") && section.hunks.length === 0) {
+			section.newPath = stripPrefix(line.slice(4), section.git);
+			if (section.newPath === null) section.isDeleted = true;
+			continue;
+		}
+		const header = HUNK_HEADER.exec(line);
+		if (header !== null) {
+			const oldStart = Number(header[1]);
+			const oldCount = header[2] === void 0 ? 1 : Number(header[2]);
+			let newCount = header[4] === void 0 ? 1 : Number(header[4]);
+			let remainingOld = oldCount;
+			const hunk = {
+				oldStart,
+				oldCount,
+				lines: [],
+				oldNoNewline: false,
+				newNoNewline: false
+			};
+			while (remainingOld > 0 || newCount > 0 || lines[index + 1]?.startsWith("\\")) {
+				const body = lines[index + 1];
+				if (body === void 0) break;
+				if (body.startsWith("\\")) {
+					const last = hunk.lines[hunk.lines.length - 1];
+					if (last?.op !== "+") hunk.oldNoNewline = true;
+					if (last?.op !== "-") hunk.newNoNewline = true;
+					index++;
+					continue;
+				}
+				if (remainingOld <= 0 && newCount <= 0) break;
+				const op = body.charAt(0);
+				if (op === "+" && newCount > 0) {
+					hunk.lines.push({
+						op: "+",
+						text: body.slice(1)
+					});
+					newCount--;
+				} else if (op === "-" && remainingOld > 0) {
+					hunk.lines.push({
+						op: "-",
+						text: body.slice(1)
+					});
+					remainingOld--;
+				} else if ((op === " " || body === "") && remainingOld > 0 && newCount > 0) {
+					hunk.lines.push({
+						op: " ",
+						text: body.slice(1)
+					});
+					remainingOld--;
+					newCount--;
+				} else break;
+				index++;
+			}
+			if (remainingOld > 0 || newCount > 0) throw invalid(`Hunk ${section.hunks.length + 1} of ${section.newPath ?? section.oldPath ?? "the patch"} is truncated or its line counts in the @@ header are wrong.`, section.newPath ?? section.oldPath ?? "");
+			section.hunks.push(hunk);
+			continue;
+		}
+	}
+	finish();
+	if (files.length === 0) throw invalid("The patch contains no file changes. Send a unified diff with ---/+++ headers and @@ hunks.");
+	if (files.length > 200) throw invalid(`The patch touches more than ${200} files; split it up.`);
+	return files;
+}
+
+//#endregion
+export { MAX_PATCH_CHARS, parsePatch };
+//# sourceMappingURL=parse-patch.mjs.map