@clinebot/core 0.0.22 → 0.0.24

package/src/tools/executors/apply-patch.ts

@@ -0,0 +1,359 @@
+/**
+ * Apply Patch Executor
+ *
+ * Built-in implementation for the legacy apply_patch format.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { ToolContext } from "@clinebot/agents";
+import type { ApplyPatchInput } from "../schemas";
+import type { ApplyPatchExecutor } from "../types";
+import {
+	BASH_WRAPPERS,
+	DiffError,
+	PATCH_MARKERS,
+	PatchActionType,
+	type PatchChunk,
+	PatchParser,
+} from "./apply-patch-parser";
+
+interface FileChange {
+	type: PatchActionType;
+	oldContent?: string;
+	newContent?: string;
+	movePath?: string;
+}
+
+/**
+ * Options for the apply_patch executor
+ */
+export interface ApplyPatchExecutorOptions {
+	/**
+	 * File encoding used for read/write operations
+	 * @default "utf-8"
+	 */
+	encoding?: BufferEncoding;
+
+	/**
+	 * Restrict relative-path file operations to paths inside cwd.
+	 * Absolute paths are always accepted as-is.
+	 * @default true
+	 */
+	restrictToCwd?: boolean;
+}
+
+function resolveFilePath(
+	cwd: string,
+	inputPath: string,
+	restrictToCwd: boolean,
+): string {
+	const isAbsoluteInput = path.isAbsolute(inputPath);
+	const resolved = isAbsoluteInput
+		? path.normalize(inputPath)
+		: path.resolve(cwd, inputPath);
+	if (!restrictToCwd || isAbsoluteInput) {
+		return resolved;
+	}
+
+	const rel = path.relative(cwd, resolved);
+	if (rel.startsWith("..") || path.isAbsolute(rel)) {
+		throw new DiffError(`Path must stay within cwd: ${inputPath}`);
+	}
+	return resolved;
+}
+
+function stripBashWrapper(lines: string[]): string[] {
+	const result: string[] = [];
+	let insidePatch = false;
+	let foundBegin = false;
+	let foundContent = false;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (
+			!insidePatch &&
+			BASH_WRAPPERS.some((wrapper) => line.startsWith(wrapper))
+		) {
+			continue;
+		}
+
+		if (line.startsWith(PATCH_MARKERS.BEGIN)) {
+			insidePatch = true;
+			foundBegin = true;
+			result.push(line);
+			continue;
+		}
+
+		if (line === PATCH_MARKERS.END) {
+			insidePatch = false;
+			result.push(line);
+			continue;
+		}
+
+		const isPatchContent =
+			line.startsWith(PATCH_MARKERS.ADD) ||
+			line.startsWith(PATCH_MARKERS.UPDATE) ||
+			line.startsWith(PATCH_MARKERS.DELETE) ||
+			line.startsWith(PATCH_MARKERS.MOVE) ||
+			line.startsWith(PATCH_MARKERS.SECTION) ||
+			line.startsWith("+") ||
+			line.startsWith("-") ||
+			line.startsWith(" ") ||
+			line === "***";
+
+		if (isPatchContent && i !== lines.length - 1) {
+			foundContent = true;
+		}
+
+		if (
+			insidePatch ||
+			(!foundBegin && isPatchContent) ||
+			(line === "" && foundContent)
+		) {
+			result.push(line);
+		}
+	}
+
+	while (result.length > 0 && result[result.length - 1] === "") {
+		result.pop();
+	}
+
+	return !foundBegin && !foundContent ? lines : result;
+}
+
+function preprocessLines(input: string): string[] {
+	let lines = input.split("\n").map((line) => line.replace(/\r$/, ""));
+	lines = stripBashWrapper(lines);
+
+	const hasBegin = lines.length > 0 && lines[0].startsWith(PATCH_MARKERS.BEGIN);
+	const hasEnd =
+		lines.length > 0 && lines[lines.length - 1] === PATCH_MARKERS.END;
+	if (!hasBegin && !hasEnd) {
+		return [PATCH_MARKERS.BEGIN, ...lines, PATCH_MARKERS.END];
+	}
+	if (hasBegin && hasEnd) {
+		return lines;
+	}
+	throw new DiffError(
+		"Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.",
+	);
+}
+
+function extractFilesForOperations(
+	text: string,
+	markers: readonly string[],
+): string[] {
+	const lines = stripBashWrapper(text.split("\n"));
+	const files: string[] = [];
+
+	for (const line of lines) {
+		for (const marker of markers) {
+			if (!line.startsWith(marker)) {
+				continue;
+			}
+			const file = line.substring(marker.length).trim();
+			if (!text.trim().endsWith(file)) {
+				files.push(file);
+			}
+			break;
+		}
+	}
+
+	return files;
+}
+
+function applyChunks(
+	content: string,
+	chunks: PatchChunk[],
+	filePath: string,
+): string {
+	if (chunks.length === 0) {
+		return content;
+	}
+
+	const lines = content.split("\n");
+	const result: string[] = [];
+	let currentIndex = 0;
+
+	for (const chunk of chunks) {
+		if (chunk.origIndex > lines.length) {
+			throw new DiffError(
+				`${filePath}: chunk.origIndex ${chunk.origIndex} > lines.length ${lines.length}`,
+			);
+		}
+		if (currentIndex > chunk.origIndex) {
+			throw new DiffError(
+				`${filePath}: currentIndex ${currentIndex} > chunk.origIndex ${chunk.origIndex}`,
+			);
+		}
+		result.push(...lines.slice(currentIndex, chunk.origIndex));
+		result.push(...chunk.insLines);
+		currentIndex = chunk.origIndex + chunk.delLines.length;
+	}
+
+	result.push(...lines.slice(currentIndex));
+	return result.join("\n");
+}
+
+async function loadFiles(
+	rawInput: string,
+	cwd: string,
+	encoding: BufferEncoding,
+	restrictToCwd: boolean,
+): Promise<Record<string, string>> {
+	const filesToLoad = extractFilesForOperations(rawInput, [
+		PATCH_MARKERS.UPDATE,
+		PATCH_MARKERS.DELETE,
+	]);
+	const files: Record<string, string> = {};
+
+	for (const filePath of filesToLoad) {
+		const absolutePath = resolveFilePath(cwd, filePath, restrictToCwd);
+		let fileContent: string;
+		try {
+			fileContent = await fs.readFile(absolutePath, encoding);
+		} catch {
+			throw new DiffError(`File not found: ${filePath}`);
+		}
+		files[filePath] = fileContent.replace(/\r\n/g, "\n");
+	}
+
+	return files;
+}
+
+function patchToChanges(
+	patch: ReturnType<PatchParser["parse"]>["patch"],
+	originalFiles: Record<string, string>,
+): Record<string, FileChange> {
+	const changes: Record<string, FileChange> = {};
+
+	for (const [filePath, action] of Object.entries(patch.actions)) {
+		switch (action.type) {
+			case PatchActionType.DELETE:
+				changes[filePath] = {
+					type: PatchActionType.DELETE,
+					oldContent: originalFiles[filePath],
+				};
+				break;
+			case PatchActionType.ADD:
+				if (action.newFile === undefined) {
+					throw new DiffError("ADD action without file content");
+				}
+				changes[filePath] = {
+					type: PatchActionType.ADD,
+					newContent: action.newFile,
+				};
+				break;
+			case PatchActionType.UPDATE:
+				changes[filePath] = {
+					type: PatchActionType.UPDATE,
+					oldContent: originalFiles[filePath],
+					newContent: applyChunks(
+						originalFiles[filePath] ?? "",
+						action.chunks,
+						filePath,
+					),
+					movePath: action.movePath,
+				};
+				break;
+		}
+	}
+
+	return changes;
+}
+
+async function applyChanges(
+	changes: Record<string, FileChange>,
+	cwd: string,
+	encoding: BufferEncoding,
+	restrictToCwd: boolean,
+): Promise<string[]> {
+	const touched: string[] = [];
+
+	for (const [filePath, change] of Object.entries(changes)) {
+		const sourceAbsPath = resolveFilePath(cwd, filePath, restrictToCwd);
+		switch (change.type) {
+			case PatchActionType.DELETE:
+				await fs.rm(sourceAbsPath, { force: true });
+				touched.push(`${filePath}: [deleted]`);
+				break;
+			case PatchActionType.ADD:
+				if (change.newContent === undefined) {
+					throw new DiffError(`Cannot create ${filePath} with no content`);
+				}
+				await fs.mkdir(path.dirname(sourceAbsPath), { recursive: true });
+				await fs.writeFile(sourceAbsPath, change.newContent, { encoding });
+				touched.push(filePath);
+				break;
+			case PatchActionType.UPDATE: {
+				if (change.newContent === undefined) {
+					throw new DiffError(
+						`UPDATE change for ${filePath} has no new content`,
+					);
+				}
+
+				if (change.movePath) {
+					const moveAbsPath = resolveFilePath(
+						cwd,
+						change.movePath,
+						restrictToCwd,
+					);
+					await fs.mkdir(path.dirname(moveAbsPath), { recursive: true });
+					await fs.writeFile(moveAbsPath, change.newContent, { encoding });
+					await fs.rm(sourceAbsPath, { force: true });
+					touched.push(`${filePath} -> ${change.movePath}`);
+				} else {
+					await fs.writeFile(sourceAbsPath, change.newContent, { encoding });
+					touched.push(filePath);
+				}
+				break;
+			}
+		}
+	}
+
+	return touched;
+}
+
+/**
+ * Create an apply_patch executor using Node.js fs module.
+ */
+export function createApplyPatchExecutor(
+	options: ApplyPatchExecutorOptions = {},
+): ApplyPatchExecutor {
+	const { encoding = "utf-8", restrictToCwd = true } = options;
+
+	return async (
+		input: ApplyPatchInput,
+		cwd: string,
+		_context: ToolContext,
+	): Promise<string> => {
+		const lines = preprocessLines(input.input);
+		const currentFiles = await loadFiles(
+			input.input,
+			cwd,
+			encoding,
+			restrictToCwd,
+		);
+		const parser = new PatchParser(lines, currentFiles);
+		const { patch, fuzz } = parser.parse();
+		const changes = patchToChanges(patch, currentFiles);
+		const touched = await applyChanges(changes, cwd, encoding, restrictToCwd);
+
+		const responseLines = [
+			"Successfully applied patch to the following files:",
+		];
+		for (const file of touched) {
+			responseLines.push(file);
+		}
+		if (fuzz > 0) {
+			responseLines.push(`Note: Patch applied with fuzz factor ${fuzz}`);
+		}
+		if (patch.warnings && patch.warnings.length > 0) {
+			for (const warning of patch.warnings) {
+				responseLines.push(`Warning (${warning.path}): ${warning.message}`);
+			}
+		}
+		return responseLines.join("\n");
+	};
+}

