@brimveyn/aimux 1.16.2 → 1.18.1

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

@@ -16,6 +16,7 @@ import { IDLE_SESSION_STATUS } from '../../../../state/types'
 import { useBusySpinner } from '../../../hooks/use-busy-spinner'
 import { moveIdToIdPosition, orderSessionsForDisplay } from '../../../session-ordering'
 import { 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'
@@ -394,6 +395,9 @@ const WorkspaceRow = memo(function WorkspaceRow({
         </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>

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

@@ -8,6 +8,7 @@ import { useAppStore } from '../../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../../state/dispatch-ref'
 import { formatDivergence } from '../../../../state/session-worktrees'
 import { useTheme } from '../../../theme'
+import { FlashLabelBadge } from '../../flash/flash-label-badge'
 import { ContextMenuBox } from '../../overlays/context-menu/context-menu-box'
 
 interface WorktreeRowProps {
@@ -127,6 +128,7 @@ export const WorktreeRow = memo(function WorktreeRow({
         <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>

package/src/ui/components/layout/top-tab-bar.tsx

@@ -15,6 +15,7 @@ import { filterTabsForActiveWorktree } from '../../../state/session-worktrees'
 import { buildTabEntries, type GroupEntry, type TabEntry } from '../../../state/tab-entries'
 import { moveIdToIdPosition } from '../../session-ordering'
 import { useTheme } from '../../theme'
+import { FlashLabelBadge } from '../flash/flash-label-badge'
 import { ContextMenuBox } from '../overlays/context-menu/context-menu-box'
 import { TabItem } from './sidebar/tab-item'
 import { useTopTabBarAutoScroll } from './sidebar/use-top-tab-bar-auto-scroll'
@@ -161,6 +162,7 @@ function GroupTabItem({
                 {' | '}
               </text>
             ) : null}
+            <FlashLabelBadge rowKey={`tab:${tab.id}`} />
             <text fg={isLeafActive ? t.text : t.textMuted} selectable={false} wrapMode="none">
               {tab.title}
             </text>

package/src/ui/flash/assign-labels.ts

@@ -0,0 +1,126 @@
+export interface FlashTarget {
+  /** Stable identity (used by callers to pair labels back with their target). */
+  key: string
+  /** Display name used to pick a nice first-letter label when possible. */
+  name: string
+}
+
+export interface AssignedLabel {
+  key: string
+  label: string
+}
+
+/**
+ * Pool of letters used as labels — home row first (easiest to reach), then the
+ * rest of the alphabet. Lowercase a–z only; the flash-jump mode handler relies
+ * on letter input being lowercase ASCII.
+ */
+const POOL: string[] = [
+  'a',
+  's',
+  'd',
+  'f',
+  'g',
+  'h',
+  'j',
+  'k',
+  'l',
+  'q',
+  'w',
+  'e',
+  'r',
+  't',
+  'y',
+  'u',
+  'i',
+  'o',
+  'p',
+  'z',
+  'x',
+  'c',
+  'v',
+  'b',
+  'n',
+  'm',
+]
+
+/**
+ * Extract the first lowercase alphanumeric letter of a name (for the
+ * "prefer the actual first letter" heuristic). Returns null when the name has
+ * no usable character.
+ */
+function firstAlphaLetter(name: string): string | null {
+  for (const raw of name) {
+    const ch = raw.toLowerCase()
+    if (ch >= 'a' && ch <= 'z') return ch
+  }
+  return null
+}
+
+/**
+ * Assign 1- or 2-char labels to a list of targets in display order.
+ *
+ * Algorithm:
+ * - Up to (POOL.length - reserved) targets get 1-char labels. We try to give
+ *   each target its real first letter when it's still free; otherwise pull
+ *   from the pool.
+ * - If the list overflows the single-char budget, the last pool letter is
+ *   reserved as a 2-char prefix and the overflow gets `<prefix><letter>`
+ *   labels (also drawn from POOL).
+ * - When a target's preferred first letter is needed as the 2-char prefix
+ *   (or already taken), we fall back to the next available pool letter.
+ *
+ * The function never returns colliding labels and never returns a label
+ * `xy` whose prefix `x` is also a 1-char label — letting the input handler
+ * resolve on each keystroke unambiguously.
+ */
+export function assignFlashLabels(targets: FlashTarget[]): AssignedLabel[] {
+  if (targets.length === 0) return []
+
+  const singleBudget = targets.length <= POOL.length ? POOL.length : POOL.length - 1
+  const needsPrefix = targets.length > POOL.length
+  const prefixLetter = needsPrefix ? (POOL.at(-1) ?? null) : null
+  const singlePool = needsPrefix ? POOL.slice(0, POOL.length - 1) : [...POOL]
+
+  const used = new Set<string>()
+  const result: AssignedLabel[] = []
+
+  const singleSlice = targets.slice(0, singleBudget)
+  for (const target of singleSlice) {
+    const preferred = firstAlphaLetter(target.name)
+    if (preferred !== null && preferred !== prefixLetter && !used.has(preferred)) {
+      used.add(preferred)
+      result.push({ key: target.key, label: preferred })
+      continue
+    }
+    const next = singlePool.find((letter) => !used.has(letter))
+    if (next === undefined) {
+      // Single-letter pool exhausted — push remaining targets to the 2-char
+      // overflow path below.
+      result.push({ key: target.key, label: '' })
+      continue
+    }
+    used.add(next)
+    result.push({ key: target.key, label: next })
+  }
+
+  if (!needsPrefix) {
+    return result.filter((entry) => entry.label !== '')
+  }
+
+  const prefix = prefixLetter as string
+  const overflow = targets.slice(singleBudget)
+  const usedSecondary = new Set<string>()
+  for (const target of overflow) {
+    const preferred = firstAlphaLetter(target.name)
+    const second =
+      preferred !== null && !usedSecondary.has(preferred)
+        ? preferred
+        : (POOL.find((letter) => !usedSecondary.has(letter)) ?? null)
+    if (second === null) break
+    usedSecondary.add(second)
+    result.push({ key: target.key, label: `${prefix}${second}` })
+  }
+
+  return result.filter((entry) => entry.label !== '')
+}

package/src/ui/flash/build-labels.ts

@@ -0,0 +1,78 @@
+import type { AppState, FlashJumpTarget, FlashLabel } from '../../state/types'
+
+import { filterTabsForActiveWorktree } from '../../state/session-worktrees'
+import { orderSessionsForDisplay } from '../session-ordering'
+import { assignFlashLabels, type FlashTarget } from './assign-labels'
+
+interface PendingTarget {
+  key: string
+  name: string
+  target: FlashJumpTarget
+}
+
+/**
+ * Collect every visible flash-jump target in the same order the UI renders:
+ * workspace rows first (each followed by its non-primary worktrees), then the
+ * tabs of the active worktree. Stable ordering keeps the assigned labels
+ * predictable across re-opens when nothing changed.
+ */
+function collectTargets(state: AppState): PendingTarget[] {
+  const out: PendingTarget[] = []
+  const ordered = orderSessionsForDisplay(state.sessions)
+  for (const [index, session] of ordered.entries()) {
+    const sessionIndex = index + 1
+    const worktrees = session.worktrees ?? []
+    const primary = worktrees.find((w) => w.source === 'primary') ?? worktrees[0]
+    out.push({
+      key: `ws:${session.id}`,
+      name: session.name,
+      target: {
+        kind: 'workspace',
+        sessionId: session.id,
+        sessionIndex,
+        worktreeId: primary?.id,
+      },
+    })
+    for (const worktree of worktrees) {
+      if (worktree.id === primary?.id) continue
+      out.push({
+        key: `wt:${worktree.id}`,
+        name: worktree.name,
+        target: {
+          kind: 'worktree',
+          sessionId: session.id,
+          sessionIndex,
+          worktreeId: worktree.id,
+        },
+      })
+    }
+  }
+
+  const currentSession = state.sessions.find((s) => s.id === state.currentSessionId)
+  if (currentSession) {
+    const tabs = filterTabsForActiveWorktree(state.tabs, currentSession)
+    for (const tab of tabs) {
+      out.push({
+        key: `tab:${tab.id}`,
+        name: tab.title,
+        target: { kind: 'tab', sessionId: currentSession.id, sessionIndex: 0, tabId: tab.id },
+      })
+    }
+  }
+
+  return out
+}
+
+export function buildFlashJumpLabels(state: AppState): FlashLabel[] {
+  const pending = collectTargets(state)
+  const flashTargets: FlashTarget[] = pending.map(({ key, name }) => ({ key, name }))
+  const assigned = assignFlashLabels(flashTargets)
+  const byKey = new Map(pending.map((entry) => [entry.key, entry.target]))
+  const out: FlashLabel[] = []
+  for (const { key, label } of assigned) {
+    const target = byKey.get(key)
+    if (!target) continue
+    out.push({ key, label, target })
+  }
+  return out
+}

package/src/ui/hooks/use-flash-label.ts

@@ -0,0 +1,40 @@
+import { useAppStore } from '../../state/app-store'
+
+export interface FlashLabelView {
+  /** Full label, e.g. "a" or "fk". */
+  label: string
+  /** Already-typed prefix length — the rendered label dims that segment. */
+  matchedLen: number
+  /** Suffix still to be typed. */
+  remaining: string
+  /** True when the current buffer still matches this label's prefix. */
+  isActive: boolean
+}
+
+/**
+ * Subscribe to the flash-jump modal and return label info for the row keyed
+ * by `key` (e.g. `tab:<id>`, `ws:<id>`, `wt:<id>`). Returns null when the
+ * modal isn't active or the row isn't a target.
+ *
+ * Selects primitives (label and buffer) separately so the snapshot React sees
+ * stays referentially stable across renders. Returning a freshly-built object
+ * from a single selector would tell useSyncExternalStore "state changed" on
+ * every render and infinite-loop.
+ */
+export function useFlashLabel(key: string): FlashLabelView | null {
+  const label = useAppStore((s) => {
+    if (s.modal.type !== 'flash-jump') return null
+    const entry = s.modal.labels.find((l) => l.key === key)
+    return entry?.label ?? null
+  })
+  const buffer = useAppStore((s) => (s.modal.type === 'flash-jump' ? s.modal.buffer : ''))
+  if (label === null) return null
+  const isActive = label.startsWith(buffer)
+  const matchedLen = isActive ? buffer.length : 0
+  return {
+    isActive,
+    label,
+    matchedLen,
+    remaining: isActive ? label.slice(buffer.length) : label,
+  }
+}

package/src/ui/root.tsx

@@ -267,6 +267,9 @@ function renderModal(
         />
       )
     }
+    case 'flash-jump':
+      // Pure overlay — rendered inline by FlashLabelBadge inside the rows.
+      return null
     case null:
       return null
     default: