@brimveyn/aimux 1.1.0 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.1.0",
+  "version": "1.2.5",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -54,11 +54,10 @@
     "restart-daemon": "bun run src/index.tsx restart-daemon",
     "lint": "oxlint .",
     "format": "oxfmt --write .",
-    "format:check": "oxfmt --check .",
-    "prepare": "lefthook install"
+    "format:check": "oxfmt --check ."
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "^0.1.0",
+    "@brimveyn/aimux-config": "0.1.0",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/side-effects.ts

@@ -1,9 +1,12 @@
+import { $ } from 'bun'
+
 import type { SideEffect } from '../input/modes/types'
 import type { SessionBackend } from '../session-backend/types'
 import type { AppAction, AppState, AssistantId, TabSession } from '../state/types'
 
 import { loadConfig, saveConfig } from '../config'
 import { logInputDebug } from '../debug/input-log'
+import { enqueueGitOp } from '../git/command-queue'
 import { createPrefixedId } from '../platform/id'
 import {
   getAllAssistantOptions,
@@ -25,6 +28,7 @@ import {
 import { filterSessions, filterSnippets } from '../state/selectors'
 import { createDefaultTerminalModes } from '../state/terminal-modes'
 import { saveCurrentWorkspace } from '../state/workspace-save'
+import { scrollGitDiff } from '../ui/git-view-controls'
 import { applyTheme } from '../ui/theme'
 import { THEME_IDS, type ThemeId } from '../ui/themes'
 import {
@@ -428,7 +432,123 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       confirmSplitSelection(ctx)
       return
     }
+    case 'scroll-git-diff': {
+      scrollGitDiff(effect.delta)
+      return
+    }
+    case 'git-stage': {
+      void enqueueGitOp(() => runGitAction(ctx, ['add', '--', effect.path], effect.path))
+      return
+    }
+    case 'git-unstage': {
+      void enqueueGitOp(() =>
+        runGitAction(ctx, ['restore', '--staged', '--', effect.path], effect.path)
+      )
+      return
+    }
+    case 'git-restore': {
+      void enqueueGitOp(() => runGitAction(ctx, ['restore', '--', effect.path], effect.path))
+      return
+    }
+    case 'git-rm': {
+      void enqueueGitOp(() => runGitRm(ctx, effect.path))
+      return
+    }
+    case 'git-commit': {
+      const { body, title } = effect
+      void enqueueGitOp(() => runGitCommit(ctx, title, body))
+      return
+    }
+    case 'git-push': {
+      void enqueueGitOp(() => runGitPush(ctx))
+      return
+    }
     default:
       effect satisfies never
   }
 }
+
+async function runGitAction(
+  ctx: SideEffectContext,
+  args: string[],
+  pathToInvalidate?: string
+): Promise<void> {
+  const cwd = ctx.getCurrentSessionProjectPath()
+  if (!cwd) return
+  const result = await $`git -C ${cwd} ${args}`.quiet().nothrow()
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim()
+    ctx.dispatch({ message: stderr || 'git action failed', type: 'git-mode-set-message' })
+    return
+  }
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  if (pathToInvalidate) {
+    ctx.dispatch({ path: pathToInvalidate, type: 'git-mode-clear-diff-cache' })
+  }
+}
+
+async function runGitRm(ctx: SideEffectContext, path: string): Promise<void> {
+  const cwd = ctx.getCurrentSessionProjectPath()
+  if (!cwd) return
+  const absolute = `${cwd}/${path}`
+  try {
+    const stat = await Bun.file(absolute).stat()
+    if (stat.isDirectory()) {
+      await Bun.$`rm -rf -- ${absolute}`.quiet().nothrow()
+    } else {
+      await Bun.file(absolute).unlink()
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'failed to delete file'
+    ctx.dispatch({ message, type: 'git-mode-set-message' })
+    return
+  }
+  ctx.dispatch({ message: null, type: 'git-mode-set-message' })
+  ctx.dispatch({ path, type: 'git-mode-clear-diff-cache' })
+}
+
+async function runGitCommit(ctx: SideEffectContext, title: string, body: string): Promise<void> {
+  const cwd = ctx.getCurrentSessionProjectPath()
+  if (!cwd) return
+  if (!title) {
+    ctx.dispatch({ message: 'empty commit title', type: 'git-mode-set-message' })
+    return
+  }
+  const result = body
+    ? await $`git -C ${cwd} commit -m ${title} -m ${body}`.quiet().nothrow()
+    : await $`git -C ${cwd} commit -m ${title}`.quiet().nothrow()
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim()
+    ctx.dispatch({
+      message: stderr || 'commit failed',
+      type: 'git-mode-set-message',
+    })
+    return
+  }
+  ctx.dispatch({ message: `committed: ${title}`, type: 'git-mode-set-message' })
+}
+
+async function runGitPush(ctx: SideEffectContext): Promise<void> {
+  const cwd = ctx.getCurrentSessionProjectPath()
+  if (!cwd) return
+  ctx.dispatch({ message: 'pushing…', type: 'git-mode-set-message' })
+
+  const upstream = await $`git -C ${cwd} rev-parse --abbrev-ref --symbolic-full-name @{u}`
+    .quiet()
+    .nothrow()
+  const hasUpstream = upstream.exitCode === 0
+
+  const result = hasUpstream
+    ? await $`git -C ${cwd} push`.quiet().nothrow()
+    : await $`git -C ${cwd} push --set-upstream origin HEAD`.quiet().nothrow()
+
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim()
+    ctx.dispatch({
+      message: stderr || 'push failed',
+      type: 'git-mode-set-message',
+    })
+    return
+  }
+  ctx.dispatch({ message: 'pushed', type: 'git-mode-set-message' })
+}

