@brimveyn/aimux 1.1.0

package/src/git/git-status.ts

@@ -0,0 +1,183 @@
+import { $ } from 'bun'
+
+import type {
+  GitFileEntry,
+  GitFileSection,
+  GitFileStatus,
+  GitPanelError,
+  GitRefreshPayload,
+} from '../state/types'
+
+interface NumstatRow {
+  added: number | null
+  removed: number | null
+}
+
+export type GitCollectResult =
+  | { kind: 'ok'; payload: GitRefreshPayload }
+  | { kind: 'error'; error: GitPanelError }
+
+const STATUS_CODES = new Set(['M', 'A', 'D', 'R', 'C', 'U', '?'])
+
+function toStatus(char: string): GitFileStatus | null {
+  return STATUS_CODES.has(char) ? (char as GitFileStatus) : null
+}
+
+export function parseBranchLines(output: string): {
+  branch: string | null
+  ahead: number
+  behind: number
+} {
+  let branch: string | null = null
+  let ahead = 0
+  let behind = 0
+  for (const line of output.split('\0')) {
+    if (line.startsWith('# branch.head ')) {
+      const head = line.slice('# branch.head '.length).trim()
+      branch = head === '(detached)' ? null : head
+    } else if (line.startsWith('# branch.ab ')) {
+      const rest = line.slice('# branch.ab '.length).trim()
+      const match = /^\+(\d+)\s+-(\d+)/.exec(rest)
+      if (match) {
+        ahead = Number.parseInt(match[1] as string, 10)
+        behind = Number.parseInt(match[2] as string, 10)
+      }
+    }
+  }
+  return { ahead, behind, branch }
+}
+
+export function parseNumstat(output: string): Map<string, NumstatRow> {
+  const map = new Map<string, NumstatRow>()
+  for (const raw of output.split('\n')) {
+    if (!raw) continue
+    const parts = raw.split('\t')
+    if (parts.length < 3) continue
+    const [addedStr, removedStr, ...pathParts] = parts
+    const path = pathParts.join('\t')
+    if (!path || path.includes('{') || path.includes(' => ')) continue
+    const added = addedStr === '-' ? null : Number.parseInt(addedStr ?? '', 10)
+    const removed = removedStr === '-' ? null : Number.parseInt(removedStr ?? '', 10)
+    map.set(path, {
+      added: Number.isNaN(added as number) ? null : added,
+      removed: Number.isNaN(removed as number) ? null : removed,
+    })
+  }
+  return map
+}
+
+function buildEntry(
+  section: GitFileSection,
+  status: GitFileStatus,
+  path: string,
+  numstat: Map<string, NumstatRow>,
+  renamedFrom?: string
+): GitFileEntry {
+  const stats = numstat.get(path)
+  let added: number | null
+  let removed: number | null
+  if (status === '?') {
+    added = null
+    removed = null
+  } else if (stats) {
+    added = stats.added
+    removed = stats.removed
+  } else {
+    added = 0
+    removed = 0
+  }
+  const entry: GitFileEntry = { added, path, removed, section, status }
+  if (renamedFrom) entry.renamedFrom = renamedFrom
+  return entry
+}
+
+export function parsePorcelainEntries(
+  output: string,
+  stagedNumstat: Map<string, NumstatRow>,
+  unstagedNumstat: Map<string, NumstatRow>
+): GitFileEntry[] {
+  const files: GitFileEntry[] = []
+  const records = output.split('\0')
+  let i = 0
+  while (i < records.length) {
+    const line = records[i] ?? ''
+    if (!line || line.startsWith('#') || line.startsWith('!')) {
+      i++
+      continue
+    }
+
+    if (line.startsWith('? ')) {
+      files.push(buildEntry('untracked', '?', line.slice(2), unstagedNumstat))
+      i++
+      continue
+    }
+
+    if (line.startsWith('1 ')) {
+      const parts = line.split(' ')
+      if (parts.length >= 9) {
+        const xy = parts[1] ?? '..'
+        const path = parts.slice(8).join(' ')
+        const x = toStatus(xy[0] ?? '.')
+        const y = toStatus(xy[1] ?? '.')
+        if (x) files.push(buildEntry('staged', x, path, stagedNumstat))
+        if (y) files.push(buildEntry('unstaged', y, path, unstagedNumstat))
+      }
+      i++
+      continue
+    }
+
+    if (line.startsWith('2 ')) {
+      const parts = line.split(' ')
+      const origPath = records[i + 1] ?? ''
+      if (parts.length >= 10 && origPath) {
+        const xy = parts[1] ?? '..'
+        const newPath = parts.slice(9).join(' ')
+        if (newPath) {
+          const x = toStatus(xy[0] ?? '.')
+          const y = toStatus(xy[1] ?? '.')
+          if (x) files.push(buildEntry('staged', x, newPath, stagedNumstat, origPath))
+          if (y) files.push(buildEntry('unstaged', y, newPath, unstagedNumstat, origPath))
+        }
+      }
+      i += 2
+      continue
+    }
+
+    if (line.startsWith('u ')) {
+      const parts = line.split(' ')
+      if (parts.length >= 11) {
+        const path = parts.slice(10).join(' ')
+        files.push(buildEntry('unstaged', 'U', path, unstagedNumstat))
+      }
+      i++
+      continue
+    }
+
+    i++
+  }
+  return files
+}
+
+export async function collectGitStatus(cwd: string): Promise<GitCollectResult> {
+  try {
+    const [statusResult, unstagedDiff, stagedDiff] = await Promise.all([
+      $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
+      $`git -C ${cwd} -c core.quotePath=false diff --numstat`.quiet().nothrow(),
+      $`git -C ${cwd} -c core.quotePath=false diff --cached --numstat`.quiet().nothrow(),
+    ])
+
+    if (statusResult.exitCode !== 0) {
+      return { error: 'not-a-repo', kind: 'error' }
+    }
+
+    const statusText = statusResult.text()
+    const { ahead, behind, branch } = parseBranchLines(statusText)
+    const unstagedNumstat = parseNumstat(unstagedDiff.text())
+    const stagedNumstat = parseNumstat(stagedDiff.text())
+    const files = parsePorcelainEntries(statusText, stagedNumstat, unstagedNumstat)
+
+    return { kind: 'ok', payload: { ahead, behind, branch, files } }
+  } catch {
+    return { error: 'unknown', kind: 'error' }
+  }
+}

