@oh-my-pi/pi-coding-agent 3.13.1337 → 3.15.0

package/src/core/tools/output.ts

@@ -9,6 +9,7 @@ import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { TextContent } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
+import outputDescription from "../../prompts/tools/output.md" with { type: "text" };
 import type { SessionContext } from "./index";
 import { getArtifactsDir } from "./task/artifacts";
 
@@ -25,11 +26,18 @@ const outputSchema = Type.Object({
 });
 
 /** Metadata for a single output file */
+interface OutputProvenance {
+	agent: string;
+	index: number;
+}
+
 interface OutputEntry {
 	id: string;
 	path: string;
 	lineCount: number;
 	charCount: number;
+	provenance?: OutputProvenance;
+	previewLines?: string[];
 }
 
 export interface OutputToolDetails {
@@ -60,6 +68,26 @@ function formatBytes(bytes: number): string {
 	return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
 }
 
+function parseOutputProvenance(id: string): OutputProvenance | undefined {
+	const match = id.match(/^(.*)_(\d+)$/);
+	if (!match) return undefined;
+	const agent = match[1];
+	const index = Number(match[2]);
+	if (!agent || Number.isNaN(index)) return undefined;
+	return { agent, index };
+}
+
+function extractPreviewLines(content: string, maxLines: number): string[] {
+	const lines = content.split("\n");
+	const preview: string[] = [];
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		preview.push(line);
+		if (preview.length >= maxLines) break;
+	}
+	return preview;
+}
+
 export function createOutputTool(
 	_cwd: string,
 	sessionContext?: SessionContext,
@@ -67,18 +95,7 @@ export function createOutputTool(
 	return {
 		name: "output",
 		label: "Output",
-		description: `Read full agent/task output by ID.
-
-Use when the Task tool's truncated preview isn't sufficient for your needs.
-The Task tool already returns summaries with line/char counts in its result.
-
-Parameters:
-- ids: Array of output IDs (e.g., ["reviewer_0", "explore_1"])
-- format: "raw" (default), "json" (structured object), or "stripped" (no ANSI codes)
-
-Returns the full output content. For unknown IDs, returns an error with available IDs.
-
-Example: { "ids": ["reviewer_0"] }`,
+		description: outputDescription,
 		parameters: outputSchema,
 		execute: async (
 			_toolCallId: string,
@@ -103,6 +120,7 @@ Example: { "ids": ["reviewer_0"] }`,
 
 			const outputs: OutputEntry[] = [];
 			const notFound: string[] = [];
+			const outputContentById = new Map<string, string>();
 			const format = params.format ?? "raw";
 
 			for (const id of params.ids) {
@@ -114,11 +132,14 @@ Example: { "ids": ["reviewer_0"] }`,
 				}
 
 				const content = fs.readFileSync(outputPath, "utf-8");
+				outputContentById.set(id, content);
 				outputs.push({
 					id,
 					path: outputPath,
 					lineCount: content.split("\n").length,
 					charCount: content.length,
+					provenance: parseOutputProvenance(id),
+					previewLines: extractPreviewLines(content, 4),
 				});
 			}
 
@@ -144,13 +165,15 @@ Example: { "ids": ["reviewer_0"] }`,
 					id: o.id,
 					lineCount: o.lineCount,
 					charCount: o.charCount,
-					content: fs.readFileSync(o.path, "utf-8"),
+					provenance: o.provenance,
+					previewLines: o.previewLines,
+					content: outputContentById.get(o.id) ?? "",
 				}));
 				contentText = JSON.stringify(jsonData, null, 2);
 			} else {
 				// raw or stripped
 				const parts = outputs.map((o) => {
-					let content = fs.readFileSync(o.path, "utf-8");
+					let content = outputContentById.get(o.id) ?? "";
 					if (format === "stripped") {
 						content = stripAnsi(content);
 					}

package/src/core/tools/read.ts

@@ -1,18 +1,299 @@
 import { spawnSync } from "node:child_process";
-import { constants } from "node:fs";
-import { access, readFile } from "node:fs/promises";
-import { extname } from "node:path";
+import { constants, existsSync } from "node:fs";
+import { access, readFile, stat } from "node:fs/promises";
+import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { Type } from "@sinclair/typebox";
+import { globSync } from "glob";
+import readDescription from "../../prompts/tools/read.md" with { type: "text" };
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
+import { ensureTool } from "../../utils/tools-manager";
 import { untilAborted } from "../utils";
-import { resolveReadPath } from "./path-utils";
+import { createLsTool } from "./ls";
+import { resolveReadPath, resolveToCwd } from "./path-utils";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
 
+// Maximum image file size (20MB) - larger images will be rejected to prevent OOM during serialization
+const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
+const MAX_FUZZY_RESULTS = 5;
+const MAX_FUZZY_CANDIDATES = 20000;
+const MIN_BASE_SIMILARITY = 0.5;
+const MIN_FULL_SIMILARITY = 0.6;
+
+function normalizePathForMatch(value: string): string {
+	return value
+		.replace(/\\/g, "/")
+		.replace(/^\.\/+/, "")
+		.replace(/\/+$/, "")
+		.toLowerCase();
+}
+
+function isNotFoundError(error: unknown): boolean {
+	if (!error || typeof error !== "object") return false;
+	const code = (error as { code?: string }).code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+
+function isPathWithin(basePath: string, targetPath: string): boolean {
+	const relativePath = path.relative(basePath, targetPath);
+	return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+
+async function findExistingDirectory(startDir: string): Promise<string | null> {
+	let current = startDir;
+	const root = path.parse(startDir).root;
+
+	while (true) {
+		try {
+			const stats = await stat(current);
+			if (stats.isDirectory()) {
+				return current;
+			}
+		} catch {
+			// Keep walking up.
+		}
+
+		if (current === root) {
+			break;
+		}
+		current = path.dirname(current);
+	}
+
+	return null;
+}
+
+function formatScopeLabel(searchRoot: string, cwd: string): string {
+	const relative = path.relative(cwd, searchRoot).replace(/\\/g, "/");
+	if (relative === "" || relative === ".") {
+		return ".";
+	}
+	if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+		return relative;
+	}
+	return searchRoot;
+}
+
+function buildDisplayPath(searchRoot: string, cwd: string, relativePath: string): string {
+	const scopeLabel = formatScopeLabel(searchRoot, cwd);
+	const normalized = relativePath.replace(/\\/g, "/");
+	if (scopeLabel === ".") {
+		return normalized;
+	}
+	if (scopeLabel.startsWith("..") || path.isAbsolute(scopeLabel)) {
+		return path.join(searchRoot, normalized).replace(/\\/g, "/");
+	}
+	return `${scopeLabel}/${normalized}`;
+}
+
+function levenshteinDistance(a: string, b: string): number {
+	if (a === b) return 0;
+	const aLen = a.length;
+	const bLen = b.length;
+	if (aLen === 0) return bLen;
+	if (bLen === 0) return aLen;
+
+	let prev = new Array<number>(bLen + 1);
+	let curr = new Array<number>(bLen + 1);
+	for (let j = 0; j <= bLen; j++) {
+		prev[j] = j;
+	}
+
+	for (let i = 1; i <= aLen; i++) {
+		curr[0] = i;
+		const aCode = a.charCodeAt(i - 1);
+		for (let j = 1; j <= bLen; j++) {
+			const cost = aCode === b.charCodeAt(j - 1) ? 0 : 1;
+			const deletion = prev[j] + 1;
+			const insertion = curr[j - 1] + 1;
+			const substitution = prev[j - 1] + cost;
+			curr[j] = Math.min(deletion, insertion, substitution);
+		}
+		const tmp = prev;
+		prev = curr;
+		curr = tmp;
+	}
+
+	return prev[bLen];
+}
+
+function similarityScore(a: string, b: string): number {
+	if (a.length === 0 && b.length === 0) {
+		return 1;
+	}
+	const maxLen = Math.max(a.length, b.length);
+	if (maxLen === 0) {
+		return 1;
+	}
+	const distance = levenshteinDistance(a, b);
+	return 1 - distance / maxLen;
+}
+
+async function listCandidateFiles(
+	searchRoot: string,
+): Promise<{ files: string[]; truncated: boolean; error?: string }> {
+	let fdPath: string | undefined;
+	try {
+		fdPath = await ensureTool("fd", true);
+	} catch {
+		return { files: [], truncated: false, error: "fd not available" };
+	}
+
+	if (!fdPath) {
+		return { files: [], truncated: false, error: "fd not available" };
+	}
+
+	const args: string[] = ["--type", "f", "--color=never", "--hidden", "--max-results", String(MAX_FUZZY_CANDIDATES)];
+
+	const gitignoreFiles = new Set<string>();
+	const rootGitignore = path.join(searchRoot, ".gitignore");
+	if (existsSync(rootGitignore)) {
+		gitignoreFiles.add(rootGitignore);
+	}
+
+	try {
+		const nestedGitignores = globSync("**/.gitignore", {
+			cwd: searchRoot,
+			dot: true,
+			absolute: true,
+			ignore: ["**/node_modules/**", "**/.git/**"],
+		});
+		for (const file of nestedGitignores) {
+			gitignoreFiles.add(file);
+		}
+	} catch {
+		// Ignore glob errors.
+	}
+
+	for (const gitignorePath of gitignoreFiles) {
+		args.push("--ignore-file", gitignorePath);
+	}
+
+	args.push(".", searchRoot);
+
+	const result = Bun.spawnSync([fdPath, ...args], {
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	const output = result.stdout.toString().trim();
+
+	if (result.exitCode !== 0 && !output) {
+		const errorMsg = result.stderr.toString().trim() || `fd exited with code ${result.exitCode}`;
+		return { files: [], truncated: false, error: errorMsg };
+	}
+
+	if (!output) {
+		return { files: [], truncated: false };
+	}
+
+	const files = output
+		.split("\n")
+		.map((line) => line.replace(/\r$/, "").trim())
+		.filter((line) => line.length > 0);
+
+	return { files, truncated: files.length >= MAX_FUZZY_CANDIDATES };
+}
+
+async function findReadPathSuggestions(
+	rawPath: string,
+	cwd: string,
+): Promise<{ suggestions: string[]; scopeLabel?: string; truncated?: boolean; error?: string } | null> {
+	const resolvedPath = resolveToCwd(rawPath, cwd);
+	const searchRoot = await findExistingDirectory(path.dirname(resolvedPath));
+	if (!searchRoot) {
+		return null;
+	}
+
+	if (!isPathWithin(cwd, resolvedPath)) {
+		const root = path.parse(searchRoot).root;
+		if (searchRoot === root) {
+			return null;
+		}
+	}
+
+	const { files, truncated, error } = await listCandidateFiles(searchRoot);
+	const scopeLabel = formatScopeLabel(searchRoot, cwd);
+
+	if (error && files.length === 0) {
+		return { suggestions: [], scopeLabel, truncated, error };
+	}
+
+	if (files.length === 0) {
+		return null;
+	}
+
+	const queryPath = (() => {
+		if (path.isAbsolute(rawPath)) {
+			const relative = path.relative(cwd, resolvedPath).replace(/\\/g, "/");
+			if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+				return normalizePathForMatch(relative);
+			}
+		}
+		return normalizePathForMatch(rawPath);
+	})();
+	const baseQuery = path.posix.basename(queryPath);
+
+	const matches: Array<{ path: string; score: number; baseScore: number; fullScore: number }> = [];
+	const seen = new Set<string>();
+
+	for (const file of files) {
+		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;
+
+		if (!relativePath || relativePath.startsWith("..")) {
+			continue;
+		}
+
+		const displayPath = buildDisplayPath(searchRoot, cwd, relativePath);
+		if (seen.has(displayPath)) {
+			continue;
+		}
+		seen.add(displayPath);
+
+		const normalizedDisplay = normalizePathForMatch(displayPath);
+		const baseCandidate = path.posix.basename(normalizedDisplay);
+
+		const fullScore = similarityScore(queryPath, normalizedDisplay);
+		const baseScore = baseQuery ? similarityScore(baseQuery, baseCandidate) : 0;
+
+		if (baseQuery) {
+			if (baseScore < MIN_BASE_SIMILARITY && fullScore < MIN_FULL_SIMILARITY) {
+				continue;
+			}
+		} else if (fullScore < MIN_FULL_SIMILARITY) {
+			continue;
+		}
+
+		const score = baseQuery ? baseScore * 0.75 + fullScore * 0.25 : fullScore;
+		matches.push({ path: displayPath, score, baseScore, fullScore });
+	}
+
+	if (matches.length === 0) {
+		return { suggestions: [], scopeLabel, truncated };
+	}
+
+	matches.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		if (b.baseScore !== a.baseScore) return b.baseScore - a.baseScore;
+		return a.path.localeCompare(b.path);
+	});
+
+	const suggestions = matches.slice(0, MAX_FUZZY_RESULTS).map((match) => match.path);
+
+	return { suggestions, scopeLabel, truncated };
+}
+
 function convertWithMarkitdown(filePath: string): { content: string; ok: boolean; error?: string } {
 	const cmd = Bun.which("markitdown");
 	if (!cmd) {
@@ -40,56 +321,90 @@ const readSchema = Type.Object({
 
 export interface ReadToolDetails {
 	truncation?: TruncationResult;
+	redirectedTo?: "ls";
 }
 
 export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
+	const lsTool = createLsTool(cwd);
 	return {
 		name: "read",
 		label: "Read",
-		description: `Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-
-Usage:
-- The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to ${DEFAULT_MAX_LINES} lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- Any lines longer than 500 characters will be truncated
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
-- This tool can read PDF files (.pdf). PDFs are processed page by page, extracting both text and visual content for analysis.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
-- This tool can only read files, not directories. To read a directory, use an ls command via the bash tool.
-- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
-- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`,
+		description: readDescription.replace("{{DEFAULT_MAX_LINES}}", String(DEFAULT_MAX_LINES)),
 		parameters: readSchema,
 		execute: async (
-			_toolCallId: string,
-			{ path, offset, limit }: { path: string; offset?: number; limit?: number },
+			toolCallId: string,
+			{ path: readPath, offset, limit }: { path: string; offset?: number; limit?: number },
 			signal?: AbortSignal,
 		) => {
-			const absolutePath = resolveReadPath(path, cwd);
+			const absolutePath = resolveReadPath(readPath, cwd);
 
 			return untilAborted(signal, async () => {
-				// Check if file exists
+				let fileStat: Awaited<ReturnType<typeof stat>>;
+				try {
+					fileStat = await stat(absolutePath);
+				} catch (error) {
+					if (isNotFoundError(error)) {
+						const suggestions = await findReadPathSuggestions(readPath, cwd);
+						let message = `File not found: ${readPath}`;
+
+						if (suggestions?.suggestions.length) {
+							const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";
+							message += `\n\nClosest matches${scopeLabel}:\n${suggestions.suggestions
+								.map((match) => `- ${match}`)
+								.join("\n")}`;
+							if (suggestions.truncated) {
+								message += `\n[Search truncated to first ${MAX_FUZZY_CANDIDATES} paths. Refine the path if the match isn't listed.]`;
+							}
+						} else if (suggestions?.error) {
+							message += `\n\nFuzzy match failed: ${suggestions.error}`;
+						} else if (suggestions?.scopeLabel) {
+							message += `\n\nNo similar paths found in ${suggestions.scopeLabel}.`;
+						}
+
+						throw new Error(message);
+					}
+					throw error;
+				}
+
+				if (fileStat.isDirectory()) {
+					const lsResult = await lsTool.execute(toolCallId, { path: readPath, limit }, signal);
+					return {
+						content: lsResult.content,
+						details: { redirectedTo: "ls", truncation: lsResult.details?.truncation },
+					};
+				}
+
 				await access(absolutePath, constants.R_OK);
 
 				const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
