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

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.

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

@@ -8,11 +8,10 @@ import { uriToFile } from "./utils";
 // =============================================================================
 
 /**
- * Apply text edits to a file.
+ * Apply text edits to a string in-memory.
  * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
  */
-export async function applyTextEdits(filePath: string, edits: TextEdit[]): Promise<void> {
-	const content = await Bun.file(filePath).text();
+export function applyTextEditsToString(content: string, edits: TextEdit[]): string {
 	const lines = content.split("\n");
 
 	// Sort edits in reverse order (bottom-to-top, right-to-left)
@@ -39,7 +38,17 @@ export async function applyTextEdits(filePath: string, edits: TextEdit[]): Promi
 		}
 	}
 
-	await Bun.write(filePath, lines.join("\n"));
+	return lines.join("\n");
+}
+
+/**
+ * Apply text edits to a file.
+ * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
+ */
+export async function applyTextEdits(filePath: string, edits: TextEdit[]): Promise<void> {
+	const content = await Bun.file(filePath).text();
+	const result = applyTextEditsToString(content, edits);
+	await Bun.write(filePath, result);
 }
 
 // =============================================================================