package/src/index.tsx

@@ -0,0 +1,56 @@
+#!/usr/bin/env bun
+import { createCliRenderer } from '@opentui/core'
+import { createRoot } from '@opentui/react'
+
+import { App } from './app'
+import { runDaemon } from './daemon/daemon'
+import { logDebug } from './debug/input-log'
+import { runDoctor } from './doctor'
+import { runRestartDaemon } from './restart-daemon'
+import { createSessionBackend } from './session-backend/bootstrap'
+import { runUpdate } from './update'
+
+const command = process.argv[2]
+
+if (command === '--version' || command === '-v' || command === 'version') {
+  const { version } = await import('../package.json')
+  process.stdout.write(`aimux ${version}\n`)
+  process.exit(0)
+}
+
+if (command === 'doctor' || command === '--doctor') {
+  process.exit(runDoctor())
+}
+
+if (command === 'restart-daemon') {
+  process.exit(await runRestartDaemon())
+}
+
+if (command === 'update') {
+  process.exit(await runUpdate())
+}
+
+if (command === 'daemon') {
+  logDebug('index.daemonMode')
+  await runDaemon()
+}
+
+if (command === '--help' || command === '-h') {
+  process.stdout.write(
+    'aimux -- terminal multiplexer for AI CLIs\n\nUsage:\n  aimux                  Start aimux\n  aimux update           Update to latest version\n  aimux doctor           Diagnose setup issues\n  aimux restart-daemon   Restart background daemon\n\n'
+  )
+  process.exit(0)
+}
+
+const renderer = await createCliRenderer({
+  autoFocus: true,
+  exitOnCtrlC: false,
+  useAlternateScreen: true,
+  useConsole: false,
+  useMouse: true,
+})
+
+const backend = await createSessionBackend()
+logDebug('index.backendReady', { backend: backend.constructor.name })
+
+createRoot(renderer).render(<App backend={backend} />)