package/src/tools/executors/bash.test.ts

@@ -0,0 +1,87 @@
+import type { ToolContext } from "@clinebot/shared";
+import { describe, expect, it } from "vitest";
+import { createBashExecutor } from "./bash";
+
+const ctx: ToolContext = {
+	agentId: "agent-1",
+	conversationId: "conv-1",
+	iteration: 1,
+};
+
+describe("createBashExecutor", () => {
+	it("runs a simple command and returns stdout", async () => {
+		const bash = createBashExecutor();
+		const output = await bash("echo hello", process.cwd(), ctx);
+		expect(output.trim()).toBe("hello");
+	});
+
+	it("rejects on non-zero exit code", async () => {
+		const bash = createBashExecutor();
+		await expect(bash("exit 1", process.cwd(), ctx)).rejects.toThrow();
+	});
+
+	it("includes stderr in combined output on success", async () => {
+		const bash = createBashExecutor({ combineOutput: true });
+		const cmd = `${process.execPath} -e "process.stdout.write('ok'); process.stderr.write('warn')"`;
+		const output = await bash(cmd, process.cwd(), ctx);
+		expect(output).toContain("ok");
+		expect(output).toContain("[stderr]");
+		expect(output).toContain("warn");
+	});
+
+	it("excludes stderr when combineOutput is false", async () => {
+		const bash = createBashExecutor({ combineOutput: false });
+		const cmd = `${process.execPath} -e "process.stdout.write('ok'); process.stderr.write('warn')"`;
+		const output = await bash(cmd, process.cwd(), ctx);
+		expect(output.trim()).toBe("ok");
+	});
+
+	it("rejects on timeout", async () => {
+		const bash = createBashExecutor({ timeoutMs: 50 });
+		await expect(bash("sleep 10", process.cwd(), ctx)).rejects.toThrow(
+			"timed out",
+		);
+	});
+
+	it("truncates output exceeding maxOutputBytes", async () => {
+		const bash = createBashExecutor({ maxOutputBytes: 10 });
+		const output = await bash(
+			`${process.execPath} -e "process.stdout.write('a'.repeat(100))"`,
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toContain("[Output truncated:");
+	});
+
+	it("rejects when abort signal fires", async () => {
+		const ac = new AbortController();
+		const abortCtx: ToolContext = { ...ctx, abortSignal: ac.signal };
+		const bash = createBashExecutor();
+
+		setTimeout(() => ac.abort(), 50);
+		await expect(bash("sleep 10", process.cwd(), abortCtx)).rejects.toThrow(
+			"aborted",
+		);
+	});
+});
+
+describe.runIf(process.platform === "win32")("createWindowsExecutor", () => {
+	it("runs structured commands without shell parsing", async () => {
+		const executor = createBashExecutor();
+		const output = await executor(
+			{
+				command: process.execPath,
+				args: ["-e", "process.stdout.write(process.argv[1])", "argv-ok"],
+			},
+			process.cwd(),
+			ctx,
+		);
+		expect(output).toBe("argv-ok");
+	});
+
+	it("runs string commands through the shell", async () => {
+		const executor = createBashExecutor();
+		const output = await executor("echo shell-ok", process.cwd(), ctx);
+		expect(output.trim()).toBe("shell-ok");
+	});
+});

package/src/tools/executors/bash.ts

@@ -0,0 +1,207 @@
+/**
+ * Bash Executor
+ *
+ * Built-in implementation for running shell commands using Node.js spawn.
+ */
+
+import { spawn } from "node:child_process";
+import {
+	getDefaultShell,
+	getShellArgs,
+	type ToolContext,
+} from "@clinebot/shared";
+import type { BashExecutor } from "../types";
+
+/**
+ * Options for the bash executor
+ */
+export interface BashExecutorOptions {
+	/**
+	 * Shell to use for execution
+	 * @default "/bin/bash" on Unix, "powershell" on Windows
+	 */
+	shell?: string;
+
+	/**
+	 * Timeout for command execution in milliseconds
+	 * @default 30000 (30 seconds)
+	 */
+	timeoutMs?: number;
+
+	/**
+	 * Maximum output size in bytes
+	 * @default 1_000_000 (1MB)
+	 */
+	maxOutputBytes?: number;
+
+	/**
+	 * Environment variables to add/override
+	 */
+	env?: Record<string, string>;
+
+	/**
+	 * Whether to combine stdout and stderr
+	 * @default true
+	 */
+	combineOutput?: boolean;
+}
+
+interface SpawnConfig {
+	executable: string;
+	args: string[];
+	cwd: string;
+	env: Record<string, string>;
+}
+
+function spawnAndCollect(
+	config: SpawnConfig,
+	context: ToolContext,
+	timeoutMs: number,
+	maxOutputBytes: number,
+	combineOutput: boolean,
+): Promise<string> {
+	return new Promise((resolve, reject) => {
+		const isWindows = process.platform === "win32";
+
+		const child = spawn(config.executable, config.args, {
+			cwd: config.cwd,
+			env: { ...process.env, ...config.env },
+			stdio: ["pipe", "pipe", "pipe"],
+			detached: !isWindows,
+		});
+		const childPid = child.pid;
+
+		let stdout = "";
+		let stderr = "";
+		let outputSize = 0;
+		let killed = false;
+		let settled = false;
+
+		const settle = (fn: () => void) => {
+			if (settled) return;
+			settled = true;
+			fn();
+		};
+
+		const killProcessTree = () => {
+			if (!childPid) return;
+			if (isWindows) {
+				const killer = spawn(
+					"taskkill",
+					["/pid", String(childPid), "/T", "/F"],
+					{ stdio: "ignore", windowsHide: true },
+				);
+				killer.unref();
+				return;
+			}
+			try {
+				process.kill(-childPid, "SIGKILL");
+			} catch {
+				child.kill("SIGKILL");
+			}
+		};
+
+		const killAndReject = (error: Error) => {
+			killed = true;
+			killProcessTree();
+			settle(() => reject(error));
+		};
+
+		const timeout = setTimeout(
+			() => killAndReject(new Error(`Command timed out after ${timeoutMs}ms`)),
+			timeoutMs,
+		);
+
+		const abortHandler = () => killAndReject(new Error("Command was aborted"));
+
+		if (context.abortSignal) {
+			context.abortSignal.addEventListener("abort", abortHandler);
+		}
+
+		const cleanup = () => {
+			clearTimeout(timeout);
+			context.abortSignal?.removeEventListener("abort", abortHandler);
+		};
+
+		child.stdout?.on("data", (data: Buffer) => {
+			outputSize += data.length;
+			if (outputSize <= maxOutputBytes) stdout += data.toString();
+		});
+
+		child.stderr?.on("data", (data: Buffer) => {
+			outputSize += data.length;
+			if (outputSize <= maxOutputBytes) stderr += data.toString();
+		});
+
+		child.on("close", (code) => {
+			cleanup();
+			if (killed) return;
+
+			let output = combineOutput
+				? stdout + (stderr ? `\n[stderr]\n${stderr}` : "")
+				: stdout;
+
+			if (outputSize > maxOutputBytes) {
+				output += `\n\n[Output truncated: ${outputSize} bytes total, showing first ${maxOutputBytes} bytes]`;
+			}
+
+			if (code !== 0) {
+				settle(() =>
+					reject(new Error(stderr || `Command exited with code ${code}`)),
+				);
+			} else {
+				settle(() => resolve(output));
+			}
+		});
+
+		child.on("error", (error) => {
+			cleanup();
+			settle(() =>
+				reject(new Error(`Failed to execute command: ${error.message}`)),
+			);
+		});
+	});
+}
+
+/**
+ * Create a bash executor using Node.js spawn
+ *
+ * @example
+ * ```typescript
+ * const bash = createBashExecutor({
+ *   timeoutMs: 60000, // 1 minute timeout
+ *   shell: "/bin/zsh",
+ * })
+ *
+ * const output = await bash("ls -la", "/path/to/project", context)
+ * ```
+ */
+export function createBashExecutor(
+	options: BashExecutorOptions = {},
+): BashExecutor {
+	const {
+		shell = getDefaultShell(process.platform),
+		timeoutMs = 30000,
+		maxOutputBytes = 1_000_000,
+		env = {},
+		combineOutput = true,
+	} = options;
+
+	return (command, cwd, context) => {
+		const isStructured = typeof command !== "string";
+		return spawnAndCollect(
+			{
+				executable: isStructured ? command.command : shell,
+				args: isStructured
+					? (command.args ?? [])
+					: getShellArgs(shell, command),
+				cwd,
+				env,
+			},
+			context,
+			timeoutMs,
+			maxOutputBytes,
+			combineOutput,
+		);
+	};
+}

package/src/tools/executors/editor.test.ts

@@ -0,0 +1,35 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createEditorExecutor } from "./editor";
+
+describe("createEditorExecutor", () => {
+	it("creates a missing file when edit is used", async () => {
+		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-editor-"));
+		const filePath = path.join(dir, "example.txt");
+
+		try {
+			const editor = createEditorExecutor();
+			const result = await editor(
+				{
+					path: filePath,
+					new_text: "created with edit",
+				},
+				dir,
+				{
+					agentId: "agent-1",
+					conversationId: "conv-1",
+					iteration: 1,
+				},
+			);
+
+			expect(result).toBe(`File created successfully at: ${filePath}`);
+			await expect(fs.readFile(filePath, "utf-8")).resolves.toBe(
+				"created with edit",
+			);
+		} finally {
+			await fs.rm(dir, { recursive: true, force: true });
+		}
+	});
+});