@brimveyn/aimux 1.5.0 → 1.6.0

package/src/state/git-tree.ts

@@ -0,0 +1,220 @@
+import type { GitFileEntry, GitFileListMode, GitFileSection } from './types'
+
+const SECTION_ORDER: GitFileSection[] = ['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
+}

package/src/state/reducers/git-mode-state.ts

@@ -1,14 +1,70 @@
-import type { AppAction, AppState, GitFileEntry, GitModeState } from '../types'
+import type { AppAction, AppState, FoldState, GitFileEntry, GitModeState } from '../types'
 
+import {
+  getSelectedGitRow,
+  gitFileKey,
+  moveGitFileSelection,
+  moveGitSelection,
+  reconcileSelectedGitEntryKey,
+} from '../git-tree'
 import { sortFilesBySection } from './git-panel-state'
 
+function applyFold(state: AppState, key: string, foldId: string, next: FoldState): AppState {
+  const perPath = state.gitMode.folds[key] ?? {}
+  const prev = perPath[foldId] ?? { bottom: 0, top: 0 }
+  if (prev.top === next.top && prev.bottom === next.bottom) return state
+  const nextPerPath = { ...perPath }
+  if (next.top === 0 && next.bottom === 0) {
+    delete nextPerPath[foldId]
+  } else {
+    nextPerPath[foldId] = next
+  }
+  const nextFolds = { ...state.gitMode.folds }
+  if (Object.keys(nextPerPath).length === 0) {
+    delete nextFolds[key]
+  } else {
+    nextFolds[key] = nextPerPath
+  }
+  return { ...state, gitMode: { ...state.gitMode, folds: nextFolds } }
+}
+
+function clearDiffCacheForPath(state: AppState, path: string): AppState {
+  const nextDiffs = { ...state.gitMode.diffs }
+  const nextFolds = { ...state.gitMode.folds }
+  const nextLoading = { ...state.gitMode.loading }
+  let changed = false
+  for (const key of Object.keys(nextDiffs)) {
+    if (nextDiffs[key]?.path !== path) continue
+    delete nextDiffs[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextFolds)) {
+    if (!key.endsWith(`:${path}`)) continue
+    delete nextFolds[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextLoading)) {
+    if (!key.endsWith(`:${path}`)) continue
+    delete nextLoading[key]
+    changed = true
+  }
+  if (!changed) return state
+  return {
+    ...state,
+    gitMode: { ...state.gitMode, diffs: nextDiffs, folds: nextFolds, loading: nextLoading },
+  }
+}
+
 export function emptyGitMode(): GitModeState {
   return {
     actionMessage: null,
+    collapsedFolders: {},
     diffs: {},
+    diffView: 'split',
+    folds: {},
     loading: {},
     pendingDeletePath: null,
-    selectedFileIndex: 0,
+    selectedEntryKey: null,
   }
 }
 
@@ -23,7 +79,12 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
           ...state.gitMode,
           actionMessage: null,
           pendingDeletePath: null,
-          selectedFileIndex: 0,
+          selectedEntryKey: reconcileSelectedGitEntryKey(
+            state.gitPanel.files,
+            state.gitMode.collapsedFolders,
+            state.gitPane.fileListMode,
+            null
+          ),
         },
       }
     }
@@ -31,28 +92,152 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
       if (state.focusMode !== 'git') return state
       return { ...state, focusMode: 'navigation' }
     }
