@brimveyn/aimux 1.8.0 → 1.9.1

package/src/ui/components/ai-usage-popover.tsx

@@ -1,152 +0,0 @@
-import type { AIUsageTool } from '@brimveyn/aimux-config'
-
-import { useKeyboard } from '@opentui/react'
-import { useEffect, useState } from 'react'
-
-import type { UsageSnapshot } from '../../services/ai-usage/types'
-
-import { useAIUsageStore } from '../../state/ai-usage-store'
-import { useAppStore } from '../../state/app-store'
-import {
-  type AIUsagePopoverState,
-  closeAIUsagePopover,
-  subscribeAIUsagePopover,
-} from '../ai-usage/controller'
-import { useTokens } from '../theme'
-
-const TOOL_TITLE: Record<AIUsageTool, string> = {
-  claude: 'Claude Code',
-  codex: 'Codex',
-}
-
-const POPOVER_WIDTH = 38
-
-function fmt(n: number): string {
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(2)}M`
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`
-  return String(n)
-}
-
-function buildLines(snap: UsageSnapshot): string[] {
-  if (snap.error) {
-    return [`error: ${snap.error.slice(0, 30)}`]
-  }
-  const lines: string[] = []
-  if (snap.percent !== null) {
-    lines.push(`usage   ${snap.percent.toFixed(1)}%`)
-  }
-  lines.push(`tokens  in ${fmt(snap.tokens.input)} / out ${fmt(snap.tokens.output)}`)
-  if (snap.tokens.cache > 0) {
-    lines.push(`cache   ${fmt(snap.tokens.cache)}`)
-  }
-  lines.push(`total   ${fmt(snap.tokens.total)}`)
-  if (snap.costUSD !== null) {
-    lines.push(`cost    $${snap.costUSD.toFixed(2)}`)
-  }
-  if (snap.burnRatePerHour !== null) {
-    lines.push(`burn    ${fmt(Math.round(snap.burnRatePerHour))}/h`)
-  }
-  if (snap.timeRemaining) {
-    lines.push(`resets  ${snap.timeRemaining}`)
-  } else if (snap.resetAt) {
-    lines.push(`resets  ${new Date(snap.resetAt).toLocaleTimeString()}`)
-  }
-  return lines
-}
-
-export function AIUsagePopover() {
-  const [popover, setPopover] = useState<AIUsagePopoverState | null>(null)
-  const t = useTokens()
-  const enabled = useAIUsageStore((s) => s.enabled)
-  const snapshots = useAIUsageStore((s) => s.snapshots)
-  const terminalCols = useAppStore((s) => s.layout.terminalCols)
-  const terminalRows = useAppStore((s) => s.layout.terminalRows)
-
-  useEffect(() => subscribeAIUsagePopover(setPopover), [])
-
-  useKeyboard((key) => {
-    if (!popover) return
-    if (key.name === 'escape') {
-      key.preventDefault()
-      closeAIUsagePopover()
-    }
-  })
-
-  if (!enabled || !popover) return null
-
-  const tools: AIUsageTool[] = ['claude', 'codex']
-  const sections = tools
-    .map((tool) => ({ snap: snapshots[tool], tool }))
-    .filter((s) => s.snap !== undefined)
-
-  let bodyLines = 0
-  if (sections.length === 0) {
-    bodyLines = 1
-  } else {
-    for (const s of sections) {
-      if (!s.snap) continue
-      bodyLines += buildLines(s.snap).length + 2
-    }
-  }
-  const height = Math.min(terminalRows - 2, bodyLines + 2)
-  const width = Math.min(terminalCols - 2, POPOVER_WIDTH)
-
-  const left = Math.max(0, Math.min(popover.anchorX - width + 2, terminalCols - width))
-  const top = Math.max(0, popover.anchorY - height)
-
-  return (
-    <box position="absolute" top={0} left={0} width="100%" height="100%">
-      <box
-        position="absolute"
-        top={0}
-        left={0}
-        width="100%"
-        height="100%"
-        onMouseDown={(e) => {
-          e.preventDefault()
-          e.stopPropagation()
-          closeAIUsagePopover()
-        }}
-      />
-      <box
-        position="absolute"
-        top={top}
-        left={left}
-        width={width}
-        flexDirection="column"
-        border
-        borderColor={t.palette.primary}
-        backgroundColor={t.elevated}
-        onMouseDown={(e) => {
-          e.stopPropagation()
-        }}
-      >
-        {sections.length === 0 ? (
-          <box paddingLeft={1} paddingRight={1}>
-            <text fg={t.muted} selectable={false}>
-              no data yet — collecting…
-            </text>
-          </box>
-        ) : (
-          sections.map(({ snap, tool }, idx) => {
-            if (!snap) return null
-            const lines = buildLines(snap)
-            return (
-              <box key={tool} flexDirection="column" paddingLeft={1} paddingRight={1}>
-                {idx > 0 ? <text fg={t.muted}> </text> : null}
-                <text fg={t.accent} selectable={false}>
-                  {TOOL_TITLE[tool]}
-                </text>
-                {lines.map((line, i) => (
-                  <text key={`${tool}-${i}`} fg={t.palette.ink} selectable={false}>
-                    {line}
-                  </text>
-                ))}
-              </box>
-            )
-          })
-        )}
-      </box>
-    </box>
-  )
-}

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

