@brimveyn/aimux 1.9.0 → 1.9.2

package/src/ui/components/diff-renderer/build-rows.ts

@@ -1,349 +0,0 @@
-import type { FileDiffMetadata, Hunk, HunkContent } from '../../../diff-parser'
-import type { FoldState } from '../../../state/types'
-
-export const KEEP_CONTEXT = 3
-export const MIN_FOLD_SIZE = 3
-export const FOLD_STEP = 5
-
-export interface FoldInfo {
-  foldId: string
-  total: number
-  hidden: number
-  topExpanded: number
-  bottomExpanded: number
-}
-
-export type SplitCell =
-  | { content: string; lineIdx: number; lineNumber: number; type: 'context' }
-  | { content: string; lineIdx: number; lineNumber: number; type: 'addition' | 'deletion' }
-  | { fold: FoldInfo; type: 'fold' }
-  | { type: 'filler' }
-
-export interface SplitRow {
-  type: 'row'
-  left: SplitCell
-  right: SplitCell
-  height: number
-}
-
-export type UnifiedRow =
-  | {
-      addLineNumber: number
-      content: string
-      lineIdx: number
-      delLineNumber: number
-      type: 'context'
-      height: number
-    }
-  | {
-      content: string
-      lineIdx: number
-      lineNumber: number
-      type: 'addition' | 'deletion'
-      height: number
-    }
-  | { fold: FoldInfo; type: 'fold' }
-
-export interface HunkHeader {
-  context?: string
-  spec: string
-  type: 'hunk-header'
-}
-
-export type SplitRowOrHeader = HunkHeader | SplitRow
-export type UnifiedRowOrHeader = HunkHeader | UnifiedRow
-
-export type FoldMap = Record<string, FoldState>
-
-function wrapCount(content: string, width: number): number {
-  if (width <= 0) return 1
-  return Math.max(1, Math.ceil(content.length / width))
-}
-
-function cellWraps(content: string, width: number): number {
-  return wrapCount(content, width)
-}
-
-interface ContextSlice {
-  // which file-line indices (relative to content start) to show, and which to fold
-  leadingVisible: number
-  fold: { length: number; offset: number } | null
-  trailingVisible: number
-}
-
-function sliceContext(
-  totalLines: number,
-  hasChangeBefore: boolean,
-  hasChangeAfter: boolean,
-  fold: FoldState
-): ContextSlice {
-  const preKeep = hasChangeBefore ? Math.min(KEEP_CONTEXT, totalLines) : 0
-  const postKeep = hasChangeAfter ? Math.min(KEEP_CONTEXT, totalLines - preKeep) : 0
-  const middle = totalLines - preKeep - postKeep
-  if (middle < MIN_FOLD_SIZE) {
-    return { fold: null, leadingVisible: totalLines, trailingVisible: 0 }
-  }
-  const top = Math.min(fold.top, middle)
-  const bottom = Math.min(fold.bottom, middle - top)
-  const hidden = middle - top - bottom
-  if (hidden <= 0) {
-    return { fold: null, leadingVisible: totalLines, trailingVisible: 0 }
-  }
-  return {
-    fold: { length: hidden, offset: preKeep + top },
-    leadingVisible: preKeep + top,
-    trailingVisible: postKeep + bottom,
-  }
-}
-
-function makeFoldInfo(foldId: string, middle: number, fold: FoldState, hidden: number): FoldInfo {
-  const topExpanded = Math.min(fold.top, middle)
-  const bottomExpanded = Math.min(fold.bottom, middle - topExpanded)
-  return { bottomExpanded, foldId, hidden, topExpanded, total: middle }
-}
-
-function contextNeighbors(
-  contents: HunkContent[],
-  index: number
-): { hasChangeBefore: boolean; hasChangeAfter: boolean } {
-  let hasChangeBefore = false
-  for (let i = index - 1; i >= 0; i--) {
-    const c = contents[i]
-    if (c && c.type !== 'context') {
-      hasChangeBefore = true
-      break
-    }
-  }
-  let hasChangeAfter = false
-  for (let i = index + 1; i < contents.length; i++) {
-    const c = contents[i]
-    if (c && c.type !== 'context') {
-      hasChangeAfter = true
-      break
-    }
-  }
-  return { hasChangeAfter, hasChangeBefore }
-}
-
-export function buildSplitRows(
-  file: FileDiffMetadata,
-  folds: FoldMap = {},
-  contentWidth = 0
-): SplitRowOrHeader[] {
-  const rows: SplitRowOrHeader[] = []
-  const pairHeight = (l: SplitCell, r: SplitCell): number => {
-    const lh =
-      l.type === 'context' || l.type === 'addition' || l.type === 'deletion'
-        ? cellWraps(l.content, contentWidth)
-        : 1
-    const rh =
-      r.type === 'context' || r.type === 'addition' || r.type === 'deletion'
-        ? cellWraps(r.content, contentWidth)
-        : 1
-    return Math.max(lh, rh)
-  }
-  for (const [hIdx, hunk] of file.hunks.entries()) {
-    rows.push(makeHeader(hunk))
-    let delLine = hunk.deletionStart
-    let addLine = hunk.additionStart
-    for (const [cIdx, content] of hunk.hunkContent.entries()) {
-      if (content.type === 'context') {
-        const foldId = `${hIdx}:${cIdx}`
-        const { hasChangeAfter, hasChangeBefore } = contextNeighbors(hunk.hunkContent, cIdx)
-        const foldState = folds[foldId] ?? { bottom: 0, top: 0 }
-        const slice = sliceContext(content.lines, hasChangeBefore, hasChangeAfter, foldState)
-
-        const pushContext = (start: number, count: number): void => {
-          for (let i = 0; i < count; i++) {
-            const offset = start + i
-            const addIdx = content.additionLineIndex + offset
-            const delIdx = content.deletionLineIndex + offset
-            const text = stripNewline(file.additionLines[addIdx] ?? '')
-            const left: SplitCell = {
-              content: text,
-              lineIdx: delIdx,
-              lineNumber: delLine++,
-              type: 'context',
-            }
-            const right: SplitCell = {
-              content: text,
-              lineIdx: addIdx,
-              lineNumber: addLine++,
-              type: 'context',
-            }
-            rows.push({ height: pairHeight(left, right), left, right, type: 'row' })
-          }
-        }
-
-        pushContext(0, slice.leadingVisible)
-        if (slice.fold) {
-          const preKeep = hasChangeBefore ? Math.min(KEEP_CONTEXT, content.lines) : 0
-          const postKeep = hasChangeAfter ? Math.min(KEEP_CONTEXT, content.lines - preKeep) : 0
-          const middle = content.lines - preKeep - postKeep
-          const info = makeFoldInfo(foldId, middle, foldState, slice.fold.length)
-          rows.push({
-            height: 1,
-            left: { fold: info, type: 'fold' },
-            right: { fold: info, type: 'fold' },
-            type: 'row',
-          })
-          delLine += slice.fold.length
-          addLine += slice.fold.length
-          pushContext(slice.fold.offset + slice.fold.length, slice.trailingVisible)
-        }
-      } else {
-        const max = Math.max(content.additions, content.deletions)
-        for (let i = 0; i < max; i++) {
-          const delIdx = content.deletionLineIndex + i
-          const addIdx = content.additionLineIndex + i
-          const left: SplitCell =
-            i < content.deletions
-              ? {
-                  content: stripNewline(file.deletionLines[delIdx] ?? ''),
-                  lineIdx: delIdx,
-                  lineNumber: delLine++,
-                  type: 'deletion',
-                }
-              : { type: 'filler' }
-          const right: SplitCell =
-            i < content.additions
-              ? {
-                  content: stripNewline(file.additionLines[addIdx] ?? ''),
-                  lineIdx: addIdx,
-                  lineNumber: addLine++,
-                  type: 'addition',
-                }
-              : { type: 'filler' }
-          rows.push({ height: pairHeight(left, right), left, right, type: 'row' })
-        }
-      }
-    }
-  }
-  return rows
-}
-
-export function buildUnifiedRows(
-  file: FileDiffMetadata,
-  folds: FoldMap = {},
-  contentWidth = 0
-): UnifiedRowOrHeader[] {
-  const rows: UnifiedRowOrHeader[] = []
-  for (const [hIdx, hunk] of file.hunks.entries()) {
-    rows.push(makeHeader(hunk))
-    let delLine = hunk.deletionStart
-    let addLine = hunk.additionStart
-    for (const [cIdx, content] of hunk.hunkContent.entries()) {
-      if (content.type === 'context') {
-        const foldId = `${hIdx}:${cIdx}`
-        const { hasChangeAfter, hasChangeBefore } = contextNeighbors(hunk.hunkContent, cIdx)
-        const foldState = folds[foldId] ?? { bottom: 0, top: 0 }
-        const slice = sliceContext(content.lines, hasChangeBefore, hasChangeAfter, foldState)
-
-        const pushContext = (start: number, count: number): void => {
-          for (let i = 0; i < count; i++) {
-            const offset = start + i
-            const addIdx = content.additionLineIndex + offset
-            const text = stripNewline(file.additionLines[addIdx] ?? '')
-            rows.push({
-              addLineNumber: addLine++,
-              content: text,
-              delLineNumber: delLine++,
-              height: cellWraps(text, contentWidth),
-              lineIdx: addIdx,
-              type: 'context',
-            })
-          }
-        }
-
-        pushContext(0, slice.leadingVisible)
-        if (slice.fold) {
-          const preKeep = hasChangeBefore ? Math.min(KEEP_CONTEXT, content.lines) : 0
-          const postKeep = hasChangeAfter ? Math.min(KEEP_CONTEXT, content.lines - preKeep) : 0
-          const middle = content.lines - preKeep - postKeep
-          const info = makeFoldInfo(foldId, middle, foldState, slice.fold.length)
-          rows.push({ fold: info, type: 'fold' })
-          delLine += slice.fold.length
-          addLine += slice.fold.length
-          pushContext(slice.fold.offset + slice.fold.length, slice.trailingVisible)
-        }
-      } else {
-        for (let i = 0; i < content.deletions; i++) {
-          const delIdx = content.deletionLineIndex + i
-          const text = stripNewline(file.deletionLines[delIdx] ?? '')
-          rows.push({
-            content: text,
-            height: cellWraps(text, contentWidth),
-            lineIdx: delIdx,
-            lineNumber: delLine++,
-            type: 'deletion',
-          })
-        }
-        for (let i = 0; i < content.additions; i++) {
-          const addIdx = content.additionLineIndex + i
-          const text = stripNewline(file.additionLines[addIdx] ?? '')
-          rows.push({
-            content: text,
-            height: cellWraps(text, contentWidth),
-            lineIdx: addIdx,
-            lineNumber: addLine++,
-            type: 'addition',
-          })
-        }
-      }
-    }
-  }
-  return rows
-}
-
-function rowHeight(row: SplitRowOrHeader | UnifiedRowOrHeader): number {
-  if (row.type === 'hunk-header') return 1
-  if (row.type === 'row') return row.height
-  if (row.type === 'fold') return 1
-  return row.height
-}
-
-function isChangeRow(row: SplitRowOrHeader | UnifiedRowOrHeader): boolean {
-  if (row.type === 'row') {
-    return (
-      row.left.type === 'addition' ||
-      row.left.type === 'deletion' ||
-      row.right.type === 'addition' ||
-      row.right.type === 'deletion'
-    )
-  }
-  return row.type === 'addition' || row.type === 'deletion'
-}
-
-export function firstChangeRowOffset(
-  rows: readonly (SplitRowOrHeader | UnifiedRowOrHeader)[]
-): number {
-  let offset = 0
-  for (const row of rows) {
-    if (isChangeRow(row)) return offset
-    offset += rowHeight(row)
-  }
-  return -1
-}
-
-function makeHeader(hunk: Hunk): HunkHeader {
-  const spec = `@@ -${hunk.deletionStart},${hunk.deletionCount} +${hunk.additionStart},${hunk.additionCount} @@`
-  return { context: hunk.hunkContext, spec, type: 'hunk-header' }
-}
-
-function stripNewline(s: string): string {
-  if (s.endsWith('\r\n')) return s.slice(0, -2)
-  if (s.endsWith('\n')) return s.slice(0, -1)
-  return s
-}
-
-export function gutterWidth(file: FileDiffMetadata): number {
-  let max = 1
-  for (const h of file.hunks) {
-    max = Math.max(
-      max,
-      h.deletionStart + h.deletionCount - 1,
-      h.additionStart + h.additionCount - 1
-    )
-  }
-  return Math.max(2, String(max).length)
-}