-    case 'git-mode-select-file': {
-      const total = state.gitPanel.files.length
-      if (total === 0) return state
-      const next = (state.gitMode.selectedFileIndex + action.delta + total) % total
-      if (next === state.gitMode.selectedFileIndex) return state
+    case 'git-mode-move-selection': {
+      const next = moveGitSelection(
+        state.gitPanel.files,
+        state.gitMode.collapsedFolders,
+        state.gitPane.fileListMode,
+        state.gitMode.selectedEntryKey,
+        action.delta
+      )
+      if (!next || next === state.gitMode.selectedEntryKey) return state
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          pendingDeletePath: null,
+          selectedEntryKey: next,
+        },
+      }
+    }
+    case 'git-mode-move-file-selection': {
+      const next = moveGitFileSelection(
+        state.gitPanel.files,
+        state.gitMode.collapsedFolders,
+        state.gitPane.fileListMode,
+        state.gitMode.selectedEntryKey,
+        action.delta
+      )
+      if (!next || next === state.gitMode.selectedEntryKey) return state
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          pendingDeletePath: null,
+          selectedEntryKey: next,
+        },
+      }
+    }
+    case 'git-mode-select-entry-by-key': {
+      const next = reconcileSelectedGitEntryKey(
+        state.gitPanel.files,
+        state.gitMode.collapsedFolders,
+        state.gitPane.fileListMode,
+        state.gitMode.selectedEntryKey,
+        [action.key]
+      )
+      if (!next || next !== action.key || next === state.gitMode.selectedEntryKey) return state
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          pendingDeletePath: null,
+          selectedEntryKey: next,
+        },
+      }
+    }
+    case 'git-mode-toggle-folder': {
+      const row = getSelectedGitRow(state.gitPanel.files, {
+        collapsedFolders: state.gitMode.collapsedFolders,
+        fileListMode: state.gitPane.fileListMode,
+        selectedEntryKey: action.key,
+      })
+      if (!row || row.kind !== 'folder') return state
+      const nextCollapsed = { ...state.gitMode.collapsedFolders }
+      if (action.key in nextCollapsed) {
+        delete nextCollapsed[action.key]
+      } else {
+        nextCollapsed[action.key] = true
+      }
+      return { ...state, gitMode: { ...state.gitMode, collapsedFolders: nextCollapsed } }
+    }
+    case 'git-mode-toggle-selected-folder': {
+      const row = getSelectedGitRow(state.gitPanel.files, {
+        collapsedFolders: state.gitMode.collapsedFolders,
+        fileListMode: state.gitPane.fileListMode,
+        selectedEntryKey: state.gitMode.selectedEntryKey,
+      })
+      if (!row || row.kind !== 'folder') return state
+      const nextCollapsed = { ...state.gitMode.collapsedFolders }
+      if (row.key in nextCollapsed) {
+        delete nextCollapsed[row.key]
+      } else {
+        nextCollapsed[row.key] = true
+      }
+      return { ...state, gitMode: { ...state.gitMode, collapsedFolders: nextCollapsed } }
+    }
+    case 'git-mode-collapse-selection': {
+      const row = getSelectedGitRow(state.gitPanel.files, {
+        collapsedFolders: state.gitMode.collapsedFolders,
+        fileListMode: state.gitPane.fileListMode,
+        selectedEntryKey: state.gitMode.selectedEntryKey,
+      })
+      if (!row) return state
+      if (row.kind === 'folder' && !row.isCollapsed) {
+        return {
+          ...state,
+          gitMode: {
+            ...state.gitMode,
+            collapsedFolders: { ...state.gitMode.collapsedFolders, [row.key]: true },
+          },
+        }
+      }
+      if (!row.parentKey || row.parentKey === state.gitMode.selectedEntryKey) return state
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          pendingDeletePath: null,
+          selectedEntryKey: row.parentKey,
+        },
+      }
+    }
+    case 'git-mode-expand-selection': {
+      const row = getSelectedGitRow(state.gitPanel.files, {
+        collapsedFolders: state.gitMode.collapsedFolders,
+        fileListMode: state.gitPane.fileListMode,
+        selectedEntryKey: state.gitMode.selectedEntryKey,
+      })
+      if (!row || row.kind !== 'folder' || !row.isCollapsed) return state
+      const nextCollapsed = { ...state.gitMode.collapsedFolders }
+      delete nextCollapsed[row.key]
+      return { ...state, gitMode: { ...state.gitMode, collapsedFolders: nextCollapsed } }
+    }
+    case 'git-mode-toggle-file-list-mode': {
+      const fileListMode = state.gitPane.fileListMode === 'tree' ? 'flat' : 'tree'
       return {
         ...state,
         gitMode: {
           ...state.gitMode,
           pendingDeletePath: null,
-          selectedFileIndex: next,
+          selectedEntryKey: reconcileSelectedGitEntryKey(
+            state.gitPanel.files,
+            state.gitMode.collapsedFolders,
+            fileListMode,
+            state.gitMode.selectedEntryKey
+          ),
         },
+        gitPane: { ...state.gitPane, fileListMode },
       }
     }
     case 'git-mode-set-diff': {
       const nextLoading = { ...state.gitMode.loading }
-      delete nextLoading[action.path]
+      delete nextLoading[action.key]
       return {
         ...state,
         gitMode: {
           ...state.gitMode,
-          diffs: { ...state.gitMode.diffs, [action.path]: action.diff },
+          diffs: { ...state.gitMode.diffs, [action.key]: action.diff },
           loading: nextLoading,
         },
       }
@@ -60,9 +245,9 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
     case 'git-mode-set-loading': {
       const nextLoading = { ...state.gitMode.loading }
       if (action.loading) {
-        nextLoading[action.path] = true
+        nextLoading[action.key] = true
       } else {
-        delete nextLoading[action.path]
+        delete nextLoading[action.key]
       }
       return { ...state, gitMode: { ...state.gitMode, loading: nextLoading } }
     }
@@ -71,17 +256,33 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
       return { ...state, gitMode: { ...state.gitMode, pendingDeletePath: action.path } }
     }
     case 'git-mode-clear-diff-cache': {
-      if (!(action.path in state.gitMode.diffs)) return state
-      const nextDiffs = { ...state.gitMode.diffs }
-      delete nextDiffs[action.path]
-      return { ...state, gitMode: { ...state.gitMode, diffs: nextDiffs } }
+      return clearDiffCacheForPath(state, action.path)
     }
     case 'git-mode-set-message': {
       if (state.gitMode.actionMessage === action.message) return state
       return { ...state, gitMode: { ...state.gitMode, actionMessage: action.message } }
     }
