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

package/src/core/tools/index.ts

@@ -5,6 +5,7 @@ export { createEditTool, type EditToolOptions, editTool } from "./edit";
 export { exaTools } from "./exa/index";
 export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "./exa/types";
 export { createFindTool, type FindToolDetails, findTool } from "./find";
+export { createGitTool, type GitToolDetails, gitTool } from "./git";
 export { createGrepTool, type GrepToolDetails, grepTool } from "./grep";
 export { createLsTool, type LsToolDetails, lsTool } from "./ls";
 export {
@@ -20,7 +21,7 @@ export {
 } from "./lsp/index";
 export { createNotebookTool, type NotebookToolDetails, notebookTool } from "./notebook";
 export { createOutputTool, type OutputToolDetails, outputTool } from "./output";
-export { createReadTool, type ReadToolDetails, readTool } from "./read";
+export { createReadTool, type ReadToolDetails, type ReadToolOptions, readTool } from "./read";
 export { createReportFindingTool, createSubmitReviewTool, reportFindingTool, submitReviewTool } from "./review";
 export {
 	createRulebookTool,
@@ -57,6 +58,7 @@ import { bashTool, createBashTool } from "./bash";
 import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
 import { createEditTool, editTool } from "./edit";
 import { createFindTool, findTool } from "./find";
+import { createGitTool, gitTool } from "./git";
 import { createGrepTool, grepTool } from "./grep";
 import { createLsTool, lsTool } from "./ls";
 import { createLspTool, createLspWritethrough, lspTool } from "./lsp/index";
@@ -87,17 +89,22 @@ export interface CodingToolsOptions {
 	lspFormatOnWrite?: boolean;
 	/** Whether to accept high-confidence fuzzy matches in edit tool (default: true) */
 	editFuzzyMatch?: boolean;
+	/** Whether to auto-resize images to 2000x2000 max in read tool (default: true) */
+	readAutoResizeImages?: boolean;
 	/** Set of tool names available to the agent (for cross-tool awareness) */
 	availableTools?: Set<string>;
 }
 
 // Factory function type
-type ToolFactory = (cwd: string, sessionContext?: SessionContext, options?: CodingToolsOptions) => Tool;
+type ToolFactory = (cwd: string, sessionContext?: SessionContext, options?: CodingToolsOptions) => Tool | Promise<Tool>;
 
 // Tool definitions: static tools and their factory functions
 const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
 	ask: { tool: askTool, create: createAskTool },
-	read: { tool: readTool, create: createReadTool },
+	read: {
+		tool: readTool,
+		create: (cwd, _ctx, options) => createReadTool(cwd, { autoResizeImages: options?.readAutoResizeImages ?? true }),
+	},
 	bash: { tool: bashTool, create: createBashTool },
 	edit: {
 		tool: editTool,
@@ -125,6 +132,7 @@ const toolDefs: Record<string, { tool: Tool; create: ToolFactory }> = {
 	},
 	grep: { tool: grepTool, create: createGrepTool },
 	find: { tool: findTool, create: createFindTool },
+	git: { tool: gitTool, create: createGitTool },
 	ls: { tool: lsTool, create: createLsTool },
 	lsp: { tool: lspTool, create: createLspTool },
 	notebook: { tool: notebookTool, create: createNotebookTool },
@@ -142,13 +150,14 @@ export type ToolName = keyof typeof toolDefs;
 const uiToolNames: ToolName[] = ["ask"];
 
 // Tool sets defined by name (base sets, without UI-only tools)
-const baseCodingToolNames: ToolName[] = [
+export const baseCodingToolNames: ToolName[] = [
 	"read",
 	"bash",
 	"edit",
 	"write",
 	"grep",
 	"find",
+	"git",
 	"ls",
 	"lsp",
 	"notebook",
@@ -178,15 +187,15 @@ export const allTools = Object.fromEntries(Object.entries(toolDefs).map(([name,
  * @param sessionContext - Optional session context for tools that need it
  * @param options - Options for tool configuration
  */
-export function createCodingTools(
+export async function createCodingTools(
 	cwd: string,
 	hasUI = false,
 	sessionContext?: SessionContext,
 	options?: CodingToolsOptions,
-): Tool[] {
+): Promise<Tool[]> {
 	const names = hasUI ? [...baseCodingToolNames, ...uiToolNames] : baseCodingToolNames;
 	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools));
+	return Promise.all(names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools)));
 }
 
 /**
@@ -196,15 +205,15 @@ export function createCodingTools(
  * @param sessionContext - Optional session context for tools that need it
  * @param options - Options for tool configuration
  */
-export function createReadOnlyTools(
+export async function createReadOnlyTools(
 	cwd: string,
 	hasUI = false,
 	sessionContext?: SessionContext,
 	options?: CodingToolsOptions,
-): Tool[] {
+): Promise<Tool[]> {
 	const names = hasUI ? [...baseReadOnlyToolNames, ...uiToolNames] : baseReadOnlyToolNames;
 	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools));
+	return Promise.all(names.map((name) => toolDefs[name].create(cwd, sessionContext, optionsWithTools)));
 }
 
 /**
@@ -213,16 +222,20 @@ export function createReadOnlyTools(
  * @param sessionContext - Optional session context for tools that need it
  * @param options - Options for tool configuration
  */
-export function createAllTools(
+export async function createAllTools(
 	cwd: string,
 	sessionContext?: SessionContext,
 	options?: CodingToolsOptions,
-): Record<ToolName, Tool> {
+): Promise<Record<ToolName, Tool>> {
 	const names = Object.keys(toolDefs);
 	const optionsWithTools = { ...options, availableTools: new Set(names) };
-	return Object.fromEntries(
-		Object.entries(toolDefs).map(([name, def]) => [name, def.create(cwd, sessionContext, optionsWithTools)]),
-	) as Record<ToolName, Tool>;
+	const entries = await Promise.all(
+		Object.entries(toolDefs).map(async ([name, def]) => [
+			name,
+			await def.create(cwd, sessionContext, optionsWithTools),
+		]),
+	);
+	return Object.fromEntries(entries) as Record<ToolName, Tool>;
 }
 
 /**

package/src/core/tools/lsp/config.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { extname, join } from "node:path";
-import { getConfigDirPaths } from "../../../config.js";
+import { getConfigDirPaths } from "../../../config";
 import { createBiomeClient } from "./clients/biome-client";
 import type { ServerConfig } from "./types";
 
@@ -618,7 +618,7 @@ export function hasRootMarkers(cwd: string, markers: string[]): boolean {
 		// Handle glob-like patterns (e.g., "*.cabal")
 		if (marker.includes("*")) {
 			try {
-				const { globSync } = require("node:fs");
+				const { globSync } = require("glob");
 				const matches = globSync(join(cwd, marker));
 				return matches.length > 0;
 			} catch {
@@ -626,7 +626,8 @@ export function hasRootMarkers(cwd: string, markers: string[]): boolean {
 				return false;
 			}
 		}
-		return existsSync(join(cwd, marker));
+		const filePath = join(cwd, marker);
+		return existsSync(filePath);
 	});
 }
 
@@ -741,7 +742,7 @@ function getConfigPaths(cwd: string): string[] {
  * }
  * ```
  */
-export function loadConfig(cwd: string): LspConfig {
+export async function loadConfig(cwd: string): Promise<LspConfig> {
 	const configPaths = getConfigPaths(cwd);
 
 	for (const configPath of configPaths) {

package/src/core/tools/lsp/index.ts

@@ -1,4 +1,5 @@
-import * as fs from "node:fs";
+import type { Dirent } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { BunFile } from "bun";
@@ -78,7 +79,7 @@ export interface LspWarmupResult {
  * @returns Status of each server that was started
  */
 export async function warmupLspServers(cwd: string): Promise<LspWarmupResult> {
-	const config = loadConfig(cwd);
+	const config = await loadConfig(cwd);
 	setIdleTimeout(config.idleTimeoutMs);
 	const servers: LspWarmupResult["servers"] = [];
 	const lspServers = getLspServers(config);
@@ -173,10 +174,10 @@ async function notifyFileSaved(
 // Cache config per cwd to avoid repeated file I/O
 const configCache = new Map<string, LspConfig>();
 
-function getConfig(cwd: string): LspConfig {
+async function getConfig(cwd: string): Promise<LspConfig> {
 	let config = configCache.get(cwd);
 	if (!config) {
-		config = loadConfig(cwd);
+		config = await loadConfig(cwd);
 		setIdleTimeout(config.idleTimeoutMs);
 		configCache.set(cwd, config);
 	}
@@ -225,9 +226,13 @@ function findFileByExtensions(baseDir: string, extensions: string[], maxDepth: n
 	const normalized = extensions.map((ext) => ext.toLowerCase());
 	const search = (dir: string, depth: number): string | null => {
 		if (depth > maxDepth) return null;
-		let entries: fs.Dirent[];
+		let entries: Dirent[];
 		try {
-			entries = fs.readdirSync(dir, { withFileTypes: true });
+			entries = Array.from(new Bun.Glob("*").scanSync({ cwd: dir, onlyFiles: false })).map((name) => ({
+				name,
+				isFile: () => !existsSync(path.join(dir, name)) || Bun.file(path.join(dir, name)).type !== "directory",
+				isDirectory: () => existsSync(path.join(dir, name)) && Bun.file(path.join(dir, name)).type === "directory",
+			})) as Dirent[];
 		} catch {
 			return null;
 		}
@@ -312,22 +317,22 @@ interface ProjectType {
 /** Detect project type from root markers */
 function detectProjectType(cwd: string): ProjectType {
 	// Check for Rust (Cargo.toml)
-	if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+	if (existsSync(path.join(cwd, "Cargo.toml"))) {
 		return { type: "rust", command: ["cargo", "check", "--message-format=short"], description: "Rust (cargo check)" };
 	}
 
 	// Check for TypeScript (tsconfig.json)
-	if (fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+	if (existsSync(path.join(cwd, "tsconfig.json"))) {
 		return { type: "typescript", command: ["npx", "tsc", "--noEmit"], description: "TypeScript (tsc --noEmit)" };
 	}
 
 	// Check for Go (go.mod)
-	if (fs.existsSync(path.join(cwd, "go.mod"))) {
+	if (existsSync(path.join(cwd, "go.mod"))) {
 		return { type: "go", command: ["go", "build", "./..."], description: "Go (go build)" };
 	}
 
 	// Check for Python (pyproject.toml or pyrightconfig.json)
-	if (fs.existsSync(path.join(cwd, "pyproject.toml")) || fs.existsSync(path.join(cwd, "pyrightconfig.json"))) {
+	if (existsSync(path.join(cwd, "pyproject.toml")) || existsSync(path.join(cwd, "pyrightconfig.json"))) {
 		return { type: "python", command: ["pyright"], description: "Python (pyright)" };
 	}
 
@@ -612,7 +617,7 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 		return writethroughNoop;
 	}
 	return async (dst: string, content: string, signal?: AbortSignal, file?: BunFile) => {
-		const config = getConfig(cwd);
+		const config = await getConfig(cwd);
 		const servers = getServersForFile(config, dst);
 		if (servers.length === 0) {
 			return writethroughNoop(dst, content, signal, file);
@@ -708,7 +713,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 				include_declaration,
 			} = params;
 
-			const config = getConfig(cwd);
+			const config = await getConfig(cwd);
 
 			// Status action doesn't need a file
 			if (action === "status") {

package/src/core/tools/lsp/render.ts

@@ -11,7 +11,8 @@
 import type { AgentToolResult, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
 import { Text } from "@oh-my-pi/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
-import type { Theme } from "../../../modes/interactive/theme/theme";
+import { getLanguageFromPath, type Theme } from "../../../modes/interactive/theme/theme";
+import { formatExpandHint, formatMoreItems, TRUNCATE_LENGTHS, truncate } from "../render-utils";
 import type { LspParams, LspToolDetails } from "./types";
 
 // =============================================================================
@@ -25,8 +26,8 @@ import type { LspParams, LspToolDetails } from "./types";
 export function renderCall(args: unknown, theme: Theme): Text {
 	const p = args as LspParams & { file?: string; files?: string[] };
 
-	let text = theme.fg("toolTitle", theme.bold("LSP "));
-	text += theme.fg("accent", p.action || "?");
+	let text = theme.fg("toolTitle", theme.bold("LSP"));
+	text += ` ${theme.fg("accent", p.action || "?")}`;
 
 	if (p.file) {
 		text += ` ${theme.fg("muted", p.file)}`;
@@ -112,7 +113,7 @@ function renderHover(
 		const v = theme.boxSharp.vertical;
 		const top = `${theme.boxSharp.topLeft}${h.repeat(3)}`;
 		const bottom = `${theme.boxSharp.bottomLeft}${h.repeat(3)}`;
-		let output = `${icon} ${theme.fg("toolTitle", "Hover")}${langLabel}`;
+		let output = `${icon}${langLabel}`;
 		output += `\n ${theme.fg("mdCodeBlockBorder", top)}`;
 		for (const line of codeLines) {
 			output += `\n ${theme.fg("mdCodeBlockBorder", v)} ${line}`;
@@ -126,9 +127,10 @@ function renderHover(
 
 	// Collapsed view
 	const firstCodeLine = codeLines[0] || "";
-	const expandHint = theme.fg("dim", " (Ctrl+O to expand)");
+	const hasMore = codeLines.length > 1 || Boolean(afterCode);
+	const expandHint = formatExpandHint(false, hasMore, theme);
 
-	let output = `${icon} ${theme.fg("toolTitle", "Hover")}${langLabel}${expandHint}`;
+	let output = `${icon}${langLabel}${expandHint}`;
 	const h = theme.boxSharp.horizontal;
 	const v = theme.boxSharp.vertical;
 	const bottom = `${theme.boxSharp.bottomLeft}${h.repeat(3)}`;
@@ -142,9 +144,7 @@ function renderHover(
 	}
 
 	if (afterCode) {
-		const ellipsis = theme.format.ellipsis;
-		const sliceLen = Math.max(0, 60 - ellipsis.length);
-		const docPreview = afterCode.length > 60 ? `${afterCode.slice(0, sliceLen)}${ellipsis}` : afterCode;
+		const docPreview = truncate(afterCode, TRUNCATE_LENGTHS.TITLE, theme.format.ellipsis);
 		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", docPreview)}`;
 	} else {
 		output += `\n ${theme.fg("mdCodeBlockBorder", bottom)}`;
@@ -186,6 +186,12 @@ function highlightCode(codeText: string, language: string, theme: Theme): string
 // Diagnostics Rendering
 // =============================================================================
 
+function formatDiagnosticLocation(file: string, line: string | number, col: string | number, theme: Theme): string {
+	const lang = getLanguageFromPath(file);
+	const icon = theme.fg("muted", theme.getLangIcon(lang));
+	return `${icon} ${file}:${line}:${col}`;
+}
+
 /**
  * Render diagnostics with color-coded severity.
  */
@@ -218,7 +224,7 @@ function renderDiagnostics(
 	const fallbackDiagnostics: RawDiagnostic[] = diagLines.map((line) => ({ raw: line.trim() }));
 
 	if (expanded) {
-		let output = `${icon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", meta.join(", "))}`;
+		let output = `${icon} ${theme.fg("dim", meta.join(theme.sep.dot))}`;
 		const items: DiagnosticItem[] = parsedDiagnostics.length > 0 ? parsedDiagnostics : fallbackDiagnostics;
 		for (let i = 0; i < items.length; i++) {
 			const item = items[i];
@@ -230,26 +236,25 @@ function renderDiagnostics(
 				continue;
 			}
 			const severityColor = severityToColor(item.severity);
-			const location = `${item.file}:${item.line}:${item.col}`;
+			const location = formatDiagnosticLocation(item.file, item.line, item.col, theme);
 			output += `\n ${theme.fg("dim", branch)} ${theme.fg(severityColor, location)} ${theme.fg(
 				"dim",
 				`[${item.severity}]`,
 			)}`;
 			if (item.message) {
-				output += `\n ${theme.fg("dim", detailPrefix)}${theme.fg("muted", trimTo(item.message, 120, theme))}`;
+				output += `\n ${theme.fg("dim", detailPrefix)}${theme.fg("muted", truncate(item.message, TRUNCATE_LENGTHS.LINE, theme.format.ellipsis))}`;
 			}
 		}
 		return new Text(output, 0, 0);
 	}
 
 	// Collapsed view
-	const expandHint = theme.fg("dim", " (Ctrl+O to expand)");
-	let output = `${icon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", meta.join(", "))}${expandHint}`;
-
 	const previewItems: DiagnosticItem[] =
 		parsedDiagnostics.length > 0 ? parsedDiagnostics.slice(0, 3) : fallbackDiagnostics.slice(0, 3);
 	const remaining =
 		(parsedDiagnostics.length > 0 ? parsedDiagnostics.length : fallbackDiagnostics.length) - previewItems.length;
+	const expandHint = formatExpandHint(false, remaining > 0, theme);
+	let output = `${icon} ${theme.fg("dim", meta.join(theme.sep.dot))}${expandHint}`;
 	for (let i = 0; i < previewItems.length; i++) {
 		const item = previewItems[i];
 		const isLast = i === previewItems.length - 1 && remaining <= 0;
@@ -259,15 +264,14 @@ function renderDiagnostics(
 			continue;
 		}
 		const severityColor = severityToColor(item.severity);
-		const location = `${item.file}:${item.line}:${item.col}`;
-		const message = item.message ? ` ${theme.fg("muted", trimTo(item.message, 80, theme))}` : "";
+		const location = formatDiagnosticLocation(item.file, item.line, item.col, theme);
+		const message = item.message
+			? ` ${theme.fg("muted", truncate(item.message, TRUNCATE_LENGTHS.CONTENT, theme.format.ellipsis))}`
+			: "";
 		output += `\n ${theme.fg("dim", branch)} ${theme.fg(severityColor, location)}${message}`;
 	}
 	if (remaining > 0) {
-		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
-			"muted",
-			`${theme.format.ellipsis} ${remaining} more`,
-		)}`;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", `${theme.format.ellipsis} ${remaining} more`)}`;
 	}
 
 	return new Text(output, 0, 0);
@@ -301,8 +305,8 @@ function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded:
 	const files = Array.from(byFile.keys());
 
 	const renderGrouped = (maxFiles: number, maxLocsPerFile: number, showHint: boolean): string => {
-		const expandHint = showHint ? theme.fg("dim", " (Ctrl+O to expand)") : "";
-		let output = `${icon} ${theme.fg("toolTitle", "References")} ${theme.fg("dim", `${refCount} found`)}${expandHint}`;
+		const expandHint = formatExpandHint(false, showHint, theme);
+		let output = `${icon} ${theme.fg("dim", `${refCount} found`)}${expandHint}`;
 
 		const filesToShow = files.slice(0, maxFiles);
 		for (let fi = 0; fi < filesToShow.length; fi++) {
@@ -330,7 +334,7 @@ function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded:
 						const context = `at ${file}:${line}:${col}`;
 						output += `\n ${theme.fg("dim", fileCont)}${theme.fg("dim", locCont)}${theme.fg(
 							"muted",
-							trimTo(context, 120, theme),
+							truncate(context, TRUNCATE_LENGTHS.LINE, theme.format.ellipsis),
 						)}`;
 					}
 				}
@@ -346,7 +350,7 @@ function renderReferences(refMatch: RegExpMatchArray, lines: string[], expanded:
 		if (files.length > maxFiles) {
 			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
 				"muted",
-				`${theme.format.ellipsis} ${files.length - maxFiles} more files`,
+				formatMoreItems(files.length - maxFiles, "file", theme),
 			)}`;
 		}
 
@@ -424,7 +428,7 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 	const topLevelCount = symbols.filter((s) => s.indent === 0).length;
 
 	if (expanded) {
-		let output = `${icon} ${theme.fg("toolTitle", "Symbols")} ${theme.fg("dim", `in ${fileName}`)}`;
+		let output = `${icon} ${theme.fg("dim", `in ${fileName}`)}`;
 
 		for (let i = 0; i < symbols.length; i++) {
 			const sym = symbols[i];
@@ -442,10 +446,10 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 	}
 
 	// Collapsed: show first 3 top-level symbols
-	const expandHint = theme.fg("dim", " (Ctrl+O to expand)");
-	let output = `${icon} ${theme.fg("toolTitle", "Symbols")} ${theme.fg("dim", `in ${fileName}`)}${expandHint}`;
-
 	const topLevel = symbols.filter((s) => s.indent === 0).slice(0, 3);
+	const hasMoreSymbols = symbols.length > topLevel.length;
+	const expandHint = formatExpandHint(false, hasMoreSymbols, theme);
+	let output = `${icon} ${theme.fg("dim", `in ${fileName}`)}${expandHint}`;
 	for (let i = 0; i < topLevel.length; i++) {
 		const sym = topLevel[i];
 		const isLast = i === topLevel.length - 1 && topLevelCount <= 3;
@@ -456,10 +460,7 @@ function renderSymbols(symbolsMatch: RegExpMatchArray, lines: string[], expanded
 		)} ${theme.fg("muted", `line ${sym.line}`)}`;
 	}
 	if (topLevelCount > 3) {
-		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
-			"muted",
-			`${theme.format.ellipsis} ${topLevelCount - 3} more`,
-		)}`;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", `${theme.format.ellipsis} ${topLevelCount - 3} more`)}`;
 	}
 
 	return new Text(output, 0, 0);
@@ -484,7 +485,7 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 				: theme.styledSymbol("status.info", "accent");
 
 	if (expanded) {
-		let output = `${icon} ${theme.fg("toolTitle", "LSP")} ${theme.fg("dim", "Output")}`;
+		let output = `${icon} ${theme.fg("dim", "Output")}`;
 		for (let i = 0; i < lines.length; i++) {
 			const isLast = i === lines.length - 1;
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
@@ -494,21 +495,18 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 	}
 
 	const firstLine = lines[0] || "No output";
-	const expandHint = lines.length > 1 ? theme.fg("dim", " (Ctrl+O to expand)") : "";
-	let output = `${icon} ${theme.fg("toolTitle", "LSP")} ${theme.fg("dim", firstLine.slice(0, 60))}${expandHint}`;
+	const expandHint = formatExpandHint(false, lines.length > 1, theme);
+	let output = `${icon} ${theme.fg("dim", truncate(firstLine, TRUNCATE_LENGTHS.TITLE, theme.format.ellipsis))}${expandHint}`;
 
 	if (lines.length > 1) {
 		const previewLines = lines.slice(1, 4);
 		for (let i = 0; i < previewLines.length; i++) {
 			const isLast = i === previewLines.length - 1 && lines.length <= 4;
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
-			output += `\n ${theme.fg("dim", branch)} ${theme.fg("dim", previewLines[i].trim().slice(0, 80))}`;
+			output += `\n ${theme.fg("dim", branch)} ${theme.fg("dim", truncate(previewLines[i].trim(), TRUNCATE_LENGTHS.CONTENT, theme.format.ellipsis))}`;
 		}
 		if (lines.length > 4) {
-			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg(
-				"muted",
-				`${theme.format.ellipsis} ${lines.length - 4} more lines`,
-			)}`;
+			output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", formatMoreItems(lines.length - 4, "line", theme))}`;
 		}
 	}
 
@@ -552,9 +550,3 @@ function severityToColor(severity: string): "error" | "warning" | "accent" | "di
 			return "dim";
 	}
 }
-
-function trimTo(value: string, maxLength: number, theme: Theme): string {
-	if (value.length <= maxLength) return value;
-	const sliceLen = Math.max(0, maxLength - theme.format.ellipsis.length);
-	return `${value.slice(0, sliceLen)}${theme.format.ellipsis}`;
-}

package/src/core/tools/read.ts

@@ -1,12 +1,11 @@
-import { spawnSync } from "node:child_process";
-import { constants, existsSync } from "node:fs";
-import { access, readFile, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
 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 { formatDimensionNote, resizeImage } from "../../utils/image-resize";
 import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime";
 import { ensureTool } from "../../utils/tools-manager";
 import { untilAborted } from "../utils";
@@ -49,9 +48,14 @@ async function findExistingDirectory(startDir: string): Promise<string | null> {
 
 	while (true) {
 		try {
-			const stats = await stat(current);
-			if (stats.isDirectory()) {
-				return current;
+			if (existsSync(current)) {
+				// Check if directory by trying to read it as dir
+				try {
+					await Bun.$`test -d ${current}`.quiet();
+					return current;
+				} catch {
+					// Not a directory, continue
+				}
 			}
 		} catch {
 			// Keep walking up.
@@ -300,17 +304,17 @@ function convertWithMarkitdown(filePath: string): { content: string; ok: boolean
 		return { content: "", ok: false, error: "markitdown not found" };
 	}
 
-	const result = spawnSync(cmd, [filePath], {
-		encoding: "utf-8",
-		timeout: 60000,
-		maxBuffer: 50 * 1024 * 1024,
+	const result = Bun.spawnSync([cmd, filePath], {
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
 	});
 
-	if (result.status === 0 && result.stdout && result.stdout.length > 0) {
-		return { content: result.stdout, ok: true };
+	if (result.exitCode === 0 && result.stdout && result.stdout.length > 0) {
+		return { content: result.stdout.toString(), ok: true };
 	}
 
-	return { content: "", ok: false, error: result.stderr || "Conversion failed" };
+	return { content: "", ok: false, error: result.stderr.toString() || "Conversion failed" };
 }
 
 const readSchema = Type.Object({
@@ -324,7 +328,13 @@ export interface ReadToolDetails {
 	redirectedTo?: "ls";
 }
 
-export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
+export interface ReadToolOptions {
+	/** Whether to auto-resize images to 2000x2000 max. Default: true */
+	autoResizeImages?: boolean;
+}
+
+export function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema> {
+	const autoResizeImages = options?.autoResizeImages ?? true;
 	const lsTool = createLsTool(cwd);
 	return {
 		name: "read",
@@ -339,9 +349,21 @@ export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
 			const absolutePath = resolveReadPath(readPath, cwd);
 
 			return untilAborted(signal, async () => {
-				let fileStat: Awaited<ReturnType<typeof stat>>;
+				let isDirectory = false;
+				let fileSize = 0;
 				try {
-					fileStat = await stat(absolutePath);
+					if (!existsSync(absolutePath)) {
+						throw { code: "ENOENT" };
+					}
+					const file = Bun.file(absolutePath);
+					fileSize = file.size;
+					// Check if directory
+					try {
+						await Bun.$`test -d ${absolutePath}`.quiet();
+						isDirectory = true;
+					} catch {
+						isDirectory = false;
+					}
 				} catch (error) {
 					if (isNotFoundError(error)) {
 						const suggestions = await findReadPathSuggestions(readPath, cwd);
@@ -366,7 +388,7 @@ export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
 					throw error;
 				}
 
-				if (fileStat.isDirectory()) {
+				if (isDirectory) {
 					const lsResult = await lsTool.execute(toolCallId, { path: readPath, limit }, signal);
 					return {
 						content: lsResult.content,
@@ -374,8 +396,6 @@ export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
 					};
 				}
 
-				await access(absolutePath, constants.R_OK);
-
 				const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
 				const ext = path.extname(absolutePath).toLowerCase();
 
@@ -385,9 +405,8 @@ export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
 
 				if (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);
+					if (fileSize > MAX_IMAGE_SIZE) {
+						const sizeStr = formatSize(fileSize);
 						const maxStr = formatSize(MAX_IMAGE_SIZE);
 						content = [
 							{
@@ -397,13 +416,30 @@ export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
 						];
 					} else {
 						// Read as image (binary)
-						const buffer = await readFile(absolutePath);
-						const base64 = buffer.toString("base64");
+						const file = Bun.file(absolutePath);
+						const buffer = await file.arrayBuffer();
+						const base64 = Buffer.from(buffer).toString("base64");
+
+						if (autoResizeImages) {
+							// Resize image if needed
+							const resized = await resizeImage({ type: "image", data: base64, mimeType });
+							const dimensionNote = formatDimensionNote(resized);
+
+							let textNote = `Read image file [${resized.mimeType}]`;
+							if (dimensionNote) {
+								textNote += `\n${dimensionNote}`;
+							}
 
-						content = [
-							{ type: "text", text: `Read image file [${mimeType}]` },
-							{ type: "image", data: base64, mimeType },
-						];
+							content = [
+								{ type: "text", text: textNote },
+								{ type: "image", data: resized.data, mimeType: resized.mimeType },
+							];
+						} else {
+							content = [
+								{ type: "text", text: `Read image file [${mimeType}]` },
+								{ type: "image", data: base64, mimeType },
+							];
+						}
 					}
 				} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {
 					// Convert document via markitdown
@@ -431,7 +467,8 @@ export function createReadTool(cwd: string): AgentTool<typeof readSchema> {
 					}
 				} else {
 					// Read as text
-					const textContent = await readFile(absolutePath, "utf-8");
+					const file = Bun.file(absolutePath);
+					const textContent = await file.text();
 					const allLines = textContent.split("\n");
 					const totalFileLines = allLines.length;