@oh-my-pi/pi-coding-agent 17.1.8 → 17.2.1

package/src/modes/components/read-tool-group.ts

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import type { AssistantMessage, Usage } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
 import { InternalUrlRouter, XD_URL_PREFIX } from "../../internal-urls";
@@ -6,7 +7,9 @@ import { getLanguageFromPath, theme } from "../../modes/theme/theme";
 import { parseLineRanges, selectorLineRanges, splitPathAndSel } from "../../tools/path-utils";
 import { PREVIEW_LIMITS, shortenPath } from "../../tools/render-utils";
 import { fileHyperlink, renderCodeCell, tryResolveInternalUrlSync } from "../../tui";
+import { canonicalizeMessage } from "../../utils/thinking-display";
 import type { ToolExecutionHandle } from "./tool-execution";
+import { formatUsageRow } from "./usage-row";
 
 /**
  * Extract the read call's target path. `path` is the canonical arg; `file_path`
@@ -39,6 +42,33 @@ export function readArgsCollapseIntoGroup(args: unknown): boolean {
 	return target.startsWith(XD_URL_PREFIX) || !InternalUrlRouter.instance().canHandle(target);
 }
 
+/**
+ * Return the collapsed read calls that can own a turn's usage row. Mixed-tool
+ * turns and visible content after a read keep the standalone row so request
+ * metrics retain their transcript ordering.
+ */
+export function groupedReadUsageCallIds(message: AssistantMessage): string[] | undefined {
+	const toolCallIds: string[] = [];
+	let sawToolCall = false;
+	for (const content of message.content) {
+		if (content.type === "toolCall") {
+			if (content.name !== "read" || !readArgsCollapseIntoGroup(content.arguments)) return undefined;
+			sawToolCall = true;
+			toolCallIds.push(content.id);
+			continue;
+		}
+		if (
+			sawToolCall &&
+			(content.type === "image" ||
+				(content.type === "text" && canonicalizeMessage(content.text)) ||
+				(content.type === "thinking" && canonicalizeMessage(content.thinking)))
+		) {
+			return undefined;
+		}
+	}
+	return toolCallIds.length > 0 ? toolCallIds : undefined;
+}
+
 type ReadRenderArgs = {
 	path?: string;
 	file_path?: string;
@@ -94,6 +124,14 @@ type ReadEntry = {
 	codeLineNumbers?: Array<number | null>;
 };
 
+type ReadUsageRow = {
+	toolCallIds: readonly string[];
+	usage: Usage;
+	durationMs?: number;
+	ttftMs?: number;
+	timestamp?: number;
+};
+
 /** Number of code lines to show in collapsed preview mode */
 const COLLAPSED_PREVIEW_LINES = PREVIEW_LIMITS.OUTPUT_COLLAPSED;
 
@@ -290,6 +328,8 @@ function formatMergedSelectorParts(selectors: string[]): string {
 
 export class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
 	#entries = new Map<string, ReadEntry>();
+	#usageRows = new Map<string, ReadUsageRow>();
+	#usageBatchByToolCallId = new Map<string, string>();
 	#text: Text;
 	#expanded = false;
 	#showContentPreview: boolean;
@@ -394,6 +434,33 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		this.#updateDisplay();
 	}
 
+	/**
+	 * Nest one request's usage beneath the last visible read call from that
+	 * request. Parallel reads share one row rather than duplicating request totals.
+	 */
+	attachUsage(
+		toolCallIds: readonly string[],
+		usage: Usage,
+		durationMs?: number,
+		ttftMs?: number,
+		timestamp?: number,
+	): boolean {
+		const attachedToolCallIds: string[] = [];
+		let anchorId: string | undefined;
+		for (const toolCallId of toolCallIds) {
+			if (!this.#entries.has(toolCallId)) continue;
+			attachedToolCallIds.push(toolCallId);
+			anchorId = toolCallId;
+		}
+		if (!anchorId) return false;
+		for (const toolCallId of attachedToolCallIds) {
+			this.#usageBatchByToolCallId.set(toolCallId, anchorId);
+		}
+		this.#usageRows.set(anchorId, { toolCallIds: attachedToolCallIds, usage, durationMs, ttftMs, timestamp });
+		this.#updateDisplay();
+		return true;
+	}
+
 	setArgsComplete(_toolCallId?: string): void {
 		this.#updateDisplay();
 	}
@@ -427,13 +494,15 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 			if (!this.#shouldRenderPreviewRow(row)) {
 				const statusSymbol = this.#formatStatus(this.#statusForTargets(row.targets));
 				const pathDisplay = this.#formatRowPath(row);
-				this.#text.setText(
-					` ${statusSymbol} ${theme.fg("toolTitle", theme.bold("Read"))} ${pathDisplay}`.trimEnd(),
-				);
+				const lines = [` ${statusSymbol} ${theme.fg("toolTitle", theme.bold("Read"))} ${pathDisplay}`.trimEnd()];
+				const usageRows = this.#usageRowsBySummaryRow(displayRows).get(0) ?? [];
+				this.#appendUsageRows(lines, usageRows, "   ");
+				this.#text.setText(lines.join("\n"));
 				this.addChild(this.#text);
 			}
 			for (const entry of this.#previewEntriesForRow(row)) {
 				this.#addContentPreview(entry);
+				this.#addPreviewUsage(entry);
 			}
 			return;
 		}
@@ -443,8 +512,9 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		const entriesWithoutPreview = entries.filter(entry => !this.#shouldRenderPreview(entry));
 		const summaryTargets = this.#displayTargetsForEntries(entriesWithoutPreview);
 		const rows = this.#buildSummaryRows(summaryTargets);
+		const usageRowsBySummaryRow = this.#usageRowsBySummaryRow(rows);
 		for (const [index, row] of rows.entries()) {
-			this.#appendSummaryRow(lines, row, index, rows.length);
+			this.#appendSummaryRow(lines, row, index, rows.length, usageRowsBySummaryRow.get(index) ?? []);
 		}
 
 		this.#text.setText(lines.join("\n"));
@@ -453,6 +523,7 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		for (const entry of entries) {
 			if (this.#shouldRenderPreview(entry)) {
 				this.#addContentPreview(entry);
+				this.#addPreviewUsage(entry);
 			}
 		}
 	}
@@ -480,27 +551,37 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	}
 
 	#buildSummaryRows(targets: ReadDisplayTarget[]): ReadSummaryRow[] {