package/src/ui/components/diff-renderer/highlight.ts

@@ -1,44 +0,0 @@
-import type { ThemedToken } from 'shiki'
-
-import { ensureActiveShikiTheme, ensureShikiLang, getShikiHighlighter } from '../../shiki'
-
-export interface HighlightSpan {
-  bold?: boolean
-  fg?: string
-  italic?: boolean
-  text: string
-  underline?: boolean
-}
-
-// Shiki FontStyle: 1 = italic, 2 = bold, 4 = underline.
-export function tokenToSpan(token: ThemedToken): HighlightSpan {
-  const fs = token.fontStyle ?? 0
-  return {
-    bold: (fs & 2) !== 0 || undefined,
-    fg: token.color,
-    italic: (fs & 1) !== 0 || undefined,
-    text: token.content,
-    underline: (fs & 4) !== 0 || undefined,
-  }
-}
-
-export async function tokenizeSide(lines: string[], lang: string): Promise<ThemedToken[][]> {
-  if (lines.length === 0) return []
-  const highlighter = await getShikiHighlighter()
-  const [langOk, themeName] = await Promise.all([
-    ensureShikiLang(highlighter, lang),
-    ensureActiveShikiTheme(highlighter),
-  ])
-  if (!langOk) return []
-  try {
-    const result = highlighter.codeToTokens(lines.join(''), {
-      // eslint-disable-next-line typescript/no-explicit-any
-      lang: lang as any,
-      // eslint-disable-next-line typescript/no-explicit-any
-      theme: themeName as any,
-    })
-    return result.tokens
-  } catch {
-    return []
-  }
-}

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

