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

package/src/core/tools/read.ts

@@ -4,6 +4,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ImageContent, TextContent } 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, untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import { CONFIG_DIR_NAME } from "../../config";
 import type { Theme } from "../../modes/interactive/theme/theme";
@@ -14,7 +15,7 @@ import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
-import { ScopeSignal, untilAborted } from "../utils";
+import { runFd } from "./find";
 import { LsTool } from "./ls";
 import { resolveReadPath, resolveToCwd } from "./path-utils";
 import { shortenPath, wrapBrackets } from "./render-utils";
@@ -153,53 +154,6 @@ function similarityScore(a: string, b: string): number {
 	return 1 - distance / maxLen;
 }
 
-async function captureCommandOutput(
-	command: string,
-	args: string[],
-	signal?: AbortSignal,
-): Promise<{ stdout: string; stderr: string; exitCode: number | null; aborted: boolean }> {
-	const child = Bun.spawn([command, ...args], {
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe",
-	});
-
-	using scope = new ScopeSignal(signal ? { signal } : undefined);
-	scope.catch(() => {
-		child.kill();
-	});
-
-	const stdoutReader = (child.stdout as ReadableStream<Uint8Array>).getReader();
-	const stderrReader = (child.stderr as ReadableStream<Uint8Array>).getReader();
-	const stdoutDecoder = new TextDecoder();
-	const stderrDecoder = new TextDecoder();
-	let stdout = "";
-	let stderr = "";
-
-	await Promise.all([
-		(async () => {
-			while (true) {
-				const { done, value } = await stdoutReader.read();
-				if (done) break;
-				stdout += stdoutDecoder.decode(value, { stream: true });
-			}
-			stdout += stdoutDecoder.decode();
-		})(),
-		(async () => {
-			while (true) {
-				const { done, value } = await stderrReader.read();
-				if (done) break;
-				stderr += stderrDecoder.decode(value, { stream: true });
-			}
-			stderr += stderrDecoder.decode();
-		})(),
-	]);
-
-	const exitCode = await child.exited;
-
-	return { stdout, stderr, exitCode, aborted: scope.aborted };
-}
-
 async function listCandidateFiles(
 	searchRoot: string,
 	signal?: AbortSignal,
@@ -238,10 +192,7 @@ async function listCandidateFiles(
 			".git",
 			searchRoot,
 		];
-		const { stdout, aborted } = await captureCommandOutput(fdPath, gitignoreArgs, signal);
-		if (aborted) {
-			throw new Error("Operation aborted");
-		}
+		const { stdout } = await runFd(fdPath, gitignoreArgs, signal);
 		const output = stdout.trim();
 		if (output) {
 			const nestedGitignores = output
@@ -269,17 +220,11 @@ async function listCandidateFiles(
 
 	args.push(".", searchRoot);
 
-	const { stdout, stderr, exitCode, aborted } = await captureCommandOutput(fdPath, args, signal);
-
-	if (aborted) {
-		throw new Error("Operation aborted");
-	}
-
+	const { stdout, stderr, exitCode } = await runFd(fdPath, args, signal);
 	const output = stdout.trim();
 
 	if (exitCode !== 0 && !output) {
-		const errorMsg = stderr.trim() || `fd exited with code ${exitCode ?? -1}`;
-		return { files: [], truncated: false, error: errorMsg };
+		return { files: [], truncated: false, error: stderr.trim() || `fd exited with code ${exitCode ?? -1}` };
 	}
 
 	if (!output) {
@@ -400,17 +345,22 @@ async function convertWithMarkitdown(
 		return { content: "", ok: false, error: "markitdown not found (uv/pip unavailable)" };
 	}
 
-	const { stdout, stderr, exitCode, aborted } = await captureCommandOutput(cmd, [filePath], signal);
-
-	if (aborted) {
-		throw new Error("Operation aborted");
+	const child = ptree.cspawn([cmd, filePath], { signal });
+	let stdout: string;
+	try {
+		stdout = await child.nothrow().text();
+	} catch (err) {
+		if (err instanceof ptree.Exception && err.aborted) {
+			throw new Error("Operation aborted");
+		}
+		throw err;
 	}
 
-	if (exitCode === 0 && stdout.length > 0) {
+	if (child.exitCode === 0 && stdout.length > 0) {
 		return { content: stdout, ok: true };
 	}
 
-	return { content: "", ok: false, error: stderr.trim() || "Conversion failed" };
+	return { content: "", ok: false, error: child.peekStderr().trim() || "Conversion failed" };
 }
 
 const readSchema = Type.Object({
@@ -605,9 +555,20 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				const startLine = offset ? Math.max(0, offset - 1) : 0;
 				const startLineDisplay = startLine + 1; // For display (1-indexed)
 
-				// Check if offset is out of bounds
+				// Check if offset is out of bounds - return graceful message instead of throwing
 				if (startLine >= allLines.length) {
-					throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+					const suggestion =
+						allLines.length === 0
+							? "The file is empty."
+							: `Use offset=1 to read from the start, or offset=${allLines.length} to read the last line.`;
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Offset ${offset} is beyond end of file (${allLines.length} lines total). ${suggestion}`,
+							},
+						],
+					};
 				}
 
 				// If limit is specified by user, use it; otherwise we'll let truncateHead decide

package/src/core/tools/render-utils.ts

@@ -324,11 +324,6 @@ export class ToolUIKit {
 	}
 }
 
-/** @deprecated Use `new ToolUIKit(theme)` instead */
-export function createToolUIKit(theme: Theme): ToolUIKit {
-	return new ToolUIKit(theme);
-}
-
 interface ParsedDiagnostic {
 	filePath: string;
 	line: number;

package/src/core/tools/ssh.ts

@@ -13,7 +13,7 @@ import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
 import type { ToolSession } from "./index";
-import { createToolUIKit } from "./render-utils";
+import { ToolUIKit } from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
 
 const sshSchema = Type.Object({
@@ -245,7 +245,7 @@ interface SshRenderContext {
 
 export const sshToolRenderer = {
 	renderCall(args: SshRenderArgs, uiTheme: Theme): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const host = args.host || uiTheme.format.ellipsis;
 		const command = args.command || uiTheme.format.ellipsis;
 		const text = ui.title(`[${host}] $ ${command}`);
@@ -260,7 +260,7 @@ export const sshToolRenderer = {
 		options: RenderResultOptions & { renderContext?: SshRenderContext },
 		uiTheme: Theme,
 	): Component {
-		const ui = createToolUIKit(uiTheme);
+		const ui = new ToolUIKit(uiTheme);
 		const { expanded, renderContext } = options;
 		const details = result.details;
 		const lines: string[] = [];

package/src/core/tools/task/model-resolver.ts

@@ -11,6 +11,7 @@
  *   - "omp/slow" or "pi/slow" → configured slow model from settings
  */
 
+import { $ } from "bun";
 import { type Settings as SettingsFile, settingsCapability } from "../../../capability/settings";
 import { loadCapability } from "../../../discovery";
 import type { Settings as SettingsData } from "../../settings-manager";
@@ -29,7 +30,7 @@ const CACHE_TTL_MS = 5 * 60 * 1000;
  * Returns models in "provider/modelId" format.
  * Caches the result for performance.
  */
-export function getAvailableModels(): string[] {
+export async function getAvailableModels(): Promise<string[]> {
 	const now = Date.now();
 	if (cachedModels !== null && now < cacheExpiry) {
 		return cachedModels;
@@ -37,20 +38,17 @@ export function getAvailableModels(): string[] {
 
 	try {
 		const ompCommand = resolveOmpCommand();
-		const result = Bun.spawnSync([ompCommand.cmd, ...ompCommand.args, "--list-models"], {
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-		});
+		const result = await $`${ompCommand.cmd} ${ompCommand.args} --list-models`.quiet().nothrow();
+		const stdout = result.stdout?.toString() ?? "";
 
-		if (result.exitCode !== 0 || !result.stdout) {
+		if (result.exitCode !== 0 || !stdout.trim()) {
 			cachedModels = [];
 			cacheExpiry = now + CACHE_TTL_MS;
 			return cachedModels;
 		}
 
 		// Parse output: skip header line, extract provider/model
-		const lines = result.stdout.toString().trim().split("\n");
+		const lines = stdout.trim().split("\n");
 		cachedModels = lines
 			.slice(1) // Skip header
 			.map((line) => {
@@ -151,7 +149,7 @@ export async function resolveModelPattern(
 		return undefined;
 	}
 
-	const models = availableModels ?? getAvailableModels();
+	const models = availableModels ?? (await getAvailableModels());
 	if (models.length === 0) {
 		// Fallback: return pattern as-is if we can't get available models
 		return pattern;

package/src/core/tools/task/worker.ts

@@ -15,19 +15,18 @@
 
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { logger, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
 import type { AgentSessionEvent } from "../../agent-session";
 import { AuthStorage } from "../../auth-storage";
 import type { CustomTool } from "../../custom-tools/types";
-import { logger } from "../../logger";
 import { ModelRegistry } from "../../model-registry";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { renderPromptTemplate } from "../../prompt-templates";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
 import { SessionManager } from "../../session-manager";
 import { SettingsManager } from "../../settings-manager";
-import { untilAborted } from "../../utils";
 import { type LspToolDetails, lspSchema } from "../lsp/types";
 import { getPythonToolDescription, type PythonToolDetails, type PythonToolParams, pythonSchema } from "../python";
 import type {
@@ -94,54 +93,58 @@ function callMCPToolViaParent(
 	signal?: AbortSignal,
 	timeoutMs = MCP_CALL_TIMEOUT_MS,
 ): Promise<{ content: Array<{ type: string; text?: string; [key: string]: unknown }>; isError?: boolean }> {
-	return new Promise((resolve, reject) => {
-		const callId = generateMCPCallId();
-		if (signal?.aborted) {
-			reject(new Error("Aborted"));
-			return;
-		}
+	const { promise, resolve, reject } = Promise.withResolvers<{
+		content: Array<{ type: string; text?: string; [key: string]: unknown }>;
+		isError?: boolean;
+	}>();
+	const callId = generateMCPCallId();
+	if (signal?.aborted) {
+		reject(new Error("Aborted"));
+		return promise;
+	}
 
-		const timeoutId = setTimeout(() => {
-			pendingMCPCalls.delete(callId);
-			reject(new Error(`MCP call timed out after ${timeoutMs}ms`));
-		}, timeoutMs);
+	const timeoutId = setTimeout(() => {
+		pendingMCPCalls.delete(callId);
+		reject(new Error(`MCP call timed out after ${timeoutMs}ms`));
+	}, timeoutMs);
 
-		const cleanup = () => {
-			clearTimeout(timeoutId);
-			pendingMCPCalls.delete(callId);
-		};
-
-		if (typeof signal?.addEventListener === "function") {
-			signal.addEventListener(
-				"abort",
-				() => {
-					cleanup();
-					reject(new Error("Aborted"));
-				},
-				{ once: true },
-			);
-		}
+	const cleanup = () => {
+		clearTimeout(timeoutId);
+		pendingMCPCalls.delete(callId);
+	};
 
-		pendingMCPCalls.set(callId, {
-			resolve: (result) => {
-				cleanup();
-				resolve(result ?? { content: [] });
-			},
-			reject: (error) => {
+	if (typeof signal?.addEventListener === "function") {
+		signal.addEventListener(
+			"abort",
+			() => {
 				cleanup();
-				reject(error);
+				reject(new Error("Aborted"));
 			},
-			timeoutId,
-		});
+			{ once: true },
+		);
+	}
 
-		postMessageSafe({
-			type: "mcp_tool_call",
-			callId,
-			toolName,
-			params,
-			timeoutMs,
-		} as SubagentWorkerResponse);
+	pendingMCPCalls.set(callId, {
+		resolve: (result) => {
+			cleanup();
+			resolve(result ?? { content: [] });
+		},
+		reject: (error) => {
+			cleanup();
+			reject(error);
+		},
+		timeoutId,
 	});
+
+	postMessageSafe({
+		type: "mcp_tool_call",
+		callId,
+		toolName,
+		params,
+		timeoutMs,
+	} as SubagentWorkerResponse);
+
+	return promise;
 }
 
 function callPythonToolViaParent(
@@ -149,64 +152,65 @@ function callPythonToolViaParent(
 	signal?: AbortSignal,
 	timeoutMs?: number,
 ): Promise<PythonToolCallResponse["result"]> {
-	return new Promise((resolve, reject) => {
-		const callId = generatePythonCallId();
-		if (signal?.aborted) {
-			reject(new Error("Aborted"));
-			return;
-		}
+	const { promise, resolve, reject } = Promise.withResolvers<PythonToolCallResponse["result"]>();
+	const callId = generatePythonCallId();
+	if (signal?.aborted) {
+		reject(new Error("Aborted"));
+		return promise;
+	}
 
-		const sendCancel = (reason: string) => {
-			postMessageSafe({ type: "python_tool_cancel", callId, reason } as SubagentWorkerResponse);
-		};
-
-		const timeoutId =
-			typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
-				? setTimeout(() => {
-						pendingPythonCalls.delete(callId);
-						sendCancel(`Python call timed out after ${timeoutMs}ms`);
-						reject(new Error(`Python call timed out after ${timeoutMs}ms`));
-					}, timeoutMs)
-				: undefined;
-
-		const cleanup = () => {
-			if (timeoutId) {
-				clearTimeout(timeoutId);
-			}
-			pendingPythonCalls.delete(callId);
-		};
-
-		if (typeof signal?.addEventListener === "function") {
-			signal.addEventListener(
-				"abort",
-				() => {
-					cleanup();
-					sendCancel("Aborted");
-					reject(new Error("Aborted"));
-				},
-				{ once: true },
-			);
+	const sendCancel = (reason: string) => {
+		postMessageSafe({ type: "python_tool_cancel", callId, reason } as SubagentWorkerResponse);
+	};
+
+	const timeoutId =
+		typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
+			? setTimeout(() => {
+					pendingPythonCalls.delete(callId);
+					sendCancel(`Python call timed out after ${timeoutMs}ms`);
+					reject(new Error(`Python call timed out after ${timeoutMs}ms`));
+				}, timeoutMs)
+			: undefined;
+
+	const cleanup = () => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
 		}
+		pendingPythonCalls.delete(callId);
+	};
 
-		pendingPythonCalls.set(callId, {
-			resolve: (result) => {
-				cleanup();
-				resolve(result ?? { content: [] });
-			},
-			reject: (error) => {
+	if (typeof signal?.addEventListener === "function") {
+		signal.addEventListener(
+			"abort",
+			() => {
 				cleanup();
-				reject(error);
+				sendCancel("Aborted");
+				reject(new Error("Aborted"));
 			},
-			timeoutId,
-		});
+			{ once: true },
+		);
+	}
 
-		postMessageSafe({
-			type: "python_tool_call",
-			callId,
-			params,
-			timeoutMs,
-		} as SubagentWorkerResponse);
+	pendingPythonCalls.set(callId, {
+		resolve: (result) => {
+			cleanup();
+			resolve(result ?? { content: [] });
+		},
+		reject: (error) => {
+			cleanup();
+			reject(error);
+		},
+		timeoutId,
 	});
+
+	postMessageSafe({
+		type: "python_tool_call",
+		callId,
+		params,
+		timeoutMs,
+	} as SubagentWorkerResponse);
+
+	return promise;
 }
 
 function callLspToolViaParent(
@@ -214,58 +218,59 @@ function callLspToolViaParent(
 	signal?: AbortSignal,
 	timeoutMs?: number,
 ): Promise<LspToolCallResponse["result"]> {
-	return new Promise((resolve, reject) => {
-		const callId = generateLspCallId();
-		if (signal?.aborted) {
-			reject(new Error("Aborted"));
-			return;
-		}
+	const { promise, resolve, reject } = Promise.withResolvers<LspToolCallResponse["result"]>();
+	const callId = generateLspCallId();
+	if (signal?.aborted) {
+		reject(new Error("Aborted"));
+		return promise;
+	}
 
-		const timeoutId =
-			typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
-				? setTimeout(() => {
-						pendingLspCalls.delete(callId);
-						reject(new Error(`LSP call timed out after ${timeoutMs}ms`));
-					}, timeoutMs)
-				: undefined;
-
-		const cleanup = () => {
-			if (timeoutId) {
-				clearTimeout(timeoutId);
-			}
-			pendingLspCalls.delete(callId);
-		};
-
-		if (typeof signal?.addEventListener === "function") {
-			signal.addEventListener(
-				"abort",
-				() => {
-					cleanup();
-					reject(new Error("Aborted"));
-				},
-				{ once: true },
-			);
+	const timeoutId =
+		typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
+			? setTimeout(() => {
+					pendingLspCalls.delete(callId);
+					reject(new Error(`LSP call timed out after ${timeoutMs}ms`));
+				}, timeoutMs)
+			: undefined;
+
+	const cleanup = () => {
+		if (timeoutId) {
+			clearTimeout(timeoutId);
 		}
+		pendingLspCalls.delete(callId);
+	};
 
-		pendingLspCalls.set(callId, {
-			resolve: (result) => {
-				cleanup();
-				resolve(result ?? { content: [] });
-			},
-			reject: (error) => {
+	if (typeof signal?.addEventListener === "function") {
+		signal.addEventListener(
+			"abort",
+			() => {
 				cleanup();
-				reject(error);
+				reject(new Error("Aborted"));
 			},
-			timeoutId,
-		});
+			{ once: true },
+		);
+	}
 
-		postMessageSafe({
-			type: "lsp_tool_call",
-			callId,
-			params,
-			timeoutMs,
-		} as SubagentWorkerResponse);
+	pendingLspCalls.set(callId, {
+		resolve: (result) => {
+			cleanup();
+			resolve(result ?? { content: [] });
+		},
+		reject: (error) => {
+			cleanup();
+			reject(error);
+		},
+		timeoutId,
 	});
+
+	postMessageSafe({
+		type: "lsp_tool_call",
+		callId,
+		params,
+		timeoutMs,
+	} as SubagentWorkerResponse);
+
+	return promise;
 }
 
 function handleMCPToolResult(response: MCPToolCallResponse): void {

package/src/core/tools/todo-write.ts

@@ -5,12 +5,12 @@ 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 { logger } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import chalk from "chalk";
 import type { Theme } from "../../modes/interactive/theme/theme";
 import todoWriteDescription from "../../prompts/tools/todo-write.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
-import { logger } from "../logger";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
 import { ensureArtifactsDir, getArtifactsDir } from "./task/artifacts";

package/src/core/tools/truncate.ts

@@ -11,7 +11,7 @@
 
 export const DEFAULT_MAX_LINES = 2000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
-export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+export const DEFAULT_MAX_COLUMN = 1024; // Max chars per grep match line
 
 export interface TruncationResult {
 	/** The truncated content */
@@ -282,7 +282,7 @@ export function truncateStringToBytesFromStart(str: string, maxBytes: number): {
  */
 export function truncateLine(
 	line: string,
-	maxChars: number = GREP_MAX_LINE_LENGTH,
+	maxChars: number = DEFAULT_MAX_COLUMN,
 ): { text: string; wasTruncated: boolean } {
 	if (line.length <= maxChars) {
 		return { text: line, wasTruncated: false };