@clinebot/core 0.0.34 → 0.0.36

package/src/{tools → extensions/tools}/executors/apply-patch.ts

@@ -1,7 +1,9 @@
 /**
  * Apply Patch Executor
  *
- * Built-in implementation for the legacy apply_patch format.
+ * 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";
@@ -25,6 +27,10 @@ interface FileChange {
 	movePath?: string;
 }
 
+interface NormalizedPatchInput {
+	lines: string[];
+}
+
 /**
  * Options for the apply_patch executor
  */
@@ -63,104 +69,87 @@ function resolveFilePath(
 	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;
-		}
+function normalizeLineEndings(input: string): string[] {
+	return input.split("\n").map((line) => line.replace(/\r$/, ""));
+}
 
-		if (line === PATCH_MARKERS.END) {
-			insidePatch = false;
-			result.push(line);
-			continue;
-		}
+function isWrapperLine(line: string): boolean {
+	if (line.trim() === "") {
+		return false;
+	}
+	return BASH_WRAPPERS.some((wrapper) => line.startsWith(wrapper));
+}
 
-		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;
-		}
+function trimWrapperLines(lines: string[]): string[] {
+	let start = 0;
+	let end = lines.length;
 
-		if (
-			insidePatch ||
-			(!foundBegin && isPatchContent) ||
-			(line === "" && foundContent)
-		) {
-			result.push(line);
-		}
+	while (start < end && isWrapperLine(lines[start] ?? "")) {
+		start++;
 	}
 
-	while (result.length > 0 && result[result.length - 1] === "") {
-		result.pop();
+	while (end > start && isWrapperLine(lines[end - 1] ?? "")) {
+		end--;
 	}
 
-	return !foundBegin && !foundContent ? lines : result;
+	return lines.slice(start, end);
 }
 
-function preprocessLines(input: string): string[] {
-	let lines = input.split("\n").map((line) => line.replace(/\r$/, ""));
-	lines = stripBashWrapper(lines);
+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 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];
+	const stripped = trimWrapperLines(rawLines);
+	while (stripped.length > 0 && stripped[0] === "") {
+		stripped.shift();
 	}
-	if (hasBegin && hasEnd) {
-		return lines;
+	while (stripped.length > 0 && stripped[stripped.length - 1] === "") {
+		stripped.pop();
 	}
-	throw new DiffError(
-		"Invalid patch text - incomplete sentinels. Try breaking it into smaller patches.",
-	);
+
+	const lines = [PATCH_MARKERS.BEGIN, ...stripped, PATCH_MARKERS.END];
+	return {
+		lines,
+	};
 }
 
 function extractFilesForOperations(
-	text: string,
+	lines: readonly string[],
 	markers: readonly string[],
 ): string[] {
-	const lines = stripBashWrapper(text.split("\n"));
-	const files: string[] = [];
+	const files = new Set<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);
+			if (line.startsWith(marker)) {
+				files.add(line.substring(marker.length).trim());
+				break;
 			}
-			break;
 		}
 	}
 