package/src/input/keymap/build-handlers.ts

@@ -0,0 +1,34 @@
+import type { ResolvedKeymapConfig } from '@brimveyn/aimux-config'
+
+import { parseKeyNotation } from './key-chord'
+import { KeymapModeHandler } from './keymap-mode-handler'
+import { KeyTrie } from './trie'
+
+/**
+ * Build a KeymapModeHandler for each mode defined in the resolved config.
+ */
+export function buildKeymapHandlers(config: ResolvedKeymapConfig): KeymapModeHandler[] {
+  const leaderChord = parseKeyNotation(config.leader)[0]
+  const handlers: KeymapModeHandler[] = []
+
+  for (const [modeId, modeDef] of config.modes) {
+    const trie = new KeyTrie()
+
+    for (const binding of modeDef.bindings) {
+      const sequence = parseKeyNotation(binding.keys, leaderChord)
+      trie.insert(sequence, {
+        group: binding.group,
+        result: binding.result,
+      })
+    }
+
+    const handler = new KeymapModeHandler(modeId, trie, {
+      passthrough: modeDef.isPassthrough,
+      timeoutMs: config.timeout,
+    })
+
+    handlers.push(handler)
+  }
+
+  return handlers
+}

package/src/input/keymap/key-chord.ts

@@ -0,0 +1,201 @@
+import type { KeyInput } from '../modes/types'
+
+/**
+ * Canonical string representation of a single key press.
+ * Examples: "C-n", "d", "J", "escape", "space", "?", "C-M-x"
+ * Modifier prefix order: C- (ctrl), M- (meta/alt), then the key name.
+ * Shift+letter is encoded as uppercase: Shift+j → "J".
+ */
+export type KeyChord = string
+
+const SPECIAL_NAMES: Record<string, string> = {
+  BS: 'backspace',
+  CR: 'return',
+  Down: 'down',
+  Esc: 'escape',
+  Left: 'left',
+  Right: 'right',
+  Space: 'space',
+  Tab: 'tab',
+  Up: 'up',
+}
+
+/**
+ * Convert a runtime KeyInput (from @opentui/core KeyEvent) to a canonical KeyChord.
+ */
+export function keyInputToChord(key: KeyInput): KeyChord {
+  const { ctrl, meta, name, sequence, shift } = key
+
+  // For single-character sequences that differ from name (e.g., '?' comes as sequence='?' name='?')
+  // Use sequence for punctuation/symbols not captured by name
+  const baseName = name === 'undefined' || name === '' ? sequence : name
+
+  // Shift+letter → uppercase letter (no S- prefix)
+  if (shift && !ctrl && !meta && baseName.length === 1 && /^[a-z]$/.test(baseName)) {
+    return baseName.toUpperCase()
+  }
+
+  let prefix = ''
+  if (ctrl) prefix += 'C-'
+  if (meta) prefix += 'M-'
+
+  return `${prefix}${baseName}`
+}
+
+// Regex to match <...> notation tokens
+const ANGLE_BRACKET_RE = /<([^>]+)>/g
+
+/**
+ * Parse a vim-style key notation string into an array of KeyChords.
+ *
+ * Supports:
+ * - `<C-n>`, `<M-x>`, `<C-M-a>` — modifier combos
+ * - `<CR>`, `<Esc>`, `<Space>`, `<BS>`, `<Tab>` — special keys
+ * - `<Down>`, `<Up>`, `<Left>`, `<Right>` — arrow keys
+ * - `<leader>` — substituted with the provided leader KeyChord
+ * - `dd`, `gj` — bare characters produce one KeyChord each
+ *
+ * Examples:
+ * - `"<C-n>"` → `["C-n"]`
+ * - `"dd"` → `["d", "d"]`
+ * - `"<leader>tn"` → `["space", "t", "n"]` (if leader is "space")
+ */
+export function parseKeyNotation(notation: string, leader?: KeyChord): KeyChord[] {
+  const chords: KeyChord[] = []
+  let lastIndex = 0
+
+  for (const match of notation.matchAll(ANGLE_BRACKET_RE)) {
+    const matchIndex = match.index ?? 0
+    const matchText = match[0] ?? ''
+    const inner = match[1] ?? ''
+
+    // Process bare characters before this angle-bracket token
+    for (let i = lastIndex; i < matchIndex; i++) {
+      const ch = notation[i]
+      if (ch !== undefined) chords.push(ch)
+    }
+
+    // Handle <leader>
+    if (inner.toLowerCase() === 'leader') {
+      if (!leader) {
+        throw new Error('parseKeyNotation: <leader> used but no leader key configured')
+      }
+      chords.push(leader)
+      lastIndex = matchIndex + matchText.length
+      continue
+    }
+
+    // Parse modifier+key combo: C-n, M-x, C-M-a, S-g
+    chords.push(parseAngleBracketToken(inner))
+    lastIndex = matchIndex + matchText.length
+  }
+
+  // Process remaining bare characters after last angle-bracket match
+  for (let i = lastIndex; i < notation.length; i++) {
+    const ch = notation[i]
+    if (ch !== undefined) chords.push(ch)
+  }
+
+  return chords
+}
+
+function parseAngleBracketToken(inner: string): KeyChord {
+  // Check if it's a special name (no modifiers)
+  const specialInner = SPECIAL_NAMES[inner]
+  if (specialInner) {
+    return specialInner
+  }
+
+  // Parse modifiers: split by '-', last part is the key
+  const parts = inner.split('-')
+  let ctrl = false
+  let meta = false
+  let shift = false
+
+  // All parts except the last are modifiers
+  for (let i = 0; i < parts.length - 1; i++) {
+    const mod = (parts[i] ?? '').toUpperCase()
+    if (mod === 'C') ctrl = true
+    else if (mod === 'M' || mod === 'A') meta = true
+    else if (mod === 'S') shift = true
+  }
+
+  let keyName = parts[parts.length - 1] ?? ''
+
+  // Check if the key part is a special name
+  const specialKey = SPECIAL_NAMES[keyName]
+  if (specialKey) {
+    keyName = specialKey
+  }
+
+  // Shift+letter → uppercase
+  if (shift && !ctrl && !meta && keyName.length === 1 && /^[a-z]$/.test(keyName)) {
+    return keyName.toUpperCase()
+  }
+
+  let prefix = ''
+  if (ctrl) prefix += 'C-'
+  if (meta) prefix += 'M-'
+
+  return `${prefix}${keyName}`
+}
+
+/**
+ * Convert a raw terminal byte sequence into a canonical KeyChord.
+ *
+ * Handles:
+ * - Single control bytes (0x01..0x1a) → `"C-<letter>"` (e.g., 0x1a → `"C-z"`)
+ * - Kitty CSI sequences `<ESC>[<code>;<mod>u` → `"C-<letter>"` (if ctrl modifier)
+ *
+ * Returns null if the sequence doesn't map to a recognizable chord.
+ */
+const KITTY_CTRL_CSI_RE = new RegExp(`^${String.fromCharCode(0x1b)}\\[(\\d+);(\\d+)u$`)
+const KITTY_MOD_CTRL = 4
+const KITTY_MOD_SHIFT = 1
+const KITTY_MOD_ALT = 2
+
+export function rawSequenceToChord(sequence: string): KeyChord | null {
+  if (sequence.length === 1) {
+    const code = sequence.charCodeAt(0)
+
+    // Control bytes: Ctrl+A (0x01) through Ctrl+Z (0x1a)
+    if (code >= 0x01 && code <= 0x1a) {
+      return `C-${String.fromCharCode(code + 0x60)}`
+    }
+
+    // DEL (0x7f) is backspace
+    if (code === 0x7f) return 'backspace'
+
+    // Printable ASCII (space through ~): return the char as-is.
+    // Uppercase letters stay uppercase (shift convention).
+    if (code >= 0x20 && code <= 0x7e) {
+      return sequence
+    }
+
+    return null
+  }
+
+  // Kitty CSI: <ESC>[<code>;<mod>u
+  const match = KITTY_CTRL_CSI_RE.exec(sequence)
+  if (!match) return null
+
+  const codePoint = Number(match[1])
+  const modifiers = Number(match[2]) - 1
+  const hasCtrl = (modifiers & KITTY_MOD_CTRL) !== 0
+  const hasShift = (modifiers & KITTY_MOD_SHIFT) !== 0
+  const hasAlt = (modifiers & KITTY_MOD_ALT) !== 0
+
+  if (!hasCtrl || hasAlt) return null
+
+  // Only handle ASCII letters for now
+  if (codePoint >= 97 && codePoint <= 122) {
+    const letter = String.fromCharCode(codePoint)
+    const chord = hasShift ? `C-${letter.toUpperCase()}` : `C-${letter}`
+    return chord
+  }
+  if (codePoint >= 65 && codePoint <= 90) {
+    return `C-${String.fromCharCode(codePoint)}`
+  }
+
+  return null
+}

