@brimveyn/aimux 1.1.0

package/src/state/session-persistence.ts

@@ -0,0 +1,210 @@
+import type { AppState, TabSession, TabStatus, WorkspaceSnapshotV1 } from './types'
+
+import {
+  allLeafIds,
+  createGroupId,
+  createLeaf,
+  type LayoutNode,
+  pruneLayoutTree,
+} from './layout-tree'
+
+export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
+  return {
+    activeTabId: null,
+    savedAt: new Date().toISOString(),
+    sidebar: {
+      visible: true,
+      width: 28,
+    },
+    tabs: [],
+    version: 1,
+  }
+}
+
+function getDisconnectedStatus(status: WorkspaceSnapshotV1['tabs'][number]['status']): TabStatus {
+  if (status === 'running' || status === 'starting') {
+    return 'disconnected'
+  }
+
+  return status
+}
+
+export function serializeWorkspace(state: AppState): WorkspaceSnapshotV1 {
+  return {
+    activeTabId: state.activeTabId,
+    layoutTree: Object.values(state.layoutTrees)[0] ?? undefined,
+    layoutTrees: Object.keys(state.layoutTrees).length > 0 ? state.layoutTrees : undefined,
+    savedAt: new Date().toISOString(),
+    sidebar: {
+      visible: state.sidebar.visible,
+      width: state.sidebar.width,
+    },
+    tabGroupMap: Object.keys(state.tabGroupMap).length > 0 ? state.tabGroupMap : undefined,
+    tabs: state.tabs.map((tab) => ({
+      assistant: tab.assistant,
+      buffer: tab.buffer,
+      command: tab.command,
+      errorMessage: tab.errorMessage,
+      exitCode: tab.exitCode,
+      id: tab.id,
+      status: tab.status === 'disconnected' ? 'running' : tab.status,
+      terminalModes: tab.terminalModes,
+      title: tab.title,
+      viewport: tab.viewport,
+    })),
+    version: 1,
+  }
+}
+
+export function restoreTabsFromWorkspace(snapshot: WorkspaceSnapshotV1 | undefined): TabSession[] {
+  if (!snapshot || snapshot.version !== 1) {
+    return []
+  }
+
+  return snapshot.tabs.map((tab) => ({
+    activity: 'idle',
+    assistant: tab.assistant,
+    buffer: tab.buffer,
+    command: tab.command,
+    errorMessage: tab.errorMessage,
+    exitCode: tab.exitCode,
+    id: tab.id,
+    status: getDisconnectedStatus(tab.status),
+    terminalModes: tab.terminalModes,
+    title: tab.title,
+    viewport: tab.viewport,
+  }))
+}
+
+export function restoreLayoutTree(
+  snapshot: WorkspaceSnapshotV1 | undefined,
+  tabs: TabSession[]
+): LayoutNode | null {
+  if (snapshot?.layoutTree) {
+    const validTabIds = new Set(tabs.map((t) => t.id))
+    const pruned = pruneLayoutTree(snapshot.layoutTree, validTabIds)
+    if (pruned) return pruned
+  }
+  // Fallback: single leaf for the first tab
+  return tabs[0] ? createLeaf(tabs[0].id) : null
+}
+
+export function restoreLayoutTrees(
+  snapshot: WorkspaceSnapshotV1 | undefined,
+  tabs: TabSession[]
+): { layoutTrees: Record<string, LayoutNode>; tabGroupMap: Record<string, string> } {
+  const validTabIds = new Set(tabs.map((t) => t.id))
+  const layoutTrees: Record<string, LayoutNode> = {}
+  const tabGroupMap: Record<string, string> = {}
+
+  if (snapshot?.layoutTrees && snapshot?.tabGroupMap) {
+    // New format
+    for (const [gId, tree] of Object.entries(snapshot.layoutTrees)) {
+      const pruned = pruneLayoutTree(tree, validTabIds)
+      if (pruned && pruned.type === 'split') {
+        layoutTrees[gId] = pruned
+        for (const leafId of allLeafIds(pruned)) {
+          tabGroupMap[leafId] = gId
+        }
+      }
+    }
+  } else if (snapshot?.layoutTree) {
+    // Legacy migration
+    const pruned = pruneLayoutTree(snapshot.layoutTree, validTabIds)
+    if (pruned && pruned.type === 'split') {
+      const gId = createGroupId()
+      layoutTrees[gId] = pruned
+      for (const leafId of allLeafIds(pruned)) {
+        tabGroupMap[leafId] = gId
+      }
+    }
+  }
+
+  return { layoutTrees, tabGroupMap }
+}
+
+export function normalizeGroupedTabOrder(
+  tabs: TabSession[],
+  layoutTrees: Record<string, LayoutNode>,
+  tabGroupMap: Record<string, string>
+): TabSession[] {
+  const groupedTabsByGroupId = new Map<string, TabSession[]>()
+  const emittedGroupIds = new Set<string>()
+  const orderedTabs: TabSession[] = []
+
+  for (const tab of tabs) {
+    const groupId = tabGroupMap[tab.id]
+    if (!groupId) {
+      continue
+    }
+
+    const groupTree = layoutTrees[groupId]
+    if (!groupTree || groupTree.type !== 'split') {
+      continue
+    }
+
+    const groupedTabs = groupedTabsByGroupId.get(groupId)
+    if (groupedTabs) {
+      groupedTabs.push(tab)
+      continue
+    }
+
+    groupedTabsByGroupId.set(groupId, [tab])
+  }
+
+  for (const tab of tabs) {
+    const groupId = tabGroupMap[tab.id]
+    const groupTree = groupId ? layoutTrees[groupId] : undefined
+
+    if (!groupId || !groupTree || groupTree.type !== 'split') {
+      orderedTabs.push(tab)
+      continue
+    }
+
+    if (emittedGroupIds.has(groupId)) {
+      continue
+    }
+
+    emittedGroupIds.add(groupId)
+    const groupedTabs = groupedTabsByGroupId.get(groupId)
+    if (!groupedTabs) {
+      continue
+    }
+
+    for (const groupTab of groupedTabs) {
+      orderedTabs.push(groupTab)
+    }
+  }
+
+  return orderedTabs
+}
+
+export function restoreWorkspaceState(
+  state: AppState,
+  workspaceSnapshot: WorkspaceSnapshotV1 | undefined
+): Pick<
+  AppState,
+  'tabs' | 'activeTabId' | 'focusMode' | 'sidebar' | 'layoutTrees' | 'tabGroupMap'
+> {
+  const tabs = restoreTabsFromWorkspace(workspaceSnapshot)
+  const activeTabId =
+    workspaceSnapshot?.activeTabId && tabs.some((tab) => tab.id === workspaceSnapshot.activeTabId)
+      ? workspaceSnapshot.activeTabId
+      : (tabs[0]?.id ?? null)
+
+  const { layoutTrees, tabGroupMap } = restoreLayoutTrees(workspaceSnapshot, tabs)
+  const orderedTabs = normalizeGroupedTabOrder(tabs, layoutTrees, tabGroupMap)
+
+  return {
+    activeTabId,
+    focusMode: 'navigation',
+    layoutTrees,
+    sidebar: {
+      ...state.sidebar,
+      visible: workspaceSnapshot?.sidebar.visible ?? state.sidebar.visible,
+      width: workspaceSnapshot?.sidebar.width ?? state.sidebar.width,
+    },
+    tabGroupMap,
+    tabs: orderedTabs,
+  }
+}