-	return files;
+	return [...files];
 }
 
 function applyChunks(
@@ -197,12 +186,12 @@ function applyChunks(
 }
 
 async function loadFiles(
-	rawInput: string,
+	lines: readonly string[],
 	cwd: string,
 	encoding: BufferEncoding,
 	restrictToCwd: boolean,
 ): Promise<Record<string, string>> {
-	const filesToLoad = extractFilesForOperations(rawInput, [
+	const filesToLoad = extractFilesForOperations(lines, [
 		PATCH_MARKERS.UPDATE,
 		PATCH_MARKERS.DELETE,
 	]);
@@ -328,14 +317,14 @@ export function createApplyPatchExecutor(
 		cwd: string,
 		_context: ToolContext,
 	): Promise<string> => {
-		const lines = preprocessLines(input.input);
+		const normalizedInput = normalizePatchInput(input.input);
 		const currentFiles = await loadFiles(
-			input.input,
+			normalizedInput.lines,
 			cwd,
 			encoding,
 			restrictToCwd,
 		);
-		const parser = new PatchParser(lines, currentFiles);
+		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);

package/src/{tools → extensions/tools}/executors/file-read.ts

@@ -10,6 +10,14 @@ 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
  */
@@ -60,14 +68,13 @@ export function createFileReadExecutor(
 		...options,
 	};
 
-	return async (
-		request: ReadFileRequest,
-		_context: ToolContext,
-	): Promise<string> => {
+	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);
@@ -84,6 +91,24 @@ export function createFileReadExecutor(
 			);
 		}
 
+		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");

package/src/{tools → extensions/tools}/executors/search.ts

@@ -1,13 +1,14 @@
 /**
  * Search Executor
  *
- * Built-in implementation for searching the codebase using regex.
+ * Built-in implementation for searching the codebase using ripgrep (if available) or regex.
  */
 
+import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { ToolContext } from "@clinebot/shared";
-import { getFileIndex } from "../../input";
+import { getFileIndex } from "../../../services/workspace";
 import type { SearchExecutor } from "../types";
 
 /**
@@ -118,6 +119,152 @@ interface SearchMatch {
 	context: string[];
 }
 
+let rgAvailable: boolean | null = null;
+
+function checkRipgrepAvailable(): Promise<boolean> {
+	if (rgAvailable !== null) {
+		return Promise.resolve(rgAvailable);
+	}
+
+	return new Promise((resolve) => {
+		const child = spawn("rg", ["--version"], {
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		child.on("close", (code) => {
+			rgAvailable = code === 0;
+			resolve(rgAvailable);
+		});
+
+		child.on("error", () => {
+			rgAvailable = false;
+			resolve(false);
+		});
+
+		setTimeout(() => {
+			if (!child.killed) {
+				child.kill("SIGTERM");
+			}
+			if (rgAvailable === null) {
+				rgAvailable = false;
+				resolve(false);
+			}
+		}, 1000);
+	});
+}
+
+function searchWithRipgrep(
+	query: string,
+	cwd: string,
+	maxResults: number,
+	contextLines: number,
+	timeoutMs: number = 5000,
+	abortSignal?: AbortSignal,
+): Promise<SearchMatch[] | null> {
+	return new Promise((resolve) => {
+		const child = spawn(
+			"rg",
+			["--json", `--context=${contextLines}`, "--max-count=1", "-i", query],
+			{
+				cwd,
+				stdio: ["ignore", "pipe", "pipe"],
+			},
+		);
+
+		let stdout = "";
+		let resolved = false;
+
+		const cleanup = () => {
+			if (!child.killed) {
+				child.kill("SIGTERM");
+			}
+		};
+
+		const timeout = setTimeout(() => {
+			if (!resolved) {
+				resolved = true;
+				cleanup();
+				resolve(null);
+			}
+		}, timeoutMs);
+
+		const finalize = (result: SearchMatch[] | null) => {
+			if (!resolved) {
+				resolved = true;
+				clearTimeout(timeout);
+				cleanup();
+				resolve(result);
+			}
+		};
+
+		if (abortSignal?.aborted) {
+			cleanup();
+			resolve(null);
+			return;
+		}
+
+		abortSignal?.addEventListener("abort", () => {
+			finalize(null);
+		});
+
+		child.stdout.on("data", (chunk: Buffer | string) => {
+			stdout += chunk.toString();
+		});
+
+		child.stderr.on("data", () => {
+			// Ignore stderr
+		});
+
+		child.on("close", (code: number | null) => {
+			if (code === 0 || code === 1) {
+				try {
+					const matches: SearchMatch[] = [];
+					const lines = stdout.split("\n").filter((line) => line.trim());
+
+					for (const line of lines) {
+						if (matches.length >= maxResults) break;
+
+						const json = JSON.parse(line);
+						if (json.type === "match") {
+							const matchData = json.data;
+							const contextLines: string[] = [];
+
+							if (json.data.submatches && json.data.submatches.length > 0) {
+								const submatch = json.data.submatches[0];
+								matches.push({
+									file: matchData.path.text,
+									line: matchData.line_number,
+									column: (submatch?.start ?? 0) + 1,
+									match: submatch?.match?.text ?? "",
+									context: contextLines,
+								});
+							}
+						} else if (json.type === "context" && matches.length > 0) {
+							const lastMatch = matches[matches.length - 1];
+							const prefix =
+								json.data.line_number === lastMatch.line ? ">" : " ";
+							lastMatch.context.push(
+								`${prefix} ${json.data.line_number}: ${json.data.lines?.text ?? json.data.line?.text ?? ""}`,
+							);
+						}
+					}
+
+					finalize(matches.length > 0 ? matches : null);
+				} catch {
+					finalize(null);
+				}
+				return;
+			}
+
+			finalize(null);
+		});
+
+		child.on("error", () => {
+			finalize(null);
+		});
+	});
+}
+
 function shouldIncludeFile(
 	relativePath: string,
 	excludeDirs: Set<string>,
@@ -173,9 +320,49 @@ export function createSearchExecutor(
 	return async (
 		query: string,
 		cwd: string,
-		_context: ToolContext,
+		context: ToolContext,
 	): Promise<string> => {
-		// Compile regex
+		// Check for abort before starting
+		if (context.abortSignal?.aborted) {
+			throw new Error("Search operation aborted");
+		}
+
+		// Try ripgrep first if available
+		const isRgAvailable = await checkRipgrepAvailable();
+		let rgMatches: SearchMatch[] | null = null;
+		if (isRgAvailable) {
+			rgMatches = await searchWithRipgrep(
+				query,
+				cwd,
+				maxResults,
+				contextLines,
+				5000,
+				context.abortSignal,
+			);
+		}
+
+		if (rgMatches) {
+			const resultLines: string[] = [
+				`Found ${rgMatches.length} result${rgMatches.length === 1 ? "" : "s"} for pattern: ${query}`,
+				"",
+			];
+
+			for (const match of rgMatches) {
+				resultLines.push(`${match.file}:${match.line}:${match.column}`);
+				resultLines.push(...match.context);
+				resultLines.push("");
+			}
+
+			if (rgMatches.length >= maxResults) {
+				resultLines.push(
+					`(Showing first ${maxResults} results. Refine your search for more specific results.)`,
+				);
+			}
+
+			return resultLines.join("\n");
+		}
+
+		// Fallback to manual regex search
 		let regex: RegExp;
 		try {
 			regex = new RegExp(query, "gim");
@@ -192,6 +379,11 @@ export function createSearchExecutor(
 
 		// Search files from the fast index.
 		for (const relativePath of fileList) {
+			// Check for abort signal
+			if (context.abortSignal?.aborted) {
+				throw new Error("Search operation aborted");
+			}
+
 			if (
 				!shouldIncludeFile(
 					relativePath,

package/src/{tools → extensions/tools}/index.ts

@@ -53,6 +53,15 @@ export {
 	type ToolPresetName,
 	ToolPresets,
 } from "./presets";
+export {
+	type BuiltinToolAvailabilityContext,
+	getCoreAcpToolNames,
+	getCoreBuiltinToolCatalog,
+	getCoreDefaultEnabledToolIds,
+	getCoreHeadlessToolNames,
+	resolveCoreSelectedToolIds,
+	type ToolCatalogEntry,
+} from "./runtime";
 // Schemas
 export {
 	type ApplyPatchInput,
@@ -78,6 +87,7 @@ export {
 	type WebFetchRequest,
 	WebFetchRequestSchema,
 } from "./schemas";
+export { TEAM_TOOL_NAMES } from "./team/team-tools";
 // Types
 export type {
 	ApplyPatchExecutor,

package/src/{tools → extensions/tools}/model-tool-routing.ts

@@ -1,4 +1,4 @@
-import type { CoreAgentMode } from "../types/config";
+import type { CoreAgentMode } from "../../types/config";
 import type { DefaultToolName, DefaultToolsConfig } from "./types";
 
 export interface ToolRoutingRule {

package/src/{tools → extensions/tools}/presets.ts

@@ -4,7 +4,7 @@
  * Pre-configured tool combinations for common use cases.
  */
 
-import type { Tool, ToolPolicy } from "@clinebot/shared";
+import type { AgentMode, Tool, ToolPolicy } from "@clinebot/shared";
 import { ALL_DEFAULT_TOOL_NAMES } from "./constants";
 import { createDefaultTools } from "./definitions";
 import type { CreateDefaultToolsOptions, DefaultToolsConfig } from "./types";
@@ -19,91 +19,73 @@ export interface ToolPresetConfig extends DefaultToolsConfig {
  */
 export const ToolPresets = {
 	/**
-	 * Browser-based tools (no shell access, no web fetch)
-	 */
-	browser: {
-		enableReadFiles: false,
-		enableSearch: false,
-		enableBash: false,
-		enableWebFetch: false,
-		enableApplyPatch: false,
-		enableEditor: false,
-		enableSkills: true,
-		enableAskQuestion: true,
-		enableSubmitAndExit: false,
-		enableSpawnAgent: true,
-		enableAgentTeams: true,
-	},
-
-	/**
-	 * Search-focused tools (read_files + search_codebase)
-	 * Good for code exploration and analysis agents
+	 * Act mode (full development tools)
+	 * Good for coding assistants and task automation
 	 */
-	search: {
+	act: {
 		enableReadFiles: true,
 		enableSearch: true,
-		enableBash: false,
+		enableBash: true,
 		enableWebFetch: false,
 		enableApplyPatch: false,
-		enableEditor: false,
-		enableSkills: false,
-		enableAskQuestion: false,
+		enableEditor: true,
+		enableSkills: true,
+		enableAskQuestion: true,
 		enableSubmitAndExit: false,
 		enableSpawnAgent: true,
 		enableAgentTeams: true,
 	},
 
 	/**
-	 * Full development tools (all tools enabled) - Act mode
-	 * Good for coding assistants and task automation
+	 * Plan mode (read-only, no shell access)
+	 * Good for analysis and documentation agents
 	 */
-	development: {
+	plan: {
 		enableReadFiles: true,
 		enableSearch: true,
 		enableBash: true,
 		enableWebFetch: true,
 		enableApplyPatch: false,
-		enableEditor: true,
+		enableEditor: false,
 		enableSkills: true,
 		enableAskQuestion: true,
-		enableSubmitAndExit: true,
+		enableSubmitAndExit: false,
 		enableSpawnAgent: true,
 		enableAgentTeams: true,
 	},
 
 	/**
-	 * Read-only tools (no shell access) - Plan mode
-	 * Good for analysis and documentation agents
+	 * Search-focused tools (read_files + search_codebase)
+	 * Good for code exploration and analysis agents
 	 */
-	readonly: {
+	search: {
 		enableReadFiles: true,
 		enableSearch: true,
-		enableBash: true,
-		enableWebFetch: true,
+		enableBash: false,
+		enableWebFetch: false,
 		enableApplyPatch: false,
 		enableEditor: false,
-		enableSkills: true,
-		enableAskQuestion: true,
+		enableSkills: false,
+		enableAskQuestion: false,
 		enableSubmitAndExit: false,
 		enableSpawnAgent: true,
 		enableAgentTeams: true,
 	},
 
 	/**
-	 * Minimal tools (file reading only)
-	 * Good for focused single-file tasks
+	 * Minimal tools for focused tasks
 	 */
 	minimal: {
 		enableReadFiles: false,
 		enableSearch: false,
-		enableBash: false,
+		enableBash: true,
 		enableWebFetch: false,
 		enableApplyPatch: false,
 		enableEditor: false,
 		enableSkills: false,
-		enableAskQuestion: true,
+		enableAskQuestion: false,
 		enableSubmitAndExit: false,
-		enableSpawnAgent: false,
+		enableSpawnAgent: true,
 		enableAgentTeams: false,
 	},
 
@@ -132,13 +114,15 @@ export const ToolPresets = {
 export type ToolPresetName = keyof typeof ToolPresets;
 
 export function resolveToolPresetName(options: {
-	mode?: "act" | "plan";
-	yolo?: boolean;
+	mode?: AgentMode;
 }): ToolPresetName {
 	if (options.mode === "plan") {
-		return "readonly";
+		return "plan";
+	}
+	if (options.mode === "yolo") {
+		return "yolo";
 	}
-	return options.yolo === true ? "yolo" : "development";
+	return "act";
 }
 
 /**
@@ -178,7 +162,7 @@ export function createToolPoliciesWithPreset(
  *
  * @example
  * ```typescript
- * const tools = createDefaultToolsWithPreset("readonly", {
+ * const tools = createDefaultToolsWithPreset("plan", {
  *   executors: {
  *     readFile: async ({ path }) => fs.readFile(path, "utf-8"),
  *     search: async (query, cwd) => searchFiles(query, cwd),