@@ -1,65 +0,0 @@
-import type { ThemedToken } from 'shiki'
-
-import { type FileDiffMetadata, parsePatchFiles } from '../../../diff-parser'
-import { diffHash } from '../../../git/diff-hash'
-import { filetypeFromPath } from './filetype'
-import { tokenizeSide } from './highlight'
-
-export interface PreparedDiff {
-  hash: string
-  file: FileDiffMetadata | null
-  filetype: string | null
-  highlights: { add: ThemedToken[][]; del: ThemedToken[][] }
-}
-
-interface PrepareOptions {
-  signal?: AbortSignal
-  /** Skip Shiki for big files to keep prepare under a few tens of ms. */
-  skipHighlightThreshold?: number
-}
-
-const DEFAULT_SKIP_HIGHLIGHT = 2000
-
-function yieldToEventLoop(): Promise<void> {
-  return new Promise((resolve) => {
-    setImmediate(resolve)
-  })
-}
-
-function throwIfAborted(signal?: AbortSignal): void {
-  if (signal?.aborted) throw new DOMException('Aborted', 'AbortError')
-}
-
-// Lifts the hot path (parse → tokenize) off the synchronous render tree. The
-// parser still blocks briefly on very large diffs, but yielding between parse
-// and each tokenize side keeps other UI updates responsive.
-export async function prepareDiff(
-  diff: string,
-  path: string,
-  opts: PrepareOptions
-): Promise<PreparedDiff> {
-  const hash = diffHash(diff)
-  throwIfAborted(opts.signal)
-  const patches = parsePatchFiles(diff)
-  const file = patches[0]?.files[0] ?? null
-  const filetype = file ? (filetypeFromPath(path) ?? null) : null
-
-  const skipThreshold = opts.skipHighlightThreshold ?? DEFAULT_SKIP_HIGHLIGHT
-  const totalLines = file ? file.additionLines.length + file.deletionLines.length : 0
-  const shouldHighlight = !!file && !!filetype && totalLines <= skipThreshold
-
-  if (!shouldHighlight) {
-    return { file, filetype, hash, highlights: { add: [], del: [] } }
-  }
-
-  await yieldToEventLoop()
-  throwIfAborted(opts.signal)
-  const add = await tokenizeSide(file.additionLines, filetype)
-  throwIfAborted(opts.signal)
-  await yieldToEventLoop()
-  throwIfAborted(opts.signal)
-  const del = await tokenizeSide(file.deletionLines, filetype)
-  throwIfAborted(opts.signal)
-
-  return { file, filetype, hash, highlights: { add, del } }
-}

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

