@brimveyn/aimux 1.20.4 → 1.22.0

package/src/state/actions.ts

@@ -0,0 +1,342 @@
+// Every action the reducer accepts, grouped by the slice of state it touches.
+//
+// Split from `types.ts` so the state shapes and the messages that change them
+// are separate files: the shapes are read by the whole app, this union only by
+// the reducer and the things that dispatch into it.
+
+import type { ModeId } from '@brimveyn/aimux-config'
+
+import type { LayoutNode, SplitDirection } from './layout-tree'
+import type {
+  AssistantId,
+  BarSide,
+  BranchDivergence,
+  DiffData,
+  DirectoryResult,
+  DiscoveredRepo,
+  FocusMode,
+  GitFileSection,
+  GitPanelError,
+  GitPaneState,
+  GitRefreshPayload,
+  PendingWorkspaceLaunch,
+  ProjectRecord,
+  ProjectSnapshotV1,
+  ProjectStatus,
+  SnippetRecord,
+  TabActivity,
+  TabSession,
+  TerminalModeState,
+  TerminalSnapshot,
+  WorkspaceRecord,
+} from './types'
+
+export type ModalAction =
+  | { type: 'move-modal-cursor'; delta?: number; to?: 'home' | 'end' }
+  | {
+      type: 'open-new-tab-modal'
+      pendingWorkspace?: PendingWorkspaceLaunch
+      pendingPrompt?: string
+    }
+  | { type: 'open-edit-custom-command'; assistantId: AssistantId }
+  | { type: 'open-help-modal'; scope?: ModeId }
+  | { type: 'open-split-picker'; direction: SplitDirection }
+  | { type: 'open-project-picker' }
+  | {
+      type: 'open-project-name-modal'
+      projectTargetId?: string
+      initialName?: string
+      returnToProjectPicker?: boolean
+    }
+  | { type: 'close-modal' }
+  | { type: 'move-modal-selection'; delta: number }
+  | { type: 'update-command-edit'; char: string }
+  | { type: 'cancel-command-edit' }
+  | { type: 'open-create-project-modal'; returnToProjectPicker: boolean }
+  | { type: 'open-create-workspace-modal' }
+  | { type: 'set-create-workspace-base-branches'; branches: string[]; defaultBranch?: string }
+  | { type: 'set-create-workspace-branch-error'; message: string | null }
+  | { type: 'switch-create-workspace-field' }
+  | { type: 'set-directory-results'; results: DirectoryResult[] }
+  | { type: 'switch-create-project-field' }
+  | { type: 'select-directory' }
+  | { type: 'open-rename-tab-modal' }
+  | {
+      type: 'open-rename-workspace-modal'
+      projectId: string
+      workspaceId: string
+      initialName: string
+    }
+  | { type: 'open-snippet-picker'; returnTo?: FocusMode }
+  | { type: 'open-snippet-editor'; snippetId?: string }
+  | { type: 'set-help-entry-count'; count: number }
+  | { type: 'set-theme-entry-count'; count: number }
+  | { type: 'open-theme-picker'; returnTo?: FocusMode }
+  | { type: 'open-update-available-modal'; currentVersion: string; latestVersion: string }
+  | { type: 'set-modal-selection-index'; index: number }
+  | { type: 'open-ai-usage-modal' }
+  | { type: 'open-workspace-move-modal'; sourceWorkspaceId: string }
+  | { type: 'toggle-workspace-move-delete' }
+  | { type: 'set-workspace-move-stats'; dirtyFiles: Record<string, number> }
+  | {
+      type: 'open-workspace-move-confirm'
+      variant: 'stash-target' | 'keep-conflicts'
+      files: string[]
+      projectId: string
+      sourceWorkspaceId: string
+      targetWorkspaceId: string
+      deleteSource: boolean
+      sourceLabel: string
+      targetLabel: string
+    }
+  | {
+      type: 'open-workspace-delete-confirm'
+      projectId: string
+      workspaceId: string
+      workspaceLabel: string
+      reason: string
+      closeTabs: boolean
+      force: boolean
+    }
+  | { type: 'open-flash-jump-modal' }
+  | { type: 'clear-flash-jump-pending' }
+
+export type ProjectAction =
+  | {
+      type: 'load-project'
+      projectId: string
+      projectSnapshot?: ProjectSnapshotV1
+      forceDisconnected?: boolean
+    }
+  | { type: 'set-projects'; projects: ProjectRecord[] }
+  | { type: 'create-project-record'; project: ProjectRecord }
+  | { type: 'rename-project-record'; projectId: string; name: string }
+  | { type: 'delete-project-record'; projectId: string; openProjectPicker?: boolean }
+  | { type: 'reorder-projects'; orderedIds: string[] }
+  | { type: 'reorder-active-project'; delta: number }
+  | { type: 'set-project-status'; projectId: string; status: ProjectStatus }
+  /** What a workspace's assistants are doing. `done` is owned by the reducer,
+   *  so this carries only the two flags derived from tab statuses. */
+  | { type: 'set-workspace-activity'; workspaceId: string; working: boolean; waiting: boolean }
+  /** An assistant in this workspace finished a turn and nobody has looked yet. */
+  | { type: 'mark-workspace-done'; workspaceId: string }
+  /** The tab that rang: it finished a turn while the user was elsewhere. */
+  | { type: 'mark-tab-unseen'; tabId: string }
+  | {
+      type: 'add-workspace-record'
+      projectId: string
+      workspace: WorkspaceRecord
+      activate?: boolean
+    }
+  | { type: 'set-active-workspace'; projectId: string; workspaceId: string }
+  | {
+      type: 'update-workspace-record'
+      projectId: string
+      workspaceId: string
+      patch: Partial<WorkspaceRecord>
+    }
+
+export type TabAction =
+  | { type: 'add-tab'; tab: TabSession }
+  | {
+      type: 'hydrate-project'
+      tabs: TabSession[]
+      activeTabId: string | null
+      layoutTree?: LayoutNode | null
+      layoutTrees?: Record<string, LayoutNode>
+      tabGroupMap?: Record<string, string>
+    }
+  | { type: 'close-tab'; tabId: string }
+  | { type: 'close-active-tab' }
+  | { type: 'set-active-tab'; tabId: string }
+  | { type: 'move-active-tab'; delta: number }
+  | { type: 'reorder-active-tab'; delta: number }
+  | { type: 'reorder-tabs'; orderedTabIds: string[] }
+  | { type: 'reset-tab-project'; tabId: string }
+  | {
+      type: 'rename-tab'
+      tabId: string
+      title: string
+      autoRenameStatus?: 'eligible' | 'attempted'
+    }
+  | {
+      type: 'update-tab-metadata'
+      tabId: string
+      title?: string
+      autoRenameStatus?: 'eligible' | 'attempted'
+      /** Set to false to promote a hidden tab into the normal tab strip. */
+      hidden?: boolean
+    }
+  | { type: 'append-tab-buffer'; tabId: string; chunk: string }
+  | {
+      type: 'replace-tab-viewport'
+      tabId: string
+      viewport: TerminalSnapshot
+      terminalModes: TerminalModeState
+      source?: 'resize' | 'scroll' | 'data' | 'switch'
+    }
+  | { type: 'set-tab-activity'; tabId: string; activity?: TabActivity }
+  | { type: 'set-tab-error'; tabId: string; message: string }
+
+export type LayoutAction =
+  | {
+      type: 'split-pane'
+      direction: SplitDirection
+      newTab: TabSession
+    }
+  | { type: 'close-pane'; tabId: string }
+  | {
+      type: 'focus-pane-direction'
+      direction: 'left' | 'right' | 'up' | 'down'
+    }
+  | {
+      type: 'resize-pane'
+      tabId: string
+      delta: number
+      axis?: SplitDirection
+    }
+  | {
+      type: 'set-split-ratio'
+      tabId: string
+      ratio: number
+      axis?: SplitDirection
+    }
+
+export type UIAction =
+  | { type: 'toggle-bar'; side: BarSide }
+  | { type: 'resize-bar'; side: BarSide; delta: number }
+  | { type: 'set-bar-width'; side: BarSide; width: number }
+  | { type: 'toggle-widget'; widgetId: string }
+  | { type: 'move-widget'; widgetId: string; side: BarSide; index: number }
+  | { type: 'set-bar-boundary'; side: BarSide; index: number; ratio: number }
+  | { type: 'resize-widget'; widgetId: string; delta: number }
+  | { type: 'set-focus-mode'; focusMode: FocusMode }
+  | { type: 'set-terminal-size'; cols: number; rows: number }
+  | { type: 'resize-git-diff-pane'; delta: number }
+  | { type: 'set-pending-chords'; chords: string[] | null }
+  | { type: 'toggle-project-bar' }
+
+export type SettingsAction =
+  | { type: 'enter-settings' }
+  | { type: 'exit-settings' }
+  | { type: 'settings-focus-pane'; pane: 'nav' | 'rows' }
+  | { type: 'settings-move-selection'; delta: -1 | 1 }
+  | { type: 'settings-select-section'; sectionId: string }
+  | { type: 'settings-select-row'; rowIndex: number }
+  | { type: 'open-settings-search' }
+  | { type: 'open-setting-text-modal'; settingId: string; label: string; value: string }
+
+export type GitPanelAction =
+  | { type: 'git-refresh-success'; payload: GitRefreshPayload }
+  | { type: 'git-refresh-error'; kind: GitPanelError }
+  | { type: 'git-panel-reset' }
+  | { type: 'set-workspace-divergence'; divergence: Record<string, BranchDivergence> }
+  | { type: 'set-git-pane'; patch: Partial<GitPaneState> }
+
+export type AutoCommitAction =
+  | {
+      type: 'auto-commit-generation-started'
+      projectId: string
+      tabId: string
+      workingTreeHash: string
+      abortController: AbortController
+      startedAt: number
+    }
+  | {
+      type: 'auto-commit-generation-ready'
+      projectId: string
+      workingTreeHash: string
+      title: string
+      body: string
+      generatedAt: number
+    }
+  | { type: 'auto-commit-clear'; projectId: string }
+
+export type GitModeAction =
+  | { type: 'enter-git-mode' }
+  | { type: 'exit-git-mode' }
+  | { type: 'git-mode-move-selection'; delta: -1 | 1 }
+  | { type: 'git-mode-move-file-selection'; delta: -1 | 1 }
+  | { type: 'git-mode-select-entry-by-key'; key: string }
+  | { type: 'git-mode-toggle-folder'; key: string }
+  | { type: 'git-mode-toggle-selected-folder' }
+  | { type: 'git-mode-collapse-selection' }
+  | { type: 'git-mode-expand-selection' }
+  | { type: 'git-mode-toggle-file-list-mode' }
+  | { type: 'git-mode-toggle-tree-compaction' }
+  | { type: 'git-mode-set-diff'; key: string; diff: DiffData; hash: string }
+  | {
+      type: 'git-mode-set-parsed'
+      key: string
+      hash: string
+      file: unknown
+    }
+  | {
+      type: 'git-mode-set-highlights'
+      key: string
+      hash: string
+      themeId: string
+      add: unknown
+      del: unknown
+    }
+  | {
+      type: 'git-mode-merge-highlights'
+      key: string
+      hash: string
+      themeId: string
+      add: { start: number; tokens: unknown }[]
+      del: { start: number; tokens: unknown }[]
+    }
+  | { type: 'git-mode-invalidate-diffs'; paths: string[] }
+  | { type: 'git-mode-set-loading'; key: string; loading: boolean }
+  | { type: 'git-mode-set-pending-delete'; path: string | null }
+  | { type: 'git-mode-clear-diff-cache'; path: string }
+  | { type: 'git-mode-set-message'; message: string | null }
+  | { type: 'snippet-picker-set-message'; message: string | null }
+  | { type: 'git-mode-toggle-diff-view' }
+  | { type: 'git-mode-toggle-review-base' }
+  | { type: 'git-mode-shift-head-offset'; delta: number }
+  | { type: 'git-mode-set-head-offset'; offset: number }
+  | {
+      type: 'git-mode-fold-adjust'
+      key: string
+      foldId: string
+      side: 'top' | 'bottom'
+      delta: number
+    }
+  | { type: 'git-mode-fold-set'; key: string; foldId: string; top: number; bottom: number }
+  | { type: 'git-mode-fold-toggle-all'; key: string }
+  | {
+      type: 'git-mode-optimistic-move'
+      path: string
+      fromSection: GitFileSection
+      toSection: GitFileSection | null
+    }
+  | { type: 'open-git-commit-modal'; projectId?: string }
+  | { type: 'git-commit-enter-confirm' }
+  | { type: 'git-commit-leave-confirm' }
+  | { type: 'git-commit-enter-generating'; projectId: string }
+  | { type: 'git-commit-leave-generating' }
+  | { type: 'git-commit-use-background-suggestion'; projectId: string }
+
+export type DataAction =
+  | { type: 'set-snippets'; snippets: SnippetRecord[] }
+  | { type: 'delete-snippet'; snippetId: string }
+  | { type: 'set-custom-commands'; customCommands: Record<AssistantId, string> }
+
+export type MultiRepoAction =
+  | { type: 'multi-repo-set-repos'; repos: DiscoveredRepo[] }
+  | { type: 'multi-repo-clear' }
+
+export type AppAction =
+  | ModalAction
+  | ProjectAction
+  | TabAction
+  | LayoutAction
+  | UIAction
+  | SettingsAction
+  | DataAction
+  | GitPanelAction
+  | GitModeAction
+  | AutoCommitAction
+  | MultiRepoAction