package/src/state/snippet-catalog.ts

@@ -0,0 +1,90 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import { CONFIG_PATH } from '../config'
+import { logDebug } from '../debug/input-log'
+import { isSnippetRecord } from './validation'
+
+export interface SnippetRecord {
+  id: string
+  name: string
+  content: string
+}
+
+const SNIPPETS_PATH = join(dirname(CONFIG_PATH), 'aimux-snippets.json')
+
+const DEFAULT_SNIPPETS: SnippetRecord[] = [
+  {
+    content: 'Review this code for bugs, security issues, and suggest improvements.',
+    id: 'default-review',
+    name: 'Code review',
+  },
+  {
+    content: 'Explain how this code works step by step.',
+    id: 'default-explain',
+    name: 'Explain',
+  },
+  {
+    content: 'Write comprehensive unit tests for this code with edge cases.',
+    id: 'default-tests',
+    name: 'Write tests',
+  },
+  {
+    content:
+      'Refactor this code to improve readability and maintainability without changing behavior.',
+    id: 'default-refactor',
+    name: 'Refactor',
+  },
+  {
+    content: 'Analyze this error and provide a fix with explanation.',
+    id: 'default-fix',
+    name: 'Fix error',
+  },
+]
+
+export function loadSnippetCatalog(): SnippetRecord[] {
+  try {
+    if (!existsSync(SNIPPETS_PATH)) {
+      saveSnippetCatalog(DEFAULT_SNIPPETS)
+      return DEFAULT_SNIPPETS
+    }
+    const parsed = JSON.parse(readFileSync(SNIPPETS_PATH, 'utf8')) as {
+      version?: unknown
+      snippets?: unknown
+    }
+    if (parsed.version !== 1 || !Array.isArray(parsed.snippets)) {
+      logDebug('snippets.catalog.loadIssue', {
+        issue: 'invalid snippet catalog header',
+        path: SNIPPETS_PATH,
+      })
+      return []
+    }
+    if (!parsed.snippets.every(isSnippetRecord)) {
+      logDebug('snippets.catalog.loadIssue', {
+        issue: 'invalid snippet catalog entries',
+        path: SNIPPETS_PATH,
+      })
+      return []
+    }
+    return parsed.snippets
+  } catch (error) {
+    logDebug('snippets.catalog.loadIssue', {
+      issue: error instanceof Error ? error.message : String(error),
+      path: SNIPPETS_PATH,
+    })
+    return []
+  }
+}
+
+export function saveSnippetCatalog(snippets: SnippetRecord[]): void {
+  try {
+    mkdirSync(dirname(SNIPPETS_PATH), { recursive: true })
+    writeFileSync(SNIPPETS_PATH, `${JSON.stringify({ snippets, version: 1 }, null, 2)}\n`)
+  } catch (error) {
+    logDebug('snippets.catalog.saveError', {
+      error: error instanceof Error ? error.message : String(error),
+      path: SNIPPETS_PATH,
+      snippetCount: snippets.length,
+    })
+  }
+}

