@brimveyn/aimux 1.1.0

package/src/app-runtime/side-effects.ts

@@ -0,0 +1,434 @@
+import type { SideEffect } from '../input/modes/types'
+import type { SessionBackend } from '../session-backend/types'
+import type { AppAction, AppState, AssistantId, TabSession } from '../state/types'
+
+import { loadConfig, saveConfig } from '../config'
+import { logInputDebug } from '../debug/input-log'
+import { createPrefixedId } from '../platform/id'
+import {
+  getAllAssistantOptions,
+  getAssistantOption,
+  isCommandAvailable,
+  parseCommand,
+} from '../pty/command-registry'
+import { createTerminalBounds } from '../state/layout-resize'
+import {
+  allLeafIds,
+  computePaneRects,
+  createLeaf,
+  getGroupIdForTab,
+  getTreeForTab,
+  PANE_BORDER,
+  type SplitDirection,
+  splitNode,
+} from '../state/layout-tree'
+import { filterSessions, filterSnippets } from '../state/selectors'
+import { createDefaultTerminalModes } from '../state/terminal-modes'
+import { saveCurrentWorkspace } from '../state/workspace-save'
+import { applyTheme } from '../ui/theme'
+import { THEME_IDS, type ThemeId } from '../ui/themes'
+import {
+  handleCreateSessionEffect,
+  handleDeleteSessionEffect,
+  handleRenameSessionEffect,
+  handleSwitchSessionEffect,
+  restartTabSession,
+} from './session-actions'
+import {
+  handleDeleteSnippetEffect,
+  handleSaveSnippetEditorEffect,
+  pasteSnippetToTab,
+} from './snippet-actions'
+
+const STARTUP_GRACE_MS = 5_000
+
+export interface SideEffectContext {
+  state: AppState
+  dispatch: (action: AppAction) => void
+  backend: SessionBackend
+  renderer: { destroy(): void }
+  themeId: ThemeId
+  setThemeId: (id: ThemeId) => void
+  activeTab: TabSession | undefined
+  clearIdleTimer: (tabId: string) => void
+  clearStartupGrace: (tabId: string) => void
+  startStartupGrace: (tabId: string, timeoutMs: number) => void
+  getCurrentSessionProjectPath: () => string | undefined
+}
+
+function getSelectedAssistantOption(state: AppState) {
+  return (
+    getAllAssistantOptions(state.customCommands)[state.modal.selectedIndex] ?? getAssistantOption(0)
+  )
+}
+
+function handleSessionSelection(ctx: SideEffectContext): void {
+  const { backend, dispatch, state } = ctx
+  const selectedSession = getSelectedSession(state)
+  logInputDebug('app.sessionPicker.confirm', {
+    creatingNew: !selectedSession,
+    selectedIndex: state.modal.selectedIndex,
+    selectedSessionId: selectedSession?.id ?? null,
+  })
+
+  if (selectedSession) {
+    handleSwitchSessionEffect(state, backend, dispatch, selectedSession)
+    return
+  }
+
+  dispatch({ type: 'open-create-session-modal' })
+}
+
+function handleSelectedSessionDelete(ctx: SideEffectContext): void {
+  const { backend, dispatch, state } = ctx
+  const selectedSession = getSelectedSession(state)
+  logInputDebug('app.sessionPicker.deleteSelected', {
+    selectedIndex: state.modal.selectedIndex,
+    selectedSessionId: selectedSession?.id ?? null,
+  })
+
+  if (selectedSession) {
+    handleDeleteSessionEffect(state, backend, dispatch, selectedSession.id)
+  }
+}
+
+function openSelectedSessionRename(ctx: SideEffectContext): void {
+  const { dispatch, state } = ctx
+  const selectedSession = getSelectedSession(state)
+  if (!selectedSession) {
+    return
+  }
+
+  logInputDebug('app.sessionPicker.openRenameModal', {
+    selectedIndex: state.modal.selectedIndex,
+    selectedSessionId: selectedSession.id,
+  })
+  dispatch({
+    initialName: selectedSession.name,
+    sessionTargetId: selectedSession.id,
+    type: 'open-session-name-modal',
+  })
+}
+
+function pasteSnippetToActiveGroup(ctx: SideEffectContext): void {
+  const { activeTab, backend, state } = ctx
+  const snippet = getSelectedSnippet(state)
+  if (!snippet || !state.activeTabId) {
+    return
+  }
+
+  const groupId = getGroupIdForTab(state.tabGroupMap, state.activeTabId)
+  const groupTree = groupId ? state.layoutTrees[groupId] : null
+  if (!groupTree) {
+    pasteSnippetToTab(backend, state.activeTabId, activeTab, snippet)
+    return
+  }
+
+  for (const tabId of allLeafIds(groupTree)) {
+    const tab = state.tabs.find((entry) => entry.id === tabId)
+    if (tab) {
+      pasteSnippetToTab(backend, tabId, tab, snippet)
+    }
+  }
+}
+
+function saveCustomCommandSelection(state: AppState): void {
+  const option = getAllAssistantOptions(state.customCommands)[state.modal.selectedIndex]
+  if (!option || state.modal.editBuffer === null) {
+    return
+  }
+
+  const trimmed = state.modal.editBuffer.trim()
+  const newCustomCommands = { ...state.customCommands }
+  if (trimmed) {
+    newCustomCommands[option.id] = trimmed
+  } else {
+    delete newCustomCommands[option.id]
+  }
+
+  saveConfig({
+    ...loadConfig(),
+    customCommands: newCustomCommands,
+  })
+}
+
+function applyThemeEffect(
+  effect: Extract<SideEffect, { type: 'apply-theme' }>,
+  ctx: SideEffectContext
+): void {
+  const { state } = ctx
+
+  switch (effect.action) {
+    case 'open':
+      applyTheme(THEME_IDS[0] ?? 'aimux')
+      return
+    case 'restore':
+      applyTheme(ctx.themeId)
+      return
+    case 'confirm': {
+      const selectedId = THEME_IDS[state.modal.selectedIndex]
+      if (selectedId) {
+        applyTheme(selectedId)
+        ctx.setThemeId(selectedId)
+        saveConfig({ ...loadConfig(), themeId: selectedId })
+      }
+      return
+    }
+    case 'preview': {
+      const count = THEME_IDS.length
+      const nextIndex = (state.modal.selectedIndex + effect.delta + count) % count
+      const previewId = THEME_IDS[nextIndex]
+      if (previewId) {
+        applyTheme(previewId)
+      }
+      return
+    }
+  }
+}
+
+function confirmSplitSelection(ctx: SideEffectContext): void {
+  const { dispatch, state } = ctx
+  const option = getSelectedAssistantOption(state)
+  const direction = state.modal.type === 'split-picker' ? state.modal.splitDirection : 'vertical'
+  const customCommand = state.customCommands[option.id]
+  const tab = createTabSession(option.id, customCommand, state.customCommands)
+  dispatch({ type: 'close-modal' })
+  executeSplitPane(ctx, direction, tab)
+  dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
+}
+
+function createTabId(): string {
+  return createPrefixedId('tab')
+}
+
+function getSelectedSession(state: AppState) {
+  const filter = state.modal.type === 'session-picker' ? state.modal.editBuffer : null
+  return filterSessions(state.sessions, filter)[state.modal.selectedIndex]
+}
+
+function getSelectedSnippet(state: AppState) {
+  const filter = state.modal.type === 'snippet-picker' ? state.modal.editBuffer : null
+  return filterSnippets(state.snippets, filter)[state.modal.selectedIndex]
+}
+
+export function createTabSession(
+  assistant: AssistantId,
+  customCommand?: string,
+  customCommands?: Record<string, string>
+): TabSession {
+  const allOptions = getAllAssistantOptions(customCommands ?? {})
+  const option = allOptions.find((o) => o.id === assistant) ?? getAssistantOption(0)
+
+  return {
+    activity: 'idle',
+    assistant,
+    buffer: '',
+    command: customCommand ?? option.command,
+    id: createTabId(),
+    status: 'starting',
+    terminalModes: createDefaultTerminalModes(),
+    title: option.label,
+  }
+}
+
+export function startTabSession(
+  backend: SessionBackend,
+  dispatch: (action: AppAction) => void,
+  clearStartupGrace: (tabId: string) => void,
+  startStartupGrace: (tabId: string) => void,
+  tab: Pick<TabSession, 'id' | 'assistant' | 'title' | 'command'>,
+  cols: number,
+  rows: number,
+  cwd?: string
+): void {
+  startStartupGrace(tab.id)
+
+  const { args, executable } = parseCommand(tab.command)
+
+  if (!isCommandAvailable(executable)) {
+    clearStartupGrace(tab.id)
+    dispatch({
+      message: `[command not found] ${executable} is not available in PATH.`,
+      tabId: tab.id,
+      type: 'set-tab-error',
+    })
+    return
+  }
+
+  backend.createSession({
+    args,
+    assistant: tab.assistant,
+    cols,
+    command: executable,
+    cwd,
+    rows,
+    tabId: tab.id,
+    title: tab.title,
+  })
+}
+
+function launchAssistant(ctx: SideEffectContext, assistant: AssistantId): void {
+  const { backend, clearStartupGrace, dispatch, startStartupGrace, state } = ctx
+  const customCommand = state.customCommands[assistant]
+  const tab = createTabSession(assistant, customCommand, state.customCommands)
+  logInputDebug('app.launchAssistant', {
+    assistant,
+    command: tab.command,
+    tabId: tab.id,
+  })
+  dispatch({ tab, type: 'add-tab' })
+  startTabSession(
+    backend,
+    dispatch,
+    clearStartupGrace,
+    (tabId) => startStartupGrace(tabId, STARTUP_GRACE_MS),
+    tab,
+    state.layout.terminalCols,
+    state.layout.terminalRows,
+    ctx.getCurrentSessionProjectPath()
+  )
+}
+
+function startExistingTab(ctx: SideEffectContext, tab: TabSession): void {
+  const { backend, clearStartupGrace, dispatch, startStartupGrace, state } = ctx
+  startTabSession(
+    backend,
+    dispatch,
+    clearStartupGrace,
+    (tabId) => startStartupGrace(tabId, STARTUP_GRACE_MS),
+    tab,
+    state.layout.terminalCols,
+    state.layout.terminalRows,
+    ctx.getCurrentSessionProjectPath()
+  )
+}
+
+function executeSplitPane(
+  ctx: SideEffectContext,
+  direction: SplitDirection,
+  tab: TabSession
+): void {
+  const { backend, clearStartupGrace, dispatch, startStartupGrace, state } = ctx
+  const activeTabId = state.activeTabId
+  if (!activeTabId) {
+    return
+  }
+
+  const existingTree = getTreeForTab(state.layoutTrees, state.tabGroupMap, activeTabId)
+  const baseTree = existingTree ?? createLeaf(activeTabId)
+  const newTree = splitNode(baseTree, activeTabId, direction, tab.id)
+  const bounds = createTerminalBounds(state.layout.terminalCols, state.layout.terminalRows)
+  const paneRect = computePaneRects(newTree, bounds).get(tab.id)
+
+  dispatch({ direction, newTab: tab, type: 'split-pane' })
+  startTabSession(
+    backend,
+    dispatch,
+    clearStartupGrace,
+    (tabId) => startStartupGrace(tabId, STARTUP_GRACE_MS),
+    tab,
+    Math.max(1, (paneRect?.cols ?? state.layout.terminalCols) - PANE_BORDER * 2),
+    Math.max(1, (paneRect?.rows ?? state.layout.terminalRows) - PANE_BORDER * 2),
+    ctx.getCurrentSessionProjectPath()
+  )
+}
+
+export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): void {
+  const { backend, dispatch, state } = ctx
+
+  switch (effect.type) {
+    case 'quit': {
+      saveCurrentWorkspace(effect.state)
+      void backend.destroy(true)
+      ctx.renderer.destroy()
+      process.exit(0)
+      return
+    }
+    case 'launch-selected-assistant': {
+      const option = getSelectedAssistantOption(state)
+      launchAssistant(ctx, option.id)
+      return
+    }
+    case 'confirm-selected-session': {
+      handleSessionSelection(ctx)
+      return
+    }
+    case 'delete-selected-session': {
+      handleSelectedSessionDelete(ctx)
+      return
+    }
+    case 'open-rename-selected-session': {
+      openSelectedSessionRename(ctx)
+      return
+    }
+    case 'create-session':
+      handleCreateSessionEffect(state, dispatch, effect.name, effect.projectPath)
+      return
+    case 'close-tab': {
+      ctx.clearIdleTimer(effect.tabId)
+      ctx.clearStartupGrace(effect.tabId)
+      backend.disposeSession(effect.tabId)
+      return
+    }
+    case 'restart-tab':
+      restartTabSession(
+        backend,
+        dispatch,
+        ctx.clearIdleTimer,
+        ctx.clearStartupGrace,
+        (tab) => startExistingTab(ctx, tab),
+        effect.tab
+      )
+      return
+    case 'paste-selected-snippet': {
+      pasteSnippetToTab(backend, state.activeTabId, ctx.activeTab, getSelectedSnippet(state))
+      return
+    }
+    case 'paste-snippet-to-group': {
+      pasteSnippetToActiveGroup(ctx)
+      return
+    }
+    case 'edit-selected-snippet': {
+      const snippet = getSelectedSnippet(state)
+      if (snippet) {
+        dispatch({ snippetId: snippet.id, type: 'open-snippet-editor' })
+      }
+      return
+    }
+    case 'delete-selected-snippet': {
+      const snippet = getSelectedSnippet(state)
+      if (snippet) {
+        handleDeleteSnippetEffect(state.snippets, dispatch, snippet.id)
+      }
+      return
+    }
+    case 'save-snippet-editor': {
+      handleSaveSnippetEditorEffect(state, dispatch)
+      return
+    }
+    case 'save-custom-command': {
+      saveCustomCommandSelection(state)
+      return
+    }
+    case 'apply-theme': {
+      applyThemeEffect(effect, ctx)
+      return
+    }
+    case 'rename-session': {
+      handleRenameSessionEffect(state.sessions, dispatch, effect.sessionId, effect.name)
+      return
+    }
+    case 'split-pane': {
+      const customCommand = state.customCommands.terminal
+      const tab = createTabSession('terminal', customCommand, state.customCommands)
+      executeSplitPane(ctx, effect.direction, tab)
+      return
+    }
+    case 'confirm-split': {
+      confirmSplitSelection(ctx)
+      return
+    }
+    default:
+      effect satisfies never
+  }
+}