package/src/app-runtime/use-renderer-bindings.ts

@@ -86,6 +86,12 @@ export function useRendererBindings({
         focusMode: currentFocusMode,
       })
 
+      if (currentFocusMode === 'command-edit') {
+        const sanitized = payload.replace(/\r\n?/g, '\n')
+        dispatch({ char: sanitized, type: 'update-command-edit' })
+        return
+      }
+
       if (currentFocusMode !== 'terminal-input' || !tabId || !tab) {
         return
       }

package/src/app.tsx

@@ -21,6 +21,7 @@ import { registerAllModes } from './input/modes/handlers'
 import { getHandler, transitionTo } from './input/modes/registry'
 import { type TerminalContentOrigin } from './input/raw-input-handler'
 import { appStore } from './state/app-store'
+import { setActiveDispatch } from './state/dispatch-ref'
 import { loadSessionCatalog } from './state/session-catalog'
 import { loadSnippetCatalog } from './state/snippet-catalog'
 import { appReducer, createInitialState } from './state/store'
@@ -53,6 +54,11 @@ export function App({ backend }: { backend: SessionBackend }) {
     appStore.setState(state)
   }, [state])
 
+  useLayoutEffect(() => {
+    setActiveDispatch(dispatch)
+    return () => setActiveDispatch(null)
+  }, [dispatch])
+
   const resizingRef = useRef(false)
   const layoutRef = useRef(state.layout)
   layoutRef.current = state.layout

package/src/git/command-queue.ts

@@ -0,0 +1,7 @@
+let tail: Promise<unknown> = Promise.resolve()
+
+export function enqueueGitOp<T>(op: () => Promise<T>): Promise<T> {
+  const next = tail.then(op, op)
+  tail = next.catch(() => {})
+  return next
+}

package/src/git/git-diff.ts

