@oh-my-pi/pi-coding-agent 15.1.2 → 15.1.4

package/src/modes/acp/acp-event-mapper.ts

@@ -1,6 +1,7 @@
 import type {
 	SessionNotification,
 	SessionUpdate,
+	ToolCall,
 	ToolCallContent,
 	ToolCallLocation,
 	ToolKind,
@@ -17,6 +18,7 @@ interface MessageProgress {
 interface AcpEventMapperOptions {
 	getMessageId?: (message: unknown) => string | undefined;
 	getMessageProgress?: (message: unknown) => MessageProgress | undefined;
+	getToolArgs?: (toolCallId: string) => unknown;
 	/**
 	 * Session cwd. Tool call locations sent to ACP clients must be absolute
 	 * (the editor host needs them to open or focus files). When provided,
@@ -30,6 +32,10 @@ interface ContentArrayContainer {
 	content?: unknown;
 }
 
+interface DetailsContainer {
+	details?: unknown;
+}
+
 interface TypedValue {
 	type?: unknown;
 }
@@ -38,6 +44,10 @@ interface TextLikeContent extends TypedValue {
 	text?: unknown;
 }
 
+interface TerminalIdContainer {
+	terminalId?: unknown;
+}
+
 interface BinaryLikeContent extends TypedValue {
 	data?: unknown;
 	mimeType?: unknown;
@@ -118,6 +128,8 @@ export function mapToolKind(toolName: string): ToolKind {
 		case "move":
 			return "move";
 		case "bash":
+		case "shell":
+		case "exec":
 		case "eval":
 			return "execute";
 		case "search":
@@ -144,24 +156,20 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		case "message_end":
 			return mapAssistantMessageEnd(event, sessionId, options);
 		case "tool_execution_start": {
-			const update: SessionUpdate = {
-				sessionUpdate: "tool_call",
+			const update = buildToolCallStartUpdate({
 				toolCallId: event.toolCallId,
-				title: buildToolTitle(event.toolName, event.args, event.intent),
-				kind: mapToolKind(event.toolName),
-				status: "pending",
-				rawInput: event.args,
-			};
-			const locations = extractToolLocations(event.args, options.cwd);
-			if (locations.length > 0) {
-				update.locations = locations;
-			}
+				toolName: event.toolName,
+				args: event.args,
+				intent: event.intent,
+				cwd: options.cwd,
+			});
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_update": {
-			const terminalContent = extractTerminalToolCallContent(event.partialResult);
-			const otherContent = terminalContent.length > 0 ? [] : extractToolCallContent(event.partialResult);
-			const content = [...terminalContent, ...otherContent];
+			const content = mergeToolUpdateContent(
+				buildToolStartContent(event.toolName, event.args),
+				extractToolCallContent(event.partialResult),
+			);
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
@@ -178,10 +186,11 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_end": {
-			const diffContent = extractDiffToolCallContent(event.result);
-			const terminalContent = extractTerminalToolCallContent(event.result);
-			const otherContent = extractToolCallContent(event.result);
-			const content = [...diffContent, ...terminalContent, ...otherContent];
+			const resultContent = [...extractDiffToolCallContent(event.result), ...extractToolCallContent(event.result)];
+			const content = mergeToolUpdateContent(
+				buildToolStartContent(event.toolName, getToolExecutionEndArgs(event, options)),
+				resultContent,
+			);
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
@@ -195,7 +204,12 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			if (locations.length > 0) {
 				update.locations = locations;
 			}
-			return [toSessionNotification(sessionId, update)];
+			const notifications = [toSessionNotification(sessionId, update)];
+			const planUpdate = mapTodoWriteResultToPlanUpdate(event);
+			if (planUpdate) {
+				notifications.push(toSessionNotification(sessionId, planUpdate));
+			}
+			return notifications;
 		}
 		case "todo_reminder": {
 			const entries = event.todos.map(todo => ({
@@ -312,6 +326,144 @@ function mapTodoStatus(status: TodoStatus): "pending" | "in_progress" | "complet
 	return todoStatusMap[status];
 }
 
+function mapTodoWriteResultToPlanUpdate(
+	event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>,
+): SessionUpdate | undefined {
+	if (event.toolName !== "todo_write" || event.isError) {
+		return undefined;
+	}
+	const phases = extractTodoWritePhases(event.result);
+	if (!Array.isArray(phases)) {
+		return undefined;
+	}
+	return {
+		sessionUpdate: "plan",
+		entries: extractTodoEntries(phases).map(todo => ({
+			content: todo.content,
+			priority: "medium" as const,
+			status: mapTodoStatus(todo.status),
+		})),
+	};
+}
+
+function extractTodoWritePhases(result: unknown): unknown {
+	if (typeof result !== "object" || result === null || !("details" in result)) {
+		return undefined;
+	}
+	const details = (result as { details?: unknown }).details;
+	if (typeof details !== "object" || details === null || !("phases" in details)) {
+		return undefined;
+	}
+	return (details as { phases?: unknown }).phases;
+}
+
+function extractTodoEntries(phases: unknown[]): Array<{ content: string; status: TodoStatus }> {
+	const entries: Array<{ content: string; status: TodoStatus }> = [];
+	for (const phase of phases) {
+		if (typeof phase !== "object" || phase === null || !("tasks" in phase)) {
+			continue;
+		}
+		const tasks = (phase as { tasks?: unknown }).tasks;
+		if (!Array.isArray(tasks)) {
+			continue;
+		}
+		for (const task of tasks) {
+			if (typeof task !== "object" || task === null || !("content" in task)) {
+				continue;
+			}
+			const content = (task as { content?: unknown }).content;
+			if (typeof content !== "string" || content.length === 0) {
+				continue;
+			}
+			const status = (task as { status?: TodoStatus }).status;
+			entries.push({ content, status: isTodoStatus(status) ? status : "pending" });
+		}
+	}
+	return entries;
+}
+
+function isTodoStatus(status: unknown): status is TodoStatus {
+	return status === "pending" || status === "in_progress" || status === "completed" || status === "abandoned";
+}
+export function buildToolCallStartUpdate(input: {
+	toolCallId: string;
+	toolName: string;
+	args: unknown;
+	intent?: string;
+	cwd?: string;
+	status?: "pending" | "completed";
+}): SessionUpdate {
+	const update: ToolCall & { sessionUpdate: "tool_call" } = {
+		sessionUpdate: "tool_call",
+		toolCallId: input.toolCallId,
+		title: buildToolTitle(input.toolName, input.args, input.intent),
+		kind: mapToolKind(input.toolName),
+		status: input.status ?? "pending",
+		rawInput: input.args,
+	};
+	const content = buildToolStartContent(input.toolName, input.args);
+	if (content.length > 0) {
+		update.content = content;
+	}
+	const locations = extractToolLocations(input.args, input.cwd);
+	if (locations.length > 0) {
+		update.locations = locations;
+	}
+	return update;
+}
+
+export function normalizeReplayToolArguments(value: unknown): { args: unknown } {
+	if (typeof value !== "string") {
+		return { args: value ?? {} };
+	}
+	try {
+		const parsed: unknown = JSON.parse(value);
+		return { args: parsed };
+	} catch {
+		return { args: value };
+	}
+}
+
+function getToolExecutionEndArgs(
+	event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>,
+	options: AcpEventMapperOptions,
+): unknown {
+	if ("args" in event) {
+		return (event as { args?: unknown }).args;
+	}
+	return options.getToolArgs?.(event.toolCallId);
+}
+
+function buildToolStartContent(toolName: string, args: unknown): ToolCallContent[] {
+	if (!isCommandToolName(toolName)) {
+		return [];
+	}
+	const command = extractStringProperty<CommandContainer>(args, "command");
+	return command ? [textToolCallContent(`$ ${command}`)] : [];
+}
+
+function mergeToolUpdateContent(startContent: ToolCallContent[], resultContent: ToolCallContent[]): ToolCallContent[] {
+	if (startContent.length === 0) {
+		return resultContent;
+	}
+	const merged = [...startContent];
+	for (const item of resultContent) {
+		if (
+			item.type === "content" &&
+			item.content.type === "text" &&
+			hasEquivalentTextContent(merged, item.content.text)
+		) {
+			continue;
+		}
+		merged.push(item);
+	}
+	return merged;
+}
+
+function isCommandToolName(toolName: string): boolean {
+	return toolName === "bash" || toolName === "shell" || toolName === "exec";
+}
+
 function buildToolTitle(toolName: string, args: unknown, intent: string | undefined): string {
 	const trimmedIntent = intent?.trim();
 	if (trimmedIntent) {
@@ -418,26 +570,33 @@ function buildDiffContent(entry: unknown): ToolCallContent | undefined {
 	};
 }
 
-/** Emit a `terminal` ToolCallContent when a tool result carries a `details.terminalId` (e.g. bash routed through ACP terminal/*). */
-function extractTerminalToolCallContent(result: unknown): ToolCallContent[] {
-	if (typeof result !== "object" || result === null) return [];
-	const details = (result as { details?: unknown }).details;
-	if (typeof details !== "object" || details === null) return [];
-	const terminalId = (details as { terminalId?: unknown }).terminalId;
-	if (typeof terminalId !== "string" || terminalId.length === 0) return [];
-	return [{ type: "terminal", terminalId }];
+function extractTerminalId(value: unknown): string | undefined {
+	const direct = extractStringProperty<TerminalIdContainer>(value, "terminalId");
+	if (direct) return direct;
+	if (typeof value !== "object" || value === null) return undefined;
+	const details = (value as DetailsContainer).details;
+	return extractStringProperty<TerminalIdContainer>(details, "terminalId");
+}
+
+function terminalToolCallContent(terminalId: string): ToolCallContent {
+	return { type: "terminal", terminalId };
 }
 
 function extractToolCallContent(value: unknown): ToolCallContent[] {
 	const richContent = extractStructuredToolCallContent(value);
+	const terminalId = extractTerminalId(value);
+	const content =
+		terminalId && !hasTerminalContent(richContent, terminalId)
+			? [...richContent, terminalToolCallContent(terminalId)]
+			: richContent;
 	const fallbackText = extractReadableText(value);
 	if (!fallbackText) {
-		return richContent;
+		return content;
 	}
-	if (hasEquivalentTextContent(richContent, fallbackText)) {
-		return richContent;
+	if (hasEquivalentTextContent(content, fallbackText)) {
+		return content;
 	}
-	return [...richContent, textToolCallContent(fallbackText)];
+	return [...content, textToolCallContent(fallbackText)];
 }
 
 function extractStructuredToolCallContent(value: unknown): ToolCallContent[] {
@@ -596,6 +755,10 @@ function hasEquivalentTextContent(content: ToolCallContent[], text: string): boo
 	return content.some(item => item.type === "content" && item.content.type === "text" && item.content.text === text);
 }
 
+function hasTerminalContent(content: ToolCallContent[], terminalId: string): boolean {
+	return content.some(item => item.type === "terminal" && item.terminalId === terminalId);
+}
+
 function extractReadableText(value: unknown): string | undefined {
 	if (typeof value === "string") {
 		return normalizeText(value);
@@ -625,11 +788,24 @@ function extractReadableText(value: unknown): string | undefined {
 			return normalizeText(text);
 		}
 	}
-
+	if (isTerminalOnlyDetails(value)) {
+		return undefined;
+	}
 	const serialized = safeJsonStringify(value);
 	return normalizeText(serialized);
 }
 
+function isTerminalOnlyDetails(value: unknown): boolean {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+	if (extractTerminalId(value) === undefined) {
+		return false;
+	}
+	const content = (value as ContentArrayContainer).content;
+	return content === undefined || (Array.isArray(content) && content.length === 0);
+}
+
 function extractAssistantMessageText(value: unknown): string {
 	if (typeof value !== "object" || value === null || !("content" in value)) {
 		return "";

package/src/modes/acp/acp-mode.ts

@@ -1,15 +1,23 @@
 import * as stream from "node:stream";
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import { AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
 import type { AgentSession } from "../../session/agent-session";
 import { AcpAgent } from "./acp-agent";
 
 export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 
-export async function runAcpMode(session: AgentSession, createSession: AcpSessionFactory): Promise<never> {
+export function createAcpConnection(
+	transport: Stream,
+	createSession: AcpSessionFactory,
+	initialSession?: AgentSession,
+): AgentSideConnection {
+	return new AgentSideConnection(conn => new AcpAgent(conn, createSession, initialSession), transport);
+}
+
+export async function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never> {
 	const input = stream.Writable.toWeb(process.stdout);
 	const output = stream.Readable.toWeb(process.stdin);
 	const transport = ndJsonStream(input, output);
-	const connection = new AgentSideConnection(conn => new AcpAgent(conn, session, createSession), transport);
+	const connection = createAcpConnection(transport, createSession, initialSession);
 	await connection.closed;
 	process.exit(0);
 }

package/src/modes/components/bash-execution.ts

@@ -2,7 +2,6 @@
  * Component for displaying bash command execution with streaming output.
  */
 
-import { sanitizeText } from "@oh-my-pi/pi-natives";
 import {
 	Container,
 	Ellipsis,
@@ -14,6 +13,7 @@ import {
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { theme } from "../../modes/theme/theme";
 import type { TruncationMeta } from "../../tools/output-meta";
 import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";

package/src/modes/components/diff.ts

@@ -1,5 +1,4 @@
-import { sanitizeText } from "@oh-my-pi/pi-natives";
-import { getIndentation } from "@oh-my-pi/pi-utils";
+import { getIndentation, sanitizeText } from "@oh-my-pi/pi-utils";
 import * as Diff from "diff";
 import { getLanguageFromPath, highlightCode, theme } from "../../modes/theme/theme";
 import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs } from "../../tools/render-utils";

package/src/modes/components/eval-execution.ts

@@ -3,8 +3,8 @@
  * Shares the same kernel session as the agent's eval tool.
  */
 
-import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { Container, type Loader, Text, type TUI } from "@oh-my-pi/pi-tui";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { highlightCode, theme } from "../../modes/theme/theme";
 import type { TruncationMeta } from "../../tools/output-meta";
 import {

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

@@ -5,6 +5,8 @@ import { theme } from "../../modes/theme/theme";
 import { matchesSelectCancel } from "../../modes/utils/keybinding-matchers";
 import type { AuthStorage } from "../../session/auth-storage";
 import { DynamicBorder } from "./dynamic-border";
+
+const OAUTH_SELECTOR_MAX_VISIBLE = 10;
 /**
  * Component that renders an OAuth provider selector.
  */
@@ -144,7 +146,16 @@ export class OAuthSelectorComponent extends Container {
 	}
 	#updateList(): void {
 		this.#listContainer.clear();
-		for (let i = 0; i < this.#allProviders.length; i++) {
+
+		const total = this.#allProviders.length;
+		const maxVisible = OAUTH_SELECTOR_MAX_VISIBLE;
+		const startIndex =
+			total <= maxVisible
+				? 0
+				: Math.max(0, Math.min(this.#selectedIndex - Math.floor(maxVisible / 2), total - maxVisible));
+		const endIndex = Math.min(startIndex + maxVisible, total);
+
+		for (let i = startIndex; i < endIndex; i++) {
 			const provider = this.#allProviders[i];
 			if (!provider) continue;
 			const isSelected = i === this.#selectedIndex;
@@ -163,8 +174,14 @@ export class OAuthSelectorComponent extends Container {
 			this.#listContainer.addChild(new TruncatedText(line, 0, 0));
 		}
 
+		// Scroll indicator when list is windowed
+		if (startIndex > 0 || endIndex < total) {
+			const scrollInfo = theme.fg("muted", `  (${this.#selectedIndex + 1}/${total})`);
+			this.#listContainer.addChild(new TruncatedText(scrollInfo, 0, 0));
+		}
+
 		// Show "no providers" if empty
-		if (this.#allProviders.length === 0) {
+		if (total === 0) {
 			const message =
 				this.#mode === "login" ? "No OAuth providers available" : "No OAuth providers logged in. Use /login first.";
 			this.#listContainer.addChild(new TruncatedText(theme.fg("muted", `  ${message}`), 0, 0));
@@ -191,6 +208,25 @@ export class OAuthSelectorComponent extends Container {
 			this.#statusMessage = undefined;
 			this.#updateList();
 		}
+		// Page up - jump up by one visible page
+		else if (matchesKey(keyData, "pageUp")) {
+			if (this.#allProviders.length > 0) {
+				this.#selectedIndex = Math.max(0, this.#selectedIndex - OAUTH_SELECTOR_MAX_VISIBLE);
+			}
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
+		// Page down - jump down by one visible page
+		else if (matchesKey(keyData, "pageDown")) {
+			if (this.#allProviders.length > 0) {
+				this.#selectedIndex = Math.min(
+					this.#allProviders.length - 1,
+					this.#selectedIndex + OAUTH_SELECTOR_MAX_VISIBLE,
+				);
+			}
+			this.#statusMessage = undefined;
+			this.#updateList();
+		}
 		// Enter
 		else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selectedProvider = this.#allProviders[this.#selectedIndex];

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

@@ -1,5 +1,4 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
-import { sanitizeText } from "@oh-my-pi/pi-natives";
 import {
 	Box,
 	type Component,
@@ -13,7 +12,7 @@ import {
 	Text,
 	type TUI,
 } from "@oh-my-pi/pi-tui";
-import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
+import { getProjectDir, logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import { EDIT_MODE_STRATEGIES, type EditMode, type PerFileDiffPreview } from "../../edit";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";

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

@@ -453,6 +453,16 @@ class TreeList implements Component {
 		);
 		const endIndex = Math.min(startIndex + this.maxVisibleLines, this.#filteredNodes.length);
 
+		// Cap the per-row gutter prefix so a content budget is always preserved.
+		// Each indent level renders as 3 cells; deep branching would otherwise eat the
+		// entire viewport (issue #1144). Reserve at least MIN_CONTENT_COLS for entry
+		// text — or half the viewport, whichever is larger — and compress older gutter
+		// levels off-screen behind a leading ellipsis when the row would exceed budget.
+		const MIN_CONTENT_COLS = 24;
+		const OVERHEAD_COLS = 4; // cursor (2) + a touch of breathing room
+		const contentReserve = Math.max(MIN_CONTENT_COLS, Math.floor(width / 2));
+		const maxIndentLevels = Math.max(1, Math.floor((width - contentReserve - OVERHEAD_COLS) / 3));
+
 		for (let i = startIndex; i < endIndex; i++) {
 			const flatNode = this.#filteredNodes[i];
 			const entry = flatNode.node.entry;
@@ -464,29 +474,34 @@ class TreeList implements Component {
 			// If multiple roots, shift display (roots at 0, not 1)
 			const displayIndent = this.#multipleRoots ? Math.max(0, flatNode.indent - 1) : flatNode.indent;
 
-			// Build prefix with gutters at their correct positions
-			// Each gutter has a position (displayIndent where its connector was shown)
+			// Build prefix with gutters at their correct positions, clamped to
+			// `maxIndentLevels` cells so the content always fits. When clamped, the
+			// leftmost cells represent the deepest visible ancestors and a `…` marker
+			// indicates older branch context has been compressed.
 			const hasConnector = flatNode.showConnector && !flatNode.isVirtualRootChild;
 			const connectorSymbol = hasConnector ? (flatNode.isLast ? theme.tree.last : theme.tree.branch) : "";
 			const connectorChars = hasConnector ? Array.from(connectorSymbol) : [];
-			const connectorPosition = hasConnector ? displayIndent - 1 : -1;
+			const renderedIndent = Math.min(displayIndent, maxIndentLevels);
+			const scrollOffset = displayIndent - renderedIndent;
+			const connectorPositionDisplay = hasConnector ? renderedIndent - 1 : -1;
 
 			// Build prefix char by char, placing gutters and connector at their positions
-			const totalChars = displayIndent * 3;
+			const totalChars = renderedIndent * 3;
 			const prefixChars: string[] = [];
 			for (let i = 0; i < totalChars; i++) {
 				const level = Math.floor(i / 3);
+				const originalLevel = level + scrollOffset;
 				const posInLevel = i % 3;
 
-				// Check if there's a gutter at this level
-				const gutter = flatNode.gutters.find(g => g.position === level);
+				// Check if there's a gutter at this level (translated to original tree depth)
+				const gutter = flatNode.gutters.find(g => g.position === originalLevel);
 				if (gutter) {
 					if (posInLevel === 0) {
 						prefixChars.push(gutter.show ? theme.tree.vertical : " ");
 					} else {
 						prefixChars.push(" ");
 					}
-				} else if (hasConnector && level === connectorPosition) {
+				} else if (hasConnector && level === connectorPositionDisplay) {
 					// Connector at this level
 					if (posInLevel === 0) {
 						prefixChars.push(connectorChars[0] ?? " ");
@@ -499,6 +514,10 @@ class TreeList implements Component {
 					prefixChars.push(" ");
 				}
 			}
+			// Mark the leftmost cell when ancestors were compressed off-screen.
+			if (scrollOffset > 0 && prefixChars.length > 0) {
+				prefixChars[0] = "…";
+			}
 			const prefix = prefixChars.join("");
 
 			// Active path marker - shown right before the entry text