@kolisachint/hoocode-agent 0.4.134 → 0.4.136

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

@@ -25,6 +25,7 @@ import { ensureTool } from "../../utils/tools-manager.js";
 import { checkForNewHooCodeVersion } from "../../utils/version-check.js";
 import { BashExecutionController } from "./bash-execution-controller.js";
 import { CommandExecutor } from "./command-executor.js";
+import { BELL, CompletionChime } from "./completion-chime.js";
 import { AssistantMessageComponent } from "./components/assistant-message.js";
 import { BashExecutionComponent } from "./components/bash-execution.js";
 import { BranchSummaryMessageComponent } from "./components/branch-summary-message.js";
@@ -172,6 +173,14 @@ export class InteractiveMode {
     retryLoader = undefined;
     retryCountdown = undefined;
     retryEscapeHandler;
+    // Completion chime state
+    chime;
+    // True between auto_retry_start and the next agent_start: the turn is not done,
+    // it is about to re-run, so the deferred completion check must not fire the chime.
+    chimePendingRetry = false;
+    // Whether the current turn's final assistant message was user-aborted (Ctrl+C /
+    // Esc). An aborted turn means the user is present, so no chime.
+    chimeTurnAborted = false;
     // Shutdown state
     shutdownRequested = false;
     // Extension UI state
@@ -394,6 +403,12 @@ export class InteractiveMode {
         this.taskPanel.onExitFocus = () => this.teamFocus.exitFocus();
         // Load hide thinking block setting
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+        // 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({
+            isEnabled: () => this.settingsManager.getChimeOnTurnComplete(),
+            ring: () => this.ui.terminal.write(BELL),
+        });
         // Register themes from resource loader and initialize
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
         initTheme(this.settingsManager.getTheme(), true);
@@ -1049,7 +1064,12 @@ export class InteractiveMode {
             select: (title, options, opts) => this.dialogs.showSelector(title, options, opts),
             confirm: (title, message, opts) => this.dialogs.confirm(title, message, opts),
             input: (title, placeholder, opts) => this.dialogs.showInput(title, placeholder, opts),
-            askOptions: (questions, opts) => this.dialogs.showAskOptions(questions, opts),
+            askOptions: (questions, opts) => {
+                // The agent is blocking on the user (the ask_options pane): ring now,
+                // bypassing the duration threshold — this is the "it needs you" cue.
+                this.chime?.onBlockedForInput();
+                return this.dialogs.showAskOptions(questions, opts);
+            },
             notify: (message, type) => this.showExtensionNotify(message, type),
             onTerminalInput: (handler) => this.addExtensionTerminalInputListener(handler),
             setStatus: (key, text) => this.setExtensionStatus(key, text),
@@ -1536,6 +1556,21 @@ export class InteractiveMode {
             await this.handleEvent(event);
         });
     }
+    /**
+     * Deferred completion chime. Called from the agent_end handler, it waits one
+     * tick so the streaming flag settles and any retry has had a chance to arm, then
+     * rings only when the session is genuinely idle (not streaming, not compacting)
+     * and no retry is pending. The chime itself enforces the enable/threshold/debounce
+     * rules; here we only decide whether the turn has truly ended.
+     */
+    maybeChimeOnIdle() {
+        setTimeout(() => {
+            if (this.chimePendingRetry || this.session.isStreaming || this.session.isCompacting) {
+                return;
+            }
+            this.chime?.onTurnComplete({ aborted: this.chimeTurnAborted });
+        }, 0);
+    }
     async handleEvent(event) {
         if (!this.isInitialized) {
             await this.init();
@@ -1544,6 +1579,10 @@ export class InteractiveMode {
         switch (event.type) {
             case "agent_start":
                 this.pendingTools.clear();
+                // A (possibly retried) turn is (re)starting: anchor its duration on the
+                // first start and clear the pending-retry gate now that it has resumed.
+                this.chime?.onTurnStart();
+                this.chimePendingRetry = false;
                 if (this.settingsManager.getShowTerminalProgress()) {
                     this.ui.terminal.setProgress(true);
                 }
@@ -1594,6 +1633,7 @@ export class InteractiveMode {
                     // glanceable for the whole turn. Active tasks are kept: a follow-up/steer
                     // message can arrive while a subagent is still running.
                     taskStore.reset();
+                    this.chimeTurnAborted = false;
                     this.addMessageToChat(event.message);
                     this.messageQueue.updatePendingMessagesDisplay();
                     this.ui.requestRender();
@@ -1635,6 +1675,11 @@ export class InteractiveMode {
             case "message_end":
                 if (event.message.role === "user")
                     break;
+                if (event.message.role === "assistant") {
+                    // Remember whether the turn's latest assistant message was user-aborted,
+                    // so the completion chime stays silent when the user is clearly present.
+                    this.chimeTurnAborted = event.message.stopReason === "aborted";
+                }
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
                     let errorMessage;
@@ -1720,6 +1765,12 @@ export class InteractiveMode {
                 }
                 this.pendingTools.clear();
                 await this.checkShutdownRequested();
+                // agent_end fires before the streaming flag clears and before the retry
+                // decision is made (both happen after this listener returns), so defer a
+                // tick and re-check: only chime once the session is genuinely idle and no
+                // retry is pending — otherwise a retried or auto-continued turn would ring
+                // a premature "it's done".
+                this.maybeChimeOnIdle();
                 this.ui.requestRender();
                 break;
             case "compaction_start": {
@@ -1782,6 +1833,9 @@ export class InteractiveMode {
                 break;
             }
             case "auto_retry_start": {
+                // The turn is not done — it will re-run after a backoff (during which the
+                // session reads as idle). Gate the deferred completion chime until then.
+                this.chimePendingRetry = true;
                 // Set up escape to abort retry
                 this.retryEscapeHandler = this.defaultEditor.onEscape;
                 this.defaultEditor.onEscape = () => {