@brimveyn/aimux 1.14.0 → 1.14.2

package/src/state/session-worktrees.ts

@@ -3,13 +3,21 @@ import { createHash } from 'node:crypto'
 import { existsSync } from 'node:fs'
 import { basename } from 'node:path'
 
-import type { SessionRecord, TabSession, WorktreeRecord } from './types'
+import type { BranchDivergence, SessionRecord, TabSession, WorktreeRecord } from './types'
 
 import { createPrefixedId } from '../platform/id'
 import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
 
 const WORKTREE_COLORS = ['#7dd3fc', '#86efac', '#facc15', '#f0abfc', '#fb7185', '#c4b5fd']
 
+export function formatDivergence(divergence: BranchDivergence | undefined): string {
+  if (divergence == null) return ''
+  const parts: string[] = []
+  if (divergence.ahead > 0) parts.push(`↑${divergence.ahead}`)
+  if (divergence.behind > 0) parts.push(`↓${divergence.behind}`)
+  return parts.join(' ')
+}
+
 export function getWorktreeColor(worktreeId: string): string {
   let hash = 0
   for (let i = 0; i < worktreeId.length; i++) {
@@ -98,7 +106,24 @@ function mergeExistingGitWorktrees(worktrees: WorktreeRecord[], now: string): Wo
       ? primaryRepoRoot
       : (live[0]?.path ?? anchor.repoRoot)
   for (const entry of live) {
-    if (byPath.has(entry.path)) continue
+    const existing = byPath.get(entry.path)
+    if (existing) {
+      // Patch branch / commitSha from git for entries we already track —
+      // notably the primary worktree, whose `branch` is never set at creation
+      // time (createPrimaryWorktree doesn't run `git`). Without this, the UI
+      // and the divergence poller have no branch for primary worktrees.
+      const patchedBranch = entry.branch ?? existing.branch
+      const patchedSha = entry.head ?? existing.commitSha
+      if (patchedBranch !== existing.branch || patchedSha !== existing.commitSha) {
+        byPath.set(entry.path, {
+          ...existing,
+          branch: patchedBranch,
+          commitSha: patchedSha,
+          updatedAt: now,
+        })
+      }
+      continue
+    }
     if (isInsideAimuxWorktreeRoot(entry.path)) continue
     const worktree: WorktreeRecord = {
       branch: entry.branch,
@@ -204,6 +229,24 @@ export function getRenderedTabWorktreeId(
   return tab.worktreeId ?? worktrees[0]?.id ?? '__main__'
 }
 
+export function filterTabsForActiveWorktree(
+  tabs: TabSession[],
+  session: SessionRecord | undefined
+): TabSession[] {
+  if (!session) return tabs
+  const activeWorktreeId = session.activeWorktreeId
+  if (activeWorktreeId == null || activeWorktreeId === '') return tabs
+  const worktrees = session.worktrees ?? []
+  const primaryId = worktrees[0]?.id
+  const activeIsPrimary = primaryId != null && primaryId === activeWorktreeId
+  return tabs.filter((tab) => {
+    const owned = tab.worktreeId != null && tab.worktreeId !== ''
+    if (owned) return tab.worktreeId === activeWorktreeId
+    // Unbound (legacy) tabs surface only under the primary worktree.
+    return activeIsPrimary
+  })
+}
+
 export function orderTabsByWorktree(
   tabs: TabSession[],
   session: SessionRecord | undefined

package/src/state/store.ts

@@ -16,7 +16,6 @@ import {
   type GitPaneMode,
   type GitPanePosition,
   type GitPaneState,
-  type SessionBarPosition,
   type SessionRecord,
   type SnippetRecord,
 } from './types'
@@ -32,7 +31,6 @@ export interface InitialStateOverrides {
   gitPane?: Partial<GitPaneState>
   sidebar?: Pick<AppState['sidebar'], 'visible' | 'width'>
   sessionBarVisible?: boolean
-  sessionBarPosition?: SessionBarPosition
 }
 
 const DEFAULT_GIT_PANE: GitPaneState = {
@@ -103,7 +101,6 @@ export function createInitialState(
     multiRepo: EMPTY_MULTI_REPO_STATE,
     pendingChords: null,
     sessionBar: {
-      position: overrides.sessionBarPosition ?? 'top',
       visible: overrides.sessionBarVisible ?? true,
     },
     sessions,

package/src/state/tab-entries.ts

@@ -0,0 +1,74 @@
+import type { TabSession } from './types'
+
+import { allLeafIds, type LayoutNode } from './layout-tree'
+
+export interface SingleEntry {
+  kind: 'single'
+  id: string
+  tab: TabSession
+}
+
+export interface GroupEntry {
+  kind: 'group'
+  id: string
+  groupId: string
+  tabs: TabSession[]
+  activeLeafId: string
+}
+
+export type TabEntry = SingleEntry | GroupEntry
+
+/**
+ * Collapse a list of visible tabs into "tab strip entries": one entry per
+ * standalone tab, one entry per multi-leaf layout group (split). Tabs that
+ * belong to a layout tree with only one leaf are treated as standalone.
+ *
+ * Within a group entry, `activeLeafId` is `activeTabId` when it falls inside
+ * the group, otherwise the first leaf in the underlying tabs order.
+ */
+export function buildTabEntries(
+  visibleTabs: TabSession[],
+  layoutTrees: Record<string, LayoutNode>,
+  tabGroupMap: Record<string, string>,
+  activeTabId: string | null
+): TabEntry[] {
+  // Set of groupIds that are real splits (>= 2 leaves).
+  const splitGroupIds = new Set<string>()
+  for (const [groupId, tree] of Object.entries(layoutTrees)) {
+    if (allLeafIds(tree).length >= 2) {
+      splitGroupIds.add(groupId)
+    }
+  }
+
+  const entries: TabEntry[] = []
+  const emittedGroupIds = new Set<string>()
+
+  for (const tab of visibleTabs) {
+    const groupId = tabGroupMap[tab.id]
+    const inSplit = groupId != null && groupId !== '' && splitGroupIds.has(groupId)
+
+    if (!inSplit) {
+      entries.push({ id: tab.id, kind: 'single', tab })
+      continue
+    }
+
+    if (emittedGroupIds.has(groupId)) continue
+    emittedGroupIds.add(groupId)
+
+    const members = visibleTabs.filter((t) => tabGroupMap[t.id] === groupId)
+    const activeLeafId =
+      activeTabId != null && members.some((t) => t.id === activeTabId)
+        ? activeTabId
+        : (members[0]?.id ?? tab.id)
+
+    entries.push({
+      activeLeafId,
+      groupId,
+      id: groupId,
+      kind: 'group',
+      tabs: members,
+    })
+  }
+
+  return entries
+}

package/src/state/types.ts

@@ -141,11 +141,8 @@ export interface SessionRecord {
   activeWorktreeId?: string
 }
 
-export type SessionBarPosition = 'top' | 'bottom'
-
 export interface SessionBarState {
   visible: boolean
-  position: SessionBarPosition
 }
 
 export interface TabSession {
@@ -539,6 +536,7 @@ export type SessionAction =
   | { type: 'rename-session-record'; sessionId: string; name: string }
   | { type: 'delete-session-record'; sessionId: string; openSessionPicker?: boolean }
   | { type: 'reorder-sessions'; orderedIds: string[] }
+  | { type: 'reorder-active-session'; delta: number }
   | { type: 'set-session-status'; sessionId: string; status: SessionStatus }
   | { type: 'add-worktree-record'; sessionId: string; worktree: WorktreeRecord; activate?: boolean }
   | { type: 'remove-worktree-record'; sessionId: string; worktreeId: string }
@@ -619,7 +617,6 @@ export type UIAction =
   | { type: 'set-git-pane-position'; position: GitPanePosition }
   | { type: 'set-pending-chords'; chords: string[] | null }
   | { type: 'toggle-session-bar' }
-  | { type: 'set-session-bar-position'; position: SessionBarPosition }
 
 // -- Git panel actions --
 export interface GitRefreshPayload {

package/src/state/workspace-save.ts

@@ -33,7 +33,6 @@ export function saveCurrentWorkspace(state: AppState): void {
       position: state.gitPane.position,
       visible: state.gitPane.visible,
     },
-    sessionBarPosition: state.sessionBar.position,
     sessionBarVisible: state.sessionBar.visible,
     sidebar: {
       visible: state.sidebar.visible,

package/src/ui/components/layout/sidebar/sidebar.tsx

@@ -1,34 +1,16 @@
-import type {
-  BoxRenderable,
-  MouseEvent as OtuiMouseEvent,
-  ScrollBoxRenderable,
-} from '@opentui/core'
+import type { BoxRenderable, MouseEvent as OtuiMouseEvent } from '@opentui/core'
 
-import { memo, type ReactNode, useCallback, useMemo, useRef } from 'react'
+import { useCallback, useMemo, useRef } from 'react'
 
-import type { BranchDivergence } from '../../../../state/types'
-
-import { useWorktreeDivergencePolling } from '../../../../git/worktree-divergence-poller'
 import { useAppStore } from '../../../../state/app-store'
 import { dispatchGlobal } from '../../../../state/dispatch-ref'
-import {
-  getActiveWorktree,
-  getRenderedTabWorktreeId,
-  getSessionProjectPath,
-  getWorktreeColor,
-  orderTabsByWorktree,
-} from '../../../../state/session-worktrees'
-import { getCurrentTheme, type ResolvedTuiTheme, useTheme } from '../../../theme'
+import { useTheme } from '../../../theme'
 import { buildGitPaneContextMenu } from '../../git/pane/git-pane-context-menu'
 import { GitPaneWidget } from '../../git/pane/git-pane-widget'
 import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
-import { buildTabGroupInfo } from './sidebar-group-metadata'
-import { TabItem } from './tab-item'
-import { useSidebarAutoScroll } from './use-sidebar-auto-scroll'
-import { useSidebarBranch } from './use-sidebar-branch'
+import { WorkspaceList } from './workspace-list'
 
 interface SidebarProps {
-  onTabActivate?: (tabId: string) => void
   onResizeDrag?: (event: OtuiMouseEvent) => boolean
   onResizeDragEnd?: () => void
   onEmbeddedGitResizeStart?: (info: {
@@ -38,314 +20,9 @@ interface SidebarProps {
   }) => void
 }
 
-const GUTTER_START = '╭'
-const GUTTER_MIDDLE = '├'
-const GUTTER_END = '╰'
-const GUTTER_PAD = '│'
 const RESIZE_HANDLE = '─'
-const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
-
-// Left accent strip + trailing space for a worktree group header.
-const WORKTREE_STRIP = '▍ '
-
-// Compact "↑ahead ↓behind" label for a worktree group header; empty when the
-// branch is level with its base (or divergence isn't known yet).
-function formatDivergence(divergence: BranchDivergence | undefined): string {
-  if (divergence == null) return ''
-  const parts: string[] = []
-  if (divergence.ahead > 0) parts.push(`↑${divergence.ahead}`)
-  if (divergence.behind > 0) parts.push(`↓${divergence.behind}`)
-  return parts.join(' ')
-}
-
-// Fit a worktree label into `max` columns, ellipsizing when it would overflow.
-// Branch names are ASCII, so character count tracks rendered column width.
-function truncateLabel(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)}…`
-}
-
-function getRowBackground({
-  alternate,
-  isActive,
-  t,
-}: {
-  isActive: boolean
-  alternate: boolean
-  t: ResolvedTuiTheme
-}): string | undefined {
-  if (isActive) return t.backgroundElement
-  if (alternate) return t.backgroundPanel
-  return t.backgroundPanel
-}
-
-const SidebarTop = memo(function SidebarTop({ contentWidth }: { contentWidth: number }) {
-  const t = useTheme()
-  const currentSessionId = useAppStore((s) => s.currentSessionId)
-  const sessions = useAppStore((s) => s.sessions)
-  const currentSession =
-    currentSessionId != null && currentSessionId !== ''
-      ? sessions.find((s) => s.id === currentSessionId)
-      : undefined
-  const activeWorktree = getActiveWorktree(currentSession)
-  const projectPath = getSessionProjectPath(currentSession)
-  const branch = useSidebarBranch(projectPath)
-
-  const handleNewAssistant = useCallback((e: OtuiMouseEvent) => {
-    e.stopPropagation()
-    dispatchGlobal({ type: 'open-new-tab-modal' })
-  }, [])
-
-  return (
-    <box flexDirection="column" flexShrink={0} gap={0}>
-      <text fg={t.text} selectable={false}>
-        <strong>aimux</strong>
-      </text>
-      <text fg={t.text} selectable={false}>
-        {currentSession ? currentSession.name : 'No workspace selected'}
-      </text>
-      {(branch != null && branch !== '') || activeWorktree ? (
-        <box flexDirection="row">
-          <text fg={t.text} selectable={false}>
-            {'\u{e702}'}{' '}
-          </text>
-          <text fg={t.text} selectable={false}>
-            {branch ?? activeWorktree?.branch ?? activeWorktree?.name}
-          </text>
-          {activeWorktree?.source === 'aimux-temp' ? (
-            <text fg={t.textMuted} selectable={false}>
-              {' '}
-              tmp
-            </text>
-          ) : null}
-        </box>
-      ) : null}
-      <box
-        flexDirection="row"
-        paddingY={1}
-        backgroundColor={t.backgroundPanel}
-        justifyContent="center"
-        marginTop={1}
-        onMouseDown={handleNewAssistant}
-      >
-        <text fg={t.text} selectable={false}>
-          + New assistant
-        </text>
-      </box>
-      <text fg={t.textMuted} selectable={false}>
-        {'·'.repeat(Math.max(0, contentWidth - 2))}
-      </text>
-    </box>
-  )
-})
-
-function renderGroupGutter(isGroupStart: boolean, isGroupMiddle: boolean, isGroupEnd: boolean) {
-  const t = getCurrentTheme()
-  return (
-    <box flexDirection="column" width={1} overflow="hidden">
-      <text fg={t.border} selectable={false}>
-        {/* oxlint-disable-next-line no-nested-ternary */}
-        {isGroupStart ? GUTTER_START : isGroupMiddle ? GUTTER_MIDDLE : GUTTER_PAD}
-      </text>
-      <text fg={t.border} selectable={false}>
-        {isGroupEnd ? GUTTER_END : GUTTER_PAD}
-      </text>
-    </box>
-  )
-}
-
-const TabRowButton = memo(function TabRowButton({
-  backgroundColor,
-  children,
-  onActivate,
-  tabId,
-}: {
-  tabId: string
-  backgroundColor: string | undefined
-  onActivate?: (tabId: string) => void
-  children: ReactNode
-}) {
-  const handleMouseDown = useCallback(
-    (event: OtuiMouseEvent) => {
-      event.stopPropagation()
-      onActivate?.(tabId)
-    },
-    [onActivate, tabId]
-  )
-  return (
-    <box backgroundColor={backgroundColor} flexDirection="row" onMouseDown={handleMouseDown}>
-      {children}
-    </box>
-  )
-})
-
-interface TabsBodyProps {
-  onTabActivate?: (tabId: string) => void
-  contentWidth: number
-}
-
-const TabsBody = memo(function TabsBody({ contentWidth, onTabActivate }: TabsBodyProps) {
-  const t = useTheme()
-  const tabs = useAppStore((s) => s.tabs)
-  const activeTabId = useAppStore((s) => s.activeTabId)
-  const focusMode = useAppStore((s) => s.focusMode)
-  const layoutTrees = useAppStore((s) => s.layoutTrees)
-  const sidebarVisible = useAppStore((s) => s.sidebar.visible)
-  const currentSessionId = useAppStore((s) => s.currentSessionId)
-  const sessions = useAppStore((s) => s.sessions)
-  const worktreeDivergence = useAppStore((s) => s.worktreeDivergence)
-  const currentSession =
-    currentSessionId != null && currentSessionId !== ''
-      ? sessions.find((s) => s.id === currentSessionId)
-      : undefined
-  const worktrees = useMemo(() => currentSession?.worktrees ?? [], [currentSession?.worktrees])
-  const worktreeById = useMemo(
-    () => new Map(worktrees.map((worktree) => [worktree.id, worktree])),
-    [worktrees]
-  )
-  const groupedTabs = useMemo(() => {
-    return orderTabsByWorktree(tabs, currentSession)
-  }, [currentSession, tabs])
-  const showWorktreeSeparators = useMemo(() => {
-    const ids = new Set<string>()
-    for (const tab of groupedTabs) {
-      ids.add(getRenderedTabWorktreeId(tab, worktrees))
-    }
-    const activeWorktreeId =
-      currentSession?.activeWorktreeId ?? getActiveWorktree(currentSession)?.id
-    if (activeWorktreeId != null && activeWorktreeId !== '') ids.add(activeWorktreeId)
-    return ids.size >= 2
-  }, [currentSession, groupedTabs, worktrees])
-
-  const scrollRef = useRef<ScrollBoxRenderable | null>(null)
-  const activeIndex = groupedTabs.findIndex((tab) => tab.id === activeTabId)
-  const tabGroupInfo = useMemo(
-    () => buildTabGroupInfo(layoutTrees, groupedTabs),
-    [layoutTrees, groupedTabs]
-  )
-
-  useSidebarAutoScroll({
-    activeIndex,
-    activeTabId,
-    scrollRef,
-    tabCount: groupedTabs.length,
-    visible: sidebarVisible,
-  })
-
-  return (
-    <scrollbox
-      paddingTop={0}
-      ref={scrollRef}
-      flexGrow={1}
-      scrollY
-      viewportCulling
-      contentOptions={COLUMN_CONTENT_OPTIONS}
-    >
-      {tabs.length === 0 ? (
-        <box paddingTop={1}>
-          <text fg={t.textMuted} selectable={false}>
-            No tabs yet. Press Ctrl+n.
-          </text>
-        </box>
-      ) : (
-        groupedTabs.map((tab, index) => {
-          const isActive = tab.id === activeTabId
-          const alternate = index % 2 === 1
-          const info = tabGroupInfo.get(tab.id)
-          const inLayout = !!(info?.inLayout === true)
-          const inGroup = info ? index >= info.groupStart && index <= info.groupEnd : false
-          const isGroupStart = info ? index === info.groupStart : false
-          const isGroupEnd = info ? index === info.groupEnd : false
-          const isGroupMiddle = inGroup && !isGroupStart && !isGroupEnd
-          const tabOwnWorktree =
-            tab.worktreeId != null && tab.worktreeId !== ''
-              ? worktreeById.get(tab.worktreeId)
-              : undefined
-          let tabWorktree = tabOwnWorktree
-          if (!tabWorktree && worktrees.length > 1) {
-            tabWorktree = worktrees[0]
-          }
-          // A tab's worktree can be moved when it has a branch (squash needs one,
-          // so not the primary) and there's at least one other worktree to land in.
-          const moveWorktreeId =
-            tabOwnWorktree?.branch != null && tabOwnWorktree.branch !== '' && worktrees.length > 1
-              ? tabOwnWorktree.id
-              : undefined
-          const prevTab = groupedTabs[index - 1]
-          const startsWorktreeGroup =
-            !prevTab ||
-            getRenderedTabWorktreeId(prevTab, worktrees) !==
-              getRenderedTabWorktreeId(tab, worktrees)
-          const worktreeColor = tabWorktree
-            ? (tabWorktree.color ?? getWorktreeColor(tabWorktree.id))
-            : t.textMuted
-          const worktreeLabel = tabWorktree?.branch ?? tabWorktree?.name ?? 'main'
-          const aheadBehind = formatDivergence(
-            tabWorktree != null ? worktreeDivergence[tabWorktree.id] : undefined
-          )
-          const aheadBehindText = aheadBehind === '' ? '' : ` ${aheadBehind}`
-          // Reserve room for the strip, the ahead/behind chip and a 1-col gap so
-          // the header never wraps; the divider fills whatever remains (min 0).
-          const labelBudget = Math.max(
-            0,
-            contentWidth - WORKTREE_STRIP.length - aheadBehindText.length - 1
-          )
-          const headerLabel = truncateLabel(worktreeLabel, labelBudget)
 
-          return (
-            <box key={tab.id} flexDirection="column">
-              {showWorktreeSeparators && startsWorktreeGroup ? (
-                <box flexDirection="row" overflow="hidden" paddingTop={index === 0 ? 0 : 1}>
-                  <text selectable={false} wrapMode="none" flexShrink={0}>
-                    <span fg={worktreeColor}>
-                      {WORKTREE_STRIP}
-                      {headerLabel}
-                    </span>
-                    {aheadBehindText !== '' ? (
-                      <span fg={t.textMuted}>{aheadBehindText}</span>
-                    ) : null}
-                  </text>
-                  <box flexGrow={1} flexShrink={1} flexBasis={0} overflow="hidden">
-                    <text fg={t.textMuted} selectable={false} wrapMode="none">
-                      {' '}
-                      {'─'.repeat(contentWidth)}
-                    </text>
-                  </box>
-                </box>
-              ) : null}
-              <TabRowButton
-                tabId={tab.id}
-                onActivate={onTabActivate}
-                backgroundColor={getRowBackground({ alternate, isActive, t })}
-              >
-                {inGroup ? renderGroupGutter(isGroupStart, isGroupMiddle, isGroupEnd) : null}
-                <box flexGrow={1}>
-                  <TabItem
-                    id={`sidebar-tab-${tab.id}`}
-                    tab={tab}
-                    active={isActive}
-                    focused={focusMode === 'navigation'}
-                    inLayout={inLayout}
-                    moveWorktreeId={moveWorktreeId}
-                  />
-                </box>
-              </TabRowButton>
-            </box>
-          )
-        })
-      )}
-    </scrollbox>
-  )
-})
-
-export function Sidebar({
-  onEmbeddedGitResizeStart,
-  onResizeDrag,
-  onResizeDragEnd,
-  onTabActivate,
-}: SidebarProps) {
+export function Sidebar({ onEmbeddedGitResizeStart, onResizeDrag, onResizeDragEnd }: SidebarProps) {
   const t = useTheme()
   const sidebarBg = t.background
   const sidebarVisible = useAppStore((s) => s.sidebar.visible)
@@ -353,7 +30,6 @@ export function Sidebar({
   const gitPane = useAppStore((s) => s.gitPane)
   const focusMode = useAppStore((s) => s.focusMode)
   const bodyRef = useRef<BoxRenderable | null>(null)
-  useWorktreeDivergencePolling(sidebarVisible)
 
   const handleSidebarMouseDown = useCallback(() => {
     if (focusMode === 'terminal-input') {
@@ -418,15 +94,10 @@ export function Sidebar({
     }
   )
 
-  // flex-grow scaled by 100 (integer preferred); tabs gets (1-ratio), git gets ratio.
-  const tabsGrow = gitEmbedded ? Math.max(1, Math.round((1 - gitPane.embeddedRatio) * 100)) : 1
+  // flex-grow scaled by 100 (integer preferred); workspace list gets (1-ratio), git gets ratio.
+  const listGrow = gitEmbedded ? Math.max(1, Math.round((1 - gitPane.embeddedRatio) * 100)) : 1
   const gitGrow = gitEmbedded ? Math.max(1, Math.round(gitPane.embeddedRatio * 100)) : 0
 
-  const separator = (
-    <text fg={t.textMuted} selectable={false}>
-      {'·'.repeat(Math.max(0, contentWidth - 2))}
-    </text>
-  )
   const gitBody = gitEmbedded ? (
     <ContextMenuBox
       flexDirection="column"
@@ -462,7 +133,6 @@ export function Sidebar({
     >
       <box flexDirection="row" width={sidebarWidth} flexGrow={1} overflow="hidden">
         <box width={contentWidth} flexGrow={1} flexDirection="column" overflow="hidden">
-          <SidebarTop contentWidth={contentWidth} />
           <box ref={bodyRef} flexDirection="column" flexGrow={1} overflow="hidden">
             {gitOnTop ? (
               <>
@@ -472,12 +142,12 @@ export function Sidebar({
             ) : null}
             <box
               flexDirection="column"
-              flexGrow={tabsGrow}
+              flexGrow={listGrow}
               flexShrink={1}
               flexBasis={0}
               overflow="hidden"
             >
-              <TabsBody onTabActivate={onTabActivate} contentWidth={contentWidth} />
+              <WorkspaceList contentWidth={contentWidth} />
             </box>
             {gitOnBottom ? (
               <>
@@ -486,7 +156,6 @@ export function Sidebar({
               </>
             ) : null}
           </box>
-          {!gitEmbedded ? separator : null}
         </box>
       </box>
     </ContextMenuBox>