@oh-my-pi/pi-coding-agent 6.7.67 → 6.8.0

package/src/core/tools/grep.ts

@@ -3,21 +3,22 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { ptree, readLines } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
-import type { Subprocess } from "bun";
+import { $ } from "bun";
 import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import grepDescription from "../../prompts/tools/grep.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
-import { ScopeSignal, untilAborted } from "../utils";
+import { untilAborted } from "../utils";
 import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
-import { createToolUIKit, PREVIEW_LIMITS } from "./render-utils";
+import { PREVIEW_LIMITS, ToolUIKit } from "./render-utils";
 import {
 	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_COLUMN,
 	formatSize,
-	GREP_MAX_LINE_LENGTH,
 	type TruncationResult,
 	truncateHead,
 	truncateLine,
@@ -118,10 +119,38 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 	private readonly session: ToolSession;
 	private readonly ops: GrepOperations;
 
+	private readonly rgPath: Promise<string | undefined>;
+
 	constructor(session: ToolSession, options?: GrepToolOptions) {
 		this.session = session;
 		this.ops = options?.operations ?? defaultGrepOperations;
 		this.description = renderPromptTemplate(grepDescription);
+		this.rgPath = ensureTool("rg", true);
+	}
+
+	/**
+	 * Validates a pattern against ripgrep's regex engine.
+	 * Uses a quick dry-run against /dev/null to check for parse errors.
+	 */
+	private async validateRegexPattern(pattern: string): Promise<{ valid: boolean; error?: string }> {
+		const rgPath = await this.rgPath;
+		if (!rgPath) {
+			return { valid: true }; // Can't validate, assume valid
+		}
+
+		// Run ripgrep against /dev/null with the pattern - this validates regex syntax
+		// without searching any files
+		const result = await $`${rgPath} --no-config --quiet -- ${pattern} /dev/null`.quiet().nothrow();
+		const stderr = result.stderr?.toString() ?? "";
+		const exitCode = result.exitCode ?? 0;
+
+		// Exit code 1 = no matches (pattern is valid), 0 = matches found
+		// Exit code 2 = error (often regex parse error)
+		if (exitCode === 2 && stderr.includes("regex parse error")) {
+			return { valid: false, error: stderr.trim() };
+		}
+
+		return { valid: true };
 	}
 
 	public async execute(
@@ -148,7 +177,17 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 		} = params;
 
 		return untilAborted(signal, async () => {
-			const rgPath = await ensureTool("rg", true);
+			// Auto-detect invalid regex patterns and switch to literal mode
+			// This handles cases like "abort(" which would cause ripgrep regex parse errors
+			let useLiteral = literal ?? false;
+			if (!useLiteral) {
+				const validation = await this.validateRegexPattern(pattern);
+				if (!validation.valid) {
+					useLiteral = true;
+				}
+			}
+
+			const rgPath = await this.rgPath;
 			if (!rgPath) {
 				throw new Error("ripgrep (rg) is not available and could not be downloaded");
 			}
@@ -221,7 +260,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				args.push("--multiline");
 			}
 
-			if (literal) {
+			if (useLiteral) {
 				args.push("--fixed-strings");
 			}
 
@@ -235,17 +274,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 			args.push("--", pattern, searchPath);
 
-			const child: Subprocess = Bun.spawn([rgPath, ...args], {
-				stdin: "ignore",
-				stdout: "pipe",
-				stderr: "pipe",
-			});
+			const child = ptree.cspawn([rgPath, ...args], { signal });
 
-			let stderr = "";
 			let matchCount = 0;
 			let matchLimitReached = false;
 			let linesTruncated = false;
-			let aborted = false;
 			let killedDueToLimit = false;
 			const outputLines: string[] = [];
 			const files = new Set<string>();
@@ -265,49 +298,18 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				fileMatchCounts.set(relative, (fileMatchCounts.get(relative) ?? 0) + 1);
 			};
 
-			const stopChild = (dueToLimit: boolean = false) => {
-				killedDueToLimit = dueToLimit;
-				child.kill();
-			};
-
-			using signalScope = new ScopeSignal(signal ? { signal } : undefined);
-			signalScope.catch(() => {
-				aborted = true;
-				stopChild();
-			});
-
 			// For simple output modes (files_with_matches, count), process text directly
 			if (effectiveOutputMode === "files_with_matches" || effectiveOutputMode === "count") {
-				const stdoutReader = (child.stdout as ReadableStream<Uint8Array>).getReader();
-				const stderrReader = (child.stderr as ReadableStream<Uint8Array>).getReader();
-				const decoder = new TextDecoder();
-				let stdout = "";
-
-				await Promise.all([
-					(async () => {
-						while (true) {
-							const { done, value } = await stdoutReader.read();
-							if (done) break;
-							stdout += decoder.decode(value, { stream: true });
-						}
-					})(),
-					(async () => {
-						while (true) {
-							const { done, value } = await stderrReader.read();
-							if (done) break;
-							stderr += decoder.decode(value, { stream: true });
-						}
-					})(),
-				]);
-
-				const exitCode = await child.exited;
-
-				if (aborted) {
-					throw new Error("Operation aborted");
-				}
+				const stdout = await child.text().catch((x) => {
+					if (x instanceof ptree.Exception && x.exitCode === 1) {
+						return "";
+					}
+					return Promise.reject(x);
+				});
 
+				const exitCode = child.exitCode ?? 0;
 				if (exitCode !== 0 && exitCode !== 1) {
-					const errorMsg = stderr.trim() || `ripgrep exited with code ${exitCode}`;
+					const errorMsg = child.peekStderr().trim() || `ripgrep exited with code ${exitCode}`;
 					throw new Error(errorMsg);
 				}
 
@@ -484,57 +486,43 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 					if (matchCount >= effectiveLimit) {
 						matchLimitReached = true;
-						stopChild(true);
+						killedDueToLimit = true;
+						child.kill("SIGKILL");
 					}
 				}
 			};
 
-			// Read streams using Bun's ReadableStream API
-			const stdoutReader = (child.stdout as ReadableStream<Uint8Array>).getReader();
-			const stderrReader = (child.stderr as ReadableStream<Uint8Array>).getReader();
-			const decoder = new TextDecoder();
-			let stdoutBuffer = "";
-
-			await Promise.all([
-				// Process stdout line by line
-				(async () => {
-					while (true) {
-						const { done, value } = await stdoutReader.read();
-						if (done) break;
-
-						stdoutBuffer += decoder.decode(value, { stream: true });
-						const lines = stdoutBuffer.split("\n");
-						// Keep the last incomplete line in the buffer
-						stdoutBuffer = lines.pop() ?? "";
-
-						for (const line of lines) {
-							await processLine(line);
-						}
-					}
-					// Process any remaining content
-					if (stdoutBuffer.trim()) {
-						await processLine(stdoutBuffer);
-					}
-				})(),
-				// Collect stderr
-				(async () => {
-					while (true) {
-						const { done, value } = await stderrReader.read();
-						if (done) break;
-						stderr += decoder.decode(value, { stream: true });
-					}
-				})(),
-			]);
-
-			const exitCode = await child.exited;
-
-			if (aborted) {
-				throw new Error("Operation aborted");
+			// Process stdout line by line
+			try {
+				for await (const line of readLines(child.stdout)) {
+					await processLine(line);
+				}
+			} catch (err) {
+				if (err instanceof ptree.Exception && err.aborted) {
+					throw new Error("Operation aborted");
+				}
+				// Stream may close early if we killed due to limit - that's ok
+				if (!killedDueToLimit) {
+					throw err;
+				}
 			}
 
-			if (!killedDueToLimit && exitCode !== 0 && exitCode !== 1) {
-				const errorMsg = stderr.trim() || `ripgrep exited with code ${exitCode}`;
-				throw new Error(errorMsg);
+			// Wait for process to exit
+			try {
+				await child.exited;
+			} catch (err) {
+				if (err instanceof ptree.Exception) {
+					if (err.aborted) {
+						throw new Error("Operation aborted");
+					}
+					// Non-zero exit is ok if we killed due to limit or exit code 1 (no matches)
+					if (!killedDueToLimit && err.exitCode !== 1) {
+						const errorMsg = child.peekStderr().trim() || `ripgrep exited with code ${err.exitCode}`;
+						throw new Error(errorMsg);
+					}
+				} else {
+					throw err;
+				}
 			}
 
 			if (matchCount === 0) {
@@ -596,7 +584,7 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			}
 
 			if (linesTruncated) {
-				notices.push(`Some lines truncated to ${GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines`);
+				notices.push(`Some lines truncated to ${DEFAULT_MAX_COLUMN} chars. Use read tool to see full lines`);
 				details.linesTruncated = true;
 			}
 
@@ -636,7 +624,7 @@ const COLLAPSED_TEXT_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
 export const grepToolRenderer = {
 	inline: true,
 	renderCall(args: GrepRenderArgs, uiTheme: Theme): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const label = ui.title("Grep");
 		let text = `${uiTheme.format.bullet} ${label} ${uiTheme.fg("accent", args.pattern || "?")}`;
 
@@ -665,7 +653,7 @@ export const grepToolRenderer = {
 		{ expanded }: RenderResultOptions,
 		uiTheme: Theme,
 	): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const details = result.details;
 
 		if (result.isError || details?.error) {

package/src/core/tools/index.ts

@@ -62,8 +62,8 @@ export {
 export { WriteTool, type WriteToolDetails } from "./write";
 
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { logger } from "@oh-my-pi/pi-utils";
 import type { EventBus } from "../event-bus";
-import { logger } from "../logger";
 import { getPreludeDocs, warmPythonEnvironment } from "../python-executor";
 import { checkPythonKernelAvailability } from "../python-kernel";
 import type { BashInterceptorRule } from "../settings-manager";

package/src/core/tools/ls.ts

@@ -1,10 +1,10 @@
 import nodePath from "node:path";
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../custom-tools/types";
-import { untilAborted } from "../utils";
 import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
 import {

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

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import { logger } from "../../logger";
+import { logger } from "@oh-my-pi/pi-utils";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
@@ -711,63 +711,63 @@ export async function sendRequest(
 
 	client.lastActivity = Date.now();
 
-	return new Promise((resolve, reject) => {
-		let timeout: ReturnType<typeof setTimeout> | undefined;
-		const cleanup = () => {
-			if (signal) {
-				signal.removeEventListener("abort", abortHandler);
-			}
-		};
-		const abortHandler = () => {
-			if (client.pendingRequests.has(id)) {
-				client.pendingRequests.delete(id);
-			}
-			if (timeout) clearTimeout(timeout);
-			cleanup();
-			const reason = signal?.reason instanceof Error ? signal.reason : new Error("Operation aborted");
-			reject(reason);
-		};
-
-		// Set timeout
-		timeout = setTimeout(() => {
-			if (client.pendingRequests.has(id)) {
-				client.pendingRequests.delete(id);
-				const err = new Error(`LSP request ${method} timed out`);
-				cleanup();
-				reject(err);
-			}
-		}, timeoutMs);
+	const { promise, resolve, reject } = Promise.withResolvers<unknown>();
+	let timeout: ReturnType<typeof setTimeout> | undefined;
+	const cleanup = () => {
 		if (signal) {
-			signal.addEventListener("abort", abortHandler, { once: true });
-			if (signal.aborted) {
-				abortHandler();
-				return;
-			}
+			signal.removeEventListener("abort", abortHandler);
+		}
+	};
+	const abortHandler = () => {
+		if (client.pendingRequests.has(id)) {
+			client.pendingRequests.delete(id);
 		}
+		if (timeout) clearTimeout(timeout);
+		cleanup();
+		const reason = signal?.reason instanceof Error ? signal.reason : new Error("Operation aborted");
+		reject(reason);
+	};
 
-		// Register pending request with timeout wrapper
-		client.pendingRequests.set(id, {
-			resolve: (result) => {
-				if (timeout) clearTimeout(timeout);
-				cleanup();
-				resolve(result);
-			},
-			reject: (err) => {
-				if (timeout) clearTimeout(timeout);
-				cleanup();
-				reject(err);
-			},
-			method,
-		});
+	// Set timeout
+	timeout = setTimeout(() => {
+		if (client.pendingRequests.has(id)) {
+			client.pendingRequests.delete(id);
+			const err = new Error(`LSP request ${method} timed out`);
+			cleanup();
+			reject(err);
+		}
+	}, timeoutMs);
+	if (signal) {
+		signal.addEventListener("abort", abortHandler, { once: true });
+		if (signal.aborted) {
+			abortHandler();
+			return;
+		}
+	}
 
-		// Write request
-		writeMessage(client.process.stdin as import("bun").FileSink, request).catch((err) => {
+	// Register pending request with timeout wrapper
+	client.pendingRequests.set(id, {
+		resolve: (result) => {
+			if (timeout) clearTimeout(timeout);
+			cleanup();
+			resolve(result);
+		},
+		reject: (err) => {
 			if (timeout) clearTimeout(timeout);
-			client.pendingRequests.delete(id);
 			cleanup();
 			reject(err);
-		});
+		},
+		method,
+	});
+
+	// Write request
+	writeMessage(client.process.stdin as import("bun").FileSink, request).catch((err) => {
+		if (timeout) clearTimeout(timeout);
+		client.pendingRequests.delete(id);
+		cleanup();
+		reject(err);
 	});
+	return promise;
 }
 
 /**

package/src/core/tools/lsp/clients/lsp-linter-client.ts

@@ -84,7 +84,7 @@ export class LspLinterClient implements LinterClient {
 			if (diagnostics !== undefined) {
 				return diagnostics;
 			}
-			await new Promise((resolve) => setTimeout(resolve, 100));
+			await Bun.sleep(100);
 		}
 
 		return client.diagnostics.get(uri) ?? [];

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

@@ -1,9 +1,9 @@
 import { homedir } from "node:os";
 import { basename, extname, join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { globSync } from "glob";
 import { getConfigDirPaths } from "../../../config";
-import { logger } from "../../logger";
 import { BiomeClient } from "./clients/biome-client";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { ServerConfig } from "./types";

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

@@ -2,12 +2,11 @@ import type { Dirent } from "node:fs";
 import { existsSync, statSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { logger, once, untilAborted } from "@oh-my-pi/pi-utils";
 import type { BunFile } from "bun";
 import { type Theme, theme } from "../../../modes/interactive/theme/theme";
 import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
-import { logger } from "../../logger";
 import { renderPromptTemplate } from "../../prompt-templates";
-import { once, untilAborted } from "../../utils";
 import type { ToolSession } from "../index";
 import { resolveToCwd } from "../path-utils";
 import {
@@ -57,7 +56,6 @@ import {
 	formatLocation,
 	formatSymbolInformation,
 	formatWorkspaceEdit,
-	sleep,
 	symbolKindToIcon,
 	uriToFile,
 } from "./utils";
@@ -340,7 +338,7 @@ async function waitForDiagnostics(
 		const diagnostics = client.diagnostics.get(uri);
 		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
 		if (diagnostics !== undefined && versionOk) return diagnostics;
-		await sleep(100);
+		await Bun.sleep(100);
 	}
 	return client.diagnostics.get(uri) ?? [];
 }

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

@@ -1,7 +1,7 @@
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { TOML } from "bun";
-import { logger } from "../../logger";
 
 /**
  * lspmux integration for LSP server multiplexing.

package/src/core/tools/lsp/rust-analyzer.ts

@@ -1,6 +1,6 @@
 import { sendNotification, sendRequest } from "./client";
 import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types";
-import { fileToUri, sleep } from "./utils";
+import { fileToUri } from "./utils";
 
 /**
  * Run flycheck (cargo check) and collect diagnostics.
@@ -39,7 +39,7 @@ export async function flycheck(client: LspClient, file?: string): Promise<Diagno
 	let stableIterations = 0;
 
 	for (let i = 0; i < maxPollIterations; i++) {
-		await sleep(pollIntervalMs);
+		await Bun.sleep(pollIntervalMs);
 
 		const currentDiagnosticsVersion = client.diagnosticsVersion;
 		const currentDiagnosticsCount = countDiagnostics(client.diagnostics);

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

@@ -507,20 +507,6 @@ export function extractHoverText(
 // General Utilities
 // =============================================================================
 
-/**
- * Sleep for the specified number of milliseconds.
- */
-export function sleep(ms: number): Promise<void> {
-	return Bun.sleep(ms);
-}
-
-/**
- * Check if a command exists in PATH.
- */
-export async function commandExists(command: string): Promise<boolean> {
-	return Bun.which(command) !== null;
-}
-
 /**
  * Truncate a string to a maximum length with ellipsis.
  */

package/src/core/tools/notebook.ts

@@ -2,11 +2,11 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import type { RenderResultOptions } from "../custom-tools/types";
 import type { ToolSession } from "../sdk";
-import { untilAborted } from "../utils";
 import { resolveToCwd } from "./path-utils";
 import {
 	formatCount,

package/src/core/tools/patch/shared.ts

@@ -10,12 +10,11 @@ import { getLanguageFromPath, type Theme } from "../../../modes/interactive/them
 import type { RenderResultOptions } from "../../custom-tools/types";
 import type { FileDiagnosticsResult } from "../lsp/index";
 import {
-	createToolUIKit,
 	formatExpandHint,
 	formatStatusIcon,
 	getDiffStats,
 	shortenPath,
-	type ToolUIKit,
+	ToolUIKit,
 	truncateDiffByHunk,
 } from "../render-utils";
 import type { RenderCallOptions } from "../renderers";
@@ -157,7 +156,7 @@ export const editToolRenderer = {
 	mergeCallAndResult: true,
 
 	renderCall(args: EditRenderArgs, uiTheme: Theme, options?: RenderCallOptions): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const rawPath = args.file_path || args.path || "";
 		const filePath = shortenPath(rawPath);
 		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
@@ -190,7 +189,7 @@ export const editToolRenderer = {
 		uiTheme: Theme,
 		args?: EditRenderArgs,
 	): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const { expanded, renderContext } = options;
 		const rawPath = args?.file_path || args?.path || "";
 		const filePath = shortenPath(rawPath);

package/src/core/tools/python.ts

@@ -13,7 +13,7 @@ import { executePython, getPreludeDocs, type PythonExecutorOptions } from "../py
 import type { PreludeHelper, PythonStatusEvent } from "../python-kernel";
 import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
-import { createToolUIKit, getTreeBranch, getTreeContinuePrefix, shortenPath, truncate } from "./render-utils";
+import { getTreeBranch, getTreeContinuePrefix, shortenPath, ToolUIKit, truncate } from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
 
 export const PYTHON_DEFAULT_PREVIEW_LINES = 10;
@@ -610,7 +610,7 @@ function renderStatusEvents(events: PythonStatusEvent[], theme: Theme, expanded:
 
 export const pythonToolRenderer = {
 	renderCall(args: PythonRenderArgs, uiTheme: Theme): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const code = args.code || uiTheme.format.ellipsis;
 		const prompt = uiTheme.fg("accent", ">>>");
 		const cwd = process.cwd();
@@ -642,7 +642,7 @@ export const pythonToolRenderer = {
 		options: RenderResultOptions & { renderContext?: PythonRenderContext },
 		uiTheme: Theme,
 	): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const { renderContext } = options;
 		const details = result.details;