+    case 'git-mode-toggle-diff-view': {
+      const next = state.gitMode.diffView === 'split' ? 'stacked' : 'split'
+      return { ...state, gitMode: { ...state.gitMode, diffView: next } }
+    }
+    case 'git-mode-fold-adjust': {
+      const perPath = state.gitMode.folds[action.key] ?? {}
+      const prev = perPath[action.foldId] ?? { bottom: 0, top: 0 }
+      const nextSide = Math.max(0, prev[action.side] + action.delta)
+      const nextFold =
+        action.side === 'top'
+          ? { bottom: prev.bottom, top: nextSide }
+          : { bottom: nextSide, top: prev.top }
+      return applyFold(state, action.key, action.foldId, nextFold)
+    }
+    case 'git-mode-fold-set': {
+      const top = Math.max(0, action.top)
+      const bottom = Math.max(0, action.bottom)
+      return applyFold(state, action.key, action.foldId, { bottom, top })
+    }
     case 'git-mode-optimistic-move': {
-      const currentIdx = state.gitMode.selectedFileIndex
+      const currentKey = state.gitMode.selectedEntryKey
       const files = state.gitPanel.files
       const idx = files.findIndex((f) => f.path === action.path && f.section === action.fromSection)
       if (idx < 0) return state
@@ -103,29 +304,25 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
         }
       }
       nextFiles = sortFilesBySection(nextFiles)