package/src/state/app-store.ts

@@ -1,7 +1,8 @@
 import { useStore } from 'zustand'
 import { createStore } from 'zustand/vanilla'
 
-import type { AppAction, AppState } from './types'
+import type { AppAction } from './actions'
+import type { AppState } from './types'
 
 import { appReducer, createInitialState } from './store'
 

package/src/state/bars.ts

@@ -0,0 +1,75 @@
+import type { BarSide, BarsState, BarState, BarWidget } from './types'
+
+export const BAR_MIN_WIDTH = 18
+export const BAR_MAX_WIDTH = 80
+
+/** Widget ids the app knows how to render. Unknown ids are pruned on load. */
+export const KNOWN_WIDGET_IDS = ['projects', 'git', 'setup'] as const
+
+/** Smallest share of a bar a single widget may shrink to, as a fraction. */
+const MIN_WIDGET_SHARE = 0.1
+
+export function clampBarWidth(width: number): number {
+  return Math.min(BAR_MAX_WIDTH, Math.max(BAR_MIN_WIDTH, Math.round(width)))
+}
+
+export function visibleWidgets(bar: BarState): BarWidget[] {
+  return bar.widgets.filter((widget) => widget.visible)
+}
+
+/**
+ * The single authority on how many columns a bar occupies. Both the `Bar`
+ * component and the terminal-size computation must call this — a mismatch
+ * silently corrupts PTY columns and mouse hit-testing.
+ */
+export function getBarWidth(bar: BarState): number {
+  if (!bar.visible || visibleWidgets(bar).length === 0) return 0
+  return clampBarWidth(bar.width)
+}
+
+export function findWidgetBar(bars: BarsState, widgetId: string): BarSide | null {
+  if (bars.left.widgets.some((widget) => widget.id === widgetId)) return 'left'
+  if (bars.right.widgets.some((widget) => widget.id === widgetId)) return 'right'
+  return null
+}
+
+function totalGrow(widgets: BarWidget[]): number {
+  return widgets.reduce((sum, widget) => sum + widget.grow, 0)
+}
+
+/**
+ * Move the boundary between visible widgets `index` and `index + 1` by
+ * `deltaGrow`. Only the pair changes, so the bar's total grow is preserved and
+ * no renormalisation is ever needed — including when a widget is added.
+ */
+export function shiftBoundary(bar: BarState, index: number, deltaGrow: number): BarWidget[] {
+  const visible = visibleWidgets(bar)
+  const above = visible[index]
+  const below = visible[index + 1]
+  if (!above || !below) return bar.widgets
+
+  const min = Math.max(1, Math.round(totalGrow(visible) * MIN_WIDGET_SHARE))
+  const pair = above.grow + below.grow
+  if (pair < min * 2) return bar.widgets
+
+  const nextAbove = Math.min(pair - min, Math.max(min, Math.round(above.grow + deltaGrow)))
+  if (nextAbove === above.grow) return bar.widgets
+
+  return bar.widgets.map((widget) => {
+    if (widget.id === above.id) return { ...widget, grow: nextAbove }
+    if (widget.id === below.id) return { ...widget, grow: pair - nextAbove }
+    return widget
+  })
+}
+
+/**
+ * Convert an absolute drag position (a 0..1 fraction of the bar's body) into
+ * the grow delta `shiftBoundary` expects for that boundary.
+ */
+export function boundaryDeltaFromRatio(bar: BarState, index: number, ratio: number): number {
+  const visible = visibleWidgets(bar)
+  const target = visible[index]
+  if (!target) return 0
+  const above = visible.slice(0, index).reduce((sum, widget) => sum + widget.grow, 0)
+  return ratio * totalGrow(visible) - above - target.grow
+}

