@brimveyn/aimux 1.9.1 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",

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

@@ -652,7 +652,11 @@ async function runGitAction(
   args: string[],
   pathToInvalidate?: string
 ): Promise<void> {
-  const cwd = ctx.getCurrentSessionProjectPath()
+  const fallback = ctx.getCurrentSessionProjectPath()
+  const repoPath = pathToInvalidate
+    ? ctx.state.gitPanel.files.find((f) => f.path === pathToInvalidate)?.repoPath
+    : undefined
+  const cwd = repoPath ?? fallback
   if (!cwd) return
   const result = await $`git -C ${cwd} ${args}`.quiet().nothrow()
   if (result.exitCode !== 0) {
@@ -667,7 +671,8 @@ async function runGitAction(
 }
 
 async function runGitRm(ctx: SideEffectContext, path: string): Promise<void> {
-  const cwd = ctx.getCurrentSessionProjectPath()
+  const repoPath = ctx.state.gitPanel.files.find((f) => f.path === path)?.repoPath
+  const cwd = repoPath ?? ctx.getCurrentSessionProjectPath()
   if (!cwd) return
   const absolute = `${cwd}/${path}`
   try {

package/src/app.tsx

@@ -1,4 +1,8 @@
-import { type ResolvedConfig, setAutoCommitEnabled } from '@brimveyn/aimux-config'
+import {
+  type ResolvedConfig,
+  setAutoCommitEnabled,
+  setMultiRepoConfig,
+} from '@brimveyn/aimux-config'
 import { useKeyboard, useRenderer, useTerminalDimensions } from '@opentui/react'
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 
@@ -51,6 +55,7 @@ export function App({
   // Publish the auto-commit enabled flag before any children render so
   // actions (which live outside React) can read it synchronously.
   setAutoCommitEnabled(resolvedConfig.autoCommit.enabled)
+  setMultiRepoConfig(resolvedConfig.multiRepo)
 
   const keymapHandlers = useMemo(
     () => {

package/src/git/git-poller.ts

@@ -1,7 +1,10 @@
 import { useEffect } from 'react'
 
+import type { DiscoveredRepo, GitFileEntry, GitRefreshPayload } from '../state/types'
+
+import { useAppStore } from '../state/app-store'
 import { dispatchGlobal } from '../state/dispatch-ref'
-import { collectGitStatus } from './git-status'
+import { collectGitStatus, type GitCollectResult } from './git-status'
 
 const BASE_INTERVAL_MS = 1000
 const MAX_INTERVAL_MS = 30_000
@@ -12,7 +15,54 @@ interface Options {
   headOffset: number
 }
 
+function tagFiles(files: GitFileEntry[], repoPath: string): GitFileEntry[] {
+  return files.map((f) => ({ ...f, repoPath }))
+}
+
+async function collectAggregated(
+  repos: DiscoveredRepo[],
+  fallbackCwd: string,
+  headOffset: number
+): Promise<GitCollectResult> {
+  // Historical walking (HEAD~N) is per-repo and doesn't compose; fall back to
+  // the root/fallback repo when offset > 0 to preserve existing behaviour.
+  if (headOffset > 0) return collectGitStatus(fallbackCwd, { headOffset })
+
+  const results = await Promise.all(repos.map((r) => collectGitStatus(r.path, { headOffset: 0 })))
+  const files: GitFileEntry[] = []
+  let branch: string | null = null
+  let ahead = 0
+  let behind = 0
+  let anyOk = false
+  for (let i = 0; i < repos.length; i++) {
+    const res = results[i]
+    const repo = repos[i]
+    if (res?.kind !== 'ok' || !repo) continue
+    anyOk = true
+    if (repo.isRoot) {
+      branch = res.payload.branch
+      ahead = res.payload.ahead
+      behind = res.payload.behind
+    }
+    files.push(...tagFiles(res.payload.files, repo.path))
+  }
+  if (!anyOk) return { error: 'not-a-repo', kind: 'error' }
+  // If there was no root repo, surface the first discovered repo's branch label.
+  if (branch === null) {
+    const firstOk = results.find(
+      (r): r is Extract<GitCollectResult, { kind: 'ok' }> => r?.kind === 'ok'
+    )
+    if (firstOk) branch = firstOk.payload.branch
+  }
+  const payload: GitRefreshPayload = { ahead, behind, branch, files }
+  return { kind: 'ok', payload }
+}
+
 export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options): void {
+  // Read repos from the store imperatively — changes trigger a fresh effect run
+  // because the repos identity is stable across ticks until set-repos fires.
+  const repos = useAppStore((s) => s.multiRepo.repos)
+
   useEffect(() => {
     if (!enabled || !projectPath) return undefined
 
@@ -28,7 +78,10 @@ export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options
     }
 
     const tick = async () => {
-      const result = await collectGitStatus(projectPath, { headOffset })
+      const result =
+        repos.length > 0
+          ? await collectAggregated(repos, projectPath, headOffset)
+          : await collectGitStatus(projectPath, { headOffset })
       if (cancelled) return
       if (result.kind === 'ok') {
         dispatchGlobal({ payload: result.payload, type: 'git-refresh-success' })
@@ -53,5 +106,5 @@ export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options
       cancelled = true
       if (timer) clearTimeout(timer)
     }
-  }, [enabled, projectPath, headOffset])
+  }, [enabled, projectPath, headOffset, repos])
 }

package/src/git/repo-discovery.ts

@@ -0,0 +1,95 @@
+import type { Dirent } from 'node:fs'
+
+import { readdir, stat } from 'node:fs/promises'
+import { basename, join, relative } from 'node:path'
+
+import type { DiscoveredRepo } from '../state/types'
+
+const IGNORED_DIRS = new Set(['node_modules', 'target', 'dist', 'build', '.git'])
+
+async function isGitRepo(path: string): Promise<boolean> {
+  try {
+    const st = await stat(join(path, '.git'))
+    return st.isDirectory() || st.isFile()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Recursively scan `projectPath` down to `maxDepth` levels for directories
+ * that are themselves git repos. `maxDepth = 1` means only direct children.
+ *
+ * Internal recursion is breadth-limited: once a `.git` is found at a given
+ * path, we don't descend into it further (nested git repos-in-repos are rare
+ * and would duplicate status noise).
+ */
+async function scan(
+  root: string,
+  current: string,
+  depth: number,
+  maxDepth: number,
+  out: DiscoveredRepo[]
+): Promise<void> {
+  if (depth > maxDepth) return
+  let entries: Dirent[] = []
+  try {
+    entries = (await readdir(current, { withFileTypes: true })) as Dirent[]
+  } catch {
+    return
+  }
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isDirectory()) return
+      if (entry.name.startsWith('.')) return
+      if (IGNORED_DIRS.has(entry.name)) return
+      const childPath = join(current, entry.name)
+      if (await isGitRepo(childPath)) {
+        const rel = relative(root, childPath)
+        out.push({ isRoot: false, name: rel || entry.name, path: childPath })
+        return
+      }
+      await scan(root, childPath, depth + 1, maxDepth, out)
+    })
+  )
+}
+
+async function discoverReposUncached(
+  projectPath: string,
+  maxDepth: number
+): Promise<DiscoveredRepo[]> {
+  const repos: DiscoveredRepo[] = []
+  if (await isGitRepo(projectPath)) {
+    repos.push({ isRoot: true, name: basename(projectPath), path: projectPath })
+  }
+  const children: DiscoveredRepo[] = []
+  await scan(projectPath, projectPath, 1, maxDepth, children)
+  children.sort((a, b) => a.name.localeCompare(b.name))
+  repos.push(...children)
+  return repos
+}
+
+interface CacheEntry {
+  maxDepth: number
+  repos: DiscoveredRepo[]
+}
+
+const cache = new Map<string, CacheEntry>()
+
+/**
+ * Cached variant. The cache key is `projectPath` + `maxDepth`: a depth change
+ * invalidates the entry. The cache persists until `invalidateRepoCache()` or
+ * process exit — discovery is one-shot per session per depth setting.
+ */
+export async function discoverRepos(projectPath: string, maxDepth = 1): Promise<DiscoveredRepo[]> {
+  const existing = cache.get(projectPath)
+  if (existing && existing.maxDepth === maxDepth) return existing.repos
+  const repos = await discoverReposUncached(projectPath, maxDepth)
+  cache.set(projectPath, { maxDepth, repos })
+  return repos
+}
+
+export function invalidateRepoCache(projectPath?: string): void {
+  if (projectPath === undefined) cache.clear()
+  else cache.delete(projectPath)
+}

package/src/git/use-repo-discovery.ts

@@ -0,0 +1,28 @@
+import { getMultiRepoConfig } from '@brimveyn/aimux-config'
+import { useEffect } from 'react'
+
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { discoverRepos } from './repo-discovery'
+
+/**
+ * Discover nested git repos inside `projectPath` once per session and push
+ * the result into state. No-op when the multi-repo config flag is off.
+ */
+export function useRepoDiscovery(projectPath: string | undefined): void {
+  useEffect(() => {
+    const cfg = getMultiRepoConfig()
+    if (!cfg.enabled || !projectPath) {
+      dispatchGlobal({ type: 'multi-repo-clear' })
+      return
+    }
+    let cancelled = false
+    void (async () => {
+      const repos = await discoverRepos(projectPath, cfg.maxDepth)
+      if (cancelled) return
+      dispatchGlobal({ repos, type: 'multi-repo-set-repos' })
+    })()
+    return () => {
+      cancelled = true
+    }
+  }, [projectPath])
+}

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

@@ -16,6 +16,9 @@ export function sortFilesBySection(files: GitFileEntry[]): GitFileEntry[] {
     const sa = SECTION_RANK[a.section]
     const sb = SECTION_RANK[b.section]
     if (sa !== sb) return sa - sb
+    const ra = a.repoPath ?? ''
+    const rb = b.repoPath ?? ''
+    if (ra !== rb) return ra.localeCompare(rb)
     return a.path.localeCompare(b.path)
   })
 }

