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

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,
@@ -13,6 +19,14 @@ import {
 } from "./edit-diff";
 import { type FileDiagnosticsResult, type WritethroughCallback, writethroughNoop } 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 +34,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 {
@@ -48,7 +63,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
@@ -73,30 +88,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,
+						});
 
-			if (!matchOutcome.match) {
-				throw new EditMatchError(path, normalizedOldText, matchOutcome.closest, {
+						// 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;
+						}
+
+						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 +175,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) {
@@ -138,3 +205,130 @@ 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/find.ts

@@ -1,12 +1,27 @@
 import { existsSync, type Stats, statSync } from "node:fs";
 import path from "node:path";
 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 { globSync } from "glob";
+import { getLanguageFromPath, type Theme } from "../../modes/interactive/theme/theme";
 import findDescription from "../../prompts/tools/find.md" with { type: "text" };
 import { ensureTool } from "../../utils/tools-manager";
+import type { RenderResultOptions } from "../custom-tools/types";
 import { untilAborted } from "../utils";
 import { resolveToCwd } from "./path-utils";
+import {
+	formatCount,
+	formatEmptyMessage,
+	formatErrorMessage,
+	formatExpandHint,
+	formatMeta,
+	formatMoreItems,
+	formatScope,
+	formatTruncationSuffix,
+	PREVIEW_LIMITS,
+} from "./render-utils";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate";
 
 const findSchema = Type.Object({
@@ -83,8 +98,14 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 				const shouldSortByMtime = sortByMtime ?? false;
 
 				// Build fd arguments
+				// When pattern contains path separators (e.g. "reports/**"), use --full-path
+				// so fd matches against the full path, not just the filename.
+				// Also prepend **/ to anchor the pattern at any depth in the search path.
+				const hasPathSeparator = pattern.includes("/") || pattern.includes("\\");
+				const effectivePattern = hasPathSeparator && !pattern.startsWith("**/") ? `**/${pattern}` : pattern;
 				const args: string[] = [
 					"--glob", // Use glob pattern
+					...(hasPathSeparator ? ["--full-path"] : []),
 					"--color=never", // No ANSI colors
 					"--max-results",
 					String(effectiveLimit),
@@ -127,7 +148,7 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 				}
 
 				// Pattern and path
-				args.push(pattern, searchPath);
+				args.push(effectivePattern, searchPath);
 
 				// Run fd
 				const result = Bun.spawnSync([fdPath, ...args], {
@@ -242,3 +263,143 @@ export function createFindTool(cwd: string): AgentTool<typeof findSchema> {
 
 /** Default find tool using process.cwd() - for backwards compatibility */
 export const findTool = createFindTool(process.cwd());
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface FindRenderArgs {
+	pattern: string;
+	path?: string;
+	type?: string;
+	hidden?: boolean;
+	sortByMtime?: boolean;
+	limit?: number;
+}
+
+const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
+
+export const findToolRenderer = {
+	renderCall(args: FindRenderArgs, uiTheme: Theme): Component {
+		const label = uiTheme.fg("toolTitle", uiTheme.bold("Find"));
+		let text = `${label} ${uiTheme.fg("accent", args.pattern || "*")}`;
+
+		const meta: string[] = [];
+		if (args.path) meta.push(`in ${args.path}`);
+		if (args.type && args.type !== "all") meta.push(`type:${args.type}`);
+		if (args.hidden) meta.push("hidden");
+		if (args.sortByMtime) meta.push("sort:mtime");
+		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?: FindToolDetails },
+		{ expanded }: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+
+		if (details?.error) {
+			return new Text(formatErrorMessage(details.error, uiTheme), 0, 0);
+		}
+
+		const hasDetailedData = details?.fileCount !== undefined;
+		const textContent = result.content?.find((c) => c.type === "text")?.text;
+
+		if (!hasDetailedData) {
+			if (!textContent || textContent.includes("No files matching") || textContent.trim() === "") {
+				return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+			}
+
+			const lines = textContent.split("\n").filter((l) => l.trim());
+			const maxLines = expanded ? lines.length : Math.min(lines.length, COLLAPSED_LIST_LIMIT);
+			const displayLines = lines.slice(0, maxLines);
+			const remaining = lines.length - maxLines;
+			const hasMore = remaining > 0;
+
+			const icon = uiTheme.styledSymbol("status.success", "success");
+			const summary = formatCount("file", lines.length);
+			const expandHint = formatExpandHint(expanded, hasMore, uiTheme);
+			let text = `${icon} ${uiTheme.fg("dim", summary)}${expandHint}`;
+
+			for (let i = 0; i < displayLines.length; i++) {
+				const isLast = i === displayLines.length - 1 && remaining === 0;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				text += `\n ${uiTheme.fg("dim", branch)} ${uiTheme.fg("accent", displayLines[i])}`;
+			}
+			if (remaining > 0) {
+				text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+					"muted",
+					formatMoreItems(remaining, "file", uiTheme),
+				)}`;
+			}
+			return new Text(text, 0, 0);
+		}
+
+		const fileCount = details?.fileCount ?? 0;
+		const truncated = details?.truncated ?? details?.truncation?.truncated ?? false;
+		const files = details?.files ?? [];
+
+		if (fileCount === 0) {
+			return new Text(formatEmptyMessage("No files found", uiTheme), 0, 0);
+		}
+
+		const icon = uiTheme.styledSymbol("status.success", "success");
+		const summaryText = formatCount("file", fileCount);
+		const scopeLabel = formatScope(details?.scopePath, uiTheme);
+		const maxFiles = expanded ? files.length : Math.min(files.length, COLLAPSED_LIST_LIMIT);
+		const hasMoreFiles = files.length > maxFiles;
+		const expandHint = formatExpandHint(expanded, hasMoreFiles, uiTheme);
+
+		let text = `${icon} ${uiTheme.fg("dim", summaryText)}${formatTruncationSuffix(
+			truncated,
+			uiTheme,
+		)}${scopeLabel}${expandHint}`;
+
+		const truncationReasons: string[] = [];
+		if (details?.resultLimitReached) {
+			truncationReasons.push(`limit ${details.resultLimitReached} results`);
+		}
+		if (details?.truncation?.truncated) {
+			truncationReasons.push("size limit");
+		}
+
+		const hasTruncation = truncationReasons.length > 0;
+
+		if (files.length > 0) {
+			for (let i = 0; i < maxFiles; i++) {
+				const isLast = i === maxFiles - 1 && !hasMoreFiles && !hasTruncation;
+				const branch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
+				const entry = files[i];
+				const isDir = entry.endsWith("/");
+				const entryPath = isDir ? entry.slice(0, -1) : entry;
+				const lang = isDir ? undefined : getLanguageFromPath(entryPath);
+				const entryIcon = isDir
+					? uiTheme.fg("accent", uiTheme.icon.folder)
+					: uiTheme.fg("muted", uiTheme.getLangIcon(lang));
+				text += `\n ${uiTheme.fg("dim", branch)} ${entryIcon} ${uiTheme.fg("accent", entry)}`;
+			}
+
+			if (hasMoreFiles) {
+				const moreFilesBranch = hasTruncation ? uiTheme.tree.branch : uiTheme.tree.last;
+				text += `\n ${uiTheme.fg("dim", moreFilesBranch)} ${uiTheme.fg(
+					"muted",
+					formatMoreItems(files.length - maxFiles, "file", uiTheme),
+				)}`;
+			}
+		}
+
+		if (hasTruncation) {
+			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.fg(
+				"warning",
+				`truncated: ${truncationReasons.join(", ")}`,
+			)}`;
+		}
+
+		return new Text(text, 0, 0);
+	},
+};