@@ -1,96 +0,0 @@
-import type { DirectoryResult } from '../../state/types'
-
-import { abbreviatePath } from '../path-format'
-import { getCurrentTokens, useTokens } from '../theme'
-import { uiTokens } from '../ui-tokens'
-import { InputField } from './input-field'
-import { ListItem } from './list-item'
-import { ModalShell } from './modal-shell'
-
-const VISIBLE_ROWS = 8
-
-function getDirectoryResultIcon(result: DirectoryResult): string {
-  if (result.type === 'worktree') return '\u{e728}'
-  if (result.type === 'workspace') return '\u{f07c}'
-  return '\u{e702}'
-}
-
-function getDirectoryResultColor(result: DirectoryResult): string {
-  const t = getCurrentTokens()
-  if (result.type === 'worktree') return t.palette.warning
-  if (result.type === 'workspace') return t.accent
-  return t.palette.primary
-}
-
-interface CreateSessionModalProps {
-  activeField: 'directory' | 'name'
-  directoryQuery: string
-  sessionName: string
-  results: DirectoryResult[]
-  selectedIndex: number
-  pendingProjectPath: string | null
-}
-
-export function CreateSessionModal({
-  activeField,
-  directoryQuery,
-  pendingProjectPath,
-  results,
-  selectedIndex,
-  sessionName,
-}: CreateSessionModalProps) {
-  const t = useTokens()
-  const dirActive = activeField === 'directory'
-  const nameActive = activeField === 'name'
-
-  const scrollOffset = Math.max(0, selectedIndex - VISIBLE_ROWS + 1)
-  const visibleResults = results.slice(scrollOffset, scrollOffset + VISIBLE_ROWS)
-
-  return (
-    <ModalShell
-      title="Create workspace"
-      keybindsModeId="modal.create-session"
-      width={uiTokens.modalWidth.xl}
-    >
-      <box flexDirection="column">
-        <text fg={dirActive ? t.palette.ink : t.muted}>Search projects</text>
-        <InputField
-          active={dirActive}
-          placeholder="Type a project name..."
-          value={
-            pendingProjectPath && !dirActive ? abbreviatePath(pendingProjectPath) : directoryQuery
-          }
-        />
-      </box>
-
-      <box flexDirection="column" height={VISIBLE_ROWS}>
-        {results.length === 0 ? (
-          <text fg={t.muted}>
-            {directoryQuery.length > 0 ? 'No matches' : 'Type a project name to search...'}
-          </text>
-        ) : (
-          visibleResults.map((result, index) => {
-            const active = dirActive && scrollOffset + index === selectedIndex
-            return (
-              <ListItem
-                key={result.path}
-                active={active}
-                leading={
-                  <text fg={getDirectoryResultColor(result)}>{getDirectoryResultIcon(result)}</text>
-                }
-                title={
-                  <text fg={active ? t.palette.ink : t.muted}>{abbreviatePath(result.path)}</text>
-                }
-              />
-            )
-          })
-        )}
-      </box>
-
-      <box flexDirection="column">
-        <text fg={nameActive ? t.palette.ink : t.muted}>Workspace name</text>
-        <InputField active={nameActive} value={sessionName} />
-      </box>
-    </ModalShell>
-  )
-}

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 } }
-}