@visorcraft/idlehands 1.1.6 → 1.1.8

package/dist/tui/controller.js

@@ -2,6 +2,7 @@ import { createSession } from "../agent.js";
 import { decodeRawInput, resolveAction } from "./keymap.js";
 import { createInitialTuiState, reduceTuiState } from "./state.js";
 import { renderTui, setRenderTheme } from "./render.js";
+import { calculateLayout } from "./layout.js";
 import { enterFullScreen, leaveFullScreen } from "./screen.js";
 import { saveSessionFile, lastSessionPath, projectSessionPath } from "../cli/session-state.js";
 import { loadBranches, executeBranchSelect } from "./branch-picker.js";
@@ -9,8 +10,15 @@ import { ensureCommandsRegistered, allCommandNames, runShellCommand, runSlashCom
 import { projectDir } from "../utils.js";
 import { formatWatchdogCancelMessage, resolveWatchdogSettings } from "../watchdog.js";
 import { TuiConfirmProvider } from "./confirm.js";
-/** Commands that need special TUI handling instead of the registry adapter. */
-const TUI_OVERRIDES = new Set(['/quit', '/exit', '/clear', '/help', '/branches']);
+import { splitTokens } from '../cli/command-utils.js';
+import { TurnProgressController } from '../progress/turn-progress.js';
+import { chainAgentHooks } from '../progress/agent-hooks.js';
+import { formatToolCallSummary } from '../progress/tool-summary.js';
+import { ToolTailBuffer } from '../progress/tool-tail.js';
+import { ProgressMessageRenderer } from '../progress/progress-message-renderer.js';
+import { renderTuiLines } from '../progress/serialize-tui.js';
+const THEME_OPTIONS = ['default', 'dark', 'light', 'minimal', 'hacker'];
+const APPROVAL_OPTIONS = ['plan', 'default', 'auto-edit', 'yolo'];
 export class TuiController {
     config;
     state = createInitialTuiState();
@@ -54,7 +62,7 @@ export class TuiController {
             this.tabIndex = -1;
             const names = allCommandNames();
             // Add TUI-specific commands that aren't in the registry
-            const extra = ['/quit', '/exit', '/clear', '/help'];
+            const extra = ['/quit', '/exit', '/clear', '/help', '/branches', '/steps', '/settings', '/hooks'];
             const all = [...new Set([...names, ...extra])];
             this.tabCandidates = all.filter(n => n.toLowerCase().startsWith(prefix)).sort();
         }
@@ -99,6 +107,214 @@ export class TuiController {
                 this.dispatch({ type: 'ALERT_PUSH', id: `br_${Date.now()}`, level: result.level ?? 'error', text: result.message });
         }
     }
+    transcriptLineStarts() {
+        const starts = [];
+        let line = 0;
+        for (const item of this.state.transcript) {
+            starts.push(line);
+            const chunks = String(item.text ?? '').split('\n');
+            line += Math.max(1, chunks.length);
+        }
+        return starts;
+    }
+    buildStepNavigatorItems(query) {
+        const q = (query ?? '').trim().toLowerCase();
+        const starts = this.transcriptLineStarts();
+        const items = this.state.transcript.map((item, idx) => {
+            const preview = String(item.text ?? '').split(/\r?\n/)[0]?.trim() ?? '';
+            return {
+                id: item.id,
+                ts: item.ts,
+                role: item.role,
+                preview,
+                lineStart: starts[idx] ?? 0,
+            };
+        });
+        if (!q)
+            return items;
+        return items.filter((it) => (`${it.role} ${it.preview}`).toLowerCase().includes(q));
+    }
+    openStepNavigator(query = '') {
+        const items = this.buildStepNavigatorItems(query);
+        this.dispatch({ type: 'STEP_NAV_OPEN', items, query });
+    }
+    stepNavigatorQueryAppend(text) {
+        const current = this.state.stepNavigator?.query ?? '';
+        const next = `${current}${text}`;
+        this.openStepNavigator(next);
+    }
+    stepNavigatorQueryBackspace() {
+        const current = this.state.stepNavigator?.query ?? '';
+        const next = current.slice(0, -1);
+        this.openStepNavigator(next);
+    }
+    jumpToStepSelection() {
+        const nav = this.state.stepNavigator;
+        if (!nav?.items.length) {
+            this.dispatch({ type: 'STEP_NAV_CLOSE' });
+            return;
+        }
+        const selected = nav.items[nav.selectedIndex];
+        if (!selected) {
+            this.dispatch({ type: 'STEP_NAV_CLOSE' });
+            return;
+        }
+        const layout = calculateLayout(process.stdout.rows ?? 30, process.stdout.columns ?? 120);
+        const starts = this.transcriptLineStarts();
+        const totalLines = starts.length
+            ? (starts[starts.length - 1] ?? 0) +
+                Math.max(1, String(this.state.transcript[this.state.transcript.length - 1]?.text ?? '').split('\n').length)
+            : 0;
+        const desiredStart = Math.max(0, Math.min(selected.lineStart, Math.max(0, totalLines - layout.transcriptRows)));
+        const scrollBack = Math.max(0, totalLines - (desiredStart + layout.transcriptRows));
+        this.dispatch({ type: 'SCROLL_SET', panel: 'transcript', value: scrollBack });
+        this.dispatch({ type: 'STEP_NAV_CLOSE' });
+        this.dispatch({ type: 'ALERT_PUSH', id: `step_${Date.now()}`, level: 'info', text: `Jumped to ${selected.role}: ${selected.preview || '(no preview)'}` });
+    }
+    buildSettingsItems() {
+        const watchdog = resolveWatchdogSettings(undefined, this.config);
+        return [
+            {
+                key: 'theme',
+                label: 'Theme',
+                value: this.config.theme || 'default',
+                hint: 'Cycle TUI themes instantly.',
+            },
+            {
+                key: 'approval',
+                label: 'Approval mode',
+                value: this.config.approval_mode || 'default',
+                hint: 'Plan/default/auto-edit/yolo for next turns.',
+            },
+            {
+                key: 'watchdog_timeout',
+                label: 'Watchdog timeout',
+                value: `${watchdog.timeoutMs} ms`,
+                hint: 'Longer timeout helps with slower models.',
+            },
+            {
+                key: 'watchdog_compactions',
+                label: 'Max compactions',
+                value: String(watchdog.maxCompactions),
+                hint: 'Retries before watchdog cancellation.',
+            },
+            {
+                key: 'watchdog_grace',
+                label: 'Grace windows',
+                value: String(watchdog.idleGraceTimeouts),
+                hint: 'Extra idle windows before first compaction.',
+            },
+            {
+                key: 'debug_abort',
+                label: 'Debug abort reason',
+                value: watchdog.debugAbortReason ? 'on' : 'off',
+                hint: 'Show raw abort reason in cancellation messages.',
+            },
+        ];
+    }
+    openSettingsMenu() {
+        this.dispatch({ type: 'SETTINGS_OPEN', items: this.buildSettingsItems() });
+    }
+    refreshSettingsMenu(selectedIndex) {
+        if (!this.state.settingsMenu)
+            return;
+        this.dispatch({ type: 'SETTINGS_UPDATE', items: this.buildSettingsItems(), selectedIndex });
+    }
+    adjustSelectedSetting(delta) {
+        const menu = this.state.settingsMenu;
+        if (!menu?.items.length)
+            return;
+        const selected = menu.items[menu.selectedIndex];
+        if (!selected)
+            return;
+        switch (selected.key) {
+            case 'theme': {
+                const current = (this.config.theme || 'default');
+                const idx = Math.max(0, THEME_OPTIONS.indexOf(current));
+                const next = THEME_OPTIONS[(idx + (delta >= 0 ? 1 : -1) + THEME_OPTIONS.length) % THEME_OPTIONS.length];
+                this.config.theme = next;
+                setRenderTheme(next);
+                break;
+            }
+            case 'approval': {
+                const current = (this.config.approval_mode || 'default');
+                const idx = Math.max(0, APPROVAL_OPTIONS.indexOf(current));
+                const next = APPROVAL_OPTIONS[(idx + (delta >= 0 ? 1 : -1) + APPROVAL_OPTIONS.length) % APPROVAL_OPTIONS.length];
+                this.config.approval_mode = next;
+                break;
+            }
+            case 'watchdog_timeout': {
+                const cur = this.config.watchdog_timeout_ms ?? 120_000;
+                const step = cur >= 180_000 ? 60_000 : 30_000;
+                this.config.watchdog_timeout_ms = Math.max(30_000, cur + (delta >= 0 ? step : -step));
+                break;
+            }
+            case 'watchdog_compactions': {
+                const cur = this.config.watchdog_max_compactions ?? 3;
+                this.config.watchdog_max_compactions = Math.max(0, cur + (delta >= 0 ? 1 : -1));
+                break;
+            }
+            case 'watchdog_grace': {
+                const cur = this.config.watchdog_idle_grace_timeouts ?? 1;
+                this.config.watchdog_idle_grace_timeouts = Math.max(0, cur + (delta >= 0 ? 1 : -1));
+                break;
+            }
+            case 'debug_abort': {
+                this.config.debug_abort_reason = !(this.config.debug_abort_reason === true);
+                break;
+            }
+            default:
+                return;
+        }
+        this.refreshSettingsMenu(menu.selectedIndex);
+    }
+    buildHookInspectorLines(mode) {
+        const manager = this.session?.hookManager;
+        if (!manager || typeof manager.getSnapshot !== 'function') {
+            return ['Hooks are unavailable for this session.'];
+        }
+        const snap = manager.getSnapshot();
+        const totalEvents = Object.values(snap.eventCounts || {}).reduce((sum, n) => sum + Number(n || 0), 0);
+        if (mode === 'errors') {
+            return snap.recentErrors?.length
+                ? snap.recentErrors.map((x) => `• ${x}`)
+                : ['No recent hook errors.'];
+        }
+        if (mode === 'slow') {
+            return snap.recentSlowHandlers?.length
+                ? snap.recentSlowHandlers.map((x) => `• ${x}`)
+                : ['No recent slow hook handlers.'];
+        }
+        if (mode === 'plugins') {
+            if (!snap.plugins?.length)
+                return ['No hook plugins loaded.'];
+            const lines = [];
+            for (const p of snap.plugins) {
+                lines.push(`• ${p.name} (${p.source})`);
+                lines.push(`  granted: ${p.grantedCapabilities.join(', ') || 'none'}`);
+                if (p.deniedCapabilities?.length)
+                    lines.push(`  denied: ${p.deniedCapabilities.join(', ')}`);
+            }
+            return lines;
+        }
+        return [
+            `Enabled: ${snap.enabled ? 'yes' : 'no'}`,
+            `Strict mode: ${snap.strict ? 'yes' : 'no'}`,
+            `Allowed capabilities: ${(snap.allowedCapabilities || []).join(', ')}`,
+            `Plugins: ${snap.plugins?.length ?? 0}`,
+            `Handlers: ${snap.handlers?.length ?? 0}`,
+            `Events observed: ${totalEvents}`,
+            `Recent errors: ${snap.recentErrors?.length ?? 0}`,
+            `Recent slow handlers: ${snap.recentSlowHandlers?.length ?? 0}`,
+        ];
+    }
+    openHooksInspector(mode = 'status') {
+        this.dispatch({
+            type: 'HOOKS_INSPECTOR_OPEN',
+            mode,
+            lines: this.buildHookInspectorLines(mode),
+        });
+    }
     /** Push a system-role transcript item and re-render. */
     pushSystemMessage(text) {
         const item = { id: `sys_${Date.now()}`, role: "system", text, ts: Date.now() };
@@ -124,7 +340,8 @@ export class TuiController {
     }
     /** Handle a slash command. Returns true if handled. */
     async handleSlashCommand(line) {
-        const head = (line.trim().split(/\s+/)[0] || "").toLowerCase();
+        const parts = splitTokens(line);
+        const head = (parts[0] || "").toLowerCase();
         if (!head.startsWith("/"))
             return false;
         ensureCommandsRegistered();
@@ -141,16 +358,37 @@ export class TuiController {
         }
         if (head === "/help") {
             const cmds = allCommandNames().join("  ");
-            this.pushSystemMessage(`Commands: ${cmds}\nShell: !<cmd> to run, !! to inject output\nTUI: /branches to browse conversation branches`);
+            this.pushSystemMessage(`Commands: ${cmds}\n` +
+                `Shell: !<cmd> to run, !! to inject output\n` +
+                `TUI: /branches [browse|checkout|merge], /steps, /settings, /hooks [status|errors|slow|plugins]\n` +
+                `Hotkeys: Ctrl+G step navigator, Ctrl+O quick settings`);
             return true;
         }
         if (head === "/branches") {
-            const parts = line.trim().split(/\s+/);
             const sub = (parts[1] || '').toLowerCase();
             const action = sub === 'checkout' ? 'checkout' : sub === 'merge' ? 'merge' : 'browse';
             await this.openBranchPicker(action);
             return true;
         }
+        if (head === '/steps') {
+            const query = line.replace(/^\/steps\s*/i, '').trim();
+            this.openStepNavigator(query);
+            return true;
+        }
+        if (head === '/settings') {
+            this.openSettingsMenu();
+            return true;
+        }
+        if (head === '/hooks') {
+            const modeRaw = line.replace(/^\/hooks\s*/i, '').trim().toLowerCase();
+            const mode = (modeRaw || 'status');
+            if (!['status', 'errors', 'slow', 'plugins'].includes(mode)) {
+                this.dispatch({ type: 'ALERT_PUSH', id: `hooks_${Date.now()}`, level: 'warn', text: 'Usage: /hooks [status|errors|slow|plugins]' });
+                return true;
+            }
+            this.openHooksInspector(mode);
+            return true;
+        }
         const result = await runSlashCommand(line, this.session, this.config, this.cleanupFn, () => this.saveTuiSessionSnapshot());
         if (!result.found) {
             this.dispatch({ type: "ALERT_PUSH", id: `cmd_${Date.now()}`, level: "warn", text: `Unknown command: ${head}` });
@@ -258,6 +496,35 @@ export class TuiController {
                 }
             }
         }, 5_000);
+        const progressRenderer = new ProgressMessageRenderer({
+            maxToolLines: 6,
+            maxTailLines: 4,
+            maxAssistantChars: 800,
+        });
+        const tails = new ToolTailBuffer({ maxChars: 4096, maxLines: 4 });
+        let activeToolId = null;
+        let streamedSoFar = '';
+        const flushStatus = (snap) => {
+            const tail = activeToolId ? tails.get(activeToolId) : null;
+            const doc = progressRenderer.render({
+                statusLine: snap.statusLine,
+                toolLines: snap.toolLines,
+                toolTail: tail ? { name: tail.name, stream: tail.stream, lines: tail.lines } : null,
+                assistantMarkdown: streamedSoFar,
+            });
+            const lines = renderTuiLines(doc, { maxLines: 8 });
+            const status = lines.find((l) => l.trim().length > 0) ?? '';
+            this.dispatch({ type: 'STATUS_SET', text: status });
+        };
+        const progress = new TurnProgressController((snap) => {
+            flushStatus(snap);
+        }, {
+            heartbeatMs: 1000,
+            bucketMs: 5000,
+            maxToolLines: 6,
+            toolCallSummary: (c) => formatToolCallSummary({ name: c.name, args: c.args }),
+        });
+        progress.start();
         try {
             let askComplete = false;
             let isRetryAfterCompaction = false;
@@ -267,36 +534,59 @@ export class TuiController {
                 const askText = isRetryAfterCompaction
                     ? 'Continue working on the task from where you left off. Context was compacted to free memory — do NOT restart from the beginning.'
                     : trimmed;
+                const uiHooks = {
+                    signal: attemptController.signal,
+                    onToken: (t) => {
+                        this.lastProgressAt = Date.now();
+                        watchdogGraceUsed = 0;
+                        streamedSoFar += t;
+                        this.dispatch({ type: 'AGENT_STREAM_TOKEN', id, token: t });
+                    },
+                    onToolCall: (c) => {
+                        this.lastProgressAt = Date.now();
+                        watchdogGraceUsed = 0;
+                        activeToolId = c.id;
+                        tails.reset(c.id, c.name);
+                        this.dispatch({
+                            type: 'TOOL_START',
+                            id: c.id,
+                            name: c.name,
+                            detail: formatToolCallSummary({ name: c.name, args: c.args }),
+                        });
+                    },
+                    onToolStream: (ev) => {
+                        if (!activeToolId || ev.id !== activeToolId)
+                            return;
+                        const tailSnap = tails.push(ev);
+                        const last = tailSnap?.lines?.[tailSnap.lines.length - 1];
+                        if (last)
+                            this.dispatch({ type: 'TOOL_TAIL', id: ev.id, tail: last });
+                        flushStatus(progress.snapshot('manual'));
+                    },
+                    onToolResult: (r) => {
+                        this.lastProgressAt = Date.now();
+                        watchdogGraceUsed = 0;
+                        if (activeToolId === r.id) {
+                            activeToolId = null;
+                            tails.clear(r.id);
+                        }
+                        this.dispatch({ type: r.success ? 'TOOL_END' : 'TOOL_ERROR', id: r.id, name: r.name, detail: r.summary });
+                    },
+                    onTurnEnd: () => {
+                        this.lastProgressAt = Date.now();
+                        watchdogGraceUsed = 0;
+                    },
+                };
+                const hooks = chainAgentHooks(uiHooks, progress.hooks);
                 try {
-                    await this.session.ask(askText, {
-                        signal: attemptController.signal,
-                        onToken: (t) => {
-                            this.lastProgressAt = Date.now();
-                            watchdogGraceUsed = 0;
-                            this.dispatch({ type: "AGENT_STREAM_TOKEN", id, token: t });
-                        },
-                        onToolCall: (c) => {
-                            this.lastProgressAt = Date.now();
-                            watchdogGraceUsed = 0;
-                            this.dispatch({ type: "TOOL_START", id: `${c.name}-${Date.now()}`, name: c.name, detail: JSON.stringify(c.args).slice(0, 120) });
-                        },
-                        onToolResult: async (r) => {
-                            this.lastProgressAt = Date.now();
-                            watchdogGraceUsed = 0;
-                            this.dispatch({ type: r.success ? "TOOL_END" : "TOOL_ERROR", id: `${r.name}-${Date.now()}`, name: r.name, detail: r.summary });
-                        },
-                        onTurnEnd: () => {
-                            this.lastProgressAt = Date.now();
-                            watchdogGraceUsed = 0;
-                        },
-                    });
+                    await this.session.ask(askText, hooks);
                     askComplete = true;
                 }
                 catch (e) {
                     const msg = e?.message ?? String(e);
                     const isAbort = msg.includes('AbortError') || msg.toLowerCase().includes('aborted');
                     if (isAbort && watchdogCompactPending) {
-                        this.dispatch({ type: "ALERT_PUSH", id: `compact_${Date.now()}`, level: "info", text: `Context too large — compacting and retrying (attempt ${this.watchdogCompactAttempts}/${maxWatchdogCompacts})...` });
+                        this.dispatch({ type: 'ALERT_PUSH', id: `compact_${Date.now()}`, level: 'info', text: `Context too large — compacting and retrying (attempt ${this.watchdogCompactAttempts}/${maxWatchdogCompacts})...` });
                         while (watchdogCompactPending) {
                             await new Promise((r) => setTimeout(r, 500));
                         }
@@ -311,17 +601,19 @@ export class TuiController {
                             debugAbortReason,
                             abortReason: msg,
                         });
-                        this.dispatch({ type: "ALERT_PUSH", id: `err_${Date.now()}`, level: "error", text });
+                        this.dispatch({ type: 'ALERT_PUSH', id: `err_${Date.now()}`, level: 'error', text });
                     }
                     else {
-                        this.dispatch({ type: "ALERT_PUSH", id: `err_${Date.now()}`, level: "error", text: msg });
+                        this.dispatch({ type: 'ALERT_PUSH', id: `err_${Date.now()}`, level: 'error', text: msg });
                     }
                 }
             }
         }
         finally {
+            progress.stop();
+            this.dispatch({ type: 'STATUS_CLEAR' });
             clearInterval(watchdog);
-            this.dispatch({ type: "AGENT_STREAM_DONE", id });
+            this.dispatch({ type: 'AGENT_STREAM_DONE', id });
             this.inFlight = false;
             this.aborter = null;
         }
