@brimveyn/aimux 1.12.6 → 1.13.2

package/src/terminal-manager/manager-client.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from 'node:events'
-import { connect, Socket } from 'node:net'
+import { connect, type Socket } from 'node:net'
 
 import type {
   ScrollIntent,
@@ -23,7 +23,7 @@ import {
   parseManagerMessage,
 } from '../ipc/manager-protocol'
 
-type ManagerClientEvents = {
+interface ManagerClientEvents {
   render: [
     sessionId: string,
     tabId: string,
@@ -84,7 +84,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     return this.socket
   }
 
-  private send(request: ManagerRequest): Promise<ManagerResponse> {
+  private async send(request: ManagerRequest): Promise<ManagerResponse> {
     const socket = this.getConnectedSocket()
     logDebug('managerClient.send', { id: request.id, type: request.type })
     return new Promise((resolve, reject) => {
@@ -286,7 +286,9 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     return response.payload
   }
 
-  createTab(options: Extract<ManagerRequest, { type: 'createTab' }>['payload']): Promise<void> {
+  async createTab(
+    options: Extract<ManagerRequest, { type: 'createTab' }>['payload']
+  ): Promise<void> {
     logDebug('managerClient.createTab', {
       command: options.command,
       sessionId: options.sessionId,
@@ -296,7 +298,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     return this.sendExpectOk({ id: crypto.randomUUID(), payload: options, type: 'createTab' })
   }
 
-  write(sessionId: string, tabId: string, data: string): Promise<void> {
+  async write(sessionId: string, tabId: string, data: string): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { data, sessionId, tabId },
@@ -304,7 +306,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  resize(
+  async resize(
     sessionId: string,
     cols: number,
     rows: number,
@@ -317,7 +319,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  resizeTab(
+  async resizeTab(
     sessionId: string,
     tabId: string,
     cols: number,
@@ -331,7 +333,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  scroll(sessionId: string, tabId: string, deltaLines: number): Promise<void> {
+  async scroll(sessionId: string, tabId: string, deltaLines: number): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { deltaLines, sessionId, tabId },
@@ -339,7 +341,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  scrollToBottom(sessionId: string, tabId: string): Promise<void> {
+  async scrollToBottom(sessionId: string, tabId: string): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { sessionId, tabId },
@@ -347,7 +349,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  reapplyScrollIntent(sessionId: string, tabId: string, intent: ScrollIntent): Promise<void> {
+  async reapplyScrollIntent(sessionId: string, tabId: string, intent: ScrollIntent): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { intent, sessionId, tabId },
@@ -355,7 +357,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  setActiveTab(sessionId: string, tabId: string | null): Promise<void> {
+  async setActiveTab(sessionId: string, tabId: string | null): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { sessionId, tabId },
@@ -363,7 +365,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  closeTab(sessionId: string, tabId: string): Promise<void> {
+  async closeTab(sessionId: string, tabId: string): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { sessionId, tabId },
@@ -371,7 +373,7 @@ export class TerminalManagerClient extends EventEmitter<ManagerClientEvents> {
     })
   }
 
-  disposeSession(sessionId: string): Promise<void> {
+  async disposeSession(sessionId: string): Promise<void> {
     return this.sendExpectOk({
       id: crypto.randomUUID(),
       payload: { sessionId },

package/src/ui/components/git/diff-renderer/fold-strip.tsx

@@ -1,13 +1,16 @@
+import { memo, useCallback } from 'react'
+
+import type { FoldDispatch } from './pierre-diff'
+
 import { useTheme } from '../../../theme'
 import { FOLD_STEP, type FoldInfo } from './build-rows'
-import { type FoldDispatch } from './pierre-diff'
 
 interface Props {
   fold: FoldInfo
   dispatch: FoldDispatch
 }
 
-function Button({ label, onPress }: { label: string; onPress: () => void }) {
+const Button = memo(function Button({ label, onPress }: { label: string; onPress: () => void }) {
   const t = useTheme()
   const bg = t.diffContextBg
   return (
@@ -15,7 +18,7 @@ function Button({ label, onPress }: { label: string; onPress: () => void }) {
       <text fg={t.primary}>{label}</text>
     </box>
   )
-}
+})
 
 function Spacer() {
   return <text> </text>
@@ -30,42 +33,47 @@ export function FoldStrip({ dispatch, fold }: Props) {
   const shrinkUp = Math.min(FOLD_STEP, topExpanded)
   const shrinkDown = Math.min(FOLD_STEP, bottomExpanded)
 
+  const handleExpandTop = useCallback(
+    () => dispatch.adjust(foldId, 'top', stepUp),
+    [dispatch, foldId, stepUp]
+  )
+  const handleExpandBottom = useCallback(
+    () => dispatch.adjust(foldId, 'bottom', stepDown),
+    [dispatch, foldId, stepDown]
+  )
+  const handleExpandAll = useCallback(
+    () => dispatch.set(foldId, total, 0),
+    [dispatch, foldId, total]
+  )
+  const handleShrinkTop = useCallback(
+    () => dispatch.adjust(foldId, 'top', -shrinkUp),
+    [dispatch, foldId, shrinkUp]
+  )
+  const handleShrinkBottom = useCallback(
+    () => dispatch.adjust(foldId, 'bottom', -shrinkDown),
+    [dispatch, foldId, shrinkDown]
+  )
+
   const controls: React.ReactNode[] = []
   if (hidden > 0) {
     controls.push(
-      <Button
-        key="up"
-        label={`↑${stepUp}`}
-        onPress={() => dispatch.adjust(foldId, 'top', stepUp)}
-      />,
+      <Button key="up" label={`↑${stepUp}`} onPress={handleExpandTop} />,
       <Spacer key="sp1" />,
-      <Button
-        key="down"
-        label={`↓${stepDown}`}
-        onPress={() => dispatch.adjust(foldId, 'bottom', stepDown)}
-      />,
+      <Button key="down" label={`↓${stepDown}`} onPress={handleExpandBottom} />,
       <Spacer key="sp2" />,
-      <Button key="all" label="⇅ all" onPress={() => dispatch.set(foldId, total, 0)} />
+      <Button key="all" label="⇅ all" onPress={handleExpandAll} />
     )
   }
   if (shrinkUp > 0) {
     controls.push(
       <Spacer key="sp3" />,
-      <Button
-        key="shrinkUp"
-        label={`−↑${shrinkUp}`}
-        onPress={() => dispatch.adjust(foldId, 'top', -shrinkUp)}
-      />
+      <Button key="shrinkUp" label={`−↑${shrinkUp}`} onPress={handleShrinkTop} />
     )
   }
   if (shrinkDown > 0) {
     controls.push(
       <Spacer key="sp4" />,
-      <Button
-        key="shrinkDown"
-        label={`−↓${shrinkDown}`}
-        onPress={() => dispatch.adjust(foldId, 'bottom', -shrinkDown)}
-      />
+      <Button key="shrinkDown" label={`−↓${shrinkDown}`} onPress={handleShrinkBottom} />
     )
   }
 

package/src/ui/components/git/diff-renderer/pierre-diff.tsx

@@ -3,11 +3,11 @@ import type { ThemedToken } from 'shiki'
 
 import { forwardRef, useEffect, useImperativeHandle, useMemo, useRef } from 'react'
 
+import type { FoldState } from '../../../../state/types'
 import type { ThemeId } from '../../../themes'
 
 import { useAppStore } from '../../../../state/app-store'
 import { dispatchGlobal } from '../../../../state/dispatch-ref'
-import { type FoldState } from '../../../../state/types'
 import { useTheme } from '../../../theme'
 import { buildDiffSegments, firstChangeSegmentOffset, gutterWidth } from './build-rows'
 import { SplitView, type SplitViewHandle } from './split-view'

package/src/ui/components/git/diff-renderer/prepare-diff.ts

@@ -22,14 +22,14 @@ interface PrepareOptions {
   signal?: AbortSignal
 }
 
-function yieldToEventLoop(): Promise<void> {
+async function yieldToEventLoop(): Promise<void> {
   return new Promise((resolve) => {
     setImmediate(resolve)
   })
 }
 
 function throwIfAborted(signal?: AbortSignal): void {
-  if (signal?.aborted) throw new DOMException('Aborted', 'AbortError')
+  if (signal?.aborted === true) throw new DOMException('Aborted', 'AbortError')
 }
 
 // Lifts diff parsing off the synchronous render tree and returns a segmented

package/src/ui/components/git/diff-renderer/split-view.tsx

@@ -34,6 +34,30 @@ import { tokenToSpan } from './highlight'
 import { useSegmentVirtualization } from './use-segment-virtualization'
 
 const OVERSCAN = 24
+const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
+const HIDDEN_SCROLLBAR_OPTIONS = { visible: false }
+
+// Stable per-row key derived from the line identities in the row, so rows keep a
+// consistent identity across fold expand/collapse rather than relying on position.
+function splitCellKey(cell: SplitCell): string {
+  switch (cell.type) {
+    case 'context':
+      return `c${cell.lineNumber}`
+    case 'addition':
+      return `a${cell.lineNumber}`
+    case 'deletion':
+      return `d${cell.lineNumber}`
+    case 'fold':
+      return `f${cell.fold.foldId}`
+    case 'filler':
+      return 'x'
+  }
+}
+
+function splitRowKey(row: SplitRowOrHeader): string {
+  if (row.type === 'hunk-header') return `hh:${row.spec}`
+  return `${splitCellKey(row.left)}|${splitCellKey(row.right)}`
+}
 
 export interface SplitViewHandle {
   leftScroll: ScrollBoxRenderable | null
@@ -154,15 +178,15 @@ export const SplitView = forwardRef<SplitViewHandle, Props>(function SplitView(
         flexGrow={1}
         scrollY
         viewportCulling
-        contentOptions={{ flexDirection: 'column', gap: 0 }}
-        verticalScrollbarOptions={{ visible: false }}
+        contentOptions={COLUMN_CONTENT_OPTIONS}
+        verticalScrollbarOptions={HIDDEN_SCROLLBAR_OPTIONS}
         onMouseScroll={handleScroll}
       >
         {visibleWindow.topSpacer > 0 ? <box height={visibleWindow.topSpacer} /> : null}
         {renderedSegments.map((rendered) =>
-          rendered.rows.map((row, i) => (
+          rendered.rows.map((row) => (
             <SideRow
-              key={`${rendered.segment.id}:left:${i}`}
+              key={`${rendered.segment.id}:left:${splitRowKey(row)}`}
               cell={row.type === 'row' ? row.left : null}
               foldDispatch={foldDispatch}
               gw={gw}
@@ -180,14 +204,14 @@ export const SplitView = forwardRef<SplitViewHandle, Props>(function SplitView(
         flexGrow={1}
         scrollY
         viewportCulling
-        contentOptions={{ flexDirection: 'column', gap: 0 }}
+        contentOptions={COLUMN_CONTENT_OPTIONS}
         onMouseScroll={handleScroll}
       >
         {visibleWindow.topSpacer > 0 ? <box height={visibleWindow.topSpacer} /> : null}
         {renderedSegments.map((rendered) =>
-          rendered.rows.map((row, i) => (
+          rendered.rows.map((row) => (
             <SideRow
-              key={`${rendered.segment.id}:right:${i}`}
+              key={`${rendered.segment.id}:right:${splitRowKey(row)}`}
               cell={row.type === 'row' ? row.right : null}
               foldDispatch={foldDispatch}
               gw={gw}
@@ -230,7 +254,9 @@ function HunkHeaderRow({ row }: { row: Extract<SplitRowOrHeader, { type: 'hunk-h
   return (
     <box flexDirection="row" backgroundColor={headerBg} paddingLeft={1} paddingRight={1}>
       <text fg={t.text}>{row.spec}</text>
-      {row.context ? <text fg={t.textMuted}> {row.context}</text> : null}
+      {row.context != null && row.context !== '' ? (
+        <text fg={t.textMuted}> {row.context}</text>
+      ) : null}
     </box>
   )
 }
@@ -285,10 +311,12 @@ function LineContent({ content, tokens }: { content: string; tokens: ThemedToken
       {tokens.map((tok, i) => {
         const s = tokenToSpan(tok)
         let attributes = 0
-        if (s.bold) attributes |= TextAttributes.BOLD
-        if (s.italic) attributes |= TextAttributes.ITALIC
-        if (s.underline) attributes |= TextAttributes.UNDERLINE
+        if (s.bold === true) attributes |= TextAttributes.BOLD
+        if (s.italic === true) attributes |= TextAttributes.ITALIC
+        if (s.underline === true) attributes |= TextAttributes.UNDERLINE
         return (
+          // Syntax tokens are positional within a single line and never reorder.
+          // eslint-disable-next-line react/no-array-index-key
           <span key={i} fg={s.fg ?? t.text} attributes={attributes}>
             {s.text}
           </span>

package/src/ui/components/git/diff-renderer/stacked-view.tsx

@@ -33,6 +33,24 @@ import { tokenToSpan } from './highlight'
 import { useSegmentVirtualization } from './use-segment-virtualization'
 
 const OVERSCAN = 24
+const COLUMN_CONTENT_OPTIONS = { flexDirection: 'column' as const, gap: 0 }
+
+// Stable per-row key derived from the line identities in the row, so rows keep a
+// consistent identity across fold expand/collapse rather than relying on position.
+function unifiedRowKey(row: UnifiedRowOrHeader): string {
+  switch (row.type) {
+    case 'hunk-header':
+      return `hh:${row.spec}`
+    case 'fold':
+      return `f:${row.fold.foldId}`
+    case 'context':
+      return `c:${row.delLineNumber}:${row.addLineNumber}`
+    case 'addition':
+      return `a:${row.lineNumber}`
+    case 'deletion':
+      return `d:${row.lineNumber}`
+  }
+}
 
 export interface StackedViewHandle {
   scroll: ScrollBoxRenderable | null
@@ -148,14 +166,14 @@ export const StackedView = forwardRef<StackedViewHandle, Props>(function Stacked
       flexGrow={1}
       scrollY
       viewportCulling
-      contentOptions={{ flexDirection: 'column', gap: 0 }}
+      contentOptions={COLUMN_CONTENT_OPTIONS}
       onMouseScroll={handleScroll}
     >
       {visibleWindow.topSpacer > 0 ? <box height={visibleWindow.topSpacer} /> : null}
       {renderedSegments.map((rendered) =>
-        rendered.rows.map((row, i) => (
+        rendered.rows.map((row) => (
           <UnifiedRowRender
-            key={`${rendered.segment.id}:${i}`}
+            key={`${rendered.segment.id}:${unifiedRowKey(row)}`}
             foldDispatch={foldDispatch}
             gw={gw}
             highlights={highlights}
@@ -186,7 +204,9 @@ function UnifiedRowRender({
     return (
       <box flexDirection="row" backgroundColor={headerBg} paddingLeft={1} paddingRight={1}>
         <text fg={t.text}>{row.spec}</text>
-        {row.context ? <text fg={t.textMuted}> {row.context}</text> : null}
+        {row.context != null && row.context !== '' ? (
+          <text fg={t.textMuted}> {row.context}</text>
+        ) : null}
       </box>
     )
   }
@@ -230,10 +250,12 @@ function LineContent({ content, tokens }: { content: string; tokens: ThemedToken
       {tokens.map((tok, i) => {
         const s = tokenToSpan(tok)
         let attributes = 0
-        if (s.bold) attributes |= TextAttributes.BOLD
-        if (s.italic) attributes |= TextAttributes.ITALIC
-        if (s.underline) attributes |= TextAttributes.UNDERLINE
+        if (s.bold === true) attributes |= TextAttributes.BOLD
+        if (s.italic === true) attributes |= TextAttributes.ITALIC
+        if (s.underline === true) attributes |= TextAttributes.UNDERLINE
         return (
+          // Syntax tokens are positional within a single line and never reorder.
+          // eslint-disable-next-line react/no-array-index-key
           <span key={i} fg={s.fg ?? t.text} attributes={attributes}>
             {s.text}
           </span>

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

@@ -13,6 +13,7 @@ interface PrefetchOptions {
   projectPath: string | undefined
   themeId: string
   headOffset: number
+  compareRef?: string
   enabled: boolean
 }
 
@@ -66,11 +67,15 @@ class PrefetchQueue {
       if (!task) break
       this.inflight.set(task.key, task.controller)
       this.running += 1
-      void this.execute(task).finally(() => {
-        this.inflight.delete(task.key)
-        this.running -= 1
-        this.pump()
-      })
+      void (async () => {
+        try {
+          await this.execute(task)
+        } finally {
+          this.inflight.delete(task.key)
+          this.running -= 1
+          this.pump()
+        }
+      })()
     }
   }
 }
@@ -94,15 +99,20 @@ export function useDiffPrefetch(
 
   const queueRef = useRef<PrefetchQueue | null>(null)
 
-  const { enabled, headOffset, projectPath } = opts
+  const { compareRef, enabled, headOffset, projectPath } = opts
   const runTaskRef = useRef<(task: Task) => Promise<void>>(async () => {})
 
   // Keep a ref to the execute function so the queue keeps the latest closure
   // without needing to recreate the queue itself.
   runTaskRef.current = async (task: Task) => {
-    if (!projectPath) return
+    if (!(projectPath != null && projectPath !== '')) return
     try {
-      const diff = await fetchDiff(task.file.repoPath ?? projectPath, task.file, headOffset)
+      const diff = await fetchDiff(
+        task.file.repoPath ?? projectPath,
+        task.file,
+        headOffset,
+        compareRef
+      )
       if (task.controller.signal.aborted) return
       const hash = diffHash(diff.rawDiff)
       dispatchGlobal({ diff, hash, key: task.key, type: 'git-mode-set-diff' })
@@ -122,13 +132,19 @@ export function useDiffPrefetch(
   }
 
   if (!queueRef.current) {
-    queueRef.current = new PrefetchQueue((task) => runTaskRef.current(task), MAX_CONCURRENCY)
+    queueRef.current = new PrefetchQueue(async (task) => runTaskRef.current(task), MAX_CONCURRENCY)
   }
 
   useEffect(() => {
     const queue = queueRef.current
     if (!queue) return
-    if (!enabled || radius <= 0 || !projectPath || !selectedEntryKey) {
+    if (
+      !enabled ||
+      radius <= 0 ||
+      projectPath == null ||
+      projectPath === '' ||
+      !(selectedEntryKey != null && selectedEntryKey !== '')
+    ) {
       queue.cancelAll()
       return
     }
@@ -149,7 +165,7 @@ export function useDiffPrefetch(
       const key = row.key
       if (diffs[key]) continue
       if (parsed[key]) continue
-      if (loading[key]) continue
+      if (loading[key] === true) continue
       tasks.push({
         controller: new AbortController(),
         distance: Math.abs(i - selectedIdx),
@@ -171,6 +187,7 @@ export function useDiffPrefetch(
     parsed,
     loading,
     headOffset,
+    compareRef,
   ])
 
   useEffect(() => {

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

@@ -124,8 +124,9 @@ export function useDiffPreparation(
     const owner = requestOwner
     const version = requestVersionRef.current
     setPreparing(true)
-    void prepareDiff(diff, path, { signal: controller.signal })
-      .then((result) => {
+    void (async () => {
+      try {
+        const result = await prepareDiff(diff, path, { signal: controller.signal })
         if (
           controller.signal.aborted ||
           requestVersionRef.current !== version ||
@@ -142,9 +143,9 @@ export function useDiffPreparation(
           key: cacheKey,
           type: 'git-mode-set-parsed',
         })
-      })
-      .catch(() => {})
-      .finally(() => {
+      } catch {
+        // Aborted or failed preparation; nothing to surface here.
+      } finally {
         if (
           !controller.signal.aborted &&
           requestVersionRef.current === version &&
@@ -152,7 +153,8 @@ export function useDiffPreparation(
         ) {
           setPreparing(false)
         }
-      })
+      }
+    })()
 
     return () => {
       controller.abort()
@@ -163,11 +165,11 @@ export function useDiffPreparation(
     (segments: readonly DiffSegment[]) => {
       const file = parsed.file
       const filetype = parsed.filetype
-      if (!file || !filetype) return
+      if (!file || !(filetype != null && filetype !== '')) return
       const owner = requestOwner
       const version = requestVersionRef.current
       const activeHash = cachedParsed?.hash ?? (localOwnerMatches ? localHash : null)
-      if (!activeHash) return
+      if (!(activeHash != null && activeHash !== '')) return
       const next = segments.filter(
         (segment) =>
           (segment.kind === 'context' || segment.kind === 'change') &&