package/src/state/dispatch-ref.ts

@@ -1,5 +1,5 @@
 import type { SideEffect } from '../input/modes/types'
-import type { AppAction } from './types'
+import type { AppAction } from './actions'
 
 type DispatchFn = (action: AppAction) => void
 type SideEffectFn = (effect: SideEffect) => void

package/src/state/git-pane-sizing.ts

@@ -1,15 +1,6 @@
 export const GIT_PANE_MIN_RATIO = 0.2
 export const GIT_PANE_MAX_RATIO = 0.8
-export const GIT_PANE_MIN_WIDTH = 20
-export const GIT_PANE_MAX_WIDTH = 80
 
 export function clampGitPaneRatio(value: number): number {
   return Math.max(GIT_PANE_MIN_RATIO, Math.min(GIT_PANE_MAX_RATIO, value))
 }
-
-export function getGitPaneWidthFromRatio(ratio: number): number {
-  return Math.max(
-    GIT_PANE_MIN_WIDTH,
-    Math.min(GIT_PANE_MAX_WIDTH, Math.round(clampGitPaneRatio(ratio) * GIT_PANE_MAX_WIDTH))
-  )
-}

package/src/state/layout-resize.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceSnapshotV1 } from './types'
+import type { ProjectSnapshotV1 } from './types'
 
 import { computePaneRects, type LayoutNode, PANE_BORDER, type PaneRect } from './layout-tree'
 