package/src/state/reducers/multi-repo-state.ts

@@ -0,0 +1,60 @@
+import {
+  type AppAction,
+  type AppState,
+  type DiscoveredRepo,
+  EMPTY_MULTI_REPO_STATE,
+} from '../types'
+
+/**
+ * Compute the shortest distinguishing prefix for each non-root repo name.
+ *
+ * Rule: start at length 1, group by that prefix. Any group with a single name
+ * is done; groups with collisions retry at length+1 until distinct or the name
+ * is exhausted. Root repos receive an empty prefix (no tag needed).
+ */
+export function computeRepoPrefixes(repos: DiscoveredRepo[]): Record<string, string> {
+  const out: Record<string, string> = {}
+  const nonRoot = repos.filter((r) => !r.isRoot)
+  for (const r of repos.filter((r) => r.isRoot)) out[r.path] = ''
+
+  const assign = (group: DiscoveredRepo[], len: number): void => {
+    if (group.length === 0) return
+    if (group.length === 1) {
+      const only = group[0]
+      if (!only) return
+      out[only.path] = only.name.slice(0, Math.max(1, len))
+      return
+    }
+    const byKey = new Map<string, DiscoveredRepo[]>()
+    for (const repo of group) {
+      const key = repo.name.slice(0, len)
+      const bucket = byKey.get(key)
+      if (bucket) bucket.push(repo)
+      else byKey.set(key, [repo])
+    }
+    for (const [key, bucket] of byKey) {
+      if (bucket.length === 1 || bucket.every((r) => r.name.length < len)) {
+        for (const r of bucket) out[r.path] = key || r.name
+      } else {
+        assign(bucket, len + 1)
+      }
+    }
+  }
+  assign(nonRoot, 1)
+  return out
+}
+
+export function reduceMultiRepoState(state: AppState, action: AppAction): AppState | null {
+  switch (action.type) {
+    case 'multi-repo-set-repos': {
+      const prefixes = computeRepoPrefixes(action.repos)
+      return { ...state, multiRepo: { prefixes, repos: action.repos } }
+    }
+    case 'multi-repo-clear': {
+      if (state.multiRepo.repos.length === 0) return state
+      return { ...state, multiRepo: EMPTY_MULTI_REPO_STATE }
+    }
+    default:
+      return null
+  }
+}