package/src/input/keymap/keymap-mode-handler.ts

@@ -0,0 +1,88 @@
+import type { ActionFn } from '@brimveyn/aimux-config'
+
+import type { KeyInput, KeyResult, ModeContext, ModeHandler, ModeId } from '../modes/types'
+import type { KeyTrie, TrieBinding } from './trie'
+
+import { handleTextInput } from '../modes/handlers/shared'
+import { type KeyChord, keyInputToChord } from './key-chord'
+import { SequenceResolver } from './sequence-resolver'
+
+const EMPTY_RESULT: KeyResult = { actions: [], effects: [] }
+
+function evalBinding(binding: TrieBinding, ctx: ModeContext): KeyResult | null {
+  if (typeof binding.result === 'function') {
+    return (binding.result as ActionFn)(ctx)
+  }
+  return binding.result
+}
+
+export class KeymapModeHandler implements ModeHandler {
+  readonly id: ModeId
+  private readonly resolver: SequenceResolver
+  private readonly isPassthrough: boolean
+
+  constructor(id: ModeId, trie: KeyTrie, opts: { timeoutMs: number; passthrough?: boolean }) {
+    this.id = id
+    this.isPassthrough = opts.passthrough ?? false
+    this.resolver = new SequenceResolver(trie, { timeoutMs: opts.timeoutMs })
+  }
+
+  handleKey(key: KeyInput, ctx: ModeContext): KeyResult | null {
+    const chord = keyInputToChord(key)
+    const match = this.resolver.feed(chord)
+
+    switch (match.type) {
+      case 'resolved':
+        return evalBinding(match.binding, ctx)
+      case 'pending':
+        return EMPTY_RESULT
+      case 'passthrough':
+        if (this.isPassthrough) return handleTextInput(key)
+        return null
+    }
+  }
+
+  /**
+   * Feed a KeyChord directly (bypassing KeyInput conversion).
+   * Used by raw-input-handler for terminal-input shortcuts.
+   * Returns the resolved KeyResult if matched, otherwise null.
+   */
+  handleChord(chord: KeyChord, ctx: ModeContext): KeyResult | null {
+    const match = this.resolver.feed(chord)
+
+    switch (match.type) {
+      case 'resolved':
+        return evalBinding(match.binding, ctx)
+      case 'pending':
+        return EMPTY_RESULT
+      case 'passthrough':
+        return null
+    }
+  }
+
+  onEnter(_ctx: ModeContext, _from: ModeId): KeyResult {
+    this.resolver.reset()
+    return EMPTY_RESULT
+  }
+
+  onExit(_ctx: ModeContext, _to: ModeId): KeyResult {
+    this.resolver.reset()
+    return EMPTY_RESULT
+  }
+
+  /**
+   * Set the callback for when an ambiguous sequence times out.
+   * Must be wired from app.tsx to call processKeyResult.
+   */
+  setTimeoutCallback(cb: (binding: TrieBinding) => void): void {
+    this.resolver.setTimeoutCallback(cb)
+  }
+
+  /**
+   * Set the callback for pending chord state changes.
+   * Fires with the current pending chord sequence (or null when cleared).
+   */
+  setPendingChangeCallback(cb: (chords: KeyChord[] | null) => void): void {
+    this.resolver.setPendingChangeCallback(cb)
+  }
+}

