@brimveyn/aimux 1.1.0

package/src/input/keymap/trie.ts

@@ -0,0 +1,103 @@
+import type { KeyResult, ModeContext } from '../modes/types'
+import type { KeyChord } from './key-chord'
+
+export type ActionFn = (ctx: ModeContext) => KeyResult | null
+
+export interface TrieBinding {
+  result: KeyResult | ActionFn
+  group?: string
+}
+
+export interface TrieNode {
+  binding: TrieBinding | null
+  children: Map<string, TrieNode>
+}
+
+export type TrieMatch =
+  | { type: 'exact'; binding: TrieBinding }
+  | { type: 'prefix'; node: TrieNode }
+  | { type: 'exact+prefix'; binding: TrieBinding; node: TrieNode }
+  | { type: 'none' }
+
+function createNode(): TrieNode {
+  return { binding: null, children: new Map() }
+}
+
+export class KeyTrie {
+  readonly root: TrieNode = createNode()
+
+  /**
+   * Insert a key sequence with a binding.
+   * Later inserts for the same sequence overwrite earlier ones.
+   */
+  insert(sequence: KeyChord[], binding: TrieBinding): void {
+    if (sequence.length === 0) return
+
+    let node = this.root
+    for (const chord of sequence) {
+      let child = node.children.get(chord)
+      if (!child) {
+        child = createNode()
+        node.children.set(chord, child)
+      }
+      node = child
+    }
+    node.binding = binding
+  }
+
+  /**
+   * Remove a key sequence. Returns true if it was found and removed.
+   */
+  remove(sequence: KeyChord[]): boolean {
+    if (sequence.length === 0) return false
+
+    const path: Array<{ node: TrieNode; chord: KeyChord }> = []
+    let node = this.root
+
+    for (const chord of sequence) {
+      const child = node.children.get(chord)
+      if (!child) return false
+      path.push({ chord, node })
+      node = child
+    }
+
+    if (!node.binding) return false
+    node.binding = null
+
+    // Prune empty branches from leaf upward
+    for (let i = path.length - 1; i >= 0; i--) {
+      const entry = path[i]
+      if (!entry) break
+      const { chord, node: parent } = entry
+      const child = parent.children.get(chord)
+      if (child && child.binding === null && child.children.size === 0) {
+        parent.children.delete(chord)
+      } else {
+        break
+      }
+    }
+
+    return true
+  }
+
+  /**
+   * Look up a single KeyChord from a given node (defaults to root).
+   */
+  lookup(chord: KeyChord, from?: TrieNode): TrieMatch {
+    const node = from ?? this.root
+    const child = node.children.get(chord)
+
+    if (!child) return { type: 'none' }
+
+    const hasChildren = child.children.size > 0
+
+    if (child.binding && hasChildren) {
+      return { binding: child.binding, node: child, type: 'exact+prefix' }
+    }
+    if (child.binding) {
+      return { binding: child.binding, type: 'exact' }
+    }
+    // hasChildren must be true (otherwise the node wouldn't exist after pruning)
+    return { node: child, type: 'prefix' }
+  }
+}

package/src/input/modes/bridge.ts

@@ -0,0 +1,58 @@
+import type { AppState, FocusMode, ModalType } from '../../state/types'
+import type { ModeId } from './types'
+
+type SupportedModalType = Exclude<ModalType, null>
+
+const DIRECT_FOCUS_MODE_IDS: Partial<Record<FocusMode, ModeId>> = {
+  'layout': 'layout',
+  'navigation': 'navigation',
+  'terminal-input': 'terminal-input',
+}
+
+const COMMAND_EDIT_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
+  'create-session': 'modal.create-session',
+  'new-tab': 'modal.new-tab.command-edit',
+  'rename-tab': 'modal.rename-tab',
+  'session-name': 'modal.session-name',
+  'session-picker': 'modal.session-picker.filtering',
+  'snippet-editor': 'modal.snippet-editor',
+  'snippet-picker': 'modal.snippet-picker.filtering',
+}
+
+const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
+  'help': 'modal.help',
+  'new-tab': 'modal.new-tab',
+  'session-picker': 'modal.session-picker',
+  'snippet-picker': 'modal.snippet-picker',
+  'split-picker': 'modal.split-picker',
+  'theme-picker': 'modal.theme-picker',
+}
+
+export function deriveModeId(state: AppState): ModeId {
+  const directMode = DIRECT_FOCUS_MODE_IDS[state.focusMode]
+  if (directMode) {
+    return directMode
+  }
+
+  if (state.focusMode === 'command-edit') {
+    const modalType = state.modal.type
+    const commandEditMode = modalType ? COMMAND_EDIT_MODE_IDS[modalType] : undefined
+    if (commandEditMode) {
+      return commandEditMode
+    }
+
+    return 'navigation'
+  }
+
+  if (state.focusMode === 'modal') {
+    const modalType = state.modal.type
+    const modalMode = modalType ? MODAL_MODE_IDS[modalType] : undefined
+    if (modalMode) {
+      return modalMode
+    }
+
+    return 'navigation'
+  }
+
+  return 'navigation'
+}

package/src/input/modes/handlers/index.ts

@@ -0,0 +1,18 @@
+import type { ResolvedKeymapConfig } from '@brimveyn/aimux-config'
+
+import type { KeymapModeHandler } from '../../keymap/keymap-mode-handler'
+
+import { buildKeymapHandlers } from '../../keymap/build-handlers'
+import { registerMode } from '../registry'
+
+/**
+ * Build and register all mode handlers from a resolved keymap config.
+ * Returns the handlers array so app.tsx can wire timeout callbacks.
+ */
+export function registerAllModes(config: ResolvedKeymapConfig): KeymapModeHandler[] {
+  const handlers = buildKeymapHandlers(config)
+  for (const handler of handlers) {
+    registerMode(handler)
+  }
+  return handlers
+}

package/src/input/modes/handlers/shared.ts

@@ -0,0 +1,70 @@
+import type { AppAction } from '../../../state/types'
+import type { KeyInput, KeyResult, ModeId, SideEffect } from '../types'
+
+type SelectionDelta = -1 | 1
+
+export function result(
+  actions: AppAction[] = [],
+  effects: SideEffect[] = [],
+  transition?: ModeId
+): KeyResult {
+  return transition ? { actions, effects, transition } : { actions, effects }
+}
+
+export function closeModalResult(
+  effects: SideEffect[] = [],
+  transition: ModeId = 'navigation'
+): KeyResult {
+  return result([{ type: 'close-modal' }], effects, transition)
+}
+
+export function moveModalSelectionResult(
+  delta: SelectionDelta,
+  effects: SideEffect[] = []
+): KeyResult {
+  return result([{ delta, type: 'move-modal-selection' }], effects)
+}
+
+export function handleModalSelectionKeys(
+  key: KeyInput,
+  getEffects?: (delta: SelectionDelta) => SideEffect[]
+): KeyResult | null {
+  if (key.name === 'j' || key.name === 'down') {
+    return moveModalSelectionResult(1, getEffects?.(1) ?? [])
+  }
+
+  if (key.name === 'k' || key.name === 'up') {
+    return moveModalSelectionResult(-1, getEffects?.(-1) ?? [])
+  }
+
+  return null
+}
+
+export function handleTextInput(key: KeyInput): KeyResult | null {
+  if (key.name === 'backspace') {
+    return result([{ char: '\b', type: 'update-command-edit' }])
+  }
+
+  if (key.name === 'space') {
+    return result([{ char: ' ', type: 'update-command-edit' }])
+  }
+
+  if (key.name.length === 1) {
+    const char = key.shift ? key.name.toUpperCase() : key.name
+    return result([{ char, type: 'update-command-edit' }])
+  }
+
+  return null
+}
+
+export function handleCtrlNavigation(key: KeyInput): KeyResult | null {
+  if (key.ctrl && key.name === 'n') {
+    return moveModalSelectionResult(1)
+  }
+
+  if (key.ctrl && key.name === 'p') {
+    return moveModalSelectionResult(-1)
+  }
+
+  return null
+}

package/src/input/modes/registry.ts

@@ -0,0 +1,34 @@
+import type { KeyResult, ModeContext, ModeHandler, ModeId } from './types'
+
+import { logDebug } from '../../debug/input-log'
+import { isValidTransition } from './transitions'
+
+const handlers = new Map<ModeId, ModeHandler>()
+const EMPTY_RESULT: KeyResult = { actions: [], effects: [] }
+
+export function registerMode(handler: ModeHandler): void {
+  handlers.set(handler.id, handler)
+}
+
+export function getHandler(id: ModeId): ModeHandler | undefined {
+  return handlers.get(id)
+}
+
+export function transitionTo(from: ModeId, to: ModeId, ctx: ModeContext): KeyResult {
+  if (!isValidTransition(from, to)) {
+    logDebug('mode.invalidTransition', { from, to })
+    return EMPTY_RESULT
+  }
+
+  const fromHandler = handlers.get(from)
+  const toHandler = handlers.get(to)
+
+  const exitResult = fromHandler?.onExit?.(ctx, to) ?? EMPTY_RESULT
+  const enterResult = toHandler?.onEnter?.(ctx, from) ?? EMPTY_RESULT
+
+  return {
+    actions: [...exitResult.actions, ...enterResult.actions],
+    effects: [...exitResult.effects, ...enterResult.effects],
+    transition: to,
+  }
+}

