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

package/src/tools/read.ts

@@ -2,9 +2,10 @@ import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+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 { ptree } from "@oh-my-pi/pi-utils";
+import { ptree, untilAborted } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import { CONFIG_DIR_NAME } from "../config";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -16,7 +17,6 @@ import { renderCodeCell, renderOutputBlock, renderStatusLine } from "../tui";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
-import { runRg } from "./grep";
 import { applyListLimit } from "./list-limit";
 import { LsTool } from "./ls";
 import type { OutputMeta } from "./output-meta";
@@ -49,6 +49,7 @@ const MAX_FUZZY_RESULTS = 5;
 const MAX_FUZZY_CANDIDATES = 20000;
 const MIN_BASE_SIMILARITY = 0.5;
 const MIN_FULL_SIMILARITY = 0.6;
+const GLOB_TIMEOUT_MS = 5000;
 
 function normalizePathForMatch(value: string): string {
 	return value
@@ -162,95 +163,36 @@ function similarityScore(a: string, b: string): number {
 async function listCandidateFiles(
 	searchRoot: string,
 	signal?: AbortSignal,
-	notify?: (message: string) => void,
+	_notify?: (message: string) => void,
 ): Promise<{ files: string[]; truncated: boolean; error?: string }> {
-	let rgPath: string | undefined;
-	try {
-		rgPath = await ensureTool("rg", { silent: true, notify });
-	} catch {
-		return { files: [], truncated: false, error: "rg not available" };
-	}
-
-	if (!rgPath) {
-		return { files: [], truncated: false, error: "rg not available" };
-	}
-
-	const args: string[] = [
-		"--files",
-		"--color=never",
-		"--hidden",
-		"--glob",
-		"!**/.git/**",
-		"--glob",
-		"!**/node_modules/**",
-	];
-
-	const gitignoreFiles = new Set<string>();
-	const rootGitignore = path.join(searchRoot, ".gitignore");
-	if (await Bun.file(rootGitignore).exists()) {
-		gitignoreFiles.add(rootGitignore);
-	}
-
+	let files: string[];
+	const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
+	const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 	try {
-		const gitignoreArgs = [
-			"--files",
-			"--color=never",
-			"--hidden",
-			"--no-ignore",
-			"--glob",
-			"!**/.git/**",
-			"--glob",
-			"!**/node_modules/**",
-			"--glob",
-			".gitignore",
-			searchRoot,
-		];
-		const { stdout } = await runRg(rgPath, gitignoreArgs, signal);
-		const output = stdout.trim();
-		if (output) {
-			const nestedGitignores = output
-				.split("\n")
-				.map(line => line.replace(/\r$/, "").trim())
-				.filter(line => line.length > 0);
-			for (const file of nestedGitignores) {
-				const normalized = file.replace(/\\/g, "/");
-				if (normalized.includes("/node_modules/") || normalized.includes("/.git/")) {
-					continue;
-				}
-				gitignoreFiles.add(file);
-			}
-		}
+		const result = await untilAborted(combinedSignal, () =>
+			wasmFind({
+				pattern: "**/*",
+				path: searchRoot,
+				fileType: "file",
+				hidden: true,
+			}),
+		);
+		files = result.matches.map(match => match.path);
 	} catch (error) {
-		if (error instanceof ToolAbortError) {
-			throw error;
-		}
-		// Ignore gitignore scan errors.
-	}
-
-	for (const gitignorePath of gitignoreFiles) {
-		args.push("--ignore-file", gitignorePath);
-	}
-
-	args.push(searchRoot);
-
-	const { stdout, stderr, exitCode } = await runRg(rgPath, args, signal);
-	const output = stdout.trim();
-
-	if (!output) {
-		// rg exit codes: 0 = ok, 1 = no matches, other = error
-		if (exitCode !== 0 && exitCode !== 1) {
-			return { files: [], truncated: false, error: stderr.trim() || `rg failed (exit ${exitCode})` };
+		if (error instanceof Error && error.name === "AbortError") {
+			if (timeoutSignal.aborted && !signal?.aborted) {
+				const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
+				return { files: [], truncated: false, error: `find timed out after ${timeoutSeconds}s` };
+			}
+			throw new ToolAbortError();
 		}
-		return { files: [], truncated: false };
+		const message = error instanceof Error ? error.message : String(error);
+		return { files: [], truncated: false, error: message };
 	}
 
-	const files = output
-		.split("\n")
-		.map(line => line.replace(/\r$/, "").trim())
-		.filter(line => line.length > 0);
-
-	const truncated = files.length > MAX_FUZZY_CANDIDATES;
-	const limited = truncated ? files.slice(0, MAX_FUZZY_CANDIDATES) : files;
+	const normalizedFiles = files.filter(line => line.length > 0);
+	const truncated = normalizedFiles.length > MAX_FUZZY_CANDIDATES;
+	const limited = truncated ? normalizedFiles.slice(0, MAX_FUZZY_CANDIDATES) : normalizedFiles;
 
 	return { files: limited, truncated };
 }
@@ -304,11 +246,7 @@ async function findReadPathSuggestions(
 		const cleaned = file.replace(/\r$/, "").trim();
 		if (!cleaned) continue;
 
-		const relativePath = path.isAbsolute(cleaned)
-			? cleaned.startsWith(searchRoot)
-				? cleaned.slice(searchRoot.length + 1)
-				: path.relative(searchRoot, cleaned)
-			: cleaned;
+		const relativePath = cleaned;
 
 		if (!relativePath || relativePath.startsWith("..")) {
 			continue;
@@ -363,22 +301,23 @@ async function convertWithMarkitdown(
 		return { content: "", ok: false, error: "markitdown not found (uv/pip unavailable)" };
 	}
 
-	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 ToolAbortError();
-		}
-		throw err;
+	const result = await ptree.exec([cmd, filePath], {
+		signal,
+		allowNonZero: true,
+		allowAbort: true,
+		stderr: "buffer",
+		detached: true,
+	});
+
+	if (result.exitError?.aborted) {
+		throw new ToolAbortError();
 	}
 
-	if (child.exitCode === 0 && stdout.length > 0) {
-		return { content: stdout, ok: true };
+	if (result.exitCode === 0 && result.stdout.length > 0) {
+		return { content: result.stdout, ok: true };
 	}
 
-	return { content: "", ok: false, error: child.peekStderr().trim() || "Conversion failed" };
+	return { content: "", ok: false, error: result.stderr.trim() || "Conversion failed" };
 }
 
 const readSchema = Type.Object({

package/src/utils/image-convert.ts

@@ -1,4 +1,4 @@
-import * as photon from "../vendor/photon";
+import { PhotonImage } from "@oh-my-pi/pi-natives";
 
 /**
  * Convert image to PNG format for terminal display.
@@ -14,16 +14,12 @@ export async function convertToPng(
 	}
 
 	try {
-		const image = photon.PhotonImage.new_from_byteslice(new Uint8Array(Buffer.from(base64Data, "base64")));
-		try {
-			const pngBuffer = image.get_bytes();
-			return {
-				data: Buffer.from(pngBuffer).toString("base64"),
-				mimeType: "image/png",
-			};
-		} finally {
-			image.free();
-		}
+		using image = await PhotonImage.new_from_byteslice(new Uint8Array(Buffer.from(base64Data, "base64")));
+		const pngBuffer = await image.get_bytes();
+		return {
+			data: Buffer.from(pngBuffer).toString("base64"),
+			mimeType: "image/png",
+		};
 	} catch {
 		// Conversion failed
 		return null;

package/src/utils/image-resize.ts

@@ -1,5 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import * as photon from "../vendor/photon";
+import { PhotonImage, resize, SamplingFilter } from "@oh-my-pi/pi-natives";
 
 export interface ImageResizeOptions {
 	maxWidth?: number; // Default: 2000
@@ -53,9 +53,8 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const inputBuffer = Buffer.from(img.data, "base64");
 
-	let image: ReturnType<typeof photon.PhotonImage.new_from_byteslice> | undefined;
 	try {
-		image = photon.PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
+		using image = await PhotonImage.new_from_byteslice(new Uint8Array(inputBuffer));
 
 		const originalWidth = image.get_width();
 		const originalHeight = image.get_height();
@@ -89,24 +88,19 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		}
 
 		// Helper to resize and encode in both formats, returning the smaller one
-		function tryBothFormats(
+		async function tryBothFormats(
 			width: number,
 			height: number,
 			jpegQuality: number,
-		): { buffer: Uint8Array; mimeType: string } {
-			const resized = photon!.resize(image!, width, height, photon!.SamplingFilter.Lanczos3);
-
-			try {
-				const pngBuffer = resized.get_bytes();
-				const jpegBuffer = resized.get_bytes_jpeg(jpegQuality);
-
-				return pickSmaller(
-					{ buffer: pngBuffer, mimeType: "image/png" },
-					{ buffer: jpegBuffer, mimeType: "image/jpeg" },
-				);
-			} finally {
-				resized.free();
-			}
+		): Promise<{ buffer: Uint8Array; mimeType: string }> {
+			using resized = await resize(image!, width, height, SamplingFilter.Lanczos3);
+
+			const [pngBuffer, jpegBuffer] = await Promise.all([resized.get_bytes(), resized.get_bytes_jpeg(jpegQuality)]);
+
+			return pickSmaller(
+				{ buffer: pngBuffer, mimeType: "image/png" },
+				{ buffer: jpegBuffer, mimeType: "image/jpeg" },
+			);
 		}
 
 		// Try to produce an image under maxBytes
@@ -118,7 +112,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		let finalHeight = targetHeight;
 
 		// First attempt: resize to target dimensions, try both formats
-		best = tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
+		best = await tryBothFormats(targetWidth, targetHeight, opts.jpegQuality);
 
 		if (best.buffer.length <= opts.maxBytes) {
 			return {
@@ -134,7 +128,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 
 		// Still too large - try JPEG with decreasing quality
 		for (const quality of qualitySteps) {
-			best = tryBothFormats(targetWidth, targetHeight, quality);
+			best = await tryBothFormats(targetWidth, targetHeight, quality);
 
 			if (best.buffer.length <= opts.maxBytes) {
 				return {
@@ -159,7 +153,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			}
 
 			for (const quality of qualitySteps) {
-				best = tryBothFormats(finalWidth, finalHeight, quality);
+				best = await tryBothFormats(finalWidth, finalHeight, quality);
 
 				if (best.buffer.length <= opts.maxBytes) {
 					return {
@@ -196,10 +190,6 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			height: 0,
 			wasResized: false,
 		};
-	} finally {
-		if (image) {
-			image.free();
-		}
 	}
 }
 

package/src/utils/tools-manager.ts

@@ -3,9 +3,9 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { logger, TempDir } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
-import { APP_NAME, getBinDir } from "../config";
+import { APP_NAME, getToolsDir } from "../config";
 
-const TOOLS_DIR = getBinDir();
+const TOOLS_DIR = getToolsDir();
 const TOOL_DOWNLOAD_TIMEOUT_MS = 15000;
 
 interface ToolConfig {
@@ -18,46 +18,6 @@ interface ToolConfig {
 }
 
 const TOOLS: Record<string, ToolConfig> = {
-	fd: {
-		name: "fd",
-		repo: "sharkdp/fd",
-		binaryName: "fd",
-		tagPrefix: "v",
-		getAssetName: (version, plat, architecture) => {
-			if (plat === "darwin") {
-				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
-				return `fd-v${version}-${archStr}-apple-darwin.tar.gz`;
-			} else if (plat === "linux") {
-				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
-				return `fd-v${version}-${archStr}-unknown-linux-gnu.tar.gz`;
-			} else if (plat === "win32") {
-				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
-				return `fd-v${version}-${archStr}-pc-windows-msvc.zip`;
-			}
-			return null;
-		},
-	},
-	rg: {
-		name: "ripgrep",
-		repo: "BurntSushi/ripgrep",
-		binaryName: "rg",
-		tagPrefix: "",
-		getAssetName: (version, plat, architecture) => {
-			if (plat === "darwin") {
-				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
-				return `ripgrep-${version}-${archStr}-apple-darwin.tar.gz`;
-			} else if (plat === "linux") {
-				if (architecture === "arm64") {
-					return `ripgrep-${version}-aarch64-unknown-linux-gnu.tar.gz`;
-				}
-				return `ripgrep-${version}-x86_64-unknown-linux-musl.tar.gz`;
-			} else if (plat === "win32") {
-				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
-				return `ripgrep-${version}-${archStr}-pc-windows-msvc.zip`;
-			}
-			return null;
-		},
-	},
 	sd: {
 		name: "sd",
 		repo: "chmln/sd",
@@ -135,7 +95,7 @@ const PYTHON_TOOLS: Record<string, PythonToolConfig> = {
 	},
 };
 
-export type ToolName = "fd" | "rg" | "sd" | "sg" | "yt-dlp" | "markitdown" | "html2text";
+export type ToolName = "sd" | "sg" | "yt-dlp" | "markitdown" | "html2text";
 
 // Get the path to a tool (system-wide or in our tools dir)
 export async function getToolPath(tool: ToolName): Promise<string | null> {

package/src/web/scrapers/utils.ts

@@ -49,16 +49,21 @@ export async function convertWithMarkitdown(
 
 	try {
 		await Bun.write(tmpFile, content);
-		const result = await ptree.cspawn([markitdown, tmpFile], { timeout });
-		const [stdout, stderr, exitCode] = await Promise.all([result.stdout.text(), result.stderr.text(), result.exited]);
-		if (exitCode !== 0) {
+		const result = await ptree.exec([markitdown, tmpFile], {
+			timeout,
+			allowNonZero: true,
+			stderr: "full",
+			detached: true,
+		});
+		if (!result.ok) {
 			return {
-				content: stdout,
+				content: result.stdout,
 				ok: false,
-				error: stderr.length > 0 ? stderr : `markitdown failed (exit ${exitCode})`,
+				error:
+					result.stderr.length > 0 ? result.stderr : `markitdown failed (exit ${result.exitCode ?? "unknown"})`,
 			};
 		}
-		return { content: stdout, ok: true };
+		return { content: result.stdout, ok: true };
 	} finally {
 		try {
 			await fs.rm(tmpFile, { force: true });

package/src/web/scrapers/youtube.ts

@@ -1,41 +1,13 @@
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import path from "node:path";
-import { cspawn } from "@oh-my-pi/pi-utils";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
 import { throwIfAborted } from "../../tools/tool-errors";
 import { ensureTool } from "../../utils/tools-manager";
 import type { RenderResult, SpecialHandler } from "./types";
 import { finalizeOutput } from "./types";
 
-/**
- * Execute a command and return stdout
- */
-async function exec(
-	cmd: string,
-	args: string[],
-	options?: { timeout?: number; input?: string | Buffer; signal?: AbortSignal },
-): Promise<{ stdout: string; stderr: string; ok: boolean; exitCode: number | null }> {
-	const proc = cspawn([cmd, ...args], {
-		signal: options?.signal,
-		timeout: options?.timeout,
-		stdin: options?.input ? Buffer.from(options.input) : undefined,
-	});
-
-	const [stdout, stderr, exitResult] = await Promise.all([
-		proc.stdout.text(),
-		proc.stderr.text(),
-		proc.exited.then(() => proc.exitCode ?? 0),
-	]);
-
-	return {
-		stdout,
-		stderr,
-		ok: exitResult === 0,
-		exitCode: exitResult,
-	};
-}
-
 interface YouTubeUrl {
 	videoId: string;
 	playlistId?: string;
@@ -163,16 +135,20 @@ export const handleYouTube: SpecialHandler = async (
 	const fetchedAt = new Date().toISOString();
 	const notes: string[] = [];
 	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
+	const execOptions = {
+		mode: "group" as const,
+		signal,
+		timeout: timeout * 1000,
+		allowNonZero: true,
+		allowAbort: true,
+		stderr: "full" as const,
+	};
 
 	// Fetch video metadata
 	throwIfAborted(signal);
-	const metaResult = await exec(
-		ytdlp,
-		["--dump-json", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
-		{
-			timeout: timeout * 1000,
-			signal,
-		},
+	const metaResult = await ptree.exec(
+		[ytdlp, "--dump-json", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		execOptions,
 	);
 	throwIfAborted(signal);
 
@@ -215,13 +191,9 @@ export const handleYouTube: SpecialHandler = async (
 
 	// First, list available subtitles
 	throwIfAborted(signal);
-	const listResult = await exec(
-		ytdlp,
-		["--list-subs", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
-		{
-			timeout: timeout * 1000,
-			signal,
-		},
+	const listResult = await ptree.exec(
+		[ytdlp, "--list-subs", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		execOptions,
 	);
 	throwIfAborted(signal);
 
@@ -236,9 +208,9 @@ export const handleYouTube: SpecialHandler = async (
 		// Try manual subtitles first (English preferred)
 		if (hasManualSubs) {
 			throwIfAborted(signal);
-			const subResult = await exec(
-				ytdlp,
+			const subResult = await ptree.exec(
 				[
+					ytdlp,
 					"--write-sub",
 					"--sub-lang",
 					"en,en-US,en-GB",
@@ -251,7 +223,7 @@ export const handleYouTube: SpecialHandler = async (
 					tmpBase,
 					videoUrl,
 				],
-				{ timeout: timeout * 1000, signal },
+				execOptions,
 			);
 
 			if (subResult.ok) {
@@ -271,9 +243,9 @@ export const handleYouTube: SpecialHandler = async (
 		// Fall back to auto-generated captions
 		if (!transcript && hasAutoSubs) {
 			throwIfAborted(signal);
-			const autoResult = await exec(
-				ytdlp,
+			const autoResult = await ptree.exec(
 				[
+					ytdlp,
 					"--write-auto-sub",
 					"--sub-lang",
 					"en,en-US,en-GB",
@@ -286,7 +258,7 @@ export const handleYouTube: SpecialHandler = async (
 					tmpBase,
 					videoUrl,
 				],
-				{ timeout: timeout * 1000, signal },
+				execOptions,
 			);
 
 			if (autoResult.ok) {

package/src/utils/utils.ts

@@ -1 +0,0 @@
-export { abortableSleep, once, untilAborted } from "@oh-my-pi/pi-utils";