@@ -1,106 +0,0 @@
-import type { ThemedToken } from 'shiki'
-
-import { useEffect, useMemo, useState } from 'react'
-
-import type { FileDiffMetadata } from '../../../diff-parser'
-
-import { useAppStore } from '../../../state/app-store'
-import { dispatchGlobal } from '../../../state/dispatch-ref'
-import { getHighlightsTokens, getParsedFile } from '../../../state/types'
-import { prepareDiff } from './prepare-diff'
-
-export interface DiffPreparation {
-  file: FileDiffMetadata | null
-  highlights: { add: ThemedToken[][]; del: ThemedToken[][] }
-  /** True while prepare is running for this cache key + hash. */
-  preparing: boolean
-  /** Available once either cache or prepare has produced a valid hash. */
-  ready: boolean
-}
-
-const EMPTY_HIGHLIGHTS = { add: [] as ThemedToken[][], del: [] as ThemedToken[][] }
-
-// Consults the parsed + highlight caches first, then falls back to an off-thread
-// prepareDiff that dispatches results into the store. Deduplicates in-flight
-// preparation per cacheKey+hash by hashing the diff string once.
-export function useDiffPreparation(
-  cacheKey: string,
-  diff: string,
-  path: string,
-  themeId: string
-): DiffPreparation {
-  const cachedParsed = useAppStore((s) => s.gitMode.parsedFiles[cacheKey])
-  const highlightKey = `${cacheKey}|${themeId}`
-  const cachedHighlights = useAppStore((s) => s.gitMode.highlights[highlightKey])
-
-  const [preparing, setPreparing] = useState(false)
-  const [localFile, setLocalFile] = useState<FileDiffMetadata | null>(null)
-  const [localHighlights, setLocalHighlights] = useState(EMPTY_HIGHLIGHTS)
-  const [localHash, setLocalHash] = useState<string | null>(null)
-
-  const { file, highlights, ready } = useMemo(() => {
-    const parsedFile = cachedParsed ? getParsedFile(cachedParsed) : null
-    const parsedMatches = !!cachedParsed
-    const tokens = cachedHighlights ? getHighlightsTokens(cachedHighlights) : null
-    const hlMatches = !!cachedHighlights && cachedHighlights.hash === cachedParsed?.hash
-
-    if (parsedMatches && hlMatches && tokens) {
-      return { file: parsedFile, highlights: tokens, ready: true }
-    }
-    if (parsedMatches && !hlMatches) {
-      return {
-        file: parsedFile,
-        highlights: tokens ?? EMPTY_HIGHLIGHTS,
-        ready: true,
-      }
-    }
-    if (localHash && localFile) {
-      return { file: localFile, highlights: localHighlights, ready: true }
-    }
-    return { file: null, highlights: EMPTY_HIGHLIGHTS, ready: false }
-  }, [cachedParsed, cachedHighlights, localFile, localHighlights, localHash])
-
-  useEffect(() => {
-    // If caches already cover both parsed and highlights for this theme, bail.
-    const parsedOk = !!cachedParsed
-    const hlOk = !!cachedHighlights && cachedParsed && cachedHighlights.hash === cachedParsed.hash
-    if (parsedOk && hlOk) return
-
-    const controller = new AbortController()
-    setPreparing(true)
-    void prepareDiff(diff, path, { signal: controller.signal })
-      .then((result) => {
-        if (controller.signal.aborted) return
-        setLocalFile(result.file)
-        setLocalHighlights(result.highlights)
-        setLocalHash(result.hash)
-        dispatchGlobal({
-          file: result.file,
-          hash: result.hash,
-          key: cacheKey,
-          type: 'git-mode-set-parsed',
-        })
-        dispatchGlobal({
-          add: result.highlights.add,
-          del: result.highlights.del,
-          hash: result.hash,
-          key: cacheKey,
-          themeId,
-          type: 'git-mode-set-highlights',
-        })
-      })
-      .catch((err: unknown) => {
-        if (err instanceof Error && err.name === 'AbortError') return
-        // Swallow — the UI falls back to "(could not parse diff)" when file stays null.
-      })
-      .finally(() => {
-        if (!controller.signal.aborted) setPreparing(false)
-      })
-
-    return () => {
-      controller.abort()
-    }
-  }, [cacheKey, diff, path, themeId, cachedParsed, cachedHighlights])
-
-  return { file, highlights, preparing, ready }
-}

