@brimveyn/aimux 1.7.4 → 1.9.0

package/src/services/ai-usage/cache.ts

@@ -0,0 +1,60 @@
+import type { AIUsageTool } from '@brimveyn/aimux-config'
+
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import type { UsageSnapshot } from './types'
+
+const CACHE_DIR = join(homedir(), '.cache', 'aimux')
+const CACHE_PATH = join(CACHE_DIR, 'ai-usage.json')
+
+interface CacheEntry {
+  fetchedAt: number
+  snapshot: UsageSnapshot
+}
+
+type CacheFile = Partial<Record<AIUsageTool, CacheEntry>>
+
+function readCacheFile(): CacheFile {
+  try {
+    if (!existsSync(CACHE_PATH)) return {}
+    const raw = readFileSync(CACHE_PATH, 'utf8')
+    const parsed = JSON.parse(raw) as unknown
+    if (typeof parsed !== 'object' || parsed === null) return {}
+    return parsed as CacheFile
+  } catch {
+    return {}
+  }
+}
+
+export interface CachedSnapshot {
+  snapshot: UsageSnapshot
+  ageMs: number
+}
+
+export function loadCachedSnapshot(tool: AIUsageTool, maxAgeMs: number): CachedSnapshot | null {
+  const cache = readCacheFile()
+  const entry = cache[tool]
+  if (!entry) return null
+  if (typeof entry.fetchedAt !== 'number') return null
+  const ageMs = Date.now() - entry.fetchedAt
+  if (ageMs > maxAgeMs) return null
+  if (!entry.snapshot || entry.snapshot.tool !== tool) return null
+  return { ageMs, snapshot: entry.snapshot }
+}
+
+export function saveCachedSnapshot(snapshot: UsageSnapshot): void {
+  if (snapshot.error) return
+  if (snapshot.percent === null) return
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true })
+    const cache = readCacheFile()
+    cache[snapshot.tool] = { fetchedAt: Date.now(), snapshot }
+    const tmpPath = `${CACHE_PATH}.${process.pid}.tmp`
+    writeFileSync(tmpPath, `${JSON.stringify(cache, null, 2)}\n`)
+    renameSync(tmpPath, CACHE_PATH)
+  } catch {
+    // swallow — cache is best-effort
+  }
+}

package/src/services/ai-usage/pace.ts

@@ -0,0 +1,79 @@
+import type { UsagePace, UsagePaceStage } from './types'
+
+function stageFor(delta: number): UsagePaceStage {
+  const abs = Math.abs(delta)
+  if (abs <= 2) return 'onTrack'
+  if (abs <= 6) return delta >= 0 ? 'slightlyBehind' : 'slightlyAhead'
+  if (abs <= 12) return delta >= 0 ? 'behind' : 'ahead'
+  return delta >= 0 ? 'farBehind' : 'farAhead'
+}
+
+function formatDuration(seconds: number): string {
+  const total = Math.max(0, Math.round(seconds))
+  const h = Math.floor(total / 3600)
+  const m = Math.floor((total % 3600) / 60)
+  if (h >= 24) {
+    const d = Math.floor(h / 24)
+    const hh = h % 24
+    return hh > 0 ? `${d}d ${hh}h` : `${d}d`
+  }
+  if (h > 0) return m > 0 ? `${h}h ${m}m` : `${h}h`
+  return `${m}m`
+}
+
+export function computePace(opts: {
+  percent: number | null
+  resetAtMs: number | null
+  windowSeconds: number | null
+  now?: number
+}): UsagePace | null {
+  const { percent, resetAtMs, windowSeconds } = opts
+  const now = opts.now ?? Date.now()
+  if (percent === null || resetAtMs === null || !windowSeconds || windowSeconds <= 0) {
+    return null
+  }
+
+  const timeUntilReset = (resetAtMs - now) / 1000
+  if (timeUntilReset <= 0 || timeUntilReset > windowSeconds) return null
+
+  const elapsed = Math.max(0, Math.min(windowSeconds, windowSeconds - timeUntilReset))
+  const expected = Math.max(0, Math.min(100, (elapsed / windowSeconds) * 100))
+  const actual = Math.max(0, Math.min(100, percent))
+  const delta = actual - expected
+  const rounded = Math.round(delta)
+  const stage = stageFor(rounded)
+
+  let rightText: string | null = null
+  if (elapsed > 0 && actual > 0) {
+    const rate = actual / elapsed
+    if (rate > 0) {
+      const remaining = Math.max(0, 100 - actual)
+      const candidate = remaining / rate
+      if (candidate >= timeUntilReset) {
+        rightText = 'Lasts to reset'
+      } else {
+        rightText = `Runs out in ${formatDuration(candidate)}`
+      }
+    }
+  } else if (elapsed > 0 && actual === 0) {
+    rightText = 'Lasts to reset'
+  }
+
+  let label: string
+  if (stage === 'onTrack') {
+    label = 'On pace'
+  } else if (rounded > 0) {
+    label = `Behind (+${rounded}%)`
+  } else {
+    label = `Ahead (${rounded}%)`
+  }
+
+  return { delta, label, rightText, stage }
+}
+
+export function formatTimeRemaining(resetAtMs: number | null, now?: number): string | null {
+  if (resetAtMs === null) return null
+  const diff = resetAtMs - (now ?? Date.now())
+  if (diff <= 0) return null
+  return formatDuration(diff / 1000)
+}