@@ -345,7 +637,7 @@ export class TuiController {
             type: "ALERT_PUSH",
             id: `info_${Date.now()}`,
             level: "info",
-            text: "Input policy: Enter=send, Ctrl+J/Alt+Enter=newline, Up/Down=history.",
+            text: "Input: Enter=send, Ctrl+J/Alt+Enter=newline, Up/Down=history, Ctrl+G=steps, Ctrl+O=settings, /hooks inspector.",
         });
         const onSigwinch = () => {
             renderTui(this.state);
@@ -406,6 +698,90 @@ export class TuiController {
                     }
                     continue; // swallow all other input during picker
                 }
+                // Step navigator: type to filter, arrows to select, Enter to jump.
+                if (this.state.stepNavigator) {
+                    const nAction = resolveAction(key);
+                    if (key.startsWith('text:')) {
+                        const ch = key.slice(5);
+                        if (ch === 'q' && !this.state.stepNavigator.query) {
+                            this.dispatch({ type: 'STEP_NAV_CLOSE' });
+                        }
+                        else {
+                            this.stepNavigatorQueryAppend(ch);
+                        }
+                        continue;
+                    }
+                    if (nAction === 'backspace') {
+                        this.stepNavigatorQueryBackspace();
+                        continue;
+                    }
+                    if (nAction === 'history_prev' || nAction === 'cursor_left') {
+                        this.dispatch({ type: 'STEP_NAV_MOVE', delta: -1 });
+                        continue;
+                    }
+                    if (nAction === 'history_next' || nAction === 'cursor_right') {
+                        this.dispatch({ type: 'STEP_NAV_MOVE', delta: 1 });
+                        continue;
+                    }
+                    if (nAction === 'scroll_up') {
+                        this.dispatch({ type: 'STEP_NAV_MOVE', delta: -10 });
+                        continue;
+                    }
+                    if (nAction === 'scroll_down') {
+                        this.dispatch({ type: 'STEP_NAV_MOVE', delta: 10 });
+                        continue;
+                    }
+                    if (nAction === 'send') {
+                        this.jumpToStepSelection();
+                        continue;
+                    }
+                    if (nAction === 'cancel' || nAction === 'quit') {
+                        this.dispatch({ type: 'STEP_NAV_CLOSE' });
+                        continue;
+                    }
+                    continue;
+                }
+                // Settings menu: arrows/select to adjust config quickly.
+                if (this.state.settingsMenu) {
+                    const sAction = resolveAction(key);
+                    if (sAction === 'history_prev') {
+                        this.dispatch({ type: 'SETTINGS_MOVE', delta: -1 });
+                        continue;
+                    }
+                    if (sAction === 'history_next') {
+                        this.dispatch({ type: 'SETTINGS_MOVE', delta: 1 });
+                        continue;
+                    }
+                    if (sAction === 'cursor_left') {
+                        this.adjustSelectedSetting(-1);
+                        continue;
+                    }
+                    if (sAction === 'cursor_right' || sAction === 'send') {
+                        this.adjustSelectedSetting(1);
+                        continue;
+                    }
+                    if (sAction === 'cancel' || sAction === 'quit' || key === 'text:q') {
+                        this.dispatch({ type: 'SETTINGS_CLOSE' });
+                        continue;
+                    }
+                    continue;
+                }
+                if (this.state.hooksInspector) {
+                    const hAction = resolveAction(key);
+                    if (hAction === 'history_prev' || hAction === 'scroll_up') {
+                        this.dispatch({ type: 'HOOKS_INSPECTOR_MOVE', delta: -1 });
+                        continue;
+                    }
+                    if (hAction === 'history_next' || hAction === 'scroll_down') {
+                        this.dispatch({ type: 'HOOKS_INSPECTOR_MOVE', delta: 1 });
+                        continue;
+                    }
+                    if (hAction === 'cancel' || hAction === 'quit' || key === 'text:q' || hAction === 'send') {
+                        this.dispatch({ type: 'HOOKS_INSPECTOR_CLOSE' });
+                        continue;
+                    }
+                    continue;
+                }
                 if (key.startsWith("text:")) {
                     this.resetTab();
                     this.dispatch({ type: "USER_INPUT_INSERT", text: key.slice(5) });
@@ -421,6 +797,14 @@ export class TuiController {
                 }
                 // Any non-tab action resets tab cycling
                 this.resetTab();
+                if (action === 'open_step_navigator') {
+                    this.openStepNavigator();
+                    continue;
+                }
+                if (action === 'open_settings') {
+                    this.openSettingsMenu();
+                    continue;
+                }
                 if (action === "quit") {
                     void cleanup();
                     continue;