package/src/ui/components/session-name-modal.tsx

@@ -1,11 +0,0 @@
-import { uiTokens } from '../ui-tokens'
-import { InputField } from './input-field'
-import { ModalShell } from './modal-shell'
-
-export function SessionNameModal({ title, value }: { title: string; value: string }) {
-  return (
-    <ModalShell title={title} keybindsModeId="modal.session-name" width={uiTokens.modalWidth.md}>
-      <InputField active value={value} />
-    </ModalShell>
-  )
-}

package/src/ui/components/snippet-editor-modal.tsx

@@ -1,40 +0,0 @@
-import { useTokens } from '../theme'
-import { uiTokens } from '../ui-tokens'
-import { InputField } from './input-field'
-import { ModalShell } from './modal-shell'
-
-interface SnippetEditorModalProps {
-  activeField: 'name' | 'content'
-  snippetName: string
-  snippetContent: string
-  isEditing: boolean
-}
-
-export function SnippetEditorModal({
-  activeField,
-  isEditing,
-  snippetContent,
-  snippetName,
-}: SnippetEditorModalProps) {
-  const t = useTokens()
-  const nameActive = activeField === 'name'
-  const contentActive = activeField === 'content'
-
-  return (
-    <ModalShell
-      title={isEditing ? 'Edit snippet' : 'Create snippet'}
-      keybindsModeId="modal.snippet-editor"
-      width={uiTokens.modalWidth.xl}
-    >
-      <box flexDirection="column">
-        <text fg={nameActive ? t.palette.ink : t.muted}>Name</text>
-        <InputField active={nameActive} value={snippetName} />
-      </box>
-
-      <box flexDirection="column">
-        <text fg={contentActive ? t.palette.ink : t.muted}>Content</text>
-        <InputField active={contentActive} value={snippetContent} />
-      </box>
-    </ModalShell>
-  )
-}