@oh-my-pi/pi-coding-agent 13.15.3 → 13.16.0

package/src/tools/grep.ts

@@ -457,6 +457,7 @@ export const grepToolRenderer = {
 							items: lines,
 							expanded,
 							maxCollapsed: COLLAPSED_TEXT_LIMIT,
+							maxCollapsedLines: COLLAPSED_TEXT_LIMIT,
 							itemType: "item",
 							renderItem: line => uiTheme.fg("toolOutput", line),
 						},
@@ -522,19 +523,6 @@ export const grepToolRenderer = {
 			}
 		}
 
-		const getCollapsedMatchLimit = (groups: string[][], maxLines: number): number => {
-			if (groups.length === 0) return 0;
-			let usedLines = 0;
-			let count = 0;
-			for (const group of groups) {
-				if (count > 0 && usedLines + group.length > maxLines) break;
-				usedLines += group.length;
-				count += 1;
-				if (usedLines >= maxLines) break;
-			}
-			return count;
-		};
-
 		const truncationReasons: string[] = [];
 		if (limits?.matchLimit) truncationReasons.push(`limit ${limits.matchLimit.reached} matches`);
 		if (limits?.resultLimit) truncationReasons.push(`limit ${limits.resultLimit.reached} results`);
@@ -551,14 +539,13 @@ export const grepToolRenderer = {
 				const { expanded } = options;
 				const key = new Hasher().bool(expanded).u32(width).digest();
 				if (cached?.key === key) return cached.lines;
-				const maxCollapsed = expanded
-					? matchGroups.length
-					: getCollapsedMatchLimit(matchGroups, COLLAPSED_TEXT_LIMIT);
+				const collapsedMatchLineBudget = Math.max(COLLAPSED_TEXT_LIMIT - extraLines.length, 0);
 				const matchLines = renderTreeList(
 					{
 						items: matchGroups,
 						expanded,
-						maxCollapsed,
+						maxCollapsed: matchGroups.length,
+						maxCollapsedLines: collapsedMatchLineBudget,
 						itemType: "match",
 						renderItem: group =>
 							group.map(line => {

package/src/tools/path-utils.ts

@@ -102,9 +102,16 @@ export function expandPath(filePath: string): string {
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.
+ *
+ * A bare root slash is treated as a workspace-root alias for tool inputs. Users
+ * often pass `/` to mean “search from here”, and letting tools escape to the
+ * filesystem root is almost never what they intended.
  */
 export function resolveToCwd(filePath: string, cwd: string): string {
 	const expanded = expandPath(filePath);
+	if (/^\/+$/.test(expanded)) {
+		return cwd;
+	}
 	if (path.isAbsolute(expanded)) {
 		return expanded;
 	}

package/src/tools/render-utils.ts

@@ -8,6 +8,7 @@ import * as os from "node:os";
 import { type Ellipsis, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { getIndentation, pluralize } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../modes/theme/theme";
+import { formatDimensionNote, type ResizedImage } from "../utils/image-resize";
 
 export { Ellipsis, truncateToWidth } from "@oh-my-pi/pi-tui";
 
@@ -527,6 +528,32 @@ export function shortenPath(filePath: string, homeDir?: string): string {
 	return filePath;
 }
 
+export function formatScreenshot(opts: {
+	saveFullRes: boolean;
+	savedMimeType: string;
+	savedByteLength: number;
+	dest: string;
+	resized: ResizedImage;
+}): string[] {
+	const lines = ["Screenshot captured"];
+	if (opts.saveFullRes) {
+		lines.push(
+			`Saved: ${opts.savedMimeType} (${(opts.savedByteLength / 1024).toFixed(2)} KB) to ${shortenPath(opts.dest)}`,
+		);
+		lines.push(
+			`Model: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB, ${opts.resized.width}x${opts.resized.height})`,
+		);
+	} else {
+		lines.push(`Format: ${opts.resized.mimeType} (${(opts.resized.buffer.length / 1024).toFixed(2)} KB)`);
+		lines.push(`Dimensions: ${opts.resized.width}x${opts.resized.height}`);
+	}
+	const dimensionNote = formatDimensionNote(opts.resized);
+	if (dimensionNote) {
+		lines.push(dimensionNote);
+	}
+	return lines;
+}
+
 export function wrapBrackets(text: string, theme: Theme): string {
 	return `${theme.format.bracketLeft}${text}${theme.format.bracketRight}`;
 }

package/src/tui/tree-list.ts

@@ -10,42 +10,71 @@ export interface TreeListOptions<T> {
 	items: T[];
 	expanded?: boolean;
 	maxCollapsed?: number;
+	/** Strict total-line budget for collapsed mode. When set (and not expanded),
+	 *  rendered item lines plus the trailing summary line must fit within this budget.
+	 */
+	maxCollapsedLines?: number;
 	itemType?: string;
+	/** Called once per item with `isLast: false` during budget calculation;
+	 *  line count MUST NOT vary based on `isLast`. */
 	renderItem: (item: T, context: TreeContext) => string | string[];
 }
 
 export function renderTreeList<T>(options: TreeListOptions<T>, theme: Theme): string[] {
-	const { items, expanded = false, maxCollapsed = 8, itemType = "item", renderItem } = options;
-	const lines: string[] = [];
+	const { items, expanded = false, maxCollapsed = 8, maxCollapsedLines, itemType = "item", renderItem } = options;
 	const maxItems = expanded ? items.length : Math.min(items.length, maxCollapsed);
+	const linesBudget = !expanded && maxCollapsedLines !== undefined ? maxCollapsedLines : Infinity;
 
+	// Pre-render each candidate item once.
+	// isLast cannot be known at this point (fittingCount is not yet determined);
+	// renderItem implementations MUST NOT vary line count based on isLast.
+	const preRendered: string[][] = [];
 	for (let i = 0; i < maxItems; i++) {
-		const isLast = i === maxItems - 1 && (expanded || items.length <= maxCollapsed);
-		const branch = getTreeBranch(isLast, theme);
-		const prefix = `${theme.fg("dim", branch)} `;
-		const continuePrefix = `${theme.fg("dim", getTreeContinuePrefix(isLast, theme))}`;
-		const context: TreeContext = {
+		const rendered = renderItem(items[i], {
 			index: i,
-			isLast,
+			isLast: false,
 			depth: 0,
 			theme,
-			prefix,
-			continuePrefix,
-		};
-		const rendered = renderItem(items[i], context);
-		if (Array.isArray(rendered)) {
-			if (rendered.length === 0) continue;
-			lines.push(`${prefix}${replaceTabs(rendered[0])}`);
-			for (let j = 1; j < rendered.length; j++) {
-				lines.push(`${continuePrefix}${replaceTabs(rendered[j])}`);
-			}
-		} else {
-			lines.push(`${prefix}${replaceTabs(rendered)}`);
+			prefix: "",
+			continuePrefix: "",
+		});
+		preRendered.push(Array.isArray(rendered) ? rendered : rendered ? [rendered] : []);
+	}
+
+	// Determine how many items fit within the line budget.
+	let fittingCount = maxItems;
+	let fittedLineCount = 0;
+	if (linesBudget !== Infinity) {
+		fittingCount = 0;
+		for (let i = 0; i < maxItems; i++) {
+			const count = preRendered[i]!.length;
+			const remainingAfter = items.length - (i + 1);
+			const reservedSummaryLines = remainingAfter > 0 ? 1 : 0;
+			if (fittedLineCount + count + reservedSummaryLines > linesBudget) break;
+			fittedLineCount += count;
+			fittingCount = i + 1;
+		}
+	}
+
+	const remaining = items.length - fittingCount;
+	const hasSummary = !expanded && remaining > 0 && (linesBudget === Infinity || fittedLineCount < linesBudget);
+
+	// Emit pre-rendered content with correct isLast-based branch prefixes.
+	const lines: string[] = [];
+	for (let i = 0; i < fittingCount; i++) {
+		const isLast = !hasSummary && i === fittingCount - 1;
+		const branch = getTreeBranch(isLast, theme);
+		const prefix = `${theme.fg("dim", branch)} `;
+		const continuePrefix = `${theme.fg("dim", getTreeContinuePrefix(isLast, theme))}`;
+		const itemLines = preRendered[i]!;
+		if (itemLines.length === 0) continue;
+		lines.push(`${prefix}${replaceTabs(itemLines[0]!)}`);
+		for (let j = 1; j < itemLines.length; j++) {
+			lines.push(`${continuePrefix}${replaceTabs(itemLines[j]!)}`);
 		}
 	}
 
-	if (!expanded && items.length > maxItems) {
-		const remaining = items.length - maxItems;
+	if (hasSummary) {
 		lines.push(`${theme.fg("dim", theme.tree.last)} ${theme.fg("muted", formatMoreItems(remaining, itemType))}`);
 	}