lsd-pi 1.3.6 → 1.3.9

package/packages/pi-coding-agent/src/modes/interactive/controllers/chat-controller.ts

@@ -9,6 +9,15 @@ import { ToolSummaryLine } from "../components/tool-summary-line.js";
 import { shouldCollapse } from "../../../core/tool-priority.js";
 import { appKey } from "../components/keybinding-hints.js";
 
+const GROUPABLE_COLLAPSED_TOOLS = new Set([
+    "read",
+    "find",
+    "ls",
+    "grep",
+    "lsp",
+
+]);
+
 export async function handleAgentEvent(host: InteractiveModeStateHost & {
     init: () => Promise<void>;
     getMarkdownThemeWithSettings: () => any;
@@ -42,6 +51,14 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         host.collapsedToolSummaryLine = undefined;
     };
 
+    // Tools that always render as their own visible row, never folded into a summary line
+    const ALWAYS_DIRECT_TOOLS = new Set([
+        "bash", "bg_shell",
+        "web_search", "search-the-web", "google_search", "search_and_read",
+        "fetch_page", "resolve_library", "get_library_docs",
+        "subagent", "await_subagent",
+    ]);
+
     const hasVisibleRender = (child: { render?: (width: number) => string[] } | undefined): boolean => {
         if (!child?.render) return true;
         try {
@@ -51,14 +68,20 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         }
     };
 
+    const canGroupCollapsedTool = (toolName: string): boolean => GROUPABLE_COLLAPSED_TOOLS.has(toolName);
+
     const findAdjacentCollapsedToolSummary = (
+        toolName: string,
         anchor?: { render: (width: number) => string[] },
     ): ToolSummaryLine | undefined => {
+        if (!canGroupCollapsedTool(toolName)) {
+            return undefined;
+        }
         const anchorIndex = anchor ? host.chatContainer.children.indexOf(anchor) : host.chatContainer.children.length;
         for (let i = anchorIndex - 1; i >= 0; i--) {
             const child = host.chatContainer.children[i];
             if (child instanceof ToolSummaryLine) {
-                return child;
+                return child.canGroupWith(toolName) ? child : undefined;
             }
             if (child instanceof ToolExecutionComponent && child.isHidden()) {
                 continue;
@@ -71,17 +94,15 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
         return undefined;
     };
 
-    const appendCollapsedToolSummary = (toolName: string, elapsed: number, anchor?: { render: (width: number) => string[] }): void => {
-        let summary = host.collapsedToolSummaryLine;
-        if ((!summary || !host.chatContainer.children.includes(summary)) && anchor) {
-            summary = findAdjacentCollapsedToolSummary(anchor);
-            if (summary) {
-                host.collapsedToolSummaryLine = summary;
-            }
-        }
-        if (!summary || !host.chatContainer.children.includes(summary)) {
+    const appendCollapsedToolSummary = (
+        toolName: string,
+        elapsed: number,
+        anchor?: { render: (width: number) => string[] },
+    ): ToolSummaryLine => {
+        let summary = findAdjacentCollapsedToolSummary(toolName, anchor);
+        if (!summary) {
             summary = new ToolSummaryLine();
-            summary.setHidden(host.toolOutputExpanded);
+            summary.setHidden(host.collapsedToolCallsExpanded);
             if (anchor) {
                 const anchorIndex = host.chatContainer.children.indexOf(anchor);
                 if (anchorIndex >= 0) {
@@ -92,9 +113,10 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
             } else {
                 host.chatContainer.addChild(summary);
             }
-            host.collapsedToolSummaryLine = summary;
         }
+        host.collapsedToolSummaryLine = summary;
         summary.addTool(toolName, elapsed);
+        return summary;
     };
 
     switch (event.type) {
@@ -158,7 +180,7 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                 (text) => theme.fg("accent", text),
                 host.defaultWorkingMessage,
             );
-            host.loadingAnimation.setCycleMessages(host.workingMessages, 3000);
+            host.loadingAnimation.setCycleMessages(host.workingMessages, 10_000);
             host.statusContainer.addChild(host.loadingAnimation);
             host.startLoadingTips();
             // Show steer/queue + expand hint in editor bottom border while agent is running
@@ -221,8 +243,19 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                                 host.ui,
                             );
                             component.setExpanded(host.toolOutputExpanded);
+                            const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                            const shouldHide = collapseToolCalls && !host.collapsedToolCallsExpanded && shouldCollapse(content.name, false) && !ALWAYS_DIRECT_TOOLS.has(content.name);
                             host.chatContainer.addChild(component);
+                            if (shouldHide) {
+                                // Check for adjacent summary AFTER adding to container so indexOf works
+                                const adjacentSummary = findAdjacentCollapsedToolSummary(content.name, component);
+                                if (adjacentSummary) {
+                                    component.setIndented(true);
+                                }
+                            }
+                            component.setHidden(shouldHide);
                             host.pendingTools.set(content.id, component);
+                            host.updateEditorExpandHint();
                         } else {
                             host.pendingTools.get(content.id)?.updateArgs(content.arguments);
                         }
@@ -240,8 +273,19 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                                 host.ui,
                             );
                             component.setExpanded(host.toolOutputExpanded);
+                            const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                            const shouldHide = collapseToolCalls && !host.collapsedToolCallsExpanded && shouldCollapse(content.name, false) && !ALWAYS_DIRECT_TOOLS.has(content.name);
                             host.chatContainer.addChild(component);
+                            if (shouldHide) {
+                                // Check for adjacent summary AFTER adding to container so indexOf works
+                                const adjacentSummary = findAdjacentCollapsedToolSummary(content.name, component);
+                                if (adjacentSummary) {
+                                    component.setIndented(true);
+                                }
+                            }
+                            component.setHidden(shouldHide);
                             host.pendingTools.set(content.id, component);
+                            host.updateEditorExpandHint();
                         }
                     } else if (content.type === "webSearchResult") {
                         const component = host.pendingTools.get(content.toolUseId);
@@ -322,8 +366,19 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
                     host.ui,
                 );
                 component.setExpanded(host.toolOutputExpanded);
+                const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                const shouldHide = collapseToolCalls && !host.collapsedToolCallsExpanded && shouldCollapse(event.toolName, false) && !ALWAYS_DIRECT_TOOLS.has(event.toolName);
                 host.chatContainer.addChild(component);
+                if (shouldHide) {
+                    // Check for adjacent summary AFTER adding to container so indexOf works
+                    const adjacentSummary = findAdjacentCollapsedToolSummary(event.toolName, component);
+                    if (adjacentSummary) {
+                        component.setIndented(true);
+                    }
+                }
+                component.setHidden(shouldHide);
                 host.pendingTools.set(event.toolCallId, component);
+                host.updateEditorExpandHint();
                 host.ui.requestRender();
             }
             break;
