@brimveyn/aimux 1.19.3 → 1.19.5

package/src/git/git-diff.ts

@@ -2,6 +2,7 @@ import { $ } from 'bun'
 
 import type { DiffData, DiffFileStatus, GitFileEntry } from '../state/types'
 
+import { MAX_DIFF_BYTES } from './diff-limits'
 import { imageFormatLabel, imageMimeFromPath, isImagePath } from './image-detect'
 
 function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?: string } {
@@ -15,19 +16,37 @@ function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?:
   return { status: 'modified' }
 }
 
+// numstat marks a binary file by replacing both line counts with a dash.
+function numstatSaysBinary(text: string): boolean {
+  const first = text.trim().split('\n')[0] ?? ''
+  return first.startsWith('-\t-\t')
+}
+
 async function isBinary(cwd: string, ref: string, path: string): Promise<boolean> {
-  const result = await $`git -C ${cwd} diff ${ref} --numstat -- ${path}`.quiet().nothrow()
-  if (result.exitCode !== 0) return false
-  const text = result.text().trim()
+  const tracked = await $`git -C ${cwd} diff ${ref} --numstat -- ${path}`.quiet().nothrow()
+  if (tracked.exitCode === 0) {
+    const text = tracked.text().trim()
+    if (text) return numstatSaysBinary(text)
+  }
+  // An untracked path is absent from `git diff <ref>` altogether, so the probe above
+  // comes back empty and says nothing about it. Compare against /dev/null to classify
+  // it — without this, every untracked binary reads as text and gets slurped as one
+  // string.
+  const untracked = await $`git -C ${cwd} diff --no-index --numstat /dev/null -- ${path}`
+    .quiet()
+    .nothrow()
+  const text = untracked.text().trim()
   if (!text) return false
-  const first = text.split('\n')[0] ?? ''
-  return first.startsWith('-\t-\t')
+  return numstatSaysBinary(text)
 }
 
 async function readHeadSize(cwd: string, ref: string, path: string): Promise<number> {
-  const result = await $`git -C ${cwd} show ${ref}:${path}`.quiet().nothrow()
+  // `cat-file -s` reads the blob header only. `git show` would materialise the entire
+  // blob as a string just to measure it — the very thing MAX_DIFF_BYTES exists to stop.
+  const result = await $`git -C ${cwd} cat-file -s ${ref}:${path}`.quiet().nothrow()
   if (result.exitCode !== 0) return 0
-  return result.text().length
+  const size = Number.parseInt(result.text().trim(), 10)
+  return Number.isFinite(size) ? size : 0
 }
 
 async function readWorkingSize(cwd: string, path: string): Promise<number> {
@@ -91,6 +110,22 @@ function resolveCompareRef(headOffset: number, compareRef: string | undefined):
   return headOffset > 0 ? `HEAD~${headOffset}` : 'HEAD'
 }
 
