@clinebot/core 0.0.37 → 0.0.38

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

@@ -1,220 +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/shared";
-import type { EditFileInput } from "../schemas";
-import type { EditorExecutor } from "../types";
-
-/**
- * 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 maxBoundaryLine = lines.length + 1;
-
-	if (insertLineOneBased < 1 || insertLineOneBased > maxBoundaryLine) {
-		throw new Error(
-			`Invalid insert_line: ${insertLineOneBased}. insert_line must be a positive one-based boundary line in the range 1-${maxBoundaryLine}. Use ${maxBoundaryLine} to append at EOF.`,
-		);
-	}
-
-	const insertLine = insertLineOneBased - 1;
-	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/extensions/tools/executors/file-read.ts

@@ -1,135 +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/shared";
-import type { ReadFileRequest } from "../schemas";
-import type { FileReadExecutor } from "../types";
-
-const IMAGE_MEDIA_TYPES = new Map<string, string>([
-	[".gif", "image/gif"],
-	[".png", "image/png"],
-	[".jpg", "image/jpeg"],
-	[".jpeg", "image/jpeg"],
-	[".webp", "image/webp"],
-]);
-
-/**
- * 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) => {
-		const { path: filePath, start_line, end_line } = request;
-		const resolvedPath = path.isAbsolute(filePath)
-			? path.normalize(filePath)
-			: path.resolve(process.cwd(), filePath);
-		const extension = path.extname(resolvedPath).toLowerCase();
-		const imageMediaType = IMAGE_MEDIA_TYPES.get(extension);
-
-		// 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.`,
-			);
-		}
-
-		if (imageMediaType) {
-			if (context.metadata?.modelSupportsImages !== true) {
-				throw new Error("Current model does not support image input");
-			}
-			const data = await fs.readFile(resolvedPath);
-			return [
-				{
-					type: "text",
-					text: "Successfully read image",
-				},
-				{
-					type: "image",
-					data: data.toString("base64"),
-					mediaType: imageMediaType,
-				},
-			];
-		}
-
-		// 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/extensions/tools/executors/index.ts

@@ -1,87 +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";
-import {
-	type ApplyPatchExecutorOptions,
-	createApplyPatchExecutor,
-} from "./apply-patch";
-import { type BashExecutorOptions, createBashExecutor } from "./bash";
-import { createEditorExecutor, type EditorExecutorOptions } from "./editor";
-import {
-	createFileReadExecutor,
-	type FileReadExecutorOptions,
-} from "./file-read";
-import { createSearchExecutor, type SearchExecutorOptions } from "./search";
-import {
-	createWebFetchExecutor,
-	type WebFetchExecutorOptions,
-} from "./web-fetch";
-
-// Re-export individual executors and their options types
-export {
-	type ApplyPatchExecutorOptions,
-	createApplyPatchExecutor,
-} from "./apply-patch";
-export {
-	type BashExecutorOptions,
-	createBashExecutor,
-} from "./bash";
-export { createEditorExecutor, type EditorExecutorOptions } from "./editor";
-export {
-	createFileReadExecutor,
-	type FileReadExecutorOptions,
-} from "./file-read";
-export { createSearchExecutor, type SearchExecutorOptions } from "./search";
-export {
-	createWebFetchExecutor,
-	type WebFetchExecutorOptions,
-} from "./web-fetch";
-
-/**
- * Options for creating default executors
- */
-export interface DefaultExecutorsOptions {
-	fileRead?: FileReadExecutorOptions;
-	search?: SearchExecutorOptions;
-	bash?: BashExecutorOptions;
-	webFetch?: WebFetchExecutorOptions;
-	applyPatch?: ApplyPatchExecutorOptions;
-	editor?: EditorExecutorOptions;
-}
-
-/**
- * Create all default executors with optional configuration
- *
- * @example
- * ```typescript
- * import { createDefaultTools, createDefaultExecutors } from "@clinebot/core"
- *
- * 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),
-	};
-}