codna 0.1.0__py3-none-any.whl

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/executors/apply-patch.ts

@@ -0,0 +1,348 @@
+/**
+ * Apply Patch Executor
+ *
+ * Built-in implementation for the documented GPT-5 apply_patch grammar.
+ * It accepts the freeform patch body directly and tolerates the legacy shell
+ * wrapper form used by older prompts.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { AgentToolContext } from "@cline/shared";
+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;
+}
+
+interface NormalizedPatchInput {
+	lines: 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 normalizeLineEndings(input: string): string[] {
+	return input.split("\n").map((line) => line.replace(/\r$/, ""));
+}
+
+function isWrapperLine(line: string): boolean {
+	if (line.trim() === "") {
+		return false;
+	}
+	return BASH_WRAPPERS.some((wrapper) => line.startsWith(wrapper));
+}
+
+function trimWrapperLines(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
+
+	while (start < end && isWrapperLine(lines[start] ?? "")) {
+		start++;
+	}
+
+	while (end > start && isWrapperLine(lines[end - 1] ?? "")) {
+		end--;
+	}
+
+	return lines.slice(start, end);
+}
+
+function normalizePatchInput(input: string): NormalizedPatchInput {
+	const rawLines = normalizeLineEndings(input);
+	const beginIndex = rawLines.findIndex((line) =>
+		line.startsWith(PATCH_MARKERS.BEGIN),
+	);
+	let endIndex = -1;
+	for (let i = rawLines.length - 1; i >= 0; i--) {
+		if (rawLines[i]?.startsWith(PATCH_MARKERS.END)) {
+			endIndex = i;
+			break;
+		}
+	}
+
+	if (beginIndex !== -1 || endIndex !== -1) {
+		if (beginIndex === -1 || endIndex === -1 || endIndex < beginIndex) {
+			throw new DiffError(
+				"Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.",
+			);
+		}
+		const lines = rawLines.slice(beginIndex, endIndex + 1);
+		return {
+			lines,
+		};
+	}
+
+	const stripped = trimWrapperLines(rawLines);
+	while (stripped.length > 0 && stripped[0] === "") {
+		stripped.shift();
+	}
+	while (stripped.length > 0 && stripped[stripped.length - 1] === "") {
+		stripped.pop();
+	}
+
+	const lines = [PATCH_MARKERS.BEGIN, ...stripped, PATCH_MARKERS.END];
+	return {
+		lines,
+	};
+}
+
+function extractFilesForOperations(
+	lines: readonly string[],
+	markers: readonly string[],
+): string[] {
+	const files = new Set<string>();
+
+	for (const line of lines) {
+		for (const marker of markers) {
+			if (line.startsWith(marker)) {
+				files.add(line.substring(marker.length).trim());
+				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(
+	lines: readonly string[],
+	cwd: string,
+	encoding: BufferEncoding,
+	restrictToCwd: boolean,
+): Promise<Record<string, string>> {
+	const filesToLoad = extractFilesForOperations(lines, [
+		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: AgentToolContext,
+	): Promise<string> => {
+		const normalizedInput = normalizePatchInput(input.input);
+		const currentFiles = await loadFiles(
+			normalizedInput.lines,
+			cwd,
+			encoding,
+			restrictToCwd,
+		);
+		const parser = new PatchParser(normalizedInput.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");
+	};
+}

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/executors/bash.test.ts

@@ -0,0 +1,108 @@
+import type { AgentToolContext } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { createBashExecutor } from "./bash";
+
+const ctx: AgentToolContext = {
+	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 output = await bash(
+			{
+				command: process.execPath,
+				args: [
+					"-e",
+					"process.stdout.write('ok'); process.stderr.write('warn')",
+				],
+			},
+			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 output = await bash(
+			{
+				command: process.execPath,
+				args: [
+					"-e",
+					"process.stdout.write('ok'); process.stderr.write('warn')",
+				],
+			},
+			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(
+			{
+				command: process.execPath,
+				args: ["-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: AgentToolContext = { ...ctx, signal: 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");
+	});
+});

codna/agent-core/vendor/cline/sdk/packages/core/src/extensions/tools/executors/bash.ts

@@ -0,0 +1,211 @@
+/**
+ * Bash Executor
+ *
+ * Built-in implementation for running shell commands using Node.js spawn.
+ */
+
+import { spawn } from "node:child_process";
+import {
+	type AgentToolContext,
+	getDefaultShell,
+	getShellArgs,
+} from "@cline/shared";
+import { TimeoutError } from "../helpers";
+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: AgentToolContext,
+	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", shell: true, 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 TimeoutError(`Command timed out after ${timeoutMs}ms`, timeoutMs),
+				),
+			timeoutMs,
+		);
+
+		const abortHandler = () => killAndReject(new Error("Command was aborted"));
+
+		if (context.signal) {
+			context.signal.addEventListener("abort", abortHandler);
+		}
+
+		const cleanup = () => {
+			clearTimeout(timeout);
+			context.signal?.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,
+		);
+	};
+}