package/src/state/store.ts

@@ -2,6 +2,7 @@ import { reduceAutoCommit } from './reducers/auto-commit-state'
 import { emptyGitMode, reduceGitModeState } from './reducers/git-mode-state'
 import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
 import { emptyModal, reduceModalState } from './reducers/modal-state'
+import { reduceMultiRepoState } from './reducers/multi-repo-state'
 import { reduceSessionState } from './reducers/session-state'
 import { reduceTabState } from './reducers/tab-state'
 import { reduceUIState } from './reducers/ui-state'
@@ -10,6 +11,7 @@ import {
   type AppAction,
   type AppState,
   EMPTY_AUTO_COMMIT_STATE,
+  EMPTY_MULTI_REPO_STATE,
   type GitModeState,
   type GitPaneMode,
   type GitPanePosition,
@@ -98,6 +100,7 @@ export function createInitialState(
           type: 'session-picker',
         }
       : emptyModal(),
+    multiRepo: EMPTY_MULTI_REPO_STATE,
     pendingChords: null,
     sessionBar: {
       position: overrides.sessionBarPosition ?? 'top',
@@ -139,6 +142,9 @@ export function appReducer(state: AppState, action: AppAction): AppState {
   const autoCommitState = reduceAutoCommit(state, action)
   if (autoCommitState) return autoCommitState
 
+  const multiRepoState = reduceMultiRepoState(state, action)
+  if (multiRepoState) return multiRepoState
+
   switch (action.type) {
     case 'set-snippets':
       return { ...state, snippets: action.snippets }

package/src/state/types.ts

@@ -188,6 +188,8 @@ export interface GitFileEntry {
   status: GitFileStatus
   added: number | null
   removed: number | null
+  /** Absolute path to the originating git repo. Set when the entry comes from a sub-repo. */
+  repoPath?: string
 }
 
 export type GitPanelError = 'not-a-repo' | 'unknown'
@@ -384,6 +386,24 @@ export interface SnippetRecord {
   content: string
 }
 
+export interface DiscoveredRepo {
+  /** Absolute path to the repo. */
+  path: string
+  /** Label shown in UI (relative to the workspace root or repo basename). */
+  name: string
+  /** True when the repo is the session's projectPath itself. */
+  isRoot: boolean
+}
+
+export interface MultiRepoState {
+  /** Discovered sub-repos, ordered so root (if any) comes first. */
+  repos: DiscoveredRepo[]
+  /** Precomputed disambiguating prefix per repo path — empty string for the root repo. */
+  prefixes: Record<string, string>
+}
+
+export const EMPTY_MULTI_REPO_STATE: MultiRepoState = { prefixes: {}, repos: [] }
+
 export interface AppState {
   tabs: TabSession[]
   activeTabId: string | null
@@ -403,6 +423,7 @@ export interface AppState {
   gitPanel: GitPanelState
   gitMode: GitModeState
   autoCommit: AutoCommitState
+  multiRepo: MultiRepoState
   /** Chord prefix the sequence resolver is currently waiting on, or null when idle. */
   pendingChords: string[] | null
 }
@@ -648,6 +669,11 @@ export type DataAction =
   | { type: 'delete-snippet'; snippetId: string }
   | { type: 'set-custom-commands'; customCommands: Record<AssistantId, string> }
 
+// -- Multi-repo actions --
+export type MultiRepoAction =
+  | { type: 'multi-repo-set-repos'; repos: DiscoveredRepo[] }
+  | { type: 'multi-repo-clear' }
+
 export type AppAction =
   | ModalAction
   | SessionAction
@@ -658,3 +684,4 @@ export type AppAction =
   | GitPanelAction
   | GitModeAction
   | AutoCommitAction
+  | MultiRepoAction

package/src/ui/components/git/diff-renderer/use-diff-prefetch.ts

@@ -102,7 +102,7 @@ export function useDiffPrefetch(
   runTaskRef.current = async (task: Task) => {
     if (!projectPath) return
     try {
-      const diff = await fetchDiff(projectPath, task.file, headOffset)
+      const diff = await fetchDiff(task.file.repoPath ?? projectPath, task.file, headOffset)
       if (task.controller.signal.aborted) return
       const hash = diffHash(diff.rawDiff)
       dispatchGlobal({ diff, hash, key: task.key, type: 'git-mode-set-diff' })

package/src/ui/components/git/git-panel.tsx

@@ -11,6 +11,7 @@ import type {
   GitPanePathConfig,
 } from '../../../state/types'
 
+import { useAppStore } from '../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../state/dispatch-ref'
 import {
   buildGitTreeRows,
@@ -189,14 +190,20 @@ function renderFileRow(
   isSelected: boolean,
   fileListMode: GitFileListMode,
   pathConfig: GitPanePathConfig,
-  diffCountConfig: GitPaneDiffCountConfig
+  diffCountConfig: GitPaneDiffCountConfig,
+  repoPrefixes: Record<string, string>
 ): ReactNode {
+  const t = getCurrentTokens()
   const file = row.file
   const hasNumstat = file.added !== null || file.removed !== null
-  const bg = isSelected && !getTransparent() ? getCurrentTokens().selected : undefined
+  const bg = isSelected && !getTransparent() ? t.selected : undefined
   const onSelect = (): void => {
     dispatchGlobal({ key: row.key, type: 'git-mode-select-entry-by-key' })
   }
+  // Repo disambiguation prefix: only in flat mode, only when the file came
+  // from a sub-repo (root repo files get an empty prefix).
+  const repoTag =
+    fileListMode === 'flat' && file.repoPath ? (repoPrefixes[file.repoPath] ?? '') : ''
   return (
     <box key={row.key} flexDirection="row" gap={1} backgroundColor={bg} onMouseDown={onSelect}>
       <box width={2} flexShrink={0} justifyContent="center">
@@ -204,6 +211,13 @@ function renderFileRow(
           <strong>{displayStatus(file)}</strong>
         </text>
       </box>
+      {repoTag ? (
+        <box flexShrink={0}>
+          <text fg={t.palette.primary} bg={bg}>
+            <strong>{repoTag}</strong>
+          </text>
+        </box>
+      ) : null}
       <box flexGrow={1} overflow="hidden" paddingLeft={fileListMode === 'tree' ? row.depth * 2 : 0}>
         {renderFileLabel(file, pathConfig, fileListMode)}
       </box>
@@ -224,7 +238,8 @@ function renderTreeSection(
   showListModeToggle: boolean,
   pathConfig: GitPanePathConfig,
   diffCountConfig: GitPaneDiffCountConfig,
-  marginTop: number
+  marginTop: number,
+  repoPrefixes: Record<string, string>
 ): ReactNode {
   if (files.length === 0) return null
   const t = getCurrentTokens()
@@ -259,7 +274,8 @@ function renderTreeSection(
               row.key === selectedEntryKey,
               fileListMode,
               pathConfig,
-              diffCountConfig
+              diffCountConfig,
+              repoPrefixes
             )
       )}
     </box>
@@ -317,6 +333,7 @@ export const GitPanel = memo(function GitPanel({
 }: GitPanelProps) {
   const t = useTokens()
   useTransparent()
+  const repoPrefixes = useAppStore((s) => s.multiRepo.prefixes)
   const sectionOrder = headOffset > 0 ? HISTORICAL_SECTION_ORDER : BASE_SECTION_ORDER
   const scrollRef = useRef<ScrollBoxRenderable | null>(null)
   const tree = useMemo(
@@ -380,7 +397,8 @@ export const GitPanel = memo(function GitPanel({
               key === toggleSection,
               pathConfig,
               diffCountConfig,
-              priorHasFiles ? 1 : 0
+              priorHasFiles ? 1 : 0,
+              repoPrefixes
             )
           })}
         </scrollbox>

package/src/ui/components/git/git-view.tsx

@@ -7,6 +7,7 @@ import type { ThemeId } from '../../themes'
 import { diffHash } from '../../../git/diff-hash'
 import { fetchDiff } from '../../../git/git-diff'
 import { useGitPanelPolling } from '../../../git/git-poller'
+import { useRepoDiscovery } from '../../../git/use-repo-discovery'
 import { useAppStore } from '../../../state/app-store'
 import { dispatchGlobal } from '../../../state/dispatch-ref'
 import { getSelectedGitFile, gitFileKey } from '../../../state/git-tree'
@@ -122,6 +123,7 @@ export const GitView = memo(function GitView({ themeId }: GitViewProps) {
     : undefined
   const projectPath = currentSession?.projectPath
 
+  useRepoDiscovery(projectPath)
   useGitPanelPolling({ enabled: focusMode === 'git', headOffset: gitMode.headOffset, projectPath })
 
   const fileBarWidth = Math.max(20, Math.floor(dimensions.width * gitPane.diffModeRatio))
@@ -165,7 +167,7 @@ export const GitView = memo(function GitView({ themeId }: GitViewProps) {
     if (!selectedDiffKey) return
     if (diff || loading) return
     dispatchGlobal({ key: selectedDiffKey, loading: true, type: 'git-mode-set-loading' })
-    void fetchDiff(projectPath, selectedFile, gitMode.headOffset)
+    void fetchDiff(selectedFile.repoPath ?? projectPath, selectedFile, gitMode.headOffset)
       .then((d) =>
         dispatchGlobal({
           diff: d,

package/src/ui/components/git/pane/git-pane-widget.tsx

@@ -3,6 +3,7 @@ import { memo, useRef } from 'react'
 import type { GitPanelState } from '../../../../state/types'
 
 import { useGitPanelPolling } from '../../../../git/git-poller'
+import { useRepoDiscovery } from '../../../../git/use-repo-discovery'
 import { useAppStore } from '../../../../state/app-store'
 import { GitPanel } from '../git-panel'
 
@@ -24,6 +25,7 @@ export const GitPaneWidget = memo(function GitPaneWidget({ pollingEnabled }: Git
     : undefined
   const projectPath = currentSession?.projectPath
 
+  useRepoDiscovery(projectPath)
   useGitPanelPolling({ enabled: pollingEnabled, headOffset: 0, projectPath })
 
   const lastGoodRef = useRef<GitPanelState | null>(null)