@brimveyn/aimux 1.8.0 → 1.9.1

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

@@ -4,6 +4,7 @@ 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']
@@ -34,32 +35,54 @@ export function startAIUsageService(
 
   const tick = async (): Promise<void> => {
     if (stopped) return
-    const results = await Promise.allSettled(tools.map((t) => fetchFor(t, config)))
-    if (stopped) return
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i]
-      const tool = tools[i]
-      if (!result || !tool) continue
-      if (result.status === 'fulfilled') {
-        onUpdate(result.value)
+
+    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 {
-        onUpdate({
-          burnRatePerHour: null,
-          costUSD: null,
-          error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-          lastUpdated: new Date().toISOString(),
-          percent: null,
-          resetAt: null,
-          timeRemaining: null,
-          tokens: { cache: 0, input: 0, output: 0, total: 0 },
-          tool,
-        })
+        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()
-      }, pollMs)
+      }, nextDelayMs)
     }
   }
 

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

@@ -2,6 +2,34 @@ 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
@@ -16,5 +44,8 @@ export interface UsageSnapshot {
   timeRemaining: string | null
   burnRatePerHour: number | null
   lastUpdated: string
+  planTier: string | null
+  windows: UsageWindow[]
   error?: string
+  stale?: boolean
 }

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

@@ -18,9 +18,16 @@ export const aiUsageStore = createStore<AIUsageState>((set) => ({
   enabled: false,
   setEnabled: (enabled: boolean) => set({ enabled }),
   setSnapshot: (snap: UsageSnapshot) =>
-    set((state) => ({
-      snapshots: { ...state.snapshots, [snap.tool]: snap },
-    })),
+    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: {},
 }))
 

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

@@ -274,6 +274,8 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
       }
     }
     case 'git-mode-set-parsed': {
+      const prevParsed = state.gitMode.parsedFiles[action.key]
+      if (prevParsed && prevParsed.hash === action.hash) return state
       return {
         ...state,
         gitMode: {
@@ -303,6 +305,62 @@ export function reduceGitModeState(state: AppState, action: AppAction): AppState
         },
       }
     }
+    case 'git-mode-merge-highlights': {
+      const k = `${action.key}|${action.themeId}`
+      const existing = state.gitMode.highlights[k]
+      const sameContent = existing && existing.hash === action.hash
+      if (sameContent) {
+        const existingAdd = existing.add as unknown[]
+        const existingDel = existing.del as unknown[]
+        let changesAnything = false
+        outer: for (const patch of action.add) {
+          const tokens = patch.tokens as unknown[]
+          for (let i = 0; i < tokens.length; i++) {
+            if (existingAdd[patch.start + i] === undefined) {
+              changesAnything = true
+              break outer
+            }
+          }
+        }
+        if (!changesAnything) {
+          outer: for (const patch of action.del) {
+            const tokens = patch.tokens as unknown[]
+            for (let i = 0; i < tokens.length; i++) {
+              if (existingDel[patch.start + i] === undefined) {
+                changesAnything = true
+                break outer
+              }
+            }
+          }
+        }
+        if (!changesAnything) return state
+      }
+      const nextAdd = sameContent ? ([...(existing.add as unknown[])] as unknown[]) : []
+      const nextDel = sameContent ? ([...(existing.del as unknown[])] as unknown[]) : []
+      for (const patch of action.add) {
+        const tokens = patch.tokens as unknown[]
+        for (let i = 0; i < tokens.length; i++) nextAdd[patch.start + i] = tokens[i]
+      }
+      for (const patch of action.del) {
+        const tokens = patch.tokens as unknown[]
+        for (let i = 0; i < tokens.length; i++) nextDel[patch.start + i] = tokens[i]
+      }
+      return {
+        ...state,
+        gitMode: {
+          ...state.gitMode,
+          highlights: {
+            ...state.gitMode.highlights,
+            [k]: {
+              add: nextAdd,
+              del: nextDel,
+              hash: action.hash,
+              themeId: action.themeId,
+            },
+          },
+        },
+      }
+    }
     case 'git-mode-invalidate-diffs': {
       if (action.paths.length === 0) return state
       return clearDiffCacheForPaths(state, new Set(action.paths))

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

@@ -54,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

package/src/state/types.ts

@@ -1,8 +1,6 @@
 import type { ModeId } from '@brimveyn/aimux-config'
 import type { ThemedToken } from 'shiki'
 
-import type { FileDiffMetadata } from '../diff-parser'
-
 export type BuiltinAssistantId = 'claude' | 'codex' | 'opencode' | 'terminal'
 
 export type AssistantId = BuiltinAssistantId | (string & {})
@@ -44,6 +42,7 @@ export type ModalType =
   | 'split-picker'
   | 'git-commit'
   | 'update-available'
+  | 'ai-usage'
   | null
 
 export interface TerminalSpan {
@@ -223,8 +222,7 @@ export interface FoldState {
 
 export interface ParsedDiffEntry {
   hash: string
-  // Stored as unknown at the state boundary; concrete type is FileDiffMetadata
-  // | null, narrowed at read sites via getParsedFile().
+  // Stored as unknown at the state boundary and narrowed at read sites.
   file: unknown
 }
 
@@ -236,9 +234,9 @@ export interface HighlightsEntry {
   del: unknown
 }
 
-export function getParsedFile(entry: ParsedDiffEntry | undefined): FileDiffMetadata | null {
+export function getParsedPayload<T>(entry: ParsedDiffEntry | undefined): T | null {
   if (!entry) return null
-  return entry.file as FileDiffMetadata | null
+  return entry.file as T | null
 }
 
 export function getHighlightsTokens(entry: HighlightsEntry | undefined): {
@@ -348,6 +346,10 @@ export interface ModalUpdateAvailable extends ModalBase {
   latestVersion: string
 }
 
+export interface ModalAIUsage extends ModalBase {
+  type: 'ai-usage'
+}
+
 export type DirectoryResultType = 'git-repo' | 'worktree' | 'workspace'
 
 export interface DirectoryResult {
@@ -369,6 +371,7 @@ export type ModalState =
   | ModalSnippetEditor
   | ModalGitCommit
   | ModalUpdateAvailable
+  | ModalAIUsage
 
 export interface LayoutState {
   terminalCols: number
@@ -434,6 +437,7 @@ export type ModalAction =
   | { type: 'open-theme-picker' }
   | { type: 'open-update-available-modal'; currentVersion: string; latestVersion: string }
   | { type: 'set-modal-selection-index'; index: number }
+  | { type: 'open-ai-usage-modal' }
 
 // -- Session actions --
 export type SessionAction =
@@ -601,6 +605,14 @@ export type GitModeAction =
       add: unknown
       del: unknown
     }
+  | {
+      type: 'git-mode-merge-highlights'
+      key: string
+      hash: string
+      themeId: string
+      add: Array<{ start: number; tokens: unknown }>
+      del: Array<{ start: number; tokens: unknown }>
+    }
   | { type: 'git-mode-invalidate-diffs'; paths: string[] }
   | { type: 'git-mode-set-loading'; key: string; loading: boolean }
   | { type: 'git-mode-set-pending-delete'; path: string | null }

package/src/ui/breaking-update-screen.tsx

@@ -1,7 +1,7 @@
 import { useKeyboard } from '@opentui/react'
 
-import { ListItem } from './components/list-item'
-import { ModalShell } from './components/modal-shell'
+import { ModalShell } from './components/modals/shared/modal-shell'
+import { ListItem } from './components/primitives/list-item'
 import { uiTokens } from './ui-tokens'
 
 interface BreakingUpdateScreenProps {