@kolisachint/hoocode-agent 0.5.30 → 0.5.32

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

@@ -18,6 +18,7 @@ import { canvasSearchRoots, discoverCanvasExtensions } from "../../core/canvas/d
 import { pluginCanvasExtensions } from "../../core/canvas/plugin-canvases.js";
 import { gateCanvasExtensions } from "../../core/canvas/trust.js";
 import { getWorkspacePlatforms, setPlatforms } from "../../core/extensions/plugins/formats/platform-targets.js";
+import { describeExternalTools } from "../../core/external-tools.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { formatDurationSecs } from "../../core/format-duration.js";
 import { formatTokens } from "../../core/format-tokens.js";
@@ -28,6 +29,7 @@ import { SessionManager } from "../../core/session-manager.js";
 import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { startupProgress } from "../../core/startup-progress.js";
 import { taskStore } from "../../core/task-store.js";
+import { cycleToolOutputView } from "../../core/tool-output-view.js";
 import { settleDanglingMainTasks } from "../../core/tools/todo.js";
 import { buildCompactWordmark } from "../../core/wordmark.js";
 import { extensionForImageMimeType, readClipboardImage } from "../../utils/clipboard-image.js";
@@ -52,6 +54,7 @@ import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
 import { TaskPanelComponent } from "./components/task-panel.js";
+import { ToolChainComponent } from "./components/tool-chain.js";
 import { ToolExecutionComponent } from "./components/tool-execution.js";
 import { TreeSelectorComponent } from "./components/tree-selector.js";
 import { UserMessageComponent } from "./components/user-message.js";