package/src/services/ai-usage/provider.ts

@@ -0,0 +1,107 @@
+import type { AIUsageTool, AIUsageToolConfig } from '@brimveyn/aimux-config'
+
+import type { UsageSnapshot } from './types'
+
+import { fetchClaudeUsage } from './adapters/claude'
+import { fetchCodexUsage } from './adapters/codex'
+import { loadCachedSnapshot, saveCachedSnapshot } from './cache'
+
+const DEFAULT_POLL_SECONDS = 60
+const DEFAULT_TOOLS: AIUsageTool[] = ['claude', 'codex']
+
+export interface AIUsageServiceHandle {
+  stop: () => void
+  refresh: () => void
+}
+
+async function fetchFor(tool: AIUsageTool, config: AIUsageToolConfig): Promise<UsageSnapshot> {
+  switch (tool) {
+    case 'claude':
+      return fetchClaudeUsage(config)
+    case 'codex':
+      return fetchCodexUsage(config)
+  }
+}
+
+export function startAIUsageService(
+  config: AIUsageToolConfig,
+  onUpdate: (snap: UsageSnapshot) => void
+): AIUsageServiceHandle {
+  const tools = config.tools && config.tools.length > 0 ? config.tools : DEFAULT_TOOLS
+  const pollMs = Math.max(5, config.pollSeconds ?? DEFAULT_POLL_SECONDS) * 1000
+
+  let stopped = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  const tick = async (): Promise<void> => {
+    if (stopped) return
+
+    const toFetch: AIUsageTool[] = []
+    let maxCachedAgeMs = 0
+    for (const tool of tools) {
+      const cached = loadCachedSnapshot(tool, pollMs)
+      if (cached) {
+        onUpdate(cached.snapshot)
+        if (cached.ageMs > maxCachedAgeMs) maxCachedAgeMs = cached.ageMs
+      } else {
+        toFetch.push(tool)
+      }
+    }
+
+    if (toFetch.length > 0) {
+      const results = await Promise.allSettled(toFetch.map((t) => fetchFor(t, config)))
+      if (stopped) return
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i]
+        const tool = toFetch[i]
+        if (!result || !tool) continue
+        if (result.status === 'fulfilled') {
+          saveCachedSnapshot(result.value)
+          onUpdate(result.value)
+        } else {
+          onUpdate({
+            burnRatePerHour: null,
+            costUSD: null,
+            error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            lastUpdated: new Date().toISOString(),
+            percent: null,
+            planTier: null,
+            resetAt: null,
+            timeRemaining: null,
+            tokens: { cache: 0, input: 0, output: 0, total: 0 },
+            tool,
+            windows: [],
+          })
+        }
+      }
+    }
+
+    if (!stopped) {
+      const minDelayMs = 5_000
+      const nextDelayMs =
+        toFetch.length > 0 ? pollMs : Math.max(minDelayMs, pollMs - maxCachedAgeMs)
+      timer = setTimeout(() => {
+        void tick()
+      }, nextDelayMs)
+    }
+  }
+
+  void tick()
+
+  return {
+    refresh: () => {
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+      void tick()
+    },
+    stop: () => {
+      stopped = true
+      if (timer) {
+        clearTimeout(timer)
+        timer = null
+      }
+    },
+  }
+}

package/src/services/ai-usage/spawn.ts

