codexslimedit 0.7.4-dev.29698722339.1 → 0.7.4-dev.29702371652.1

package/README.md

@@ -12,11 +12,11 @@ bunx codexslimedit
 
 The MCP server exposes:
 
-- `read`: returns a root-relative path and file content without footer boilerplate.
-- `edit`: replaces one unique exact string or a 1-based inclusive line range such as `55-64`, then returns `OK <path>`.
+- `read_file`: returns a root-relative path and file content without footer boilerplate.
+- `apply_patch`: accepts Codex `*** Begin Patch` envelopes for `Add File`, `Update File`, and `Delete File`. It also retains a compact `filePath`/`oldString`/`newString` form for one unique exact replacement or inclusive line range such as `55-64`.
 
-Both tools constrain access to the server working directory. Reads reject non-UTF-8, NUL-containing, missing, non-file, traversal, and symlink-escape targets. Edits validate before writing, reject ambiguous matches and invalid ranges, preserve line endings and file mode, and use same-directory atomic replacement.
+Both tools constrain access to the server working directory. Reads reject non-UTF-8, NUL-containing, missing, non-file, traversal, and symlink-escape targets. Patches create, update, and delete regular UTF-8 files; exact edits reject ambiguous matches and invalid ranges, preserve line endings and file mode, and use same-directory atomic replacement.
 
 ## Codex adaptation
 
-This package adapts ideas from OpenSlimEdit for supported Codex extension surfaces. Codex plugins cannot replace descriptions of native tools or replace model-facing `PostToolUse` output, and Codex native patch editing has no OpenCode `oldString` contract. `codexslimedit` therefore provides separate concise MCP tools and makes no upstream token-saving claim.
+This package adapts ideas from OpenSlimEdit for supported Codex extension surfaces. Codex qualifies MCP tool names with their server namespace, so the model-facing names are `mcp__codexslimedit__read_file` and `mcp__codexslimedit__apply_patch`; MCP cannot overwrite Codex's built-in `apply_patch` registration. HolyCodex instructions require these tools for workspace reads and writes. Native patch envelopes preserve familiar patch ergonomics, while the compact exact-replacement form reduces simple-edit arguments and results. No upstream token-saving percentage is claimed without Codex-specific benchmarks.

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as CODEX_SLIM_EDIT_VERSION, n as runCodexSlimEditMcpStdioServer, o as isVersionRequest, s as stackOrMessageFromError } from "./mcp.js";
+import { d as stackOrMessageFromError, i as isVersionRequest, n as runCodexSlimEditMcpStdioServer, r as CODEX_SLIM_EDIT_VERSION } from "./mcp.js";
 import { stderr } from "node:process";
 //#region src/cli.ts
 /** Starts the CodexSlimEdit MCP stdio entrypoint. */

package/dist/index.d.ts

@@ -8,8 +8,10 @@ export declare function isVersionRequest(args: readonly string[]): boolean;
 
 /** Identifies a workspace file operation failure. */
 export type WorkspaceFileErrorCode =
+  | "ALREADY_EXISTS"
   | "EXACT_MATCH_NOT_FOUND"
   | "DUPLICATE_MATCH"
+  | "INVALID_PATCH"
   | "INVALID_RANGE"
   | "NOT_A_FILE"
   | "NOT_FOUND"
@@ -49,6 +51,26 @@ export interface WorkspaceFileResult {
   readonly content: string;
 }
 