@@ -371,9 +426,12 @@ export async function handleAgentEvent(host: InteractiveModeStateHost & {
             const component = host.pendingTools.get(event.toolCallId);
             if (component) {
                 component.updateResult({ ...event.result, isError: event.isError });
-                if (shouldCollapse(event.toolName, event.isError)) {
+                const collapseToolCalls = host.settingsManager.getCollapseToolCalls?.() ?? false;
+                if (collapseToolCalls && shouldCollapse(event.toolName, event.isError) && !ALWAYS_DIRECT_TOOLS.has(event.toolName)) {
                     appendCollapsedToolSummary(event.toolName, component.getElapsed(), component);
-                    component.setHidden(true);
+                    component.setHidden(!host.collapsedToolCallsExpanded);
+                    component.setIndented(false);
+                    host.updateEditorExpandHint();
                 } else {
                     component.setHidden(false);
                     resetCollapsedToolSummary();

package/packages/pi-coding-agent/src/modes/interactive/controllers/extension-ui-controller.ts

@@ -53,8 +53,9 @@ export function createExtensionUIContext(host: any): ExtensionUIContext {
 			}
 			return result;
 		},
-		getToolsExpanded: () => host.toolOutputExpanded,
+		getToolsExpanded: () => host.collapsedToolCallsExpanded || host.toolOutputExpanded,
 		setToolsExpanded: (expanded) => host.setToolsExpanded(expanded),
+		isEditorFocused: () => !!host.editor.focused,
 	};
 }
 

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode-state.ts

@@ -12,6 +12,7 @@ export interface InteractiveModeStateHost {
 	settingsManager: any;
 	pendingTools: Map<string, any>;
 	collapsedToolSummaryLine?: any;
+	collapsedToolCallsExpanded: boolean;
 	toolOutputExpanded: boolean;
 	hideThinkingBlock: boolean;
 	notificationSoundEnabled: boolean;

package/packages/pi-coding-agent/src/modes/interactive/interactive-mode.ts

@@ -325,6 +325,7 @@ export class InteractiveMode {
 	private agentPtyComponents = new Map<string, EmbeddedTerminalComponent>();
 
 	// Tool output expansion state
+	private collapsedToolCallsExpanded = false;
 	private toolOutputExpanded = false;
 
 	// Thinking block visibility state
@@ -444,6 +445,7 @@ export class InteractiveMode {
 		// Load notification sound setting
 		this.notificationSoundEnabled = this.settingsManager.getNotificationSound();
 		this.footer.setNotificationSoundEnabled(this.notificationSoundEnabled);
+		this.footer.setVerboseFooterEnabled(this.settingsManager.getVerboseFooter());
 
 		// Register themes from resource loader and initialize
 		setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
@@ -1536,7 +1538,7 @@ export class InteractiveMode {
 		this.defaultEditor.onExtensionShortcut = undefined;
 		this.updateTerminalTitle();
 		if (this.loadingAnimation) {
-			this.loadingAnimation.setCycleMessages(this.workingMessages);
+			this.loadingAnimation.setCycleMessages(this.workingMessages, 10_000);
 		}
 	}
 
@@ -1879,7 +1881,7 @@ export class InteractiveMode {
 	/** Reset the loading animation back to cycling working messages. */
 	private resetLoadingMessage(): void {
 		if (this.loadingAnimation) {
-			this.loadingAnimation.setCycleMessages(this.workingMessages);
+			this.loadingAnimation.setCycleMessages(this.workingMessages, 10_000);
 		}
 	}
 
@@ -2358,6 +2360,7 @@ export class InteractiveMode {
 			if (wasBashMode !== this.isBashMode) {
 				this.updateEditorBorderColor();
 			}
+			this.updateEditorExpandHint();
 		};
 
 		// Handle clipboard image paste (triggered on Ctrl+V)
@@ -3072,63 +3075,93 @@ export class InteractiveMode {
 		}
 	}
 
+	private hasCollapsedToolCallSummaries(): boolean {
+		return this.chatContainer.children.some((child) => child instanceof ToolSummaryLine);
+	}
+
+	private shouldUseCollapsedToolCallIntermediateState(): boolean {
+		return this.settingsManager.getCollapseToolCalls() && this.hasCollapsedToolCallSummaries();
+	}
+
 	private toggleToolOutputExpansion(): void {
-		this.setToolsExpanded(!this.toolOutputExpanded);
+		if (this.toolOutputExpanded) {
+			this.setToolOutputExpansionState(false, false);
+			return;
+		}
+		if (this.shouldUseCollapsedToolCallIntermediateState() && !this.collapsedToolCallsExpanded) {
+			this.setToolOutputExpansionState(true, false);
+			return;
+		}
+		this.setToolOutputExpansionState(true, true);
 	}
 
 	private setToolsExpanded(expanded: boolean): void {
-		this.toolOutputExpanded = expanded;
+		this.setToolOutputExpansionState(expanded, expanded);
+	}
+
+	private setToolOutputExpansionState(collapsedToolCallsExpanded: boolean, toolOutputExpanded: boolean): void {
+		this.collapsedToolCallsExpanded = collapsedToolCallsExpanded || toolOutputExpanded;
+		this.toolOutputExpanded = toolOutputExpanded;
+		const collapseToolCalls = this.settingsManager.getCollapseToolCalls();
+		const showCollapsedToolCalls = collapseToolCalls && this.collapsedToolCallsExpanded;
 		for (const child of this.chatContainer.children) {
 			if (isExpandable(child)) {
-				child.setExpanded(expanded);
+				child.setExpanded(toolOutputExpanded);
 			}
 			if (child instanceof ToolExecutionComponent) {
-				child.setHidden(!expanded && child.shouldHideWhenCollapsed());
+				child.setHidden(!showCollapsedToolCalls && child.shouldHideWhenCollapsed(collapseToolCalls));
+				child.setIndented(false);
 			}
 			if (child instanceof ToolSummaryLine) {
-				child.setHidden(expanded);
+				child.setHidden(!collapseToolCalls || showCollapsedToolCalls);
 			}
 		}
 		if (this.bashComponent) {
-			this.bashComponent.setExpanded(expanded);
+			this.bashComponent.setExpanded(toolOutputExpanded);
 		}
 		for (const component of this.pendingBashComponents) {
-			component.setExpanded(expanded);
+			component.setExpanded(toolOutputExpanded);
 		}
 		this.updateEditorExpandHint();
 		this.ui.requestRender();
 	}
 
-	/** Append/remove the "ctrl+o to expand" hint in the editor bottom border. */
+	/** Append/remove right-aligned expand and streaming hints in editor bottom border. */
 	updateEditorExpandHint(): void {
 		const expandKey = appKey(this.keybindings, "expandTools");
 		const collapseHint = `${theme.fg("dim", expandKey)}${theme.fg("muted", " collapse")}`;
-		const expandHint = `${theme.fg("dim", expandKey)}${theme.fg("muted", " : verbose")}`;
-		// The base hint set during agent_start
-		const enterKey = theme.fg("dim", "↵");
-		const followUpKey = theme.fg("dim", appKey(this.keybindings, "followUp"));
-		const steerLabel = theme.fg("muted", " steer");
-		const queueLabel = theme.fg("muted", " queue");
-		const baseHint = `${enterKey}${steerLabel}  ${followUpKey}${queueLabel}`;
+		const expandToolCallsHint = `${theme.fg("dim", expandKey)}${theme.fg("muted", " : uncollapsed tools")}`;
+		const expandVerboseHint = `${theme.fg("dim", expandKey)}${theme.fg("muted", " : verbose")}`;
+		const editorHasText = this.defaultEditor.getText().trim().length > 0;
+		const streamingHints = editorHasText
+			? `${theme.fg("dim", "↵")}${theme.fg("muted", " steer")}  ${theme.fg("dim", appKey(this.keybindings, "followUp"))}${theme.fg("muted", " queue")}`
+			: "";
 
 		// Check if there are any expandable tool outputs in the chat
 		const hasToolOutputs =
 			this.chatContainer.children.some(isExpandable) ||
 			!!this.bashComponent ||
 			this.pendingBashComponents.length > 0;
+		const canExpandCollapsedToolCalls = this.shouldUseCollapsedToolCallIntermediateState();
 
-		const activeHint = this.toolOutputExpanded ? collapseHint : expandHint;
+		let activeHint = expandVerboseHint;
+		if (this.toolOutputExpanded) {
+			activeHint = collapseHint;
+		} else if (this.collapsedToolCallsExpanded && canExpandCollapsedToolCalls) {
+			activeHint = expandVerboseHint;
+		} else if (canExpandCollapsedToolCalls) {
+			activeHint = expandToolCallsHint;
+		}
 
-		if (this.loadingAnimation) {
-			// Agent is running - always show expand/collapse hint when there are tool outputs
-			this.defaultEditor.bottomHint = hasToolOutputs
-				? `${baseHint}  ${activeHint}`
-				: baseHint;
-		} else if (hasToolOutputs) {
-			// Idle - show expand/collapse hint so user knows ctrl+o works
-			this.defaultEditor.bottomHint = activeHint;
+		const rightHints: string[] = [];
+		if (this.loadingAnimation && streamingHints) {
+			rightHints.push(streamingHints);
 		}
-		// If no tool outputs and idle, leave bottomHint as-is (cleared by agent_end)
+		if (hasToolOutputs) {
+			rightHints.push(activeHint);
+		}
+
+		this.defaultEditor.bottomHint = rightHints.join("  ");
 	}
 
 	private toggleThinkingBlockVisibility(): void {
@@ -3481,6 +3514,7 @@ export class InteractiveMode {
 					codexRotate: this.settingsManager.getCodexRotate(),
 					fastMode: this.settingsManager.getFastMode(),
 					cacheTimer: this.settingsManager.getCacheTimer(),
+					verboseFooter: this.settingsManager.getVerboseFooter(),
 					pinLastPrompt: this.settingsManager.getPinLastPrompt(),
 					steeringMode: this.session.steeringMode,
 					followUpMode: this.session.followUpMode,
@@ -3505,6 +3539,7 @@ export class InteractiveMode {
 					clearOnShrink: this.settingsManager.getClearOnShrink(),
 					timestampFormat: this.settingsManager.getTimestampFormat(),
 					toolOutputMode: this.settingsManager.getToolOutputMode(),
+					collapseToolCalls: this.settingsManager.getCollapseToolCalls(),
 					rtk: this.settingsManager.getRtk(),
 					editorScheme: this.settingsManager.getEditorScheme(),
 					autoDream: this.settingsManager.getAutoDream(),
@@ -3688,6 +3723,12 @@ export class InteractiveMode {
 						this.settingsManager.setCacheTimer(enabled);
 						this.showStatus(`Cache timer: ${enabled ? "enabled" : "disabled"}`);
 					},
+					onVerboseFooterChange: (enabled) => {
+						this.settingsManager.setVerboseFooter(enabled);
+						this.footer.setVerboseFooterEnabled(enabled);
+						this.ui.requestRender();
+						this.showStatus(`Verbose footer: ${enabled ? "enabled" : "disabled"}`);
+					},
 					onPinLastPromptChange: (enabled) => {
 						this.settingsManager.setPinLastPrompt(enabled);
 						this.pinLastPromptEnabled = enabled;
@@ -3827,6 +3868,14 @@ export class InteractiveMode {
 						this.settingsManager.setEditorScheme(scheme);
 						this.showStatus(`Editor link scheme: ${scheme}`);
 					},
+					onCollapseToolCallsChange: (enabled) => {
+						this.settingsManager.setCollapseToolCalls(enabled);
+						this.setToolOutputExpansionState(enabled && (this.collapsedToolCallsExpanded || this.toolOutputExpanded), this.toolOutputExpanded);
+						if (!enabled) {
+							this.collapsedToolSummaryLine = undefined;
+						}
+						this.showStatus(`Collapse tool calls: ${enabled ? "enabled" : "disabled"}`);
+					},
 					onToolOutputModeChange: (mode) => {
 						this.settingsManager.setToolOutputMode(mode);
 						for (const child of this.chatContainer.children) {

package/packages/pi-coding-agent/src/modes/interactive/theme/themes.ts

@@ -78,8 +78,8 @@ const dark: ThemeJson = {
 		mdHr: "gray",
 		mdListBullet: "accent",
 
-		toolDiffAdded: "green",
-		toolDiffRemoved: "red",
+		toolDiffAdded: "#4ade80",
+		toolDiffRemoved: "#fb7185",
 		toolDiffContext: "gray",
 
 		syntaxComment: "#6A9955",
@@ -174,8 +174,8 @@ const light: ThemeJson = {
 		mdHr: "mediumGray",
 		mdListBullet: "green",
 
-		toolDiffAdded: "green",
-		toolDiffRemoved: "red",
+		toolDiffAdded: "#15803d",
+		toolDiffRemoved: "#b91c1c",
 		toolDiffContext: "mediumGray",
 
 		syntaxComment: "#008000",

package/packages/pi-coding-agent/src/modes/rpc/rpc-mode.ts

@@ -422,6 +422,10 @@ export async function runRpcMode(session: AgentSession): Promise<never> {
 		setToolsExpanded(_expanded: boolean) {
 			// Tool expansion not supported in RPC mode - no TUI
 		},
+
+		isEditorFocused() {
+			return false;
+		},
 	});
 
 	// Set up extensions with RPC-based UI context.

package/packages/pi-tui/dist/components/editor.js

@@ -343,15 +343,15 @@ export class Editor {
             result.push(this.borderColor(indicator + "─".repeat(Math.max(0, remaining))));
         }
         else if (this.bottomHint) {
-            // Embed hint right-aligned in the bottom border: ─────── hint ─
+            // Embed hint at far right in bottom border: ─────────────── hint ─
             // Apply borderColor only to the dashes so the hint's own styling is preserved.
             const hintVisible = visibleWidth(this.bottomHint);
             const minDashes = 1;
             const separatorWidth = 1; // single space on each side of hint
             const totalFixed = hintVisible + separatorWidth * 2 + minDashes * 2;
             if (width >= totalFixed) {
-                const leftDashes = Math.floor((width - hintVisible - separatorWidth * 2) * 0.75);
-                const rightDashes = Math.max(minDashes, width - hintVisible - separatorWidth * 2 - leftDashes);
+                const rightDashes = minDashes;
+                const leftDashes = Math.max(minDashes, width - hintVisible - separatorWidth * 2 - rightDashes);
                 const line = this.borderColor("─".repeat(leftDashes)) +
                     " " +
                     this.bottomHint +