@clinebot/core 0.0.18 → 0.0.21

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

@@ -1,359 +0,0 @@
-/**
- * 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.js";
-import type { ApplyPatchExecutor } from "../types.js";
-import {
-	BASH_WRAPPERS,
-	DiffError,
-	PATCH_MARKERS,
-	PatchActionType,
-	type PatchChunk,
-	PatchParser,
-} from "./apply-patch-parser.js";
-
-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.ts

@@ -1,205 +0,0 @@
-/**
- * Bash Executor
- *
- * Built-in implementation for running shell commands using Node.js spawn.
- */
-
-import { spawn } from "node:child_process";
-import type { ToolContext } from "@clinebot/agents";
-import type { BashExecutor } from "../types.js";
-
-/**
- * Options for the bash executor
- */
-export interface BashExecutorOptions {
-	/**
-	 * Shell to use for execution
-	 * @default "/bin/bash" on Unix, "cmd.exe" 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;
-}
-
-/**
- * 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 = process.platform === "win32" ? "cmd.exe" : "/bin/bash",
-		timeoutMs = 30000,
-		maxOutputBytes = 1_000_000,
-		env = {},
-		combineOutput = true,
-	} = options;
-
-	return async (
-		command: string,
-		cwd: string,
-		context: ToolContext,
-	): Promise<string> => {
-		return new Promise((resolve, reject) => {
-			const shellArgs =
-				process.platform === "win32" ? ["/c", command] : ["-c", command];
-			const isWindows = process.platform === "win32";
-
-			const child = spawn(shell, shellArgs, {
-				cwd,
-				env: { ...process.env, ...env },
-				stdio: ["pipe", "pipe", "pipe"],
-				// On Unix, place command in its own process group so abort can kill descendants too.
-				detached: !isWindows,
-			});
-			const childPid = child.pid;
-
-			let stdout = "";
-			let stderr = "";
-			let outputSize = 0;
-			let killed = false;
-			let settled = false;
-
-			const finalizeReject = (error: Error) => {
-				if (settled) {
-					return;
-				}
-				settled = true;
-				reject(error);
-			};
-
-			const finalizeResolve = (output: string) => {
-				if (settled) {
-					return;
-				}
-				settled = true;
-				resolve(output);
-			};
-
-			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");
-				}
-			};
-
-			// Handle timeout
-			const timeout = setTimeout(() => {
-				killed = true;
-				killProcessTree();
-				finalizeReject(new Error(`Command timed out after ${timeoutMs}ms`));
-			}, timeoutMs);
-
-			// Handle abort signal
-			const abortHandler = () => {
-				killed = true;
-				killProcessTree();
-				finalizeReject(new Error("Command was aborted"));
-			};
-
-			if (context.abortSignal) {
-				context.abortSignal.addEventListener("abort", abortHandler);
-			}
-
-			// Collect stdout
-			child.stdout?.on("data", (data: Buffer) => {
-				outputSize += data.length;
-				if (outputSize <= maxOutputBytes) {
-					stdout += data.toString();
-				}
-			});
-
-			// Collect stderr
-			child.stderr?.on("data", (data: Buffer) => {
-				outputSize += data.length;
-				if (outputSize <= maxOutputBytes) {
-					stderr += data.toString();
-				}
-			});
-
-			// Handle completion
-			child.on("close", (code) => {
-				clearTimeout(timeout);
-				if (context.abortSignal) {
-					context.abortSignal.removeEventListener("abort", abortHandler);
-				}
-
-				if (killed) return;
-
-				// Truncation warning
-				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) {
-					const errorMsg = stderr || `Command exited with code ${code}`;
-					finalizeReject(new Error(errorMsg));
-				} else {
-					finalizeResolve(output);
-				}
-			});
-
-			// Handle spawn errors
-			child.on("error", (error) => {
-				clearTimeout(timeout);
-				if (context.abortSignal) {
-					context.abortSignal.removeEventListener("abort", abortHandler);
-				}
-				finalizeReject(
-					new Error(`Failed to execute command: ${error.message}`),
-				);
-			});
-		});
-	};
-}

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

@@ -1,35 +0,0 @@
-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.js";
-
-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 });
-		}
-	});
-});