+/** Input for writing complete UTF-8 content to a workspace file. */
+export interface WriteWorkspaceFileInput extends WorkspaceFileInput {
+  /** Complete replacement content. */
+  readonly content: string;
+}
+
+/** Input for a Codex-compatible workspace patch envelope. */
+export interface ApplyWorkspacePatchInput {
+  /** Workspace root used to constrain file access. */
+  readonly root: string;
+  /** Codex `*** Begin Patch` envelope. */
+  readonly patch: string;
+}
+
+/** Paths changed by a workspace patch. */
+export interface WorkspacePatchResult {
+  /** Canonical root-relative paths in patch order. */
+  readonly paths: readonly string[];
+}
+
 /** Options for the CodexSlimEdit MCP server. */
 export interface CodexSlimEditMcpOptions {
   /** Workspace root; defaults to the server process current directory. */
@@ -63,6 +85,26 @@ export declare function editWorkspaceFile(
   input: EditWorkspaceFileInput,
 ): Promise<WorkspaceFileResult>;
 
+/** Replaces an existing workspace file with complete UTF-8 content. */
+export declare function writeWorkspaceFile(
+  input: WriteWorkspaceFileInput,
+): Promise<WorkspaceFileResult>;
+
+/** Creates a new workspace file in an existing directory. */
+export declare function createWorkspaceFile(
+  input: WriteWorkspaceFileInput,
+): Promise<WorkspaceFileResult>;
+
+/** Deletes one existing regular workspace file. */
+export declare function deleteWorkspaceFile(
+  input: WorkspaceFileInput,
+): Promise<WorkspaceFileResult>;
+
+/** Applies Codex add, update, and delete patch operations inside a workspace. */
+export declare function applyWorkspacePatch(
+  input: ApplyWorkspacePatchInput,
+): Promise<WorkspacePatchResult>;
+
 /** Handles one CodexSlimEdit MCP JSON-RPC request. */
 export declare function handleCodexSlimEditMcpRequest(
   input: unknown,

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as CODEX_SLIM_EDIT_VERSION, c as WorkspaceFileError, i as readWorkspaceFile, n as runCodexSlimEditMcpStdioServer, o as isVersionRequest, r as editWorkspaceFile, t as handleCodexSlimEditMcpRequest } from "./mcp.js";
-export { CODEX_SLIM_EDIT_VERSION, WorkspaceFileError, editWorkspaceFile, handleCodexSlimEditMcpRequest, isVersionRequest, readWorkspaceFile, runCodexSlimEditMcpStdioServer };
+import { a as applyWorkspacePatch, c as editWorkspaceFile, f as WorkspaceFileError, i as isVersionRequest, l as readWorkspaceFile, n as runCodexSlimEditMcpStdioServer, o as createWorkspaceFile, r as CODEX_SLIM_EDIT_VERSION, s as deleteWorkspaceFile, t as handleCodexSlimEditMcpRequest, u as writeWorkspaceFile } from "./mcp.js";
+export { CODEX_SLIM_EDIT_VERSION, WorkspaceFileError, applyWorkspacePatch, createWorkspaceFile, deleteWorkspaceFile, editWorkspaceFile, handleCodexSlimEditMcpRequest, isVersionRequest, readWorkspaceFile, runCodexSlimEditMcpStdioServer, writeWorkspaceFile };

package/dist/mcp.js

@@ -1,5 +1,5 @@
 import "node:child_process";
-import { chmod, open, readFile, realpath, rename, rm, stat } from "node:fs/promises";
+import { chmod, lstat, mkdir, open, readFile, realpath, rename, rm, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 //#region src/errors.ts
 /** Reports a typed, actionable workspace file operation failure. */
@@ -4508,14 +4508,6 @@ function createIdleTimer(idleTimeoutMs, log, onIdleTimeout) {
 	};
 }
 //#endregion
-//#region src/version.ts
-/** Current independent codexslimedit package version. */
-var CODEX_SLIM_EDIT_VERSION = "0.7.4-dev.29698722339.1";
-/** Returns whether command-line arguments request the package version. */
-function isVersionRequest(args) {
-	return args.includes("--version");
-}
-//#endregion
 //#region src/workspace.ts
 var RANGE_PATTERN = /^\s*(?<start>[1-9]\d*)\s*(?:-\s*(?<end>[1-9]\d*)\s*)?$/;
 var TEMPORARY_FILE_PREFIX = ".codexslimedit-";
@@ -4531,12 +4523,69 @@ async function readWorkspaceFile(input) {
 async function editWorkspaceFile(input) {
 	const target = await resolveWorkspaceFile(input);
 	const nextContent = replaceContent(await readUtf8Text(target.absolutePath), input.oldString, input.newString);
+	validateText(nextContent);
 	await atomicWrite(target.absolutePath, nextContent);
 	return {
 		path: target.relativePath,
 		content: nextContent
 	};
 }
+/** Replaces an existing workspace file with complete UTF-8 content. */
+async function writeWorkspaceFile(input) {
+	const target = await resolveWorkspaceFile(input);
+	validateText(input.content);
+	await atomicWrite(target.absolutePath, input.content);
+	return {
+		path: target.relativePath,
+		content: input.content
+	};
+}
+/** Creates a new workspace file in an existing directory. */
+async function createWorkspaceFile(input) {
+	const target = await resolveNewWorkspaceFile(input);
+	validateText(input.content);
+	let file;
+	let created = false;
+	try {
+		file = await open(target.absolutePath, "wx", 420);
+		created = true;
+		await file.writeFile(input.content, "utf8");
+		await file.sync();
+		await file.close();
+		file = void 0;
+	} catch (error) {
+		await file?.close();
+		if (created) await rm(target.absolutePath, { force: true });
+		throw new WorkspaceFileError("WRITE_FAILED", `Could not create filePath: ${message(error)}`);
+	}
+	return {
+		path: target.relativePath,
+		content: input.content
+	};
+}
+/** Validates a new workspace file without modifying the workspace. */
+async function prepareWorkspaceFileCreation(input) {
+	const target = await resolveNewWorkspaceFile(input, false);
+	validateText(input.content);
+	return {
+		path: target.relativePath,
+		content: input.content
+	};
+}
+/** Deletes one existing regular workspace file. */
+async function deleteWorkspaceFile(input) {
+	const target = await resolveWorkspaceFile(input);
+	const content = await readUtf8Text(target.absolutePath);
+	try {
+		await rm(target.absolutePath);
+	} catch (error) {
+		throw new WorkspaceFileError("WRITE_FAILED", `Could not delete filePath: ${message(error)}`);
+	}
+	return {
+		path: target.relativePath,
+		content
+	};
+}
 async function resolveWorkspaceFile(input) {
 	const rootPath = await existingDirectory(input.root);
 	const candidate = resolve(rootPath, normalizeSeparators(input.filePath));
@@ -4548,6 +4597,38 @@ async function resolveWorkspaceFile(input) {
 		relativePath: relative(rootPath, resolvedCandidate).split(sep).join("/")
 	};
 }
+async function resolveNewWorkspaceFile(input, createParent = true) {
+	const rootPath = await existingDirectory(input.root);
+	const candidate = resolve(rootPath, normalizeSeparators(input.filePath));
+	if (!isInside(rootPath, candidate)) throw new WorkspaceFileError("PATH_OUTSIDE_ROOT", "filePath must remain inside the workspace root.");
+	try {
+		await lstat(candidate);
+		throw new WorkspaceFileError("ALREADY_EXISTS", "filePath already exists.");
+	} catch (error) {
+		if (error instanceof WorkspaceFileError) throw error;
+	}
+	const absolutePath = resolve(await safeParent(rootPath, dirname(candidate), createParent), basename(candidate));
+	return {
+		absolutePath,
+		relativePath: relative(rootPath, absolutePath).split(sep).join("/")
+	};
+}
+async function safeParent(rootPath, requestedParent, createParent) {
+	const missingDirectories = [];
+	let existingParent = requestedParent;
+	while (true) try {
+		existingParent = await realpath(existingParent);
+		break;
+	} catch {
+		if (existingParent === rootPath) throw new WorkspaceFileError("NOT_FOUND", "Workspace root does not exist.");
+		missingDirectories.push(basename(existingParent));
+		existingParent = dirname(existingParent);
+	}
+	if (existingParent !== rootPath && !isInside(rootPath, existingParent)) throw new WorkspaceFileError("PATH_OUTSIDE_ROOT", "filePath parent resolves outside the workspace root through a symlink.");
+	const parentPath = resolve(existingParent, ...missingDirectories.reverse());
+	if (createParent) await mkdir(parentPath, { recursive: true });
+	return parentPath;
+}
 async function existingDirectory(root) {
 	try {
 		const resolvedRoot = await realpath(resolve(root));
@@ -4584,12 +4665,15 @@ async function readUtf8Text(path) {
 	}
 	try {
 		const content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-		if (content.includes("\0")) throw new TypeError("NUL byte");
+		validateText(content);
 		return content;
 	} catch {
 		throw new WorkspaceFileError("UNSUPPORTED_TEXT", "filePath must contain UTF-8 text without NUL bytes.");
 	}
 }
+function validateText(content) {
+	if (content.includes("\0")) throw new WorkspaceFileError("UNSUPPORTED_TEXT", "Text must not contain NUL bytes.");
+}
 function replaceContent(content, oldString, newString) {
 	const range = parseRange(oldString, lineCount(content));
 	if (range !== null) return replaceLineRange(content, range.start, range.end, newString);
@@ -4687,14 +4771,210 @@ function message(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
+//#region src/patch.ts
+/** Applies Codex add, update, and delete patch operations inside a workspace. */
+async function applyWorkspacePatch(input) {
+	const operations = parsePatch(input.patch);
+	const planned = await planOperations(input.root, operations);
+	const paths = [];
+	for (const { operation, path, content } of planned) {
+		if (operation.kind === "add") {
+			await createWorkspaceFile({
+				root: input.root,
+				filePath: operation.filePath,
+				content: operation.content
+			});
+			paths.push(path);
+			continue;
+		}
+		if (operation.kind === "delete") {
+			await deleteWorkspaceFile({
+				root: input.root,
+				filePath: operation.filePath
+			});
+			paths.push(path);
+			continue;
+		}
+		await writeWorkspaceFile({
+			root: input.root,
+			filePath: operation.filePath,
+			content: content ?? ""
+		});
+		paths.push(path);
+	}
+	return { paths };
+}
+async function planOperations(root, operations) {
+	const planned = [];
+	const paths = /* @__PURE__ */ new Set();
+	for (const operation of operations) {
+		if (operation.kind === "add") {
+			const result = await prepareWorkspaceFileCreation({
+				root,
+				filePath: operation.filePath,
+				content: operation.content
+			});
+			assertUniquePath(paths, result.path);
+			planned.push({
+				operation,
+				path: result.path
+			});
+			continue;
+		}
+		const current = await readWorkspaceFile({
+			root,
+			filePath: operation.filePath
+		});
+		assertUniquePath(paths, current.path);
+		planned.push({
+			operation,
+			path: current.path,
+			content: operation.kind === "update" ? applyUpdateHunks(current.content, operation.hunks) : void 0
+		});
+	}
+	return planned;
+}
+function assertUniquePath(paths, path) {
+	if (paths.has(path)) invalidPatch(`Patch contains multiple operations for ${path}.`);
+	paths.add(path);
+}
+function parsePatch(patch) {
+	const lines = patch.replace(/\r\n|\r/g, "\n").split("\n");
+	while (lines.at(-1) === "") lines.pop();
+	if (lines[0] !== "*** Begin Patch" || lines.at(-1) !== "*** End Patch") invalidPatch("Patch must start with `*** Begin Patch` and end with `*** End Patch`.");
+	const operations = [];
+	let index = 1;
+	while (index < lines.length - 1) {
+		const header = lines[index];
+		const addPath = header?.match(/^\*\*\* Add File: (.+)$/)?.[1];
+		const updatePath = header?.match(/^\*\*\* Update File: (.+)$/)?.[1];
+		const deletePath = header?.match(/^\*\*\* Delete File: (.+)$/)?.[1];
+		index += 1;
+		if (addPath !== void 0) {
+			const contentLines = [];
+			while (index < lines.length - 1 && !isOperationHeader(lines[index])) {
+				const line = lines[index];
+				if (line === "*** End of File") {
+					index += 1;
+					break;
+				}
+				if (!line?.startsWith("+")) invalidPatch("Add File lines must start with `+`.");
+				contentLines.push(line.slice(1));
+				index += 1;
+			}
+			operations.push({
+				kind: "add",
+				filePath: filePath(addPath),
+				content: contentLines.length === 0 ? "" : `${contentLines.join("\n")}\n`
+			});
+			continue;
+		}
+		if (deletePath !== void 0) {
+			operations.push({
+				kind: "delete",
+				filePath: filePath(deletePath)
+			});
+			continue;
+		}
+		if (updatePath !== void 0) {
+			const hunks = [];
+			let oldLines;
+			let newLines;
+			while (index < lines.length - 1 && !isOperationHeader(lines[index])) {
+				const line = lines[index];
+				if (line === "*** End of File") {
+					index += 1;
+					break;
+				}
+				if (line?.startsWith("@@")) {
+					if (oldLines !== void 0 && newLines !== void 0) hunks.push(validHunk(oldLines, newLines));
+					oldLines = [];
+					newLines = [];
+					index += 1;
+					continue;
+				}
+				if (oldLines === void 0 || newLines === void 0 || line === void 0) invalidPatch("Update File content must begin with an `@@` hunk header.");
+				const prefix = line[0];
+				const content = line.slice(1);
+				if (prefix === " " || prefix === "-") oldLines.push(content);
+				if (prefix === " " || prefix === "+") newLines.push(content);
+				if (prefix !== " " && prefix !== "-" && prefix !== "+") invalidPatch("Update hunk lines must start with a space, `-`, or `+`.");
+				index += 1;
+			}
+			if (oldLines !== void 0 && newLines !== void 0) hunks.push(validHunk(oldLines, newLines));
+			if (hunks.length === 0) invalidPatch("Update File requires at least one hunk.");
+			operations.push({
+				kind: "update",
+				filePath: filePath(updatePath),
+				hunks
+			});
+			continue;
+		}
+		invalidPatch(`Unknown patch operation: ${header ?? "<missing>"}`);
+	}
+	if (operations.length === 0) invalidPatch("Patch must contain at least one file operation.");
+	return operations;
+}
+function isOperationHeader(line) {
+	return /^\*\*\* (?:Add|Update|Delete) File: /.test(line ?? "");
+}
+function validHunk(oldLines, newLines) {
+	if (oldLines.length === 0) invalidPatch("Update hunks require old or context lines for deterministic placement.");
+	return {
+		oldLines,
+		newLines
+	};
+}
+function applyUpdateHunks(content, hunks) {
+	const lineEnding = content.includes("\r\n") ? "\r\n" : "\n";
+	const normalized = content.replace(/\r\n|\r/g, "\n");
+	const hasFinalNewline = normalized.endsWith("\n");
+	const lines = normalized.split("\n");
+	if (hasFinalNewline) lines.pop();
+	let cursor = 0;
+	for (const hunk of hunks) {
+		const offset = uniqueSequenceOffset(lines, hunk.oldLines, cursor);
+		lines.splice(offset, hunk.oldLines.length, ...hunk.newLines);
+		cursor = offset + hunk.newLines.length;
+	}
+	if (lines.length === 0) return "";
+	return `${lines.join(lineEnding)}${hasFinalNewline ? lineEnding : ""}`;
+}
+function uniqueSequenceOffset(lines, expected, cursor) {
+	const offsets = [];
+	for (let offset = cursor; offset <= lines.length - expected.length; offset += 1) if (expected.every((line, index) => lines[offset + index] === line)) offsets.push(offset);
+	if (offsets.length === 1) return offsets[0] ?? 0;
+	if (offsets.length > 1) throw new WorkspaceFileError("DUPLICATE_MATCH", "Patch hunk matches more than once; include more unchanged context.");
+	throw new WorkspaceFileError("EXACT_MATCH_NOT_FOUND", "Patch hunk context was not found exactly.");
+}
+function filePath(value) {
+	const trimmed = value.trim();
+	if (trimmed === "") invalidPatch("Patch file paths must not be empty.");
+	return trimmed;
+}
+function invalidPatch(message) {
+	throw new WorkspaceFileError("INVALID_PATCH", message);
+}
+//#endregion
+//#region src/version.ts
+/** Current independent codexslimedit package version. */
+var CODEX_SLIM_EDIT_VERSION = "0.7.4-dev.29702371652.1";
+/** Returns whether command-line arguments request the package version. */
+function isVersionRequest(args) {
+	return args.includes("--version");
+}
+//#endregion
 //#region src/mcp.ts
 var InitializeParamsSchema = looseObject({ protocolVersion: string() });
 var ReadArgumentsSchema = strictObject({ filePath: string().min(1) });
-var EditArgumentsSchema = strictObject({
+var ExactEditArgumentsSchema = strictObject({
 	filePath: string().min(1),
 	oldString: string().min(1),
 	newString: string()
 });
+var ApplyPatchArgumentsSchema = union([strictObject({ patch: string().min(1) }), ExactEditArgumentsSchema]);
+var READ_FILE_TOOL_NAME = "read_file";
+var APPLY_PATCH_TOOL_NAME = "apply_patch";
 /** Handles one CodexSlimEdit MCP JSON-RPC request. */
 async function handleCodexSlimEditMcpRequest(input, options = {}) {
 	const request = JsonRpcRequestSchema.safeParse(input);
@@ -4731,53 +5011,89 @@ async function runCodexSlimEditMcpStdioServer(input, output, options = {}) {
 	});
 }
 var TOOL_DEFINITIONS = [{
-	name: "read",
-	description: "Read one UTF-8 workspace file concisely.",
+	name: READ_FILE_TOOL_NAME,
+	description: "Required tool for reading one complete UTF-8 workspace file. Returns the workspace-relative path and exact content without metadata or footer boilerplate.",
 	inputSchema: {
 		type: "object",
-		properties: { filePath: { type: "string" } },
+		properties: { filePath: {
+			type: "string",
+			description: "The workspace-relative path of the file to read."
+		} },
 		required: ["filePath"],
 		additionalProperties: false
+	},
+	annotations: {
+		readOnlyHint: true,
+		destructiveHint: false,
+		idempotentHint: true,
+		openWorldHint: false
 	}
 }, {
-	name: "edit",
-	description: "Atomically replace unique content or an inclusive line range.",
+	name: APPLY_PATCH_TOOL_NAME,
+	description: "Required workspace write tool. Use a native `*** Begin Patch` envelope to add, update, or delete files; for a smaller single replacement, pass filePath, oldString, and newString.",
 	inputSchema: {
 		type: "object",
 		properties: {
-			filePath: { type: "string" },
-			oldString: { type: "string" },
-			newString: { type: "string" }
+			patch: {
+				type: "string",
+				description: "Native Codex patch envelope with Add File, Update File, or Delete File operations."
+			},
+			filePath: {
+				type: "string",
+				description: "The workspace-relative path for a compact single-file replacement."
+			},
+			oldString: {
+				type: "string",
+				description: "The unique exact text, or inclusive 1-based line number or N-M range to replace."
+			},
+			newString: {
+				type: "string",
+				description: "Replacement text; may be empty."
+			}
 		},
-		required: [
+		oneOf: [{ required: ["patch"] }, { required: [
 			"filePath",
 			"oldString",
 			"newString"
-		],
+		] }],
 		additionalProperties: false
+	},
+	annotations: {
+		readOnlyHint: false,
+		destructiveHint: true,
+		idempotentHint: false,
+		openWorldHint: false
 	}
 }];
 async function callTool(id, name, arguments_, options) {
 	const root = options.root ?? process.cwd();
-	if (name === "read") {
+	if (name === READ_FILE_TOOL_NAME) {
 		const parsed = ReadArgumentsSchema.safeParse(arguments_);
-		if (!parsed.success) return toolResponse(id, "read.filePath must be a non-empty string.", true);
-		return fileOperationResponse(id, () => readWorkspaceFile({
+		if (!parsed.success) return toolResponse(id, `${READ_FILE_TOOL_NAME}.filePath must be a non-empty string.`, true);
+		return operationResponse(id, () => readWorkspaceFile({
 			root,
 			...parsed.data
 		}), (result) => `${result.path}\n${result.content}`);
 	}
-	if (name === "edit") {
-		const parsed = EditArgumentsSchema.safeParse(arguments_);
-		if (!parsed.success) return toolResponse(id, "edit requires non-empty filePath and oldString plus string newString.", true);
-		return fileOperationResponse(id, () => editWorkspaceFile({
+	if (name === APPLY_PATCH_TOOL_NAME) {
+		const parsed = ApplyPatchArgumentsSchema.safeParse(arguments_);
+		if (!parsed.success) return toolResponse(id, `${APPLY_PATCH_TOOL_NAME} requires a non-empty patch envelope or non-empty filePath and oldString plus string newString.`, true);
+		const parsedArguments = parsed.data;
+		if ("patch" in parsedArguments) {
+			const patch = parsedArguments.patch;
+			return operationResponse(id, () => applyWorkspacePatch({
+				root,
+				patch
+			}), () => "Done!");
+		}
+		return operationResponse(id, () => editWorkspaceFile({
 			root,
-			...parsed.data
+			...parsedArguments
 		}), (result) => `OK ${result.path}`);
 	}
 	return toolResponse(id, `Unknown codexslimedit tool: ${name}`, true);
 }
-async function fileOperationResponse(id, operation, successText) {
+async function operationResponse(id, operation, successText) {
 	try {
 		return toolResponse(id, successText(await operation()));
 	} catch (error) {
@@ -4794,4 +5110,4 @@ function toolResponse(id, text, isError = false) {
 	});
 }
 //#endregion
-export { CODEX_SLIM_EDIT_VERSION as a, WorkspaceFileError as c, readWorkspaceFile as i, runCodexSlimEditMcpStdioServer as n, isVersionRequest as o, editWorkspaceFile as r, stackOrMessageFromError as s, handleCodexSlimEditMcpRequest as t };
+export { applyWorkspacePatch as a, editWorkspaceFile as c, stackOrMessageFromError as d, WorkspaceFileError as f, isVersionRequest as i, readWorkspaceFile as l, runCodexSlimEditMcpStdioServer as n, createWorkspaceFile as o, CODEX_SLIM_EDIT_VERSION as r, deleteWorkspaceFile as s, handleCodexSlimEditMcpRequest as t, writeWorkspaceFile as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexslimedit",
-  "version": "0.7.4-dev.29698722339.1",
+  "version": "0.7.4-dev.29702371652.1",
   "description": "Concise, workspace-safe MCP file reading and editing.",
   "license": "SUL-1.0",
   "repository": {