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

package/src/core/tools/bash.ts

@@ -1,7 +1,14 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
+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 bashDescription from "../../prompts/tools/bash.md" with { type: "text" };
 import { executeBash } from "../bash-executor";
+import type { RenderResultOptions } from "../custom-tools/types";
+import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
+import type { ToolSession } from "./index";
+import { formatBytes, wrapBrackets } from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
 
 const bashSchema = Type.Object({
@@ -14,7 +21,7 @@ export interface BashToolDetails {
 	fullOutputPath?: string;
 }
 
-export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
+export function createBashTool(session: ToolSession): AgentTool<typeof bashSchema> {
 	return {
 		name: "bash",
 		label: "Bash",
@@ -25,12 +32,25 @@ export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
 			{ command, timeout }: { command: string; timeout?: number },
 			signal?: AbortSignal,
 			onUpdate?,
+			ctx?: AgentToolContext,
 		) => {
+			// Check interception if enabled and available tools are known
+			if (session.settings?.getBashInterceptorEnabled()) {
+				const interception = checkBashInterception(command, ctx?.toolNames ?? []);
+				if (interception.block) {
+					throw new Error(interception.message);
+				}
+				const lsInterception = checkSimpleLsInterception(command, ctx?.toolNames ?? []);
+				if (lsInterception.block) {
+					throw new Error(lsInterception.message);
+				}
+			}
+
 			// Track output for streaming updates
 			let currentOutput = "";
 
 			const result = await executeBash(command, {
-				cwd,
+				cwd: session.cwd,
 				timeout: timeout ? timeout * 1000 : undefined, // Convert to milliseconds
 				signal,
 				onChunk: (chunk) => {
@@ -87,5 +107,101 @@ export function createBashTool(cwd: string): AgentTool<typeof bashSchema> {
 	};
 }
 
-/** Default bash tool using process.cwd() - for backwards compatibility */
-export const bashTool = createBashTool(process.cwd());
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface BashRenderArgs {
+	command?: string;
+	timeout?: number;
+}
+
+interface BashRenderContext {
+	/** Visual lines for truncated output (pre-computed by tool-execution) */
+	visualLines?: string[];
+	/** Number of lines skipped */
+	skippedCount?: number;
+	/** Total visual lines */
+	totalVisualLines?: number;
+}
+
+export const bashToolRenderer = {
+	renderCall(args: BashRenderArgs, uiTheme: Theme): Component {
+		const command = args.command || uiTheme.format.ellipsis;
+		const text = uiTheme.fg("toolTitle", uiTheme.bold(`$ ${command}`));
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: {
+			content: Array<{ type: string; text?: string }>;
+			details?: BashToolDetails;
+		},
+		options: RenderResultOptions & { renderContext?: BashRenderContext },
+		uiTheme: Theme,
+	): Component {
+		const { expanded, renderContext } = options;
+		const details = result.details;
+		const lines: string[] = [];
+
+		// Get output text
+		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
+		const output = textContent.trim();
+
+		if (output) {
+			if (expanded) {
+				// Show all lines when expanded
+				const styledOutput = output
+					.split("\n")
+					.map((line) => uiTheme.fg("toolOutput", line))
+					.join("\n");
+				lines.push(styledOutput);
+			} else if (renderContext?.visualLines) {
+				// Use pre-computed visual lines from tool-execution
+				const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
+				if (skippedCount > 0) {
+					lines.push(
+						uiTheme.fg(
+							"dim",
+							`${uiTheme.format.ellipsis} (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
+						),
+					);
+				}
+				lines.push(...visualLines);
+			} else {
+				// Fallback: show first few lines
+				const outputLines = output.split("\n");
+				const maxLines = 5;
+				const displayLines = outputLines.slice(0, maxLines);
+				const remaining = outputLines.length - maxLines;
+
+				lines.push(...displayLines.map((line) => uiTheme.fg("toolOutput", line)));
+				if (remaining > 0) {
+					lines.push(uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${remaining} more lines) (ctrl+o to expand)`));
+				}
+			}
+		}
+
+		// Truncation warnings
+		const truncation = details?.truncation;
+		const fullOutputPath = details?.fullOutputPath;
+		if (truncation?.truncated || fullOutputPath) {
+			const warnings: string[] = [];
+			if (fullOutputPath) {
+				warnings.push(`Full output: ${fullOutputPath}`);
+			}
+			if (truncation?.truncated) {
+				if (truncation.truncatedBy === "lines") {
+					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+				} else {
+					warnings.push(
+						`Truncated: ${truncation.outputLines} lines shown (${formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+					);
+				}
+			}
+			lines.push(uiTheme.fg("warning", wrapBrackets(warnings.join(". "), uiTheme)));
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+};

package/src/core/tools/context.ts

@@ -6,27 +6,34 @@ declare module "@oh-my-pi/pi-agent-core" {
 	interface AgentToolContext extends CustomToolContext {
 		ui?: ExtensionUIContext;
 		hasUI?: boolean;
+		toolNames?: string[];
 	}
 }
 
 export interface ToolContextStore {
 	getContext(): AgentToolContext;
 	setUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
+	setToolNames(names: string[]): void;
 }
 
 export function createToolContextStore(getBaseContext: () => CustomToolContext): ToolContextStore {
 	let uiContext: ExtensionUIContext | undefined;
 	let hasUI = false;
+	let toolNames: string[] = [];
 
 	return {
 		getContext: () => ({
 			...getBaseContext(),
 			ui: uiContext,
 			hasUI,
+			toolNames,
 		}),
 		setUIContext: (context, uiAvailable) => {
 			uiContext = context;
 			hasUI = uiAvailable;
 		},
+		setToolNames: (names) => {
+			toolNames = names;
+		},
 	};
 }

package/src/core/tools/edit-diff.ts

@@ -422,6 +422,7 @@ export async function computeEditDiff(
 	newText: string,
 	cwd: string,
 	fuzzy = true,
+	all = false,
 ): Promise<EditDiffResult | EditDiffError> {
 	const absolutePath = resolveToCwd(path, cwd);
 
@@ -443,34 +444,82 @@ export async function computeEditDiff(
 		const normalizedOldText = normalizeToLF(oldText);
 		const normalizedNewText = normalizeToLF(newText);
 
-		const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
-			allowFuzzy: fuzzy,
-			similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
-		});
+		let normalizedNewContent: string;
 
-		if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
-			return {
-				error: `Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
-			};
-		}
+		if (all) {
+			// Replace all occurrences mode with fuzzy matching
+			normalizedNewContent = normalizedContent;
+			let replacementCount = 0;
 
-		if (!matchOutcome.match) {
-			return {
-				error: EditMatchError.formatMessage(path, normalizedOldText, matchOutcome.closest, {
-					allowFuzzy: fuzzy,
-					similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
-					fuzzyMatches: matchOutcome.fuzzyMatches,
-				}),
-			};
-		}
+			// First check: if exact matches exist, use simple replaceAll
+			const exactCount = normalizedContent.split(normalizedOldText).length - 1;
+			if (exactCount > 0) {
+				normalizedNewContent = normalizedContent.split(normalizedOldText).join(normalizedNewText);
+				replacementCount = exactCount;
+			} else {
+				// No exact matches - try fuzzy matching iteratively
+				while (true) {
+					const matchOutcome = findEditMatch(normalizedNewContent, normalizedOldText, {
+						allowFuzzy: fuzzy,
+						similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+					});
+
+					// In all mode, use closest match if it passes threshold (even with multiple matches)
+					const match =
+						matchOutcome.match ||
+						(fuzzy && matchOutcome.closest && matchOutcome.closest.confidence >= DEFAULT_FUZZY_THRESHOLD
+							? matchOutcome.closest
+							: undefined);
+
+					if (!match) {
+						if (replacementCount === 0) {
+							return {
+								error: EditMatchError.formatMessage(path, normalizedOldText, matchOutcome.closest, {
+									allowFuzzy: fuzzy,
+									similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+									fuzzyMatches: matchOutcome.fuzzyMatches,
+								}),
+							};
+						}
+						break;
+					}
+
+					normalizedNewContent =
+						normalizedNewContent.substring(0, match.startIndex) +
+						normalizedNewText +
+						normalizedNewContent.substring(match.startIndex + match.actualText.length);
+					replacementCount++;
+				}
+			}
+		} else {
+			// Single replacement mode with fuzzy matching
+			const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
+				allowFuzzy: fuzzy,
+				similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+			});
+
+			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+				return {
+					error: `Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique, or use all: true to replace all.`,
+				};
+			}
 
-		const match = matchOutcome.match;
+			if (!matchOutcome.match) {
+				return {
+					error: EditMatchError.formatMessage(path, normalizedOldText, matchOutcome.closest, {
+						allowFuzzy: fuzzy,
+						similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+						fuzzyMatches: matchOutcome.fuzzyMatches,
+					}),
+				};
+			}
 
-		// Compute the new content
-		const normalizedNewContent =
-			normalizedContent.substring(0, match.startIndex) +
-			normalizedNewText +
-			normalizedContent.substring(match.startIndex + match.actualText.length);
+			const match = matchOutcome.match;
+			normalizedNewContent =
+				normalizedContent.substring(0, match.startIndex) +
+				normalizedNewText +
+				normalizedContent.substring(match.startIndex + match.actualText.length);
+		}
 
 		// Check if it would actually change anything
 		if (normalizedContent === normalizedNewContent) {

package/src/core/tools/edit.ts

@@ -1,9 +1,15 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import editDescription from "../../prompts/tools/edit.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
 import {
 	DEFAULT_FUZZY_THRESHOLD,
 	detectLineEnding,
+	type EditDiffError,
+	type EditDiffResult,
 	EditMatchError,
 	findEditMatch,
 	generateDiffString,
@@ -11,8 +17,17 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "./edit-diff";
-import { type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } from "./lsp/index";
+import type { ToolSession } from "./index";
+import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
+import {
+	formatDiagnostics,
+	formatDiffStats,
+	getDiffStats,
+	shortenPath,
+	truncateDiffByHunk,
+	wrapBrackets,
+} from "./render-utils";
 
 const editSchema = Type.Object({
 	path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
@@ -20,6 +35,7 @@ const editSchema = Type.Object({
 		description: "Text to find and replace (high-confidence fuzzy matching for whitespace/indentation is always on)",
 	}),
 	newText: Type.String({ description: "New text to replace the old text with" }),
+	all: Type.Optional(Type.Boolean({ description: "Replace all occurrences instead of requiring unique match" })),
 });
 
 export interface EditToolDetails {
@@ -31,16 +47,11 @@ export interface EditToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 }
 
-export interface EditToolOptions {
-	/** Whether to accept high-confidence fuzzy matches for whitespace/indentation (default: true) */
-	fuzzyMatch?: boolean;
-	/** Writethrough callback to get LSP diagnostics after editing a file */
-	writethrough?: WritethroughCallback;
-}
-
-export function createEditTool(cwd: string, options: EditToolOptions = {}): AgentTool<typeof editSchema> {
-	const allowFuzzy = options.fuzzyMatch ?? true;
-	const writethrough = options.writethrough ?? writethroughNoop;
+export function createEditTool(session: ToolSession): AgentTool<typeof editSchema> {
+	const allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
+	const enableDiagnostics = session.settings?.getLspDiagnosticsOnEdit() ?? false;
+	const enableFormat = session.settings?.getLspFormatOnWrite() ?? true;
+	const writethrough = createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics });
 	return {
 		name: "edit",
 		label: "Edit",
@@ -48,7 +59,7 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 		parameters: editSchema,
 		execute: async (
 			_toolCallId: string,
-			{ path, oldText, newText }: { path: string; oldText: string; newText: string },
+			{ path, oldText, newText, all }: { path: string; oldText: string; newText: string; all?: boolean },
 			signal?: AbortSignal,
 		) => {
 			// Reject .ipynb files - use NotebookEdit tool instead
@@ -56,7 +67,7 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 			}
 
-			const absolutePath = resolveToCwd(path, cwd);
+			const absolutePath = resolveToCwd(path, session.cwd);
 
 			const file = Bun.file(absolutePath);
 			if (!(await file.exists())) {
@@ -73,30 +84,79 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 			const normalizedOldText = normalizeToLF(oldText);
 			const normalizedNewText = normalizeToLF(newText);
 
-			const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
-				allowFuzzy,
-				similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
-			});
+			let normalizedNewContent: string;
+			let replacementCount = 0;
 
-			if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
-				throw new Error(
-					`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`,
-				);
-			}
+			if (all) {
+				// Replace all occurrences mode with fuzzy matching
+				normalizedNewContent = normalizedContent;
+
+				// First check: if exact matches exist, use simple replaceAll
+				const exactCount = normalizedContent.split(normalizedOldText).length - 1;
+				if (exactCount > 0) {
+					normalizedNewContent = normalizedContent.split(normalizedOldText).join(normalizedNewText);
+					replacementCount = exactCount;
+				} else {
+					// No exact matches - try fuzzy matching iteratively
+					while (true) {
+						const matchOutcome = findEditMatch(normalizedNewContent, normalizedOldText, {
+							allowFuzzy,
+							similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+						});
+
+						// In all mode, use closest match if it passes threshold (even with multiple matches)
+						const match =
+							matchOutcome.match ||
+							(allowFuzzy && matchOutcome.closest && matchOutcome.closest.confidence >= DEFAULT_FUZZY_THRESHOLD
+								? matchOutcome.closest
+								: undefined);
+
+						if (!match) {
+							if (replacementCount === 0) {
+								throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
+									allowFuzzy,
+									similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+									fuzzyMatches: matchOutcome.fuzzyMatches,
+								});
+							}
+							break;
+						}
 
-			if (!matchOutcome.match) {
-				throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
+						normalizedNewContent =
+							normalizedNewContent.substring(0, match.startIndex) +
+							normalizedNewText +
+							normalizedNewContent.substring(match.startIndex + match.actualText.length);
+						replacementCount++;
+					}
+				}
+			} else {
+				// Single replacement mode with fuzzy matching
+				const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
 					allowFuzzy,
 					similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
-					fuzzyMatches: matchOutcome.fuzzyMatches,
 				});
-			}
 
-			const match = matchOutcome.match;
-			const normalizedNewContent =
-				normalizedContent.substring(0, match.startIndex) +
-				normalizedNewText +
-				normalizedContent.substring(match.startIndex + match.actualText.length);
+				if (matchOutcome.occurrences && matchOutcome.occurrences > 1) {
+					throw new Error(
+						`Found ${matchOutcome.occurrences} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique, or use all: true to replace all.`,
+					);
+				}
+
+				if (!matchOutcome.match) {
+					throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
+						allowFuzzy,
+						similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
+						fuzzyMatches: matchOutcome.fuzzyMatches,
+					});
+				}
+
+				const match = matchOutcome.match;
+				normalizedNewContent =
+					normalizedContent.substring(0, match.startIndex) +
+					normalizedNewText +
+					normalizedContent.substring(match.startIndex + match.actualText.length);
+				replacementCount = 1;
+			}
 
 			// Verify the replacement actually changed something
 			if (normalizedContent === normalizedNewContent) {
@@ -111,7 +171,10 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 			const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
 
 			// Build result text
-			let resultText = `Successfully replaced text in ${path}.`;
+			let resultText =
+				replacementCount > 1
+					? `Successfully replaced ${replacementCount} occurrences in ${path}.`
+					: `Successfully replaced text in ${path}.`;
 
 			const messages = diagnostics?.messages;
 			if (messages && messages.length > 0) {
@@ -136,5 +199,129 @@ export function createEditTool(cwd: string, options: EditToolOptions = {}): Agen
 	};
 }
 
-/** Default edit tool using process.cwd() - for backwards compatibility */
-export const editTool = createEditTool(process.cwd());
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface EditRenderArgs {
+	path?: string;
+	file_path?: string;
+	oldText?: string;
+	newText?: string;
+	all?: boolean;
+}
+
+/** Extended context for edit tool rendering */
+export interface EditRenderContext {
+	/** Pre-computed diff preview (computed before tool executes) */
+	editDiffPreview?: EditDiffResult | EditDiffError;
+	/** Function to render diff text with syntax highlighting */
+	renderDiff?: (diffText: string, options?: { filePath?: string }) => string;
+}
+
+const EDIT_DIFF_PREVIEW_HUNKS = 2;
+const EDIT_DIFF_PREVIEW_LINES = 24;
+
+function countLines(text: string): number {
+	if (!text) return 0;
+	return text.split("\n").length;
+}
+
+function formatMetadataLine(lineCount: number | null, language: string | undefined, uiTheme: Theme): string {
+	const icon = uiTheme.getLangIcon(language);
+	if (lineCount !== null) {
+		return uiTheme.fg("dim", `${icon} ${lineCount} lines`);
+	}
+	return uiTheme.fg("dim", `${icon}`);
+}
+
+export const editToolRenderer = {
+	renderCall(args: EditRenderArgs, uiTheme: Theme): Component {
+		const rawPath = args.file_path || args.path || "";
+		const filePath = shortenPath(rawPath);
+		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
+		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
+		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
+
+		const text = `${uiTheme.fg("toolTitle", uiTheme.bold("Edit"))} ${editIcon} ${pathDisplay}`;
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: EditToolDetails; isError?: boolean },
+		options: RenderResultOptions & { renderContext?: EditRenderContext },
+		uiTheme: Theme,
+		args?: EditRenderArgs,
+	): Component {
+		const { expanded, renderContext } = options;
+		const rawPath = args?.file_path || args?.path || "";
+		const filePath = shortenPath(rawPath);
+		const editLanguage = getLanguageFromPath(rawPath) ?? "text";
+		const editIcon = uiTheme.fg("muted", uiTheme.getLangIcon(editLanguage));
+		const editDiffPreview = renderContext?.editDiffPreview;
+		const renderDiffFn = renderContext?.renderDiff ?? ((t: string) => t);
+
+		// Build path display with line number if available
+		let pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", uiTheme.format.ellipsis);
+		const firstChangedLine =
+			(editDiffPreview && "firstChangedLine" in editDiffPreview ? editDiffPreview.firstChangedLine : undefined) ||
+			(result.details && !result.isError ? result.details.firstChangedLine : undefined);
+		if (firstChangedLine) {
+			pathDisplay += uiTheme.fg("warning", `:${firstChangedLine}`);
+		}
+
+		let text = `${uiTheme.fg("toolTitle", uiTheme.bold("Edit"))} ${editIcon} ${pathDisplay}`;
+
+		const editLineCount = countLines(args?.newText ?? args?.oldText ?? "");
+		text += `\n${formatMetadataLine(editLineCount, editLanguage, uiTheme)}`;
+
+		if (result.isError) {
+			// Show error from result
+			const errorText = result.content?.find((c) => c.type === "text")?.text ?? "";
+			if (errorText) {
+				text += `\n\n${uiTheme.fg("error", errorText)}`;
+			}
+		} else if (editDiffPreview) {
+			// Use cached diff preview (works both before and after execution)
+			if ("error" in editDiffPreview) {
+				text += `\n\n${uiTheme.fg("error", editDiffPreview.error)}`;
+			} else if (editDiffPreview.diff) {
+				const diffStats = getDiffStats(editDiffPreview.diff);
+				text += `\n${uiTheme.fg("dim", uiTheme.format.bracketLeft)}${formatDiffStats(
+					diffStats.added,
+					diffStats.removed,
+					diffStats.hunks,
+					uiTheme,
+				)}${uiTheme.fg("dim", uiTheme.format.bracketRight)}`;
+
+				const {
+					text: diffText,
+					hiddenHunks,
+					hiddenLines,
+				} = expanded
+					? { text: editDiffPreview.diff, hiddenHunks: 0, hiddenLines: 0 }
+					: truncateDiffByHunk(editDiffPreview.diff, EDIT_DIFF_PREVIEW_HUNKS, EDIT_DIFF_PREVIEW_LINES);
+
+				text += `\n\n${renderDiffFn(diffText, { filePath: rawPath })}`;
+				if (!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 += uiTheme.fg(
+						"toolOutput",
+						`\n${uiTheme.format.ellipsis} (${remainder.join(", ")}) ${wrapBrackets("Ctrl+O to expand", uiTheme)}`,
+					);
+				}
+			}
+		}
+
+		// Show LSP diagnostics if available
+		if (result.details?.diagnostics) {
+			text += formatDiagnostics(result.details.diagnostics, expanded, uiTheme, (fp) =>
+				uiTheme.getLangIcon(getLanguageFromPath(fp)),
+			);
+		}
+
+		return new Text(text, 0, 0);
+	},
+};

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

@@ -78,10 +78,7 @@ export function renderExaResult(
 			}
 
 			if (remaining > 0) {
-				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
-					"muted",
-					formatMoreItems(remaining, "line", uiTheme),
-				)}`;
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg("muted", formatMoreItems(remaining, "line", uiTheme))}`;
 			}
 
 			return new Text(text, 0, 0);
@@ -168,17 +165,11 @@ export function renderExaResult(
 		text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", title)}${domainPart}`;
 
 		if (res.url) {
-			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
-				"mdLinkUrl",
-				res.url,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("mdLinkUrl", res.url)}`;
 		}
 
 		if (res.author) {
-			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
-				"muted",
-				`Author: ${res.author}`,
-			)}`;
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("muted", `Author: ${res.author}`)}`;
 		}
 
 		if (res.publishedDate) {
@@ -206,10 +197,7 @@ export function renderExaResult(
 		}
 
 		if (res.highlights?.length) {
-			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg(
-				"accent",
-				"Highlights",
-			)}`;
+			text += `\n ${uiTheme.fg("dim", cont)} ${uiTheme.fg("dim", uiTheme.tree.hook)} ${uiTheme.fg("accent", "Highlights")}`;
 			const maxHighlights = Math.min(res.highlights.length, 3);
 			for (let j = 0; j < maxHighlights; j++) {
 				const h = res.highlights[j];