@kolisachint/hoocode-agent 0.5.55 → 0.5.57

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

@@ -26,11 +26,12 @@ import { formatTokens } from "../../core/format-tokens.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { measurePromptSurface, measureToolSchemaTokens } from "../../core/light.js";
 import { formatMissingSessionCwdPrompt, MissingSessionCwdError } from "../../core/session-cwd.js";
+import { cycleSessionColorSlot, sessionColorName } from "../../core/session-identity.js";
 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 { cycleToolOutputView, DEFAULT_TOOL_OUTPUT_VIEW, MAX_TOOL_OUTPUT_VIEW, } 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";
@@ -201,10 +202,21 @@ export class InteractiveMode {
     });
     // Tool execution tracking: toolCallId -> component
     pendingTools = new Map();
-    // Tool output expansion state
-    toolOutputExpanded = false;
-    // Persisted view dial (radar / glance / full). See core/tool-output-view.ts.
-    toolOutputView = "glance";
+    // Persisted view dial (radar / peek / full). See core/tool-output-view.ts.
+    toolOutputView = DEFAULT_TOOL_OUTPUT_VIEW;
+    // Where `app.tools.expand` came from, so the same key goes back there. Kept
+    // in memory only: the jump is the momentary look, the dial is the decision.
+    viewBeforeJump;
+    /**
+     * Whether everything foldable is currently open.
+     *
+     * Not a state of its own any more — it is the top of the view dial. The
+     * header, compaction and branch summaries and skill blocks follow the dial
+     * for the same reason tool bodies do: `full` means nothing is held back.
+     */
+    get toolOutputExpanded() {
+        return this.toolOutputView === MAX_TOOL_OUTPUT_VIEW;
+    }
     // The chain currently collecting tool calls, if the agent is mid-run.
     openChain;
     /** The newest tool block in the transcript; radar marks it. */
@@ -707,9 +719,8 @@ 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 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.tools.expand", "to jump to full output and back"),
+                hint("app.view.cycleForward", "to cycle tool output (radar/peek/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")] : []),
@@ -1505,11 +1516,9 @@ export class InteractiveMode {
         // Global debug handler on TUI (works regardless of focus)
         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.tools.expand", () => this.jumpToFullView());
         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();
@@ -1529,6 +1538,8 @@ export class InteractiveMode {
             this.editor.setText("/cd ");
             this.ui.requestRender();
         });
+        this.defaultEditor.onAction("app.session.color.cycleForward", () => this.cycleSessionColor("forward"));
+        this.defaultEditor.onAction("app.session.color.cycleBackward", () => this.cycleSessionColor("backward"));
         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());
@@ -2019,7 +2030,6 @@ export class InteractiveMode {
                                     imageWidthCells: this.settingsManager.getImageWidthCells(),
                                     view: this.toolOutputView,
                                 }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
-                                component.setExpanded(this.toolOutputExpanded);
                                 this.attachToolBlock(component);
                                 this.pendingTools.set(content.id, component);
                             }
@@ -2086,7 +2096,6 @@ export class InteractiveMode {
                         imageWidthCells: this.settingsManager.getImageWidthCells(),
                         view: this.toolOutputView,
                     }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.sessionManager.getCwd());
-                    component.setExpanded(this.toolOutputExpanded);
                     this.attachToolBlock(component);
                     this.pendingTools.set(event.toolCallId, component);
                 }
@@ -2385,7 +2394,6 @@ export class InteractiveMode {
                             imageWidthCells: this.settingsManager.getImageWidthCells(),
                             view: this.toolOutputView,
                         }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
