@warlock.js/ai-workspace 5.39.1 → 5.40.0

package/cjs/index.cjs

@@ -89,6 +89,7 @@ var WorkspaceEditError = class extends _warlock_js_ai.AIError {
 		this.expectedHash = options.expectedHash;
 		this.actualHash = options.actualHash;
 		this.editIndex = options.editIndex;
+		this.hunkIndex = options.hunkIndex;
 	}
 };
 /**
@@ -1900,6 +1901,493 @@ function buildCommandEnv(policy) {
 	return env;
 }
 
+//#endregion
+//#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
+//#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
+//#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: _warlock_js_fs.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: _warlock_js_fs.fs.hash.string(updated)
+					});
+					continue;
+				}
+				staged.set(source, updated);
+				results.push({
+					path: shownFrom,
+					action: "modified",
+					hunks: filePatch.hunks.length,
+					hash: _warlock_js_fs.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
+//#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 (_warlock_js_fs.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 = node_path.default.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
 //#region ../../packages/ai-workspace/src/shell-jobs.ts
 /** Finished commands kept for a last `shell_output` read before the oldest are pruned. */
@@ -2405,6 +2893,21 @@ var Ops = class {
 			};
 		});
 	}
+	async applyPatch(input) {
+		return executePatch(input, {
+			resolve: (inputPath) => resolveInJail(this.policy, inputPath),
+			exists: (absolutePath) => this.backend.exists(absolutePath),
+			stat: this.backend.stat ? (absolutePath) => this.backend.stat(absolutePath) : void 0,
+			read: (absolutePath) => this.backend.readFile(absolutePath),
+			write: async (absolutePath, content) => {
+				await this.backend.mkdir(node_path.default.dirname(absolutePath));
+				await this.backend.writeFile(absolutePath, content);
+			},
+			remove: (absolutePath) => this.backend.remove(absolutePath),
+			withLock: (key, task) => this.withPathLock(key, task),
+			display: (absolutePath) => node_path.default.relative(this.policy.cwd, absolutePath)
+		});
+	}
 	/**
 	* Check a command line against the shell policy: every command in it
 	* (argv or shell mode), then — shell mode — every redirection target and
@@ -3370,120 +3873,6 @@ function isMockBackendSeed(seed) {
 	return typeof seed.files === "object" || typeof seed.commands === "object";
 }
 
-//#endregion
-//#region ../../packages/ai-workspace/src/tools/schema.ts
-/**
-* Tiny, dependency-free [Standard Schema](https://standardschema.dev)
-* builders for the workspace tools' input validation. The package pins
-* only `@warlock.js/ai` and `@warlock.js/fs` as runtime dependencies, so
-* rather than pull in a schema library we hand-roll the few shapes the
-* file tools need — exactly the pattern `@warlock.js/ai`'s own `tool()`
-* tests use. Each builder returns a `StandardSchemaV1`, which is what
-* `tool({ input })` validates against before calling `execute`.
-*
-* These intentionally cover only the primitive cases the FILE tools
-* require (`string`, `optional string`, `optional number`, `optional
-* boolean`, and an `object` of fields). They are not a general-purpose
-* validator.
-*/
-/** The vendor tag stamped on every issue these builders produce. */
-const VENDOR = "ai-workspace";
-/** Attach a JSON Schema description to a hand-rolled Standard Schema. */
-function withJsonSchema(schema, jsonSchema) {
-	return Object.assign(schema, { jsonSchema });
-}
-/** Required string field — rejects anything that is not a string. */
-function stringField() {
-	return (value, key) => {
-		if (typeof value === "string") return { value };
-		return { issues: [{
-			message: `"${key}" must be a string`,
-			path: [key]
-		}] };
-	};
-}
-/**
-* Optional string field — accepts `undefined` (the property absent or
-* explicitly undefined) or a string, and rejects every other type.
-*/
-function optionalStringField() {
-	return (value, key) => {
-		if (value === void 0) return { value: void 0 };
-		if (typeof value === "string") return { value };
-		return { issues: [{
-			message: `"${key}" must be a string when provided`,
-			path: [key]
-		}] };
-	};
-}
-/**
-* Optional finite-number field — accepts `undefined` or a finite number,
-* rejecting `NaN`/`Infinity` and non-number types.
-*/
-function optionalNumberField() {
-	return (value, key) => {
-		if (value === void 0) return { value: void 0 };
-		if (typeof value === "number" && Number.isFinite(value)) return { value };
-		return { issues: [{
-			message: `"${key}" must be a finite number when provided`,
-			path: [key]
-		}] };
-	};
-}
-/** Optional boolean field — accepts `undefined` or a boolean. */
-function optionalBooleanField() {
-	return (value, key) => {
-		if (value === void 0) return { value: void 0 };
-		if (typeof value === "boolean") return { value };
-		return { issues: [{
-			message: `"${key}" must be a boolean when provided`,
-			path: [key]
-		}] };
-	};
-}
-/**
-* Optional array-of-strings field — accepts `undefined` or an array whose
-* every element is a string (at most `maxItems` of them).
-*/
-function optionalStringArrayField(maxItems = 50) {
-	return (value, key) => {
-		if (value === void 0) return { value: void 0 };
-		if (Array.isArray(value) && value.length <= maxItems && value.every((item) => typeof item === "string")) return { value };
-		return { issues: [{
-			message: `"${key}" must be an array of at most ${maxItems} strings when provided`,
-			path: [key]
-		}] };
-	};
-}
-function objectSchema(shape, jsonSchema) {
-	const schema = buildObjectSchema(shape);
-	return jsonSchema === void 0 ? schema : withJsonSchema(schema, jsonSchema);
-}
-/** The validator behind {@link objectSchema}. */
-function buildObjectSchema(shape) {
-	return { "~standard": {
-		version: 1,
-		vendor: VENDOR,
-		validate(input) {
-			if (typeof input !== "object" || input === null || Array.isArray(input)) return { issues: [{ message: "input must be an object" }] };
-			const source = input;
-			const issues = [];
-			const result = {};
-			for (const key of Object.keys(shape)) {
-				const field = shape[key];
-				const outcome = field(source[key], key);
-				if ("issues" in outcome) {
-					issues.push(...outcome.issues);
-					continue;
-				}
-				if (outcome.value !== void 0) result[key] = outcome.value;
-			}
-			if (issues.length > 0) return { issues };
-			return { value: result };
-		}
-	} };
-}
-
 //#endregion
 //#region ../../packages/ai-workspace/src/tools/json-schemas.ts
 /**
@@ -3530,6 +3919,15 @@ const EDIT_FILE_JSON_SCHEMA = {
 		"newString"
 	]
 };
+/** `apply_patch`. */
+const APPLY_PATCH_JSON_SCHEMA = {
+	type: "object",
+	properties: {
+		patch: string("Unified diff (--- a/file, +++ b/file, @@ hunks; git style with rename from/to, new file, deleted file is fine). Applies to all files or none. Binary files are refused."),
+		dryRun: boolean("Check that the patch applies without writing anything.")
+	},
+	required: ["patch"]
+};
 /** `multi_edit`. */
 const MULTI_EDIT_JSON_SCHEMA = {
 	type: "object",
@@ -3657,6 +4055,174 @@ const TODO_READ_JSON_SCHEMA = {
 	properties: {}
 };
 
+//#endregion
+//#region ../../packages/ai-workspace/src/tools/schema.ts
+/**
+* Tiny, dependency-free [Standard Schema](https://standardschema.dev)
+* builders for the workspace tools' input validation. The package pins
+* only `@warlock.js/ai` and `@warlock.js/fs` as runtime dependencies, so
+* rather than pull in a schema library we hand-roll the few shapes the
+* file tools need — exactly the pattern `@warlock.js/ai`'s own `tool()`
+* tests use. Each builder returns a `StandardSchemaV1`, which is what
+* `tool({ input })` validates against before calling `execute`.
+*
+* These intentionally cover only the primitive cases the FILE tools
+* require (`string`, `optional string`, `optional number`, `optional
+* boolean`, and an `object` of fields). They are not a general-purpose
+* validator.
+*/
+/** The vendor tag stamped on every issue these builders produce. */
+const VENDOR = "ai-workspace";
+/** Attach a JSON Schema description to a hand-rolled Standard Schema. */
+function withJsonSchema(schema, jsonSchema) {
+	return Object.assign(schema, { jsonSchema });
+}
+/** Required string field — rejects anything that is not a string. */
+function stringField() {
+	return (value, key) => {
+		if (typeof value === "string") return { value };
+		return { issues: [{
+			message: `"${key}" must be a string`,
+			path: [key]
+		}] };
+	};
+}
+/**
+* Optional string field — accepts `undefined` (the property absent or
+* explicitly undefined) or a string, and rejects every other type.
+*/
+function optionalStringField() {
+	return (value, key) => {
+		if (value === void 0) return { value: void 0 };
+		if (typeof value === "string") return { value };
+		return { issues: [{
+			message: `"${key}" must be a string when provided`,
+			path: [key]
+		}] };
+	};
+}
+/**
+* Optional finite-number field — accepts `undefined` or a finite number,
+* rejecting `NaN`/`Infinity` and non-number types.
+*/
+function optionalNumberField() {
+	return (value, key) => {
+		if (value === void 0) return { value: void 0 };
+		if (typeof value === "number" && Number.isFinite(value)) return { value };
+		return { issues: [{
+			message: `"${key}" must be a finite number when provided`,
+			path: [key]
+		}] };
+	};
+}
+/** Optional boolean field — accepts `undefined` or a boolean. */
+function optionalBooleanField() {
+	return (value, key) => {
+		if (value === void 0) return { value: void 0 };
+		if (typeof value === "boolean") return { value };
+		return { issues: [{
+			message: `"${key}" must be a boolean when provided`,
+			path: [key]
+		}] };
+	};
+}
+/**
+* Optional array-of-strings field — accepts `undefined` or an array whose
+* every element is a string (at most `maxItems` of them).
+*/
+function optionalStringArrayField(maxItems = 50) {
+	return (value, key) => {
+		if (value === void 0) return { value: void 0 };
+		if (Array.isArray(value) && value.length <= maxItems && value.every((item) => typeof item === "string")) return { value };
+		return { issues: [{
+			message: `"${key}" must be an array of at most ${maxItems} strings when provided`,
+			path: [key]
+		}] };
+	};
+}
+function objectSchema(shape, jsonSchema) {
+	const schema = buildObjectSchema(shape);
+	return jsonSchema === void 0 ? schema : withJsonSchema(schema, jsonSchema);
+}
+/** The validator behind {@link objectSchema}. */
+function buildObjectSchema(shape) {
+	return { "~standard": {
+		version: 1,
+		vendor: VENDOR,
+		validate(input) {
+			if (typeof input !== "object" || input === null || Array.isArray(input)) return { issues: [{ message: "input must be an object" }] };
+			const source = input;
+			const issues = [];
+			const result = {};
+			for (const key of Object.keys(shape)) {
+				const field = shape[key];
+				const outcome = field(source[key], key);
+				if ("issues" in outcome) {
+					issues.push(...outcome.issues);
+					continue;
+				}
+				if (outcome.value !== void 0) result[key] = outcome.value;
+			}
+			if (issues.length > 0) return { issues };
+			return { value: result };
+		}
+	} };
+}
+
+//#endregion
+//#region ../../packages/ai-workspace/src/tools/apply-patch.ts
+/** Default tool name exposed to the LLM. */
+const DEFAULT_NAME$7 = "apply_patch";
+/** Input schema for the `apply_patch` tool. */
+const inputSchema$7 = withJsonSchema({ "~standard": {
+	version: 1,
+	vendor: "ai-workspace",
+	validate(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return { issues: [{ message: "input must be an object" }] };
+		const candidate = value;
+		const issues = [];
+		if (typeof candidate.patch !== "string" || candidate.patch.trim() === "") issues.push({
+			message: "\"patch\" must be a non-empty string",
+			path: ["patch"]
+		});
+		if (candidate.dryRun !== void 0 && typeof candidate.dryRun !== "boolean") issues.push({
+			message: "\"dryRun\" must be a boolean when provided",
+			path: ["dryRun"]
+		});
+		if (issues.length > 0 || typeof candidate.patch !== "string") return { issues };
+		return { value: {
+			patch: candidate.patch,
+			...candidate.dryRun === true ? { dryRun: true } : {}
+		} };
+	}
+} }, APPLY_PATCH_JSON_SCHEMA);
+/**
+* Build the agent-facing `apply_patch` tool over a workspace's policy-enforced
+* {@link WorkspaceOps}: apply a unified diff that modifies, creates, deletes
+* and renames files. It is **atomic** — every hunk of every file applies, or
+* nothing on disk changes — every path stays inside the workspace jail, and a
+* patch that touches a binary file is refused with a clear error. A failure
+* surfaces as a `WorkspaceEditError` in the result's `error` field.
+*
+* @param ops - The shared, policy-enforced operation layer.
+* @param options - Optional overrides; `name` renames the LLM-visible tool.
+*
+* @example
+* const patch = makeApplyPatchTool(ops);
+* const { data, error } = await patch.invoke({
+*   patch: "--- a/src/a.ts\n+++ b/src/a.ts\n@@ -1 +1 @@\n-old\n+new\n",
+* });
+*/
+function makeApplyPatchTool(ops, options) {
+	return (0, _warlock_js_ai.tool)({
+		name: options?.name ?? DEFAULT_NAME$7,
+		description: "Apply a unified diff to the workspace: modify, create (--- /dev/null), delete (+++ /dev/null) and rename (git rename from/to) files in one call. All of it applies or none of it does. Hunks are located by their context, so small line drift is fine; binary files are refused. Use dryRun to check first.",
+		action: (input) => input.dryRun === true ? "Checking a patch" : "Applying a patch",
+		input: inputSchema$7,
+		execute: (input) => ops.applyPatch ? ops.applyPatch(input) : applyPatchWithOps(ops, input)
+	});
+}
+
 //#endregion
 //#region ../../packages/ai-workspace/src/tools/edit-file.ts
 /** Default tool name exposed to the LLM. */
@@ -4470,6 +5036,7 @@ const ALL_TOOL_NAMES = [
 	"readFile",
 	"editFile",
 	"multiEdit",
+	"applyPatch",
 	"writeFile",
 	"listDir",
 	"runShell",
@@ -4549,6 +5116,7 @@ var WorkspaceImpl = class WorkspaceImpl {
 			readFile: (opts) => erase(makeReadFileTool(this.ops, opts)),
 			editFile: (opts) => erase(makeEditFileTool(this.ops, opts)),
 			multiEdit: (opts) => erase(makeMultiEditTool(this.ops, opts)),
+			applyPatch: (opts) => erase(makeApplyPatchTool(this.ops, opts)),
 			writeFile: (opts) => erase(makeWriteFileTool(this.ops, opts)),
 			listDir: (opts) => erase(makeListDirTool(this.ops, opts)),
 			runShell: (opts) => erase(makeRunShellTool(this.ops, {
@@ -4575,6 +5143,7 @@ var WorkspaceImpl = class WorkspaceImpl {
 			readFile: (opts) => build("readFile", opts),
 			editFile: (opts) => build("editFile", opts),
 			multiEdit: (opts) => build("multiEdit", opts),
+			applyPatch: (opts) => build("applyPatch", opts),
 			writeFile: (opts) => build("writeFile", opts),
 			listDir: (opts) => build("listDir", opts),
 			runShell: (opts) => build("runShell", opts),
@@ -4614,6 +5183,10 @@ var WorkspaceImpl = class WorkspaceImpl {
 		this.assertWritable("multiEdit");
 		return this.ops.multiEdit(input);
 	}
+	async applyPatch(input) {
+		this.assertWritable("applyPatch");
+		return this.ops.applyPatch ? this.ops.applyPatch(input) : applyPatchWithOps(this.ops, input);
+	}
 	listDir(dirPath, opts) {
 		return this.ops.listDir(dirPath, opts);
 	}
@@ -4734,12 +5307,15 @@ exports.WorkspaceEditError = WorkspaceEditError;
 exports.WorkspaceJobError = WorkspaceJobError;
 exports.WorkspacePolicyError = WorkspacePolicyError;
 exports.analyzeArgvCommand = analyzeArgvCommand;
+exports.applyHunks = applyHunks;
+exports.applyPatchWithOps = applyPatchWithOps;
 exports.buildEnv = buildEnv;
 exports.checkShellCommand = checkShellCommand;
 exports.createLocalBackend = createLocalBackend;
 exports.createMockBackend = createMockBackend;
 exports.createOps = createOps;
 exports.isCommandAllowed = isCommandAllowed;
+exports.makeApplyPatchTool = makeApplyPatchTool;
 exports.makeEditFileTool = makeEditFileTool;
 exports.makeGlobTool = makeGlobTool;
 exports.makeGrepTool = makeGrepTool;
@@ -4753,6 +5329,7 @@ exports.makeShellOutputTool = makeShellOutputTool;
 exports.makeTodoReadTool = makeTodoReadTool;
 exports.makeTodoWriteTool = makeTodoWriteTool;
 exports.makeWriteFileTool = makeWriteFileTool;
+exports.parsePatch = parsePatch;
 exports.resolveInJail = resolveInJail;
 exports.tokenizeCommand = tokenizeCommand;
 exports.workspace = workspace;