@oh-my-pi/pi-coding-agent 3.5.1337 → 3.8.1337

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,
+				};
 			});
 		},
 	};

package/src/core/tools/index.ts

@@ -11,8 +11,6 @@ export {
 	createLspTool,
 	type FileDiagnosticsResult,
 	type FileFormatResult,
-	formatFile,
-	getDiagnosticsForFile,
 	getLspStatus,
 	type LspServerStatus,
 	type LspToolDetails,
@@ -61,7 +59,7 @@ import { createEditTool, editTool } from "./edit";
 import { createFindTool, findTool } from "./find";
 import { createGrepTool, grepTool } from "./grep";
 import { createLsTool, lsTool } from "./ls";
-import { createLspTool, formatFile, getDiagnosticsForFile, lspTool } from "./lsp/index";
+import { createLspTool, createLspWritethrough, lspTool } from "./lsp/index";
 import { createNotebookTool, notebookTool } from "./notebook";
 import { createOutputTool, outputTool } from "./output";
 import { createReadTool, readTool } from "./read";
@@ -105,10 +103,12 @@ const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
 		tool: editTool,
 		create: (cwd, _ctx, options) => {
 			const enableDiagnostics = options?.lspDiagnosticsOnEdit ?? false;
-			return createEditTool(cwd, {
-				fuzzyMatch: options?.editFuzzyMatch ?? true,
-				getDiagnostics: enableDiagnostics ? (absolutePath) => getDiagnosticsForFile(absolutePath, cwd) : undefined,
+			const enableFormat = options?.lspFormatOnWrite ?? true;
+			const writethrough = createLspWritethrough(cwd, {
+				enableFormat,
+				enableDiagnostics,
 			});
+			return createEditTool(cwd, { fuzzyMatch: options?.editFuzzyMatch ?? true, writethrough });
 		},
 	},
 	write: {
@@ -116,10 +116,11 @@ const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
 		create: (cwd, _ctx, options) => {
 			const enableFormat = options?.lspFormatOnWrite ?? true;
 			const enableDiagnostics = options?.lspDiagnosticsOnWrite ?? true;
-			return createWriteTool(cwd, {
-				formatOnWrite: enableFormat ? (absolutePath) => formatFile(absolutePath, cwd) : undefined,
-				getDiagnostics: enableDiagnostics ? (absolutePath) => getDiagnosticsForFile(absolutePath, cwd) : undefined,
+			const writethrough = createLspWritethrough(cwd, {
+				enableFormat,
+				enableDiagnostics,
 			});
+			return createWriteTool(cwd, { writethrough });
 		},
 	},
 	grep: { tool: grepTool, create: createGrepTool },

package/src/core/tools/ls.ts

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, statSync } from "node:fs";
 import nodePath from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
+import { untilAborted } from "../utils";
 import { resolveToCwd } from "./path-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
@@ -28,109 +29,90 @@ export function createLsTool(cwd: string): AgentTool<typeof lsSchema> {
 			{ path, limit }: { path?: string; limit?: number },
 			signal?: AbortSignal,
 		) => {
-			return new Promise((resolve, reject) => {
-				if (signal?.aborted) {
-					reject(new Error("Operation aborted"));
-					return;
+			return untilAborted(signal, async () => {
+				const dirPath = resolveToCwd(path || ".", cwd);
+				const effectiveLimit = limit ?? DEFAULT_LIMIT;
+
+				// Check if path exists
+				if (!existsSync(dirPath)) {
+					throw new Error(`Path not found: ${dirPath}`);
 				}
 
-				const onAbort = () => reject(new Error("Operation aborted"));
-				signal?.addEventListener("abort", onAbort, { once: true });
+				// Check if path is a directory
+				const stat = statSync(dirPath);
+				if (!stat.isDirectory()) {
+					throw new Error(`Not a directory: ${dirPath}`);
+				}
 
+				// Read directory entries
+				let entries: string[];
 				try {
-					const dirPath = resolveToCwd(path || ".", cwd);
-					const effectiveLimit = limit ?? DEFAULT_LIMIT;
+					entries = readdirSync(dirPath);
+				} catch (e: any) {
+					throw new Error(`Cannot read directory: ${e.message}`);
+				}
 
-					// Check if path exists
-					if (!existsSync(dirPath)) {
-						reject(new Error(`Path not found: ${dirPath}`));
-						return;
-					}
+				// Sort alphabetically (case-insensitive)
+				entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
 
-					// Check if path is a directory
-					const stat = statSync(dirPath);
-					if (!stat.isDirectory()) {
-						reject(new Error(`Not a directory: ${dirPath}`));
-						return;
-					}
+				// Format entries with directory indicators
+				const results: string[] = [];
+				let entryLimitReached = false;
 
-					// Read directory entries
-					let entries: string[];
-					try {
-						entries = readdirSync(dirPath);
-					} catch (e: any) {
-						reject(new Error(`Cannot read directory: ${e.message}`));
-						return;
+				for (const entry of entries) {
+					if (results.length >= effectiveLimit) {
+						entryLimitReached = true;
+						break;
 					}
 
-					// Sort alphabetically (case-insensitive)
-					entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-
-					// Format entries with directory indicators
-					const results: string[] = [];
-					let entryLimitReached = false;
-
-					for (const entry of entries) {
-						if (results.length >= effectiveLimit) {
-							entryLimitReached = true;
-							break;
-						}
+					const fullPath = nodePath.join(dirPath, entry);
+					let suffix = "";
 
-						const fullPath = nodePath.join(dirPath, entry);
-						let suffix = "";
-
-						try {
-							const entryStat = statSync(fullPath);
-							if (entryStat.isDirectory()) {
-								suffix = "/";
-							}
-						} catch {
-							// Skip entries we can't stat
-							continue;
+					try {
+						const entryStat = statSync(fullPath);
+						if (entryStat.isDirectory()) {
+							suffix = "/";
 						}
-
-						results.push(entry + suffix);
+					} catch {
+						// Skip entries we can't stat
+						continue;
 					}
 
-					signal?.removeEventListener("abort", onAbort);
-
-					if (results.length === 0) {
-						resolve({ content: [{ type: "text", text: "(empty directory)" }], details: undefined });
-						return;
-					}
+					results.push(entry + suffix);
+				}
 
-					// Apply byte truncation (no line limit since we already have entry limit)
-					const rawOutput = results.join("\n");
-					const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
+				if (results.length === 0) {
+					return { content: [{ type: "text", text: "(empty directory)" }], details: undefined };
+				}
 
-					let output = truncation.content;
-					const details: LsToolDetails = {};
+				// Apply byte truncation (no line limit since we already have entry limit)
+				const rawOutput = results.join("\n");
+				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-					// Build notices
-					const notices: string[] = [];
+				let output = truncation.content;
+				const details: LsToolDetails = {};
 
-					if (entryLimitReached) {
-						notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
-						details.entryLimitReached = effectiveLimit;
-					}
+				// Build notices
+				const notices: string[] = [];
 
-					if (truncation.truncated) {
-						notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
-						details.truncation = truncation;
-					}
+				if (entryLimitReached) {
+					notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`);
+					details.entryLimitReached = effectiveLimit;
+				}
 
-					if (notices.length > 0) {
-						output += `\n\n[${notices.join(". ")}]`;
-					}
+				if (truncation.truncated) {
+					notices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+					details.truncation = truncation;
+				}
 
-					resolve({
-						content: [{ type: "text", text: output }],
-						details: Object.keys(details).length > 0 ? details : undefined,
-					});
-				} catch (e: any) {
-					signal?.removeEventListener("abort", onAbort);
-					reject(e);
+				if (notices.length > 0) {
+					output += `\n\n[${notices.join(". ")}]`;
 				}
+
+				return {
+					content: [{ type: "text", text: output }],
+					details: Object.keys(details).length > 0 ? details : undefined,
+				};
 			});
 		},
 	};

package/src/core/tools/lsp/client.ts

@@ -512,6 +512,69 @@ export async function ensureFileOpen(client: LspClient, filePath: string): Promi
 	}
 }
 
+/**
+ * Sync in-memory content to the LSP client without reading from disk.
+ * Use this to provide instant feedback during edits before the file is saved.
+ */
+export async function syncContent(client: LspClient, filePath: string, content: string): Promise<void> {
+	const uri = fileToUri(filePath);
+	const lockKey = `${client.name}:${uri}`;
+
+	const existingLock = fileOperationLocks.get(lockKey);
+	if (existingLock) {
+		await existingLock;
+	}
+
+	const syncPromise = (async () => {
+		const info = client.openFiles.get(uri);
+
+		if (!info) {
+			// Open file with provided content instead of reading from disk
+			const languageId = detectLanguageId(filePath);
+			await sendNotification(client, "textDocument/didOpen", {
+				textDocument: {
+					uri,
+					languageId,
+					version: 1,
+					text: content,
+				},
+			});
+			client.openFiles.set(uri, { version: 1, languageId });
+			client.lastActivity = Date.now();
+			return;
+		}
+
+		const version = ++info.version;
+		await sendNotification(client, "textDocument/didChange", {
+			textDocument: { uri, version },
+			contentChanges: [{ text: content }],
+		});
+		client.lastActivity = Date.now();
+	})();
+
+	fileOperationLocks.set(lockKey, syncPromise);
+	try {
+		await syncPromise;
+	} finally {
+		fileOperationLocks.delete(lockKey);
+	}
+}
+
+/**
+ * Notify LSP that a file was saved.
+ * Assumes content was already synced via syncContent - just sends didSave.
+ */
+export async function notifySaved(client: LspClient, filePath: string): Promise<void> {
+	const uri = fileToUri(filePath);
+	const info = client.openFiles.get(uri);
+	if (!info) return; // File not open, nothing to notify
+
+	await sendNotification(client, "textDocument/didSave", {
+		textDocument: { uri },
+	});
+	client.lastActivity = Date.now();
+}
+
 /**
  * Refresh a file in the LSP client.
  * Increments version, sends didChange and didSave notifications.