@oh-my-pi/pi-coding-agent 3.6.1337 → 3.9.1337

package/src/core/tools/edit.ts

@@ -1,18 +1,16 @@
-import { constants } from "node:fs";
-import { access, readFile, writeFile } from "node:fs/promises";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
 import {
 	DEFAULT_FUZZY_THRESHOLD,
 	detectLineEnding,
+	EditMatchError,
 	findEditMatch,
-	formatEditMatchError,
 	generateDiffString,
 	normalizeToLF,
 	restoreLineEndings,
 	stripBom,
 } from "./edit-diff";
-import type { FileDiagnosticsResult } from "./lsp/index";
+import { type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 
 const editSchema = Type.Object({
@@ -28,8 +26,6 @@ export interface EditToolDetails {
 	diff: string;
 	/** Line number of the first change in the new file (for editor navigation) */
 	firstChangedLine?: number;
-	/** Whether LSP diagnostics were retrieved */
-	hasDiagnostics?: boolean;
 	/** Diagnostic result (if available) */
 	diagnostics?: FileDiagnosticsResult;
 }
@@ -37,12 +33,13 @@ export interface EditToolDetails {
 export interface EditToolOptions {
 	/** Whether to accept high-confidence fuzzy matches for whitespace/indentation (default: true) */
 	fuzzyMatch?: boolean;
-	/** Callback to get LSP diagnostics after editing a file */
-	getDiagnostics?: (absolutePath: string) => Promise<FileDiagnosticsResult>;
+	/** Writethrough callback to get LSP diagnostics after editing a file */
+	writethrough?: WritethroughCallback;
 }
 
 export function createEditTool(cwd: string, options: EditToolOptions = {}): AgentTool<typeof editSchema> {
 	const allowFuzzy = options.fuzzyMatch ?? true;
+	const writethrough = options.writethrough ?? writethroughNoop;
 	return {
 		name: "edit",
 		label: "Edit",
@@ -61,196 +58,87 @@ Usage:
 			{ path, oldText, newText }: { path: string; oldText: string; newText: string },
 			signal?: AbortSignal,
 		) => {
-			const absolutePath = resolveToCwd(path, cwd);
-
 			// Reject .ipynb files - use NotebookEdit tool instead
-			if (absolutePath.endsWith(".ipynb")) {
-				return {
-					content: [
-						{
-							type: "text",
-							text: "Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.",
-						},
-					],
-					details: undefined,
-				};
+			if (path.endsWith(".ipynb")) {
+				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 			}
 
-			return new Promise<{
-				content: Array<{ type: "text"; text: string }>;
-				details: EditToolDetails | undefined;
-			}>((resolve, reject) => {
-				// Check if already aborted
-				if (signal?.aborted) {
-					reject(new Error("Operation aborted"));
-					return;
-				}
-
-				let aborted = false;
-
-				// Set up abort handler
-				const onAbort = () => {
-					aborted = true;
-					reject(new Error("Operation aborted"));
-				};
-
-				if (signal) {
-					signal.addEventListener("abort", onAbort, { once: true });
-				}
-
-				// Perform the edit operation
-				(async () => {
-					try {
-						// Check if file exists
-						try {
-							await access(absolutePath, constants.R_OK | constants.W_OK);
-						} catch {
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-							reject(new Error(`File not found: ${path}`));
-							return;
-						}
-
-						// Check if aborted before reading
-						if (aborted) {
-							return;
-						}
-
-						// Read the file
-						const rawContent = await readFile(absolutePath, "utf-8");
-
-						// Check if aborted after reading
-						if (aborted) {
-							return;
-						}
-
-						// Strip BOM before matching (LLM won't include invisible BOM in oldText)
-						const { bom, text: content } = stripBom(rawContent);
-
-						const originalEnding = detectLineEnding(content);
-						const normalizedContent = normalizeToLF(content);
-						const normalizedOldText = normalizeToLF(oldText);
-						const normalizedNewText = normalizeToLF(newText);
-
-						const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
-							allowFuzzy,
-							similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
-						});
-
-						if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-							reject(
-								new Error(
-									`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
-								),
-							);
-							return;
-						}
-
-						if (!matchOutcome.match) {
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-							reject(
-								new Error(
-									formatEditMatchError(path, normalizedOldText, matchOutcome.closest, {
-										allowFuzzy,
-										similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
-										fuzzyMatches: matchOutcome.fuzzyMatches,
-									}),
-								),
-							);
-							return;
-						}
+			const absolutePath = resolveToCwd(path, cwd);
 
-						const match = matchOutcome.match;
+			const file = Bun.file(absolutePath);
+			if (!(await file.exists())) {
+				throw new Error(`File not found: ${path}`);
+			}
 
-						// Check if aborted before writing
-						if (aborted) {
-							return;
-						}
+			const rawContent = await file.text();
 
-						const normalizedNewContent =
-							normalizedContent.substring(0, match.startIndex) +
-							normalizedNewText +
-							normalizedContent.substring(match.startIndex + match.actualText.length);
+			// Strip BOM before matching (LLM won't include invisible BOM in oldText)
+			const { bom, text: content } = stripBom(rawContent);
 
-						// Verify the replacement actually changed something
-						if (normalizedContent === normalizedNewContent) {
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-							reject(
-								new Error(
-									`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`,
-								),
-							);
-							return;
-						}
+			const originalEnding = detectLineEnding(content);
+			const normalizedContent = normalizeToLF(content);
+			const normalizedOldText = normalizeToLF(oldText);
+			const normalizedNewText = normalizeToLF(newText);
 
-						const finalContent = bom + restoreLineEndings(normalizedNewContent, originalEnding);
-						await writeFile(absolutePath, finalContent, "utf-8");
+			const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
+				allowFuzzy,
+				similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+			});
 
-						// Check if aborted after writing
-						if (aborted) {
-							return;
-						}
+			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+				throw new Error(
+					`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
+				);
+			}
 
-						// Clean up abort handler
-						if (signal) {
-							signal.removeEventListener("abort", onAbort);
-						}
+			if (!matchOutcome.match) {
+				throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
+					allowFuzzy,
+					similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+					fuzzyMatches: matchOutcome.fuzzyMatches,
+				});
+			}
 
-						const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
+			const match = matchOutcome.match;
+			const normalizedNewContent =
+				normalizedContent.substring(0, match.startIndex) +
+				normalizedNewText +
+				normalizedContent.substring(match.startIndex + match.actualText.length);
+
+			// Verify the replacement actually changed something
+			if (normalizedContent === normalizedNewContent) {
+				throw new Error(
+					`No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`,
+				);
+			}
 
-						// Get LSP diagnostics if callback provided
-						let diagnosticsResult: FileDiagnosticsResult | undefined;
-						if (options.getDiagnostics) {
-							try {
-								diagnosticsResult = await options.getDiagnostics(absolutePath);
-							} catch {
-								// Ignore diagnostics errors - don't fail the edit
-							}
-						}
+			const finalContent = bom + restoreLineEndings(normalizedNewContent, originalEnding);
+			const diagnostics = await writethrough(absolutePath, finalContent, signal, file);
 
-						// Build result text
-						let resultText = `Successfully replaced text in ${path}.`;
+			const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
 
-						// Append diagnostics if available and there are issues
-						if (diagnosticsResult?.available && diagnosticsResult.diagnostics.length > 0) {
-							resultText += `\n\nLSP Diagnostics (${diagnosticsResult.summary}):\n`;
-							resultText += diagnosticsResult.diagnostics.map((d) => `  ${d}`).join("\n");
-						}
+			// Build result text
+			let resultText = `Successfully replaced text in ${path}.`;
 
-						resolve({
-							content: [
-								{
-									type: "text",
-									text: resultText,
-								},
-							],
-							details: {
-								diff: diffResult.diff,
-								firstChangedLine: diffResult.firstChangedLine,
-								hasDiagnostics: diagnosticsResult?.available ?? false,
-								diagnostics: diagnosticsResult,
-							},
-						});
-					} catch (error: any) {
-						// Clean up abort handler
-						if (signal) {
-							signal.removeEventListener("abort", onAbort);
-						}
+			const messages = diagnostics?.messages;
+			if (messages && messages.length > 0) {
+				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+				resultText += messages.map((d) => `  ${d}`).join("\n");
+			}
 
-						if (!aborted) {
-							reject(error);
-						}
-					}
-				})();
-			});
+			return {
+				content: [
+					{
+						type: "text",
+						text: resultText,
+					},
+				],
+				details: {
+					diff: diffResult.diff,
+					firstChangedLine: diffResult.firstChangedLine,
+					diagnostics: diagnostics,
+				},
+			};
 		},
 	};
 }

