@oh-my-pi/pi-coding-agent 3.25.0 → 3.31.0

package/src/core/tools/find.ts

@@ -1,28 +1,16 @@
-import { existsSync, type Stats, statSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { globSync } from "glob";
 import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import findDescription from "../../prompts/tools/find.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResultOptions } from "../custom-tools/types";
-import { untilAborted } from "../utils";
+import { ScopeSignal, untilAborted } from "../utils";
 import type { ToolSession } from "./index";
 import { resolveToCwd } from "./path-utils";
-import {
-	formatCount,
-	formatEmptyMessage,
-	formatErrorMessage,
-	formatExpandHint,
-	formatMeta,
-	formatMoreItems,
-	formatScope,
-	formatTruncationSuffix,
-	PREVIEW_LIMITS,
-} from "./render-utils";
+import { createToolUIKit, PREVIEW_LIMITS } from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
@@ -56,6 +44,53 @@ export interface FindToolDetails {
 	error?: string;
 }
 
+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 };
+}
+
 export function createFindTool(session: ToolSession): AgentTool<typeof findSchema> {
 	return {
 		name: "find",
@@ -126,22 +161,43 @@ export function createFindTool(session: ToolSession): AgentTool<typeof findSchem
 				// Include .gitignore files (root + nested) so fd respects them even outside git repos
 				const gitignoreFiles = new Set<string>();
 				const rootGitignore = path.join(searchPath, ".gitignore");
-				if (existsSync(rootGitignore)) {
+				if (await Bun.file(rootGitignore).exists()) {
 					gitignoreFiles.add(rootGitignore);
 				}
 
 				try {
-					const nestedGitignores = globSync("**/.gitignore", {
-						cwd: searchPath,
-						dot: true,
-						absolute: true,
-						ignore: ["**/node_modules/**", "**/.git/**"],
-					});
-					for (const file of nestedGitignores) {
+					const gitignoreArgs = [
+						"--hidden",
+						"--no-ignore",
+						"--type",
+						"f",
+						"--name",
+						".gitignore",
+						"--exclude",
+						".git",
+						"--exclude",
+						"node_modules",
+						"--absolute-path",
+						searchPath,
+					];
+					const { stdout: gitignoreStdout, aborted: gitignoreAborted } = await captureCommandOutput(
+						fdPath,
+						gitignoreArgs,
+						signal,
+					);
+					if (gitignoreAborted) {
+						throw new Error("Operation aborted");
+					}
+					for (const rawLine of gitignoreStdout.split("\n")) {
+						const file = rawLine.trim();
+						if (!file) continue;
 						gitignoreFiles.add(file);
 					}
-				} catch {
-					// Ignore glob errors
+				} catch (err) {
+					if (signal?.aborted) {
+						throw err instanceof Error ? err : new Error("Operation aborted");
+					}
+					// Ignore lookup errors
 				}
 
 				for (const gitignorePath of gitignoreFiles) {
@@ -152,16 +208,16 @@ export function createFindTool(session: ToolSession): AgentTool<typeof findSchem
 				args.push(effectivePattern, searchPath);
 
 				// Run fd
-				const result = Bun.spawnSync([fdPath, ...args], {
-					stdin: "ignore",
-					stdout: "pipe",
-					stderr: "pipe",
-				});
+				const { stdout, stderr, exitCode, aborted } = await captureCommandOutput(fdPath, args, signal);
+
+				if (aborted) {
+					throw new Error("Operation aborted");
+				}
 
-				const output = result.stdout.toString().trim();
+				const output = stdout.trim();
 
-				if (result.exitCode !== 0) {
-					const errorMsg = result.stderr.toString().trim() || `fd exited with code ${result.exitCode}`;
+				if (exitCode !== 0) {
+					const errorMsg = stderr.trim() || `fd exited with code ${exitCode ?? -1}`;
 					// fd returns non-zero for some errors but may still have partial output
 					if (!output) {
 						throw new Error(errorMsg);
@@ -180,6 +236,7 @@ export function createFindTool(session: ToolSession): AgentTool<typeof findSchem
 				const mtimes: number[] = [];
 
 				for (const rawLine of lines) {
+					signal?.throwIfAborted();
 					const line = rawLine.replace(/\r$/, "").trim();
 					if (!line) {
 						continue;
@@ -197,23 +254,25 @@ export function createFindTool(session: ToolSession): AgentTool<typeof findSchem
 						relativePath += "/";
 					}
 
-					relativized.push(relativePath);
-
-					// Collect mtime if sorting is requested
+					// When sorting by mtime, keep files that fail to stat with mtime 0
 					if (shouldSortByMtime) {
 						try {
 							const fullPath = path.join(searchPath, relativePath);
-							const stat: Stats = statSync(fullPath);
+							const stat = await Bun.file(fullPath).stat();
+							relativized.push(relativePath);
 							mtimes.push(stat.mtimeMs);
 						} catch {
+							relativized.push(relativePath);
 							mtimes.push(0);
 						}
+					} else {
+						relativized.push(relativePath);
 					}
 				}
 
 				// Sort by mtime if requested (most recent first)
 				if (shouldSortByMtime && relativized.length > 0) {
-					const indexed = relativized.map((path, idx) => ({ path, mtime: mtimes[idx] || 0 }));
+					const indexed = relativized.map((path, idx) => ({ path, mtime: mtimes[idx] }));
 					indexed.sort((a, b) => b.mtime - a.mtime);
 					relativized.length = 0;
 					relativized.push(...indexed.map((item) => item.path));
@@ -279,7 +338,8 @@ const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
 export const findToolRenderer = {
 	renderCall(args: FindRenderArgs, uiTheme: Theme): Component {
-		const label = uiTheme.fg("toolTitle", uiTheme.bold("Find"));
+		const ui = createToolUIKit(uiTheme);
+		const label = ui.title("Find");
 		let text = `${label} ${uiTheme.fg("accent", args.pattern || "*")}`;
 
 		const meta: string[] = [];
@@ -289,7 +349,7 @@ export const findToolRenderer = {
 		if (args.sortByMtime) meta.push("sort:mtime");
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 
-		text += formatMeta(meta, uiTheme);
+		text += ui.meta(meta);
 
 		return new Text(text, 0, 0);
 	},
@@ -299,10 +359,11 @@ export const findToolRenderer = {
 		{ expanded }: RenderResultOptions,
 		uiTheme: Theme,
 	): Component {
+		const ui = createToolUIKit(uiTheme);
 		const details = result.details;
 
 		if (details?.error) {
-			return new Text(formatErrorMessage(details.error, uiTheme), 0, 0);
+			return new Text(ui.errorMessage(details.error), 0, 0);
 		}
 
 		const hasDetailedData = details?.fileCount !== undefined;
@@ -310,7 +371,7 @@ export const findToolRenderer = {
 
 		if (!hasDetailedData) {
 			if (!textContent || textContent.includes("No files matching") || textContent.trim() === "") {
-				return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+				return new Text(ui.emptyMessage("No files found"), 0, 0);
 			}
 
 			const lines = textContent.split("\n").filter((l) => l.trim());
@@ -320,8 +381,8 @@ export const findToolRenderer = {
 			const hasMore = remaining > 0;
 
 			const icon = uiTheme.styledSymbol("status.success", "success");
-			const summary = formatCount("file", lines.length);
-			const expandHint = formatExpandHint(expanded, hasMore, uiTheme);
+			const summary = ui.count("file", lines.length);
+			const expandHint = ui.expandHint(expanded, hasMore);
 			let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
 
 			for (let i = 0; i < displayLines.length; i++) {
@@ -330,7 +391,7 @@ export const findToolRenderer = {
 				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", displayLines[i])}`;
 			}
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "file", uiTheme))}`;
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", ui.moreItems(remaining, "file"))}`;
 			}
 			return new Text(text, 0, 0);
 		}
@@ -340,17 +401,17 @@ export const findToolRenderer = {
 		const files = details?.files ?? [];
 
 		if (fileCount === 0) {
-			return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+			return new Text(ui.emptyMessage("No files found"), 0, 0);
 		}
 
 		const icon = uiTheme.styledSymbol("status.success", "success");
-		const summaryText = formatCount("file", fileCount);
-		const scopeLabel = formatScope(details?.scopePath, uiTheme);
+		const summaryText = ui.count("file", fileCount);
+		const scopeLabel = ui.scope(details?.scopePath);
 		const maxFiles = expanded ? files.length : Math.min(files.length, COLLAPSED_LIST_LIMIT);
 		const hasMoreFiles = files.length > maxFiles;
-		const expandHint = formatExpandHint(expanded, hasMoreFiles, uiTheme);
+		const expandHint = ui.expandHint(expanded, hasMoreFiles);
 
-		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(truncated, uiTheme)}${scopeLabel}${expandHint}`;
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${ui.truncationSuffix(truncated)}${scopeLabel}${expandHint}`;
 
 		const truncationReasons: string[] = [];
 		if (details?.resultLimitReached) {
@@ -380,7 +441,7 @@ export const findToolRenderer = {
 				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
 				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
 					"muted",
-					formatMoreItems(files.length - maxFiles, "file", uiTheme),
+					ui.moreItems(files.length - maxFiles, "file"),
 				)}`;
 			}
 		}

package/src/core/tools/gemini-image.ts

@@ -1,8 +1,7 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { type Static, Type } from "@sinclair/typebox";
+import { nanoid } from "nanoid";
 import geminiImageDescription from "../../prompts/tools/gemini-image.md" with { type: "text" };
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
 import type { CustomTool } from "../custom-tools/types";
@@ -311,14 +310,18 @@ function getExtensionForMime(mimeType: string): string {
 	return map[mimeType] ?? "png";
 }
 
-function saveImageToTemp(image: InlineImageData): string {
+async function saveImageToTemp(image: InlineImageData): Promise<string> {
 	const ext = getExtensionForMime(image.mimeType);
-	const filename = `omp-image-${crypto.randomUUID()}.${ext}`;
+	const filename = `omp-image-${nanoid()}.${ext}`;
 	const filepath = join(tmpdir(), filename);
-	fs.writeFileSync(filepath, Buffer.from(image.data, "base64"));
+	await Bun.write(filepath, Buffer.from(image.data, "base64"));
 	return filepath;
 }
 
+async function saveImagesToTemp(images: InlineImageData[]): Promise<string[]> {
+	return Promise.all(images.map(saveImageToTemp));
+}
+
 function buildResponseSummary(model: string, imagePaths: string[], responseText: string | undefined): string {
 	const lines = [`Model: ${model}`, `Generated ${imagePaths.length} image(s):`];
 	for (const p of imagePaths) {
@@ -356,27 +359,9 @@ function combineParts(response: GeminiGenerateContentResponse): GeminiPart[] {
 	return parts;
 }
 
-function createAbortController(
-	signal: AbortSignal | undefined,
-	timeoutSeconds: number,
-): { controller: AbortController; cleanup: () => void } {
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
-
-	let abortListener: (() => void) | undefined;
-	if (signal) {
-		abortListener = () => controller.abort(signal.reason);
-		signal.addEventListener("abort", abortListener, { once: true });
-	}
-
-	const cleanup = () => {
-		clearTimeout(timeout);
-		if (abortListener && signal) {
-			signal.removeEventListener("abort", abortListener);
-		}
-	};
-
-	return { controller, cleanup };
+function createRequestSignal(signal: AbortSignal | undefined, timeoutSeconds: number): AbortSignal {
+	const timeoutSignal = AbortSignal.timeout(timeoutSeconds * 1000);
+	return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 }
 
 export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageToolDetails> = {
@@ -404,118 +389,28 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 			}
 
 			const timeoutSeconds = params.timeout_seconds ?? DEFAULT_TIMEOUT_SECONDS;
-			const { controller, cleanup } = createAbortController(signal, timeoutSeconds);
-
-			try {
-				if (provider === "openrouter") {
-					const contentParts: OpenRouterContentPart[] = [{ type: "text", text: params.prompt }];
-					for (const image of resolvedImages) {
-						contentParts.push({ type: "image_url", image_url: { url: toDataUrl(image) } });
-					}
-
-					const requestBody = {
-						model: resolvedModel,
-						messages: [{ role: "user" as const, content: contentParts }],
-					};
-
-					const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
-						method: "POST",
-						headers: {
-							"Content-Type": "application/json",
-							Authorization: `Bearer ${apiKey.apiKey}`,
-						},
-						body: JSON.stringify(requestBody),
-						signal: controller.signal,
-					});
-
-					const rawText = await response.text();
-					if (!response.ok) {
-						let message = rawText;
-						try {
-							const parsed = JSON.parse(rawText) as { error?: { message?: string } };
-							message = parsed.error?.message ?? message;
-						} catch {
-							// Keep raw text.
-						}
-						throw new Error(`OpenRouter image request failed (${response.status}): ${message}`);
-					}
-
-					const data = JSON.parse(rawText) as OpenRouterResponse;
-					const message = data.choices?.[0]?.message;
-					const responseText = collectOpenRouterResponseText(message);
-					const imageUrls = extractOpenRouterImageUrls(message);
-					const inlineImages: InlineImageData[] = [];
-					for (const imageUrl of imageUrls) {
-						inlineImages.push(await loadImageFromUrl(imageUrl, controller.signal));
-					}
-
-					if (inlineImages.length === 0) {
-						const messageText = responseText ? `\n\n${responseText}` : "";
-						return {
-							content: [{ type: "text", text: `No image data returned.${messageText}` }],
-							details: {
-								provider,
-								model: resolvedModel,
-								imageCount: 0,
-								imagePaths: [],
-								images: [],
-								responseText,
-							},
-						};
-					}
-
-					const imagePaths = inlineImages.map(saveImageToTemp);
-
-					return {
-						content: [{ type: "text", text: buildResponseSummary(resolvedModel, imagePaths, responseText) }],
-						details: {
-							provider,
-							model: resolvedModel,
-							imageCount: inlineImages.length,
-							imagePaths,
-							images: inlineImages,
-							responseText,
-						},
-					};
-				}
+			const requestSignal = createRequestSignal(signal, timeoutSeconds);
 
-				const parts = [] as Array<{ text?: string; inlineData?: InlineImageData }>;
+			if (provider === "openrouter") {
+				const contentParts: OpenRouterContentPart[] = [{ type: "text", text: params.prompt }];
 				for (const image of resolvedImages) {
-					parts.push({ inlineData: image });
-				}
-				parts.push({ text: params.prompt });
-
-				const generationConfig: {
-					responseModalities: GeminiResponseModality[];
-					imageConfig?: { aspectRatio?: string; imageSize?: string };
-				} = {
-					responseModalities: ["Image"],
-				};
-
-				if (params.aspect_ratio || params.image_size) {
-					generationConfig.imageConfig = {
-						aspectRatio: params.aspect_ratio,
-						imageSize: params.image_size,
-					};
+					contentParts.push({ type: "image_url", image_url: { url: toDataUrl(image) } });
 				}
 
 				const requestBody = {
-					contents: [{ role: "user" as const, parts }],
-					generationConfig,
+					model: resolvedModel,
+					messages: [{ role: "user" as const, content: contentParts }],
 				};
 
-				const response = await fetch(
-					`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`,
-					{
-						method: "POST",
-						headers: {
-							"Content-Type": "application/json",
-							"x-goog-api-key": apiKey.apiKey,
-						},
-						body: JSON.stringify(requestBody),
-						signal: controller.signal,
+				const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${apiKey.apiKey}`,
 					},
-				);
+					body: JSON.stringify(requestBody),
+					signal: requestSignal,
+				});
 
 				const rawText = await response.text();
 				if (!response.ok) {
@@ -526,51 +421,137 @@ export const geminiImageTool: CustomTool<typeof geminiImageSchema, GeminiImageTo
 					} catch {
 						// Keep raw text.
 					}
-					throw new Error(`Gemini image request failed (${response.status}): ${message}`);
+					throw new Error(`OpenRouter image request failed (${response.status}): ${message}`);
 				}
 
-				const data = JSON.parse(rawText) as GeminiGenerateContentResponse;
-				const responseParts = combineParts(data);
-				const responseText = collectResponseText(responseParts);
-				const inlineImages = collectInlineImages(responseParts);
+				const data = JSON.parse(rawText) as OpenRouterResponse;
+				const message = data.choices?.[0]?.message;
+				const responseText = collectOpenRouterResponseText(message);
+				const imageUrls = extractOpenRouterImageUrls(message);
+				const inlineImages: InlineImageData[] = [];
+				for (const imageUrl of imageUrls) {
+					inlineImages.push(await loadImageFromUrl(imageUrl, requestSignal));
+				}
 
 				if (inlineImages.length === 0) {
-					const blocked = data.promptFeedback?.blockReason
-						? `Blocked: ${data.promptFeedback.blockReason}`
-						: "No image data returned.";
+					const messageText = responseText ? `\n\n${responseText}` : "";
 					return {
-						content: [{ type: "text", text: `${blocked}${responseText ? `\n\n${responseText}` : ""}` }],
+						content: [{ type: "text", text: `No image data returned.${messageText}` }],
 						details: {
 							provider,
-							model,
+							model: resolvedModel,
 							imageCount: 0,
 							imagePaths: [],
 							images: [],
 							responseText,
-							promptFeedback: data.promptFeedback,
-							usage: data.usageMetadata,
 						},
 					};
 				}
 
-				const imagePaths = inlineImages.map(saveImageToTemp);
+				const imagePaths = await saveImagesToTemp(inlineImages);
 
 				return {
-					content: [{ type: "text", text: buildResponseSummary(model, imagePaths, responseText) }],
+					content: [{ type: "text", text: buildResponseSummary(resolvedModel, imagePaths, responseText) }],
 					details: {
 						provider,
-						model,
+						model: resolvedModel,
 						imageCount: inlineImages.length,
 						imagePaths,
 						images: inlineImages,
 						responseText,
+					},
+				};
+			}
+
+			const parts = [] as Array<{ text?: string; inlineData?: InlineImageData }>;
+			for (const image of resolvedImages) {
+				parts.push({ inlineData: image });
+			}
+			parts.push({ text: params.prompt });
+
+			const generationConfig: {
+				responseModalities: GeminiResponseModality[];
+				imageConfig?: { aspectRatio?: string; imageSize?: string };
+			} = {
+				responseModalities: ["Image"],
+			};
+
+			if (params.aspect_ratio || params.image_size) {
+				generationConfig.imageConfig = {
+					aspectRatio: params.aspect_ratio,
+					imageSize: params.image_size,
+				};
+			}
+
+			const requestBody = {
+				contents: [{ role: "user" as const, parts }],
+				generationConfig,
+			};
+
+			const response = await fetch(
+				`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`,
+				{
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						"x-goog-api-key": apiKey.apiKey,
+					},
+					body: JSON.stringify(requestBody),
+					signal: requestSignal,
+				},
+			);
+
+			const rawText = await response.text();
+			if (!response.ok) {
+				let message = rawText;
+				try {
+					const parsed = JSON.parse(rawText) as { error?: { message?: string } };
+					message = parsed.error?.message ?? message;
+				} catch {
+					// Keep raw text.
+				}
+				throw new Error(`Gemini image request failed (${response.status}): ${message}`);
+			}
+
+			const data = JSON.parse(rawText) as GeminiGenerateContentResponse;
+			const responseParts = combineParts(data);
+			const responseText = collectResponseText(responseParts);
+			const inlineImages = collectInlineImages(responseParts);
+
+			if (inlineImages.length === 0) {
+				const blocked = data.promptFeedback?.blockReason
+					? `Blocked: ${data.promptFeedback.blockReason}`
+					: "No image data returned.";
+				return {
+					content: [{ type: "text", text: `${blocked}${responseText ? `\n\n${responseText}` : ""}` }],
+					details: {
+						provider,
+						model,
+						imageCount: 0,
+						imagePaths: [],
+						images: [],
+						responseText,
 						promptFeedback: data.promptFeedback,
 						usage: data.usageMetadata,
 					},
 				};
-			} finally {
-				cleanup();
 			}
+
+			const imagePaths = await saveImagesToTemp(inlineImages);
+
+			return {
+				content: [{ type: "text", text: buildResponseSummary(model, imagePaths, responseText) }],
+				details: {
+					provider,
+					model,
+					imageCount: inlineImages.length,
+					imagePaths,
+					images: inlineImages,
+					responseText,
+					promptFeedback: data.promptFeedback,
+					usage: data.usageMetadata,
+				},
+			};
 		});
 	},
 };