@@ -0,0 +1,49 @@
+interface CliResult {
+  ok: boolean
+  stdout: string
+  stderr: string
+  error?: string
+}
+
+const DEFAULT_TIMEOUT_MS = 15_000
+
+export async function runCli(
+  command: string,
+  args: string[],
+  timeoutMs: number = DEFAULT_TIMEOUT_MS
+): Promise<CliResult> {
+  const proc = Bun.spawn([command, ...args], {
+    stderr: 'pipe',
+    stdin: 'ignore',
+    stdout: 'pipe',
+  })
+
+  const timeout = setTimeout(() => {
+    try {
+      proc.kill()
+    } catch {
+      // process already gone
+    }
+  }, timeoutMs)
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+
+    if (exitCode !== 0) {
+      return {
+        error: `${command} exit ${exitCode}: ${stderr.trim().slice(0, 200)}`,
+        ok: false,
+        stderr,
+        stdout,
+      }
+    }
+
+    return { ok: true, stderr, stdout }
+  } finally {
+    clearTimeout(timeout)
+  }
+}

package/src/services/ai-usage/types.ts

@@ -0,0 +1,51 @@
+import type { AIUsageTool } from '@brimveyn/aimux-config'
+
+export type { AIUsageTool }
+
+export type UsageWindowKind = 'session' | 'weekly' | 'sonnet' | 'opus' | 'primary' | 'secondary'
+
+export type UsagePaceStage =
+  | 'farAhead'
+  | 'ahead'
+  | 'slightlyAhead'
+  | 'onTrack'
+  | 'slightlyBehind'
+  | 'behind'
+  | 'farBehind'
+
+export interface UsagePace {
+  delta: number
+  stage: UsagePaceStage
+  label: string
+  rightText: string | null
+}
+
+export interface UsageWindow {
+  kind: UsageWindowKind
+  label: string
+  percent: number | null
+  resetAt: string | null
+  timeRemaining: string | null
+  windowSeconds: number | null
+  pace: UsagePace | null
+}
+
+export interface UsageSnapshot {
+  tool: AIUsageTool
+  percent: number | null
+  tokens: {
+    input: number
+    output: number
+    cache: number
+    total: number
+  }
+  costUSD: number | null
+  resetAt: string | null
+  timeRemaining: string | null
+  burnRatePerHour: number | null
+  lastUpdated: string
+  planTier: string | null
+  windows: UsageWindow[]
+  error?: string
+  stale?: boolean
+}

package/src/session-backend/local-session-backend.ts

@@ -12,6 +12,7 @@ import {
   getSnapshotTrees,
   toTerminalContentSize,
 } from '../state/layout-resize'
+import { getSnapshotScrollIntents } from '../state/session-persistence'
 
 export class LocalSessionBackend
   extends EventEmitter<SessionBackendEvents>
@@ -66,15 +67,22 @@ export class LocalSessionBackend
     })
     this.currentSessionId = options.sessionId
     const trees = getSnapshotTrees(options.workspaceSnapshot)