@@ -0,0 +1,83 @@
+import { $ } from 'bun'
+
+import type { DiffData, DiffFileStatus, GitFileEntry } from '../state/types'
+
+function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?: string } {
+  if (entry.renamedFrom) return { oldPath: entry.renamedFrom, status: 'renamed' }
+  if (entry.section === 'untracked' || entry.status === '?') return { status: 'new' }
+  if (entry.status === 'D') return { status: 'deleted' }
+  if (entry.status === 'A' && entry.section === 'staged') return { status: 'new' }
+  return { status: 'modified' }
+}
+
+async function isBinary(cwd: string, path: string): Promise<boolean> {
+  const result = await $`git -C ${cwd} diff HEAD --numstat -- ${path}`.quiet().nothrow()
+  if (result.exitCode !== 0) return false
+  const text = result.text().trim()
+  if (!text) return false
+  const first = text.split('\n')[0] ?? ''
+  return first.startsWith('-\t-\t')
+}
+
+async function readHeadSize(cwd: string, path: string): Promise<number> {
+  const result = await $`git -C ${cwd} show HEAD:${path}`.quiet().nothrow()
+  if (result.exitCode !== 0) return 0
+  return result.text().length
+}
+
+async function readWorkingSize(cwd: string, path: string): Promise<number> {
+  try {
+    const file = Bun.file(`${cwd}/${path}`)
+    if (await file.exists()) return file.size
+  } catch {}
+  return 0
+}
+
+async function rawUnifiedDiff(cwd: string, path: string, status: DiffFileStatus): Promise<string> {
+  if (status === 'new') {
+    const result = await $`git -C ${cwd} diff HEAD --no-color --no-textconv -- ${path}`
+      .quiet()
+      .nothrow()
+    if (result.exitCode === 0 && result.text().length > 0) return result.text()
+    const untracked =
+      await $`git -C ${cwd} diff --no-index --no-color --no-textconv /dev/null -- ${path}`
+        .quiet()
+        .nothrow()
+    return untracked.text()
+  }
+
+  const result =
+    await $`git -C ${cwd} diff HEAD --unified=99999 --no-color --no-textconv -- ${path}`
+      .quiet()
+      .nothrow()
+  if (result.exitCode !== 0) return ''
+  return result.text()
+}
+
+export async function fetchDiff(cwd: string, file: GitFileEntry): Promise<DiffData> {
+  const { oldPath, status } = resolveStatus(file)
+
+  if (await isBinary(cwd, file.path)) {
+    const [binarySizeBefore, binarySizeAfter] = await Promise.all([
+      readHeadSize(cwd, file.path),
+      readWorkingSize(cwd, file.path),
+    ])
+    return {
+      binarySizeAfter,
+      binarySizeBefore,
+      path: file.path,
+      rawDiff: '',
+      status: 'binary',
+    }
+  }
+
+  const rawDiff = await rawUnifiedDiff(cwd, file.path, status)
+
+  const data: DiffData = {
+    path: file.path,
+    rawDiff,
+    status,
+  }
+  if (oldPath) data.oldPath = oldPath
+  return data
+}

package/src/git/git-poller.ts

@@ -1,6 +1,6 @@
 import { useEffect } from 'react'
 
