@brimveyn/aimux 1.5.4 → 1.6.1

package/src/git/git-status.ts

@@ -16,6 +16,7 @@ interface NumstatRow {
 export type GitCollectResult =
   | { kind: 'ok'; payload: GitRefreshPayload }
   | { kind: 'error'; error: GitPanelError }
+  | { kind: 'out-of-range'; maxOffset: number }
 
 const STATUS_CODES = new Set(['M', 'A', 'D', 'R', 'C', 'U', '?'])
 
@@ -189,26 +190,106 @@ async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Prom
   }
 }
 
-export async function collectGitStatus(cwd: string): Promise<GitCollectResult> {
-  try {
-    const [statusResult, unstagedDiff, stagedDiff] = await Promise.all([
-      $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
-      $`git -C ${cwd} -c core.quotePath=false diff --numstat`.quiet().nothrow(),
-      $`git -C ${cwd} -c core.quotePath=false diff --cached --numstat`.quiet().nothrow(),
-    ])
-
-    if (statusResult.exitCode !== 0) {
-      return { error: 'not-a-repo', kind: 'error' }
+interface CollectOptions {
+  headOffset?: number
+}
+
+function parseNameStatus(
+  output: string
+): { path: string; status: GitFileStatus; renamedFrom?: string }[] {
+  const rows: { path: string; status: GitFileStatus; renamedFrom?: string }[] = []
+  for (const raw of output.split('\n')) {
+    if (!raw) continue
+    const parts = raw.split('\t')
+    const code = parts[0] ?? ''
+    const letter = code[0] ?? ''
+    const status = toStatus(letter)
+    if (!status) continue
+    if (letter === 'R' || letter === 'C') {
+      const from = parts[1]
+      const to = parts[2]
+      if (!from || !to) continue
+      rows.push({ path: to, renamedFrom: from, status })
+    } else {
+      const path = parts.slice(1).join('\t')
+      if (!path) continue
+      rows.push({ path, status })
     }
+  }
+  return rows
+}
+
+async function collectAgainstHead(cwd: string): Promise<GitCollectResult> {
+  const [statusResult, unstagedDiff, stagedDiff] = await Promise.all([
+    $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
+    $`git -C ${cwd} -c core.quotePath=false diff --numstat`.quiet().nothrow(),
+    $`git -C ${cwd} -c core.quotePath=false diff --cached --numstat`.quiet().nothrow(),
+  ])
 
-    const statusText = statusResult.text()
-    const { ahead, behind, branch } = parseBranchLines(statusText)
-    const unstagedNumstat = parseNumstat(unstagedDiff.text())
-    const stagedNumstat = parseNumstat(stagedDiff.text())
-    const files = parsePorcelainEntries(statusText, stagedNumstat, unstagedNumstat)
-    await annotateUntrackedCounts(cwd, files)
+  if (statusResult.exitCode !== 0) {
+    return { error: 'not-a-repo', kind: 'error' }
+  }
+
+  const statusText = statusResult.text()
+  const { ahead, behind, branch } = parseBranchLines(statusText)
+  const unstagedNumstat = parseNumstat(unstagedDiff.text())
+  const stagedNumstat = parseNumstat(stagedDiff.text())
+  const files = parsePorcelainEntries(statusText, stagedNumstat, unstagedNumstat)
+  await annotateUntrackedCounts(cwd, files)
 
-    return { kind: 'ok', payload: { ahead, behind, branch, files } }
+  return { kind: 'ok', payload: { ahead, behind, branch, files } }
+}
+
+async function collectAgainstHistorical(
+  cwd: string,
+  headOffset: number
+): Promise<GitCollectResult> {
+  const ref = `HEAD~${headOffset}`
+  const revParse = await $`git -C ${cwd} rev-parse ${ref}`.quiet().nothrow()
+  if (revParse.exitCode !== 0) {
+    const countResult = await $`git -C ${cwd} rev-list --count HEAD`.quiet().nothrow()
+    const count = countResult.exitCode === 0 ? Number.parseInt(countResult.text().trim(), 10) : NaN
+    const maxOffset = Number.isFinite(count) && count > 0 ? count - 1 : 0
+    return { kind: 'out-of-range', maxOffset }
+  }
+
+  const [statusResult, nameStatus, numstat, untrackedStatus] = await Promise.all([
+    $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
+    $`git -C ${cwd} -c core.quotePath=false diff ${ref} --name-status`.quiet().nothrow(),
+    $`git -C ${cwd} -c core.quotePath=false diff ${ref} --numstat`.quiet().nothrow(),
+    $`git -C ${cwd} status --porcelain=v2 -z --untracked-files=all`.quiet().nothrow(),
+  ])
+
+  if (statusResult.exitCode !== 0) {
+    return { error: 'not-a-repo', kind: 'error' }
+  }
+
+  const { ahead, behind, branch } = parseBranchLines(statusResult.text())
+  const stats = parseNumstat(numstat.text())
+  const rows = parseNameStatus(nameStatus.text())
+  const files: GitFileEntry[] = rows.map((row) =>
+    buildEntry('historical', row.status, row.path, stats, row.renamedFrom)
+  )
+
+  // Untracked files live outside any commit — still surface them so `?` files
+  // don't vanish when the user walks history.
+  const porcelain = parsePorcelainEntries(untrackedStatus.text(), new Map(), new Map())
+  const untracked = porcelain.filter((f) => f.section === 'untracked')
+  await annotateUntrackedCounts(cwd, untracked)
+  files.push(...untracked)
+
+  return { kind: 'ok', payload: { ahead, behind, branch, files } }
+}
+
+export async function collectGitStatus(
+  cwd: string,
+  options: CollectOptions = {}
+): Promise<GitCollectResult> {
+  const headOffset = options.headOffset ?? 0
+  try {
+    return headOffset > 0
+      ? await collectAgainstHistorical(cwd, headOffset)
+      : await collectAgainstHead(cwd)
   } catch {
     return { error: 'unknown', kind: 'error' }
   }

package/src/input/modes/bridge.ts

@@ -19,6 +19,7 @@ const COMMAND_EDIT_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
   'session-picker': 'modal.session-picker.filtering',
   'snippet-editor': 'modal.snippet-editor',
   'snippet-picker': 'modal.snippet-picker.filtering',
+  'theme-picker': 'modal.theme-picker.filtering',
 }
 
 const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
@@ -32,6 +33,13 @@ const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
 }
 
 export function deriveModeId(state: AppState): ModeId {
+  // Help renders as an overlay on top of git/navigation without flipping
+  // focusMode, so it needs modal-first dispatch. Filter sub-mode is tracked
+  // by editBuffer presence, not focusMode.
+  if (state.modal.type === 'help') {
+    return state.modal.editBuffer !== null ? 'modal.help.filtering' : 'modal.help'
+  }
+
   const directMode = DIRECT_FOCUS_MODE_IDS[state.focusMode]
   if (directMode) {
     return directMode

package/src/input/modes/transitions.ts

@@ -21,7 +21,8 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'modal.snippet-picker': ['navigation', 'modal.snippet-picker.filtering', 'modal.snippet-editor'],
   'modal.snippet-picker.filtering': ['modal.snippet-picker'],
   'modal.split-picker': ['navigation', 'terminal-input'],
-  'modal.theme-picker': ['navigation'],
+  'modal.theme-picker': ['navigation', 'modal.theme-picker.filtering'],
+  'modal.theme-picker.filtering': ['modal.theme-picker'],
   'modal.update-available': ['navigation'],
   'navigation': [
     'terminal-input',

package/src/input/modes/types.ts

@@ -1,6 +1,6 @@
 import type { KeyEvent } from '@opentui/core'
 
-import type { AppAction, AppState, TabSession } from '../../state/types'
+import type { AppAction, AppState, GitFileListMode, TabSession } from '../../state/types'
 
 export type ModeId =
   | 'navigation'
@@ -17,6 +17,7 @@ export type ModeId =
   | 'modal.snippet-picker.filtering'
   | 'modal.snippet-editor'
   | 'modal.theme-picker'
+  | 'modal.theme-picker.filtering'
   | 'modal.help'
   | 'modal.help.filtering'
   | 'modal.split-picker'
@@ -46,6 +47,8 @@ export type SideEffect =
   | { type: 'split-pane'; direction: import('../../state/layout-tree').SplitDirection }
   | { type: 'confirm-split' }
   | { type: 'scroll-git-diff'; delta: number }
+  | { type: 'persist-git-diff-mode-ratio'; ratio: number }
+  | { type: 'persist-git-file-list-mode'; mode: GitFileListMode }
   | { type: 'git-stage'; path: string }
   | { type: 'git-unstage'; path: string }
   | { type: 'git-restore'; path: string }

package/src/pty/terminal-snapshot.ts

@@ -2,7 +2,7 @@ import type { Terminal } from '@xterm/headless'
 
 import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
 
-import { theme } from '../ui/theme'
+import { getCurrentTheme } from '../ui/theme'
 
 const ANSI_PALETTE = [
   '#000000',
@@ -113,15 +113,15 @@ function buildLine(
     let bg = getColorHex(current.getBgColor(), bgMode)
 
     if (current.isInverse()) {
-      const resolvedFg = fg ?? theme.text
-      const resolvedBg = bg ?? theme.background
+      const resolvedFg = fg ?? getCurrentTheme().colors['editor.foreground']
+      const resolvedBg = bg ?? getCurrentTheme().colors['editor.background']
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 
     const isCursorCell = cursorVisible && cursorColumn === column
     if (isCursorCell) {
-      const resolvedFg = fg ?? theme.text
-      const resolvedBg = bg ?? theme.background
+      const resolvedFg = fg ?? getCurrentTheme().colors['editor.foreground']
+      const resolvedBg = bg ?? getCurrentTheme().colors['editor.background']
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 

package/src/state/git-tree.ts

@@ -0,0 +1,220 @@
+import type { GitFileEntry, GitFileListMode, GitFileSection } from './types'
+
+const SECTION_ORDER: GitFileSection[] = ['historical', 'staged', 'unstaged', 'untracked']
+
+interface GitTreeNode {
+  files: GitFileEntry[]
+  folders: Map<string, GitTreeNode>
+  path: string
+  section: GitFileSection
+}
+
+export interface GitTreeFolderRow {
+  kind: 'folder'
+  key: string
+  section: GitFileSection
+  depth: number
+  name: string
+  folderPath: string
+  parentKey?: string
+  isCollapsed: boolean
+}
+
+export interface GitTreeFileRow {
+  kind: 'file'
+  key: string
+  section: GitFileSection
+  depth: number
+  file: GitFileEntry
+  parentKey?: string
+}
+
+export type GitTreeRow = GitTreeFolderRow | GitTreeFileRow
+
+export interface GitTreeSectionRows {
+  section: GitFileSection
+  files: GitFileEntry[]
+  rows: GitTreeRow[]
+}
+
+export interface GitTreeRows {
+  sections: GitTreeSectionRows[]
+  visibleRows: GitTreeRow[]
+}
+
+export function gitFileKey(file: Pick<GitFileEntry, 'path' | 'section'>): string {
+  return `${file.section}:${file.path}`
+}
+
+export function gitFolderKey(section: GitFileSection, folderPath: string): string {
+  return `${section}:dir:${folderPath}`
+}
+
+export function buildGitTreeRows(
+  files: GitFileEntry[],
+  collapsedFolders: Record<string, true>,
+  fileListMode: GitFileListMode = 'tree'
+): GitTreeRows {
+  const sections = SECTION_ORDER.map((section) => {
+    const sectionFiles = files.filter((file) => file.section === section)
+    return {
+      files: sectionFiles,
+      rows:
+        fileListMode === 'flat'
+          ? sectionFiles.map((file) => ({
+              depth: 0,
+              file,
+              key: gitFileKey(file),
+              kind: 'file' as const,
+              section,
+            }))
+          : flattenSectionRows(sectionFiles, collapsedFolders),
+      section,
+    }
+  })
+  return { sections, visibleRows: sections.flatMap((section) => section.rows) }
+}
+
+export function getSelectedGitRow(
+  files: GitFileEntry[],
+  options: {
+    collapsedFolders: Record<string, true>
+    fileListMode: GitFileListMode
+    selectedEntryKey: string | null
+  }
+): GitTreeRow | null {
+  if (!options.selectedEntryKey) return null
+  const { visibleRows } = buildGitTreeRows(files, options.collapsedFolders, options.fileListMode)
+  return visibleRows.find((row) => row.key === options.selectedEntryKey) ?? null
+}
+
+export function getSelectedGitFile(
+  files: GitFileEntry[],
+  options: {
+    collapsedFolders: Record<string, true>
+    fileListMode: GitFileListMode
+    selectedEntryKey: string | null
+  }
+): GitFileEntry | null {
+  const row = getSelectedGitRow(files, options)
+  return row?.kind === 'file' ? row.file : null
+}
+
+export function reconcileSelectedGitEntryKey(
+  files: GitFileEntry[],
+  collapsedFolders: Record<string, true>,
+  fileListMode: GitFileListMode,
+  selectedEntryKey: string | null | undefined,
+  preferredKeys: string[] = []
+): string | null {
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  if (visibleRows.length === 0) return null
+  const candidates = [...preferredKeys, selectedEntryKey ?? '']
+  for (const key of candidates) {
+    if (!key) continue
+    if (visibleRows.some((row) => row.key === key)) return key
+  }
+  return visibleRows[0]?.key ?? null
+}
+
+export function moveGitSelection(
+  files: GitFileEntry[],
+  collapsedFolders: Record<string, true>,
+  fileListMode: GitFileListMode,
+  selectedEntryKey: string | null,
+  delta: -1 | 1
+): string | null {
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const total = visibleRows.length
+  if (total === 0) return null
+  const current = visibleRows.findIndex((row) => row.key === selectedEntryKey)
+  const base = current >= 0 ? current : 0
+  return visibleRows[(base + delta + total) % total]?.key ?? null
+}
+
+export function moveGitFileSelection(
+  files: GitFileEntry[],
+  collapsedFolders: Record<string, true>,
+  fileListMode: GitFileListMode,
+  selectedEntryKey: string | null,
+  delta: -1 | 1
+): string | null {
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const fileRows = visibleRows.filter((row) => row.kind === 'file')
+  const total = fileRows.length
+  if (total === 0) return null
+  const current = fileRows.findIndex((row) => row.key === selectedEntryKey)
+  let base = current
+  if (base < 0) {
+    base = delta > 0 ? -1 : 0
+  }
+  return fileRows[(base + delta + total) % total]?.key ?? null
+}
+
+function flattenSectionRows(
+  files: GitFileEntry[],
+  collapsedFolders: Record<string, true>
+): GitTreeRow[] {
+  if (files.length === 0) return []
+  const section = files[0]?.section
+  if (!section) return []
+  const root = buildSectionTree(files, section)
+  return flattenTreeNode(root, collapsedFolders, 0)
+}
+
+function buildSectionTree(files: GitFileEntry[], section: GitFileSection): GitTreeNode {
+  const root: GitTreeNode = { files: [], folders: new Map(), path: '', section }
+  for (const file of files) {
+    const parts = file.path.split('/')
+    let cursor = root
+    for (let i = 0; i < parts.length - 1; i++) {
+      const name = parts[i]
+      if (!name) continue
+      const nextPath = cursor.path ? `${cursor.path}/${name}` : name
+      let child = cursor.folders.get(name)
+      if (!child) {
+        child = { files: [], folders: new Map(), path: nextPath, section }
+        cursor.folders.set(name, child)
+      }
+      cursor = child
+    }
+    cursor.files.push(file)
+  }
+  return root
+}
+
+function flattenTreeNode(
+  node: GitTreeNode,
+  collapsedFolders: Record<string, true>,
+  depth: number,
+  parentKey?: string
+): GitTreeRow[] {
+  const rows: GitTreeRow[] = []
+  for (const child of node.folders.values()) {
+    const name = child.path.split('/').pop() ?? child.path
+    const key = gitFolderKey(node.section, child.path)
+    const isCollapsed = key in collapsedFolders
+    rows.push({
+      depth,
+      folderPath: child.path,
+      isCollapsed,
+      key,
+      kind: 'folder',
+      name,
+      parentKey,
+      section: node.section,
+    })
+    if (!isCollapsed) rows.push(...flattenTreeNode(child, collapsedFolders, depth + 1, key))
+  }
+  for (const file of node.files) {
+    rows.push({
+      depth,
+      file,
+      key: gitFileKey(file),
+      kind: 'file',
+      parentKey,
+      section: file.section,
+    })
+  }
+  return rows
+}