package/src/input/modes/transitions.ts

@@ -0,0 +1,37 @@
+import type { ModeId } from './types'
+
+const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
+  'layout': ['terminal-input', 'navigation', 'modal.split-picker'],
+  'modal.create-session': ['navigation', 'modal.session-picker'],
+  'modal.help': ['navigation'],
+  'modal.new-tab': ['navigation', 'modal.new-tab.command-edit'],
+  'modal.new-tab.command-edit': ['modal.new-tab'],
+  'modal.rename-tab': ['navigation'],
+  'modal.session-name': ['modal.session-picker', 'navigation'],
+  'modal.session-picker': [
+    'navigation',
+    'modal.session-picker.filtering',
+    'modal.session-name',
+    'modal.create-session',
+  ],
+  'modal.session-picker.filtering': ['modal.session-picker'],
+  'modal.snippet-editor': ['navigation', 'modal.snippet-picker'],
+  'modal.snippet-picker': ['navigation', 'modal.snippet-picker.filtering', 'modal.snippet-editor'],
+  'modal.snippet-picker.filtering': ['modal.snippet-picker'],
+  'modal.split-picker': ['navigation'],
+  'modal.theme-picker': ['navigation'],
+  'navigation': [
+    'terminal-input',
+    'modal.new-tab',
+    'modal.session-picker',
+    'modal.help',
+    'modal.snippet-picker',
+    'modal.theme-picker',
+    'modal.rename-tab',
+  ],
+  'terminal-input': ['navigation', 'layout'],
+}
+
+export function isValidTransition(from: ModeId, to: ModeId): boolean {
+  return TRANSITIONS[from].includes(to)
+}

package/src/input/modes/types.ts

@@ -0,0 +1,63 @@
+import type { KeyEvent } from '@opentui/core'
+
+import type { AppAction, AppState, TabSession } from '../../state/types'
+
+export type ModeId =
+  | 'navigation'
+  | 'terminal-input'
+  | 'layout'
+  | 'modal.new-tab'
+  | 'modal.new-tab.command-edit'
+  | 'modal.session-picker'
+  | 'modal.session-picker.filtering'
+  | 'modal.session-name'
+  | 'modal.create-session'
+  | 'modal.rename-tab'
+  | 'modal.snippet-picker'
+  | 'modal.snippet-picker.filtering'
+  | 'modal.snippet-editor'
+  | 'modal.theme-picker'
+  | 'modal.help'
+  | 'modal.split-picker'
+
+export type SideEffect =
+  | { type: 'quit'; state: AppState }
+  | { type: 'launch-selected-assistant' }
+  | { type: 'confirm-selected-session' }
+  | { type: 'delete-selected-session' }
+  | { type: 'open-rename-selected-session' }
+  | { type: 'create-session'; name: string; projectPath?: string }
+  | { type: 'close-tab'; tabId: string }
+  | { type: 'restart-tab'; tab: TabSession }
+  | { type: 'paste-selected-snippet' }
+  | { type: 'paste-snippet-to-group' }
+  | { type: 'edit-selected-snippet' }
+  | { type: 'delete-selected-snippet' }
+  | { type: 'save-snippet-editor' }
+  | { type: 'save-custom-command' }
+  | { type: 'apply-theme'; action: 'open' }
+  | { type: 'apply-theme'; action: 'restore' }
+  | { type: 'apply-theme'; action: 'confirm' }
+  | { type: 'apply-theme'; action: 'preview'; delta: 1 | -1 }
+  | { type: 'rename-session'; sessionId: string; name: string }
+  | { type: 'split-pane'; direction: import('../../state/layout-tree').SplitDirection }
+  | { type: 'confirm-split' }
+
+export interface KeyResult {
+  actions: AppAction[]
+  effects: SideEffect[]
+  transition?: ModeId
+}
+
+export interface ModeContext {
+  readonly state: AppState
+}
+
+export type KeyInput = Pick<KeyEvent, 'name' | 'ctrl' | 'meta' | 'shift' | 'sequence'>
+
+export interface ModeHandler {
+  readonly id: ModeId
+  handleKey(key: KeyInput, ctx: ModeContext): KeyResult | null
+  onEnter?(ctx: ModeContext, from: ModeId): KeyResult
+  onExit?(ctx: ModeContext, to: ModeId): KeyResult
+}

package/src/input/mouse-forwarding.ts