-import { appStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
 import { collectGitStatus } from './git-status'
 
 const BASE_INTERVAL_MS = 1000
@@ -15,7 +15,7 @@ export function useGitPanelPolling({ enabled, projectPath }: Options): void {
   useEffect(() => {
     if (!enabled || !projectPath) return undefined
 
-    appStore.getState().dispatch({ type: 'git-panel-reset' })
+    dispatchGlobal({ type: 'git-panel-reset' })
 
     let cancelled = false
     let timer: ReturnType<typeof setTimeout> | null = null
@@ -30,10 +30,10 @@ export function useGitPanelPolling({ enabled, projectPath }: Options): void {
       const result = await collectGitStatus(projectPath)
       if (cancelled) return
       if (result.kind === 'ok') {
-        appStore.getState().dispatch({ payload: result.payload, type: 'git-refresh-success' })
+        dispatchGlobal({ payload: result.payload, type: 'git-refresh-success' })
         delay = BASE_INTERVAL_MS
       } else {
-        appStore.getState().dispatch({ kind: result.error, type: 'git-refresh-error' })
+        dispatchGlobal({ kind: result.error, type: 'git-refresh-error' })
         delay = Math.min(delay * 2, MAX_INTERVAL_MS)
       }
       schedule()

package/src/git/git-status.ts

@@ -158,6 +158,37 @@ export function parsePorcelainEntries(
   return files
 }
 
+async function countUntrackedLines(cwd: string, path: string): Promise<number | null> {
+  try {
+    const file = Bun.file(`${cwd}/${path}`)
+    if (!(await file.exists())) return null
+    const text = await file.text()
+    if (text.length === 0) return 0
+    let count = 0
+    for (let i = 0; i < text.length; i++) {
+      if (text.charCodeAt(i) === 10) count++
+    }
+    if (text.charCodeAt(text.length - 1) !== 10) count++
+    return count
+  } catch {
+    return null
+  }
+}
+
+async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Promise<void> {
+  const untracked = files.filter((f) => f.section === 'untracked')
+  if (untracked.length === 0) return
+  const counts = await Promise.all(untracked.map((f) => countUntrackedLines(cwd, f.path)))
+  for (let i = 0; i < untracked.length; i++) {
+    const file = untracked[i]
+    const count = counts[i]
+    if (file && count !== null && count !== undefined) {
+      file.added = count
+      file.removed = 0
+    }
+  }
+}
+
 export async function collectGitStatus(cwd: string): Promise<GitCollectResult> {
   try {
     const [statusResult, unstagedDiff, stagedDiff] = await Promise.all([
@@ -175,6 +206,7 @@ export async function collectGitStatus(cwd: string): Promise<GitCollectResult> {
     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 } }
   } catch {

package/src/input/modes/bridge.ts

@@ -4,6 +4,7 @@ import type { ModeId } from './types'
 type SupportedModalType = Exclude<ModalType, null>
 
 const DIRECT_FOCUS_MODE_IDS: Partial<Record<FocusMode, ModeId>> = {
+  'git': 'git-mode',
   'layout': 'layout',
   'navigation': 'navigation',
   'terminal-input': 'terminal-input',
@@ -11,6 +12,7 @@ const DIRECT_FOCUS_MODE_IDS: Partial<Record<FocusMode, ModeId>> = {
 
 const COMMAND_EDIT_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
   'create-session': 'modal.create-session',
+  'git-commit': 'modal.git-commit',
   'new-tab': 'modal.new-tab.command-edit',
   'rename-tab': 'modal.rename-tab',
   'session-name': 'modal.session-name',

package/src/input/modes/handlers/shared.ts

@@ -68,3 +68,19 @@ export function handleCtrlNavigation(key: KeyInput): KeyResult | null {
 
   return null
 }
+
+export function handleCursorNavigation(key: KeyInput): KeyResult | null {
+  if (key.name === 'left' && !key.ctrl && !key.meta) {
+    return result([{ delta: -1, type: 'move-modal-cursor' }])
+  }
+  if (key.name === 'right' && !key.ctrl && !key.meta) {
+    return result([{ delta: 1, type: 'move-modal-cursor' }])
+  }
+  if (key.name === 'home' || (key.ctrl && key.name === 'a')) {
+    return result([{ to: 'home', type: 'move-modal-cursor' }])
+  }
+  if (key.name === 'end' || (key.ctrl && key.name === 'e')) {
+    return result([{ to: 'end', type: 'move-modal-cursor' }])
+  }
+  return null
+}

package/src/input/modes/transitions.ts

@@ -1,8 +1,10 @@
 import type { ModeId } from './types'
 
 const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
+  'git-mode': ['navigation', 'modal.git-commit'],
   'layout': ['terminal-input', 'navigation', 'modal.split-picker'],
   'modal.create-session': ['navigation', 'modal.session-picker'],
+  'modal.git-commit': ['git-mode'],
   'modal.help': ['navigation'],
   'modal.new-tab': ['navigation', 'modal.new-tab.command-edit'],
   'modal.new-tab.command-edit': ['modal.new-tab'],
@@ -28,6 +30,7 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
     'modal.snippet-picker',
     'modal.theme-picker',
     'modal.rename-tab',
+    'git-mode',
   ],
   'terminal-input': ['navigation', 'layout'],
 }

package/src/input/modes/types.ts

@@ -6,6 +6,7 @@ export type ModeId =
   | 'navigation'
   | 'terminal-input'
   | 'layout'
+  | 'git-mode'
   | 'modal.new-tab'
   | 'modal.new-tab.command-edit'
   | 'modal.session-picker'
@@ -19,6 +20,7 @@ export type ModeId =
   | 'modal.theme-picker'
   | 'modal.help'
   | 'modal.split-picker'
+  | 'modal.git-commit'
 
 export type SideEffect =
   | { type: 'quit'; state: AppState }
@@ -42,6 +44,13 @@ export type SideEffect =
   | { type: 'rename-session'; sessionId: string; name: string }
   | { type: 'split-pane'; direction: import('../../state/layout-tree').SplitDirection }
   | { type: 'confirm-split' }
+  | { type: 'scroll-git-diff'; delta: number }
+  | { type: 'git-stage'; path: string }
+  | { type: 'git-unstage'; path: string }
+  | { type: 'git-restore'; path: string }
+  | { type: 'git-rm'; path: string }
+  | { type: 'git-commit'; title: string; body: string }
+  | { type: 'git-push' }
 
 export interface KeyResult {
   actions: AppAction[]

package/src/state/dispatch-ref.ts

@@ -0,0 +1,13 @@
+import type { AppAction } from './types'
+
+type DispatchFn = (action: AppAction) => void
+
+let activeDispatch: DispatchFn | null = null
+
+export function setActiveDispatch(dispatch: DispatchFn | null): void {
+  activeDispatch = dispatch
+}
+
+export function dispatchGlobal(action: AppAction): void {
+  activeDispatch?.(action)
+}

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

@@ -0,0 +1,136 @@
+import type { AppAction, AppState, GitFileEntry, GitModeState } from '../types'
+
+import { sortFilesBySection } from './git-panel-state'
+
+export function emptyGitMode(): GitModeState {
+  return {
+    actionMessage: null,
+    diffs: {},
+    loading: {},
+    pendingDeletePath: null,
+    selectedFileIndex: 0,
+  }
+}
+
+export function reduceGitModeState(state: AppState, action: AppAction): AppState | null {
+  switch (action.type) {
+    case 'enter-git-mode': {
+      if (state.focusMode === 'git') return state
+      return {
+        ...state,
+        focusMode: 'git',
+        gitMode: {
+          ...state.gitMode,
+          actionMessage: null,
+          pendingDeletePath: null,
+          selectedFileIndex: 0,
+        },
+      }
+    }
+    case 'exit-git-mode': {
+      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
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          pendingDeletePath: null,
+          selectedFileIndex: next,
+        },
+      }
+    }
+    case 'git-mode-set-diff': {
+      const nextLoading = { ...state.gitMode.loading }
+      delete nextLoading[action.path]
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          diffs: { ...state.gitMode.diffs, [action.path]: action.diff },
+          loading: nextLoading,
+        },
+      }
+    }
+    case 'git-mode-set-loading': {
+      const nextLoading = { ...state.gitMode.loading }
+      if (action.loading) {
+        nextLoading[action.path] = true
+      } else {
+        delete nextLoading[action.path]
+      }
+      return { ...state, gitMode: { ...state.gitMode, loading: nextLoading } }
+    }
+    case 'git-mode-set-pending-delete': {
+      if (state.gitMode.pendingDeletePath === action.path) return state
+      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 } }
+    }
+    case 'git-mode-set-message': {
+      if (state.gitMode.actionMessage === action.message) return state
+      return { ...state, gitMode: { ...state.gitMode, actionMessage: action.message } }
+    }
+    case 'git-mode-optimistic-move': {
+      const currentIdx = state.gitMode.selectedFileIndex
+      const files = state.gitPanel.files
+      const idx = files.findIndex((f) => f.path === action.path && f.section === action.fromSection)
+      if (idx < 0) return state
+
+      const toSection = action.toSection
+      let nextFiles: GitFileEntry[]
+      if (toSection === null) {
+        nextFiles = files.filter((_, i) => i !== idx)
+      } else {
+        const duplicateIdx = files.findIndex(
+          (f, i) => i !== idx && f.path === action.path && f.section === toSection
+        )
+        if (duplicateIdx >= 0) {
+          nextFiles = files.filter((_, i) => i !== idx)
+        } else {
+          nextFiles = files.map((f, i) =>
+            i === idx ? ({ ...f, section: toSection } as GitFileEntry) : f
+          )
+        }
+      }
+      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)
+        }
+      }
+
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          pendingDeletePath: null,
+          selectedFileIndex: nextIdx,
+        },
+        gitPanel: { ...state.gitPanel, files: nextFiles },
+      }
+    }
+    default:
+      return null
+  }
+}

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

