@pellux/goodvibes-tui 2.0.21 → 2.1.1

package/src/input/handler-shortcuts.ts

@@ -4,7 +4,6 @@ import type { SearchManager } from './search.ts';
 import type { HistorySearch } from './input-history.ts';
 import type { ConversationManager } from '../core/conversation';
 import type { AutocompleteEngine } from './autocomplete.ts';
-import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { KillRing } from './kill-ring.ts';
 import { wordBoundaryBack, wordBoundaryForward } from './kill-ring.ts';
@@ -17,8 +16,6 @@ type WrappedPromptInfo = {
 };
 
 export type GlobalShortcutRouteState = {
-  panelFocused: boolean;
-  panelManager: PanelManager;
   keybindingsManager: KeybindingsManager;
   prompt: string;
   cursorPos: number;
@@ -45,7 +42,6 @@ export type GlobalShortcutRouteState = {
   handleRedo: () => void;
   handlePaste: () => void;
   handleEscape: () => void;
-  cyclePanelTab: (direction: 'next' | 'prev') => void;
   killRing: KillRing;
 };
 
@@ -56,40 +52,27 @@ export function handleGlobalShortcutToken(
 ): boolean {
   if (token.type !== 'key') return false;
 
-  // Fast-path: BARE pageup/pagedown scroll the transcript. The `!token.ctrl`
-  // guard is load-bearing: Ctrl+PageUp/PageDown are the panel-tab-prev/next
-  // chords, so they must fall through to the keybinding lookup below instead of
-  // being swallowed here as a scroll.
+  // Fast-path: BARE pageup/pagedown scroll the transcript (modified ones fall
+  // through to the keybinding lookup below).
   if (token.logicalName === 'pageup' && !token.ctrl) {
-    if (state.panelFocused) return false;
     state.scroll(-Math.max(1, viewportHeight - 2));
     return true;
   }
   if (token.logicalName === 'pagedown' && !token.ctrl) {
-    if (state.panelFocused) return false;
     state.scroll(Math.max(1, viewportHeight - 2));
     return true;
   }
   // Bare escape is also not in the keybinding table.
-  if (token.logicalName === 'escape' && !state.panelFocused) {
+  if (token.logicalName === 'escape') {
     state.handleEscape();
     return true;
   }
 
-  // Bare F2 is also not in the keybinding table (hardcoded, like pageup/
-  // pagedown/escape above), it must be handled here, GLOBALLY, rather than
-  // in handlePromptKeyToken (handler-feed-routes.ts) where it used to live.
-  // That location only ever runs when the panel workspace does NOT already
-  // own focus (handlePanelFocusToken, which runs before it, swallows every
-  // unclaimed key once panelFocused is true and reports it handled). The
-  // practical effect was that F2 could OPEN+focus the Fleet panel exactly
-  // once; every subsequent press while already focused vanished silently,
-  // "F2 pressed 4x never closed the panel" (evaluator finding). Routing
-  // it here, before handlePanelFocusToken ever sees the token, gives F2 the
-  // same toggle semantics as Ctrl+O below, matching how Ctrl+P/panel-picker
-  // was already reachable regardless of panelFocused.
+  // Bare F2 opens the Agents modal (hardcoded, like pageup/pagedown/escape;
+  // F2 inside the Agents modal closes it, see input/agents-modal.ts).
   if (token.logicalName === 'f2' && !token.ctrl && !token.meta) {
-    toggleFleetPanel(state);
+    state.commandContext?.openAgents?.();
+    state.requestRender();
     return true;
   }
 
@@ -98,10 +81,9 @@ export function handleGlobalShortcutToken(
   // escape/f2, because it is not in the keybinding table and bare Tab is
   // already heavily overloaded. Arrives as the legacy xterm backtab literal
   // ('\x1b[Z') OR, under a kitty/CSI-u terminal, as tab-with-shift. Only when
-  // the composer owns focus (a focused panel keeps its own Shift+Tab, e.g. the
-  // diff panel's previous-file); modal/picker routes run earlier and swallow
-  // the token before it reaches here, so overlays keep their reverse-tab too.
-  if (!state.panelFocused && (token.logicalName === '\x1b[Z' || (token.logicalName === 'tab' && token.shift))) {
+  // the composer owns focus; modal/picker routes run earlier and swallow the
+  // token before it reaches here, so overlays keep their reverse-tab too.
+  if (token.logicalName === '\x1b[Z' || (token.logicalName === 'tab' && token.shift)) {
     cycleSessionPermissionMode(state);
     return true;
   }
@@ -133,10 +115,9 @@ export function handleGlobalShortcutToken(
       return true;
 
     case 'voice-input':
-      // Start recording, or stop the recording already running. Routed globally so
-      // the key works whether focus is on the composer or the panel workspace,
-      // dictation is not a composer-only act. Still consumed when voice input is
-      // not wired, so a stray Alt+V never lands in the prompt as text.
+      // Start recording, or stop the recording already running. Routed globally;
+      // still consumed when voice input is not wired, so a stray Alt+V never
+      // lands in the prompt as text.
       state.commandContext?.toggleVoiceInput?.();
       return true;
 
@@ -154,110 +135,17 @@ export function handleGlobalShortcutToken(
       state.commandContext?.clearScreen?.();
       return true;
 
-    case 'panel-close-all': {
-      const pm = state.panelManager;
-      for (const p of pm.getAllOpen()) pm.close(p.id);
-      pm.hide();
-      state.panelFocused = false;
-      state.requestRender();
-      return true;
-    }
-
-    case 'panel-close': {
-      const pm = state.panelManager;
-      const active = pm.getActivePanel();
-      // Give the active panel a chance to consume Ctrl+X for an
-      // in-panel action (FleetPanel session-tab detach) before it closes the
-      // panel outright, see Panel.interceptPanelClose's doc comment.
-      if (active?.interceptPanelClose?.()) {
-        // fix: a consumed Ctrl+X (the Fleet panel's session-tab detach)
-        // used to leave panelFocused untouched, so focus stayed on the panel
-        //, the evaluator's "Ctrl+X detach landed focus in the panel and a
-        // typed question became nav keys". Detach is a leave-taking action:
-        // like the ordinary close below, it hands control back to the
-        // composer rather than leaving the user stranded on the fleet tree.
-        state.panelFocused = false;
-        state.requestRender();
-        return true;
-      }
-      if (active) {
-        pm.close(active.id);
-        state.requestRender();
-      }
-      state.panelFocused = false;
-      return true;
-    }
-
     case 'command-palette':
       state.commandContext?.openCommandPalette?.();
       state.requestRender();
       return true;
 
-    case 'panel-picker':
-      state.commandContext?.openPanelPicker?.();
-      state.panelFocused = state.panelManager.isVisible() && state.panelManager.getAllOpen().length > 0;
+    case 'open-agents':
+      // Ctrl+O: the Agents modal (the same as F2).
+      state.commandContext?.openAgents?.();
       state.requestRender();
       return true;
 
-    case 'panel-focus-toggle': {
-      // Global entry point for the focus-toggle key (Ctrl+G): from the prompt
-      // it grabs focus for the panel workspace. Once the workspace already has
-      // focus we let it fall through (return false) so handlePanelFocusToken
-      // can do the top/bottom pane swap, keeping that behavior in one place.
-      if (state.panelFocused) return false;
-      const pm = state.panelManager;
-      if (pm.isVisible() && pm.getAllOpen().length > 0) {
-        state.panelFocused = true;
-        state.requestRender();
-        return true;
-      }
-      return false;
-    }
-
-    case 'panel-tab-next':
-      state.cyclePanelTab('next');
-      return true;
-
-    case 'panel-tab-prev':
-      state.cyclePanelTab('prev');
-      return true;
-
-    case 'panel-tab-1':
-    case 'panel-tab-2':
-    case 'panel-tab-3':
-    case 'panel-tab-4':
-    case 'panel-tab-5':
-    case 'panel-tab-6':
-    case 'panel-tab-7':
-    case 'panel-tab-8':
-    case 'panel-tab-9': {
-      // Alt+1..9: jump directly to the Nth workspace tab. Routed globally (like
-      // panel-tab-next/prev) so the jump works whether focus is on the prompt or
-      // the workspace; gated on visibility, matching cyclePanelTab semantics.
-      // a chord jump is "I'm going panel-driving" (focus rule 1a), the
-      // jump now also grabs keyboard focus, matching F2/Ctrl+O/Ctrl+P, so j/k
-      // land in the newly-active tab immediately instead of the composer.
-      const pm = state.panelManager;
-      if (pm.isVisible()) {
-        const index = Number(action.slice('panel-tab-'.length)) - 1;
-        pm.activateWorkspaceIndex(index);
-        pm.focusPanels();
-        state.panelFocused = true;
-        state.requestRender();
-      }
-      return true;
-    }
-
-    case 'panel-ops': {
-      // Ctrl+O: TOGGLE the Fleet panel (same semantics as F2 above; see
-      // toggleFleetPanel's doc comment). The former Ops Control panel was
-      // retired to an 'ops-control' -> 'fleet' alias; rather than route
-      // through the now-aliased openOpsPanel callback (which opens without
-      // transferring focus), this operates on 'fleet' directly.
-      toggleFleetPanel(state);
-      return true;
-    }
-
     case 'history-search':
       state.historySearch.open(state.prompt);
       state.requestRender();
@@ -433,17 +321,6 @@ export function handleGlobalShortcutToken(
   }
 }
 
-/**
- * toggleFleetPanel, the shared F2 / Ctrl+O TOGGLE (item 2): if the
- * Fleet panel is open AND the panel workspace currently owns keyboard focus
- * with Fleet as the active tab, the chord CLOSES it and returns focus to the
- * composer; if Fleet is open but not the focused/active tab, the chord brings
- * it to front and focuses it; if Fleet isn't open at all, the chord opens and
- * focuses it. Uses `state.panelFocused` (not a panelManager query) for the
- * focus check, consistent with every other case in this file and with what
- * the mocked PanelManager test doubles in global-shortcuts.test.ts actually
- * implement.
- */
 /**
  * Cycle the session permission mode (Shift+Tab). The change goes through the
  * SDK config surface, configManager.set('permissions.mode', ...), which is
@@ -461,18 +338,3 @@ function cycleSessionPermissionMode(state: GlobalShortcutRouteState): void {
   state.commandContext?.print(`[Permissions] Mode: ${permissionModeLabel(next)}`);
   state.requestRender();
 }
-
-function toggleFleetPanel(state: GlobalShortcutRouteState): void {
-  const pm = state.panelManager;
-  const fleetOpen = pm.getAllOpen().some((p) => p.id === 'fleet');
-  const fleetIsFocusedActive = fleetOpen && state.panelFocused && pm.getActivePanel()?.id === 'fleet';
-  if (fleetIsFocusedActive) {
-    pm.close('fleet');
-    state.panelFocused = false;
-  } else {
-    pm.open('fleet');
-    pm.focusPanels();
-    state.panelFocused = true;
-  }
-  state.requestRender();
-}

package/src/input/handler-types.ts

@@ -97,8 +97,7 @@ export interface InputHandlerLike {
   // ── Modal state ───────────────────────────────────────────────────────────
   commandMode: boolean;
   modalStack: string[];
-  modalReturnFocus: 'prompt' | 'panel' | 'indicator';
-  panelFocused: boolean;
+  modalReturnFocus: 'prompt' | 'indicator';
   indicatorFocused: boolean;
   helpOverlayActive: boolean;
   helpScrollOffset: number;
@@ -118,6 +117,9 @@ export interface InputHandlerLike {
   modelPicker: ModelPickerModal;
   filePicker: FilePickerModal;
   blockActionsMenu: BlockActionsMenu;
+  surfaceModals: import('./surface-modal-host.ts').SurfaceModalHost;
+  sessionView: import('./handler-session-view-route.ts').SessionViewControls | null;
+  transcriptScroll: import('./handler-modal-stack.ts').TranscriptScrollControls | null;
   selectionModal: SelectionModal;
 
   // ── Onboarding ────────────────────────────────────────────────────────────

package/src/input/handler-ui-state.ts

@@ -1,6 +1,8 @@
 import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
 import type { InfiniteBuffer } from '@pellux/goodvibes-terminal-shell';
 import type { SearchManager } from './search.ts';
+import type { OverlayFilter, OverlayFilters } from './overlay-filter.ts';
+import { isTextBackspace } from './delete-key-policy.ts';
 import type { HistorySearch } from './input-history.ts';
 import type { ConversationManager } from '../core/conversation';
 import type {
@@ -289,36 +291,64 @@ type OverlayRouteState = {
   helpScrollOffset: number;
   shortcutsOverlayActive: boolean;
   shortcutsScrollOffset: number;
+  /** The overlays' always-live search rows (absent in minimal test states). */
+  overlayFilters?: OverlayFilters;
   requestRender: () => void;
   handleEscape: () => void;
 };
 
+/**
+ * Keys shared by the help and shortcuts overlays: ↑↓ and PgUp/PgDn scroll
+ * (never past the end the renderer recorded), printable text goes into the
+ * always-live search row (the offset returns to the top as the list
+ * narrows), Backspace edits it, Esc closes. Returns the new scroll offset.
+ */
+function routeFilteredOverlayKey(token: InputToken, offset: number, filter: OverlayFilter | undefined): number {
+  const max = filter ? filter.maxScroll : 100;
+  if (token.type === 'key') {
+    if (token.logicalName === 'up') return Math.max(0, Math.min(offset, max) - 1);
+    if (token.logicalName === 'down') return Math.min(offset + 1, max);
+    if (token.logicalName === 'pageup') return Math.max(0, Math.min(offset, max) - 10);
+    if (token.logicalName === 'pagedown') return Math.min(offset + 10, max);
+    if (filter && isTextBackspace(token.logicalName ?? '') && filter.query.length > 0) {
+      filter.query = filter.query.slice(0, -1);
+      return 0;
+    }
+    return offset;
+  }
+  if (token.type === 'text' && filter) {
+    filter.query += token.value;
+    return 0;
+  }
+  return offset;
+}
+
 export function handleOverlayToken(state: OverlayRouteState, token: InputToken): boolean {
   if (state.helpOverlayActive) {
-    if (token.type === 'key') {
-      if (token.logicalName === 'escape') {
-        state.handleEscape();
-        return true;
-      }
-      if (token.logicalName === 'up') state.helpScrollOffset = Math.max(0, state.helpScrollOffset - 1);
-      else if (token.logicalName === 'down') state.helpScrollOffset = Math.min(state.helpScrollOffset + 1, 100);
-    } else if (token.type === 'text' && token.value === '?') {
+    const filter = state.overlayFilters?.help;
+    if (token.type === 'key' && token.logicalName === 'escape') {
+      state.handleEscape();
+      return true;
+    }
+    // '?' toggles help closed, but only while the query is empty; once
+    // something is typed, '?' is just another character.
+    if (token.type === 'text' && token.value === '?' && (!filter || filter.query.length === 0)) {
       state.helpOverlayActive = false;
       state.helpScrollOffset = 0;
+      filter?.clear();
+    } else {
+      state.helpScrollOffset = routeFilteredOverlayKey(token, state.helpScrollOffset, filter);
     }
     state.requestRender();
     return true;
   }
 
   if (state.shortcutsOverlayActive) {
-    if (token.type === 'key') {
-      if (token.logicalName === 'escape') {
-        state.handleEscape();
-        return true;
-      }
-      if (token.logicalName === 'up') state.shortcutsScrollOffset = Math.max(0, state.shortcutsScrollOffset - 1);
-      else if (token.logicalName === 'down') state.shortcutsScrollOffset = Math.min(state.shortcutsScrollOffset + 1, 50);
+    if (token.type === 'key' && token.logicalName === 'escape') {
+      state.handleEscape();
+      return true;
     }
+    state.shortcutsScrollOffset = routeFilteredOverlayKey(token, state.shortcutsScrollOffset, state.overlayFilters?.shortcuts);
     state.requestRender();
     return true;
   }

package/src/input/handler-work-tree-route.ts

@@ -0,0 +1,123 @@
+/**
+ * handler-work-tree-route.ts, the keyboard inside the conversation work tree.
+ *
+ * The `focus-work-tree` binding (Alt+Up, Ctrl+Up) moves the keyboard from the
+ * composer onto the work tree's rows. There:
+ *
+ *   ↑ ↓     move between beads (and turn headers and agent lanes)
+ *   ← →     fold / unfold
+ *   Enter   open a bead's body; on an agent lane open that agent full
+ *           screen; on a ▶ bead open that background process's output
+ *   y       copy the focused row's content
+ *   Esc     back to typing (never stops or cancels anything)
+ *
+ * Any other key hands the keyboard back to the composer and is typed there,
+ * so starting to type never needs an Esc first.
+ */
+
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core';
+import type { ConversationManager } from '../core/conversation.ts';
+import { handleBlockCopy } from './handler-content-actions.ts';
+
+export interface WorkTreeRouteState {
+  readonly conversationManager: ConversationManager | null;
+  /** The token matches the `focus-work-tree` binding. */
+  readonly enterMatch: boolean;
+  /** The last visible transcript line (where focus lands on entry). */
+  readonly anchorLine: number;
+  readonly scrollTop: number;
+  readonly viewportHeight: number;
+  readonly scroll: (delta: number) => void;
+  readonly requestRender: () => void;
+  readonly onCopied: () => void;
+  /** Open an agent full screen (Enter on its lane); false when it cannot be opened. */
+  readonly openAgent?: (agentId: string) => boolean;
+  /** Open a background process's output (Enter on its ▶ bead); false when it cannot be opened. */
+  readonly openProcess?: (processId: string) => boolean;
+}
+
+/** Scroll so the focused row (and as much of its opened body as fits) is visible. */
+function revealFocus(state: WorkTreeRouteState): void {
+  const block = state.conversationManager?.workTree.focusBlock();
+  if (!block) return;
+  const top = block.startLine;
+  const bottom = block.startLine + Math.min(Math.max(1, block.lineCount), state.viewportHeight) - 1;
+  if (top < state.scrollTop) state.scroll(top - state.scrollTop);
+  else if (bottom >= state.scrollTop + state.viewportHeight) state.scroll(bottom - (state.scrollTop + state.viewportHeight) + 1);
+}
+
+/** Returns true when the token was handled here. */
+export function handleWorkTreeToken(state: WorkTreeRouteState, token: InputToken): boolean {
+  const cm = state.conversationManager;
+  if (!cm) return false;
+  const tree = cm.workTree;
+
+  if (!tree.focused) {
+    if (token.type !== 'key' || !state.enterMatch) return false;
+    if (tree.enter(state.anchorLine)) revealFocus(state);
+    state.requestRender();
+    return true;
+  }
+
+  if (token.type === 'text') {
+    if (token.value === 'y') {
+      const block = tree.focusBlock();
+      if (block) handleBlockCopy(cm, () => block.startLine, state.requestRender, state.onCopied);
+      return true;
+    }
+    // Typing goes back to the composer.
+    tree.leave();
+    state.requestRender();
+    return false;
+  }
+  if (token.type !== 'key') return false;
+
+  if (!token.ctrl && !token.meta) {
+    switch (token.logicalName) {
+      case 'escape':
+        tree.leave();
+        state.requestRender();
+        return true;
+      case 'up':
+      case 'down':
+        tree.move(token.logicalName === 'up' ? -1 : 1);
+        revealFocus(state);
+        state.requestRender();
+        return true;
+      case 'enter': {
+        const wt = tree.focusBlock()?.workTree;
+        const opened = wt?.kind === 'lane' && wt.agentId ? state.openAgent?.(wt.agentId)
+          : wt?.kind === 'bead' && wt.processId ? state.openProcess?.(wt.processId)
+            : false;
+        if (opened) {
+          tree.leave();
+          state.requestRender();
+          return true;
+        }
+        tree.act('activate');
+        revealFocus(state);
+        state.requestRender();
+        return true;
+      }
+      case 'left':
+      case 'right':
+        tree.act(token.logicalName === 'left' ? 'fold' : 'unfold');
+        revealFocus(state);
+        state.requestRender();
+        return true;
+      case 'y':
+        {
+          const block = tree.focusBlock();
+          if (block) handleBlockCopy(cm, () => block.startLine, state.requestRender, state.onCopied);
+        }
+        return true;
+      default:
+        break;
+    }
+  }
+  if (state.enterMatch) return true;
+  // Anything else goes back to the composer (and is handled there).
+  tree.leave();
+  state.requestRender();
+  return false;
+}