-		const selectorTargetsByBasePath = new Map<string, ReadDisplayTarget[]>();
+		const selectorTargetsByBasePathAndBatch = new Map<string, Map<string | undefined, ReadDisplayTarget[]>>();
 		for (const target of targets) {
 			if (!target.selector) continue;
-			const existing = selectorTargetsByBasePath.get(target.basePath);
+			let targetsByBatch = selectorTargetsByBasePathAndBatch.get(target.basePath);
+			if (!targetsByBatch) {
+				targetsByBatch = new Map<string | undefined, ReadDisplayTarget[]>();
+				selectorTargetsByBasePathAndBatch.set(target.basePath, targetsByBatch);
+			}
+			const batchId = this.#usageBatchByToolCallId.get(target.entry.toolCallId);
+			const existing = targetsByBatch.get(batchId);
 			if (existing) existing.push(target);
-			else selectorTargetsByBasePath.set(target.basePath, [target]);
+			else targetsByBatch.set(batchId, [target]);
 		}
 
-		const mergeableBasePaths = new Set<string>();
-		for (const [basePath, baseTargets] of selectorTargetsByBasePath) {
-			if (basePath && baseTargets.length > 1) {
-				mergeableBasePaths.add(basePath);
+		const mergedTargetsByTarget = new Map<ReadDisplayTarget, ReadDisplayTarget[]>();
+		for (const [basePath, targetsByBatch] of selectorTargetsByBasePathAndBatch) {
+			if (!basePath) continue;
+			for (const groupedTargets of targetsByBatch.values()) {
+				if (groupedTargets.length <= 1) continue;
+				for (const target of groupedTargets) {
+					mergedTargetsByTarget.set(target, groupedTargets);
+				}
 			}
 		}
 
-		const emittedMergedRows = new Set<string>();
+		const emittedMergedTargets = new Set<ReadDisplayTarget[]>();
 		const rows: ReadSummaryRow[] = [];
 		for (const target of targets) {
-			if (target.selector && mergeableBasePaths.has(target.basePath)) {
-				if (!emittedMergedRows.has(target.basePath)) {
-					const mergedTargets = selectorTargetsByBasePath.get(target.basePath) ?? [target];
+			const mergedTargets = mergedTargetsByTarget.get(target);
+			if (mergedTargets) {
+				if (!emittedMergedTargets.has(mergedTargets)) {
 					rows.push({
 						targetPath: `${target.basePath}:${formatMergedSelectorParts(
 							mergedTargets
@@ -510,7 +591,7 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 						basePath: target.basePath,
 						targets: mergedTargets,
 					});
-					emittedMergedRows.add(target.basePath);
+					emittedMergedTargets.add(mergedTargets);
 				}
 				continue;
 			}
@@ -519,9 +600,58 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		return rows;
 	}
 
-	#appendSummaryRow(lines: string[], row: ReadSummaryRow, index: number, total: number): void {
+	#appendSummaryRow(
+		lines: string[],
+		row: ReadSummaryRow,
+		index: number,
+		total: number,
+		usageRows: ReadUsageRow[],
+	): void {
 		const connector = index === total - 1 ? theme.tree.last : theme.tree.branch;
 		lines.push(`   ${theme.fg("dim", connector)} ${this.#formatRow(row)}`.trimEnd());
+
+		const connectorWidth = Bun.stringWidth(connector);
+		const continuation =
+			index === total - 1
+				? " ".repeat(connectorWidth)
+				: `${theme.tree.vertical}${" ".repeat(Math.max(0, connectorWidth - Bun.stringWidth(theme.tree.vertical)))}`;
+		this.#appendUsageRows(lines, usageRows, `   ${continuation} `);
+	}
+
+	#usageRowsBySummaryRow(rows: ReadSummaryRow[]): Map<number, ReadUsageRow[]> {
+		const lastRowIndexByToolCallId = new Map<string, number>();
+		for (const [index, row] of rows.entries()) {
+			for (const target of row.targets) {
+				lastRowIndexByToolCallId.set(target.entry.toolCallId, index);
+			}
+		}
+
+		const usageRowsByIndex = new Map<number, ReadUsageRow[]>();
+		for (const usageRow of this.#usageRows.values()) {
+			let lastRowIndex: number | undefined;
+			for (const toolCallId of usageRow.toolCallIds) {
+				const index = lastRowIndexByToolCallId.get(toolCallId);
+				if (index !== undefined && (lastRowIndex === undefined || index > lastRowIndex)) {
+					lastRowIndex = index;
+				}
+			}
+			if (lastRowIndex === undefined) continue;
+			const usageRows = usageRowsByIndex.get(lastRowIndex);
+			if (usageRows) usageRows.push(usageRow);
+			else usageRowsByIndex.set(lastRowIndex, [usageRow]);
+		}
+		return usageRowsByIndex;
+	}
+
+	#appendUsageRows(lines: string[], usageRows: ReadUsageRow[], prefix: string): void {
+		for (const usageRow of usageRows) {
+			lines.push(
+				theme.fg(
+					"dim",
+					`${prefix}${formatUsageRow(usageRow.usage, usageRow.durationMs, usageRow.ttftMs, usageRow.timestamp)}`,
+				),
+			);
+		}
 	}
 
 	#formatRow(row: ReadSummaryRow): string {
@@ -659,6 +789,18 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		this.addChild(component);
 	}
 
+	#addPreviewUsage(entry: ReadEntry): void {
+		const usageRow = this.#usageRows.get(entry.toolCallId);
+		if (!usageRow) return;
+		this.addChild(
+			new Text(
+				theme.fg("dim", formatUsageRow(usageRow.usage, usageRow.durationMs, usageRow.ttftMs, usageRow.timestamp)),
+				3,
+				0,
+			),
+		);
+	}
+
 	#shouldRenderPreview(entry: ReadEntry): boolean {
 		return this.#showContentPreview && entry.contentText !== undefined;
 	}

package/src/modes/components/session-selector.ts

@@ -724,6 +724,12 @@ export interface SessionSelectorOptions {
 	loadAllSessions?: () => Promise<SessionInfo[]>;
 	/** Preloaded all-projects list; cached so the first Tab toggle is instant. */
 	allSessions?: SessionInfo[];
+	/** Picker heading; defaults to "Resume Session". */
+	title?: string;
+	/** Fixed scope label, or false to omit the scope suffix. */
+	scopeLabel?: string | false;
+	/** Show each session's working directory in the list. */
+	showCwd?: boolean;
 	/**
 	 * Reads the live terminal height so the visible window fits the viewport.
 	 * Omitted only in tests; defaults to a conservative 24 rows.
@@ -773,6 +779,8 @@ export class SessionSelectorComponent extends Container {
 	readonly #getTerminalRows: () => number;
 	readonly #fillHeight: boolean;
 	readonly #bottomBorder = new DynamicBorder();
+	readonly #title: string;
+	readonly #scopeLabel: string | false | undefined;
 
 	constructor(
 		sessions: SessionInfo[],
@@ -790,6 +798,8 @@ export class SessionSelectorComponent extends Container {
 		this.#globalSessions = options.allSessions ?? null;
 		this.#getTerminalRows = options.getTerminalRows ?? (() => 24);
 		this.#fillHeight = options.fillHeight ?? false;
+		this.#title = options.title ?? "Resume Session";
+		this.#scopeLabel = options.scopeLabel;
 		// Add header
 		this.addChild(new Spacer(1));
 		this.#headerText = new Text(this.#headerLabel(), 1, 0);
@@ -801,7 +811,12 @@ export class SessionSelectorComponent extends Container {
 		// Create session list in folder scope; the empty-state hint invites the
 		// user to Tab into all-projects rather than silently surfacing other
 		// projects' history (issue #3099).
-		this.#sessionList = new SessionList(sessions, false, options.historyMatcher, options.getTerminalRows);
+		this.#sessionList = new SessionList(
+			sessions,
+			options.showCwd ?? false,
+			options.historyMatcher,
+			options.getTerminalRows,
+		);
 		// Every exit path cancels the list's pending history merge, so a stale
 		// debounce timer can never run its SQLite lookup after the picker closed.
 		this.#sessionList.onSelect = session => {
@@ -831,8 +846,9 @@ export class SessionSelectorComponent extends Container {
 	}
 
 	#headerLabel(): string {
-		const scopeLabel = this.#scope === "all" ? "all projects" : "current folder";
-		return `${theme.bold("Resume Session")} ${theme.fg("muted", `(${scopeLabel})`)}`;
+		if (this.#scopeLabel === false) return theme.bold(this.#title);
+		const scopeLabel = this.#scopeLabel ?? (this.#scope === "all" ? "all projects" : "current folder");
+		return `${theme.bold(this.#title)} ${theme.fg("muted", `(${scopeLabel})`)}`;
 	}
 
 	/**