package/src/core/tools/find.ts

@@ -4,6 +4,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
 import { globSync } from "glob";
 import { ensureTool } from "../../utils/tools-manager";
+import { untilAborted } from "../utils";
 import { resolveToCwd } from "./path-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
@@ -67,191 +68,171 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 			},
 			signal?: AbortSignal,
 		) => {
-			return new Promise((resolve, reject) => {
-				if (signal?.aborted) {
-					reject(new Error("Operation aborted"));
-					return;
+			return untilAborted(signal, async () => {
+				// Ensure fd is available
+				const fdPath = await ensureTool("fd", true);
+				if (!fdPath) {
+					throw new Error("fd is not available and could not be downloaded");
 				}
 
-				const onAbort = () => reject(new Error("Operation aborted"));
-				signal?.addEventListener("abort", onAbort, { once: true });
+				const searchPath = resolveToCwd(searchDir || ".", cwd);
+				const effectiveLimit = limit ?? DEFAULT_LIMIT;
+				const effectiveType = type ?? "all";
+				const includeHidden = hidden ?? false;
+				const shouldSortByMtime = sortByMtime ?? false;
+
+				// Build fd arguments
+				const args: string[] = [
+					"--glob", // Use glob pattern
+					"--color=never", // No ANSI colors
+					"--max-results",
+					String(effectiveLimit),
+				];
+
+				if (includeHidden) {
+					args.push("--hidden");
+				}
 
-				(async () => {
-					try {
-						// Ensure fd is available
-						const fdPath = await ensureTool("fd", true);
-						if (!fdPath) {
-							reject(new Error("fd is not available and could not be downloaded"));
-							return;
-						}
+				// Add type filter
+				if (effectiveType === "file") {
+					args.push("--type", "f");
+				} else if (effectiveType === "dir") {
+					args.push("--type", "d");
+				}
 
-						const searchPath = resolveToCwd(searchDir || ".", cwd);
-						const effectiveLimit = limit ?? DEFAULT_LIMIT;
-						const effectiveType = type ?? "all";
-						const includeHidden = hidden ?? false;
-						const shouldSortByMtime = sortByMtime ?? false;
-
-						// Build fd arguments
-						const args: string[] = [
-							"--glob", // Use glob pattern
-							"--color=never", // No ANSI colors
-							"--max-results",
-							String(effectiveLimit),
-						];
-
-						if (includeHidden) {
-							args.push("--hidden");
-						}
+				// Include .gitignore files (root + nested) so fd respects them even outside git repos
+				const gitignoreFiles = new Set<string>();
+				const rootGitignore = path.join(searchPath, ".gitignore");
+				if (existsSync(rootGitignore)) {
+					gitignoreFiles.add(rootGitignore);
+				}
 
-						// Add type filter
-						if (effectiveType === "file") {
-							args.push("--type", "f");
-						} else if (effectiveType === "dir") {
-							args.push("--type", "d");
-						}
+				try {
+					const nestedGitignores = globSync("**/.gitignore", {
+						cwd: searchPath,
+						dot: true,
+						absolute: true,
+						ignore: ["**/node_modules/**", "**/.git/**"],
+					});
+					for (const file of nestedGitignores) {
+						gitignoreFiles.add(file);
+					}
+				} catch {
+					// Ignore glob errors
+				}
 
-						// Include .gitignore files (root + nested) so fd respects them even outside git repos
-						const gitignoreFiles = new Set<string>();
-						const rootGitignore = path.join(searchPath, ".gitignore");
-						if (existsSync(rootGitignore)) {
-							gitignoreFiles.add(rootGitignore);
-						}
+				for (const gitignorePath of gitignoreFiles) {
+					args.push("--ignore-file", gitignorePath);
+				}
 
-						try {
-							const nestedGitignores = globSync("**/.gitignore", {
-								cwd: searchPath,
-								dot: true,
-								absolute: true,
-								ignore: ["**/node_modules/**", "**/.git/**"],
-							});
-							for (const file of nestedGitignores) {
-								gitignoreFiles.add(file);
-							}
-						} catch {
-							// Ignore glob errors
-						}
+				// Pattern and path
+				args.push(pattern, searchPath);
 
-						for (const gitignorePath of gitignoreFiles) {
-							args.push("--ignore-file", gitignorePath);
-						}
+				// Run fd
+				const result = Bun.spawnSync([fdPath, ...args], {
+					stdin: "ignore",
+					stdout: "pipe",
+					stderr: "pipe",
+				});
 
-						// Pattern and path
-						args.push(pattern, searchPath);
+				const output = result.stdout.toString().trim();
 
-						// Run fd
-						const result = Bun.spawnSync([fdPath, ...args], {
-							stdin: "ignore",
-							stdout: "pipe",
-							stderr: "pipe",
-						});
+				if (result.exitCode !== 0) {
+					const errorMsg = result.stderr.toString().trim() || `fd exited with code ${result.exitCode}`;
+					// fd returns non-zero for some errors but may still have partial output
+					if (!output) {
+						throw new Error(errorMsg);
+					}
+				}
 
-						signal?.removeEventListener("abort", onAbort);
+				if (!output) {
+					return {
+						content: [{ type: "text", text: "No files found matching pattern" }],
+						details: { fileCount: 0, files: [], truncated: false },
+					};
+				}
 
-						const output = result.stdout.toString().trim();
+				const lines = output.split("\n");
+				const relativized: string[] = [];
+				const mtimes: number[] = [];
 
-						if (result.exitCode !== 0) {
-							const errorMsg = result.stderr.toString().trim() || `fd exited with code ${result.exitCode}`;
-							// fd returns non-zero for some errors but may still have partial output
-							if (!output) {
-								reject(new Error(errorMsg));
-								return;
-							}
-						}
+				for (const rawLine of lines) {
+					const line = rawLine.replace(/\r$/, "").trim();
+					if (!line) {
+						continue;
+					}
 
-						if (!output) {
-							resolve({
-								content: [{ type: "text", text: "No files found matching pattern" }],
-								details: { fileCount: 0, files: [], truncated: false },
-							});
-							return;
-						}
+					const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
+					let relativePath = line;
+					if (line.startsWith(searchPath)) {
+						relativePath = line.slice(searchPath.length + 1); // +1 for the /
+					} else {
+						relativePath = path.relative(searchPath, line);
+					}
 
-						const lines = output.split("\n");
-						const relativized: string[] = [];
-						const mtimes: number[] = [];
-
-						for (const rawLine of lines) {
-							const line = rawLine.replace(/\r$/, "").trim();
-							if (!line) {
-								continue;
-							}
-
-							const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-							let relativePath = line;
-							if (line.startsWith(searchPath)) {
-								relativePath = line.slice(searchPath.length + 1); // +1 for the /
-							} else {
-								relativePath = path.relative(searchPath, line);
-							}
-
-							if (hadTrailingSlash && !relativePath.endsWith("/")) {
-								relativePath += "/";
-							}
-
-							relativized.push(relativePath);
-
-							// Collect mtime if sorting is requested
-							if (shouldSortByMtime) {
-								try {
-									const fullPath = path.join(searchPath, relativePath);
-									const stat: Stats = statSync(fullPath);
-									mtimes.push(stat.mtimeMs);
-								} catch {
-									mtimes.push(0);
-								}
-							}
-						}
+					if (hadTrailingSlash && !relativePath.endsWith("/")) {
+						relativePath += "/";
+					}
+
+					relativized.push(relativePath);
 
-						// Sort by mtime if requested (most recent first)
-						if (shouldSortByMtime && relativized.length > 0) {
-							const indexed = relativized.map((path, idx) => ({ path, mtime: mtimes[idx] || 0 }));
-							indexed.sort((a, b) => b.mtime - a.mtime);
-							relativized.length = 0;
-							relativized.push(...indexed.map((item) => item.path));
+					// Collect mtime if sorting is requested
+					if (shouldSortByMtime) {
+						try {
+							const fullPath = path.join(searchPath, relativePath);
+							const stat: Stats = statSync(fullPath);
+							mtimes.push(stat.mtimeMs);
+						} catch {
+							mtimes.push(0);
 						}
+					}
+				}
 
-						// Check if we hit the result limit
-						const resultLimitReached = relativized.length >= effectiveLimit;
+				// Sort by mtime if requested (most recent first)
+				if (shouldSortByMtime && relativized.length > 0) {
+					const indexed = relativized.map((path, idx) => ({ path, mtime: mtimes[idx] || 0 }));
+					indexed.sort((a, b) => b.mtime - a.mtime);
+					relativized.length = 0;
+					relativized.push(...indexed.map((item) => item.path));
+				}
 
-						// Apply byte truncation (no line limit since we already have result limit)
-						const rawOutput = relativized.join("\n");
-						const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+				// Check if we hit the result limit
+				const resultLimitReached = relativized.length >= effectiveLimit;
 
-						let resultOutput = truncation.content;
-						const details: FindToolDetails = {
-							fileCount: relativized.length,
-							files: relativized.slice(0, 50),
-							truncated: resultLimitReached || truncation.truncated,
-						};
+				// Apply byte truncation (no line limit since we already have result limit)
+				const rawOutput = relativized.join("\n");
+				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-						// Build notices
-						const notices: string[] = [];
+				let resultOutput = truncation.content;
+				const details: FindToolDetails = {
+					fileCount: relativized.length,
+					files: relativized.slice(0, 50),
+					truncated: resultLimitReached || truncation.truncated,
+				};
 
-						if (resultLimitReached) {
-							notices.push(
-								`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`,
-							);
-							details.resultLimitReached = effectiveLimit;
-						}
+				// Build notices
+				const notices: string[] = [];
 
-						if (truncation.truncated) {
-							notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-							details.truncation = truncation;
-						}
+				if (resultLimitReached) {
+					notices.push(
+						`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`,
+					);
+					details.resultLimitReached = effectiveLimit;
+				}
 
-						if (notices.length > 0) {
-							resultOutput += `\n\n[${notices.join(". ")}]`;
-						}
+				if (truncation.truncated) {
+					notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+					details.truncation = truncation;
+				}
 
-						resolve({
-							content: [{ type: "text", text: resultOutput }],
-							details: Object.keys(details).length > 0 ? details : undefined,
-						});
-					} catch (e: any) {
-						signal?.removeEventListener("abort", onAbort);
-						reject(e);
-					}
-				})();
+				if (notices.length > 0) {
+					resultOutput += `\n\n[${notices.join(". ")}]`;
+				}
+
+				return {
+					content: [{ type: "text", text: resultOutput }],
+					details: Object.keys(details).length > 0 ? details : undefined,
+				};
 			});
 		},
 	};