@oh-my-pi/pi-coding-agent 13.14.0 → 13.15.2

package/src/tools/ask.ts

@@ -16,13 +16,12 @@
  */
 
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { Component } from "@oh-my-pi/pi-tui";
-import { TERMINAL, Text } from "@oh-my-pi/pi-tui";
+import { type Component, Container, Markdown, renderInlineMarkdown, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { type Theme, theme } from "../modes/theme/theme";
+import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
 import { renderStatusLine } from "../tui";
 import type { ToolSession } from ".";
@@ -574,10 +573,13 @@ interface AskRenderArgs {
 export const askToolRenderer = {
 	renderCall(args: AskRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const label = formatTitle("Ask", uiTheme);
+		const mdTheme = getMarkdownTheme();
+		const accentStyle = { color: (t: string) => uiTheme.fg("accent", t) };
 
 		// Multi-part questions
 		if (args.questions && args.questions.length > 0) {
-			let text = `${label} ${uiTheme.fg("muted", `${args.questions.length} questions`)}`;
+			const container = new Container();
+			container.addChild(new Text(`${label} ${uiTheme.fg("muted", `${args.questions.length} questions`)}`, 0, 0));
 
 			for (let i = 0; i < args.questions.length; i++) {
 				const q = args.questions[i];
@@ -585,25 +587,29 @@ export const askToolRenderer = {
 				const qBranch = isLastQ ? uiTheme.tree.last : uiTheme.tree.branch;
 				const continuation = isLastQ ? " " : uiTheme.tree.vertical;
 
-				// Question line with metadata
 				const meta: string[] = [];
 				if (q.multi) meta.push("multi");
 				if (q.options?.length) meta.push(`options:${q.options.length}`);
 				const metaStr = meta.length > 0 ? uiTheme.fg("dim", ` · ${meta.join(" · ")}`) : "";
 
-				text += `\n ${uiTheme.fg("dim", qBranch)} ${uiTheme.fg("dim", `[${q.id}]`)} ${uiTheme.fg("accent", q.question)}${metaStr}`;
+				container.addChild(
+					new Text(` ${uiTheme.fg("dim", qBranch)} ${uiTheme.fg("dim", `[${q.id}]`)}${metaStr}`, 0, 0),
+				);
+				container.addChild(new Markdown(q.question, 3, 0, mdTheme, accentStyle));
 
-				// Options under question
 				if (q.options?.length) {
+					let optText = "";
 					for (let j = 0; j < q.options.length; j++) {
 						const opt = q.options[j];
 						const isLastOpt = j === q.options.length - 1;
 						const optBranch = isLastOpt ? uiTheme.tree.last : uiTheme.tree.branch;
-						text += `\n ${uiTheme.fg("dim", continuation)}   ${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${uiTheme.fg("muted", opt.label)}`;
+						const optLabel = renderInlineMarkdown(opt.label, mdTheme, t => uiTheme.fg("muted", t));
+						optText += `\n ${uiTheme.fg("dim", continuation)}   ${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${optLabel}`;
 					}
+					container.addChild(new Text(optText, 0, 0));
 				}
 			}
-			return new Text(text, 0, 0);
+			return container;
 		}
 
 		// Single question
@@ -611,22 +617,26 @@ export const askToolRenderer = {
 			return new Text(formatErrorMessage("No question provided", uiTheme), 0, 0);
 		}
 
-		let text = `${label} ${uiTheme.fg("accent", args.question)}`;
+		const container = new Container();
 		const meta: string[] = [];
 		if (args.multi) meta.push("multi");
 		if (args.options?.length) meta.push(`options:${args.options.length}`);
-		text += formatMeta(meta, uiTheme);
+		container.addChild(new Text(`${label}${formatMeta(meta, uiTheme)}`, 0, 0));
+		container.addChild(new Markdown(args.question, 1, 0, mdTheme, accentStyle));
 
 		if (args.options?.length) {
+			let optText = "";
 			for (let i = 0; i < args.options.length; i++) {
 				const opt = args.options[i];
 				const isLast = i === args.options.length - 1;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${uiTheme.fg("muted", opt.label)}`;
+				const optLabel = renderInlineMarkdown(opt.label, mdTheme, t => uiTheme.fg("muted", t));
+				optText += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("dim", uiTheme.checkbox.unchecked)} ${optLabel}`;
 			}
+			container.addChild(new Text(optText, 0, 0));
 		}
 
-		return new Text(text, 0, 0);
+		return container;
 	},
 
 	renderResult(
@@ -635,6 +645,9 @@ export const askToolRenderer = {
 		uiTheme: Theme,
 	): Component {
 		const { details } = result;
+		const mdTheme = getMarkdownTheme();
+		const accentStyle = { color: (t: string) => uiTheme.fg("accent", t) };
+
 		if (!details) {
 			const txt = result.content[0];
 			const fallback = txt?.type === "text" && txt.text ? txt.text : "";
@@ -655,7 +668,8 @@ export const askToolRenderer = {
 				},
 				uiTheme,
 			);
-			let text = header;
+			const container = new Container();
+			container.addChild(new Text(header, 0, 0));
 
 			for (let i = 0; i < details.results.length; i++) {
 				const r = details.results[i];
@@ -667,22 +681,31 @@ export const askToolRenderer = {
 					? uiTheme.styledSymbol("status.success", "success")
 					: uiTheme.styledSymbol("status.warning", "warning");
 
-				text += `\n ${uiTheme.fg("dim", branch)} ${statusIcon} ${uiTheme.fg("dim", `[${r.id}]`)} ${uiTheme.fg("accent", r.question)}`;
+				container.addChild(
+					new Text(` ${uiTheme.fg("dim", branch)} ${statusIcon} ${uiTheme.fg("dim", `[${r.id}]`)}`, 0, 0),
+				);
+				container.addChild(new Markdown(r.question, 3, 0, mdTheme, accentStyle));
 
+				let answerText = "";
 				if (r.customInput) {
-					text += `\n${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", r.customInput)}`;
+					answerText = `${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", r.customInput)}`;
 				} else if (r.selectedOptions.length > 0) {
 					for (let j = 0; j < r.selectedOptions.length; j++) {
 						const isLast = j === r.selectedOptions.length - 1;
 						const optBranch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-						text += `\n${continuation}${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${uiTheme.fg("toolOutput", r.selectedOptions[j])}`;
+						const selectedLabel = renderInlineMarkdown(r.selectedOptions[j], mdTheme, t =>
+							uiTheme.fg("toolOutput", t),
+						);
+						answerText += `\n${continuation}${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${selectedLabel}`;
 					}
 				} else {
-					text += `\n${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
+					answerText = `${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
+				}
+				if (answerText) {
+					container.addChild(new Text(answerText, 0, 0));
 				}
 			}
-
-			return new Text(text, 0, 0);
+			return container;
 		}
 
 		// Single question result
@@ -693,25 +716,28 @@ export const askToolRenderer = {
 		}
 
 		const hasSelection = details.customInput || (details.selectedOptions && details.selectedOptions.length > 0);
-		const header = renderStatusLine(
-			{ icon: hasSelection ? "success" : "warning", title: "Ask", description: details.question },
-			uiTheme,
-		);
-
-		let text = header;
+		const header = renderStatusLine({ icon: hasSelection ? "success" : "warning", title: "Ask" }, uiTheme);
+		const container = new Container();
+		container.addChild(new Text(header, 0, 0));
+		container.addChild(new Markdown(details.question, 1, 0, mdTheme, accentStyle));
 
+		let answerText = "";
 		if (details.customInput) {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", details.customInput)}`;
+			answerText = ` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", details.customInput)}`;
 		} else if (details.selectedOptions && details.selectedOptions.length > 0) {
 			for (let i = 0; i < details.selectedOptions.length; i++) {
 				const isLast = i === details.selectedOptions.length - 1;
 				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${uiTheme.fg("toolOutput", details.selectedOptions[i])}`;
+				const selectedLabel = renderInlineMarkdown(details.selectedOptions[i], mdTheme, t =>
+					uiTheme.fg("toolOutput", t),
+				);
+				answerText += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${selectedLabel}`;
 			}
 		} else {
-			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
+			answerText = ` ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
 		}
+		container.addChild(new Text(answerText, 0, 0));
 
-		return new Text(text, 0, 0);
+		return container;
 	},
 };

package/src/tools/bash-interactive.ts

@@ -295,7 +295,6 @@ export async function runInteractiveBashPty(
 	},
 ): Promise<BashInteractiveResult> {
 	const sink = new OutputSink({ artifactPath: options.artifactPath, artifactId: options.artifactId });
-	let pendingChunks = Promise.resolve();
 	const result = await ui.custom<BashInteractiveResult>(
 		(tui, uiTheme, _keybindings, done) => {
 			const session = new PtySession();
@@ -309,7 +308,6 @@ export async function runInteractiveBashPty(
 				tui.requestRender();
 				void (async () => {
 					await component.flushOutput();
-					await pendingChunks;
 					const summary = await sink.dump();
 					done({
 						exitCode: run.exitCode,
@@ -362,15 +360,13 @@ export async function runInteractiveBashPty(
 						if (finished || err || !chunk) return;
 						component.appendOutput(chunk);
 						const normalizedChunk = normalizeCaptureChunk(chunk);
-						pendingChunks = pendingChunks.then(() => sink.push(normalizedChunk)).catch(() => {});
+						sink.push(normalizedChunk);
 						tui.requestRender();
 					},
 				)
 				.then(finalize)
 				.catch(error => {
-					pendingChunks = pendingChunks
-						.then(() => sink.push(`PTY error: ${error instanceof Error ? error.message : String(error)}\n`))
-						.catch(() => {});
+					sink.push(`PTY error: ${error instanceof Error ? error.message : String(error)}\n`);
 					finalize({ exitCode: undefined, cancelled: false, timedOut: false });
 				});
 			return component;

package/src/tools/bash-interceptor.ts

@@ -5,45 +5,7 @@
  * this interceptor provides helpful error messages directing them to use
  * the specialized tools instead.
  */
-import type { BashInterceptorRule } from "../config/settings-schema";
-
-export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
-	{
-		pattern: "^\\s*(cat|head|tail|less|more)\\s+",
-		tool: "read",
-		message: "Use the `read` tool instead of cat/head/tail. It provides better context and handles binary files.",
-	},
-	{
-		pattern: "^\\s*(grep|rg|ripgrep|ag|ack)\\s+",
-		tool: "grep",
-		message: "Use the `grep` tool instead of grep/rg. It respects .gitignore and provides structured output.",
-	},
-	{
-		pattern: "^\\s*(find|fd|locate)\\s+.*(-name|-iname|-type|--type|-glob)",
-		tool: "find",
-		message: "Use the `find` tool instead of find/fd. It respects .gitignore and is faster for glob patterns.",
-	},
-	{
-		pattern: "^\\s*sed\\s+(-i|--in-place)",
-		tool: "edit",
-		message: "Use the `edit` tool instead of sed -i. It provides diff preview and fuzzy matching.",
-	},
-	{
-		pattern: "^\\s*perl\\s+.*-[pn]?i",
-		tool: "edit",
-		message: "Use the `edit` tool instead of perl -i. It provides diff preview and fuzzy matching.",
-	},
-	{
-		pattern: "^\\s*awk\\s+.*-i\\s+inplace",
-		tool: "edit",
-		message: "Use the `edit` tool instead of awk -i inplace. It provides diff preview and fuzzy matching.",
-	},
-	{
-		pattern: "^\\s*(echo|printf|cat\\s*<<)\\s+.*[^|]>\\s*\\S",
-		tool: "write",
-		message: "Use the `write` tool instead of echo/cat redirection. It handles encoding and provides confirmation.",
-	},
-];
+import { type BashInterceptorRule, DEFAULT_BASH_INTERCEPTOR_RULES } from "../config/settings-schema";
 
 export interface InterceptionResult {
 	/** If true, the bash command should be blocked */

package/src/tools/bash-skill-urls.ts

@@ -131,7 +131,7 @@ async function resolveInternalUrlToPath(
 		return resolvedLocalPath;
 	}
 
-	if (!internalRouter || !internalRouter.canHandle(url)) {
+	if (!internalRouter?.canHandle(url)) {
 		throw new ToolError(
 			`Cannot resolve ${scheme}:// URL in bash command: ${url}\n` +
 				"Internal URL router is unavailable for this protocol in the current session.",

package/src/tools/browser.ts

@@ -564,7 +564,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		if (this.#page && !this.#page.isClosed()) {
 			return this.#page;
 		}
-		if (!this.#browser || !this.#browser.isConnected()) {
+		if (!this.#browser?.isConnected()) {
 			return this.#resetBrowser(params);
 		}
 		this.#page = await this.#browser.newPage();

package/src/tools/gemini-image.ts

@@ -287,7 +287,7 @@ async function loadImageFromUrl(imageUrl: string, signal?: AbortSignal): Promise
 		throw new Error(`Image download failed (${response.status}): ${rawText}`);
 	}
 	const contentType = response.headers.get("content-type")?.split(";")[0];
-	if (!contentType || !contentType.startsWith("image/")) {
+	if (!contentType?.startsWith("image/")) {
 		throw new Error(`Unsupported image type from URL: ${imageUrl}`);
 	}
 	const buffer = await response.bytes();

package/src/tools/python.ts

@@ -289,8 +289,8 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 				const executorOptions: PythonExecutorOptions = {
 					...baseExecutorOptions,
 					reset: isFirstCell ? reset : false,
-					onChunk: async chunk => {
-						await outputSink!.push(chunk);
+					onChunk: chunk => {
+						outputSink!.push(chunk);
 					},
 				};
 

package/src/tools/resolve.ts

@@ -54,7 +54,7 @@ export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolD
 	): Promise<AgentToolResult<ResolveToolDetails>> {
 		return untilAborted(signal, async () => {
 			const store = this.session.pendingActionStore;
-			if (!store || !store.hasPending) {
+			if (!store?.hasPending) {
 				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
 			}
 

package/src/utils/child-process.ts

@@ -0,0 +1,88 @@
+import type { ChildProcess } from "node:child_process";
+
+const EXIT_STDIO_GRACE_MS = 100;
+
+/**
+ * Wait for a child process to terminate without hanging on inherited stdio handles.
+ *
+ * Daemonized descendants can inherit the child's stdout/stderr pipe handles. In that
+ * case the child emits `exit`, but `close` can hang forever even though the original
+ * process is already gone. We wait briefly for stdio to end, then forcibly stop
+ * tracking the inherited handles.
+ */
+export function waitForChildProcess(child: ChildProcess): Promise<number | null> {
+	const { promise, resolve, reject } = Promise.withResolvers<number | null>();
+
+	let settled = false;
+	let exited = false;
+	let exitCode: number | null = null;
+	let postExitTimer: NodeJS.Timeout | undefined;
+	let stdoutEnded = child.stdout === null;
+	let stderrEnded = child.stderr === null;
+
+	const cleanup = () => {
+		if (postExitTimer) {
+			clearTimeout(postExitTimer);
+			postExitTimer = undefined;
+		}
+		child.removeListener("error", onError);
+		child.removeListener("exit", onExit);
+		child.removeListener("close", onClose);
+		child.stdout?.removeListener("end", onStdoutEnd);
+		child.stderr?.removeListener("end", onStderrEnd);
+	};
+
+	const finalize = (code: number | null) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		child.stdout?.destroy();
+		child.stderr?.destroy();
+		resolve(code);
+	};
+
+	const maybeFinalizeAfterExit = () => {
+		if (!exited || settled) return;
+		if (stdoutEnded && stderrEnded) {
+			finalize(exitCode);
+		}
+	};
+
+	const onStdoutEnd = () => {
+		stdoutEnded = true;
+		maybeFinalizeAfterExit();
+	};
+
+	const onStderrEnd = () => {
+		stderrEnded = true;
+		maybeFinalizeAfterExit();
+	};
+
+	const onError = (err: Error) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		reject(err);
+	};
+
+	const onExit = (code: number | null) => {
+		exited = true;
+		exitCode = code;
+		maybeFinalizeAfterExit();
+		if (!settled) {
+			postExitTimer = setTimeout(() => finalize(code), EXIT_STDIO_GRACE_MS);
+		}
+	};
+
+	const onClose = (code: number | null) => {
+		finalize(code);
+	};
+
+	child.stdout?.once("end", onStdoutEnd);
+	child.stderr?.once("end", onStderrEnd);
+	child.once("error", onError);
+	child.once("exit", onExit);
+	child.once("close", onClose);
+
+	return promise;
+}