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

package/src/core/tools/read.ts

@@ -6,6 +6,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
+import { untilAborted } from "../utils";
 import { resolveReadPath } from "./path-utils";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
@@ -69,169 +70,120 @@ Usage:
 		) => {
 			const absolutePath = resolveReadPath(path, cwd);
 
-			return new Promise<{ content: (TextContent | ImageContent)[]; details: ReadToolDetails | undefined }>(
-				(resolve, reject) => {
-					// Check if already aborted
-					if (signal?.aborted) {
-						reject(new Error("Operation aborted"));
-						return;
-					}
-
-					let aborted = false;
+			return untilAborted(signal, async () => {
+				// Check if file exists
+				await access(absolutePath, constants.R_OK);
+
+				const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+				const ext = extname(absolutePath).toLowerCase();
+
+				// Read the file based on type
+				let content: (TextContent | ImageContent)[];
+				let details: ReadToolDetails | undefined;
+
+				if (mimeType) {
+					// Read as image (binary)
+					const buffer = await readFile(absolutePath);
+					const base64 = buffer.toString("base64");
+
+					content = [
+						{ type: "text", text: `Read image file [${mimeType}]` },
+						{ type: "image", data: base64, mimeType },
+					];
+				} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {
+					// Convert document via markitdown
+					const result = convertWithMarkitdown(absolutePath);
+					if (result.ok) {
+						// Apply truncation to converted content
+						const truncation = truncateHead(result.content);
+						let outputText = truncation.content;
+
+						if (truncation.truncated) {
+							outputText += `\n\n[Document converted via markitdown. Output truncated to $formatSize(
+								DEFAULT_MAX_BYTES,
+							)]`;
+							details = { truncation };
+						}
 
-					// Set up abort handler
-					const onAbort = () => {
-						aborted = true;
-						reject(new Error("Operation aborted"));
-					};
+						content = [{ type: "text", text: outputText }];
+					} else {
+						// markitdown not available or failed
+						const errorMsg =
+							result.error === "markitdown not found"
+								? `markitdown not installed. Install with: pip install markitdown`
+								: result.error || "conversion failed";
+						content = [{ type: "text", text: `[Cannot read ${ext} file: ${errorMsg}]` }];
+					}
+				} else {
+					// Read as text
+					const textContent = await readFile(absolutePath, "utf-8");
+					const allLines = textContent.split("\n");
+					const totalFileLines = allLines.length;
+
+					// Apply offset if specified (1-indexed to 0-indexed)
+					const startLine = offset ? Math.max(0, offset - 1) : 0;
+					const startLineDisplay = startLine + 1; // For display (1-indexed)
+
+					// Check if offset is out of bounds
+					if (startLine >= allLines.length) {
+						throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+					}
 
-					if (signal) {
-						signal.addEventListener("abort", onAbort, { once: true });
+					// If limit is specified by user, use it; otherwise we'll let truncateHead decide
+					let selectedContent: string;
+					let userLimitedLines: number | undefined;
+					if (limit !== undefined) {
+						const endLine = Math.min(startLine + limit, allLines.length);
+						selectedContent = allLines.slice(startLine, endLine).join("\n");
+						userLimitedLines = endLine - startLine;
+					} else {
+						selectedContent = allLines.slice(startLine).join("\n");
 					}
 
-					// Perform the read operation
-					(async () => {
-						try {
-							// Check if file exists
-							await access(absolutePath, constants.R_OK);
-
-							// Check if aborted before reading
-							if (aborted) {
-								return;
-							}
-
-							const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
-							const ext = extname(absolutePath).toLowerCase();
-
-							// Read the file based on type
-							let content: (TextContent | ImageContent)[];
-							let details: ReadToolDetails | undefined;
-
-							if (mimeType) {
-								// Read as image (binary)
-								const buffer = await readFile(absolutePath);
-								const base64 = buffer.toString("base64");
-
-								content = [
-									{ type: "text", text: `Read image file [${mimeType}]` },
-									{ type: "image", data: base64, mimeType },
-								];
-							} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {
-								// Convert document via markitdown
-								const result = convertWithMarkitdown(absolutePath);
-								if (result.ok) {
-									// Apply truncation to converted content
-									const truncation = truncateHead(result.content);
-									let outputText = truncation.content;
-
-									if (truncation.truncated) {
-										outputText += `\n\n[Document converted via markitdown. Output truncated to $formatSize(
-											DEFAULT_MAX_BYTES,
-										)]`;
-										details = { truncation };
-									}
-
-									content = [{ type: "text", text: outputText }];
-								} else {
-									// markitdown not available or failed
-									const errorMsg =
-										result.error === "markitdown not found"
-											? `markitdown not installed. Install with: pip install markitdown`
-											: result.error || "conversion failed";
-									content = [{ type: "text", text: `[Cannot read ${ext} file: ${errorMsg}]` }];
-								}
-							} else {
-								// Read as text
-								const textContent = await readFile(absolutePath, "utf-8");
-								const allLines = textContent.split("\n");
-								const totalFileLines = allLines.length;
-
-								// Apply offset if specified (1-indexed to 0-indexed)
-								const startLine = offset ? Math.max(0, offset - 1) : 0;
-								const startLineDisplay = startLine + 1; // For display (1-indexed)
-
-								// Check if offset is out of bounds
-								if (startLine >= allLines.length) {
-									throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
-								}
-
-								// If limit is specified by user, use it; otherwise we'll let truncateHead decide
-								let selectedContent: string;
-								let userLimitedLines: number | undefined;
-								if (limit !== undefined) {
-									const endLine = Math.min(startLine + limit, allLines.length);
-									selectedContent = allLines.slice(startLine, endLine).join("\n");
-									userLimitedLines = endLine - startLine;
-								} else {
-									selectedContent = allLines.slice(startLine).join("\n");
-								}
-
-								// Apply truncation (respects both line and byte limits)
-								const truncation = truncateHead(selectedContent);
-
-								let outputText: string;
-
-								if (truncation.firstLineExceedsLimit) {
-									// First line at offset exceeds 30KB - tell model to use bash
-									const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
-									outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(
-										DEFAULT_MAX_BYTES,
-									)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
-									details = { truncation };
-								} else if (truncation.truncated) {
-									// Truncation occurred - build actionable notice
-									const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
-									const nextOffset = endLineDisplay + 1;
-
-									outputText = truncation.content;
-
-									if (truncation.truncatedBy === "lines") {
-										outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`;
-									} else {
-										outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(
-											DEFAULT_MAX_BYTES,
-										)} limit). Use offset=${nextOffset} to continue]`;
-									}
-									details = { truncation };
-								} else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
-									// User specified limit, there's more content, but no truncation
-									const remaining = allLines.length - (startLine + userLimitedLines);
-									const nextOffset = startLine + userLimitedLines + 1;
-
-									outputText = truncation.content;
-									outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue]`;
-								} else {
-									// No truncation, no user limit exceeded
-									outputText = truncation.content;
-								}
-
-								content = [{ type: "text", text: outputText }];
-							}
-
-							// Check if aborted after reading
-							if (aborted) {
-								return;
-							}
-
-							// Clean up abort handler
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-
-							resolve({ content, details });
-						} catch (error: any) {
-							// Clean up abort handler
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-
-							if (!aborted) {
-								reject(error);
-							}
+					// Apply truncation (respects both line and byte limits)
+					const truncation = truncateHead(selectedContent);
+
+					let outputText: string;
+
+					if (truncation.firstLineExceedsLimit) {
+						// First line at offset exceeds 30KB - tell model to use bash
+						const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
+						outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(
+							DEFAULT_MAX_BYTES,
+						)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
+						details = { truncation };
+					} else if (truncation.truncated) {
+						// Truncation occurred - build actionable notice
+						const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+						const nextOffset = endLineDisplay + 1;
+
+						outputText = truncation.content;
+
+						if (truncation.truncatedBy === "lines") {
+							outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`;
+						} else {
+							outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(
+								DEFAULT_MAX_BYTES,
+							)} limit). Use offset=${nextOffset} to continue]`;
 						}
-					})();
-				},
-			);
+						details = { truncation };
+					} else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
+						// User specified limit, there's more content, but no truncation
+						const remaining = allLines.length - (startLine + userLimitedLines);
+						const nextOffset = startLine + userLimitedLines + 1;
+
+						outputText = truncation.content;
+						outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue]`;
+					} else {
+						// No truncation, no user limit exceeded
+						outputText = truncation.content;
+					}
+
+					content = [{ type: "text", text: outputText }];
+				}
+
+				return { content, details };
+			});
 		},
 	};
 }

