@caupulican/pi-adaptative 0.93.18 → 0.94.0

package/dist/modes/interactive/interactive-mode.js

@@ -5,7 +5,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getToolCallRepairInfo } from "@caupulican/pi-agent-core/agent-loop";
-import { Container, Loader, ProcessTerminal, Spacer, setKeybindings, Text, TUI, } from "@caupulican/pi-tui";
+import { Container, ProcessTerminal, Spacer, setKeybindings, Text, TUI, } from "@caupulican/pi-tui";
 import { APP_NAME, APP_TITLE, getAgentDir, VERSION } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
@@ -25,6 +25,8 @@ import * as autocompleteProvider from "./autocomplete-provider.js";
 import * as autonomyCommands from "./autonomy-commands.js";
 import * as clipboardInput from "./clipboard-input.js";
 import * as compactionQueue from "./compaction-queue.js";
+import { ActionTranscriptComponent } from "./components/action-transcript.js";
+import { ActiveToolCallRegistry } from "./components/active-tool-call-registry.js";
 import { ActivityLaneComponent } from "./components/activity-lane.js";
 import { AgentsOverlay } from "./components/agents-overlay.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
@@ -39,9 +41,7 @@ import { FooterComponent } from "./components/footer.js";
 import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
-import { ToolGroupComponent } from "./components/tool-group.js";
-import { getToolPanelActionKey, shouldReuseToolPanelInPlace, ToolPanelRegistry, } from "./components/tool-panel-registry.js";
-import { TranscriptPager } from "./components/transcript-pager.js";
+import { openTranscriptOverlay } from "./components/transcript-overlay.js";
 import { UserMessageComponent } from "./components/user-message.js";
 import * as configBackup from "./config-backup.js";
 import { EditorOverlayHost } from "./editor-overlay-host.js";
@@ -56,6 +56,7 @@ import * as localModelCommands from "./local-model-commands.js";
 import { ProfileMenuController } from "./profile-menu-controller.js";
 import * as reportCommands from "./report-commands.js";
 import * as resourceShellCommands from "./resource-shell-commands.js";
+import { RuntimeStatusController } from "./runtime-status-controller.js";
 import { SecretMenuController } from "./secret-menu-controller.js";
 import * as sessionFlows from "./session-flow-commands.js";
 import * as sessionIoCommands from "./session-io-commands.js";