@@ -9,7 +9,7 @@ export interface TerminalBounds {
   rows: number
 }
 
-export function getSnapshotTrees(snapshot: WorkspaceSnapshotV1 | undefined): LayoutNode[] {
+export function getSnapshotTrees(snapshot: ProjectSnapshotV1 | undefined): LayoutNode[] {
   if (snapshot?.layoutTrees) {
     return Object.values(snapshot.layoutTrees)
   }

package/src/state/pr-status-store.ts

@@ -0,0 +1,39 @@
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import type { PrStatusResult } from '../git/pr-status'
+
+export interface PrStatusState {
+  result: PrStatusResult | null
+  /** True once a fetch failed but we are still showing the previous good result. */
+  stale: boolean
+  setResult: (result: PrStatusResult) => void
+  reset: () => void
+}
+
+export const prStatusStore = createStore<PrStatusState>((set) => ({
+  reset: () => set({ result: null, stale: false }),
+  result: null,
+  setResult: (result: PrStatusResult) =>
+    set((state) => {
+      // A transient `gh` failure shouldn't blank a PR we already resolved — keep
+      // the last good snapshot and mark it stale instead (same contract as
+      // ai-usage-store's setSnapshot).
+      if (result.kind === 'error' && state.result?.kind === 'ok') return { stale: true }
+      return { result, stale: false }
+    }),
+  stale: false,
+}))
+
+/**
+ * The PR state row occupies its band both while the first fetch is in flight
+ * and once it resolved to a PR — anything else (no PR, no gh, error) gives the
+ * row back. Shared so the header and the row itself can never disagree and
+ * shift the layout under the user.
+ */
+export const selectPrRowVisible = (state: PrStatusState): boolean =>
+  state.result === null || state.result.kind === 'ok'
+
+export function usePrStatusStore<T>(selector: (state: PrStatusState) => T): T {
+  return useStore(prStatusStore, selector)
+}