package/src/core/tools/write.ts

@@ -1,8 +1,6 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
-import type { FileDiagnosticsResult, FileFormatResult } from "./lsp/index";
+import { type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 
 const writeSchema = Type.Object({
@@ -12,21 +10,11 @@ const writeSchema = Type.Object({
 
 /** Options for creating the write tool */
 export interface WriteToolOptions {
-	/** Callback to format file using LSP after writing */
-	formatOnWrite?: (absolutePath: string) => Promise<FileFormatResult>;
-	/** Callback to get LSP diagnostics after writing a file */
-	getDiagnostics?: (absolutePath: string) => Promise<FileDiagnosticsResult>;
+	writethrough?: WritethroughCallback;
 }
 
 /** Details returned by the write tool for TUI rendering */
 export interface WriteToolDetails {
-	/** Whether the file was formatted */
-	wasFormatted: boolean;
-	/** Format result (if available) */
-	formatResult?: FileFormatResult;
-	/** Whether LSP diagnostics were retrieved */
-	hasDiagnostics: boolean;
-	/** Diagnostic result (if available) */
 	diagnostics?: FileDiagnosticsResult;
 }
 
@@ -34,6 +22,7 @@ export function createWriteTool(
 	cwd: string,
 	options: WriteToolOptions = {},
 ): AgentTool<typeof writeSchema, WriteToolDetails> {
+	const writethrough = options.writethrough ?? writethroughNoop;
 	return {
 		name: "write",
 		label: "Write",
@@ -52,108 +41,26 @@ Usage:
 			signal?: AbortSignal,
 		) => {
 			const absolutePath = resolveToCwd(path, cwd);
-			const dir = dirname(absolutePath);
 
-			return new Promise<{ content: Array<{ type: "text"; text: string }>; details: WriteToolDetails }>(
-				(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 write operation
-					(async () => {
-						try {
-							// Create parent directories if needed
-							await mkdir(dir, { recursive: true });
-
-							// Check if aborted before writing
-							if (aborted) {
-								return;
-							}
-
-							// Write the file
-							await writeFile(absolutePath, content, "utf-8");
-
-							// Check if aborted after writing
-							if (aborted) {
-								return;
-							}
-
-							// Clean up abort handler
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-
-							// Format file if callback provided (before diagnostics)
-							let formatResult: FileFormatResult | undefined;
-							if (options.formatOnWrite) {
-								try {
-									formatResult = await options.formatOnWrite(absolutePath);
-								} catch {
-									// Ignore formatting errors - don't fail the write
-								}
-							}
-
-							// Get LSP diagnostics if callback provided (after formatting)
-							let diagnosticsResult: FileDiagnosticsResult | undefined;
-							if (options.getDiagnostics) {
-								try {
-									diagnosticsResult = await options.getDiagnostics(absolutePath);
-								} catch {
-									// Ignore diagnostics errors - don't fail the write
-								}
-							}
-
-							// Build result text
-							let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
-
-							// Note if file was formatted
-							if (formatResult?.formatted) {
-								resultText += ` (formatted by ${formatResult.serverName})`;
-							}
-
-							// 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");
-							}
-
-							resolve({
-								content: [{ type: "text", text: resultText }],
-								details: {
-									wasFormatted: formatResult?.formatted ?? false,
-									formatResult,
-									hasDiagnostics: diagnosticsResult?.available ?? false,
-									diagnostics: diagnosticsResult,
-								},
-							});
-						} catch (error: any) {
-							// Clean up abort handler
-							if (signal) {
-								signal.removeEventListener("abort", onAbort);
-							}
-
-							if (!aborted) {
-								reject(error);
-							}
-						}
-					})();
-				},
-			);
+			const diagnostics = await writethrough(absolutePath, content, signal);
+
+			let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
+			if (!diagnostics) {
+				return {
+					content: [{ type: "text", text: resultText }],
+					details: {},
+				};
+			}
+
+			const messages = diagnostics?.messages;
+			if (messages && messages.length > 0) {
+				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+				resultText += messages.map((d) => `  ${d}`).join("\n");
+			}
+			return {
+				content: [{ type: "text", text: resultText }],
+				details: { diagnostics },
+			};
 		},
 	};
 }

package/src/core/utils.ts

@@ -0,0 +1,187 @@
+// Utility constant for representing aborted operations
+const kAbortError = new Error("Operation aborted");
+
+/**
+ * Runs a promise-returning function (`pr`). If the given AbortSignal is aborted before or during
+ * execution, the promise is rejected with a standard error.
+ *
+ * @param signal - Optional AbortSignal to cancel the operation
+ * @param pr - Function returning a promise to run
+ * @returns Promise resolving as `pr` would, or rejecting on abort
+ */
+export function untilAborted<T>(signal: AbortSignal | undefined | null, pr: () => Promise<T>): Promise<T> {
+	if (!signal) {
+		return pr();
+	}
+
+	if (signal.aborted) {
+		return Promise.reject(kAbortError);
+	}
+
+	return new Promise((resolve, reject) => {
+		const listener = () => reject(kAbortError);
+		signal.addEventListener("abort", listener, { once: true });
+
+		signal.throwIfAborted();
+
+		pr()
+			.then(resolve, reject)
+			.finally(() => {
+				signal.removeEventListener("abort", listener);
+			});
+	});
+}
+
+/**
+ * Memoizes a function with no arguments, calling it once and caching the result.
+ *
+ * @param fn - Function to be called once
+ * @returns A function that returns the cached result of `fn`
+ */
+export function once<T>(fn: () => T): () => T {
+	let store = undefined as { value: T } | undefined;
+	return () => {
+		if (store) {
+			return store.value;
+		}
+		const value = fn();
+		store = { value };
+		return value;
+	};
+}
+
+// ScopeSignal is a cancellation/helper utility similar to AbortController but
+// allows composition of an existing AbortSignal and/or a timeout. It exposes a
+// simple API for cancellation observation (finally, catch).
+interface ScopeSignalOptions {
+	signal?: AbortSignal;
+	timeout?: number;
+}
+
+const kTimeoutReason = new Error("Timeout");
+const kDisposedReason = new Error("Disposed");
+
+/**
+ * Type of signal exit (None = disposed, TimedOut = timed out, Aborted = underlying signal aborted)
+ */
+enum ExitReason {
+	None = 0,
+	TimedOut = 1,
+	Aborted = 2,
+}
+
+/**
+ * ScopeSignal: composable cancellation for async work–observes an external AbortSignal and/or a timeout.
+ *
+ * Use .finally(fn) to register a one-time callback invoked on *any* exit (abort, timeout, or manual dispose).
+ * Use .catch(fn) to register a one-time callback invoked only on abort/timeout.
+ *
+ * Disposing ScopeSignal disables further callbacks.
+ */
+export class ScopeSignal implements Disposable {
+	#signal: AbortSignal | undefined;
+	#timer: NodeJS.Timeout | undefined;
+	#exit = undefined as ExitReason | undefined;
+	#onAbort: (() => void) | undefined;
+	#callbacks?: (() => void)[];
+	#reason: unknown | undefined;
+
+	/**
+	 * Provides abort/timeout reason (Error or user-defined).
+	 */
+	get reason(): unknown | undefined {
+		return this.#reason;
+	}
+
+	/**
+	 * True if exited due to external AbortSignal or timeout.
+	 */
+	get aborted(): boolean {
+		return this.#exit !== undefined && this.#exit > ExitReason.None;
+	}
+
+	/**
+	 * True if this ScopeSignal timed out (not external abort).
+	 */
+	timedOut(): boolean {
+		return this.#exit === ExitReason.TimedOut;
+	}
+
+	/**
+	 * Create a new ScopeSignal, optionally observing an AbortSignal and/or auto-aborting after a timeout (ms).
+	 */
+	constructor(options?: ScopeSignalOptions) {
+		const { signal, timeout } = options ?? {};
+
+		if (signal?.aborted) {
+			this.#abort(ExitReason.Aborted, signal.reason); // Immediately abort if already-aborted
+			return;
+		}
+		if (timeout && timeout <= 0) {
+			this.#abort(ExitReason.TimedOut, kTimeoutReason);
+			return;
+		}
+
+		// Observe external signal if provided
+		if (signal) {
+			const onAbort = () => {
+				this.#abort(ExitReason.Aborted, signal.reason);
+			};
+			this.#signal = signal;
+			this.#onAbort = onAbort;
+			this.#signal.addEventListener("abort", onAbort, { once: true });
+		}
+
+		// Set up timeout if provided
+		if (timeout) {
+			this.#timer = setTimeout(() => {
+				this.#abort(ExitReason.TimedOut, kTimeoutReason);
+			}, timeout);
+		}
+	}
+
+	/**
+	 * Register a one-time callback invoked on any exit (abort, timeout, or manual dispose).
+	 * Runs immediately if already exited.
+	 */
+	finally(onfinally: () => void): void {
+		if (this.#exit !== undefined) {
+			onfinally();
+			return;
+		}
+		this.#callbacks ??= [];
+		this.#callbacks.push(onfinally);
+	}
+
+	/**
+	 * Register a one-time callback invoked only if exited due to abort/timeout (not normal disposal).
+	 */
+	catch(oncatch: (reason: unknown) => void): void {
+		this.finally(() => {
+			if (this.aborted) {
+				oncatch(this.reason);
+			}
+		});
+	}
+
+	/** Internal: cause exit; only first call takes effect. */
+	#abort(exit: ExitReason, reason?: unknown): void {
+		if (this.#exit !== undefined) return;
+		this.#reason = reason;
+		clearTimeout(this.#timer);
+		this.#signal?.removeEventListener("abort", this.#onAbort!);
+
+		this.#exit = exit;
+
+		const callbacks = this.#callbacks;
+		this.#callbacks = undefined;
+		callbacks?.forEach((fn) => void fn());
+	}
+
+	/**
+	 * Dispose: marks as normally exited (not abort/timeout); disables further callback registration.
+	 */
+	[Symbol.dispose](): void {
+		this.#abort(ExitReason.None, kDisposedReason);
+	}
+}