@@ -108,6 +109,24 @@ export class InteractiveMode {
     get settingsManager() {
         return this.session.settingsManager;
     }
+    get loadingAnimation() {
+        return this.runtimeStatus.loadingAnimation;
+    }
+    set loadingAnimation(value) {
+        this.runtimeStatus.loadingAnimation = value;
+    }
+    get workingVisible() {
+        return this.runtimeStatus.isWorkingVisible;
+    }
+    set workingVisible(value) {
+        this.runtimeStatus.isWorkingVisible = value;
+    }
+    get workingIndicatorOptions() {
+        return this.runtimeStatus.indicatorOptions;
+    }
+    set workingIndicatorOptions(value) {
+        this.runtimeStatus.indicatorOptions = value;
+    }
     constructor(runtimeHost, options = {}) {
         this.autocompleteProviderWrappers = [];
         this.isInitialized = false;
@@ -116,13 +135,6 @@ export class InteractiveMode {
             pendingClipboardImages: [],
             clipboardImageCounter: 0,
         };
-        this.loadingAnimation = undefined;
-        this.workingMessage = undefined;
-        this.workingVisible = true;
-        this.workingIndicatorOptions = undefined;
-        this.defaultWorkingMessage = "Working...";
-        this.defaultHiddenThinkingLabel = "Thinking...";
-        this.hiddenThinkingLabel = this.defaultHiddenThinkingLabel;
         this.lastSigintTime = 0;
         this.lastEscapeTime = 0;
         this.changelogMarkdown = undefined;
@@ -141,10 +153,11 @@ export class InteractiveMode {
         this.streamingMessage = undefined;
         this.streamingUiUpdateTimer = undefined;
         this.lastStreamingUiUpdateAt = 0;
-        // Tool execution tracking and session-scoped reusable panels
-        this.toolPanels = new ToolPanelRegistry();
+        // Active execution identity. Completed actions are owned by the transcript.
+        this.activeToolCalls = new ActiveToolCallRegistry();
         // Tool output expansion state
         this.toolOutputExpanded = false;
+        this.transcriptActionsExpanded = false;
         // Thinking block visibility state
         this.hideThinkingBlock = true;
         // Skill commands: command name -> skill file path
@@ -180,7 +193,6 @@ export class InteractiveMode {
         this.runtimeHost = runtimeHost;
         this.options = options;
         this.hasHumanAudience = options.hasHumanAudience ?? true;
-        this.workingVisible = this.hasHumanAudience;
         this.runtimeHost.setBeforeSessionInvalidate(() => {
             this.extensionUiHost.resetExtensionUI();
         });
@@ -199,6 +211,14 @@ export class InteractiveMode {
         this.activityLane = this.hasHumanAudience
             ? new ActivityLaneComponent(theme, () => this.ui.requestRender())
             : undefined;
+        this.runtimeStatus = new RuntimeStatusController({
+            ui: this.ui,
+            statusContainer: this.statusContainer,
+            activityLane: this.activityLane,
+            hasHumanAudience: this.hasHumanAudience,
+            isStreaming: () => this.session.isStreaming,
+            isThinkingHidden: () => this.hideThinkingBlock,
+        });
         this.keybindings = KeybindingsManager.create();
         setKeybindings(this.keybindings);
         const editorPaddingX = this.settingsManager.getEditorPaddingX();
@@ -414,6 +434,7 @@ export class InteractiveMode {
                 hint("app.tools.expand", "to expand tools"),
                 hint("app.history.load", "to load session history"),
                 hint("app.agents.open", "to show live agents"),
+                hint("app.transcript.open", "to view transcript"),
                 hint("app.thinking.toggle", "to expand thinking"),
                 hint("app.editor.external", "for external editor"),
                 rawKeyHint("/", "for commands"),
@@ -864,7 +885,7 @@ export class InteractiveMode {
         this.compactionQueuedMessages = [];
         this.streamingComponent = undefined;
         this.streamingMessage = undefined;
-        this.clearRenderedToolPanelState();
+        this.clearActiveToolCallState();
         void this.renderInitialMessages();
     }
     /**
@@ -873,193 +894,81 @@ export class InteractiveMode {
     getRegisteredToolDefinition(toolName) {
         return this.session.getToolDefinition(toolName);
     }
-    getToolPanelScope() {
-        return {
-            sessionId: this.sessionManager.getSessionId?.(),
-            sessionFile: this.sessionManager.getSessionFile?.(),
-            cwd: this.sessionManager.getCwd(),
-        };
-    }
-    appendToolExecutionComponent(component, allowGrouping) {
-        const toolGroup = allowGrouping ? component.toolGroup?.trim() : undefined;
-        if (!toolGroup) {
-            this.chatContainer.addChild(component);
-            this.trimLiveTuiHistory();
-            return;
-        }
+    appendTranscriptAction(component) {
         const children = this.chatContainer.children;
-        const lastChild = children[children.length - 1];
-        if (lastChild instanceof ToolGroupComponent && lastChild.toolGroup === toolGroup) {
-            lastChild.addTool(component);
-            this.trimLiveTuiHistory();
-            return;
-        }
-        if (lastChild instanceof ToolExecutionComponent && lastChild.toolGroup?.trim() === toolGroup) {
-            const group = new ToolGroupComponent(toolGroup, [lastChild, component]);
-            group.setExpanded(this.toolOutputExpanded);
-            children[children.length - 1] = group;
-            this.trimLiveTuiHistory();
-            return;
-        }
-        this.chatContainer.addChild(component);
-        this.trimLiveTuiHistory();
-    }
-    detachToolExecutionComponent(component) {
-        const children = this.chatContainer.children;
-        const directIndex = children.indexOf(component);
-        if (directIndex !== -1) {
-            children.splice(directIndex, 1);
-            return;
-        }
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-            if (!(child instanceof ToolGroupComponent) || !child.removeTool(component))
-                continue;
-            const remaining = child.getToolCount();
-            if (remaining === 0) {
-                children.splice(i, 1);
-            }
-            else if (remaining === 1) {
-                const onlyTool = child.getOnlyTool();
-                if (onlyTool)
-                    children[i] = onlyTool;
+        for (let index = children.length - 1; index >= 0; index--) {
+            const candidate = children[index];
+            if (candidate instanceof ActionTranscriptComponent) {
+                if (candidate.canAccept()) {
+                    candidate.addAction(component);
+                    this.trimLiveTuiHistory();
+                    return;
+                }
+                break;
             }
-            return;
+            if (candidate instanceof AssistantMessageComponent && !candidate.hasVisibleOutput())
+                continue;
+            break;
         }
+        const transcript = new ActionTranscriptComponent([component]);
+        transcript.setTranscriptExpanded(this.transcriptActionsExpanded);
+        this.chatContainer.addChild(transcript);
+        this.trimLiveTuiHistory();
     }
     attachToolExecutionComponent(toolName, toolCallId, args, repair, deferResultUntilExpanded = false) {
-        const actionKey = getToolPanelActionKey(this.getToolPanelScope(), toolName, args);
         const toolDefinition = this.getRegisteredToolDefinition(toolName);
-        const reuseInPlace = shouldReuseToolPanelInPlace(toolName, args);
-        const existing = this.toolPanels.getReusable(actionKey, { allowActive: reuseInPlace });
-        if (existing) {
-            if (reuseInPlace && actionKey) {
-                existing.resetInvocation(toolName, toolCallId, args, toolDefinition, repair, deferResultUntilExpanded);
-                existing.setExpanded(this.toolOutputExpanded);
-                this.toolPanels.replaceActiveForAction(toolCallId, existing, actionKey);
-                this.ui.requestRender();
-                return existing;
-            }
-            this.detachToolExecutionComponent(existing);
-            existing.resetInvocation(toolName, toolCallId, args, toolDefinition, repair, deferResultUntilExpanded);
-            existing.setExpanded(this.toolOutputExpanded);
-            this.appendToolExecutionComponent(existing, true);
-            this.toolPanels.register(toolCallId, existing, actionKey);
-            return existing;
-        }
         const component = new ToolExecutionComponent(toolName, toolCallId, args, {
             showImages: this.settingsManager.getShowImages(),
             imageWidthCells: this.settingsManager.getImageWidthCells(),
             repair,
             deferResultUntilExpanded,
         }, toolDefinition, this.ui, this.sessionManager.getCwd());
-        component.setExpanded(this.toolOutputExpanded);
-        this.appendToolExecutionComponent(component, true);
-        this.toolPanels.register(toolCallId, component, actionKey);
+        this.appendTranscriptAction(component);
+        this.activeToolCalls.register(toolCallId, component);
         return component;
     }
     clearActiveToolCalls() {
-        this.toolPanels.clearActive();
+        this.activeToolCalls.clearActive();
     }
-    clearRenderedToolPanelState() {
-        this.toolPanels.clearAll();
+    clearActiveToolCallState() {
+        this.activeToolCalls.clearActive();
     }
     getWorkingLoaderMessage() {
-        return this.workingMessage ?? this.defaultWorkingMessage;
+        return this.runtimeStatus.getWorkingLoaderMessage();
     }
     createWorkingLoader() {
-        return new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), this.getWorkingLoaderMessage(), this.workingIndicatorOptions);
+        return this.runtimeStatus.createWorkingLoader();
     }
     stopWorkingLoader() {
-        if (this.loadingAnimation) {
-            this.loadingAnimation.stop();
-            this.loadingAnimation = undefined;
-        }
-        this.statusContainer.clear();
-        this.activityLane?.remove("runtime:routing");
-        this.activityLane?.remove("runtime:turn");
+        this.runtimeStatus.stopWorkingLoader();
     }
     setWorkingVisible(visible) {
-        if (!this.hasHumanAudience) {
-            this.workingVisible = false;
-            this.stopWorkingLoader();
-            return;
-        }
-        this.workingVisible = visible;
-        if (!visible) {
-            this.stopWorkingLoader();
-            this.ui.requestRender();
-            return;
-        }
-        if (this.session.isStreaming && !this.loadingAnimation) {
-            if (this.workingIndicatorOptions) {
-                this.statusContainer.clear();
-                this.loadingAnimation = this.createWorkingLoader();
-                this.statusContainer.addChild(this.loadingAnimation);
-            }
-            else {
-                this.activityLane?.start({ id: "runtime:turn", kind: "runtime", label: this.getWorkingLoaderMessage() });
-            }
-        }
-        this.ui.requestRender();
+        this.runtimeStatus.setWorkingVisible(visible);
     }
     setWorkingIndicator(options) {
-        this.workingIndicatorOptions = options;
-        if (!this.hasHumanAudience) {
-            this.stopWorkingLoader();
-            return;
-        }
-        if (options) {
-            this.activityLane?.remove("runtime:turn");
-            if (this.session.isStreaming && this.workingVisible) {
-                this.stopWorkingLoader();
-                this.loadingAnimation = this.createWorkingLoader();
-                this.statusContainer.addChild(this.loadingAnimation);
-            }
-        }
-        else {
-            this.loadingAnimation?.stop();
-            this.loadingAnimation = undefined;
-            this.statusContainer.clear();
-            if (this.session.isStreaming && this.workingVisible) {
-                this.activityLane?.start({ id: "runtime:turn", kind: "runtime", label: this.getWorkingLoaderMessage() });
-            }
-        }
-        this.ui.requestRender();
+        this.runtimeStatus.setWorkingIndicator(options);
     }
     setHiddenThinkingLabel(label) {
-        this.hiddenThinkingLabel = label ?? this.defaultHiddenThinkingLabel;
-        for (const child of this.chatContainer.children) {
-            if (child instanceof AssistantMessageComponent) {
-                child.setHiddenThinkingLabel(this.hiddenThinkingLabel);
-            }
-        }
-        if (this.streamingComponent) {
-            this.streamingComponent.setHiddenThinkingLabel(this.hiddenThinkingLabel);
-        }
-        this.ui.requestRender();
+        this.runtimeStatus.setHiddenThinkingLabel(label);
+        if (this.streamingMessage)
+            this.updateRuntimeStatus(this.streamingMessage);
+    }
+    updateRuntimeStatus(message) {
+        this.runtimeStatus.updateRuntimeStatus(message);
     }
     /**
      * Set the extension-provided working-loader message (undefined restores the default).
      */
     setWorkingMessage(message) {
-        this.workingMessage = message;
-        if (this.loadingAnimation) {
-            this.loadingAnimation.setMessage(message ?? this.defaultWorkingMessage);
-        }
-        this.activityLane?.update("runtime:turn", message ?? this.defaultWorkingMessage);
+        this.runtimeStatus.setWorkingMessage(message, this.streamingMessage);
     }
     /**
      * Reset the working indicator and hidden-thinking label to their built-in defaults.
      */
     resetWorkingIndicators() {
-        this.workingMessage = undefined;
-        this.workingVisible = this.hasHumanAudience;
-        this.setWorkingIndicator();
-        if (this.loadingAnimation) {
-            this.loadingAnimation.setMessage(`${this.defaultWorkingMessage} (${keyText("app.interrupt")} to interrupt)`);
-        }
-        this.setHiddenThinkingLabel();
+        this.runtimeStatus.resetWorkingIndicators();
+        if (this.streamingMessage)
+            this.updateRuntimeStatus(this.streamingMessage);
     }
     async promptForMissingSessionCwd(error) {
         const confirmed = await this.extensionUiHost.showExtensionConfirm("Session cwd not found", formatMissingSessionCwdPrompt(error.issue));
@@ -1537,7 +1446,7 @@ export class InteractiveMode {
     showDeferredHistoryPlaceholder(options = {}) {
         this.chatContainer.children = [];
         this.resetLiveTuiHistoryTrim();
-        this.clearRenderedToolPanelState();
+        this.clearActiveToolCallState();
         const entryCount = this.getSessionEntryCount();
         if (entryCount > 0) {
             this.chatContainer.addChild(new Text(theme.fg("dim", `History hidden for typing performance (${entryCount} entries). Press ${keyText("app.history.load")} to load session history.`), 1, 0));
@@ -1609,30 +1518,27 @@ export class InteractiveMode {
         overlay.mount();
     }
     showTranscriptPager() {
-        let handle;
-        const pager = new TranscriptPager({
+        openTranscriptOverlay({
             source: this.chatContainer,
             viewportRows: () => this.ui.terminal.rows,
             keybindings: this.keybindings,
-            onClose: () => handle?.hide(),
-        });
-        handle = this.ui.showOverlay(pager, {
-            width: "100%",
-            maxHeight: "100%",
-            row: 0,
-            col: 0,
+            getToolsExpanded: () => this.toolOutputExpanded,
+            setToolsExpanded: (expanded) => this.setToolsExpanded(expanded),
+            getActionsExpanded: () => this.transcriptActionsExpanded,
+            setActionsExpanded: (expanded) => this.setTranscriptActionsExpanded(expanded),
+            showOverlay: (component, options) => this.ui.showOverlay(component, options),
         });
     }
-    attachStreamingToolPanels(message) {
+    attachStreamingToolActions(message) {
         for (const content of message.content) {
             if (content.type !== "toolCall")
                 continue;
             const repair = getToolCallRepairInfo(content);
-            if (!this.toolPanels.hasActive(content.id)) {
+            if (!this.activeToolCalls.hasActive(content.id)) {
                 this.attachToolExecutionComponent(content.name, content.id, content.arguments, repair);
             }
             else {
-                const component = this.toolPanels.getActive(content.id);
+                const component = this.activeToolCalls.getActive(content.id);
                 if (component) {
                     component.updateArgs(content.arguments, repair);
                 }
@@ -1641,6 +1547,7 @@ export class InteractiveMode {
     }
     applyStreamingMessageUpdate(message, options = {}) {
         this.streamingMessage = message;
+        this.updateRuntimeStatus(message);
         if (!this.streamingComponent)
             return;
         const now = performance.now();
@@ -1651,7 +1558,7 @@ export class InteractiveMode {
             if (!this.streamingComponent || !this.streamingMessage)
                 return;
             this.streamingComponent.updateContent(this.streamingMessage);
-            this.attachStreamingToolPanels(this.streamingMessage);
+            this.attachStreamingToolActions(this.streamingMessage);
             this.lastStreamingUiUpdateAt = performance.now();
             this.ui.requestRender();
         };
@@ -1682,8 +1589,9 @@ export class InteractiveMode {
         protect(this.streamingComponent);
         protect(this.lastStatusSpacer);
         protect(this.lastStatusText);
-        for (const [, component] of this.toolPanels.activeEntries()) {
-            protect(component);
+        for (const [, action] of this.activeToolCalls.activeEntries()) {
+            const transcript = children.find((child) => child instanceof ActionTranscriptComponent && child.containsAction(action));
+            protect(transcript);
         }
         const trimStart = children[0] === this.liveHistoryHiddenNotice ? 1 : 0;
         const targetTrimEnd = children.length - TUI_LIVE_HISTORY_TRIM_TO_COMPONENTS;
@@ -1798,7 +1706,7 @@ export class InteractiveMode {
                 break;
             }
             case "assistant": {
-                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
+                const assistantComponent = new AssistantMessageComponent(message, this.hideThinkingBlock, this.getMarkdownThemeWithSettings());
                 this.chatContainer.addChild(assistantComponent);
                 break;
             }
@@ -1836,7 +1744,7 @@ export class InteractiveMode {
             const stagingChatContainer = new Container();
             this.chatContainer = stagingChatContainer;
             this.resetLiveTuiHistoryTrim();
-            this.clearRenderedToolPanelState();
+            this.clearActiveToolCallState();
             const renderedPendingTools = new Map();
             try {
                 if (options.updateFooter) {
@@ -1874,7 +1782,7 @@ export class InteractiveMode {
                                         errorMessage = message.errorMessage || "Error";
                                     }
                                     component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
-                                    this.toolPanels.finish(content.id);
+                                    this.activeToolCalls.finish(content.id);
                                 }
                                 else {
                                     renderedPendingTools.set(content.id, component);
@@ -1888,7 +1796,7 @@ export class InteractiveMode {
                         if (component) {
                             component.updateResult(message);
                             renderedPendingTools.delete(message.toolCallId);
-                            this.toolPanels.finish(message.toolCallId);
+                            this.activeToolCalls.finish(message.toolCallId);
                         }
                     }
                     else {
@@ -2143,6 +2051,14 @@ export class InteractiveMode {
         }
         this.ui.requestRender();
     }
+    setTranscriptActionsExpanded(expanded) {
+        this.transcriptActionsExpanded = expanded;
+        for (const child of this.chatContainer.children) {
+            if (child instanceof ActionTranscriptComponent)
+                child.setTranscriptExpanded(expanded);
+        }
+        this.ui.requestRender();
+    }
     async toggleThinkingBlockVisibility() {
         this.hideThinkingBlock = !this.hideThinkingBlock;
         this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
@@ -2152,7 +2068,12 @@ export class InteractiveMode {
         if (this.streamingComponent && this.streamingMessage) {
             this.streamingComponent.setHideThinkingBlock(this.hideThinkingBlock);
             this.streamingComponent.updateContent(this.streamingMessage);
+            this.updateRuntimeStatus(this.streamingMessage);
             this.chatContainer.addChild(this.streamingComponent);
+            // Rebuilding the chat clears active call identity. Reattach
+            // any tool calls that are still arriving so toggling thinking visibility
+            // cannot make an in-flight tool disappear from the TUI.
+            this.attachStreamingToolActions(this.streamingMessage);
         }
         this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
     }