@brimveyn/aimux 1.21.0 → 1.22.2

package/src/state/workspace-save.ts

@@ -1,43 +0,0 @@
-import type { AppState, SessionRecord } from './types'
-
-import { loadConfig, saveConfig } from '../config'
-import { saveSessionCatalog } from './session-catalog'
-import { serializeWorkspace } from './session-persistence'
-
-export function buildSessionsWithCurrentSnapshot(
-  sessions: SessionRecord[],
-  currentSessionId: string | null,
-  state: AppState
-): SessionRecord[] {
-  return sessions.map((session) =>
-    session.id === currentSessionId
-      ? {
-          ...session,
-          updatedAt: new Date().toISOString(),
-          workspaceSnapshot: serializeWorkspace(state),
-        }
-      : session
-  )
-}
-
-export function saveCurrentWorkspace(state: AppState): void {
-  saveConfig({
-    ...loadConfig(),
-    bars: state.bars,
-    customCommands: state.customCommands,
-    gitPane: {
-      diffModeRatio: state.gitPane.diffModeRatio,
-      fileListMode: state.gitPane.fileListMode,
-    },
-    sessionBarVisible: state.sessionBar.visible,
-    // Legacy mirror of the left bar: lets an older build (and the workspace
-    // snapshot schema) still find a sidebar after a downgrade.
-    sidebar: {
-      visible: state.bars.left.visible,
-      width: state.bars.left.width,
-    },
-  })
-  saveSessionCatalog(
-    buildSessionsWithCurrentSnapshot(state.sessions, state.currentSessionId, state)
-  )
-}

package/src/ui/components/layout/sidebar/use-top-tab-bar-auto-scroll.ts

@@ -1,30 +0,0 @@
-import type { ScrollBoxRenderable } from '@opentui/core'
-
-import { useEffect } from 'react'
-
-interface Options {
-  scrollRef: React.RefObject<ScrollBoxRenderable | null>
-  visible: boolean
-  activeTabId: string | null
-  idPrefix: string
-}
-
-/**
- * Scroll the active tab into view whenever the active tab id changes (and on
- * first reveal). The top bar is a single horizontal row, so this is just a
- * thin wrapper around `scrollChildIntoView` — no wrap-around/edge heuristics.
- */
-export function useTopTabBarAutoScroll({
-  activeTabId,
-  idPrefix,
-  scrollRef,
-  visible,
-}: Options): void {
-  useEffect(() => {
-    if (!visible) return
-    if (activeTabId == null || activeTabId === '') return
-    const scrollbox = scrollRef.current
-    if (!scrollbox) return
-    scrollbox.scrollChildIntoView(`${idPrefix}${activeTabId}`)
-  }, [activeTabId, idPrefix, scrollRef, visible])
-}

package/src/ui/components/layout/sidebar/workspace-list.tsx