package/src/state/store.ts

@@ -0,0 +1,93 @@
+import type { AppAction, AppState, SessionRecord, SnippetRecord } from './types'
+
+import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
+import { emptyModal, reduceModalState } from './reducers/modal-state'
+import { reduceSessionState } from './reducers/session-state'
+import { reduceTabState } from './reducers/tab-state'
+import { reduceUIState } from './reducers/ui-state'
+import { filterSnippets } from './selectors'
+
+const DEFAULT_SIDEBAR_WIDTH = 28
+const DEFAULT_SIDEBAR_MIN_WIDTH = 18
+const DEFAULT_SIDEBAR_MAX_WIDTH = 42
+const DEFAULT_TERMINAL_COLS = 80
+const DEFAULT_TERMINAL_ROWS = 24
+
+export interface InitialStateOverrides {
+  gitPanelVisible?: boolean
+  gitPanelRatio?: number
+}
+
+export function createInitialState(
+  customCommands: Record<string, string> = {},
+  sessions: SessionRecord[] = [],
+  snippets: SnippetRecord[] = [],
+  showSessionPicker = false,
+  overrides: InitialStateOverrides = {}
+): AppState {
+  return {
+    activeTabId: null,
+    currentSessionId: null,
+    customCommands,
+    focusMode: showSessionPicker ? 'modal' : 'navigation',
+    gitPanel: emptyGitPanel(),
+    layout: {
+      terminalCols: DEFAULT_TERMINAL_COLS,
+      terminalRows: DEFAULT_TERMINAL_ROWS,
+    },
+    layoutTrees: {},
+    modal: showSessionPicker
+      ? { editBuffer: null, selectedIndex: 0, sessionTargetId: null, type: 'session-picker' }
+      : emptyModal(),
+    pendingChords: null,
+    sessions,
+    sidebar: {
+      gitPanelRatio: overrides.gitPanelRatio ?? 0.5,
+      gitPanelVisible: overrides.gitPanelVisible ?? true,
+      maxWidth: DEFAULT_SIDEBAR_MAX_WIDTH,
+      minWidth: DEFAULT_SIDEBAR_MIN_WIDTH,
+      visible: true,
+      width: DEFAULT_SIDEBAR_WIDTH,
+    },
+    snippets,
+    tabGroupMap: {},
+    tabs: [],
+  }
+}
+
+export function appReducer(state: AppState, action: AppAction): AppState {
+  const sessionState = reduceSessionState(state, action)
+  if (sessionState) return sessionState
+
+  const tabState = reduceTabState(state, action)
+  if (tabState) return tabState
+
+  const modalState = reduceModalState(state, action)
+  if (modalState) return modalState
+
+  const uiState = reduceUIState(state, action)
+  if (uiState) return uiState
+
+  const gitPanelState = reduceGitPanelState(state, action)
+  if (gitPanelState) return gitPanelState
+
+  switch (action.type) {
+    case 'set-snippets':
+      return { ...state, snippets: action.snippets }
+    case 'delete-snippet': {
+      const newSnippets = state.snippets.filter((s) => s.id !== action.snippetId)
+      const filteredNew = filterSnippets(newSnippets, state.modal.editBuffer)
+      const maxIndex = Math.max(0, filteredNew.length - 1)
+      return {
+        ...state,
+        modal: {
+          ...state.modal,
+          selectedIndex: Math.min(state.modal.selectedIndex, maxIndex),
+        },
+        snippets: newSnippets,
+      }
+    }
+    default:
+      return state
+  }
+}

package/src/state/terminal-modes.ts

@@ -0,0 +1,11 @@
+import type { TerminalModeState } from './types'
+
+export function createDefaultTerminalModes(): TerminalModeState {
+  return {
+    alternateScrollMode: false,
+    bracketedPasteMode: false,
+    isAlternateBuffer: false,
+    mouseTrackingMode: 'none',
+    sendFocusMode: false,
+  }
+}