-
-      const newLen = nextFiles.length
-      let nextIdx: number
-      if (newLen === 0) {
-        nextIdx = 0
-      } else {
-        const movedIdx =
-          toSection === null
-            ? -1
-            : nextFiles.findIndex((f) => f.path === action.path && f.section === toSection)
-        if (movedIdx === currentIdx) {
-          nextIdx = (currentIdx + 1) % newLen
-        } else {
-          nextIdx = Math.min(currentIdx, newLen - 1)
-        }
-      }
+      const movedCurrentKey = gitFileKey({ path: action.path, section: action.fromSection })
+      const preferredSelection =
+        currentKey === movedCurrentKey && toSection !== null
+          ? [gitFileKey({ path: action.path, section: toSection })]
+          : []
+      const nextSelectedEntryKey = reconcileSelectedGitEntryKey(
+        nextFiles,
+        state.gitMode.collapsedFolders,
+        state.gitPane.fileListMode,
+        currentKey,
+        preferredSelection
+      )
 
       return {
         ...state,
         gitMode: {
           ...state.gitMode,
           pendingDeletePath: null,
-          selectedFileIndex: nextIdx,
+          selectedEntryKey: nextSelectedEntryKey,
         },
         gitPanel: { ...state.gitPanel, files: nextFiles },
       }

package/src/state/reducers/git-panel-state.ts

@@ -1,5 +1,7 @@
 import type { AppAction, AppState, GitFileEntry, GitFileSection, GitPanelState } from '../types'
 
+import { reconcileSelectedGitEntryKey } from '../git-tree'
+
 export const GIT_PANEL_MIN_RATIO = 0.2
 export const GIT_PANEL_MAX_RATIO = 0.8
 
@@ -63,6 +65,11 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
       if (nextRatio === state.gitPane.ratio) return state
       return { ...state, gitPane: { ...state.gitPane, ratio: nextRatio } }
     }
+    case 'resize-git-diff-pane': {
+      const nextRatio = clampRatio(state.gitPane.diffModeRatio + action.delta)
+      if (nextRatio === state.gitPane.diffModeRatio) return state
+      return { ...state, gitPane: { ...state.gitPane, diffModeRatio: nextRatio } }
+    }
     case 'set-git-pane-mode': {
       if (state.gitPane.mode === action.mode) return state
       const isEmbedded = action.mode === 'embedded'
@@ -93,17 +100,25 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
       const prev = state.gitPanel
       const next = action.payload
       const sortedNext = sortFilesBySection(next.files)
+      const nextSelectedEntryKey = reconcileSelectedGitEntryKey(
+        sortedNext,
+        state.gitMode.collapsedFolders,
+        state.gitPane.fileListMode,
+        state.gitMode.selectedEntryKey
+      )
       if (
         prev.branch === next.branch &&
         prev.ahead === next.ahead &&
         prev.behind === next.behind &&
         prev.error === null &&
-        sameFiles(prev.files, sortedNext)
+        sameFiles(prev.files, sortedNext) &&
+        nextSelectedEntryKey === state.gitMode.selectedEntryKey
       ) {
         return state
       }
       return {
         ...state,
+        gitMode: { ...state.gitMode, selectedEntryKey: nextSelectedEntryKey },
         gitPanel: {
           ...prev,
           ahead: next.ahead,
@@ -116,9 +131,16 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
     }
     case 'git-refresh-error': {
       const prev = state.gitPanel
-      if (prev.error === action.kind && prev.files.length === 0) return state
+      if (
+        prev.error === action.kind &&
+        prev.files.length === 0 &&
+        state.gitMode.selectedEntryKey === null
+      ) {
+        return state
+      }
       return {
         ...state,
+        gitMode: { ...state.gitMode, pendingDeletePath: null, selectedEntryKey: null },
         gitPanel: { ...prev, error: action.kind, files: [] },
       }
     }
@@ -133,7 +155,11 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
       ) {
         return state
       }
-      return { ...state, gitPanel: emptyGitPanel() }
+      return {
+        ...state,
+        gitMode: { ...state.gitMode, pendingDeletePath: null, selectedEntryKey: null },
+        gitPanel: emptyGitPanel(),
+      }
     }
     default:
       return null