+    const intents = getSnapshotScrollIntents(options.workspaceSnapshot)
     const splitTrees = trees.filter((t) => t.type === 'split')
     if (splitTrees.length > 0) {
       const bounds = createTerminalBounds(options.cols, options.rows)
       forEachSplitPaneRect(splitTrees, bounds, (tabId, rect) => {
         const size = toTerminalContentSize(rect)
-        this.sessionManager.resizeTab(options.sessionId, tabId, size.cols, size.rows)
+        this.sessionManager.resizeTab(
+          options.sessionId,
+          tabId,
+          size.cols,
+          size.rows,
+          intents.get(tabId)
+        )
       })
     } else {
-      this.sessionManager.resize(options.sessionId, options.cols, options.rows)
+      this.sessionManager.resize(options.sessionId, options.cols, options.rows, intents)
     }
     const attachResult = this.sessionManager.attachSession(
       options.sessionId,

package/src/state/ai-usage-store.ts

@@ -0,0 +1,36 @@
+import type { AIUsageTool } from '@brimveyn/aimux-config'
+
+import { useStore } from 'zustand'
+import { createStore } from 'zustand/vanilla'
+
+import type { UsageSnapshot } from '../services/ai-usage/types'
+
+export interface AIUsageState {
+  enabled: boolean
+  snapshots: Partial<Record<AIUsageTool, UsageSnapshot>>
+  setEnabled: (enabled: boolean) => void
+  setSnapshot: (snap: UsageSnapshot) => void
+  clear: () => void
+}
+
+export const aiUsageStore = createStore<AIUsageState>((set) => ({
+  clear: () => set({ snapshots: {} }),
+  enabled: false,
+  setEnabled: (enabled: boolean) => set({ enabled }),
+  setSnapshot: (snap: UsageSnapshot) =>
+    set((state) => {
+      const prev = state.snapshots[snap.tool]
+      const isFailure = Boolean(snap.error)
+      const hasPriorValue = prev && prev.percent !== null
+      const merged: UsageSnapshot =
+        isFailure && hasPriorValue && prev
+          ? { ...prev, error: snap.error, lastUpdated: snap.lastUpdated, stale: true }
+          : snap
+      return { snapshots: { ...state.snapshots, [snap.tool]: merged } }
+    }),
+  snapshots: {},
+}))
+
+export function useAIUsageStore<T>(selector: (state: AIUsageState) => T): T {
+  return useStore(aiUsageStore, selector)
+}

package/src/state/reducers/auto-commit-state.ts

@@ -0,0 +1,59 @@
+import type { AppAction, AppState, AutoCommitState } from '../types'
+
+function setBySession(
+  state: AutoCommitState,
+  sessionId: string,
+  next: AutoCommitState['bySession'][string]
+): AutoCommitState {
+  return { bySession: { ...state.bySession, [sessionId]: next } }
+}
+
+export function reduceAutoCommitState(
+  state: AutoCommitState,
+  action: AppAction
+): AutoCommitState | null {
+  switch (action.type) {
+    case 'auto-commit-generation-started': {
+      return setBySession(state, action.sessionId, {
+        abortController: action.abortController,
+        kind: 'generating',
+        startedAt: action.startedAt,
+        tabId: action.tabId,
+        workingTreeHash: action.workingTreeHash,
+      })
+    }
+    case 'auto-commit-generation-ready': {
+      const current = state.bySession[action.sessionId]
+      if (!current || current.kind !== 'generating') return null
+      if (current.workingTreeHash !== action.workingTreeHash) return null
+      return setBySession(state, action.sessionId, {
+        body: action.body,
+        generatedAt: action.generatedAt,
+        kind: 'ready',
+        tabId: current.tabId,
+        title: action.title,
+        workingTreeHash: current.workingTreeHash,
+      })
+    }
+    case 'auto-commit-clear': {
+      const current = state.bySession[action.sessionId]
+      if (!current || current.kind === 'idle') return null
+      if (current.kind === 'generating') {
+        try {
+          current.abortController.abort()
+        } catch {
+          // ignore
+        }
+      }
+      return setBySession(state, action.sessionId, { kind: 'idle' })
+    }
+    default:
+      return null
+  }
+}
+
+export function reduceAutoCommit(state: AppState, action: AppAction): AppState | null {
+  const next = reduceAutoCommitState(state.autoCommit, action)
+  if (next === null) return null
+  return { ...state, autoCommit: next }
+}

package/src/state/reducers/modal-state.ts

@@ -7,6 +7,7 @@ import { getActiveKeymap } from '../../input/keymap/keymap-ref'
 import { getAllAssistantOptions } from '../../pty/command-registry'
 import { filterThemeIds } from '../../ui/filter-themes'
 import { filterAssistants, filterSessions, filterSnippets } from '../selectors'
+import { reduceAutoCommitState } from './auto-commit-state'
 
 function emptyModal() {
   return {
@@ -53,6 +54,19 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         },
       }
     }
+    case 'open-ai-usage-modal': {
+      return {
+        ...state,
+        focusMode: 'modal',
+        modal: {
+          cursorPos: 0,
+          editBuffer: '',
+          selectedIndex: 0,
+          sessionTargetId: null,
+          type: 'ai-usage',
+        },
+      }
+    }
     case 'open-help-modal': {
       const keymap = getActiveKeymap()
       const scope = action.scope ?? null
@@ -199,7 +213,8 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           type: 'update-available',
         },
       }
-    case 'open-git-commit-modal':
+    case 'open-git-commit-modal': {
+      const sessionId = action.sessionId
       return {
         ...state,
         focusMode: 'command-edit',
@@ -209,10 +224,112 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           cursorPos: 0,
           editBuffer: '',
           selectedIndex: 0,
-          sessionTargetId: null,
+          sessionTargetId: sessionId ?? null,
+          stage: 'edit',
           type: 'git-commit',
         },
       }