@@ -0,0 +1,98 @@
+import { MouseButton, type MouseEvent } from '@opentui/core'
+
+import type { TerminalContentOrigin } from './raw-input-handler'
+
+function clampPtyCoordinates(
+  event: MouseEvent,
+  origin: TerminalContentOrigin
+): { x: number; y: number } | null {
+  const x = event.x + 1 - origin.x
+  const y = event.y + 1 - origin.y
+
+  if (x < 1 || y < 1 || x > origin.cols || y > origin.rows) {
+    return null
+  }
+
+  return { x, y }
+}
+
+function getModifierBits(event: MouseEvent): number {
+  return (
+    (event.modifiers.shift ? 4 : 0) |
+    (event.modifiers.alt ? 8 : 0) |
+    (event.modifiers.ctrl ? 16 : 0)
+  )
+}
+
+function getBaseButtonCode(event: MouseEvent): number | null {
+  if (event.type === 'scroll') {
+    switch (event.scroll?.direction) {
+      case 'up':
+        return 64
+      case 'down':
+        return 65
+      case 'left':
+        return 66
+      case 'right':
+        return 67
+      default:
+        return null
+    }
+  }
+
+  switch (event.button) {
+    case MouseButton.LEFT:
+      return 0
+    case MouseButton.MIDDLE:
+      return 1
+    case MouseButton.RIGHT:
+      return 2
+    case MouseButton.WHEEL_UP:
+      return 64
+    case MouseButton.WHEEL_DOWN:
+      return 65
+    default:
+      return null
+  }
+}
+
+export function encodeMouseEventForPty(
+  event: MouseEvent,
+  origin: TerminalContentOrigin
+): string | null {
+  const coordinates = clampPtyCoordinates(event, origin)
+  if (!coordinates) {
+    return null
+  }
+
+  const modifierBits = getModifierBits(event)
+
+  switch (event.type) {
+    case 'down': {
+      const buttonCode = getBaseButtonCode(event)
+      if (buttonCode === null) {
+        return null
+      }
+      return `\x1b[<${buttonCode | modifierBits};${coordinates.x};${coordinates.y}M`
+    }
+    case 'up': {
+      return `\x1b[<${3 | modifierBits};${coordinates.x};${coordinates.y}m`
+    }
+    case 'drag': {
+      const buttonCode = getBaseButtonCode(event)
+      if (buttonCode === null) {
+        return null
+      }
+      return `\x1b[<${buttonCode | 32 | modifierBits};${coordinates.x};${coordinates.y}M`
+    }
+    case 'scroll': {
+      const buttonCode = getBaseButtonCode(event)
+      if (buttonCode === null) {
+        return null
+      }
+      return `\x1b[<${buttonCode | modifierBits};${coordinates.x};${coordinates.y}M`
+    }
+    default:
+      return null
+  }
+}

package/src/input/multi-click-detector.ts

@@ -0,0 +1,55 @@
+import { logInputDebug } from '../debug/input-log'
+
+const MULTI_CLICK_TIMEOUT_MS = 400
+const MULTI_CLICK_MAX_DISTANCE = 1
+
+export class MultiClickDetector {
+  private lastClickTime = 0
+  private lastX = -1
+  private lastY = -1
+  private clickCount = 0
+
+  track(x: number, y: number): number {
+    const now = Date.now()
+    const prevX = this.lastX
+    const prevY = this.lastY
+    const prevTime = this.lastClickTime
+    // X tolerance allows slight horizontal drift during rapid clicks.
+    // Y must match exactly because 1 pixel = 1 terminal row — a 1-pixel
+    // vertical shift means a completely different line.
+    const samePosition = Math.abs(x - this.lastX) <= MULTI_CLICK_MAX_DISTANCE && y === this.lastY
+    const withinTimeout = now - this.lastClickTime < MULTI_CLICK_TIMEOUT_MS
+
+    if (samePosition && withinTimeout && this.clickCount < 3) {
+      this.clickCount += 1
+    } else {
+      this.clickCount = 1
+    }
+
+    this.lastClickTime = now
+    this.lastX = x
+    this.lastY = y
+
+    logInputDebug('multiclick.track', {
+      count: this.clickCount,
+      dt: now - prevTime,
+      dX: Math.abs(x - prevX),
+      dY: Math.abs(y - prevY),
+      inTime: withinTimeout,
+      prevX,
+      prevY,
+      samePos: samePosition,
+      x,
+      y,
+    })
+
+    return this.clickCount
+  }
+
+  reset(): void {
+    this.clickCount = 0
+    this.lastClickTime = 0
+    this.lastX = -1
+    this.lastY = -1
+  }
+}

package/src/input/paste.ts

@@ -0,0 +1,12 @@
+const BRACKETED_PASTE_START = '\x1b[200~'
+const BRACKETED_PASTE_END = '\x1b[201~'
+
+export function buildPtyPastePayload(text: string, bracketedPasteMode: boolean): string {
+  if (!bracketedPasteMode) {
+    return text
+  }
+
+  return `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`
+}
+
+export { BRACKETED_PASTE_END, BRACKETED_PASTE_START }