-                        component.setExpanded(this.toolOutputExpanded);
                         this.attachToolBlock(component);
                         if (message.stopReason === "aborted" || message.stopReason === "error") {
                             let errorMessage;
@@ -2711,66 +2719,35 @@ export class InteractiveMode {
         }
         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.
+     * Jump to the full view, or back to where the jump started.
      *
-     * `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.
+     * The dial's top stop is the whole result with nothing trimmed, which is what
+     * "expand" always meant — so expand is not a second state layered over the
+     * dial any more, it is a jump along it. From any stop the first press lands
+     * on `full`; the next press returns to the stop you came from (`peek` if the
+     * jump started there, so the key is never a no-op).
      *
-     * 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.
+     * Only `app.view.cycleForward` writes the setting. This key deliberately does
+     * not: the dial is the decision you keep, the jump is the look you take.
      */
-    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;
-                // A chain of one is never summarised, so there is nothing for unfold to
-                // reveal; skipping it keeps the press moving to a chain that will change.
-                if (wantOpen && !chains[i].isSummarised)
-                    continue;
-                chains[i].setOpened(wantOpen);
-                this.ui.requestRender();
-                return;
-            }
-            this.showStatus(wantOpen ? "No collapsed chains below this point" : "No open chains below this point");
+    jumpToFullView() {
+        if (this.toolOutputView === MAX_TOOL_OUTPUT_VIEW) {
+            const back = this.viewBeforeJump ?? DEFAULT_TOOL_OUTPUT_VIEW;
+            this.viewBeforeJump = undefined;
+            this.applyToolOutputView(back, { persist: false });
             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");
+        this.viewBeforeJump = this.toolOutputView;
+        this.applyToolOutputView(MAX_TOOL_OUTPUT_VIEW, { persist: false });
     }
     /**
-     * Move the view dial one stop and report where it landed.
+     * Move the view dial one stop; the footer shows 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.
+     * This is the persistent decision ("how much do I ever want to see"), which
+     * is why it saves. `app.tools.expand` jumps along the same dial without
+     * saving, which is what keeps "the look I am taking now" from overwriting
+     * "the view I live in".
      */
     cycleToolOutputView(direction) {
         const next = cycleToolOutputView(this.toolOutputView, direction);
@@ -2799,10 +2776,17 @@ export class InteractiveMode {
             return "omit";
         return this.hideThinkingBlock ? "label" : "full";
     }
-    applyToolOutputView(view) {
+    applyToolOutputView(view, options = {}) {
         const previousThinking = this.thinkingDisplayForView();
+        const wasExpanded = this.toolOutputExpanded;
         this.toolOutputView = view;
-        this.settingsManager.setToolOutputView(view);
+        if (options.persist !== false) {
+            this.settingsManager.setToolOutputView(view);
+            // Anything that moves the dial deliberately — the cycle key, the
+            // settings pane — is a new home stop, so the jump has nowhere stale to
+            // return to.
+            this.viewBeforeJump = undefined;
+        }
         this.footer.setToolOutputView(view);
         const thinking = this.thinkingDisplayForView();
         for (const child of this.chatContainer.children) {
@@ -2817,10 +2801,18 @@ export class InteractiveMode {
         if (this.streamingComponent && thinking !== previousThinking) {
             this.streamingComponent.setThinkingDisplay(thinking);
         }
+        // The header and the summary blocks are not tool output, but "full" means
+        // nothing is held back, so they open and close with the dial's top stop.
+        if (this.toolOutputExpanded !== wasExpanded)
+            this.setToolsExpanded(this.toolOutputExpanded);
         this.ui.requestRender();
     }
+    /**
+     * Open or close everything that folds but is not a tool call — the header,
+     * compaction and branch summaries, skill blocks. Tool blocks and chains are
+     * not in this sweep: they take the view dial directly.
+     */
     setToolsExpanded(expanded) {
-        this.toolOutputExpanded = expanded;
         const activeHeader = this.chrome.customHeader ?? this.builtInHeader;
         if (isExpandable(activeHeader)) {
             activeHeader.setExpanded(expanded);
@@ -2859,6 +2851,22 @@ export class InteractiveMode {
         const next = modes[(index + 1) % modes.length];
         await this.session.prompt(`/mode ${next}`);
     }
+    /**
+     * Step the session chip to the next colour slot, no picker involved.
+     *
+     * The picker exists for choosing a colour; this exists for telling two
+     * terminals apart, which is a different job — you press the key until the two
+     * chips stop looking alike, and the chip repaints on each press because
+     * setSessionColor writes the slot and the session_info event refreshes the
+     * identity. The status line names the slot as well, since the point of the
+     * names is that `/color <name>` takes them.
+     */
+    cycleSessionColor(direction) {
+        const slot = cycleSessionColorSlot(this.sessionManager.getSessionColorSlot(), direction);
+        this.session.setSessionColor(slot);
+        const name = sessionColorName(slot);
+        this.showStatus(`Session color: ${name ?? slot}`);
+    }
     toggleThinkingBlockVisibility() {
         this.hideThinkingBlock = !this.hideThinkingBlock;
         this.settingsManager.setHideThinkingBlock(this.hideThinkingBlock);
@@ -3522,7 +3530,7 @@ export class InteractiveMode {
             const selector = new SessionColorSelectorComponent(this.sessionManager.getDisplayName(), originalSlot, (slot) => {
                 done();
                 this.session.setSessionColor(slot);
-                this.showStatus(`Session color set to ${slot}`);
+                this.showStatus(`Session color: ${sessionColorName(slot) ?? slot}`);
             }, () => {
                 done();
                 // Cancelling must put back the colour the session actually has,