package/src/app-runtime/snippet-actions.ts

@@ -0,0 +1,90 @@
+import type { SessionBackend } from '../session-backend/types'
+import type { AppAction, AppState, SnippetRecord, TabSession } from '../state/types'
+
+import { createPrefixedId } from '../platform/id'
+import { saveSnippetCatalog } from '../state/snippet-catalog'
+import { writePasteToTab } from './pty-write'
+
+function createSnippetId(): string {
+  return createPrefixedId('snip')
+}
+
+export function getSnippetEditorValue(state: AppState): { name: string; content: string } | null {
+  if (state.modal.type !== 'snippet-editor') {
+    return null
+  }
+
+  const { modal } = state
+  const name =
+    modal.activeField === 'name' ? (modal.editBuffer ?? '').trim() : modal.contentBuffer.trim()
+  const content =
+    modal.activeField === 'content' ? (modal.editBuffer ?? '').trim() : modal.contentBuffer.trim()
+
+  return { content, name }
+}
+
+export function saveSnippetEditorState(state: AppState): SnippetRecord[] | null {
+  const editorValue = getSnippetEditorValue(state)
+  if (
+    !editorValue ||
+    !editorValue.name ||
+    !editorValue.content ||
+    state.modal.type !== 'snippet-editor'
+  ) {
+    return null
+  }
+
+  const snippetId = state.modal.sessionTargetId
+  if (snippetId) {
+    return state.snippets.map((snippet) =>
+      snippet.id === snippetId
+        ? { ...snippet, content: editorValue.content, name: editorValue.name }
+        : snippet
+    )
+  }
+
+  return [
+    ...state.snippets,
+    { content: editorValue.content, id: createSnippetId(), name: editorValue.name },
+  ]
+}
+
+export function deleteSnippetState(snippets: SnippetRecord[], snippetId: string): SnippetRecord[] {
+  return snippets.filter((snippet) => snippet.id !== snippetId)
+}
+
+export function pasteSnippetToTab(
+  backend: SessionBackend,
+  activeTabId: string | null,
+  activeTab: TabSession | undefined,
+  snippet: SnippetRecord | undefined
+): void {
+  if (!snippet || !activeTabId || !activeTab) {
+    return
+  }
+
+  writePasteToTab(backend, activeTabId, activeTab, snippet.content)
+}
+
+export function handleDeleteSnippetEffect(
+  snippets: SnippetRecord[],
+  dispatch: (action: AppAction) => void,
+  snippetId: string
+): void {
+  const updated = deleteSnippetState(snippets, snippetId)
+  saveSnippetCatalog(updated)
+  dispatch({ snippetId, type: 'delete-snippet' })
+}
+
+export function handleSaveSnippetEditorEffect(
+  state: AppState,
+  dispatch: (action: AppAction) => void
+): void {
+  const updated = saveSnippetEditorState(state)
+  if (!updated) {
+    return
+  }
+
+  saveSnippetCatalog(updated)
+  dispatch({ snippets: updated, type: 'set-snippets' })
+}

