@pellux/goodvibes-tui 0.18.20 → 0.19.0

package/src/input/feed-context-factory.ts

@@ -0,0 +1,236 @@
+/**
+ * feed-context-factory.ts — Construction and mutable-field sync for InputFeedContext.
+ *
+ * Extracted from handler.ts (Wave 4α review, 0.18.23) to keep handler.ts under the
+ * 800-line architecture cap.
+ *
+ * Two exported functions:
+ *   - `buildInitialFeedContext` — assembles the long-lived InputFeedContext from
+ *     pre-built field groups. Called once at InputHandler construction time.
+ *   - `syncFeedContextMutableFields` — copies mutable scalar fields into the
+ *     already-allocated context before each feed() dispatch.
+ */
+import type { InputFeedContext } from './handler-feed.ts';
+import type { SelectionManager } from './selection.ts';
+import type { InfiniteBuffer } from '../core/history.ts';
+import type { CommandRegistry, CommandContext } from './command-registry.ts';
+import type { AutocompleteEngine } from './autocomplete.ts';
+import type { FilePickerModal } from './file-picker.ts';
+import type { ModelPickerModal } from './model-picker.ts';
+import type { SelectionModal } from './selection-modal.ts';
+import type { SelectionResult } from './selection-modal.ts';
+import type { SearchManager } from './search.ts';
+import type { InputHistory, HistorySearch } from './input-history.ts';
+import type { ConversationManager } from '../core/conversation';
+import type { ProcessModal } from '../renderer/process-modal.ts';
+import type { LiveTailModal } from '../renderer/live-tail-modal.ts';
+import type { BlockActionsMenu } from '../renderer/block-actions.ts';
+import type { AgentDetailModal } from '../renderer/agent-detail-modal.ts';
+import type { ContextInspectorModal } from '../renderer/context-inspector.ts';
+import type { BookmarkModal } from './bookmark-modal.ts';
+import type { SettingsModal } from './settings-modal.ts';
+import type { SessionPickerModal } from './session-picker-modal.ts';
+import type { ProfilePickerModal } from './profile-picker-modal.ts';
+import type { WrappedPromptInfo } from './handler-prompt-buffer.ts';
+import type { Panel } from '../panels/types.ts';
+import type { PanelManager } from '../panels/panel-manager.ts';
+import type { KeybindingsManager } from './keybindings.ts';
+
+/**
+ * Initial mutable scalar values for InputFeedContext.
+ *
+ * **Mutable fields** (synced per-feed via syncFeedContextMutableFields or inside
+ * action closures that call syncFeedContextMutableFields):
+ *   - `prompt`, `cursorPos` — current text buffer state
+ *   - `commandMode`, `panelFocused`, `indicatorFocused` — focus-mode flags
+ *   - `helpOverlayActive`, `helpScrollOffset` — help overlay state
+ *   - `shortcutsOverlayActive`, `shortcutsScrollOffset` — shortcuts overlay state
+ *   - `nextPasteId`, `nextImageId` — monotonically increasing ID counters
+ *   - `mouseDownRow`, `mouseDownCol` — drag-tracking coordinates
+ *   - `contentWidth` — reflow width, updated by setContentWidth()
+ *   - `selectionCallback` — current selection modal callback (nullable)
+ */
+export interface FeedContextMutableInit {
+  prompt: string;
+  cursorPos: number;
+  commandMode: boolean;
+  panelFocused: boolean;
+  indicatorFocused: boolean;
+  helpOverlayActive: boolean;
+  helpScrollOffset: number;
+  shortcutsOverlayActive: boolean;
+  shortcutsScrollOffset: number;
+  nextPasteId: number;
+  nextImageId: number;
+  mouseDownRow: number;
+  mouseDownCol: number;
+  contentWidth: number;
+  selectionCallback: ((result: SelectionResult | null) => void) | null;
+}
+
+/**
+ * Stable (readonly) service references for InputFeedContext.
+ *
+ * **Stable references** (set once at construction, never reallocated):
+ *   - `pasteRegistry`, `imageRegistry` — owned Maps, never replaced
+ *   - `selectionModal`, `bookmarkModal`, `settingsModal`, `sessionPickerModal`,
+ *     `profilePickerModal` — modal objects constructed once
+ *   - `filePicker`, `modelPicker`, `processModal`, `liveTailModal`,
+ *     `agentDetailModal`, `contextInspectorModal`, `blockActionsMenu`,
+ *     `searchManager`, `historySearch` — service objects constructed once
+ *   - `panelManager`, `keybindingsManager` — from uiServices, stable
+ *   - `modalStack` — reference to the handler's shared array
+ *   - `getHistory`, `getViewportHeight`, `getScrollTop`, `scroll`, `exitApp` — callbacks
+ *   - `commandRegistry`, `commandContext`, `autocomplete`, `inputHistory`,
+ *     `conversationManager` — wired after construction; synced at feed() entry only
+ *     (not per-action) since no in-feed action changes them
+ *
+ * **Rationale:** per-feed mutation on a single object avoids per-keystroke GC pressure
+ * from ~80-field object allocation. Stable references are service handles that never
+ * need to change after construction.
+ */
+export interface FeedContextStableRefs {
+  selection: SelectionManager;
+  pasteRegistry: Map<string, string>;
+  imageRegistry: Map<string, { data: string; mediaType: string }>;
+  selectionModal: SelectionModal;
+  bookmarkModal: BookmarkModal;
+  settingsModal: SettingsModal;
+  sessionPickerModal: SessionPickerModal;
+  profilePickerModal: ProfilePickerModal;
+  historySearch: HistorySearch;
+  commandRegistry: CommandRegistry | null;
+  commandContext: CommandContext | undefined;
+  autocomplete: AutocompleteEngine | null;
+  filePicker: FilePickerModal;
+  modelPicker: ModelPickerModal;
+  processModal: ProcessModal;
+  liveTailModal: LiveTailModal;
+  agentDetailModal: AgentDetailModal;
+  contextInspectorModal: ContextInspectorModal;
+  blockActionsMenu: BlockActionsMenu;
+  searchManager: SearchManager;
+  modalStack: string[];
+  inputHistory: InputHistory | null;
+  conversationManager: ConversationManager | null;
+  panelManager: PanelManager;
+  keybindingsManager: KeybindingsManager;
+  getHistory: () => InfiniteBuffer;
+  getViewportHeight: () => number;
+  getScrollTop: () => number;
+  scroll: (delta: number) => void;
+  exitApp: () => void;
+}
+
+/** Bound method closures for InputFeedContext. Built in handler.ts where private members are accessible. */
+export interface FeedContextClosures {
+  modalOpened: (name: string) => void;
+  handleEscape: () => void;
+  handleCopy: () => void;
+  handleCtrlC: () => void;
+  handleBlockCopy: () => void;
+  handleBookmark: () => void;
+  handleBlockSave: () => void;
+  handleDiffApply: () => boolean;
+  handleUndo: () => void;
+  handleRedo: () => void;
+  handlePaste: () => void;
+  saveUndoState: () => void;
+  ensureInputCursorVisible: (contentWidth?: number) => void;
+  registerPaste: (content: string) => string;
+  executeBlockAction: (id: string) => void;
+  cyclePanelTab: (direction: 'next' | 'prev') => void;
+  onPanelInputConsumed: (activePanel: Panel | null, key: string) => void;
+  getWrappedPromptInfo: (contentWidth: number) => WrappedPromptInfo;
+  moveCursorVertical: (direction: -1 | 1) => boolean;
+  handlePathCompletion: () => boolean;
+  handleBlockToggle: () => void;
+  findMarkerAtPos: (pos: number) => { start: number; end: number } | null;
+  cleanupMarkerRegistry: (text: string) => void;
+  expandPrompt: (text: string) => string | import('@pellux/goodvibes-sdk/platform/providers/interface').ContentPart[];
+}
+
+/**
+ * buildInitialFeedContext — Allocate the single InputFeedContext that lives for the
+ * lifetime of the InputHandler.
+ *
+ * Accepts pre-built field groups from handler.ts where private access is available.
+ * The resulting context object is mutated in place on every feed() call via
+ * syncFeedContextMutableFields — no re-allocation occurs per keystroke.
+ *
+ * @param mutable  Initial mutable scalar values (synced per-feed).
+ * @param stable   Stable service references (set once, never replaced).
+ * @param closures Pre-built bound method closures (built in handler.ts).
+ */
+export function buildInitialFeedContext(
+  mutable: FeedContextMutableInit,
+  stable: FeedContextStableRefs,
+  closures: FeedContextClosures,
+): InputFeedContext {
+  const noop = (): void => {};
+  return {
+    // --- mutable scalars ---
+    ...mutable,
+    // --- requestRender: placeholder, swapped per-feed to buffered version ---
+    requestRender: noop,
+    // --- stable refs ---
+    ...stable,
+    // --- closures ---
+    ...closures,
+  };
+}
+
+/**
+ * syncFeedContextMutableFields — Copy mutable scalar fields into the reused
+ * InputFeedContext object.
+ *
+ * **Fields synced (updated on every call):**
+ *   - `prompt` — current prompt text buffer
+ *   - `cursorPos` — caret position within prompt
+ *   - `commandMode` — whether command-mode prefix is active
+ *   - `panelFocused` — whether the active panel owns keyboard focus
+ *   - `indicatorFocused` — whether the status indicator owns focus
+ *   - `helpOverlayActive` / `helpScrollOffset` — help overlay visibility and scroll
+ *   - `shortcutsOverlayActive` / `shortcutsScrollOffset` — shortcuts overlay state
+ *   - `selectionCallback` — the current in-flight selection modal callback
+ *   - `nextPasteId` / `nextImageId` — monotonically increasing allocation counters
+ *   - `mouseDownRow` / `mouseDownCol` — drag-start coordinates
+ *
+ * **Fields intentionally excluded (synced only at feed() entry, not here):**
+ *   - `contentWidth` — semi-stable; only changes on terminal resize via setContentWidth().
+ *     Synced at feed() entry because it is only relevant for layout, not action-reaction
+ *     sequences within a single feed.
+ *   - `commandRegistry`, `commandContext` — wired after construction via
+ *     setCommandRegistry(); synced at feed() entry since no in-feed action changes them.
+ *   - `autocomplete` — wired after construction; synced at feed() entry.
+ *   - `inputHistory`, `conversationManager` — late-wired service handles; stable within
+ *     a feed. Synced at feed() entry only.
+ *   - `requestRender` — swapped to a buffered version at feed() entry and restored in
+ *     the finally block; not managed by this function.
+ *
+ * Called from within action closures (`handleEscape`, `handleCtrlC`, `handleUndo`,
+ * `handleRedo`, `handlePaste`) that mutate handler state mid-feed, so subsequent
+ * route handlers see updated values without re-reading handler fields.
+ *
+ * @param fields  Current mutable field values from the handler.
+ * @param ctx     The InputFeedContext to update in place.
+ */
+export function syncFeedContextMutableFields(
+  fields: FeedContextMutableInit,
+  ctx: InputFeedContext,
+): void {
+  ctx.prompt = fields.prompt;
+  ctx.cursorPos = fields.cursorPos;
+  ctx.commandMode = fields.commandMode;
+  ctx.panelFocused = fields.panelFocused;
+  ctx.indicatorFocused = fields.indicatorFocused;
+  ctx.helpOverlayActive = fields.helpOverlayActive;
+  ctx.helpScrollOffset = fields.helpScrollOffset;
+  ctx.shortcutsOverlayActive = fields.shortcutsOverlayActive;
+  ctx.shortcutsScrollOffset = fields.shortcutsScrollOffset;
+  ctx.selectionCallback = fields.selectionCallback;
+  ctx.nextPasteId = fields.nextPasteId;
+  ctx.nextImageId = fields.nextImageId;
+  ctx.mouseDownRow = fields.mouseDownRow;
+  ctx.mouseDownCol = fields.mouseDownCol;
+}