@@ -1,418 +0,0 @@
-import type {
-  BoxRenderable,
-  MouseEvent as OtuiMouseEvent,
-  ScrollBoxRenderable,
-} from '@opentui/core'
-
-import { memo, type ReactNode, useCallback, useMemo, useRef, useState } from 'react'
-
-import type { SessionRecord, SessionStatus, WorktreeRecord } from '../../../../state/types'
-
-import { useAppStore } from '../../../../state/app-store'
-import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
-import { formatDivergence } from '../../../../state/session-worktrees'
-// eslint-disable-next-line no-duplicate-imports
-import { IDLE_SESSION_STATUS } from '../../../../state/types'
-import { useBusySpinner } from '../../../hooks/use-busy-spinner'
-import { moveIdToIdPosition, orderSessionsForDisplay } from '../../../session-ordering'
-import { useBaseTheme, useTheme } from '../../../theme'
-import { FlashLabelBadge } from '../../flash/flash-label-badge'
-import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
-import { useSidebarAutoScroll } from './use-sidebar-auto-scroll'
-import { WorktreeRow } from './worktree-row'
-
-interface WorkspaceListProps {
-  contentWidth: number
-}
-
-const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
-
-function arraysEqual(a: string[], b: string[]): boolean {
-  if (a.length !== b.length) return false
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) return false
-  }
-  return true
-}
-
-function truncate(label: string, max: number): string {
-  if (max <= 0) return ''
-  if (label.length <= max) return label
-  if (max === 1) return '…'
-  return `${label.slice(0, max - 1)}…`
-}
-
-export function WorkspaceList({ contentWidth }: WorkspaceListProps) {
-  const t = useTheme()
-  const sessions = useAppStore((s) => s.sessions)
-  const currentSessionId = useAppStore((s) => s.currentSessionId)
-  const statusMap = useAppStore((s) => s.sessionStatuses)
-
-  const [draggingId, setDraggingId] = useState<string | null>(null)
-  const [dragOrder, setDragOrder] = useState<string[] | null>(null)
-  const lastSwapWithRef = useRef<string | null>(null)
-  const rowRefs = useRef(new Map<string, BoxRenderable>())
-  const scrollRef = useRef<ScrollBoxRenderable | null>(null)
-
-  const ordered = useMemo(() => orderSessionsForDisplay(sessions), [sessions])
-  const baselineOrder = useMemo(() => ordered.map((s) => s.id), [ordered])
-
-  const currentSession = useMemo(
-    () =>
-      currentSessionId != null && currentSessionId !== ''
-        ? sessions.find((s) => s.id === currentSessionId)
-        : undefined,
-    [currentSessionId, sessions]
-  )
-  // The active row can be either a worktree row OR the workspace row
-  // (when the primary worktree is active). Both must scroll into view —
-  // otherwise the cursor visually "disappears" off-screen when crossing
-  // a workspace boundary on a key press.
-  const currentWorktrees = currentSession?.worktrees ?? []
-  const currentPrimary = currentWorktrees.find((w) => w.source === 'primary') ?? currentWorktrees[0]
-  const rawActiveWorktreeId = currentSession?.activeWorktreeId
-  const activeOnNonPrimary =
-    rawActiveWorktreeId != null &&
-    rawActiveWorktreeId !== '' &&
-    rawActiveWorktreeId !== currentPrimary?.id
-  let activeRowId: string | null = null
-  if (activeOnNonPrimary) {
-    activeRowId = `sidebar-wt-${rawActiveWorktreeId}`
-  } else if (currentSessionId != null && currentSessionId !== '') {
-    activeRowId = `sidebar-ws-${currentSessionId}`
-  }
-
-  useSidebarAutoScroll({
-    activeRowId,
-    scrollRef,
-    visible: true,
-  })
-
-  const setRowRef = useCallback((id: string, ref: BoxRenderable | null): void => {
-    if (ref) rowRefs.current.set(id, ref)
-    else rowRefs.current.delete(id)
-  }, [])
-
-  const findRowAtY = useCallback((y: number): string | null => {
-    for (const [id, ref] of rowRefs.current) {
-      if (y >= ref.y && y < ref.y + ref.height) return id
-    }
-    return null
-  }, [])
-
-  const handleRowDragStart = useCallback(
-    (id: string) => {
-      setDraggingId(id)
-      setDragOrder(baselineOrder)
-      lastSwapWithRef.current = null
-    },
-    [baselineOrder]
-  )
-
-  const handleRowDrag = useCallback(
-    (event: OtuiMouseEvent) => {
-      if (!(draggingId != null && draggingId !== '')) return
-      const hit = findRowAtY(event.y)
-      if (hit === null) {
-        lastSwapWithRef.current = null
-        return
-      }
-      if (hit === draggingId) {
-        lastSwapWithRef.current = null
-        return
-      }
-      if (hit === lastSwapWithRef.current) return
-      setDragOrder((prev) => (prev ? moveIdToIdPosition(prev, draggingId, hit) : prev))
-      lastSwapWithRef.current = hit
-    },
-    [draggingId, findRowAtY]
-  )
-
-  const commitDrop = useCallback(() => {
-    const source = draggingId
-    const finalOrder = dragOrder
-    setDraggingId(null)
-    setDragOrder(null)
-    lastSwapWithRef.current = null
-
-    if (source == null || source === '' || !finalOrder) return
-
-    const changed = !arraysEqual(finalOrder, baselineOrder)
-    if (changed) {
-      dispatchGlobal({ orderedIds: finalOrder, type: 'reorder-sessions' })
-      return
-    }
-
-    const idx = baselineOrder.indexOf(source)
-    if (idx >= 0) {
-      // The workspace row visually anchors the session's primary worktree
-      // (its branch line shows the primary's branch). Clicking it should
-      // land on the primary — same semantics as j/k cycling onto a workspace
-      // item — instead of preserving whatever non-primary worktree happened
-      // to be active last time we left this session.
-      const sourceSession = ordered.find((s) => s.id === source)
-      const sourceWorktrees = sourceSession?.worktrees ?? []
-      const sourcePrimaryId = (
-        sourceWorktrees.find((w) => w.source === 'primary') ?? sourceWorktrees[0]
-      )?.id
-      runSideEffectGlobal({
-        index: idx + 1,
-        type: 'switch-session-by-index',
-        worktreeId: sourcePrimaryId,
-      })
-    }
-  }, [baselineOrder, dragOrder, draggingId, ordered])
-
-  const cancelDrag = useCallback(() => {
-    setDraggingId(null)
-    setDragOrder(null)
-    lastSwapWithRef.current = null
-  }, [])
-
-  const handleNewSession = useCallback((e: OtuiMouseEvent) => {
-    e.stopPropagation()
-    e.preventDefault()
-    dispatchGlobal({ returnToSessionPicker: false, type: 'open-create-session-modal' })
-  }, [])
-
-  const visibleSessions =
-    dragOrder !== null
-      ? dragOrder
-          .map((id) => ordered.find((s) => s.id === id))
-          .filter((s): s is SessionRecord => !!s)
-      : ordered
-
-  return (
-    <box flexDirection="column" flexGrow={1} flexShrink={1} overflow="hidden">
-      <scrollbox
-        ref={scrollRef}
-        scrollY
-        flexGrow={1}
-        flexShrink={1}
-        contentOptions={COLUMN_CONTENT_OPTIONS}
-      >
-        {(() => {
-          // Build a single flat list of items — workspace rows interleaved
-          // with their non-primary worktrees. One map, one React keypath per
-          // visible row; transitions are a single atomic reconciliation.
-          const rows: ReactNode[] = []
-          for (const [visibleIdx, session] of visibleSessions.entries()) {
-            const sessionIndex = baselineOrder.indexOf(session.id) + 1
-            const isCurrentSession = session.id === currentSessionId
-            const worktrees = session.worktrees ?? []
-            const primaryWorktree = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
-            const extraWorktrees = worktrees.filter((w) => w.id !== primaryWorktree?.id)
-            const workspaceIsActiveItem =
-              isCurrentSession &&
-              (session.activeWorktreeId == null ||
-                session.activeWorktreeId === '' ||
-                session.activeWorktreeId === primaryWorktree?.id)
-            rows.push(
-              <WorkspaceRow
-                key={`ws:${session.id}`}
-                session={session}
-                isActiveItem={workspaceIsActiveItem}
-                inCurrentGroup={isCurrentSession}
-                primaryWorktree={primaryWorktree}
-                hasExtraWorktrees={extraWorktrees.length > 0}
-                status={statusMap[session.id] ?? IDLE_SESSION_STATUS}
-                dragging={draggingId === session.id}
-                contentWidth={contentWidth}
-                marginTop={visibleIdx > 0 ? 1 : 0}
-                setRowRef={setRowRef}
-                onDragStart={handleRowDragStart}
-                onDrag={handleRowDrag}
-                onDrop={commitDrop}
-                onDragCancel={cancelDrag}
-              />
-            )
-            for (const [wtIdx, worktree] of extraWorktrees.entries()) {
-              rows.push(
-                <WorktreeRow
-                  key={`wt:${worktree.id}`}
-                  session={session}
-                  worktree={worktree}
-                  sessionIndex={sessionIndex}
-                  isActiveItem={isCurrentSession && worktree.id === session.activeWorktreeId}
-                  inCurrentGroup={isCurrentSession}
-                  isLast={wtIdx === extraWorktrees.length - 1}
-                />
-              )
-            }
-          }
-          return rows
-        })()}
-      </scrollbox>
-      <box
-        flexDirection="row"
-        flexShrink={0}
-        marginTop={1}
-        backgroundColor={t.backgroundPanel}
-        justifyContent="center"
-        onMouseDown={handleNewSession}
-      >
-        <text fg={t.text} selectable={false}>
-          + New workspace
-        </text>
-      </box>
-    </box>
-  )
-}
-
-interface WorkspaceRowProps {
-  session: SessionRecord
-  /** True when this row is the active cursor item (workspace's primary active). */
-  isActiveItem: boolean
-  /** True when this row belongs to the current workspace (selection scope). */
-  inCurrentGroup: boolean
-  /** The session's primary worktree — its git branch is shown as the workspace's anchor identity. */
-  primaryWorktree: WorktreeRecord | undefined
-  /** True when at least one non-primary worktree follows — used to draw the tree continuator. */
-  hasExtraWorktrees: boolean
-  status: SessionStatus
-  dragging: boolean
-  contentWidth: number
-  /** Vertical spacing above this row — used to separate workspace blocks. */
-  marginTop: number
-  setRowRef: (id: string, ref: BoxRenderable | null) => void
-  onDragStart: (id: string) => void
-  onDrag: (event: OtuiMouseEvent) => void
-  onDrop: () => void
-  onDragCancel: () => void
-}
-
-const WorkspaceRow = memo(function WorkspaceRow({
-  contentWidth,
-  dragging,
-  hasExtraWorktrees,
-  inCurrentGroup,
-  isActiveItem,
-  marginTop,
-  onDrag,
-  onDragCancel,
-  onDragStart,
-  onDrop,
-  primaryWorktree,
-  session,
-  setRowRef,
-  status,
-}: WorkspaceRowProps) {
-  const t = useTheme()
-  // Selection highlight must stay opaque in transparent mode — otherwise the
-  // cursor row visually disappears against the see-through chrome.
-  const base = useBaseTheme()
-  const showSpinner = status.working
-  const showWaiting = status.waiting
-  const spinner = useBusySpinner(showSpinner)
-  let bgColor: string | undefined
-  if (dragging || isActiveItem) {
-    bgColor = base.backgroundElement
-  } else if (inCurrentGroup) {
-    bgColor = base.backgroundPanel
-  }
-  const workingColor = t.primary
-  const waitingColor = t.warning
-  const divergence = useAppStore((s) =>
-    primaryWorktree ? s.worktreeDivergence[primaryWorktree.id] : undefined
-  )
-
-  const handleRef = useCallback(
-    (r: BoxRenderable | null) => setRowRef(session.id, r),
-    [setRowRef, session.id]
-  )
-  const handleMouseDown = useCallback(
-    (e: OtuiMouseEvent) => {
-      e.preventDefault()
-      e.stopPropagation()
-      onDragStart(session.id)
-    },
-    [onDragStart, session.id]
-  )
-  const handleMouseUp = useCallback(
-    (e: OtuiMouseEvent) => {
-      e.preventDefault()
-      onDrop()
-    },
-    [onDrop]
-  )
-  const rightClickMenu = useMemo<[string, () => void][]>(
-    () => [
-      [
-        'Rename workspace',
-        () =>
-          dispatchGlobal({
-            initialName: session.name,
-            returnToSessionPicker: false,
-            sessionTargetId: session.id,
-            type: 'open-session-name-modal',
-          }),
-      ],
-      [
-        'Delete workspace',
-        () => runSideEffectGlobal({ sessionId: session.id, type: 'delete-session' }),
-      ],
-    ],
-    [session.id, session.name]
-  )
-
-  // Neutral muted marker; working/waiting overrides it. Keeping a glyph
-  // in the slot avoids name shifts when state indicators come and go.
-  let leadingGlyph = '•'
-  let leadingColor = t.textMuted
-  if (showWaiting) {
-    leadingGlyph = '?'
-    leadingColor = waitingColor
-  } else if (showSpinner) {
-    leadingGlyph = spinner
-    leadingColor = workingColor
-  }
-
-  const branchText = primaryWorktree?.branch ?? ''
-  const divergenceText = formatDivergence(divergence)
-  const showBranch = branchText !== ''
-  const nameLabel = truncate(session.name, Math.max(0, contentWidth - 4))
-  const branchLabel = truncate(
-    branchText,
-    Math.max(0, contentWidth - 5 - (divergenceText.length + 1))
-  )
-
-  return (
-    <ContextMenuBox
-      ref={handleRef}
-      id={`sidebar-ws-${session.id}`}
-      flexDirection="column"
-      flexShrink={0}
-      marginTop={marginTop}
-      paddingLeft={1}
-      paddingRight={1}
-      backgroundColor={bgColor}
-      rightClickMenu={rightClickMenu}
-      onMouseDown={handleMouseDown}
-      onMouseDrag={onDrag}
-      onMouseUp={handleMouseUp}
-      onMouseDragEnd={onDragCancel}
-    >
-      <box flexDirection="row" alignItems="center">
-        <text fg={leadingColor} selectable={false} wrapMode="none">
-          {leadingGlyph}
-        </text>
-        <text fg={t.text} selectable={false} wrapMode="none">
-          {' '}
-        </text>
-        <FlashLabelBadge rowKey={`ws:${session.id}`} />
-        <text fg={t.text} selectable={false} wrapMode="none">
-          {nameLabel}
-        </text>
-      </box>
-      {showBranch ? (
-        <box flexDirection="row">
-          <text fg={t.textMuted} selectable={false} wrapMode="none">
-            {hasExtraWorktrees ? '│ ' : '  '}
-            {'\u{e702}'} {branchLabel}
-            {divergenceText !== '' ? ` ${divergenceText}` : ''}
-          </text>
-        </box>
-      ) : null}
-    </ContextMenuBox>
-  )
-})