@@ -1,8 +1,19 @@
-import type { AppAction, AppState, GitFileEntry, GitPanelState } from '../types'
+import type { AppAction, AppState, GitFileEntry, GitFileSection, GitPanelState } from '../types'
 
 export const GIT_PANEL_MIN_RATIO = 0.2
 export const GIT_PANEL_MAX_RATIO = 0.8
 
+const SECTION_RANK: Record<GitFileSection, number> = { staged: 0, unstaged: 1, untracked: 2 }
+
+export function sortFilesBySection(files: GitFileEntry[]): GitFileEntry[] {
+  return [...files].sort((a, b) => {
+    const sa = SECTION_RANK[a.section]
+    const sb = SECTION_RANK[b.section]
+    if (sa !== sb) return sa - sb
+    return a.path.localeCompare(b.path)
+  })
+}
+
 function clampRatio(value: number): number {
   return Math.max(GIT_PANEL_MIN_RATIO, Math.min(GIT_PANEL_MAX_RATIO, value))
 }
@@ -54,12 +65,13 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
     case 'git-refresh-success': {
       const prev = state.gitPanel
       const next = action.payload
+      const sortedNext = sortFilesBySection(next.files)
       if (
         prev.branch === next.branch &&
         prev.ahead === next.ahead &&
         prev.behind === next.behind &&
         prev.error === null &&
-        sameFiles(prev.files, next.files)
+        sameFiles(prev.files, sortedNext)
       ) {
         return state
       }
@@ -71,7 +83,7 @@ export function reduceGitPanelState(state: AppState, action: AppAction): AppStat
           behind: next.behind,
           branch: next.branch,
           error: null,
-          files: next.files,
+          files: sortedNext,
         },
       }
     }