+    }
+    case 'git-commit-enter-confirm': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'confirm' },
+      }
+    }
+    case 'git-commit-leave-confirm': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'edit' },
+      }
+    }
+    case 'git-commit-enter-generating': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'modal',
+        modal: { ...state.modal, sessionTargetId: action.sessionId, stage: 'generating' },
+      }
+    }
+    case 'git-commit-leave-generating': {
+      if (state.modal.type !== 'git-commit') return state
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'edit' },
+      }
+    }
+    case 'auto-commit-generation-ready': {
+      if (
+        state.modal.type !== 'git-commit' ||
+        state.modal.stage !== 'generating' ||
+        state.modal.sessionTargetId !== action.sessionId
+      ) {
+        return null
+      }
+      const nextAutoCommit = reduceAutoCommitState(state.autoCommit, action)
+      if (!nextAutoCommit) {
+        // Stale result (hash mismatch or slice was cleared mid-flight): don't
+        // strand the modal in `generating` — flip back to edit so the user
+        // isn't stuck staring at a spinner that will never resolve.
+        return {
+          ...state,
+          focusMode: 'command-edit',
+          modal: { ...state.modal, stage: 'edit' },
+        }
+      }
+      return {
+        ...state,
+        autoCommit: nextAutoCommit,
+        focusMode: 'command-edit',
+        modal: {
+          ...state.modal,
+          activeField: 'title',
+          contentBuffer: action.body,
+          cursorPos: action.title.length,
+          editBuffer: action.title,
+          stage: 'confirm',
+        },
+      }
+    }
+    case 'git-commit-use-background-suggestion': {
+      if (state.modal.type !== 'git-commit' || state.modal.sessionTargetId !== action.sessionId) {
+        return null
+      }
+      const suggestion = state.autoCommit.bySession[action.sessionId]
+      if (!suggestion || suggestion.kind !== 'ready') return null
+      return {
+        ...state,
+        focusMode: 'command-edit',
+        modal: {
+          ...state.modal,
+          activeField: 'title',
+          contentBuffer: suggestion.body,
+          cursorPos: suggestion.title.length,
+          editBuffer: suggestion.title,
+          stage: 'confirm',
+        },
+      }
+    }
+    case 'auto-commit-clear': {
+      if (
+        state.modal.type !== 'git-commit' ||
+        state.modal.stage !== 'generating' ||
+        state.modal.sessionTargetId !== action.sessionId
+      ) {
+        return null
+      }
+      const nextAutoCommit = reduceAutoCommitState(state.autoCommit, action)
+      return {
+        ...state,
+        autoCommit: nextAutoCommit ?? state.autoCommit,
+        focusMode: 'command-edit',
+        modal: { ...state.modal, stage: 'edit' },
+      }
+    }
     case 'set-help-entry-count': {
       if (state.modal.type !== 'help') return state
       if (state.modal.entryCount === action.count) {

package/src/state/reducers/session-state.ts

@@ -53,27 +53,39 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
         ),
       }
     case 'delete-session-record': {
+      const deletingCurrent = action.sessionId === state.currentSessionId
       const newSessions = state.sessions.filter((session) => session.id !== action.sessionId)
-      const filteredNew = filterSessions(newSessions, state.modal.editBuffer)
-      const maxIndex = filteredNew.length
-      const clampedIndex = Math.min(state.modal.selectedIndex, maxIndex)
       const nextStatuses = { ...state.sessionStatuses }
       delete nextStatuses[action.sessionId]
+      if (action.openSessionPicker) {
+        const filteredNew = filterSessions(newSessions, state.modal.editBuffer)
+        const maxIndex = filteredNew.length
+        const clampedIndex = Math.min(state.modal.selectedIndex, maxIndex)
+        return {
+          ...state,
+          activeTabId: deletingCurrent ? null : state.activeTabId,
+          currentSessionId: deletingCurrent ? null : state.currentSessionId,
+          focusMode: 'modal',
+          modal: {
+            editBuffer: null,
+            selectedIndex: clampedIndex,
+            sessionTargetId: null,
+            type: 'session-picker',
+          },
+          sessions: newSessions,
+          sessionStatuses: nextStatuses,
+          tabs: deletingCurrent ? [] : state.tabs,
+        }
+      }
       return {
         ...state,
-        activeTabId: action.sessionId === state.currentSessionId ? null : state.activeTabId,
-        currentSessionId:
-          action.sessionId === state.currentSessionId ? null : state.currentSessionId,
-        focusMode: 'modal',
-        modal: {
-          editBuffer: null,
-          selectedIndex: clampedIndex,
-          sessionTargetId: null,
-          type: 'session-picker',
-        },
+        activeTabId: deletingCurrent ? null : state.activeTabId,
+        currentSessionId: deletingCurrent ? null : state.currentSessionId,
+        focusMode: deletingCurrent ? 'navigation' : state.focusMode,
+        modal: deletingCurrent ? CLOSED_MODAL : state.modal,
         sessions: newSessions,
         sessionStatuses: nextStatuses,
-        tabs: action.sessionId === state.currentSessionId ? [] : state.tabs,
+        tabs: deletingCurrent ? [] : state.tabs,
       }
     }
     case 'reorder-sessions': {