package/src/app-runtime/split-drag-controller.ts

@@ -0,0 +1,15 @@
+import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
+
+import type { SplitDirection } from '../state/layout-tree'
+
+export interface SplitDragState {
+  tabId: string
+  direction: SplitDirection
+  screenStart: number
+  totalSize: number
+}
+
+export function getSplitRatioFromDrag(event: OtuiMouseEvent, drag: SplitDragState): number {
+  const position = drag.direction === 'vertical' ? event.x : event.y
+  return (position - drag.screenStart) / drag.totalSize
+}

package/src/app-runtime/tab-runtime-timeouts.ts

@@ -0,0 +1,86 @@
+import { useCallback, useRef } from 'react'
+
+import type { AppAction } from '../state/types'
+
+export interface TabRuntimeTimeouts {
+  clearIdleTimer: (tabId: string) => void
+  clearStartupGrace: (tabId: string) => void
+  startStartupGrace: (tabId: string, timeoutMs: number) => void
+  isStartupGraceActive: (tabId: string) => boolean
+  scheduleIdle: (tabId: string, timeoutMs: number) => void
+  clearAllTimers: () => void
+}
+
+function clearTimeoutRegistry(timeouts: Map<string, ReturnType<typeof setTimeout>>): void {
+  for (const timeout of timeouts.values()) {
+    clearTimeout(timeout)
+  }
+
+  timeouts.clear()
+}
+
+export function useTabRuntimeTimeouts(dispatch: (action: AppAction) => void): TabRuntimeTimeouts {
+  const idleTimeoutsRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map())
+  const startupGraceTimeoutsRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map())
+
+  const clearIdleTimer = useCallback((tabId: string): void => {
+    const timeout = idleTimeoutsRef.current.get(tabId)
+    if (!timeout) {
+      return
+    }
+
+    clearTimeout(timeout)
+    idleTimeoutsRef.current.delete(tabId)
+  }, [])
+
+  const clearStartupGrace = useCallback((tabId: string): void => {
+    const timeout = startupGraceTimeoutsRef.current.get(tabId)
+    if (!timeout) {
+      return
+    }
+
+    clearTimeout(timeout)
+    startupGraceTimeoutsRef.current.delete(tabId)
+  }, [])
+
+  const startStartupGrace = useCallback(
+    (tabId: string, timeoutMs: number): void => {
+      clearStartupGrace(tabId)
+      const timeout = setTimeout(() => {
+        startupGraceTimeoutsRef.current.delete(tabId)
+      }, timeoutMs)
+      startupGraceTimeoutsRef.current.set(tabId, timeout)
+    },
+    [clearStartupGrace]
+  )
+
+  const isStartupGraceActive = useCallback((tabId: string): boolean => {
+    return startupGraceTimeoutsRef.current.has(tabId)
+  }, [])
+
+  const scheduleIdle = useCallback(
+    (tabId: string, timeoutMs: number): void => {
+      clearIdleTimer(tabId)
+      const timeout = setTimeout(() => {
+        dispatch({ activity: 'idle', tabId, type: 'set-tab-activity' })
+        idleTimeoutsRef.current.delete(tabId)
+      }, timeoutMs)
+      idleTimeoutsRef.current.set(tabId, timeout)
+    },
+    [clearIdleTimer, dispatch]
+  )
+
+  const clearAllTimers = useCallback((): void => {
+    clearTimeoutRegistry(idleTimeoutsRef.current)
+    clearTimeoutRegistry(startupGraceTimeoutsRef.current)
+  }, [])
+
+  return {
+    clearAllTimers,
+    clearIdleTimer,
+    clearStartupGrace,
+    isStartupGraceActive,
+    scheduleIdle,
+    startStartupGrace,
+  }
+}

package/src/app-runtime/terminal-mouse-adapter.ts

@@ -0,0 +1,31 @@
+import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
+
+import type { TerminalContentOrigin } from '../input/raw-input-handler'
+
+import { encodeMouseEventForPty } from '../input/mouse-forwarding'
+
+export const SCROLL_LINES_PER_WHEEL_STEP = 3
+
+export function getForwardedMouseSequence(
+  event: OtuiMouseEvent,
+  origin: TerminalContentOrigin
+): string | null {
+  return encodeMouseEventForPty(event, origin)
+}
+
+export function getScrollViewportDelta(event: OtuiMouseEvent): number | null {
+  if (event.type !== 'scroll') {
+    return null
+  }
+
+  const direction = event.scroll?.direction
+  if (direction === 'up') {
+    return -SCROLL_LINES_PER_WHEEL_STEP
+  }
+
+  if (direction === 'down') {
+    return SCROLL_LINES_PER_WHEEL_STEP
+  }
+
+  return null
+}