package/src/input/keymap/sequence-resolver.ts

@@ -0,0 +1,117 @@
+import type { KeyChord } from './key-chord'
+import type { KeyTrie, TrieBinding, TrieNode } from './trie'
+
+export type ResolveResult =
+  | { type: 'resolved'; binding: TrieBinding }
+  | { type: 'pending' }
+  | { type: 'passthrough' }
+
+export interface SequenceResolverConfig {
+  timeoutMs: number
+}
+
+export class SequenceResolver {
+  private currentNode: TrieNode | null = null
+  private pendingBinding: TrieBinding | null = null
+  private pendingChords: KeyChord[] = []
+  private timeoutHandle: ReturnType<typeof setTimeout> | null = null
+  private onTimeout: ((binding: TrieBinding) => void) | null = null
+  private onPendingChange: ((chords: KeyChord[] | null) => void) | null = null
+
+  constructor(
+    private readonly trie: KeyTrie,
+    private readonly config: SequenceResolverConfig
+  ) {}
+
+  /**
+   * Feed a key chord into the resolver.
+   *
+   * Algorithm:
+   * 1. Lookup from current position (or root if no pending sequence).
+   * 2. 'none' → reset, try from root. If still none → passthrough.
+   * 3. 'exact' → fire immediately.
+   * 4. 'prefix' → wait for more keys.
+   * 5. 'exact+prefix' → start timeout. If next key arrives in time, advance.
+   *    If timeout fires, resolve the exact match.
+   */
+  feed(chord: KeyChord): ResolveResult {
+    this.clearTimeout()
+
+    const fromNode = this.currentNode ?? this.trie.root
+    const match = this.trie.lookup(chord, fromNode)
+
+    switch (match.type) {
+      case 'exact': {
+        this.resetState()
+        return { binding: match.binding, type: 'resolved' }
+      }
+
+      case 'prefix': {
+        this.currentNode = match.node
+        this.pendingBinding = null
+        this.pendingChords.push(chord)
+        this.emitPendingChange()
+        return { type: 'pending' }
+      }
+
+      case 'exact+prefix': {
+        this.currentNode = match.node
+        this.pendingBinding = match.binding
+        this.pendingChords.push(chord)
+        this.emitPendingChange()
+        this.startTimeout(match.binding)
+        return { type: 'pending' }
+      }
+
+      case 'none': {
+        // If we were mid-sequence, try the chord from root
+        if (this.currentNode !== null) {
+          this.resetState()
+          return this.feed(chord)
+        }
+        return { type: 'passthrough' }
+      }
+    }
+  }
+
+  reset(): void {
+    this.clearTimeout()
+    this.resetState()
+  }
+
+  setTimeoutCallback(cb: (binding: TrieBinding) => void): void {
+    this.onTimeout = cb
+  }
+
+  setPendingChangeCallback(cb: (chords: KeyChord[] | null) => void): void {
+    this.onPendingChange = cb
+  }
+
+  private resetState(): void {
+    const hadPending = this.pendingChords.length > 0
+    this.currentNode = null
+    this.pendingBinding = null
+    this.pendingChords = []
+    if (hadPending) this.emitPendingChange()
+  }
+
+  private emitPendingChange(): void {
+    if (!this.onPendingChange) return
+    this.onPendingChange(this.pendingChords.length === 0 ? null : [...this.pendingChords])
+  }
+
+  private clearTimeout(): void {
+    if (this.timeoutHandle !== null) {
+      clearTimeout(this.timeoutHandle)
+      this.timeoutHandle = null
+    }
+  }
+
+  private startTimeout(binding: TrieBinding): void {
+    this.timeoutHandle = setTimeout(() => {
+      this.timeoutHandle = null
+      this.resetState()
+      this.onTimeout?.(binding)
+    }, this.config.timeoutMs)
+  }
+}