package/src/ui/components/layout/sidebar/worktree-row.tsx

@@ -1,149 +0,0 @@
-import type { MouseEvent as OtuiMouseEvent } from '@opentui/core'
-
-import { memo, useCallback, useMemo } from 'react'
-
-import type { SessionRecord, WorktreeRecord } from '../../../../state/types'
-
-import { useAppStore } from '../../../../state/app-store'
-import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
-import { formatDivergence } from '../../../../state/session-worktrees'
-import { useBaseTheme, useTheme } from '../../../theme'
-import { FlashLabelBadge } from '../../flash/flash-label-badge'
-import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
-
-interface WorktreeRowProps {
-  session: SessionRecord
-  worktree: WorktreeRecord
-  /** 1-based index of the workspace in the visible order (for switch-session-by-index). */
-  sessionIndex: number
-  /** True when this row is the active cursor item. */
-  isActiveItem: boolean
-  /** True when this row's workspace is the current session (selection scope). */
-  inCurrentGroup: boolean
-  /** True when this is the last non-primary worktree of its workspace. Drives └─ vs ├─. */
-  isLast: boolean
-}
-
-export const WorktreeRow = memo(function WorktreeRow({
-  inCurrentGroup,
-  isActiveItem,
-  isLast,
-  session,
-  sessionIndex,
-  worktree,
-}: WorktreeRowProps) {
-  const t = useTheme()
-  // Selection highlight must stay opaque in transparent mode.
-  const base = useBaseTheme()
-  const currentSessionId = useAppStore((s) => s.currentSessionId)
-  const isCurrentSession = session.id === currentSessionId
-  const divergence = useAppStore((s) => s.worktreeDivergence[worktree.id])
-
-  const handleMouseDown = useCallback(
-    (event: OtuiMouseEvent) => {
-      if (event.button !== 0) return
-      event.preventDefault()
-      event.stopPropagation()
-      if (isCurrentSession) {
-        dispatchGlobal({
-          sessionId: session.id,
-          type: 'set-active-worktree',
-          worktreeId: worktree.id,
-        })
-        return
-      }
-      // Cross-workspace click: send the worktree id along with the switch so
-      // the side effect can apply it atomically. Splitting it into a separate
-      // dispatch+switch leaves a window where subscribers/re-renders can
-      // re-assert the target session's last-persisted worktree.
-      runSideEffectGlobal({
-        index: sessionIndex,
-        type: 'switch-session-by-index',
-        worktreeId: worktree.id,
-      })
-    },
-    [isCurrentSession, session.id, sessionIndex, worktree.id]
-  )
-
-  const rightClickMenu = useMemo<[string, () => void][] | undefined>(() => {
-    const entries: [string, () => void][] = [
-      [
-        'Rename',
-        () =>
-          dispatchGlobal({
-            initialName: worktree.name,
-            sessionId: session.id,
-            type: 'open-rename-worktree-modal',
-            worktreeId: worktree.id,
-          }),
-      ],
-    ]
-    if (worktree.source !== 'primary') {
-      entries.push([
-        'Remove worktree',
-        () =>
-          // Always confirm first. Confirming routes through the full delete side
-          // effect (closes the worktree's tabs, disposes their PTYs, prunes the
-          // snapshot, removes the git worktree). closeTabs (not force) cleans up
-          // the tabs while keeping the non-force `git worktree remove`, so
-          // uncommitted work in a temp worktree is still protected — a dirty
-          // worktree re-prompts for an explicit force-delete.
-          dispatchGlobal({
-            closeTabs: true,
-            force: false,
-            reason: 'Its assistant tabs will be closed and the worktree removed.',
-            sessionId: session.id,
-            type: 'open-worktree-delete-confirm',
-            worktreeId: worktree.id,
-            worktreeLabel: worktree.branch ?? worktree.name,
-          }),
-      ])
-    }
-    return entries
-  }, [session.id, worktree.branch, worktree.id, worktree.name, worktree.source])
-
-  let bgColor: string | undefined
-  if (isActiveItem) {
-    bgColor = base.backgroundElement
-  } else if (inCurrentGroup) {
-    bgColor = base.backgroundPanel
-  }
-
-  const connector = isLast ? '└─' : '├─'
-  const branchCont = isLast ? '   ' : '│  '
-  const branchText = worktree.branch ?? ''
-  const showBranch = branchText !== ''
-  const divergenceText = formatDivergence(divergence)
-
-  return (
-    <ContextMenuBox
-      id={`sidebar-wt-${worktree.id}`}
-      flexDirection="column"
-      flexShrink={0}
-      paddingLeft={1}
-      paddingRight={1}
-      backgroundColor={bgColor}
-      rightClickMenu={rightClickMenu}
-      onMouseDown={handleMouseDown}
-    >
-      <box flexDirection="row" alignItems="center">
-        <text fg={t.textMuted} selectable={false} wrapMode="none">
-          {connector}{' '}
-        </text>
-        <FlashLabelBadge rowKey={`wt:${worktree.id}`} />
-        <text fg={t.text} selectable={false} wrapMode="none">
-          {worktree.name}
-        </text>
-      </box>
-      {showBranch ? (
-        <box flexDirection="row">
-          <text fg={t.textMuted} selectable={false} wrapMode="none">
-            {branchCont}
-            {'\u{e702}'} {branchText}
-            {divergenceText !== '' ? ` ${divergenceText}` : ''}
-          </text>
-        </box>
-      ) : null}
-    </ContextMenuBox>
-  )
-})