-				const ext = extname(absolutePath).toLowerCase();
+				const ext = path.extname(absolutePath).toLowerCase();
 
 				// Read the file based on type
 				let content: (TextContent | ImageContent)[];
 				let details: ReadToolDetails | undefined;
 
 				if (mimeType) {
-					// Read as image (binary)
-					const buffer = await readFile(absolutePath);
-					const base64 = buffer.toString("base64");
-
-					content = [
-						{ type: "text", text: `Read image file [${mimeType}]` },
-						{ type: "image", data: base64, mimeType },
-					];
+					// Check image file size before reading to prevent OOM during serialization
+					const fileStat = await stat(absolutePath);
+					if (fileStat.size > MAX_IMAGE_SIZE) {
+						const sizeStr = formatSize(fileStat.size);
+						const maxStr = formatSize(MAX_IMAGE_SIZE);
+						content = [
+							{
+								type: "text",
+								text: `[Image file too large: ${sizeStr} exceeds ${maxStr} limit. Use an image viewer or resize the image.]`,
+							},
+						];
+					} else {
+						// Read as image (binary)
+						const buffer = await readFile(absolutePath);
+						const base64 = buffer.toString("base64");
+
+						content = [
+							{ type: "text", text: `Read image file [${mimeType}]` },
+							{ type: "image", data: base64, mimeType },
+						];
+					}
 				} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {
 					// Convert document via markitdown
 					const result = convertWithMarkitdown(absolutePath);
@@ -150,7 +465,7 @@ Usage:
 						const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
 						outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(
 							DEFAULT_MAX_BYTES,
-						)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
+						)} limit. Use bash: sed -n '${startLineDisplay}p' ${readPath} | head -c ${DEFAULT_MAX_BYTES}]`;
 						details = { truncation };
 					} else if (truncation.truncated) {
 						// Truncation occurred - build actionable notice