pi-agent-flow 1.2.3 → 1.2.5

package/src/batch.ts

@@ -1,1649 +1,15 @@
 /**
- * batch — Unified batch file operations tool.
+ * batch — re-export barrel.
  *
- * Combines read, write, edit, and delete into a single tool call.
- * Executes operations sequentially with skip-on-failure semantics.
- */
-
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { Type } from "@sinclair/typebox";
-import { Text, TruncatedText } from "@mariozechner/pi-tui";
-
-// ---------------------------------------------------------------------------
-// Schema
-// ---------------------------------------------------------------------------
-
-const EditOp = Type.Object({
-	f: Type.String({
-		description:
-			"Exact text to find (oldText). Must be unique in the file. All edits matched against original file, not incrementally.",
-	}),
-	r: Type.String({ description: "Replacement text (newText)." }),
-});
-
-const FileOp = Type.Object({
-	o: Type.Union([
-		Type.Literal("read"),
-		Type.Literal("write"),
-		Type.Literal("edit"),
-		Type.Literal("delete"),
-	]),
-	p: Type.String({ description: "Path to the file (relative or absolute)" }),
-	c: Type.Optional(
-		Type.String({
-			description:
-				"Full file content. Creates if new, overwrites if exists. Auto-creates parent dirs. Used with o: 'write'.",
-		}),
-	),
-	e: Type.Optional(
-		Type.Array(EditOp, {
-			description:
-				"One or more targeted replacements matched against the original file, not incrementally.",
-		}),
-	),
-	s: Type.Optional(
-		Type.Number({
-			minimum: 1,
-			description:
-				"1-indexed line number to start reading from (offset). Used with o: 'read'.",
-		}),
-	),
-	l: Type.Optional(
-		Type.Number({
-			minimum: 1,
-			description:
-				"Maximum number of lines to read (limit). Used with o: 'read'.",
-		}),
-	),
-});
-
-export const WeavePatchParams = Type.Object({
-	o: Type.Array(FileOp, {
-		description:
-			"Ordered list of file operations. Executed sequentially. On failure, remaining operations are skipped.",
-	}),
-});
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface EditReplacement {
-	f: string;
-	r: string;
-}
-
-interface FileOpInput {
-	o: "read" | "write" | "edit" | "delete";
-	p: string;
-	c?: string;
-	e?: EditReplacement[];
-	s?: number;
-	l?: number;
-}
-
-interface ContextMapEntry {
-	kind: string;
-	name: string;
-	startLine: number;
-	endLine: number;
-	parent?: string;
-}
-
-interface OpResult {
-	op: "read" | "write" | "edit" | "delete";
-	path: string;
-	status: "ok" | "error" | "skipped";
-	content?: string;
-	bytes?: number;
-	blocksChanged?: number;
-	totalLines?: number;
-	contextMap?: boolean;
-	language?: string;
-	symbols?: ContextMapEntry[];
-	symbolsTruncated?: boolean;
-	warning?: string;
-	truncated?: boolean;
-	nextOffset?: number;
-	error?: string;
-	hint?: string;
-}
-
-interface ReadTruncationResult {
-	content: string;
-	truncated: boolean;
-	nextOffset?: number;
-	linesRead: number;
-}
-
-interface ReadOptions {
-	/**
-	 * When false, readWithOffsetLimit ignores regular batch MAX_LINES and total
-	 * MAX_BYTES caps. batch_read applies its own safe full-file and targeted-read
-	 * guards before calling this helper.
-	 */
-	truncate?: boolean;
-	toolName?: "batch" | "batch_read";
-}
-
-interface ExecuteOptions {
-	readOptions?: ReadOptions;
-	includeLimitWarnings?: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const MAX_LINES = 2000;
-const MAX_BYTES = 50 * 1024; // 50KB
-const SAFE_FULL_READ_LIMIT = 300;
-const TARGETED_READ_LINE_LIMIT = 1000;
-const MAX_CONTEXT_MAP_ENTRIES = 100;
-
-function normalizeToLF(text: string): string {
-	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-function restoreLineEndings(text: string, ending: string): string {
-	return ending === "\r\n" ? text.replace(/\n/g, "\r\n") : text;
-}
-
-function detectLineEnding(content: string): string {
-	const crlfIdx = content.indexOf("\r\n");
-	const lfIdx = content.indexOf("\n");
-	if (lfIdx === -1) return "\n";
-	if (crlfIdx === -1) return "\n";
-	return crlfIdx < lfIdx ? "\r\n" : "\n";
-}
-
-function stripBom(content: string): { bom: string; text: string } {
-	return content.startsWith("\uFEFF")
-		? { bom: "\uFEFF", text: content.slice(1) }
-		: { bom: "", text: content };
-}
-
-type ContextLanguage =
-	| "typescript"
-	| "javascript"
-	| "python"
-	| "terraform"
-	| "hcl"
-	| "yaml"
-	| "dockerfile"
-	| "plain";
-
-interface FileContextMap {
-	language: ContextLanguage;
-	symbols: ContextMapEntry[];
-	symbolsTruncated?: boolean;
-}
-
-function isBatchRead(options: ExecuteOptions): boolean {
-	return options.readOptions?.toolName === "batch_read";
-}
-
-function isFullFileRead(op: FileOpInput, totalLines: number): boolean {
-	const start = op.s ?? 1;
-	if (start !== 1) return false;
-	return op.l === undefined || op.l >= totalLines;
-}
-
-function buildBatchReadSafetyWarning(): string {
-	return `[batch_read safety] Raw content truncated at ${TARGETED_READ_LINE_LIMIT} lines to preserve context. Adjust your 's' and 'l' parameters to read further.`;
-}
-
-function detectContextLanguage(filePath: string): ContextLanguage {
-	const base = path.basename(filePath);
-	const lowerBase = base.toLowerCase();
-	const ext = path.extname(lowerBase);
-
-	if (
-		lowerBase === "dockerfile" ||
-		lowerBase.startsWith("dockerfile.") ||
-		lowerBase === ".dockerfile" ||
-		lowerBase.endsWith(".dockerfile")
-	) {
-		return "dockerfile";
-	}
-
-	if ([".ts", ".tsx", ".mts", ".cts"].includes(ext)) return "typescript";
-	if ([".js", ".jsx", ".mjs", ".cjs"].includes(ext)) return "javascript";
-	if ([".py", ".pyw"].includes(ext)) return "python";
-	if ([".tf", ".tfvars"].includes(ext)) return "terraform";
-	if (ext === ".hcl") return "hcl";
-	if ([".yml", ".yaml"].includes(ext)) return "yaml";
-	return "plain";
-}
-
-function buildFileContextMap(filePath: string, lines: string[]): FileContextMap {
-	const language = detectContextLanguage(filePath);
-	let symbols: ContextMapEntry[] = [];
-
-	try {
-		switch (language) {
-			case "typescript":
-			case "javascript":
-				symbols = extractTsJsSymbols(lines);
-				break;
-			case "python":
-				symbols = extractPythonSymbols(lines);
-				break;
-			case "terraform":
-			case "hcl":
-				symbols = extractTerraformSymbols(lines);
-				break;
-			case "yaml":
-				symbols = extractYamlSymbols(lines);
-				break;
-			case "dockerfile":
-				symbols = extractDockerfileSymbols(lines);
-				break;
-			default:
-				symbols = [];
-		}
-	} catch {
-		symbols = [];
-	}
-
-	const sorted = symbols
-		.filter((entry) => entry.startLine > 0 && entry.endLine >= entry.startLine)
-		.sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
-
-	return {
-		language,
-		symbols: sorted.slice(0, MAX_CONTEXT_MAP_ENTRIES),
-		symbolsTruncated: sorted.length > MAX_CONTEXT_MAP_ENTRIES || undefined,
-	};
-}
-
-function countLeadingWhitespace(line: string): number {
-	return line.match(/^\s*/)?.[0].length ?? 0;
-}
-
-function findBraceBlockEnd(lines: string[], startIndex: number): number {
-	let depth = 0;
-	let sawOpenBrace = false;
-
-	for (let i = startIndex; i < lines.length; i++) {
-		for (const char of lines[i]) {
-			if (char === "{") {
-				depth++;
-				sawOpenBrace = true;
-			} else if (char === "}") {
-				depth--;
-			}
-		}
-		if (sawOpenBrace && depth <= 0) return i + 1;
-	}
-
-	return sawOpenBrace ? lines.length : startIndex + 1;
-}
-
-function findStatementEnd(lines: string[], startIndex: number): number {
-	for (let i = startIndex; i < lines.length; i++) {
-		if (lines[i].includes(";")) return i + 1;
-	}
-	return startIndex + 1;
-}
-
-function findIndentedBlockEnd(lines: string[], startIndex: number, indent: number): number {
-	for (let i = startIndex + 1; i < lines.length; i++) {
-		const trimmed = lines[i].trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		if (countLeadingWhitespace(lines[i]) <= indent) return i;
-	}
-	return lines.length;
-}
-
-function findYamlBlockEnd(lines: string[], startIndex: number, indent: number): number {
-	for (let i = startIndex + 1; i < lines.length; i++) {
-		const trimmed = lines[i].trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		if (trimmed === "---" || countLeadingWhitespace(lines[i]) <= indent) return i;
-	}
-	return lines.length;
-}
-
-function extractTsJsSymbols(lines: string[]): ContextMapEntry[] {
-	const entries: ContextMapEntry[] = [];
-	const classes: ContextMapEntry[] = [];
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-		let match = line.match(/^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/);
-		if (match) {
-			entries.push({ kind: "function", name: match[1], startLine: i + 1, endLine: findBraceBlockEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^\s*(?:export\s+)?(?:default\s+)?class\s+([A-Za-z_$][\w$]*)\b/);
-		if (match) {
-			const entry = { kind: "class", name: match[1], startLine: i + 1, endLine: findBraceBlockEnd(lines, i) };
-			entries.push(entry);
-			classes.push(entry);
-			continue;
-		}
-
-		match = line.match(/^\s*(?:export\s+)?interface\s+([A-Za-z_$][\w$]*)\b/);
-		if (match) {
-			entries.push({ kind: "interface", name: match[1], startLine: i + 1, endLine: findBraceBlockEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^\s*(?:export\s+)?type\s+([A-Za-z_$][\w$]*)\b/);
-		if (match) {
-			entries.push({ kind: "type", name: match[1], startLine: i + 1, endLine: line.includes("{") ? findBraceBlockEnd(lines, i) : findStatementEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^\s*(?:export\s+)?enum\s+([A-Za-z_$][\w$]*)\b/);
-		if (match) {
-			entries.push({ kind: "enum", name: match[1], startLine: i + 1, endLine: findBraceBlockEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:function\b|(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>)/);
-		if (match) {
-			entries.push({ kind: "function", name: match[1], startLine: i + 1, endLine: line.includes("{") ? findBraceBlockEnd(lines, i) : findStatementEnd(lines, i) });
-		}
-	}
-
-	const methodNameBlacklist = new Set(["if", "for", "while", "switch", "catch", "function"]);
-	for (const classEntry of classes) {
-		for (let i = classEntry.startLine; i < classEntry.endLine - 1 && i < lines.length; i++) {
-			const match = lines[i].match(/^\s*(?:(?:public|private|protected|static|async|override|readonly)\s+)*([A-Za-z_$][\w$]*)\s*(?:<[^>]+>)?\s*\([^)]*\)\s*(?::\s*[^={]+)?\s*\{/);
-			if (!match || methodNameBlacklist.has(match[1])) continue;
-			entries.push({
-				kind: "method",
-				name: `${classEntry.name}.${match[1]}`,
-				parent: classEntry.name,
-				startLine: i + 1,
-				endLine: findBraceBlockEnd(lines, i),
-			});
-		}
-	}
-
-	return entries;
-}
-
-function extractPythonSymbols(lines: string[]): ContextMapEntry[] {
-	const entries: ContextMapEntry[] = [];
-	const classes: Array<ContextMapEntry & { indent: number }> = [];
-
-	for (let i = 0; i < lines.length; i++) {
-		const match = lines[i].match(/^(\s*)class\s+([A-Za-z_]\w*)\b/);
-		if (!match) continue;
-		const indent = match[1].length;
-		const entry = { kind: "class", name: match[2], startLine: i + 1, endLine: findIndentedBlockEnd(lines, i, indent), indent };
-		classes.push(entry);
-		entries.push(entry);
-	}
-
-	for (let i = 0; i < lines.length; i++) {
-		const match = lines[i].match(/^(\s*)(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/);
-		if (!match) continue;
-		const indent = match[1].length;
-		const parent = classes.find((cls) => i + 1 > cls.startLine && i + 1 < cls.endLine && indent > cls.indent);
-		entries.push({
-			kind: parent ? "method" : "function",
-			name: parent ? `${parent.name}.${match[2]}` : match[2],
-			parent: parent?.name,
-			startLine: i + 1,
-			endLine: findIndentedBlockEnd(lines, i, indent),
-		});
-	}
-
-	return entries;
-}
-
-function extractTerraformSymbols(lines: string[]): ContextMapEntry[] {
-	const entries: ContextMapEntry[] = [];
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-		let match = line.match(/^\s*(resource|data)\s+"([^"]+)"\s+"([^"]+)"\s*\{/);
-		if (match) {
-			entries.push({ kind: match[1], name: `${match[2]}.${match[3]}`, startLine: i + 1, endLine: findBraceBlockEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^\s*(module|variable|output|provider)\s+"([^"]+)"\s*\{/);
-		if (match) {
-			entries.push({ kind: match[1], name: match[2], startLine: i + 1, endLine: findBraceBlockEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^\s*(locals|terraform)\s*\{/);
-		if (match) {
-			entries.push({ kind: match[1], name: match[1], startLine: i + 1, endLine: findBraceBlockEnd(lines, i) });
-			continue;
-		}
-
-		match = line.match(/^([A-Za-z_][\w-]*)\s*=/);
-		if (match) {
-			entries.push({ kind: "assignment", name: match[1], startLine: i + 1, endLine: i + 1 });
-		}
-	}
-
-	return entries;
-}
-
-function extractYamlSymbols(lines: string[]): ContextMapEntry[] {
-	const entries: ContextMapEntry[] = [];
-
-	let docStart = 0;
-	for (let i = 0; i <= lines.length; i++) {
-		if (i < lines.length && lines[i].trim() !== "---") continue;
-		const docEnd = i === lines.length ? lines.length : i;
-		const docLines = lines.slice(docStart, docEnd);
-		const kindLine = docLines.findIndex((line) => /^kind:\s*\S+/.test(line));
-		const nameLine = docLines.findIndex((line) => /^\s{2}name:\s*\S+/.test(line));
-		if (kindLine >= 0 && nameLine >= 0) {
-			const kind = docLines[kindLine].replace(/^kind:\s*/, "").trim();
-			const name = docLines[nameLine].replace(/^\s{2}name:\s*/, "").trim();
-			entries.push({ kind, name, startLine: docStart + 1, endLine: Math.max(docStart + 1, docEnd) });
-		}
-		docStart = i + 1;
-	}
-
-	for (let i = 0; i < lines.length; i++) {
-		const topLevel = lines[i].match(/^([A-Za-z_][\w.-]*):\s*/);
-		if (topLevel) {
-			const key = topLevel[1];
-			entries.push({ kind: "section", name: key, startLine: i + 1, endLine: findYamlBlockEnd(lines, i, 0) });
-
-			if (["jobs", "services", "volumes", "networks"].includes(key)) {
-				for (let j = i + 1; j < lines.length; j++) {
-					const trimmed = lines[j].trim();
-					if (!trimmed || trimmed.startsWith("#")) continue;
-					const indent = countLeadingWhitespace(lines[j]);
-					if (indent <= 0) break;
-					const child = lines[j].match(/^\s{2}([A-Za-z0-9_.-]+):\s*/);
-					if (!child) continue;
-					const childKind = key === "jobs" ? "job" : key.slice(0, -1);
-					entries.push({ kind: childKind, name: child[1], startLine: j + 1, endLine: findYamlBlockEnd(lines, j, 2) });
-				}
-			}
-		}
-
-		const step = lines[i].match(/^\s*-\s+(?:name:\s*(.+)|uses:\s*(.+)|run:\s*(.+))/);
-		if (step) {
-			const name = (step[1] ?? step[2] ?? step[3] ?? "step").trim();
-			entries.push({ kind: "step", name: name.slice(0, 120), startLine: i + 1, endLine: i + 1 });
-		}
-	}
-
-	return entries;
-}
-
-function findDockerInstructionEnd(lines: string[], startIndex: number): number {
-	let endIndex = startIndex;
-	while (endIndex + 1 < lines.length && lines[endIndex].trimEnd().endsWith("\\")) {
-		endIndex++;
-	}
-	return endIndex + 1;
-}
-
-function extractDockerfileSymbols(lines: string[]): ContextMapEntry[] {
-	const entries: ContextMapEntry[] = [];
-	const fromLines: number[] = [];
-
-	for (let i = 0; i < lines.length; i++) {
-		if (/^\s*FROM\s+/i.test(lines[i])) fromLines.push(i);
-	}
-
-	for (let idx = 0; idx < fromLines.length; idx++) {
-		const i = fromLines[idx];
-		const nextFrom = fromLines[idx + 1] ?? lines.length;
-		const match = lines[i].match(/^\s*FROM\s+(\S+)(?:\s+AS\s+(\S+))?/i);
-		const image = match?.[1] ?? "unknown";
-		const alias = match?.[2];
-		entries.push({ kind: "stage", name: alias ? `${alias} FROM ${image}` : image, startLine: i + 1, endLine: nextFrom });
-	}
-
-	const important = /^(RUN|COPY|ADD|ENTRYPOINT|CMD|EXPOSE|ENV|ARG|WORKDIR)\b\s*(.*)/i;
-	for (let i = 0; i < lines.length; i++) {
-		const match = lines[i].trim().match(important);
-		if (!match) continue;
-		entries.push({ kind: match[1].toUpperCase(), name: (match[2] || match[1]).slice(0, 120), startLine: i + 1, endLine: findDockerInstructionEnd(lines, i) });
-	}
-
-	return entries;
-}
-
-function readWithOffsetLimit(
-	content: string,
-	offset?: number,
-	limit?: number,
-	filePath?: string,
-	options: ReadOptions = {},
-): ReadTruncationResult {
-	const allLines = content.split("\n");
-	const totalFileLines = allLines.length;
-	const shouldTruncate = options.truncate !== false;
-	const toolName = options.toolName ?? "batch";
-
-	// Validate offset
-	if (offset !== undefined && offset > totalFileLines) {
-		throw new Error(
-			`Offset ${offset} is beyond end of file (${totalFileLines} lines total)`,
-		);
-	}
-
-	// Determine the start line (convert 1-indexed to 0-indexed)
-	const startLine = offset !== undefined ? Math.max(0, offset - 1) : 0;
-
-	// Determine end line
-	let endLine = totalFileLines;
-	if (limit !== undefined) {
-		endLine = Math.min(startLine + limit, totalFileLines);
-	}
-
-	let selectedLines = allLines.slice(startLine, endLine);
-	let truncated = false;
-	let nextOffset: number | undefined;
-
-	// Apply max-lines cap for regular batch reads. batch_read clamps oversized
-	// targeted reads before this helper and context-maps large full-file reads.
-	if (shouldTruncate && selectedLines.length > MAX_LINES) {
-		selectedLines = selectedLines.slice(0, MAX_LINES);
-		truncated = true;
-	}
-
-	// A single selected line that exceeds the byte cap is not safely splittable by
-	// line-oriented offsets, so keep the existing hard error in both modes.
-	for (let i = 0; i < selectedLines.length; i++) {
-		if (Buffer.byteLength(selectedLines[i], "utf-8") > MAX_BYTES) {
-			const lineDisplay = startLine + i + 1;
-			throw new Error(
-				`Line ${lineDisplay} exceeds limit. Try: ${toolName} with o:"read", s:${lineDisplay}, l:10, or use bash: head -c ... ${filePath ?? "<file>"}`,
-			);
-		}
-	}
-
-	// Join and check byte size
-	let result = selectedLines.join("\n");
-
-	// Truncate by total bytes for regular batch reads only. batch_read relies on
-	// its line-oriented safety guards and still rejects an individual huge line.
-	if (shouldTruncate && Buffer.byteLength(result, "utf-8") > MAX_BYTES) {
-		let byteAccum = 0;
-		let keepLines = 0;
-		for (let i = 0; i < selectedLines.length; i++) {
-			byteAccum += Buffer.byteLength(selectedLines[i], "utf-8") + (i > 0 ? 1 : 0); // newline separator between lines
-			if (byteAccum > MAX_BYTES) break;
-			keepLines = i + 1;
-		}
-		selectedLines = selectedLines.slice(0, keepLines);
-		result = selectedLines.join("\n");
-		truncated = true;
-	}
-
-	// Calculate nextOffset for continuation
-	const lastLineRead = startLine + selectedLines.length;
-	if (truncated || (limit !== undefined && lastLineRead < totalFileLines)) {
-		nextOffset = lastLineRead + 1; // 1-indexed
-	}
-
-	// Append truncation/continuation hints
-	if (truncated) {
-		const endDisplay = startLine + selectedLines.length;
-		const startDisplay = startLine + 1;
-		result += `\n\n[Showing lines ${startDisplay}-${endDisplay} of ${totalFileLines}. Use s=${nextOffset} to continue.]`;
-	} else if (limit !== undefined && lastLineRead < totalFileLines) {
-		const remaining = totalFileLines - lastLineRead;
-		result += `\n\n[${remaining} more lines in file. Use s=${nextOffset} to continue.]`;
-	}
-
-	return { content: result, truncated, nextOffset, linesRead: selectedLines.length };
-}
-
-function levenshtein(a: string, b: string): number {
-	const m = a.length;
-	const n = b.length;
-	const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-	for (let i = 0; i <= m; i++) dp[i][0] = i;
-	for (let j = 0; j <= n; j++) dp[0][j] = j;
-	for (let i = 1; i <= m; i++) {
-		for (let j = 1; j <= n; j++) {
-			dp[i][j] =
-				a[i - 1] === b[j - 1]
-					? dp[i - 1][j - 1]
-					: 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
-		}
-	}
-	return dp[m][n];
-}
-
-/**
- * Scan the parent directory (or cwd) for files with similar names.
- * Returns up to 3 suggestions sorted by similarity.
- */
-export async function suggestSimilarFiles(
-	inputPath: string,
-	cwd: string,
-): Promise<string[]> {
-	const resolved = path.resolve(cwd, inputPath);
-	const dir = path.dirname(resolved);
-	const target = path.basename(resolved);
-
-	try {
-		const entries = await fs.readdir(dir, { withFileTypes: true });
-		const candidates: { name: string; dist: number }[] = [];
-
-		for (const entry of entries) {
-			const name = entry.name;
-			// Skip hidden files and node_modules
-			if (name.startsWith(".") || name === "node_modules") continue;
-
-			const dist = levenshtein(target.toLowerCase(), name.toLowerCase());
-			const maxLen = Math.max(target.length, name.length);
-			// Only suggest if reasonably similar (within 40% edit distance, or shares prefix)
-			if (dist <= Math.ceil(maxLen * 0.4) || name.startsWith(target.slice(0, 3))) {
-				candidates.push({ name: entry.isDirectory() ? name + "/" : name, dist });
-			}
-		}
-
-		return candidates
-			.sort((a, b) => a.dist - b.dist)
-			.slice(0, 3)
-			.map((c) => path.join(path.relative(cwd, dir), c.name));
-	} catch {
-		return [];
-	}
-}
-
-function getErrorHint(error: string): string {
-	if (error.includes("File not found") || error.includes("file not found"))
-		return "Verify the path exists.";
-	if (error.includes("Could not find"))
-		return "Re-read the file first, then retry with exact f (oldText).";
-	if (error.includes("occurrences"))
-		return "Add more surrounding context to make oldText unique.";
-	if (error.includes("overlap"))
-		return "Merge overlapping edits into one.";
-	if (error.includes("No changes"))
-		return "File already has this content. No edit needed.";
-	if (error.includes("is not readable") || error.includes("not readable"))
-		return "Check file permissions.";
-	if (error.includes("ENOENT") || error.includes("no such file"))
-		return "Verify the path exists.";
-	if (error.includes("is beyond end of file"))
-		return "Use a smaller offset within the file length.";
-	return "";
-}
-
-// ---------------------------------------------------------------------------
-// Fuzzy matching (simplified)
-// ---------------------------------------------------------------------------
-
-function normalizeForMatch(text: string): string {
-	return text
-		.split("\n")
-		.map((line) => line.trimEnd())
-		.join("\n");
-}
-
-function buildPositionMap(original: string): number[] {
-	const normalized = normalizeForMatch(original);
-	const map: number[] = new Array(normalized.length + 1);
-	let oi = 0;
-	let ni = 0;
-
-	while (oi < original.length && ni < normalized.length) {
-		map[ni] = oi;
-		if (original[oi] === normalized[ni]) {
-			oi++;
-			ni++;
-		} else {
-			oi++;
-		}
-	}
-
-	while (ni < normalized.length) {
-		map[ni] = oi;
-		ni++;
-	}
-
-	map[normalized.length] = original.length;
-	return map;
-}
-
-function fuzzyFindText(
-	content: string,
-	oldText: string,
-): { found: boolean; index: number; matchLength: number; isExact: boolean } {
-	// Try exact match first
-	const exactIndex = content.indexOf(oldText);
-	if (exactIndex !== -1) {
-		return { found: true, index: exactIndex, matchLength: oldText.length, isExact: true };
-	}
-
-	// Try trimmed match, returning original indices
-	const normalizedContent = normalizeForMatch(content);
-	const normalizedOld = normalizeForMatch(oldText);
-	const fuzzyIndex = normalizedContent.indexOf(normalizedOld);
-	if (fuzzyIndex !== -1) {
-		const map = buildPositionMap(content);
-		const originalStart = map[fuzzyIndex];
-		const originalEnd = map[fuzzyIndex + normalizedOld.length];
-		return { found: true, index: originalStart, matchLength: originalEnd - originalStart, isExact: false };
-	}
-
-	return { found: false, index: -1, matchLength: 0, isExact: false };
-}
-
-function countOccurrences(content: string, oldText: string): number {
-	const normalizedContent = normalizeForMatch(content);
-	const normalizedOld = normalizeForMatch(oldText);
-	let count = 0;
-	let pos = 0;
-	while (true) {
-		const idx = normalizedContent.indexOf(normalizedOld, pos);
-		if (idx === -1) break;
-		count++;
-		pos = idx + normalizedOld.length;
-	}
-	return count;
-}
-
-function countExactOccurrences(content: string, oldText: string): number {
-	let count = 0;
-	let pos = 0;
-	while (true) {
-		const idx = content.indexOf(oldText, pos);
-		if (idx === -1) break;
-		count++;
-		pos = idx + oldText.length;
-	}
-	return count;
-}
-
-// ---------------------------------------------------------------------------
-// Edit logic
-// ---------------------------------------------------------------------------
-
-/**
- * Apply a fuzzy edit, preserving trailing whitespace from the original matched
- * text that wasn't explicitly present in the oldText.
- *
- * This prevents normalizeForMatch from stripping trailing whitespace on lines
- * that are being edited when fuzzy matching is used.
- */
-function applyFuzzyEdit(
-	content: string,
-	matchIndex: number,
-	matchLength: number,
-	oldText: string,
-	newText: string,
-): string {
-	const before = content.substring(0, matchIndex);
-	const after = content.substring(matchIndex + matchLength);
-	const matched = content.substring(matchIndex, matchIndex + matchLength);
-
-	const matchedLines = matched.split("\n");
-	const oldLines = oldText.split("\n");
-	const newLines = newText.split("\n");
-
-	const resultLines: string[] = [];
-	for (let i = 0; i < newLines.length; i++) {
-		const newLine = newLines[i];
-		const oldLine = oldLines[i] ?? "";
-		const matchedLine = matchedLines[i] ?? "";
-
-		const oldTrailing = oldLine.length - oldLine.trimEnd().length;
-		const matchedTrailing = matchedLine.length - matchedLine.trimEnd().length;
-
-		if (matchedTrailing > oldTrailing) {
-			const extraStart = matchedLine.trimEnd().length + oldTrailing;
-			resultLines.push(newLine + matchedLine.slice(extraStart));
-		} else {
-			resultLines.push(newLine);
-		}
-	}
-
-	return before + resultLines.join("\n") + after;
-}
-
-function applyEdits(
-	content: string,
-	edits: EditReplacement[],
-	filePath: string,
-): { newContent: string; blocksChanged: number } {
-	const normalizedEdits = edits.map((e) => ({
-		oldText: normalizeToLF(e.f),
-		newText: normalizeToLF(e.r),
-	}));
-
-	// Validate non-empty
-	for (let i = 0; i < normalizedEdits.length; i++) {
-		if (normalizedEdits[i].oldText.length === 0) {
-			throw new Error(`edits[${i}].f (oldText) must not be empty in ${filePath}.`);
-		}
-	}
-
-	const baseContent = content;
-
-	// Match all edits
-	interface MatchResult {
-		editIndex: number;
-		matchIndex: number;
-		matchLength: number;
-		newText: string;
-		oldText: string;
-		isExact: boolean;
-	}
-
-	const matchedEdits: MatchResult[] = [];
-	for (let i = 0; i < normalizedEdits.length; i++) {
-		const edit = normalizedEdits[i];
-		const matchResult = fuzzyFindText(baseContent, edit.oldText);
-
-		if (!matchResult.found) {
-			throw new Error(
-				edits.length === 1
-					? `Could not find the exact text in ${filePath}. The old text must match exactly including all whitespace and newlines.`
-					: `Could not find edits[${i}] in ${filePath}. The f (oldText) must match exactly including all whitespace and newlines.`,
-			);
-		}
-
-		const occurrences = matchResult.isExact
-			? countExactOccurrences(baseContent, edit.oldText)
-			: countOccurrences(baseContent, edit.oldText);
-		if (occurrences > 1) {
-			throw new Error(
-				edits.length === 1
-					? `Found ${occurrences} occurrences of the text in ${filePath}. The text must be unique. Please provide more context to make it unique.`
-					: `Found ${occurrences} occurrences of edits[${i}] in ${filePath}. Each f (oldText) must be unique. Please provide more context to make it unique.`,
-			);
-		}
-
-		matchedEdits.push({
-			editIndex: i,
-			matchIndex: matchResult.index,
-			matchLength: matchResult.matchLength,
-			newText: edit.newText,
-			oldText: edit.oldText,
-			isExact: matchResult.isExact,
-		});
-	}
-
-	// Sort by position (ascending)
-	matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);
-
-	// Check for overlaps
-	for (let i = 1; i < matchedEdits.length; i++) {
-		const previous = matchedEdits[i - 1];
-		const current = matchedEdits[i];
-		if (previous.matchIndex + previous.matchLength > current.matchIndex) {
-			throw new Error(
-				`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${filePath}. Merge them into one edit or target disjoint regions.`,
-			);
-		}
-	}
-
-	// Apply edits in reverse order to preserve offsets
-	let newContent = baseContent;
-	for (let i = matchedEdits.length - 1; i >= 0; i--) {
-		const edit = matchedEdits[i];
-		if (edit.isExact) {
-			newContent =
-				newContent.substring(0, edit.matchIndex) +
-				edit.newText +
-				newContent.substring(edit.matchIndex + edit.matchLength);
-		} else {
-			newContent = applyFuzzyEdit(
-				newContent,
-				edit.matchIndex,
-				edit.matchLength,
-				edit.oldText,
-				edit.newText,
-			);
-		}
-	}
-
-	if (baseContent === newContent) {
-		throw new Error(
-			edits.length === 1
-				? `No changes made to ${filePath}. The replacement produced identical content.`
-				: `No changes made to ${filePath}. The replacements produced identical content.`,
-		);
-	}
-
-	return {
-		newContent,
-		blocksChanged: matchedEdits.length,
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Path validation
-// ---------------------------------------------------------------------------
-
-function expandTilde(inputPath: string): string {
-	if (inputPath === "~") return os.homedir();
-	if (inputPath.startsWith("~/")) return path.join(os.homedir(), inputPath.slice(2));
-	return inputPath;
-}
-
-export function isWithinDirectory(child: string, parent: string): boolean {
-	if (process.platform === "win32") {
-		const childLower = child.toLowerCase();
-		const parentLower = parent.toLowerCase();
-		if (childLower === parentLower) return true;
-		const sep = path.win32.sep;
-		const prefix = parentLower.endsWith(sep) ? parentLower : parentLower + sep;
-		return childLower.startsWith(prefix);
-	}
-	if (child === parent) return true;
-	if (parent === "/") return child.startsWith("/");
-	return child.startsWith(parent + path.sep);
-}
-
-async function validatePath(inputPath: string, cwd: string): Promise<string> {
-	const expandedPath = expandTilde(inputPath);
-	return path.resolve(cwd, expandedPath);
-}
-
-// ---------------------------------------------------------------------------
-// prepareArguments shim
-// ---------------------------------------------------------------------------
-
-/**
- * Normalize a single operation object from any legacy format to the new
- * single-letter canonical form: { o, p, c, e, s, l }.
- */
-function normalizeOp(raw: Record<string, unknown>): Record<string, unknown> {
-	const op: Record<string, unknown> = {};
-
-	// Map operation type
-	op.o = raw.o ?? raw.op ?? (raw.c != null || raw.content != null ? "write" : (raw.e != null || raw.edits != null ? "edit" : "read"));
-
-	// Map path
-	op.p = raw.p ?? raw.path;
-
-	// Map content
-	if (raw.c !== undefined) op.c = raw.c;
-	else if (raw.content !== undefined) op.c = raw.content;
-
-	// Map edits
-	let editsRaw = raw.e ?? raw.edits;
-	if (typeof editsRaw === "string") {
-		try { editsRaw = JSON.parse(editsRaw); } catch { /* ignore */ }
-	}
-	if (Array.isArray(editsRaw)) {
-		op.e = editsRaw.map((e: unknown) => {
-			if (!e || typeof e !== "object") return e;
-			const edit = e as Record<string, unknown>;
-			return { f: edit.f ?? edit.oldText, r: edit.r ?? edit.newText };
-		});
-	}
-
-	// Map offset / limit
-	if (raw.s !== undefined) op.s = raw.s;
-	else if (raw.offset !== undefined) op.s = raw.offset;
-	if (raw.l !== undefined) op.l = raw.l;
-	else if (raw.limit !== undefined) op.l = raw.limit;
-
-	return op;
-}
-
-/**
- * Normalize input arguments to the canonical { o: [...] } shape.
- * Handles legacy formats, bare arrays, and single-operation shorthands.
- * Always returns { o: FileOpInput[] } to match WeavePatchParams schema.
- */
-function prepareArguments(input: unknown): { o: unknown[] } | unknown {
-	if (!input || typeof input !== "object") return { o: [] };
-
-	const args = input as Record<string, unknown>;
-
-	// Handle legacy top-level format: { path, oldText, newText }
-	if (
-		typeof args.oldText === "string" &&
-		typeof args.newText === "string" &&
-		typeof args.path === "string"
-	) {
-		return {
-			o: [
-				normalizeOp({
-					o: "edit",
-					p: args.path,
-					e: [{ oldText: args.oldText, newText: args.newText }],
-				}),
-			],
-		};
-	}
-
-	// Extract ops array — canonical { o: [...] }, legacy { op: [...] }, legacy { operations: [...] }, or bare array
-	let opsArray: unknown[];
-	if (Array.isArray(args.o)) {
-		opsArray = args.o;
-	} else if (Array.isArray(args.op)) {
-		opsArray = args.op;
-	} else if (Array.isArray(args.operations)) {
-		opsArray = args.operations;
-	} else if (Array.isArray(args)) {
-		opsArray = args;
-	} else if (typeof args.p === "string" || typeof args.path === "string") {
-		// Single-operation shorthand: { p: "...", o: "read" }
-		opsArray = [args];
-	} else {
-		return { o: [] };
-	}
-
-	// Normalize each operation to single-letter form
-	return {
-		o: opsArray.map((op: unknown) => {
-			if (!op || typeof op !== "object") return op;
-			return normalizeOp(op as Record<string, unknown>);
-		}),
-	};
-}
-
-// ---------------------------------------------------------------------------
-// Main execute function
-// ---------------------------------------------------------------------------
-
-async function executeOperations(
-	operations: FileOpInput[],
-	cwd: string,
-	signal?: AbortSignal,
-	options: ExecuteOptions = {},
-): Promise<{ summary: string; contentText: string; results: OpResult[] }> {
-	const results: OpResult[] = [];
-	let failed = false;
-
-	const counts = { read: 0, write: 0, edit: 0, delete: 0, error: 0, skipped: 0 };
-	const errors: { path: string; op: string; message: string; hint?: string }[] = [];
-	const truncatedFiles: { path: string; shown: number; total: number; nextOffset?: number }[] = [];
-	const includeLimitWarnings = options.includeLimitWarnings ?? true;
-
-	for (const op of operations) {
-		if (signal?.aborted) {
-			results.push({ op: op.o, path: op.p, status: "skipped", error: "Operation aborted." });
-			counts.skipped++;
-			continue;
-		}
-
-		if (failed) {
-			results.push({ op: op.o, path: op.p, status: "skipped" });
-			counts.skipped++;
-			continue;
-		}
-
-		try {
-			const resolvedPath = await validatePath(op.p, cwd);
-
-			switch (op.o) {
-				case "read": {
-					// Access check before reading
-					try {
-						await fs.access(resolvedPath);
-					} catch {
-						throw new Error(`File not found: ${op.p}`);
-					}
-					try {
-						await fs.access(resolvedPath, fs.constants.R_OK);
-					} catch {
-						throw new Error(`File not readable: ${op.p}`);
-					}
-
-					const rawContent = await fs.readFile(resolvedPath, "utf-8");
-					const { text } = stripBom(rawContent);
-					const allLines = text.split("\n");
-					const totalFileLines = allLines.length;
-
-					if (isBatchRead(options) && isFullFileRead(op, totalFileLines) && totalFileLines > SAFE_FULL_READ_LIMIT) {
-						const context = buildFileContextMap(op.p, allLines);
-						results.push({
-							op: "read",
-							path: op.p,
-							status: "ok",
-							totalLines: totalFileLines,
-							contextMap: true,
-							language: context.language !== "plain" ? context.language : undefined,
-							symbols: context.symbols.length > 0 ? context.symbols : undefined,
-							symbolsTruncated: context.symbolsTruncated,
-						});
-						counts.read++;
-						break;
-					}
-
-					let effectiveLimit = op.l;
-					let safetyTruncated = false;
-					let safetyWarning: string | undefined;
-					if (isBatchRead(options) && !isFullFileRead(op, totalFileLines)) {
-						if (effectiveLimit === undefined || effectiveLimit > TARGETED_READ_LINE_LIMIT) {
-							effectiveLimit = TARGETED_READ_LINE_LIMIT;
-							safetyTruncated = true;
-							safetyWarning = buildBatchReadSafetyWarning();
-						}
-					}
-
-					const { content: readContent, truncated, nextOffset, linesRead } =
-						readWithOffsetLimit(text, op.s, effectiveLimit, op.p, options.readOptions);
-					const finalContent = safetyWarning
-						? `${readContent}\n\n${safetyWarning}`
-						: readContent;
-					const finalTruncated = truncated || safetyTruncated;
-
-					if (finalTruncated || (includeLimitWarnings && effectiveLimit !== undefined && (op.s ?? 1) - 1 + effectiveLimit < totalFileLines)) {
-						const shownLines = finalTruncated ? linesRead : effectiveLimit!;
-						truncatedFiles.push({
-							path: op.p,
-							shown: shownLines,
-							total: totalFileLines,
-							nextOffset,
-						});
-					}
-
-					results.push({
-						op: "read",
-						path: op.p,
-						status: "ok",
-						content: finalContent,
-						totalLines: totalFileLines,
-						warning: safetyWarning,
-						truncated: finalTruncated || undefined,
-						nextOffset,
-					});
-					counts.read++;
-					break;
-				}
-
-				case "write": {
-					if (!op.c && op.c !== "") {
-						throw new Error("c (content) is required for write operations.");
-					}
-					await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
-					await fs.writeFile(resolvedPath, op.c!, "utf-8");
-					results.push({
-						op: "write",
-						path: op.p,
-						status: "ok",
-						bytes: Buffer.byteLength(op.c!, "utf-8"),
-					});
-					counts.write++;
-					break;
-				}
-
-				case "edit": {
-					if (!op.e || op.e.length === 0) {
-						throw new Error("e (edits) array is required for edit operations.");
-					}
-
-					const rawContent = await fs.readFile(resolvedPath, "utf-8");
-					const { bom, text: contentWithoutBom } = stripBom(rawContent);
-					const originalEnding = detectLineEnding(contentWithoutBom);
-					const normalizedContent = normalizeToLF(contentWithoutBom);
-
-					const { newContent, blocksChanged } = applyEdits(
-						normalizedContent,
-						op.e,
-						op.p,
-					);
-
-					const finalContent = bom + restoreLineEndings(newContent, originalEnding);
-					await fs.writeFile(resolvedPath, finalContent, "utf-8");
-
-					results.push({
-						op: "edit",
-						path: op.p,
-						status: "ok",
-						blocksChanged,
-					});
-					counts.edit++;
-					break;
-				}
-
-				case "delete": {
-					let stat;
-					try {
-						stat = await fs.lstat(resolvedPath);
-					} catch (err: any) {
-						if (err.code === "ENOENT") {
-							throw new Error(`File not found: ${op.p}`);
-						}
-						throw err;
-					}
-					if (stat.isDirectory()) {
-						throw new Error(`Cannot delete directory: ${op.p}. Use a recursive removal tool or delete files individually.`);
-					}
-					await fs.unlink(resolvedPath);
-					results.push({ op: "delete", path: op.p, status: "ok" });
-					counts.delete++;
-					break;
-				}
-
-				default:
-					throw new Error(`Unknown operation type: ${op.o}`);
-			}
-		} catch (err) {
-			failed = true;
-			counts.error++;
-			const message = err instanceof Error ? err.message : String(err);
-
-			// Enrich file-not-found errors with fuzzy filename suggestions
-			let hint = getErrorHint(message);
-			if (
-				message.includes("File not found") ||
-				message.includes("file not found") ||
-				message.includes("ENOENT") ||
-				message.includes("no such file")
-			) {
-				const suggestions = await suggestSimilarFiles(op.p, cwd);
-				if (suggestions.length > 0) {
-					hint += ` Did you mean: ${suggestions.join(", ")}?`;
-				}
-			}
-
-			errors.push({ path: op.p, op: op.o, message, hint });
-			results.push({
-				op: op.o,
-				path: op.p,
-				status: "error",
-				error: message,
-				hint,
-			});
-		}
-
-	}
-	// Build the enhanced summary and content text
-	const summary = buildSummary(counts, errors, truncatedFiles);
-	const contentText = buildContentText(summary, results);
-
-	return { summary, contentText, results };
-}
-
-function buildSummary(
-	counts: { read: number; write: number; edit: number; delete: number; error: number; skipped: number },
-	errors: { path: string; op: string; message: string; hint?: string }[],
-	truncatedFiles: { path: string; shown: number; total: number; nextOffset?: number }[],
-): string {
-	const totalSuccess =
-		counts.read + counts.write + counts.edit + counts.delete;
-	const totalOps = totalSuccess + counts.error + counts.skipped;
-
-	const parts: string[] = [];
-
-	// Build the success breakdown
-	const successParts: string[] = [];
-	if (counts.read > 0)
-		successParts.push(
-			`${counts.read} read${counts.read > 1 ? "s" : ""}`,
-		);
-	if (counts.write > 0)
-		successParts.push(
-			`${counts.write} write${counts.write > 1 ? "s" : ""}`,
-		);
-	if (counts.edit > 0)
-		successParts.push(
-			`${counts.edit} edit${counts.edit > 1 ? "s" : ""}`,
-		);
-	if (counts.delete > 0)
-		successParts.push(
-			`${counts.delete} delete${counts.delete > 1 ? "s" : ""}`,
-		);
-
-	if (counts.error === 0) {
-		// All success
-		parts.push(`✓ ${totalOps} operations: ${successParts.join(", ")}`);
-	} else {
-		// Mixed success/failure
-		parts.push(
-			`✗ ${counts.error} failed${counts.skipped > 0 ? `, ${counts.skipped} skipped` : ""}`,
-		);
-		if (totalSuccess > 0) {
-			parts.push(`  ✓ ${successParts.join(", ")} ok`);
-		}
-		for (const err of errors) {
-			const hint = err.hint ?? "";
-			const hintSuffix = hint ? ` — ${hint}` : "";
-			parts.push(`  ✗ ${err.op} ${err.path}: ${err.message}${hintSuffix}`);
-		}
-	}
-
-	// Truncation warnings
-	for (const tf of truncatedFiles) {
-		if (tf.nextOffset) {
-			parts.push(
-				`  ⚠ ${tf.path} truncated (${tf.shown}/${tf.total} lines) — use s=${tf.nextOffset}`,
-			);
-		}
-	}
-
-	return parts.join("\n");
-}
-
-function shortenPath(p: string): string {
-	const home = os.homedir();
-	return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
-}
-
-type BatchTheme = {
-	fg: (color: string, text: string) => string;
-	bold: (s: string) => string;
-	bg: (color: string, text: string) => string;
-};
-
-function extractBatchOps(args: Record<string, unknown>): Array<{ o: string; p: string; e?: unknown[] }> {
-	let rawOps: unknown[];
-	if (Array.isArray(args.o)) rawOps = args.o;
-	else if (Array.isArray(args.op)) rawOps = args.op;
-	else if (Array.isArray(args.operations)) rawOps = args.operations;
-	else if (Array.isArray(args)) rawOps = args;
-	else rawOps = [];
-
-	return rawOps
-		.filter((op): op is Record<string, unknown> => !!op && typeof op === "object")
-		.map((op) => {
-			const opName = String(op.o ?? op.op ?? "?");
-			const opPath = String(op.p ?? op.path ?? "?");
-			const edits = Array.isArray(op.e) ? op.e : Array.isArray(op.edits) ? op.edits : undefined;
-			return { o: opName, p: opPath, e: edits };
-		});
-}
-
-function formatBatchCall(args: Record<string, unknown>): string {
-	const ops = extractBatchOps(args);
-	if (ops.length === 0) return "batch (empty)";
-
-	const parts: string[] = [];
-	for (const op of ops) {
-		const shortPath = shortenPath(op.p);
-		if (op.o === "edit" && op.e && op.e.length > 1) {
-			parts.push(`edit ${shortPath} (${op.e.length} blocks)`);
-		} else {
-			parts.push(`${op.o} ${shortPath}`);
-		}
-	}
-
-	if (parts.length <= 3) {
-		return parts.join(", ");
-	}
-	return `${parts.slice(0, 2).join(", ")} +${parts.length - 2} more`;
-}
-
-function renderBatchCall(args: Record<string, unknown>, theme: BatchTheme): Text {
-	const summary = formatBatchCall(args);
-	return new Text(theme.fg("muted", "batch ") + theme.fg("accent", summary), 0, 0);
-}
-
-function renderBatchResult(
-	result: { content?: Array<{ type: string; text?: string }> },
-	expanded: boolean,
-	_theme: BatchTheme,
-	_args?: Record<string, unknown>,
-): Text | TruncatedText {
-	const fullText = result.content?.find((c) => c.type === "text")?.text ?? "";
-	if (!expanded) {
-		const summary = fullText.split("\n")[0] ?? "";
-		return new TruncatedText(summary, 0, 0);
-	}
-	return new Text(fullText, 0, 0);
-}
-
-function buildContextMapText(result: OpResult): string {
-	const title = result.language || result.symbols ? "context map" : "file summary";
-	const lines: string[] = [`\n--- ${result.path} ${title} ---`];
-	lines.push(`Total lines: ${result.totalLines ?? 0}`);
-	if (result.language) lines.push(`Language: ${result.language}`);
-	lines.push("");
-	lines.push(`Full-file content omitted because file exceeds SAFE_FULL_READ_LIMIT=${SAFE_FULL_READ_LIMIT} lines.`);
-	lines.push("Use targeted reads with s/l, for example:");
-	lines.push(`{ "o": "read", "p": "${result.path}", "s": <startLine>, "l": <lineCount> }`);
-
-	if (result.symbols && result.symbols.length > 0) {
-		lines.push("");
-		lines.push("Context map:");
-		for (const entry of result.symbols) {
-			lines.push(`- ${entry.kind} ${entry.name} ${entry.startLine}-${entry.endLine}`);
-		}
-		if (result.symbolsTruncated) {
-			lines.push(`... [Context map truncated. Over ${MAX_CONTEXT_MAP_ENTRIES} entries detected. Use targeted reads to explore further.]`);
-		}
-	} else if (result.language) {
-		lines.push("");
-		lines.push("No context map entries detected for this structured file.");
-	}
-
-	return lines.join("\n");
-}
-
-function buildContentText(summary: string, results: OpResult[]): string {
-	const sections: string[] = [summary];
-
-	for (const r of results) {
-		if (r.op === "read" && r.status === "ok" && r.contextMap) {
-			sections.push(buildContextMapText(r));
-		} else if (r.op === "read" && r.status === "ok" && r.content) {
-			const lineInfo = r.totalLines !== undefined ? ` (${r.totalLines} lines)` : "";
-			sections.push(`\n--- ${r.path}${lineInfo} ---\n${r.content}`);
-		} else if (r.op === "edit" && r.status === "ok") {
-			const blockInfo = r.blocksChanged !== undefined ? `${r.blocksChanged} block${r.blocksChanged > 1 ? "s" : ""}` : "";
-			sections.push(`\n--- edit: ${r.path} (${blockInfo}) ---`);
-		} else if (r.op === "write" && r.status === "ok") {
-			sections.push(`\n--- write: ${r.path} (${r.bytes ?? 0} bytes) ---`);
-		} else if (r.op === "delete" && r.status === "ok") {
-			sections.push(`\n--- delete: ${r.path} ---`);
-		} else if (r.status === "error") {
-			sections.push(`\n--- ${r.op}: ${r.path} ---\nError: ${r.error}`);
-		}
-	}
-
-	return sections.join("");
-}
-
-// ---------------------------------------------------------------------------
-// Tool definition factory
-// ---------------------------------------------------------------------------
-
-export const BatchReadParams = Type.Object({
-	o: Type.Array(
-		Type.Object({
-			o: Type.Literal("read"),
-			p: Type.String({ description: "Path to the file (relative or absolute)" }),
-			s: Type.Optional(
-				Type.Number({
-					minimum: 1,
-					description:
-						"1-indexed line number to start reading from (offset). Used with o: 'read'.",
-				}),
-			),
-			l: Type.Optional(
-				Type.Number({
-					minimum: 1,
-					description:
-						"Maximum number of lines to read (limit). Used with o: 'read'.",
-				}),
-			),
-		}),
-		{
-			description:
-				"Ordered list of read operations. Executed sequentially. On failure, remaining operations are skipped.",
-		},
-	),
-});
-
-function prepareBatchReadArguments(input: unknown): { o: FileOpInput[] } | unknown {
-	const prepared = prepareArguments(input);
-	const ops = Array.isArray(prepared) ? prepared : (prepared as { o: unknown[] }).o;
-	if (!Array.isArray(ops)) return { o: [] };
-
-	for (const op of ops) {
-		if (!op || typeof op !== "object") continue;
-		const obj = op as Record<string, unknown>;
-		const opType = String(obj.o ?? obj.op ?? "").toLowerCase();
-		if (opType && opType !== "read") {
-			throw new Error(`batch_read only supports read operations. Received: ${opType}`);
-		}
-	}
-	return prepared;
-}
-
-function renderBatchReadCall(args: Record<string, unknown>, theme: BatchTheme): Text {
-	const summary = formatBatchCall(args);
-	return new Text(theme.fg("muted", "batch_read ") + theme.fg("accent", summary), 0, 0);
-}
-
-export function createBatchReadTool() {
-	return {
-		name: "batch_read",
-		label: "batch_read",
-		description: [
-			"Batch read-only file operations — run multiple read ops in a single call.",
-			"Each operation is independent and executes sequentially in array order; on failure, remaining operations are skipped.",
-			`Full-file reads up to ${SAFE_FULL_READ_LIMIT} lines return raw content; larger full-file reads return a context map for code/infra files or total lines for plain text.`,
-			`Targeted reads with l over ${TARGETED_READ_LINE_LIMIT} are clamped with a continuation warning; a single line over the byte limit still errors.`,
-			"Use `o: \"read\"` with `s` (offset) and `l` (limit) for targeted reading. Prefer this over bash sed/head/tail.",
-			"Best for reading multiple files or sections in one call.",
-		].join("\n"),
-		promptSnippet: "Batch read-only file operations — run multiple read ops in one call",
-		promptGuidelines: [
-			"Use batch_read to perform multiple file reads in a single call rather than separate tool calls.",
-			"Prefer batch_read when reading 2+ files or multiple sections of the same file.",
-			`Small full-file reads (<=${SAFE_FULL_READ_LIMIT} lines) return raw content; larger full-file reads return navigable context maps or line counts.`,
-			`Use targeted reads with s/l around context-map entries; targeted reads are capped at ${TARGETED_READ_LINE_LIMIT} lines.`,
-			"Do not retry the same full-file read when a context map is returned.",
-		],
-		parameters: BatchReadParams,
-		prepareArguments: prepareBatchReadArguments,
-
-		async execute(
-			_toolCallId: string,
-			input: unknown,
-			signal: AbortSignal | undefined,
-			_onUpdate: unknown,
-			ctx: { cwd: string },
-		) {
-			let prepared: unknown;
-			try {
-				prepared = prepareBatchReadArguments(input);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				return {
-					content: [{ type: "text", text: `Error: ${message}` }],
-					isError: true,
-				};
-			}
-
-			const ops = Array.isArray(prepared)
-				? (prepared as FileOpInput[])
-				: (prepared as { o: FileOpInput[] }).o;
-
-			if (!Array.isArray(ops) || ops.length === 0) {
-				return {
-					content: [
-						{ type: "text", text: "Error: o array is required and must not be empty." },
-					],
-					isError: true,
-				};
-			}
-
-			// Defensive validation: reject any non-read operations
-			for (const op of ops) {
-				if (op.o !== "read") {
-					return {
-						content: [
-							{
-								type: "text",
-								text: `Error: batch_read only supports read operations. Received ${op.o} for ${op.p}.`,
-							},
-						],
-						isError: true,
-					};
-				}
-			}
-
-			if (signal?.aborted) {
-				return {
-					content: [{ type: "text", text: "Operation aborted." }],
-					isError: true,
-				};
-			}
-
-			const { contentText, results } = await executeOperations(ops, ctx.cwd, signal, {
-				readOptions: { truncate: false, toolName: "batch_read" },
-				includeLimitWarnings: false,
-			});
-
-			return {
-				content: [{ type: "text", text: contentText }],
-				details: { results },
-			};
-		},
-
-		renderCall: (args: Record<string, unknown>, theme: BatchTheme) => renderBatchReadCall(args, theme),
-		renderResult: (result: any, { expanded }: { expanded: boolean }, theme: BatchTheme, args?: Record<string, unknown>) =>
-			renderBatchResult(result, expanded, theme, args),
-	};
-}
-
-export function createBatchTool() {
-	return {
-		name: "batch",
-		label: "batch",
-		description: [
-			"Batch file operations — run multiple read, write, edit, or delete ops in a single call.",
-			"Each operation is independent: edits are matched against the current on-disk file, not against prior operations in the same call.",
-			"Operations execute sequentially in array order; on failure, remaining operations are skipped.",
-			"Use `o: \"read\"` with `s` (offset) and `l` (limit) for targeted reading. Prefer this over bash sed/head/tail.",
-			"Best for cross-cutting changes, multi-file refactors, or mixing reads with writes across several files.",
-		].join("\n"),
-		promptSnippet: "Batch file operations — run multiple read/write/edit/delete ops in one call",
-		promptGuidelines: [
-			"Use batch to perform multiple file operations in a single call rather than separate tool calls.",
-			"Prefer batch when touching 2+ files or mixing creates, edits, reads, and deletes.",
-			"Each operation is independent — edits match the on-disk file, not prior ops in the same call.",
-			"For single-file edits, the edit tool is fine; batch shines for cross-cutting and multi-file work.",
-		],
-		parameters: WeavePatchParams,
-		prepareArguments: prepareArguments,
-
-		async execute(
-			_toolCallId: string,
-			input: unknown,
-			signal: AbortSignal | undefined,
-			_onUpdate: unknown,
-			ctx: { cwd: string },
-		) {
-			const prepared = prepareArguments(input);
-			// prepareArguments always returns { o: [...] }, but handle
-			// legacy bare arrays for backward compatibility
-			const ops = Array.isArray(prepared)
-				? prepared as FileOpInput[]
-				: (prepared as { o: FileOpInput[] }).o;
-
-			if (!Array.isArray(ops) || ops.length === 0) {
-				return {
-					content: [
-						{ type: "text", text: "Error: o array is required and must not be empty." },
-					],
-					isError: true,
-				};
-			}
-
-			if (signal?.aborted) {
-				return {
-					content: [{ type: "text", text: "Operation aborted." }],
-					isError: true,
-				};
-			}
-
-			const { contentText, results } = await executeOperations(ops, ctx.cwd, signal);
-
-			return {
-				content: [{ type: "text", text: contentText }],
-				details: { results },
-			};
-		},
-
-		renderCall: (args: Record<string, unknown>, theme: BatchTheme) => renderBatchCall(args, theme),
-		renderResult: (result: any, { expanded }: { expanded: boolean }, theme: BatchTheme, args?: Record<string, unknown>) =>
-			renderBatchResult(result, expanded, theme, args),
-	};
-}
+ * Delegates to src/batch/ submodules. This file exists for backward
+ * compatibility with existing import paths.
+ */
+export {
+	WeavePatchParams,
+	BatchReadParams,
+	createBatchTool,
+	createBatchReadTool,
+} from "./batch/index.js";
+
+export { suggestSimilarFiles } from "./batch/execute.js";
+export { isWithinDirectory } from "./batch/fuzzy-edit.js";