@clinebot/core 0.0.20 → 0.0.22

package/src/tools/executors/editor.ts

@@ -1,219 +0,0 @@
-/**
- * Editor Executor
- *
- * Built-in implementation for filesystem editing operations.
- */
-
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import type { ToolContext } from "@clinebot/agents";
-import type { EditFileInput } from "../schemas.js";
-import type { EditorExecutor } from "../types.js";
-
-/**
- * Options for the editor executor
- */
-export interface EditorExecutorOptions {
-	/**
-	 * 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;
-
-	/**
-	 * Maximum number of diff lines in str_replace output
-	 * @default 200
-	 */
-	maxDiffLines?: number;
-}
-
-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) {
-		return resolved;
-	}
-
-	// Absolute paths are accepted directly; cwd restriction applies to relative inputs.
-	if (isAbsoluteInput) {
-		return resolved;
-	}
-
-	const rel = path.relative(cwd, resolved);
-	if (rel.startsWith("..") || path.isAbsolute(rel)) {
-		throw new Error(`Path must stay within cwd: ${inputPath}`);
-	}
-	return resolved;
-}
-
-function countOccurrences(content: string, needle: string): number {
-	if (needle.length === 0) return 0;
-	return content.split(needle).length - 1;
-}
-
-function createLineDiff(
-	oldContent: string,
-	newContent: string,
-	maxLines: number,
-): string {
-	const oldLines = oldContent.split("\n");
-	const newLines = newContent.split("\n");
-	const max = Math.max(oldLines.length, newLines.length);
-	const out: string[] = ["```diff"];
-	let emitted = 0;
-
-	for (let i = 0; i < max; i++) {
-		if (emitted >= maxLines) {
-			out.push("... diff truncated ...");
-			break;
-		}
-
-		const oldLine = oldLines[i];
-		const newLine = newLines[i];
-
-		if (oldLine === newLine) {
-			continue;
-		}
-
-		const lineNo = i + 1;
-		if (oldLine !== undefined) {
-			out.push(`-${lineNo}: ${oldLine}`);
-			emitted++;
-		}
-		if (newLine !== undefined && emitted < maxLines) {
-			out.push(`+${lineNo}: ${newLine}`);
-			emitted++;
-		}
-	}
-
-	out.push("```");
-	return out.join("\n");
-}
-
-async function createFile(
-	filePath: string,
-	fileText: string,
-	encoding: BufferEncoding,
-): Promise<string> {
-	await fs.mkdir(path.dirname(filePath), { recursive: true });
-	await fs.writeFile(filePath, fileText, { encoding });
-	return `File created successfully at: ${filePath}`;
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function replaceInFile(
-	filePath: string,
-	oldStr: string,
-	newStr: string | null | undefined,
-	encoding: BufferEncoding,
-	maxDiffLines: number,
-): Promise<string> {
-	const content = await fs.readFile(filePath, encoding);
-	const occurrences = countOccurrences(content, oldStr);
-
-	if (occurrences === 0) {
-		throw new Error(`No replacement performed: text not found in ${filePath}.`);
-	}
-
-	if (occurrences > 1) {
-		throw new Error(
-			`No replacement performed: multiple occurrences of text found in ${filePath}.`,
-		);
-	}
-
-	const updated = content.replace(oldStr, newStr ?? "");
-	await fs.writeFile(filePath, updated, { encoding });
-
-	const diff = createLineDiff(content, updated, maxDiffLines);
-	return `Edited ${filePath}\n${diff}`;
-}
-
-async function insertInFile(
-	filePath: string,
-	insertLineOneBased: number,
-	newStr: string,
-	encoding: BufferEncoding,
-): Promise<string> {
-	const content = await fs.readFile(filePath, encoding);
-	const lines = content.split("\n");
-	const insertLine = insertLineOneBased - 1; // Convert to zero-based index
-
-	if (insertLine < 0 || insertLine > lines.length) {
-		throw new Error(
-			`Invalid line number: ${insertLineOneBased}. Valid range: 1-${lines.length}`,
-		);
-	}
-
-	lines.splice(insertLine, 0, ...newStr.split("\n"));
-	await fs.writeFile(filePath, lines.join("\n"), { encoding });
-
-	return `Inserted content at line ${insertLineOneBased} in ${filePath}.`;
-}
-
-/**
- * Create an editor executor using Node.js fs module
- */
-export function createEditorExecutor(
-	options: EditorExecutorOptions = {},
-): EditorExecutor {
-	const {
-		encoding = "utf-8",
-		restrictToCwd = true,
-		maxDiffLines = 200,
-	} = options;
-
-	return async (
-		input: EditFileInput,
-		cwd: string,
-		_context: ToolContext,
-	): Promise<string> => {
-		const filePath = resolveFilePath(cwd, input.path, restrictToCwd);
-
-		if (input.insert_line != null) {
-			return insertInFile(
-				filePath,
-				input.insert_line, // One-based index
-				input.new_text,
-				encoding,
-			);
-		}
-
-		if (!(await fileExists(filePath))) {
-			return createFile(filePath, input.new_text, encoding);
-		}
-		if (input.old_text == null) {
-			throw new Error(
-				"Parameter `old_text` is required when editing an existing file without `insert_line`",
-			);
-		}
-
-		return replaceInFile(
-			filePath,
-			input.old_text,
-			input.new_text,
-			encoding,
-			maxDiffLines,
-		);
-	};
-}

package/src/tools/executors/file-read.test.ts

@@ -1,49 +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 { createFileReadExecutor } from "./file-read.js";
-
-describe("createFileReadExecutor", () => {
-	it("reads a file from an absolute path", async () => {
-		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
-		const filePath = path.join(dir, "example.txt");
-		await fs.writeFile(filePath, "hello absolute path", "utf-8");
-
-		try {
-			const readFile = createFileReadExecutor();
-			const result = await readFile(
-				{ path: filePath },
-				{
-					agentId: "agent-1",
-					conversationId: "conv-1",
-					iteration: 1,
-				},
-			);
-			expect(result).toBe("1 | hello absolute path");
-		} finally {
-			await fs.rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("returns only the requested inclusive line range", async () => {
-		const dir = await fs.mkdtemp(path.join(os.tmpdir(), "agents-file-read-"));
-		const filePath = path.join(dir, "example.txt");
-		await fs.writeFile(filePath, "alpha\nbeta\ngamma\ndelta", "utf-8");
-
-		try {
-			const readFile = createFileReadExecutor();
-			const result = await readFile(
-				{ path: filePath, start_line: 2, end_line: 3 },
-				{
-					agentId: "agent-1",
-					conversationId: "conv-1",
-					iteration: 1,
-				},
-			);
-			expect(result).toBe("2 | beta\n3 | gamma");
-		} finally {
-			await fs.rm(dir, { recursive: true, force: true });
-		}
-	});
-});

package/src/tools/executors/file-read.ts

@@ -1,110 +0,0 @@
-/**
- * File Read Executor
- *
- * Built-in implementation for reading files using Node.js fs module.
- */
-
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import type { ToolContext } from "@clinebot/agents";
-import type { ReadFileRequest } from "../schemas.js";
-import type { FileReadExecutor } from "../types.js";
-
-/**
- * Options for the file read executor
- */
-export interface FileReadExecutorOptions {
-	/**
-	 * Maximum file size to read in bytes
-	 * @default 10_000_000 (10MB)
-	 */
-	maxFileSizeBytes?: number;
-
-	/**
-	 * File encoding
-	 * @default "utf-8"
-	 */
-	encoding?: BufferEncoding;
-
-	/**
-	 * Whether to include line numbers in output
-	 * @default false
-	 */
-	includeLineNumbers?: boolean;
-}
-
-const DEFAULT_FILE_READ_OPTIONS: Required<FileReadExecutorOptions> = {
-	maxFileSizeBytes: 10_000_000, // 10MB default limit
-	encoding: "utf-8", // Default to UTF-8 encoding
-	includeLineNumbers: true, // Include line numbers by default
-};
-
-/**
- * Create a file read executor using Node.js fs module
- *
- * @example
- * ```typescript
- * const readFile = createFileReadExecutor({
- *   maxFileSizeBytes: 5_000_000, // 5MB limit
- *   includeLineNumbers: true,
- * })
- *
- * const content = await readFile({ path: "/path/to/file.ts" }, context)
- * ```
- */
-export function createFileReadExecutor(
-	options: FileReadExecutorOptions = {},
-): FileReadExecutor {
-	const { maxFileSizeBytes, encoding, includeLineNumbers } = {
-		...DEFAULT_FILE_READ_OPTIONS,
-		...options,
-	};
-
-	return async (
-		request: ReadFileRequest,
-		_context: ToolContext,
-	): Promise<string> => {
-		const { path: filePath, start_line, end_line } = request;
-		const resolvedPath = path.isAbsolute(filePath)
-			? path.normalize(filePath)
-			: path.resolve(process.cwd(), filePath);
-
-		// Check if file exists
-		const stat = await fs.stat(resolvedPath);
-
-		if (!stat.isFile()) {
-			throw new Error(`Path is not a file: ${resolvedPath}`);
-		}
-
-		// Check file size
-		if (stat.size > maxFileSizeBytes) {
-			throw new Error(
-				`File too large: ${stat.size} bytes (max: ${maxFileSizeBytes} bytes). ` +
-					`Consider reading specific sections or using a different approach.`,
-			);
-		}
-
-		// Read file content
-		const content = await fs.readFile(resolvedPath, encoding);
-		const allLines = content.split("\n");
-		const rangeStart = Math.max((start_line ?? 1) - 1, 0);
-		const rangeEndExclusive = Math.min(
-			end_line ?? allLines.length,
-			allLines.length,
-		);
-		const lines = allLines.slice(rangeStart, rangeEndExclusive);
-
-		// Optionally add line numbers - one-based indexing for better readability
-		if (includeLineNumbers) {
-			const maxLineNumWidth = String(allLines.length).length;
-			return lines
-				.map(
-					(line, i) =>
-						`${String(rangeStart + i + 1).padStart(maxLineNumWidth, " ")} | ${line}`,
-				)
-				.join("\n");
-		}
-
-		return lines.join("\n");
-	};
-}

package/src/tools/executors/index.ts

@@ -1,75 +0,0 @@
-/**
- * Built-in Executor Implementations
- *
- * This module provides ready-to-use implementations of the tool executors
- * using Node.js built-in modules. These can be used directly or as references
- * for custom implementations.
- */
-
-import type { ToolExecutors } from "../types.js";
-import { createApplyPatchExecutor } from "./apply-patch.js";
-import { createBashExecutor } from "./bash.js";
-import { createEditorExecutor } from "./editor.js";
-import { createFileReadExecutor } from "./file-read.js";
-import { createSearchExecutor } from "./search.js";
-import { createWebFetchExecutor } from "./web-fetch.js";
-
-// Re-export individual executors and their options types
-export {
-	type ApplyPatchExecutorOptions,
-	createApplyPatchExecutor,
-} from "./apply-patch.js";
-export { type BashExecutorOptions, createBashExecutor } from "./bash.js";
-export { createEditorExecutor, type EditorExecutorOptions } from "./editor.js";
-export {
-	createFileReadExecutor,
-	type FileReadExecutorOptions,
-} from "./file-read.js";
-export { createSearchExecutor, type SearchExecutorOptions } from "./search.js";
-export {
-	createWebFetchExecutor,
-	type WebFetchExecutorOptions,
-} from "./web-fetch.js";
-
-/**
- * Options for creating default executors
- */
-export interface DefaultExecutorsOptions {
-	fileRead?: import("./file-read.js").FileReadExecutorOptions;
-	search?: import("./search.js").SearchExecutorOptions;
-	bash?: import("./bash.js").BashExecutorOptions;
-	webFetch?: import("./web-fetch.js").WebFetchExecutorOptions;
-	applyPatch?: import("./apply-patch.js").ApplyPatchExecutorOptions;
-	editor?: import("./editor.js").EditorExecutorOptions;
-}
-
-/**
- * Create all default executors with optional configuration
- *
- * @example
- * ```typescript
- * import { createDefaultTools, createDefaultExecutors } from "@clinebot/core/node"
- *
- * const executors = createDefaultExecutors({
- *   bash: { timeoutMs: 60000 },
- *   search: { maxResults: 50 },
- * })
- *
- * const tools = createDefaultTools({
- *   executors,
- *   cwd: "/path/to/project",
- * })
- * ```
- */
-export function createDefaultExecutors(
-	options: DefaultExecutorsOptions = {},
-): ToolExecutors {
-	return {
-		readFile: createFileReadExecutor(options.fileRead),
-		search: createSearchExecutor(options.search),
-		bash: createBashExecutor(options.bash),
-		webFetch: createWebFetchExecutor(options.webFetch),
-		applyPatch: createApplyPatchExecutor(options.applyPatch),
-		editor: createEditorExecutor(options.editor),
-	};
-}