@@ -196,8 +199,13 @@ export class InteractiveMode {
     pendingTools = new Map();
     // Tool output expansion state
     toolOutputExpanded = false;
-    // Persisted tool-output display level (collapsed / peek / standard).
-    toolOutputDisplay = "standard";
+    // Persisted view dial (radar / glance / full). See core/tool-output-view.ts.
+    toolOutputView = "glance";
+    // The chain currently collecting tool calls, if the agent is mid-run.
+    openChain;
+    // Whether the assistant message being streamed has said anything yet. The
+    // first words it speaks close the chain the previous message's calls built.
+    sawTextInCurrentMessage = false;
     // Thinking block visibility state
     hideThinkingBlock = false;
     // Skill commands: command name -> skill file path
@@ -371,6 +379,7 @@ export class InteractiveMode {
         this.footerDataProvider = new FooterDataProvider(this.sessionManager.getCwd());
         this.footer = new FooterComponent(this.session, this.footerDataProvider);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
+        this.footer.setToolOutputView(this.toolOutputView);
         this.footerDataProvider.setSubagentEnabled(this.session.getActiveToolNames().includes("Task"));
         this.chrome = new ExtensionChrome({
             ui: this.ui,
@@ -459,8 +468,8 @@ export class InteractiveMode {
         this.taskPanel.onExitFocus = () => this.teamFocus.exitFocus();
         // Load hide thinking block setting
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
-        // Load tool-output display level
-        this.toolOutputDisplay = this.settingsManager.getToolOutputDisplay();
+        // Load the tool-output view dial
+        this.toolOutputView = this.settingsManager.getToolOutputView();
         // Completion chime: rings the terminal bell when a long turn finishes or the
         // agent blocks awaiting input. Enable is read fresh so a live toggle applies.
         this.chime = new CompletionChime({
@@ -542,6 +551,14 @@ export class InteractiveMode {
                 }));
             };
         }
+        const cdCommand = slashCommands.find((command) => command.name === "cd");
+        if (cdCommand) {
+            cdCommand.argumentHint = "<path>";
+            cdCommand.getArgumentCompletions = (prefix) => {
+                const completions = this.commandExecutor.getChangeDirectoryCompletions(prefix);
+                return completions.length > 0 ? completions : null;
+            };
+        }
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
@@ -657,7 +674,9 @@ export class InteractiveMode {
         // Add header with keybindings from config (unless silenced)
         if (this.options.verbose || !this.settingsManager.getQuietStartup()) {
             const termW = this.ui.terminal.columns;
-            const logo = termW >= 40
+            // A function, not a value: the banner names the working directory, and
+            // `/cd` moves it. `refreshBuiltInHeader` re-reads this after a move.
+            const logo = () => termW >= 40
                 ? buildCompactWordmark({
                     appName: APP_NAME,
                     version: this.version,
@@ -681,10 +700,16 @@ export class InteractiveMode {
                 hint("app.thinking.cycle", "to cycle thinking level"),
                 rawKeyHint(`${keyText("app.model.cycleForward")}/${keyText("app.model.cycleBackward")}`, "to cycle models"),
                 hint("app.model.select", "to select model"),
-                hint("app.tools.expand", "to expand tools"),
+                hint("app.tools.expand", "to expand all tool output"),
+                hint("app.tools.unfoldOne", "to open one chain or block (repeat to peel back)"),
+                hint("app.view.cycleForward", "to cycle tool output (radar/glance/full)"),
                 hint("app.thinking.toggle", "to expand thinking"),
                 hint("app.tasks.cycleView", "to cycle task panel view"),
                 ...(this.teamFocus.connected ? [hint("app.team.focus", "to focus team roster")] : []),
+                hint("app.mode.cycle", "to cycle agent mode"),
+                hint("app.session.changeDirectory", "to change working directory"),
+                hint("app.settings.open", "for settings"),
+                hint("app.hotkeys.open", "for all shortcuts"),
                 hint("app.editor.external", "for external editor"),
                 rawKeyHint("/", "for commands"),
                 rawKeyHint("!", "to run bash"),
@@ -695,7 +720,7 @@ export class InteractiveMode {
                 rawKeyHint("drop files", "to attach"),
             ].join("\n");
             const onboarding = theme.fg("dim", `${APP_NAME} can explain its own features and look up its docs. Ask it how to use or extend ${APP_NAME}.`);
-            this.builtInHeader = new ExpandableText(() => logo, () => `${logo}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
+            this.builtInHeader = new ExpandableText(() => logo(), () => `${logo()}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
             // Setup UI layout
             this.headerContainer.addChild(this.builtInHeader);
         }
@@ -1001,6 +1026,11 @@ export class InteractiveMode {
     applyRuntimeSettings() {
         this.footer.setSession(this.session);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
+        this.footer.setToolOutputView(this.toolOutputView);
+        // The startup banner names the cwd, which `/cd` changes under it.
+        if (this.builtInHeader instanceof ExpandableText) {
+            this.builtInHeader.refresh();
+        }
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
@@ -1047,6 +1077,7 @@ export class InteractiveMode {
      */
     renderCurrentSessionState() {
         this.chatContainer.clear();
+        this.openChain = undefined;
         this.pendingMessagesContainer.clear();
         this.messageQueue.resetCompactionQueue();
         this.streamingComponent = undefined;
@@ -1063,12 +1094,7 @@ export class InteractiveMode {
      * later full rebuild (theme toggle / reload) restores full fidelity.
      */
     trimTranscriptMemory() {
-        const freezable = [];
-        for (const child of this.chatContainer.children) {
-            if (child instanceof ToolExecutionComponent && child.isFreezable()) {
-                freezable.push(child);
-            }
-        }
+        const freezable = this.transcriptToolBlocks().filter((block) => block.isFreezable());
         const excess = freezable.length - LIVE_TOOL_WINDOW;
         for (let i = 0; i < excess; i++) {
             freezable[i].freeze();
@@ -1443,6 +1469,10 @@ export class InteractiveMode {
         this.ui.onDebug = () => this.commandExecutor.handleDebug();
         this.defaultEditor.onAction("app.model.select", () => this.modelController.showModelSelector());
         this.defaultEditor.onAction("app.tools.expand", () => this.toggleToolOutputExpansion());
+        this.defaultEditor.onAction("app.view.cycleForward", () => this.cycleToolOutputView("forward"));
+        this.defaultEditor.onAction("app.view.cycleBackward", () => this.cycleToolOutputView("backward"));
+        this.defaultEditor.onAction("app.tools.unfoldOne", () => this.stepToolOutput("unfold"));
+        this.defaultEditor.onAction("app.tools.foldOne", () => this.stepToolOutput("fold"));
         this.defaultEditor.onAction("app.thinking.toggle", () => this.toggleThinkingBlockVisibility());
         this.defaultEditor.onAction("app.tasks.cycleView", () => {
             this.taskPanel.cycleView();
@@ -1456,6 +1486,15 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.session.tree", () => this.showTreeSelector());
         this.defaultEditor.onAction("app.session.fork", () => this.showUserMessageSelector());
         this.defaultEditor.onAction("app.session.resume", () => this.showSessionSelector());
+        this.defaultEditor.onAction("app.session.changeDirectory", () => {
+            // Prefill rather than act: a directory change needs a target, and the
+            // editor's own path completion is already the best way to name one.
+            this.editor.setText("/cd ");
+            this.ui.requestRender();
+        });
+        this.defaultEditor.onAction("app.settings.open", () => this.showSettingsSelector());
+        this.defaultEditor.onAction("app.hotkeys.open", () => this.commandExecutor.handleHotkeys());
+        this.defaultEditor.onAction("app.mode.cycle", () => void this.cycleAgentMode());
         this.defaultEditor.onChange = (text) => {
             const wasBashMode = this.isBashMode;
             this.isBashMode = text.trimStart().startsWith("!");
@@ -1644,6 +1683,13 @@ export class InteractiveMode {
                     clearEditor();
                 },
             },
+            "/cd": {
+                withArgs: true,
+                run: async (text) => {
+                    clearEditor();
+                    await this.commandExecutor.handleChangeDirectory(text);
+                },
+            },
             "/quit": {
                 run: async () => {
                     clearEditor();
@@ -1742,6 +1788,10 @@ export class InteractiveMode {
             if (this.chimePendingRetry || this.session.isStreaming || this.session.isCompacting) {
                 return;
             }
+            // The last chain of a turn has nothing after it to close it, so it
+            // settles here. A turn that did not end cleanly leaves its chain in the
+            // running rendering plus a marker rather than claiming an outcome.
+            this.closeOpenChain(this.turnStopReason === "stop" ? "done" : "interrupted");
             this.showTurnCost();
             this.settleDanglingPlanItems();
             this.chime?.onTurnComplete({ aborted: this.turnStopReason === "aborted" });
@@ -1893,6 +1943,7 @@ export class InteractiveMode {
                 else if (event.message.role === "assistant") {
                     this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
                     this.streamingMessage = event.message;
+                    this.sawTextInCurrentMessage = false;
                     this.chatContainer.addChild(this.streamingComponent);
                     this.streamingComponent.updateContent(this.streamingMessage);
                     this.ui.requestRender();
@@ -1902,16 +1953,25 @@ export class InteractiveMode {
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
                     this.scheduleStreamingRender();
+                    // The agent speaking ends the run its previous calls formed. Tool
+                    // calls later in this same message open a fresh chain.
+                    if (!this.sawTextInCurrentMessage) {
+                        const spoke = this.streamingMessage.content.some((content) => content.type === "text" && content.text.trim() !== "");
+                        if (spoke) {
+                            this.sawTextInCurrentMessage = true;
+                            this.closeOpenChain("done");
+                        }
+                    }
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
                             if (!this.pendingTools.has(content.id)) {
                                 const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
                                     showImages: this.settingsManager.getShowImages(),
                                     imageWidthCells: this.settingsManager.getImageWidthCells(),
-                                    displayLevel: this.toolOutputDisplay,
+                                    view: this.toolOutputView,
                                 }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
                                 component.setExpanded(this.toolOutputExpanded);
-                                this.chatContainer.addChild(component);
+                                this.attachToolBlock(component);
                                 this.pendingTools.set(content.id, component);
                             }
                             else {
@@ -1975,10 +2035,10 @@ export class InteractiveMode {
                     component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
                         showImages: this.settingsManager.getShowImages(),
                         imageWidthCells: this.settingsManager.getImageWidthCells(),
-                        displayLevel: this.toolOutputDisplay,
+                        view: this.toolOutputView,
                     }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.sessionManager.getCwd());
                     component.setExpanded(this.toolOutputExpanded);
-                    this.chatContainer.addChild(component);
+                    this.attachToolBlock(component);
                     this.pendingTools.set(event.toolCallId, component);
                 }
                 component.markExecutionStarted();
@@ -2255,9 +2315,18 @@ export class InteractiveMode {
             this.footer.invalidate();
             this.updateEditorBorderColor();
         }
+        let lastAssistantStopReason;
         for (const message of sessionContext.messages) {
             // Assistant messages need special handling for tool calls
             if (message.role === "assistant") {
+                // Same boundary the live path uses: the agent speaking ends the run
+                // its previous calls formed. Rebuilding history has to reproduce it,
+                // or a resumed session would show one chain where it lived through
+                // several.
+                const spoke = message.content.some((content) => content.type === "text" && content.text.trim() !== "");
+                if (spoke)
+                    this.closeOpenChain("done");
+                lastAssistantStopReason = message.stopReason;
                 this.addMessageToChat(message);
                 // Render tool call components
                 for (const content of message.content) {
@@ -2265,10 +2334,10 @@ export class InteractiveMode {
                         const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
                             showImages: this.settingsManager.getShowImages(),
                             imageWidthCells: this.settingsManager.getImageWidthCells(),
-                            displayLevel: this.toolOutputDisplay,
+                            view: this.toolOutputView,
                         }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
                         component.setExpanded(this.toolOutputExpanded);
-                        this.chatContainer.addChild(component);
+                        this.attachToolBlock(component);
                         if (message.stopReason === "aborted" || message.stopReason === "error") {
                             let errorMessage;
                             if (message.stopReason === "aborted") {
@@ -2302,6 +2371,13 @@ export class InteractiveMode {
                 this.addMessageToChat(message, options);
             }
         }
+        // History has no live state: a chain left open at the end of the rebuild is
+        // finished, and how the last assistant message ended says whether it
+        // finished cleanly. Tool calls still awaiting results are the exception —
+        // this is a resumed run in flight, so its chain stays open for them.
+        if (renderedPendingTools.size === 0) {
+            this.closeOpenChain(lastAssistantStopReason === "stop" ? "done" : "interrupted");
+        }
         for (const [toolCallId, component] of renderedPendingTools) {
             this.pendingTools.set(toolCallId, component);
         }
@@ -2528,9 +2604,124 @@ export class InteractiveMode {
             this.showStatus(`Thinking level: ${newLevel}`);
         }
     }
+    /**
+     * Put a tool block into the transcript, extending the open chain or starting
+     * one. Every path that renders a tool call comes through here — live
+     * streaming, execution start, and rebuilding history — so a chain cannot be
+     * assembled correctly in one place and forgotten in another.
+     */
+    attachToolBlock(block) {
+        if (!this.openChain || !this.openChain.isOpen) {
+            this.openChain = new ToolChainComponent(this.toolOutputView);
+            this.chatContainer.addChild(this.openChain);
+        }
+        this.openChain.add(block);
+    }
+    /**
+     * Settle the open chain.
+     *
+     * Called when the agent speaks (the run it was doing is over, whatever comes
+     * next is a new one) and when the turn settles. Closing on the agent's next
+     * words rather than only at turn end is what keeps the flip cheap: the line
+     * is still at the bottom of the screen, so the TUI rewrites it in place
+     * instead of taking the full-redraw path that clears terminal scrollback.
+     */
+    closeOpenChain(outcome) {
+        if (!this.openChain)
+            return;
+        if (this.openChain.isEmpty) {
+            this.chatContainer.removeChild(this.openChain);
+        }
+        else {
+            this.openChain.close(outcome);
+        }
+        this.openChain = undefined;
+        this.ui.requestRender();
+    }
+    /** Every tool block in the transcript, in order, across all chains. */
+    transcriptToolBlocks() {
+        const blocks = [];
+        for (const child of this.chatContainer.children) {
+            if (child instanceof ToolChainComponent)
+                blocks.push(...child.toolBlocks);
+            else if (child instanceof ToolExecutionComponent)
+                blocks.push(child);
+        }
+        return blocks;
+    }
+    /** Every chain in the transcript, in order. */
+    transcriptChains() {
+        return this.chatContainer.children.filter((child) => child instanceof ToolChainComponent);
+    }
     toggleToolOutputExpansion() {
         this.setToolsExpanded(!this.toolOutputExpanded);
     }
+    /**
+     * Open or close one tool block instead of all of them.
+     *
+     * `ctrl+o` is all-or-nothing, which left the ▸ caret on every glance and
+     * radar row advertising something no key could do. This is the missing half:
+     * unfold walks back from the newest block to the first one still folded,
+     * fold walks back to the most recently opened one.
+     *
+     * Working from the tail is not a shortcut, it is the only thing this view can
+     * honestly offer. The transcript is bottom-anchored and has no app-level
+     * scrolling — anything far enough up is in the terminal's own scrollback,
+     * where this process cannot put a cursor or scroll to a selection. So the
+     * key peels backwards through what is actually on screen, and each block it
+     * opens is its own marker for where you have got to.
+     */
+    stepToolOutput(direction) {
+        const wantOpen = direction === "unfold";
+        // Radar's unit is the chain: one press turns the newest summary line back
+        // into the calls it stands for. Its per-call bodies are a glance/full
+        // question, so the step stops there rather than cascading.
+        if (this.toolOutputView === "radar") {
+            const chains = this.transcriptChains();
+            for (let i = chains.length - 1; i >= 0; i--) {
+                if (chains[i].isEmpty || chains[i].isOpened === wantOpen)
+                    continue;
+                chains[i].setOpened(wantOpen);
+                this.ui.requestRender();
+                return;
+            }
+            this.showStatus(wantOpen ? "No collapsed chains below this point" : "No open chains below this point");
+            return;
+        }
+        const blocks = this.transcriptToolBlocks();
+        for (let i = blocks.length - 1; i >= 0; i--) {
+            const block = blocks[i];
+            if (block.isRevealed() === wantOpen)
+                continue;
+            block.setExpanded(wantOpen);
+            this.ui.requestRender();
+            return;
+        }
+        this.showStatus(wantOpen ? "No folded tool output below this point" : "No unfolded tool output below this point");
+    }
+    /**
+     * Move the view dial one stop and report where it landed.
+     *
+     * The dial is the persistent decision ("how much do I ever want to see"),
+     * which is why it saves; `app.tools.expand` stays the momentary one ("open
+     * what is in front of me"), which is why it does not.
+     */
+    cycleToolOutputView(direction) {
+        const next = cycleToolOutputView(this.toolOutputView, direction);
+        this.applyToolOutputView(next);
+    }
+    applyToolOutputView(view) {
+        this.toolOutputView = view;
+        this.settingsManager.setToolOutputView(view);
+        this.footer.setToolOutputView(view);
+        for (const child of this.chatContainer.children) {
+            if (child instanceof ToolChainComponent)
+                child.setView(view);
+            else if (child instanceof ToolExecutionComponent)
+                child.setView(view);
+        }
+        this.ui.requestRender();
+    }
     setToolsExpanded(expanded) {
         this.toolOutputExpanded = expanded;
         const activeHeader = this.chrome.customHeader ?? this.builtInHeader;
@@ -2544,6 +2735,33 @@ export class InteractiveMode {
         }
         this.ui.requestRender();
     }
+    /**
+     * Step the agent mode one along (ask → plan → build → debug → ask).
+     *
+     * Mode is the product's central guardrail and sits first in the footer, yet
+     * it was reachable only by typing `/mode <name>`. The list comes from the
+     * mode command's own argument completions rather than a copy kept here, so
+     * a project that adds a mode gets it in the rotation for free; if the command
+     * is missing (a `--light` run strips the extension), the key says so instead
+     * of guessing.
+     */
+    async cycleAgentMode() {
+        const command = this.session.extensionRunner.getCommand("mode");
+        if (!command) {
+            this.showWarning("Modes are not available in this session");
+            return;
+        }
+        const completions = (await command.getArgumentCompletions?.("")) ?? [];
+        const modes = completions.map((item) => item.value);
+        if (modes.length === 0) {
+            this.showWarning("No modes are configured");
+            return;
+        }
+        const current = this.footerDataProvider.getActiveMode();
+        const index = modes.indexOf(current);
+        const next = modes[(index + 1) % modes.length];
+        await this.session.prompt(`/mode ${next}`);
+    }
     toggleThinkingBlockVisibility() {
         this.hideThinkingBlock = !this.hideThinkingBlock;
         this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
@@ -2742,8 +2960,12 @@ export class InteractiveMode {
                 autoCompact: this.session.autoCompactionEnabled,
                 tools: toolToggles,
                 toolGroups,
+                // Resolved fresh on every open, never downloaded: a binary that
+                // arrived since the last open (a startup fetch, a `brew install`)
+                // shows as present without a restart.
+                externalTools: describeExternalTools(),
                 flags,
-                toolOutputDisplay: this.toolOutputDisplay,
+                toolOutputView: this.toolOutputView,
                 toolOutputMaxBytes: this.settingsManager.getToolOutputMaxBytes(),
                 toolOutputMaxLines: this.settingsManager.getToolOutputMaxLines(),
                 contextGc: this.settingsManager.getContextGcEnabled(),
@@ -2843,15 +3065,8 @@ export class InteractiveMode {
                             break;
                     }
                 },
-                onToolOutputDisplayChange: (level) => {
-                    this.toolOutputDisplay = level;
-                    this.settingsManager.setToolOutputDisplay(level);
-                    for (const child of this.chatContainer.children) {
-                        if (child instanceof ToolExecutionComponent) {
-                            child.setDisplayLevel(level);
-                        }
-                    }
-                    this.ui.requestRender();
+                onToolOutputViewChange: (view) => {
+                    this.applyToolOutputView(view);
                 },
                 onToolOutputMaxBytesChange: (bytes) => {
                     this.settingsManager.setToolOutputMaxBytes(bytes);