@oh-my-pi/pi-coding-agent 8.12.2 → 8.12.4

package/src/tools/ask.ts

@@ -12,7 +12,7 @@
  *   - Users will always be able to select "Other" to provide custom text input
  *   - Use multi: true to allow multiple answers to be selected for a question
  *   - Use recommended: <index> to mark the default option; "(Recommended)" suffix is added automatically
- *   - Questions time out after 30 seconds and auto-select the recommended option
+ *   - Questions may time out and auto-select the recommended option (configurable, disabled in plan mode)
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -23,6 +23,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
 import { renderStatusLine } from "../tui";
+import { detectNotificationProtocol, isNotificationSuppressed, sendNotification } from "../utils/terminal-notify";
 import type { ToolSession } from ".";
 import { ToolUIKit } from "./render-utils";
 
@@ -77,7 +78,8 @@ export interface AskToolDetails {
 
 const OTHER_OPTION = "Other (type your own)";
 const RECOMMENDED_SUFFIX = " (Recommended)";
-const ASK_TIMEOUT_MS = 30000;
+/** Default timeout in milliseconds (used when settings unavailable) */
+const DEFAULT_ASK_TIMEOUT_MS = 30000;
 
 function getDoneOptionLabel(): string {
 	return `${theme.status.success} Done selecting`;
@@ -119,13 +121,20 @@ interface UIContext {
 	input(prompt: string): Promise<string | undefined>;
 }
 
+interface AskQuestionOptions {
+	/** Timeout in milliseconds, null/undefined to disable */
+	timeout?: number | null;
+}
+
 async function askSingleQuestion(
 	ui: UIContext,
 	question: string,
 	optionLabels: string[],
 	multi: boolean,
 	recommended?: number,
+	options?: AskQuestionOptions,
 ): Promise<SelectionResult> {
+	const timeout = options?.timeout ?? undefined;
 	const doneLabel = getDoneOptionLabel();
 	let selectedOptions: string[] = [];
 	let customInput: string | undefined;
@@ -152,11 +161,11 @@ async function askSingleQuestion(
 			const selectionStart = Date.now();
 			const choice = await ui.select(`${prefix}${question}`, opts, {
 				initialIndex: cursorIndex,
-				timeout: ASK_TIMEOUT_MS,
+				timeout: timeout ?? undefined,
 				outline: true,
 			});
 			const elapsed = Date.now() - selectionStart;
-			const timedOut = elapsed >= ASK_TIMEOUT_MS;
+			const timedOut = timeout != null && elapsed >= timeout;
 
 			if (choice === undefined || choice === doneLabel) break;
 
@@ -198,7 +207,7 @@ async function askSingleQuestion(
 	} else {
 		const displayLabels = addRecommendedSuffix(optionLabels, recommended);
 		const choice = await ui.select(question, [...displayLabels, OTHER_OPTION], {
-			timeout: ASK_TIMEOUT_MS,
+			timeout: timeout ?? undefined,
 			initialIndex: recommended,
 			outline: true,
 		});
@@ -254,8 +263,10 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	public readonly label = "Ask";
 	public readonly description: string;
 	public readonly parameters = askSchema;
+	private readonly session: ToolSession;
 
-	constructor(_session: ToolSession) {
+	constructor(session: ToolSession) {
+		this.session = session;
 		this.description = renderPromptTemplate(askDescription);
 	}
 
@@ -263,6 +274,17 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		return session.hasUI ? new AskTool(session) : null;
 	}
 
+	/** Send terminal notification when ask tool is waiting for input */
+	private sendAskNotification(): void {
+		if (isNotificationSuppressed()) return;
+
+		const method = this.session.settingsManager?.getAskNotification() ?? "auto";
+		if (method === "off") return;
+
+		const protocol = method === "auto" ? detectNotificationProtocol() : method;
+		sendNotification(protocol, "Waiting for input");
+	}
+
 	public async execute(
 		_toolCallId: string,
 		params: AskParams,
@@ -280,6 +302,14 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 
 		const { ui } = context;
 
+		// Determine timeout based on settings and plan mode
+		const planModeEnabled = this.session.getPlanModeState?.()?.enabled ?? false;
+		const settingsTimeout = this.session.settingsManager?.getAskTimeout() ?? DEFAULT_ASK_TIMEOUT_MS;
+		const timeout = planModeEnabled ? null : settingsTimeout;
+
+		// Send notification if waiting and not suppressed
+		this.sendAskNotification();
+
 		// Multi-part questions mode
 		if (params.questions && params.questions.length > 0) {
 			const results: QuestionResult[] = [];
@@ -292,6 +322,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					optionLabels,
 					q.multi ?? false,
 					q.recommended,
+					{ timeout },
 				);
 
 				results.push({
@@ -330,6 +361,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 			optionLabels,
 			multi,
 			params.recommended,
+			{ timeout },
 		);
 
 		const details: AskToolDetails = {

package/src/tools/fetch.ts

@@ -75,65 +75,6 @@ const CONVERTIBLE_EXTENSIONS = new Set([
 // Utilities
 // =============================================================================
 
-/**
- * Execute a command and return stdout
- */
-
-type WritableLike = {
-	write: (chunk: string | Uint8Array) => unknown;
-	flush?: () => unknown;
-	end?: () => unknown;
-};
-
-const textEncoder = new TextEncoder();
-
-async function writeStdin(handle: unknown, input: string | Buffer): Promise<void> {
-	if (!handle || typeof handle === "number") return;
-	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
-		const writer = (handle as WritableStream<Uint8Array>).getWriter();
-		try {
-			const chunk = typeof input === "string" ? textEncoder.encode(input) : new Uint8Array(input);
-			await writer.write(chunk);
-		} finally {
-			await writer.close();
-		}
-		return;
-	}
-
-	const sink = handle as WritableLike;
-	sink.write(input);
-	if (sink.flush) sink.flush();
-	if (sink.end) sink.end();
-}
-
-async function exec(
-	cmd: string,
-	args: string[],
-	options?: { timeout?: number; input?: string | Buffer },
-): Promise<{ stdout: string; stderr: string; ok: boolean }> {
-	const proc = ptree.cspawn([cmd, ...args], {
-		stdin: options?.input ? "pipe" : null,
-		timeout: options?.timeout ? options.timeout * 1000 : undefined,
-	});
-
-	if (options?.input) {
-		await writeStdin(proc.stdin, options.input);
-	}
-
-	const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
-	try {
-		await proc.exited;
-	} catch {
-		// Handle non-zero exit or timeout
-	}
-
-	return {
-		stdout,
-		stderr,
-		ok: proc.exitCode === 0,
-	};
-}
-
 /**
  * Check if a command exists (cross-platform)
  */
@@ -456,13 +397,20 @@ async function renderHtmlToText(
 
 	try {
 		await Bun.write(tmpFile, html);
+		const execOptions = {
+			mode: "group" as const,
+			timeout: timeout * 1000,
+			allowNonZero: true,
+			allowAbort: true,
+			stderr: "full" as const,
+		};
 
 		// Try lynx first (can't auto-install, system package)
 		const lynx = hasCommand("lynx");
 		if (lynx) {
 			const normalizedPath = tmpFile.replace(/\\/g, "/");
 			const fileUrl = normalizedPath.startsWith("/") ? `file://${normalizedPath}` : `file:///${normalizedPath}`;
-			const result = await exec("lynx", ["-dump", "-nolist", "-width", "120", fileUrl], { timeout });
+			const result = await ptree.exec(["lynx", "-dump", "-nolist", "-width", "120", fileUrl], execOptions);
 			if (result.ok) {
 				return { content: result.stdout, ok: true, method: "lynx" };
 			}
@@ -471,7 +419,7 @@ async function renderHtmlToText(
 		// Fall back to html2text (auto-install via uv/pip)
 		const html2text = await ensureTool("html2text", true);
 		if (html2text) {
-			const result = await exec(html2text, [tmpFile], { timeout });
+			const result = await ptree.exec([html2text, tmpFile], execOptions);
 			if (result.ok) {
 				return { content: result.stdout, ok: true, method: "html2text" };
 			}

package/src/tools/find.ts

@@ -1,9 +1,10 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { find as wasmFind } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { globPaths, isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
+import { isEnoent, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Static } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -169,22 +170,26 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			}
 
 			let lines: string[];
+			const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
+			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 			try {
-				lines = await globPaths(globPattern, {
-					cwd: searchPath,
-					gitignore: true,
-					dot: includeHidden,
-					signal,
-					timeoutMs: GLOB_TIMEOUT_MS,
-				});
+				const result = await untilAborted(combinedSignal, () =>
+					wasmFind({
+						pattern: globPattern,
+						path: searchPath,
+						fileType: "file",
+						hidden: includeHidden,
+					}),
+				);
+				lines = result.matches.map(match => match.path);
 			} catch (error) {
 				if (error instanceof Error && error.name === "AbortError") {
+					if (timeoutSignal.aborted && !signal?.aborted) {
+						const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
+						throw new ToolError(`find timed out after ${timeoutSeconds}s`);
+					}
 					throw new ToolAbortError();
 				}
-				if (error instanceof Error && error.name === "TimeoutError") {
-					const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
-					throw new ToolError(`glob timed out after ${timeoutSeconds}s`);
-				}
 				throw error;
 			}
 
@@ -197,13 +202,13 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 			for (const rawLine of lines) {
 				throwIfAborted(signal);
-				const line = rawLine.replace(/\r$/, "").trim();
+				const line = rawLine;
 				if (!line) {
 					continue;
 				}
 
 				const hadTrailingSlash = line.endsWith("/") || line.endsWith("\\");
-				let relativePath = line.replace(/\\/g, "/");
+				let relativePath = line;
 
 				let mtimeMs = 0;
 				let isDirectory = false;