package/src/input/handler-feed.ts

@@ -40,6 +40,44 @@ import { SelectionManager } from './selection.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 
+/**
+ * InputFeedContext — The single long-lived context object passed to feedInputTokens
+ * on every keystroke. Allocated once at InputHandler construction; mutated in place
+ * per-feed to avoid per-keystroke GC pressure from ~80-field object allocation.
+ *
+ * **Mutable per-feed** (synced from handler at the top of every feed() call, and
+ * updated inside action closures via syncFeedContextMutableFields):
+ *   - `prompt`, `cursorPos` — current text buffer state
+ *   - `commandMode`, `panelFocused`, `indicatorFocused` — focus-mode flags
+ *   - `helpOverlayActive`, `helpScrollOffset` — help overlay visibility and scroll
+ *   - `shortcutsOverlayActive`, `shortcutsScrollOffset` — shortcuts overlay state
+ *   - `nextPasteId`, `nextImageId` — monotonically increasing ID counters
+ *   - `mouseDownRow`, `mouseDownCol` — drag-tracking coordinates
+ *   - `contentWidth` — reflow width (semi-stable; synced at feed() entry only)
+ *   - `selectionCallback` — current in-flight selection modal callback (nullable)
+ *   - `requestRender` — swapped per-feed to a buffered version, restored after
+ *
+ * **Stable service handles** (set once at construction, never reallocated):
+ *   - `commandRegistry`, `commandContext` — wired via setCommandRegistry() after
+ *     construction; synced at feed() entry (not per-action) since no action changes them
+ *   - `autocomplete` — wired after construction; synced at feed() entry
+ *   - `inputHistory`, `conversationManager` — late-wired service handles; synced at
+ *     feed() entry only since no in-feed action rewires them
+ *   - `pasteRegistry`, `imageRegistry` — owned Maps, never replaced
+ *   - `selectionModal`, `bookmarkModal`, `settingsModal`, `sessionPickerModal`,
+ *     `profilePickerModal` — modal objects constructed once in InputHandler constructor
+ *   - `filePicker`, `modelPicker`, `processModal`, `liveTailModal`, `agentDetailModal`,
+ *     `contextInspectorModal`, `blockActionsMenu`, `searchManager`, `historySearch` —
+ *     service objects constructed once
+ *   - `panelManager`, `keybindingsManager` — from uiServices, stable for app lifetime
+ *   - `modalStack` — reference to the handler's shared array (mutated in place)
+ *   - `getHistory`, `getViewportHeight`, `getScrollTop`, `scroll`, `exitApp` — stable
+ *     callbacks bound in the InputHandler constructor
+ *   - All method closures (`modalOpened`, `handleEscape`, etc.) — bound once at init
+ *
+ * **Rationale:** per-feed mutation avoids per-keystroke allocation cost; stable
+ * references are service handles whose identity never changes after construction.
+ */
 export interface InputFeedContext {
   prompt: string;
   cursorPos: number;
@@ -65,9 +103,9 @@ export interface InputFeedContext {
   readonly sessionPickerModal: SessionPickerModal;
   readonly profilePickerModal: ProfilePickerModal;
   readonly historySearch: HistorySearch;
-  readonly commandRegistry: CommandRegistry | null;
-  readonly commandContext: CommandContext | undefined;
-  readonly autocomplete: AutocompleteEngine | null;
+  commandRegistry: CommandRegistry | null;
+  commandContext: CommandContext | undefined;
+  autocomplete: AutocompleteEngine | null;
   readonly filePicker: FilePickerModal;
   readonly modelPicker: ModelPickerModal;
   readonly processModal: ProcessModal;
@@ -79,13 +117,13 @@ export interface InputFeedContext {
   readonly panelManager: PanelManager;
   readonly keybindingsManager: KeybindingsManager;
   readonly modalStack: string[];
-  readonly inputHistory: InputHistory | null;
-  readonly conversationManager: ConversationManager | null;
+  inputHistory: InputHistory | null;
+  conversationManager: ConversationManager | null;
   readonly getHistory: () => InfiniteBuffer;
   readonly getViewportHeight: () => number;
   readonly getScrollTop: () => number;
   readonly scroll: (delta: number) => void;
-  readonly requestRender: () => void;
+  requestRender: () => void;
   readonly modalOpened: (name: string) => void;
   readonly handleEscape: () => void;
   readonly handleCopy: () => void;

package/src/input/handler-shortcuts.ts

@@ -52,144 +52,157 @@ export function handleGlobalShortcutToken(
 ): boolean {
   if (token.type !== 'key') return false;
 
-  const kb = state.keybindingsManager;
-  if (kb.matches('copy-selection', token)) {
-    state.handleCopy();
+  // Fast-path: bare pageup/pagedown have no keybinding entry.
+  if (token.logicalName === 'pageup') {
+    state.scroll(-Math.max(1, viewportHeight - 2));
     return true;
   }
-  if (kb.matches('clear-cancel', token)) {
-    state.handleCtrlC();
+  if (token.logicalName === 'pagedown') {
+    state.scroll(Math.max(1, viewportHeight - 2));
     return true;
   }
+  // Bare escape is also not in the keybinding table.
   if (token.logicalName === 'escape' && !state.panelFocused) {
     state.handleEscape();
     return true;
   }
-  if (kb.matches('screen-clear', token)) {
-    state.commandContext?.clearScreen?.();
-    return true;
-  }
-  if (kb.matches('panel-close-all', token)) {
-    const pm = state.panelManager;
-    for (const p of pm.getAllOpen()) pm.close(p.id);
-    pm.hide();
-    state.requestRender();
-    return true;
-  }
-  if (kb.matches('panel-close', token)) {
-    const pm = state.panelManager;
-    const active = pm.getActivePanel();
-    if (active) {
-      pm.close(active.id);
+
+  // O(1) lookup via inverted map.
+  const kb = state.keybindingsManager;
+  const action = kb.lookup(token);
+
+  switch (action) {
+    case 'copy-selection':
+      state.handleCopy();
+      return true;
+
+    case 'clear-cancel':
+      state.handleCtrlC();
+      return true;
+
+    case 'screen-clear':
+      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.requestRender();
+      return true;
     }
-    return true;
-  }
-  if (kb.matches('panel-picker', token)) {
-    state.commandContext?.openPanelPicker?.();
-    state.requestRender();
-    return true;
-  }
-  if (kb.matches('panel-tab-next', token)) {
-    state.cyclePanelTab('next');
-    return true;
-  }
-  if (kb.matches('panel-tab-prev', token)) {
-    state.cyclePanelTab('prev');
-    return true;
-  }
-  if (kb.matches('history-search', token)) {
-    state.historySearch.open(state.prompt);
-    state.requestRender();
-    return true;
-  }
-  if (kb.matches('search', token)) {
-    if (state.searchManager.active) state.searchManager.close();
-    else state.searchManager.open();
-    state.requestRender();
-    return true;
-  }
-  if (kb.matches('block-copy', token) && !state.commandMode) {
-    state.handleBlockCopy();
-    return true;
-  }
-  if (kb.matches('bookmark', token) && !state.commandMode) {
-    state.handleBookmark();
-    return true;
-  }
-  if (kb.matches('block-save', token) && !state.commandMode) {
-    state.handleBlockSave();
-    return true;
-  }
-  if (kb.matches('delete-word', token)) {
-    state.saveUndoState();
-    let pos = state.cursorPos;
-    while (pos > 0 && state.prompt[pos - 1] === ' ') pos--;
-    while (pos > 0 && state.prompt[pos - 1] !== ' ') pos--;
-    state.prompt = state.prompt.slice(0, pos) + state.prompt.slice(state.cursorPos);
-    state.cursorPos = pos;
-    state.ensureInputCursorVisible();
-    return true;
-  }
-  if (kb.matches('apply-diff-line-start', token)) {
-    if (!state.commandMode && state.handleDiffApply()) return true;
-    const info = state.getWrappedPromptInfo(state.contentWidth);
-    state.cursorPos = info.wrappedLines.length > 1 ? info.segments[info.cursorWrappedLine].rawStart : 0;
-    state.ensureInputCursorVisible();
-    return true;
-  }
-  if (kb.matches('next-error-line-end', token)) {
-    if (state.prompt === '' && !state.commandMode) {
-      const nextLine = state.conversationManager?.nextErrorLine(state.getScrollTop()) ?? -1;
-      if (nextLine >= 0) {
-        state.scroll(nextLine - state.getScrollTop());
+
+    case 'panel-close': {
+      const pm = state.panelManager;
+      const active = pm.getActivePanel();
+      if (active) {
+        pm.close(active.id);
         state.requestRender();
-        return true;
       }
+      return true;
     }
-    const info = state.getWrappedPromptInfo(state.contentWidth);
-    state.cursorPos = info.wrappedLines.length > 1
-      ? info.segments[info.cursorWrappedLine].rawStart + info.segments[info.cursorWrappedLine].length
-      : state.prompt.length;
-    state.ensureInputCursorVisible();
-    return true;
-  }
-  if (kb.matches('kill-line', token)) {
-    state.saveUndoState();
-    state.prompt = state.prompt.slice(0, state.cursorPos);
-    state.ensureInputCursorVisible();
-    return true;
-  }
-  if (kb.matches('clear-prompt', token)) {
-    state.saveUndoState();
-    state.prompt = '';
-    state.cursorPos = 0;
-    if (state.commandMode) {
-      state.commandMode = false;
-      state.autocomplete?.reset();
+
+    case 'panel-picker':
+      state.commandContext?.openPanelPicker?.();
+      state.requestRender();
+      return true;
+
+    case 'panel-tab-next':
+      state.cyclePanelTab('next');
+      return true;
+
+    case 'panel-tab-prev':
+      state.cyclePanelTab('prev');
+      return true;
+
+    case 'history-search':
+      state.historySearch.open(state.prompt);
+      state.requestRender();
+      return true;
+
+    case 'search':
+      if (state.searchManager.active) state.searchManager.close();
+      else state.searchManager.open();
+      state.requestRender();
+      return true;
+
+    case 'block-copy':
+      if (!state.commandMode) { state.handleBlockCopy(); return true; }
+      return false;
+
+    case 'bookmark':
+      if (!state.commandMode) { state.handleBookmark(); return true; }
+      return false;
+
+    case 'block-save':
+      if (!state.commandMode) { state.handleBlockSave(); return true; }
+      return false;
+
+    case 'delete-word': {
+      state.saveUndoState();
+      let pos = state.cursorPos;
+      while (pos > 0 && state.prompt[pos - 1] === ' ') pos--;
+      while (pos > 0 && state.prompt[pos - 1] !== ' ') pos--;
+      state.prompt = state.prompt.slice(0, pos) + state.prompt.slice(state.cursorPos);
+      state.cursorPos = pos;
+      state.ensureInputCursorVisible();
+      return true;
+    }
+
+    case 'apply-diff-line-start': {
+      if (!state.commandMode && state.handleDiffApply()) return true;
+      const info = state.getWrappedPromptInfo(state.contentWidth);
+      state.cursorPos = info.wrappedLines.length > 1 ? info.segments[info.cursorWrappedLine].rawStart : 0;
+      state.ensureInputCursorVisible();
+      return true;
     }
-    return true;
-  }
-  if (kb.matches('undo', token)) {
-    state.handleUndo();
-    return true;
-  }
-  if (kb.matches('redo', token)) {
-    state.handleRedo();
-    return true;
-  }
-  if (kb.matches('paste', token)) {
-    state.handlePaste();
-    return true;
-  }
-  if (token.logicalName === 'pageup') {
-    state.scroll(-Math.max(1, viewportHeight - 2));
-    return true;
-  }
-  if (token.logicalName === 'pagedown') {
-    state.scroll(Math.max(1, viewportHeight - 2));
-    return true;
-  }
 
-  return false;
+    case 'next-error-line-end': {
+      if (state.prompt === '' && !state.commandMode) {
+        const nextLine = state.conversationManager?.nextErrorLine(state.getScrollTop()) ?? -1;
+        if (nextLine >= 0) {
+          state.scroll(nextLine - state.getScrollTop());
+          state.requestRender();
+          return true;
+        }
+      }
+      const info = state.getWrappedPromptInfo(state.contentWidth);
+      state.cursorPos = info.wrappedLines.length > 1
+        ? info.segments[info.cursorWrappedLine].rawStart + info.segments[info.cursorWrappedLine].length
+        : state.prompt.length;
+      state.ensureInputCursorVisible();
+      return true;
+    }
+
+    case 'kill-line':
+      state.saveUndoState();
+      state.prompt = state.prompt.slice(0, state.cursorPos);
+      state.ensureInputCursorVisible();
+      return true;
+
+    case 'clear-prompt':
+      state.saveUndoState();
+      state.prompt = '';
+      state.cursorPos = 0;
+      if (state.commandMode) {
+        state.commandMode = false;
+        state.autocomplete?.reset();
+      }
+      return true;
+
+    case 'undo':
+      state.handleUndo();
+      return true;
+
+    case 'redo':
+      state.handleRedo();
+      return true;
+
+    case 'paste':
+      state.handlePaste();
+      return true;
+
+    default:
+      return false;
+  }
 }