+// Both sides are measured from metadata only (blob header + stat), never by reading
+// content — the sizes are what decide whether reading content is safe at all.
+async function diffSizes(
+  cwd: string,
+  ref: string,
+  path: string,
+  headPath: string,
+  status: DiffFileStatus
+): Promise<{ after: number; before: number }> {
+  const [before, after] = await Promise.all([
+    status === 'new' ? Promise.resolve(0) : readHeadSize(cwd, ref, headPath),
+    status === 'deleted' ? Promise.resolve(0) : readWorkingSize(cwd, path),
+  ])
+  return { after, before }
+}
+
 export async function fetchDiff(
   cwd: string,
   file: GitFileEntry,
@@ -99,9 +134,31 @@ export async function fetchDiff(
 ): Promise<DiffData> {
   const { oldPath, status } = resolveStatus(file)
   const ref = resolveCompareRef(headOffset, compareRef)
+  const headPath = oldPath ?? file.path
+
+  const { after: sizeAfter, before: sizeBefore } = await diffSizes(
+    cwd,
+    ref,
+    file.path,
+    headPath,
+    status
+  )
+
+  // Ahead of the image branch on purpose: a multi-gigabyte .png must not be read
+  // into memory either.
+  if (sizeBefore > MAX_DIFF_BYTES || sizeAfter > MAX_DIFF_BYTES) {
+    const data: DiffData = {
+      binarySizeAfter: sizeAfter,
+      binarySizeBefore: sizeBefore,
+      path: file.path,
+      rawDiff: '',
+      status: 'too-large',
+    }
+    if (oldPath != null && oldPath !== '') data.oldPath = oldPath
+    return data
+  }
 
   if (isImagePath(file.path)) {
-    const headPath = oldPath ?? file.path
     const wantsBefore = status !== 'new'
     const wantsAfter = status !== 'deleted'
     const [imageBytesBefore, imageBytesAfter] = await Promise.all([
@@ -124,13 +181,9 @@ export async function fetchDiff(
   }
 
   if (await isBinary(cwd, ref, file.path)) {
-    const [binarySizeBefore, binarySizeAfter] = await Promise.all([
-      readHeadSize(cwd, ref, file.path),
-      readWorkingSize(cwd, file.path),
-    ])
     return {
-      binarySizeAfter,
-      binarySizeBefore,
+      binarySizeAfter: sizeAfter,
+      binarySizeBefore: sizeBefore,
       path: file.path,
       rawDiff: '',
       status: 'binary',

package/src/git/git-status.ts

@@ -8,6 +8,8 @@ import type {
   GitRefreshPayload,
 } from '../state/types'
 
+import { MAX_DIFF_BYTES } from './diff-limits'
+
 interface NumstatRow {
   added: number | null
   removed: number | null
@@ -163,6 +165,11 @@ async function countUntrackedLines(cwd: string, path: string): Promise<number |
   try {
     const file = Bun.file(`${cwd}/${path}`)
     if (!(await file.exists())) return null
+    // Size gate before the read, not after: `.text()` aborts the process on an
+    // oversized blob rather than throwing, so the catch below would never run. Callers
+    // treat null as "no count available", which is the honest answer for a 3 GB
+    // download sitting untracked in the working tree.
+    if (file.size > MAX_DIFF_BYTES) return null
     const text = await file.text()
     if (text.length === 0) return 0
     let count = 0

package/src/index.tsx

@@ -83,7 +83,7 @@ if (command === '--help' || command === '-h' || command === 'help') {
       '',
       'Common CLI verbs at a glance',
       '  aimux tab list                                     Enumerate tabs (+ activeTabId)',
-      '  aimux tab create --assistant <id> [--title …]      Spawn claude / codex / opencode / terminal / …',
+      '  aimux tab create --assistant <id> [--title …]      Spawn claude / codex / opencode / grok / terminal / …',
       '  aimux tab send <tabId> [text] [--enter|--keys|--stdin]  Type, chord, or paste into a tab',
       '  aimux tab focus <tabId>                            Bring a tab to the foreground',
       '  aimux tab close <tabId>                            Terminate a tab',

package/src/pty/assistant-question-extractor.ts

@@ -41,6 +41,7 @@ const PERMISSION_SIGNALS: readonly string[] = [
   '△ permission',
   'allow this',
   'approve',
+  'pprove', // Grok stylized plan approval "[ a ] pprove ..."
   'grant',
   'press enter to confirm',
 ]

package/src/pty/assistant-status-detector.ts

@@ -6,7 +6,7 @@
  * `src/detect.rs` in that repo.
  *
  * The detector classifies a terminal session as `working`, `waiting-input`,
- * or `idle`. Built-in CLIs (claude, codex, opencode) use per-CLI substring
+ * or `idle`. Built-in CLIs (claude, codex, opencode, grok) have dedicated classify* functions.
  * tables. Custom CLIs fall back to a generic heuristic that (a) recognises
  * common shells as always-idle and (b) uses pane-tail change velocity plus
  * generic y/n / confirm prompt patterns.
@@ -95,7 +95,7 @@ export class AssistantStatusDetector {
 export function extractTailLines(viewport: TerminalSnapshot, lineCount: number): string[] {
   const isScrolledToBottom = viewport.viewportY === viewport.baseY
   const lines = isScrolledToBottom ? viewport.lines : (viewport.tailLines ?? viewport.lines)
-  // Full-screen TUIs (claude, opencode) paint in the alternate buffer and
+  // Full-screen TUIs (claude, opencode, grok) paint in the alternate buffer and
   // often leave the last rows blank, putting their status bar higher up.
   // Skip trailing blank rows before taking the last `lineCount`.
   let end = lines.length
@@ -138,6 +138,8 @@ function classifyBuiltin(
       return classifyCodex(haystack)
     case 'opencode':
       return classifyOpencode(haystack)
+    case 'grok':
+      return classifyGrok(haystack, rawTail)
     default:
       return null
   }
@@ -212,6 +214,47 @@ function classifyOpencode(haystack: string): TabActivity {
   return 'idle'
 }
 
+function classifyGrok(haystack: string, _rawTail: string): TabActivity {
+  // Waiting for user decision / input (plan approval, Q&A, permissions, confirms).
+  // These are the distinctive Grok Build TUI states that must produce 'waiting-input'
+  // so the rest of the system (turn lifecycle, question events, UI chips, orchestrators)
+  // treats grok the same as claude/codex/opencode.
+  if (
+    haystack.includes('waiting on answers') ||
+    haystack.includes('pprove') || // stylized "[ a ] pprove [ c ] omment [ q ] uit plan"
+    haystack.includes('omment') ||
+    haystack.includes('uit plan') ||
+    (haystack.includes('approve') &&
+      (haystack.includes('comment') || haystack.includes('quit') || haystack.includes('plan'))) ||
+    haystack.includes('enter :select') ||
+    haystack.includes('enter to select') ||
+    haystack.includes('enter submit') ||
+    haystack.includes('do you want') ||
+    haystack.includes('would you like') ||
+    haystack.includes('permission required') ||
+    haystack.includes('permission to') ||
+    haystack.includes('approve?') ||
+    haystack.includes('allow?')
+  ) {
+    return 'waiting-input'
+  }
+
+  // Agent actively reasoning or executing (mirrors claude spinner + interrupt logic).
+  // "Thought for Xs" is the primary visible trace while Grok thinks/plans.
+  if (
+    haystack.includes('thought for') || // "Thought for 3.4s", etc.
+    haystack.includes('thinking…') ||
+    haystack.includes('thinking ...') ||
+    haystack.includes('esc to interrupt') ||
+    haystack.includes('esc interrupt') ||
+    haystack.includes('esc: interrupt')
+  ) {
+    return 'working'
+  }
+
+  return 'idle'
+}
+
 const GENERIC_WAITING_PATTERNS: string[] = [
   '[y/n]',
   '(y/n)',

package/src/pty/command-registry.ts

@@ -59,6 +59,17 @@ export const ASSISTANT_OPTIONS: AssistantOption[] = [
       buildModelArgs: (model) => ['--model', model],
     },
   },
+  {
+    command: 'grok',
+    description: 'xAI Grok Build CLI',
+    id: 'grok',
+    label: 'Grok',
+    model: {
+      // Grok supports -m (and likely --model) plus --effort (alias --reasoning-effort).
+      buildEffortArgs: (effort) => ['--effort', effort],
+      buildModelArgs: (model) => ['-m', model],
+    },
+  },
   {
     command: 'agy',
     description: 'Antigravity CLI',

package/src/state/types.ts

@@ -4,7 +4,13 @@ import type { ThemedToken } from 'shiki'
 import type { WorktreeTemplate } from '../config'
 import type { LayoutNode, SplitDirection } from './layout-tree'
 
-export type BuiltinAssistantId = 'claude' | 'codex' | 'opencode' | 'terminal' | 'antigravity'
+export type BuiltinAssistantId =
+  | 'claude'
+  | 'codex'
+  | 'opencode'
+  | 'grok'
+  | 'terminal'
+  | 'antigravity'
 
 export type AssistantId = BuiltinAssistantId | (string & {})
 
@@ -256,7 +262,14 @@ export interface GitPanelState {
   error: GitPanelError | null
 }
 
-export type DiffFileStatus = 'modified' | 'new' | 'deleted' | 'binary' | 'renamed' | 'image'
+export type DiffFileStatus =
+  | 'modified'
+  | 'new'
+  | 'deleted'
+  | 'binary'
+  | 'renamed'
+  | 'image'
+  | 'too-large'
 
 export interface DiffData {
   path: string

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

@@ -7,6 +7,7 @@ import type { DiffData, GitDiffView } from '../../../state/types'
 import type { ThemeId } from '../../themes'
 
 import { diffHash } from '../../../git/diff-hash'
+import { MAX_DIFF_BYTES } from '../../../git/diff-limits'
 import { getMergeBase } from '../../../git/divergence'
 import { fetchDiff } from '../../../git/git-diff'
 import { useGitPanelPolling } from '../../../git/git-poller'
@@ -21,6 +22,7 @@ import { PierreDiff, type PierreDiffHandle } from './diff-renderer'
 import { useDiffPrefetch } from './diff-renderer/use-diff-prefetch'
 import { GitPanel } from './git-panel'
 import { ImageDiffView } from './image-diff'
+import { formatBytes } from './image-diff/dimensions'
 import { GitPaneHeader } from './pane/git-pane-header'
 
 interface DiffStageProps {
@@ -33,6 +35,12 @@ interface DiffStageProps {
 }
 
 function placeholderText(diff: DiffData): string | null {
+  if (diff.status === 'too-large') {
+    const before = diff.binarySizeBefore ?? 0
+    const after = diff.binarySizeAfter ?? 0
+    const largest = Math.max(before, after)
+    return `(file too large to diff — ${formatBytes(largest)}, limit ${formatBytes(MAX_DIFF_BYTES)})`
+  }
   if (diff.status === 'binary') {
     const before = diff.binarySizeBefore ?? 0
     const after = diff.binarySizeAfter ?? 0

package/src/ui/components/git/image-diff/dimensions.ts

@@ -92,5 +92,6 @@ export function readImageDimensions(bytes: Uint8Array): ImageDimensions | null {
 export function formatBytes(n: number): string {
   if (n < 1024) return `${n} B`
   if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
-  return `${(n / (1024 * 1024)).toFixed(2)} MB`
+  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(2)} MB`
+  return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`
 }