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

package/src/modes/interactive/components/tool-execution.ts

@@ -22,6 +22,289 @@ import { truncateToVisualLines } from "./visual-truncate";
 
 // Preview line limit for bash when not expanded
 const BASH_PREVIEW_LINES = 5;
+const GENERIC_PREVIEW_LINES = 6;
+const GENERIC_ARG_PREVIEW = 6;
+const GENERIC_VALUE_MAX = 80;
+const EDIT_DIFF_PREVIEW_HUNKS = 2;
+const EDIT_DIFF_PREVIEW_LINES = 24;
+
+function wrapBrackets(text: string): string {
+	return `${theme.format.bracketLeft}${text}${theme.format.bracketRight}`;
+}
+
+function countLines(text: string): number {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+
+function formatMetadataLine(lineCount: number | null, language: string | undefined): string {
+	const icon = theme.getLangIcon(language);
+	if (lineCount !== null) {
+		return theme.fg("dim", `${icon} ${lineCount} lines`);
+	}
+	return theme.fg("dim", `${icon}`);
+}
+
+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";
+}
+
+function formatDiffStats(added: number, removed: number, hunks: number): string {
+	const parts: string[] = [];
+	if (added > 0) parts.push(theme.fg("success", `+${added}`));
+	if (removed > 0) parts.push(theme.fg("error", `-${removed}`));
+	if (hunks > 0) parts.push(theme.fg("dim", `${hunks} hunk${hunks !== 1 ? "s" : ""}`));
+	return parts.join(theme.fg("dim", " / "));
+}
+
+type DiffStats = {
+	added: number;
+	removed: number;
+	hunks: number;
+	lines: number;
+};
+
+function getDiffStats(diffText: string): DiffStats {
+	const lines = diffText ? diffText.split("\n") : [];
+	let added = 0;
+	let removed = 0;
+	let hunks = 0;
+	let inHunk = false;
+
+	for (const line of lines) {
+		const isAdded = line.startsWith("+");
+		const isRemoved = line.startsWith("-");
+		const isChange = isAdded || isRemoved;
+
+		if (isAdded) added++;
+		if (isRemoved) removed++;
+
+		if (isChange && !inHunk) {
+			hunks++;
+			inHunk = true;
+		} else if (!isChange) {
+			inHunk = false;
+		}
+	}
+
+	return { added, removed, hunks, lines: lines.length };
+}
+
+function truncateDiffByHunk(
+	diffText: string,
+	maxHunks: number,
+	maxLines: number,
+): { text: string; hiddenHunks: number; hiddenLines: number } {
+	const lines = diffText ? diffText.split("\n") : [];
+	const totalStats = getDiffStats(diffText);
+	const kept: string[] = [];
+	let inHunk = false;
+	let currentHunks = 0;
+	let reachedLimit = false;
+
+	for (const line of lines) {
+		const isChange = line.startsWith("+") || line.startsWith("-");
+		if (isChange && !inHunk) {
+			currentHunks++;
+			inHunk = true;
+		}
+		if (!isChange) {
+			inHunk = false;
+		}
+
+		if (currentHunks > maxHunks) {
+			reachedLimit = true;
+			break;
+		}
+
+		kept.push(line);
+		if (kept.length >= maxLines) {
+			reachedLimit = true;
+			break;
+		}
+	}
+
+	if (!reachedLimit) {
+		return { text: diffText, hiddenHunks: 0, hiddenLines: 0 };
+	}
+
+	const keptStats = getDiffStats(kept.join("\n"));
+	return {
+		text: kept.join("\n"),
+		hiddenHunks: Math.max(0, totalStats.hunks - keptStats.hunks),
+		hiddenLines: Math.max(0, totalStats.lines - kept.length),
+	};
+}
+
+interface ParsedDiagnostic {
+	filePath: string;
+	line: number;
+	col: number;
+	severity: "error" | "warning" | "info" | "hint";
+	source?: string;
+	message: string;
+	code?: string;
+}
+
+function parseDiagnosticMessage(msg: string): ParsedDiagnostic | null {
+	// Format: filePath:line:col [severity] [source] message (code)
+	const match = msg.match(/^(.+?):(\d+):(\d+)\s+\[(\w+)\]\s+(?:\[([^\]]+)\]\s+)?(.+?)(?:\s+\(([^)]+)\))?$/);
+	if (!match) return null;
+	return {
+		filePath: match[1],
+		line: parseInt(match[2], 10),
+		col: parseInt(match[3], 10),
+		severity: match[4] as ParsedDiagnostic["severity"],
+		source: match[5],
+		message: match[6],
+		code: match[7],
+	};
+}
+
+function formatDiagnostics(diag: { errored: boolean; summary: string; messages: string[] }, expanded: boolean): string {
+	if (diag.messages.length === 0) return "";
+
+	// Parse and group diagnostics by file
+	const byFile = new Map<string, ParsedDiagnostic[]>();
+	const unparsed: string[] = [];
+
+	for (const msg of diag.messages) {
+		const parsed = parseDiagnosticMessage(msg);
+		if (parsed) {
+			const existing = byFile.get(parsed.filePath) ?? [];
+			existing.push(parsed);
+			byFile.set(parsed.filePath, existing);
+		} else {
+			unparsed.push(msg);
+		}
+	}
+
+	const headerIcon = diag.errored
+		? theme.styledSymbol("status.error", "error")
+		: theme.styledSymbol("status.warning", "warning");
+	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${diag.summary})`)}`;
+
+	const maxDiags = expanded ? diag.messages.length : 5;
+	let shown = 0;
+
+	// Render grouped diagnostics with file icons
+	const files = Array.from(byFile.entries());
+	for (let fi = 0; fi < files.length && shown < maxDiags; fi++) {
+		const [filePath, diagnostics] = files[fi];
+		const isLastFile = fi === files.length - 1 && unparsed.length === 0;
+		const fileBranch = isLastFile ? theme.tree.last : theme.tree.branch;
+
+		// File header with icon
+		output += `\n ${theme.fg("dim", fileBranch)} ${theme.fg("muted", theme.icon.file)} ${theme.fg("accent", filePath)}`;
+		shown++;
+
+		// Render diagnostics for this file
+		for (let di = 0; di < diagnostics.length && shown < maxDiags; di++) {
+			const d = diagnostics[di];
+			const isLastDiag = di === diagnostics.length - 1;
+			const diagBranch = isLastFile
+				? isLastDiag
+					? `   ${theme.tree.last}`
+					: `   ${theme.tree.branch}`
+				: isLastDiag
+					? ` ${theme.tree.vertical} ${theme.tree.last}`
+					: ` ${theme.tree.vertical} ${theme.tree.branch}`;
+
+			const sevIcon =
+				d.severity === "error"
+					? theme.styledSymbol("status.error", "error")
+					: d.severity === "warning"
+						? theme.styledSymbol("status.warning", "warning")
+						: theme.styledSymbol("status.info", "muted");
+			const location = theme.fg("dim", `:${d.line}:${d.col}`);
+			const codeTag = d.code ? theme.fg("dim", ` (${d.code})`) : "";
+			const msgColor = d.severity === "error" ? "error" : d.severity === "warning" ? "warning" : "toolOutput";
+
+			output += `\n ${theme.fg("dim", diagBranch)} ${sevIcon}${location} ${theme.fg(msgColor, d.message)}${codeTag}`;
+			shown++;
+		}
+	}
+
+	// Render unparsed messages (fallback)
+	for (const msg of unparsed) {
+		if (shown >= maxDiags) break;
+		const color = msg.includes("[error]") ? "error" : msg.includes("[warning]") ? "warning" : "dim";
+		output += `\n ${theme.fg("dim", theme.tree.branch)} ${theme.fg(color, msg)}`;
+		shown++;
+	}
+
+	if (diag.messages.length > shown) {
+		const remaining = diag.messages.length - shown;
+		output += `\n ${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", `${theme.format.ellipsis} ${remaining} more`)} ${theme.fg("dim", "(Ctrl+O to expand)")}`;
+	}
+
+	return output;
+}
+
+function formatCompactValue(value: unknown, maxLength: number): string {
+	let rendered = "";
+
+	if (value === null) {
+		rendered = "null";
+	} else if (value === undefined) {
+		rendered = "undefined";
+	} else if (typeof value === "string") {
+		rendered = value;
+	} else if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+		rendered = String(value);
+	} else if (Array.isArray(value)) {
+		const previewItems = value.slice(0, 3).map((item) => formatCompactValue(item, maxLength));
+		rendered = `[${previewItems.join(", ")}${value.length > 3 ? ", ..." : ""}]`;
+	} else if (typeof value === "object") {
+		try {
+			rendered = JSON.stringify(value);
+		} catch {
+			rendered = "[object]";
+		}
+	} else if (typeof value === "function") {
+		rendered = "[function]";
+	} else {
+		rendered = String(value);
+	}
+
+	if (rendered.length > maxLength) {
+		rendered = `${rendered.slice(0, maxLength - 1)}${theme.format.ellipsis}`;
+	}
+
+	return rendered;
+}
+
+function formatArgsPreview(
+	args: unknown,
+	maxEntries: number,
+	maxValueLength: number,
+): { lines: string[]; remaining: number; total: number } {
+	if (args === undefined) {
+		return { lines: [theme.fg("dim", "(none)")], remaining: 0, total: 0 };
+	}
+	if (args === null || typeof args !== "object") {
+		const single = theme.fg("toolOutput", formatCompactValue(args, maxValueLength));
+		return { lines: [single], remaining: 0, total: 1 };
+	}
+
+	const entries = Object.entries(args as Record<string, unknown>);
+	const total = entries.length;
+	const visible = entries.slice(0, maxEntries);
+	const lines = visible.map(([key, value]) => {
+		const keyText = theme.fg("accent", key);
+		const valueText = theme.fg("toolOutput", formatCompactValue(value, maxValueLength));
+		return `${keyText}: ${valueText}`;
+	});
+
+	return { lines, remaining: Math.max(total - visible.length, 0), total };
+}
 
 /**
  * Convert absolute path to tilde notation if it's in home directory
@@ -63,12 +346,15 @@ export class ToolExecutionComponent extends Container {
 	private cwd: string;
 	private result?: {
 		content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
-		isError: boolean;
+		isError?: boolean;
 		details?: any;
 	};
 	// Cached edit diff preview (computed when args arrive, before tool executes)
 	private editDiffPreview?: EditDiffResult | EditDiffError;
 	private editDiffArgsKey?: string; // Track which args the preview is for
+	// Spinner animation for partial task results
+	private spinnerFrame = 0;
+	private spinnerInterval: ReturnType<typeof setInterval> | null = null;
 
 	constructor(
 		toolName: string,
@@ -153,15 +439,45 @@ export class ToolExecutionComponent extends Container {
 		result: {
 			content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
 			details?: any;
-			isError: boolean;
+			isError?: boolean;
 		},
 		isPartial = false,
 	): void {
 		this.result = result;
 		this.isPartial = isPartial;
+		this.updateSpinnerAnimation();
 		this.updateDisplay();
 	}
 
+	/**
+	 * Start or stop spinner animation based on whether this is a partial task result.
+	 */
+	private updateSpinnerAnimation(): void {
+		const needsSpinner = this.isPartial && this.toolName === "task";
+		if (needsSpinner && !this.spinnerInterval) {
+			this.spinnerInterval = setInterval(() => {
+				const frameCount = theme.spinnerFrames.length;
+				if (frameCount === 0) return;
+				this.spinnerFrame = (this.spinnerFrame + 1) % frameCount;
+				this.updateDisplay();
+				this.ui.requestRender();
+			}, 80);
+		} else if (!needsSpinner && this.spinnerInterval) {
+			clearInterval(this.spinnerInterval);
+			this.spinnerInterval = null;
+		}
+	}
+
+	/**
+	 * Stop spinner animation and cleanup resources.
+	 */
+	stopAnimation(): void {
+		if (this.spinnerInterval) {
+			clearInterval(this.spinnerInterval);
+			this.spinnerInterval = null;
+		}
+	}
+
 	setExpanded(expanded: boolean): void {
 		this.expanded = expanded;
 		this.updateDisplay();
@@ -207,7 +523,7 @@ export class ToolExecutionComponent extends Container {
 				try {
 					const resultComponent = this.customTool.renderResult(
 						{ content: this.result.content as any, details: this.result.details },
-						{ expanded: this.expanded, isPartial: this.isPartial },
+						{ expanded: this.expanded, isPartial: this.isPartial, spinnerFrame: this.spinnerFrame },
 						theme,
 					);
 					if (resultComponent) {
@@ -254,7 +570,7 @@ export class ToolExecutionComponent extends Container {
 				try {
 					const resultComponent = renderer.renderResult(
 						{ content: this.result.content as any, details: this.result.details },
-						{ expanded: this.expanded, isPartial: this.isPartial },
+						{ expanded: this.expanded, isPartial: this.isPartial, spinnerFrame: this.spinnerFrame },
 						theme,
 					);
 					if (resultComponent) {
@@ -314,7 +630,11 @@ export class ToolExecutionComponent extends Container {
 
 		// Header
 		this.contentBox.addChild(
-			new Text(theme.fg("toolTitle", theme.bold(`$ ${command || theme.fg("toolOutput", "...")}`)), 0, 0),
+			new Text(
+				theme.fg("toolTitle", theme.bold(`$ ${command || theme.fg("toolOutput", theme.format.ellipsis)}`)),
+				0,
+				0,
+			),
 		);
 
 		if (this.result) {
@@ -339,9 +659,17 @@ export class ToolExecutionComponent extends Container {
 						this.ui.terminal.columns - 2,
 					);
 
+					const totalVisualLines = skippedCount + visualLines.length;
 					if (skippedCount > 0) {
 						this.contentBox.addChild(
-							new Text(theme.fg("toolOutput", `\n... (${skippedCount} earlier lines)`), 0, 0),
+							new Text(
+								theme.fg(
+									"dim",
+									`\n${theme.format.ellipsis} (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
+								),
+								0,
+								0,
+							),
 						);
 					}
 
@@ -372,7 +700,7 @@ export class ToolExecutionComponent extends Container {
 						);
 					}
 				}
-				this.contentBox.addChild(new Text(`\n${theme.fg("warning", `[${warnings.join(". ")}]`)}`, 0, 0));
+				this.contentBox.addChild(new Text(`\n${theme.fg("warning", wrapBrackets(warnings.join(". ")))}`, 0, 0));
 			}
 		}
 	}
@@ -408,11 +736,13 @@ export class ToolExecutionComponent extends Container {
 		let text = "";
 
 		if (this.toolName === "read") {
-			const path = shortenPath(this.args?.file_path || this.args?.path || "");
+			const rawPath = this.args?.file_path || this.args?.path || "";
+			const path = shortenPath(rawPath);
 			const offset = this.args?.offset;
 			const limit = this.args?.limit;
+			const fileType = getFileType(rawPath);
 
-			let pathDisplay = path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
+			let pathDisplay = path ? theme.fg("accent", path) : theme.fg("toolOutput", theme.format.ellipsis);
 			if (offset !== undefined || limit !== undefined) {
 				const startLine = offset ?? 1;
 				const endLine = limit !== undefined ? startLine + limit - 1 : "";
@@ -423,50 +753,46 @@ export class ToolExecutionComponent extends Container {
 
 			if (this.result) {
 				const output = this.getTextOutput();
-				const rawPath = this.args?.file_path || this.args?.path || "";
-				const lang = getLanguageFromPath(rawPath);
-				const lines = lang ? highlightCode(replaceTabs(output), lang) : output.split("\n");
 
-				const maxLines = this.expanded ? lines.length : 10;
-				const displayLines = lines.slice(0, maxLines);
-				const remaining = lines.length - maxLines;
-
-				text +=
-					"\n\n" +
-					displayLines
-						.map((line: string) => (lang ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))))
-						.join("\n");
-				if (remaining > 0) {
-					text += theme.fg("toolOutput", `\n... (${remaining} more lines)`);
-				}
+				if (fileType === "image") {
+					// Image file - use image icon
+					const ext = rawPath.split(".").pop()?.toLowerCase() ?? "image";
+					text += `${theme.sep.dot}${theme.fg("dim", theme.getLangIcon(ext))}`;
+					// Images are rendered by the image component, just show hint
+					text += `\n${theme.fg("muted", "Image rendered below")}`;
+				} else if (fileType === "binary") {
+					// Binary file - use binary/pdf/archive icon based on extension
+					const ext = rawPath.split(".").pop()?.toLowerCase() ?? "binary";
+					text += `${theme.sep.dot}${theme.fg("dim", theme.getLangIcon(ext))}`;
+				} else {
+					// Text file - show line count and language on same line
+					const lang = getLanguageFromPath(rawPath);
+					const lines = lang ? highlightCode(replaceTabs(output), lang) : output.split("\n");
+					text += `${theme.sep.dot}${formatMetadataLine(null, lang)}`;
 
-				const truncation = this.result.details?.truncation;
-				if (truncation?.truncated) {
-					if (truncation.firstLineExceedsLimit) {
+					// Content is hidden by default, only shown when expanded
+					if (this.expanded) {
 						text +=
-							"\n" +
-							theme.fg(
-								"warning",
-								`[First line exceeds ${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit]`,
-							);
-					} else if (truncation.truncatedBy === "lines") {
-						text +=
-							"\n" +
-							theme.fg(
-								"warning",
-								`[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines (${
-									truncation.maxLines ?? DEFAULT_MAX_LINES
-								} line limit)]`,
-							);
+							"\n\n" +
+							lines
+								.map((line: string) => (lang ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))))
+								.join("\n");
 					} else {
-						text +=
-							"\n" +
-							theme.fg(
-								"warning",
-								`[Truncated: ${truncation.outputLines} lines shown (${formatSize(
-									truncation.maxBytes ?? DEFAULT_MAX_BYTES,
-								)} limit)]`,
-							);
+						text += `\n${theme.fg("dim", `${theme.nav.expand} Ctrl+O to show content`)}`;
+					}
+
+					// Truncation warning
+					const truncation = this.result.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)`;
+						}
+						text += `\n${theme.fg("warning", wrapBrackets(warning))}`;
 					}
 				}
 			}
@@ -485,7 +811,9 @@ export class ToolExecutionComponent extends Container {
 			text =
 				theme.fg("toolTitle", theme.bold("write")) +
 				" " +
-				(path ? theme.fg("accent", path) : theme.fg("toolOutput", "..."));
+				(path ? theme.fg("accent", path) : theme.fg("toolOutput", theme.format.ellipsis));
+
+			text += `\n${formatMetadataLine(countLines(fileContent), lang ?? "text")}`;
 
 			if (fileContent) {
 				const maxLines = this.expanded ? lines.length : 10;
@@ -498,33 +826,23 @@ export class ToolExecutionComponent extends Container {
 						.map((line: string) => (lang ? replaceTabs(line) : theme.fg("toolOutput", replaceTabs(line))))
 						.join("\n");
 				if (remaining > 0) {
-					text += theme.fg("toolOutput", `\n... (${remaining} more lines, ${totalLines} total)`);
+					text += theme.fg(
+						"toolOutput",
+						`\n${theme.format.ellipsis} (${remaining} more lines, ${totalLines} total) ${wrapBrackets("Ctrl+O to expand")}`,
+					);
 				}
 			}
 
 			// Show LSP diagnostics if available
 			if (this.result?.details?.diagnostics) {
-				const diag = this.result.details.diagnostics;
-				if (diag.messages.length > 0) {
-					const icon = diag.errored ? theme.fg("error", "●") : theme.fg("warning", "●");
-					text += `\n\n${icon} ${theme.fg("toolTitle", "LSP Diagnostics")} ${theme.fg("dim", `(${diag.summary})`)}`;
-					const maxDiags = this.expanded ? diag.messages.length : 5;
-					const displayDiags = diag.messages.slice(0, maxDiags);
-					for (const d of displayDiags) {
-						const color = d.includes("[error]") ? "error" : d.includes("[warning]") ? "warning" : "dim";
-						text += `\n  ${theme.fg(color, d)}`;
-					}
-					if (diag.messages.length > maxDiags) {
-						text += theme.fg("dim", `\n  ... (${diag.messages.length - maxDiags} more)`);
-					}
-				}
+				text += formatDiagnostics(this.result.details.diagnostics, this.expanded);
 			}
 		} else if (this.toolName === "edit") {
 			const rawPath = this.args?.file_path || this.args?.path || "";
 			const path = shortenPath(rawPath);
 
 			// Build path display, appending :line if we have diff info
-			let pathDisplay = path ? theme.fg("accent", path) : theme.fg("toolOutput", "...");
+			let pathDisplay = path ? theme.fg("accent", path) : theme.fg("toolOutput", theme.format.ellipsis);
 			const firstChangedLine =
 				(this.editDiffPreview && "firstChangedLine" in this.editDiffPreview
 					? this.editDiffPreview.firstChangedLine
@@ -536,6 +854,10 @@ export class ToolExecutionComponent extends Container {
 
 			text = `${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`;
 
+			const editLanguage = getLanguageFromPath(rawPath) ?? "text";
+			const editLineCount = countLines(this.args?.newText ?? this.args?.oldText ?? "");
+			text += `\n${formatMetadataLine(editLineCount, editLanguage)}`;
+
 			if (this.result?.isError) {
 				// Show error from result
 				const errorText = this.getTextOutput();
@@ -547,162 +869,75 @@ export class ToolExecutionComponent extends Container {
 				if ("error" in this.editDiffPreview) {
 					text += `\n\n${theme.fg("error", this.editDiffPreview.error)}`;
 				} else if (this.editDiffPreview.diff) {
-					text += `\n\n${renderDiff(this.editDiffPreview.diff, { filePath: rawPath })}`;
+					const diffStats = getDiffStats(this.editDiffPreview.diff);
+					text += `\n${theme.fg("dim", theme.format.bracketLeft)}${formatDiffStats(diffStats.added, diffStats.removed, diffStats.hunks)}${theme.fg("dim", theme.format.bracketRight)}`;
+
+					const {
+						text: diffText,
+						hiddenHunks,
+						hiddenLines,
+					} = this.expanded
+						? { text: this.editDiffPreview.diff, hiddenHunks: 0, hiddenLines: 0 }
+						: truncateDiffByHunk(this.editDiffPreview.diff, EDIT_DIFF_PREVIEW_HUNKS, EDIT_DIFF_PREVIEW_LINES);
+
+					text += `\n\n${renderDiff(diffText, { filePath: rawPath })}`;
+					if (!this.expanded && (hiddenHunks > 0 || hiddenLines > 0)) {
+						const remainder: string[] = [];
+						if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
+						if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+						text += theme.fg(
+							"toolOutput",
+							`\n${theme.format.ellipsis} (${remainder.join(", ")}) ${wrapBrackets("Ctrl+O to expand")}`,
+						);
+					}
 				}
 			}
 
 			// Show LSP diagnostics if available
 			if (this.result?.details?.diagnostics) {
-				const diag = this.result.details.diagnostics;
-				if (diag.messages.length > 0) {
-					const icon = diag.errored ? theme.fg("error", "●") : theme.fg("warning", "●");
-					text += `\n\n${icon} ${theme.fg("toolTitle", "LSP Diagnostics")} ${theme.fg("dim", `(${diag.summary})`)}`;
-					const maxDiags = this.expanded ? diag.messages.length : 5;
-					const displayDiags = diag.messages.slice(0, maxDiags);
-					for (const d of displayDiags) {
-						const color = d.includes("[error]") ? "error" : d.includes("[warning]") ? "warning" : "dim";
-						text += `\n  ${theme.fg(color, d)}`;
-					}
-					if (diag.messages.length > maxDiags) {
-						text += theme.fg("dim", `\n  ... (${diag.messages.length - maxDiags} more)`);
-					}
-				}
-			}
-		} else if (this.toolName === "ls") {
-			const path = shortenPath(this.args?.path || ".");
-			const limit = this.args?.limit;
-
-			text = `${theme.fg("toolTitle", theme.bold("ls"))} ${theme.fg("accent", path)}`;
-			if (limit !== undefined) {
-				text += theme.fg("toolOutput", ` (limit ${limit})`);
-			}
-
-			if (this.result) {
-				const output = this.getTextOutput().trim();
-				if (output) {
-					const lines = output.split("\n");
-					const maxLines = this.expanded ? lines.length : 20;
-					const displayLines = lines.slice(0, maxLines);
-					const remaining = lines.length - maxLines;
-
-					text += `\n\n${displayLines.map((line: string) => theme.fg("toolOutput", line)).join("\n")}`;
-					if (remaining > 0) {
-						text += theme.fg("toolOutput", `\n... (${remaining} more lines)`);
-					}
-				}
-
-				const entryLimit = this.result.details?.entryLimitReached;
-				const truncation = this.result.details?.truncation;
-				if (entryLimit || truncation?.truncated) {
-					const warnings: string[] = [];
-					if (entryLimit) {
-						warnings.push(`${entryLimit} entries limit`);
-					}
-					if (truncation?.truncated) {
-						warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
-					}
-					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
-				}
-			}
-		} else if (this.toolName === "find") {
-			const pattern = this.args?.pattern || "";
-			const path = shortenPath(this.args?.path || ".");
-			const limit = this.args?.limit;
-
-			text =
-				theme.fg("toolTitle", theme.bold("find")) +
-				" " +
-				theme.fg("accent", pattern) +
-				theme.fg("toolOutput", ` in ${path}`);
-			if (limit !== undefined) {
-				text += theme.fg("toolOutput", ` (limit ${limit})`);
-			}
-
-			if (this.result) {
-				const output = this.getTextOutput().trim();
-				if (output) {
-					const lines = output.split("\n");
-					const maxLines = this.expanded ? lines.length : 20;
-					const displayLines = lines.slice(0, maxLines);
-					const remaining = lines.length - maxLines;
-
-					text += `\n\n${displayLines.map((line: string) => theme.fg("toolOutput", line)).join("\n")}`;
-					if (remaining > 0) {
-						text += theme.fg("toolOutput", `\n... (${remaining} more lines)`);
-					}
-				}
-
-				const resultLimit = this.result.details?.resultLimitReached;
-				const truncation = this.result.details?.truncation;
-				if (resultLimit || truncation?.truncated) {
-					const warnings: string[] = [];
-					if (resultLimit) {
-						warnings.push(`${resultLimit} results limit`);
-					}
-					if (truncation?.truncated) {
-						warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
-					}
-					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
-				}
-			}
-		} else if (this.toolName === "grep") {
-			const pattern = this.args?.pattern || "";
-			const path = shortenPath(this.args?.path || ".");
-			const glob = this.args?.glob;
-			const limit = this.args?.limit;
-
-			text =
-				theme.fg("toolTitle", theme.bold("grep")) +
-				" " +
-				theme.fg("accent", `/${pattern}/`) +
-				theme.fg("toolOutput", ` in ${path}`);
-			if (glob) {
-				text += theme.fg("toolOutput", ` (${glob})`);
-			}
-			if (limit !== undefined) {
-				text += theme.fg("toolOutput", ` limit ${limit}`);
-			}
-
-			if (this.result) {
-				const output = this.getTextOutput().trim();
-				if (output) {
-					const lines = output.split("\n");
-					const maxLines = this.expanded ? lines.length : 15;
-					const displayLines = lines.slice(0, maxLines);
-					const remaining = lines.length - maxLines;
-
-					text += `\n\n${displayLines.map((line: string) => theme.fg("toolOutput", line)).join("\n")}`;
-					if (remaining > 0) {
-						text += theme.fg("toolOutput", `\n... (${remaining} more lines)`);
-					}
-				}
-
-				const matchLimit = this.result.details?.matchLimitReached;
-				const truncation = this.result.details?.truncation;
-				const linesTruncated = this.result.details?.linesTruncated;
-				if (matchLimit || truncation?.truncated || linesTruncated) {
-					const warnings: string[] = [];
-					if (matchLimit) {
-						warnings.push(`${matchLimit} matches limit`);
-					}
-					if (truncation?.truncated) {
-						warnings.push(`${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
-					}
-					if (linesTruncated) {
-						warnings.push("some lines truncated");
-					}
-					text += `\n${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
-				}
+				text += formatDiagnostics(this.result.details.diagnostics, this.expanded);
 			}
 		} else {
 			// Generic tool (shouldn't reach here for custom tools)
 			text = theme.fg("toolTitle", theme.bold(this.toolName));
 
-			const content = JSON.stringify(this.args, null, 2);
-			text += `\n\n${content}`;
-			const output = this.getTextOutput();
+			const argTotal =
+				this.args && typeof this.args === "object"
+					? Object.keys(this.args as Record<string, unknown>).length
+					: this.args === undefined
+						? 0
+						: 1;
+			const argPreviewLimit = this.expanded ? argTotal : GENERIC_ARG_PREVIEW;
+			const valueLimit = this.expanded ? 2000 : GENERIC_VALUE_MAX;
+			const argsPreview = formatArgsPreview(this.args, argPreviewLimit, valueLimit);
+
+			text += `\n\n${theme.fg("toolTitle", "Args")} ${theme.fg("dim", `(${argsPreview.total})`)}`;
+			if (argsPreview.lines.length > 0) {
+				text += `\n${argsPreview.lines.join("\n")}`;
+			} else {
+				text += `\n${theme.fg("dim", "(none)")}`;
+			}
+			if (argsPreview.remaining > 0) {
+				text += theme.fg(
+					"dim",
+					`\n${theme.format.ellipsis} (${argsPreview.remaining} more args) (ctrl+o to expand)`,
+				);
+			}
+
+			const output = this.getTextOutput().trim();
+			text += `\n\n${theme.fg("toolTitle", "Output")}`;
 			if (output) {
-				text += `\n${output}`;
+				const lines = output.split("\n");
+				const maxLines = this.expanded ? lines.length : GENERIC_PREVIEW_LINES;
+				const displayLines = lines.slice(-maxLines);
+				const remaining = lines.length - displayLines.length;
+				text += ` ${theme.fg("dim", `(${lines.length} lines)`)}`;
+				text += `\n${displayLines.map((line) => theme.fg("toolOutput", line)).join("\n")}`;
+				if (remaining > 0) {
+					text += theme.fg("dim", `\n${theme.format.ellipsis} (${remaining} earlier lines) (ctrl+o to expand)`);
+				}
+			} else {
+				text += ` ${theme.fg("dim", "(empty)")}`;
 			}
 		}