@oh-my-pi/pi-coding-agent 3.20.1 → 3.24.0

package/src/core/tools/output.ts

@@ -6,11 +6,24 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { TextContent } from "@oh-my-pi/pi-ai";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import type { Theme } from "../../modes/interactive/theme/theme";
 import outputDescription from "../../prompts/tools/output.md" with { type: "text" };
-import type { SessionContext } from "./index";
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { ToolSession } from "./index";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	TRUNCATE_LENGTHS,
+	truncate,
+} from "./render-utils";
 import { getArtifactsDir } from "./task/artifacts";
 
 const outputSchema = Type.Object({
@@ -23,6 +36,18 @@ const outputSchema = Type.Object({
 			description: "Output format: raw (default), json (structured), stripped (no ANSI)",
 		}),
 	),
+	offset: Type.Optional(
+		Type.Number({
+			description: "Line number to start reading from (1-indexed)",
+			minimum: 1,
+		}),
+	),
+	limit: Type.Optional(
+		Type.Number({
+			description: "Maximum number of lines to read",
+			minimum: 1,
+		}),
+	),
 });
 
 /** Metadata for a single output file */
@@ -31,6 +56,12 @@ interface OutputProvenance {
 	index: number;
 }
 
+interface OutputRange {
+	startLine: number;
+	endLine: number;
+	totalLines: number;
+}
+
 interface OutputEntry {
 	id: string;
 	path: string;
@@ -38,6 +69,7 @@ interface OutputEntry {
 	charCount: number;
 	provenance?: OutputProvenance;
 	previewLines?: string[];
+	range?: OutputRange;
 }
 
 export interface OutputToolDetails {
@@ -88,10 +120,7 @@ function extractPreviewLines(content: string, maxLines: number): string[] {
 	return preview;
 }
 
-export function createOutputTool(
-	_cwd: string,
-	sessionContext?: SessionContext,
-): AgentTool<typeof outputSchema, OutputToolDetails> {
+export function createOutputTool(session: ToolSession): AgentTool<typeof outputSchema, OutputToolDetails> {
 	return {
 		name: "output",
 		label: "Output",
@@ -99,9 +128,9 @@ export function createOutputTool(
 		parameters: outputSchema,
 		execute: async (
 			_toolCallId: string,
-			params: { ids: string[]; format?: "raw" | "json" | "stripped" },
+			params: { ids: string[]; format?: "raw" | "json" | "stripped"; offset?: number; limit?: number },
 		): Promise<{ content: TextContent[]; details: OutputToolDetails }> => {
-			const sessionFile = sessionContext?.getSessionFile();
+			const sessionFile = session.getSessionFile();
 
 			if (!sessionFile) {
 				return {
@@ -131,15 +160,37 @@ export function createOutputTool(
 					continue;
 				}
 
-				const content = fs.readFileSync(outputPath, "utf-8");
-				outputContentById.set(id, content);
+				const rawContent = fs.readFileSync(outputPath, "utf-8");
+				const rawLines = rawContent.split("\n");
+				const totalLines = rawLines.length;
+				const totalChars = rawContent.length;
+
+				let selectedContent = rawContent;
+				let range: OutputRange | undefined;
+
+				if (params.offset !== undefined || params.limit !== undefined) {
+					const startLine = Math.max(1, params.offset ?? 1);
+					if (startLine > totalLines) {
+						throw new Error(
+							`Offset ${params.offset ?? startLine} is beyond end of output (${totalLines} lines) for ${id}`,
+						);
+					}
+					const effectiveLimit = params.limit ?? totalLines - startLine + 1;
+					const endLine = Math.min(totalLines, startLine + effectiveLimit - 1);
+					const selectedLines = rawLines.slice(startLine - 1, endLine);
+					selectedContent = selectedLines.join("\n");
+					range = { startLine, endLine, totalLines };
+				}
+
+				outputContentById.set(id, selectedContent);
 				outputs.push({
 					id,
 					path: outputPath,
-					lineCount: content.split("\n").length,
-					charCount: content.length,
+					lineCount: totalLines,
+					charCount: totalChars,
 					provenance: parseOutputProvenance(id),
-					previewLines: extractPreviewLines(content, 4),
+					previewLines: extractPreviewLines(selectedContent, 4),
+					range,
 				});
 			}
 
@@ -167,6 +218,7 @@ export function createOutputTool(
 					charCount: o.charCount,
 					provenance: o.provenance,
 					previewLines: o.previewLines,
+					range: o.range,
 					content: outputContentById.get(o.id) ?? "",
 				}));
 				contentText = JSON.stringify(jsonData, null, 2);
@@ -177,6 +229,10 @@ export function createOutputTool(
 					if (format === "stripped") {
 						content = stripAnsi(content);
 					}
+					if (o.range && o.range.endLine < o.range.totalLines) {
+						const nextOffset = o.range.endLine + 1;
+						content += `\n\n[Showing lines ${o.range.startLine}-${o.range.endLine} of ${o.range.totalLines}. Use offset=${nextOffset} to continue]`;
+					}
 					// Add header for multiple outputs
 					if (outputs.length > 1) {
 						return `=== ${o.id} (${o.lineCount} lines, ${formatBytes(o.charCount)}) ===\n${content}`;
@@ -194,5 +250,109 @@ export function createOutputTool(
 	};
 }
 
-/** Default output tool using process.cwd() - for backwards compatibility */
-export const outputTool = createOutputTool(process.cwd());
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface OutputRenderArgs {
+	ids: string[];
+	format?: "raw" | "json" | "stripped";
+	offset?: number;
+	limit?: number;
+}
+
+type OutputEntryItem = OutputToolDetails["outputs"][number];
+
+function formatOutputMeta(entry: OutputEntryItem, uiTheme: Theme): string {
+	const metaParts: string[] = [];
+	if (entry.range) {
+		metaParts.push(`lines ${entry.range.startLine}-${entry.range.endLine} of ${entry.range.totalLines}`);
+	} else {
+		metaParts.push(formatCount("line", entry.lineCount));
+	}
+	metaParts.push(formatBytes(entry.charCount));
+	if (entry.provenance) {
+		metaParts.push(`agent ${entry.provenance.agent}(${entry.provenance.index})`);
+	}
+	return uiTheme.fg("dim", metaParts.join(uiTheme.sep.dot));
+}
+
+export const outputToolRenderer = {
+	renderCall(args: OutputRenderArgs, uiTheme: Theme): Component {
+		const ids = args.ids?.join(", ") ?? "?";
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Output"));
+		let text = `${label} ${uiTheme.fg("accent", ids)}`;
+
+		const meta: string[] = [];
+		if (args.format && args.format !== "raw") meta.push(`format:${args.format}`);
+		if (args.offset !== undefined) meta.push(`offset:${args.offset}`);
+		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
+		text += formatMeta(meta, uiTheme);
+
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: OutputToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+
+		if (details?.notFound?.length) {
+			const icon = uiTheme.styledSymbol("status.error", "error");
+			let text = `${icon} ${uiTheme.fg("error", `Error: Not found: ${details.notFound.join(", ")}`)}`;
+			if (details.availableIds?.length) {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", `Available: ${details.availableIds.join(", ")}`)}`;
+			} else {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", "No outputs available in current session")}`;
+			}
+			return new Text(text, 0, 0);
+		}
+
+		const outputs = details?.outputs ?? [];
+
+		if (outputs.length === 0) {
+			const textContent = result.content?.find((c) => c.type === "text")?.text;
+			return new Text(formatEmptyMessage(textContent || "No outputs", uiTheme), 0, 0);
+		}
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summary = `read ${formatCount("output", outputs.length)}`;
+		const previewLimit = expanded ? 3 : 1;
+		const maxOutputs = expanded ? outputs.length : Math.min(outputs.length, 5);
+		const hasMoreOutputs = outputs.length > maxOutputs;
+		const hasMorePreview = outputs.some((o) => (o.previewLines?.length ?? 0) > previewLimit);
+		const expandHint = formatExpandHint(expanded, hasMoreOutputs || hasMorePreview, uiTheme);
+		let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+
+		for (let i = 0; i < maxOutputs; i++) {
+			const o = outputs[i];
+			const isLast = i === maxOutputs - 1 && !hasMoreOutputs;
+			const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+			text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", o.id)} ${formatOutputMeta(o, uiTheme)}`;
+
+			const previewLines = o.previewLines ?? [];
+			const shownPreview = previewLines.slice(0, previewLimit);
+			if (shownPreview.length > 0) {
+				const childPrefix = isLast ? "   " : ` ${uiTheme.fg("dim", uiTheme.tree.vertical)} `;
+				for (const line of shownPreview) {
+					const previewText = truncate(line, TRUNCATE_LENGTHS.CONTENT, uiTheme.format.ellipsis);
+					text += `\n${childPrefix}${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
+						"muted",
+						"preview:",
+					)} ${uiTheme.fg("toolOutput", previewText)}`;
+				}
+			}
+		}
+
+		if (hasMoreOutputs) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+				"muted",
+				formatMoreItems(outputs.length - maxOutputs, "output", uiTheme),
+			)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

package/src/core/tools/read.ts

@@ -1,17 +1,30 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
+import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+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, highlightCode, type Theme } from "../../modes/interactive/theme/theme";
 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 type { RenderResultOptions } from "../custom-tools/types";
+import type { ToolSession } from "../sdk";
 import { untilAborted } from "../utils";
 import { createLsTool } from "./ls";
 import { resolveReadPath, resolveToCwd } from "./path-utils";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, type TruncationResult, truncateHead } from "./truncate";
+import { replaceTabs, shortenPath, wrapBrackets } from "./render-utils";
+import {
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	type TruncationResult,
+	truncateHead,
+	truncateStringToBytesFromStart,
+} from "./truncate";
 
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
@@ -328,14 +341,9 @@ export interface ReadToolDetails {
 	redirectedTo?: "ls";
 }
 
-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);
+export function createReadTool(session: ToolSession): AgentTool<typeof readSchema> {
+	const autoResizeImages = session.settings?.getImageAutoResize() ?? true;
+	const lsTool = createLsTool(session);
 	return {
 		name: "read",
 		label: "Read",
@@ -346,7 +354,7 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 			{ path: readPath, offset, limit }: { path: string; offset?: number; limit?: number },
 			signal?: AbortSignal,
 		) => {
-			const absolutePath = resolveReadPath(readPath, cwd);
+			const absolutePath = resolveReadPath(readPath, session.cwd);
 
 			return untilAborted(signal, async () => {
 				let isDirectory = false;
@@ -366,14 +374,12 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 					}
 				} catch (error) {
 					if (isNotFoundError(error)) {
-						const suggestions = await findReadPathSuggestions(readPath, cwd);
+						const suggestions = await findReadPathSuggestions(readPath, session.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")}`;
+							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.]`;
 							}
@@ -450,9 +456,7 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 						let outputText = truncation.content;
 
 						if (truncation.truncated) {
-							outputText += `\n\n[Document converted via markitdown. Output truncated to $formatSize(
-								DEFAULT_MAX_BYTES,
-							)]`;
+							outputText += `\n\n[Document converted via markitdown. Output truncated to ${formatSize(DEFAULT_MAX_BYTES)}]`;
 							details = { truncation };
 						}
 
@@ -498,11 +502,21 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 					let outputText: string;
 
 					if (truncation.firstLineExceedsLimit) {
-						// First line at offset exceeds 30KB - tell model to use bash
-						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' ${readPath} | head -c ${DEFAULT_MAX_BYTES}]`;
+						const firstLine = allLines[startLine] ?? "";
+						const firstLineBytes = Buffer.byteLength(firstLine, "utf-8");
+						const snippet = truncateStringToBytesFromStart(firstLine, DEFAULT_MAX_BYTES);
+						const shownSize = formatSize(snippet.bytes);
+
+						outputText = snippet.text;
+						if (outputText.length > 0) {
+							outputText += `\n\n[Line ${startLineDisplay} is ${formatSize(
+								firstLineBytes,
+							)}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Showing first ${shownSize} of the line.]`;
+						} else {
+							outputText = `[Line ${startLineDisplay} is ${formatSize(
+								firstLineBytes,
+							)}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Unable to display a valid UTF-8 snippet.]`;
+						}
 						details = { truncation };
 					} else if (truncation.truncated) {
 						// Truncation occurred - build actionable notice
@@ -540,5 +554,93 @@ export function createReadTool(cwd: string, options?: ReadToolOptions): AgentToo
 	};
 }
 
-/** Default read tool using process.cwd() - for backwards compatibility */
-export const readTool = createReadTool(process.cwd());
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface ReadRenderArgs {
+	path?: string;
+	file_path?: string;
+	offset?: number;
+	limit?: number;
+}
+
+const IMAGE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "ico", "bmp", "tiff"]);
+const BINARY_EXTENSIONS = new Set(["pdf", "zip", "tar", "gz", "exe", "dll", "so", "dylib", "wasm"]);
+
+function getFileType(filePath: string): "image" | "binary" | "text" {
+	const ext = filePath.split(".").pop()?.toLowerCase();
+	if (!ext) return "text";
+	if (IMAGE_EXTENSIONS.has(ext)) return "image";
+	if (BINARY_EXTENSIONS.has(ext)) return "binary";
+	return "text";
+}
+
+export const readToolRenderer = {
+	renderCall(args: ReadRenderArgs, uiTheme: Theme): Component {
+		const rawPath = args.file_path || args.path || "";
+		const filePath = shortenPath(rawPath);
+		const offset = args.offset;
+		const limit = args.limit;
+
+		let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
+		if (offset !== undefined || limit !== undefined) {
+			const startLine = offset ?? 1;
+			const endLine = limit !== undefined ? startLine + limit - 1 : "";
+			pathDisplay += uiTheme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+		}
+
+		const text = `${uiTheme.fg("toolTitle", uiTheme.bold("Read"))} ${pathDisplay}`;
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: ReadToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+		args?: ReadRenderArgs,
+	): Component {
+		const rawPath = args?.file_path || args?.path || "";
+		const fileType = getFileType(rawPath);
+		const details = result.details;
+		const lines: string[] = [];
+
+		const output = result.content?.find((c) => c.type === "text")?.text ?? "";
+
+		if (fileType === "image") {
+			lines.push(uiTheme.fg("muted", "Image rendered below"));
+		} else if (fileType === "binary") {
+			// Binary files just show the header from renderCall
+		} else {
+			// Text file
+			const lang = getLanguageFromPath(rawPath);
+			const contentLines = lang ? highlightCode(replaceTabs(output), lang) : output.split("\n");
+
+			if (expanded) {
+				lines.push(
+					...contentLines.map((line: string) =>
+						lang ? replaceTabs(line) : uiTheme.fg("toolOutput", replaceTabs(line)),
+					),
+				);
+			} else {
+				lines.push(uiTheme.fg("dim", `${uiTheme.nav.expand} Ctrl+O to show content`));
+			}
+
+			// Truncation warning
+			const truncation = details?.truncation;
+			if (truncation?.truncated) {
+				let warning: string;
+				if (truncation.firstLineExceedsLimit) {
+					warning = `First line exceeds ${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`;
+				} else if (truncation.truncatedBy === "lines") {
+					warning = `Truncated: ${truncation.outputLines} of ${truncation.totalLines} lines (${truncation.maxLines ?? DEFAULT_MAX_LINES} line limit)`;
+				} else {
+					warning = `Truncated: ${truncation.outputLines} lines (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`;
+				}
+				lines.push(uiTheme.fg("warning", wrapBrackets(warning, uiTheme)));
+			}
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+};