anymd 0.0.7 → 0.0.9

package/tui.tsx

@@ -1,1105 +0,0 @@
-// oxlint-disable react/no-unknown-property
-/* eslint-disable react/no-unknown-property, react-hooks/rules-of-hooks, @typescript-eslint/promise-function-async */
-/** biome-ignore-all lint/nursery/noUnknownAttribute: OpenTUI uses custom JSX intrinsics */
-import { createCliRenderer } from '@opentui/core'
-import { createRoot, useKeyboard, useTerminalDimensions } from '@opentui/react'
-import { useCallback, useEffect, useReducer, useRef, useState } from 'react'
-
-import type { AllStepsData, CommandKey, DatasetResult, OcrProgress, StepData } from '~/tui-data'
-
-import { bootstrapPython } from '~/bootstrap'
-import { getPaths } from '~/paths'
-import { runPreflight } from '~/preflight'
-import {
-  appendErrorLog,
-  appendPipelineLog,
-  buildDataset,
-  clearErrorLog,
-  clearPipelineLog,
-  fetchStepData,
-  getOcrStats,
-  readLogTail,
-  runClassify,
-  runEnhanceOcr,
-  spawnCommand,
-  writeNativeFileList
-} from '~/tui-data'
-
-const stripAnsi = (s: string): string => s.replaceAll(new RegExp(`${String.fromCodePoint(0x1b)}\\[[0-9;]*m`, 'gu'), '')
-
-const DIM = '#888888'
-const SIDEBAR_WIDTH = 38
-
-const setTerminalTitle = (title: string): void => {
-  process.stdout.write(`\u001B]0;${title}\u0007`)
-}
-
-interface StepConfig {
-  command: CommandKey
-  name: string
-  stepNum: number
-  unit: string
-}
-
-const STEPS: StepConfig[] = [
-  { command: 'classify', name: 'Classify PDFs', stepNum: 1, unit: 'PDFs' },
-  { command: 'pipeline', name: 'Convert to Markdown', stepNum: 2, unit: 'files' },
-  { command: 'ocr', name: 'OCR Scanned PDFs', stepNum: 3, unit: 'files' },
-  { command: 'enhance', name: 'Enhance Markdown', stepNum: 4, unit: 'files' },
-  { command: 'dataset', name: 'Build Dataset', stepNum: 5, unit: 'entries' }
-]
-
-const STEP_ORDER: CommandKey[] = ['classify', 'pipeline', 'ocr', 'enhance', 'dataset']
-
-type Action =
-  | { active: boolean; type: 'SET_BACKGROUND_OCR' }
-  | { code: number; type: 'COMMAND_DONE' }
-  | { command: CommandKey; count: number; type: 'RECORD_FAILURES' }
-  | { command: CommandKey; seconds: number; type: 'RECORD_DURATION' }
-  | { data: AllStepsData; type: 'SET_STEPS' }
-  | { errors: string[]; type: 'SET_PREFLIGHT'; warnings: string[] }
-  | { label: string; stepCommand: CommandKey; type: 'START_COMMAND' }
-  | { line: string; type: 'APPEND_OUTPUT' }
-  | { lines: string[]; type: 'SET_LOG' }
-  | { result: DatasetResult; type: 'SET_DATASET_RESULT' }
-  | { status: string; type: 'SET_RUNNING_STATUS' }
-  | { type: 'CLEAR_FAILURE' }
-  | { type: 'SET_ALL_DONE' }
-  | { type: 'TOGGLE_LOG' }
-
-interface AppState {
-  allDone: boolean
-  backgroundOcr: boolean
-  datasetResult: DatasetResult | null
-  failed: boolean
-  logLines: string[]
-  pipelineStartedAt: number
-  preflightErrors: string[]
-  preflightWarnings: string[]
-  runningCommand: CommandKey | null
-  runningLines: string[]
-  runningStatus: string
-  showLog: boolean
-  stepDurations: Partial<Record<CommandKey, number>>
-  stepFailures: Partial<Record<CommandKey, number>>
-  stepsData: AllStepsData | null
-  stepStartedAt: number
-}
-
-const MAX_OUTPUT_LINES = 15
-// oxlint-disable-next-line promise/prefer-await-to-then
-const noop = (): Promise<void> => Promise.resolve() // eslint-disable-line @typescript-eslint/promise-function-async
-
-const initialState: AppState = {
-  allDone: false,
-  backgroundOcr: false,
-  datasetResult: null,
-  failed: false,
-  logLines: [],
-  pipelineStartedAt: Date.now(),
-  preflightErrors: [],
-  preflightWarnings: [],
-  runningCommand: null,
-  runningLines: [],
-  runningStatus: '',
-  showLog: false,
-  stepDurations: {},
-  stepFailures: {},
-  stepsData: null,
-  stepStartedAt: 0
-}
-
-const reducer = (state: AppState, action: Action): AppState => {
-  switch (action.type) {
-    case 'APPEND_OUTPUT':
-      return { ...state, runningLines: [...state.runningLines.slice(-MAX_OUTPUT_LINES), stripAnsi(action.line)] }
-    case 'CLEAR_FAILURE':
-      return { ...state, backgroundOcr: false, failed: false, runningCommand: null }
-    case 'COMMAND_DONE': {
-      const durations =
-        action.code === 0 && state.runningCommand && state.stepStartedAt > 0
-          ? { ...state.stepDurations, [state.runningCommand]: Math.floor((Date.now() - state.stepStartedAt) / 1000) }
-          : state.stepDurations
-      return {
-        ...state,
-        failed: action.code !== 0,
-        runningCommand: action.code === 0 ? null : state.runningCommand,
-        stepDurations: durations
-      }
-    }
-    case 'RECORD_DURATION':
-      return { ...state, stepDurations: { ...state.stepDurations, [action.command]: action.seconds } }
-    case 'RECORD_FAILURES':
-      if (action.count <= 0) return state
-      return { ...state, stepFailures: { ...state.stepFailures, [action.command]: action.count } }
-    case 'SET_ALL_DONE':
-      return { ...state, allDone: true, backgroundOcr: false, runningCommand: null }
-    case 'SET_BACKGROUND_OCR':
-      return { ...state, backgroundOcr: action.active }
-    case 'SET_DATASET_RESULT':
-      return { ...state, datasetResult: action.result }
-    case 'SET_LOG':
-      return { ...state, logLines: action.lines.map(stripAnsi) }
-    case 'SET_PREFLIGHT':
-      return { ...state, preflightErrors: action.errors, preflightWarnings: action.warnings }
-    case 'SET_RUNNING_STATUS':
-      return { ...state, runningStatus: action.status }
-    case 'SET_STEPS':
-      return { ...state, stepsData: action.data }
-    case 'START_COMMAND':
-      return {
-        ...state,
-        failed: false,
-        runningCommand: action.stepCommand,
-        runningLines: [],
-        runningStatus: '',
-        stepStartedAt: Date.now()
-      }
-    case 'TOGGLE_LOG':
-      return { ...state, showLog: !state.showLog }
-    default:
-      return state
-  }
-}
-
-const isStepDone = (step: CommandKey, data: AllStepsData): boolean => {
-  const s: StepData = data[step]
-  if (s.requires) return false
-  return s.done >= s.total
-}
-
-const findFirstIncomplete = (data: AllStepsData): CommandKey | null => {
-  for (const key of STEP_ORDER) if (!isStepDone(key, data)) return key
-
-  return null
-}
-
-const formatDuration = (seconds: number): string => {
-  const h = Math.floor(seconds / 3600)
-  const m = Math.floor((seconds % 3600) / 60)
-  const s = Math.floor(seconds % 60)
-  if (h > 0) return `${h}h${m.toString().padStart(2, '0')}m`
-  if (m > 0) return `${m}m${s.toString().padStart(2, '0')}s`
-  return `${s}s`
-}
-
-const SPINNER_FRAMES = ['\u28CB', '\u28D9', '\u28F9', '\u28F8', '\u28FC', '\u28F4', '\u28E6', '\u28E7', '\u28C7', '\u28CF']
-
-const SpinnerDots = ({ fg }: { fg?: string }) => {
-  const [frame, setFrame] = useState(0)
-
-  useEffect(() => {
-    const interval = setInterval(() => {
-      setFrame(f => (f + 1) % SPINNER_FRAMES.length)
-    }, 80)
-    return () => clearInterval(interval)
-  }, [])
-
-  return <text fg={fg ?? 'yellow'}>{SPINNER_FRAMES[frame]} </text>
-}
-
-const PROGRESS_FULL = '█'
-const PROGRESS_EMPTY = '░'
-
-const ProgressBarSimple = ({ value, width = 12 }: { value: number; width?: number }) => {
-  const filled = Math.round((value / 100) * width)
-  const empty = width - filled
-  return (
-    <text>
-      <span fg='green'>{PROGRESS_FULL.repeat(filled)}</span>
-      <span fg='#444444'>{PROGRESS_EMPTY.repeat(empty)}</span>
-    </text>
-  )
-}
-
-const ElapsedTimer = ({ startedAt }: { startedAt: number }) => {
-  const [secs, setSecs] = useState(0)
-
-  useEffect(() => {
-    if (startedAt <= 0) return
-    const tick = (): void => {
-      setSecs(Math.max(0, Math.floor((Date.now() - startedAt) / 1000)))
-    }
-    tick()
-    const timer = setInterval(tick, 1000)
-    return () => clearInterval(timer)
-  }, [startedAt])
-
-  if (startedAt <= 0) return null
-  return <text fg={DIM}> {formatDuration(secs)}</text>
-}
-
-const RecentFiles = ({ files }: { files: { duration: number; name: string; pages: number; per_page: number }[] }) => {
-  const display = files.slice(-3)
-  return (
-    <box flexDirection='column'>
-      <text fg={DIM}>
-        <b>── recent ──</b>
-      </text>
-      {display.map((f, i) => (
-        // eslint-disable-next-line react/no-array-index-key
-        <text key={i}>
-          <span fg='green'>✓</span>
-          <span fg='cyan'> {f.name.slice(0, 18)}</span>
-          <span> {f.pages.toString().padStart(2)}p</span>
-          <span fg='yellow'> {formatDuration(f.duration)}</span>
-        </text>
-      ))}
-    </box>
-  )
-}
-
-const OcrLiveInfo = ({ progress }: { progress: OcrProgress }) => {
-  const [elapsed, setElapsed] = useState(0)
-
-  useEffect(() => {
-    const started = progress.current_file_started
-    if (progress.current_file === '-' || !started || started <= 0) {
-      setElapsed(0)
-      return
-    }
-    const update = (): void => {
-      setElapsed(Date.now() / 1000 - started)
-    }
-    update()
-    const timer = setInterval(update, 1000)
-    return () => clearInterval(timer)
-  }, [progress.current_file, progress.current_file_started])
-
-  return (
-    <box flexDirection='column' paddingLeft={2}>
-      {progress.current_file === '-' ? null : (
-        <text>
-          <span fg={DIM}>Now: </span>
-          <b fg='cyan'>{progress.current_file.slice(0, 20)}</b>
-        </text>
-      )}
-      {progress.current_file === '-' ? null : (
-        <text>
-          <span fg={DIM}>p</span>
-          <span>{progress.current_page}</span>
-          {progress.current_pages_total ? <span fg={DIM}>/{progress.current_pages_total}</span> : null}
-          <span fg={DIM}> </span>
-          <span fg='yellow'>{formatDuration(elapsed)}</span>
-        </text>
-      )}
-      <text>
-        <span fg={DIM}>ETA </span>
-        <span fg='yellow'>{progress.eta}</span>
-        <span fg={DIM}> avg </span>
-        <span>{progress.avg_per_file}</span>
-      </text>
-      <text>
-        <span fg={DIM}>err </span>
-        <span fg={progress.errors > 0 ? 'red' : 'green'}>{progress.errors}</span>
-      </text>
-      {progress.recent_files?.length ? <RecentFiles files={progress.recent_files} /> : null}
-    </box>
-  )
-}
-
-const getStepIcon = (isDone: boolean, isFailed: boolean): string => {
-  if (isFailed) return '✗'
-  if (isDone) return '✓'
-  return '·'
-}
-
-const getStepColor = (isRunning: boolean, isDone: boolean, isFailed: boolean): string => {
-  if (isFailed) return 'red'
-  if (isRunning) return 'yellow'
-  if (isDone) return 'green'
-  return 'gray'
-}
-
-const StepIcon = ({
-  color,
-  isDone,
-  isFailed,
-  isRunning
-}: {
-  color: string
-  isDone: boolean
-  isFailed: boolean
-  isRunning: boolean
-}) => {
-  if (isRunning) return <SpinnerDots fg='yellow' />
-  return (
-    <text fg={color}>
-      <b>{getStepIcon(isDone, isFailed)} </b>
-    </text>
-  )
-}
-
-const SidebarStep = ({
-  completedDuration,
-  failedCount,
-  isFailed,
-  isRunning,
-  ocrProgress,
-  runningStatus,
-  step,
-  stepData,
-  stepStartedAt
-}: {
-  completedDuration?: number
-  failedCount?: number
-  isFailed: boolean
-  isRunning: boolean
-  ocrProgress?: null | OcrProgress
-  runningStatus: string
-  step: StepConfig
-  stepData: StepData | undefined
-  stepStartedAt: number
-  // eslint-disable-next-line complexity, max-statements
-}) => {
-  const done = stepData?.done ?? 0
-  const total = stepData?.total ?? 0
-  const isDone = total > 0 && done >= total
-  const pct = total > 0 ? Math.round((done / total) * 100) : 0
-  const color = getStepColor(isRunning, isDone, isFailed)
-  const isActive = isRunning || isDone || isFailed
-  const showRequires = Boolean(stepData?.requires) && !isDone && !isRunning
-  const showOcr = isRunning && step.command === 'ocr'
-
-  return (
-    <box flexDirection='column'>
-      <box>
-        <box width={2}>
-          <StepIcon color={color} isDone={isDone} isFailed={false} isRunning={isRunning} />
-        </box>
-        <text fg={isActive ? color : DIM}>{step.name}</text>
-        {isRunning ? <ElapsedTimer startedAt={stepStartedAt} /> : null}
-        {isDone && !isRunning && completedDuration !== undefined ? (
-          <text fg={DIM}> {formatDuration(completedDuration)}</text>
-        ) : null}
-      </box>
-      <box paddingLeft={2}>
-        <ProgressBarSimple value={pct} />
-        <text>
-          <span fg='green'> {done}</span>
-          <span fg={DIM}>/{total > 0 ? total : '?'}</span>
-          {failedCount && failedCount > 0 ? <span fg='red'> {failedCount}✗</span> : null}
-        </text>
-      </box>
-      {stepData?.details?.length ? (
-        <box flexDirection='column' paddingLeft={2}>
-          {stepData.details.map((d, i) => (
-            // eslint-disable-next-line react/no-array-index-key
-            <text fg={DIM} key={i}>
-              {d}
-            </text>
-          ))}
-        </box>
-      ) : null}
-      {isRunning && runningStatus !== '' ? (
-        <box paddingLeft={2}>
-          <text fg='cyan'>{runningStatus}</text>
-        </box>
-      ) : null}
-      {showRequires ? (
-        <box paddingLeft={2}>
-          <text fg='yellow'>⚠ {stepData?.requires}</text>
-        </box>
-      ) : null}
-      {showOcr && ocrProgress ? <OcrLiveInfo progress={ocrProgress} /> : null}
-    </box>
-  )
-}
-
-const ERROR_PATTERN = /\b(?:ERROR|Error:|Failed:|failed|FAILED|\u2716|exception|traceback)/iu
-
-const PreflightBanner = ({ errors, warnings }: { errors: string[]; warnings: string[] }) => {
-  if (errors.length === 0 && warnings.length === 0) return null
-  return (
-    <box
-      border
-      borderColor={errors.length > 0 ? 'red' : 'yellow'}
-      borderStyle='rounded'
-      flexDirection='column'
-      marginTop={1}
-      paddingLeft={1}
-      paddingRight={1}>
-      {errors.length > 0 ? (
-        <>
-          <text fg='red'>
-            <b>✗ Missing required tools:</b>
-          </text>
-          {errors.map((err, i) => (
-            // eslint-disable-next-line react/no-array-index-key
-            <text fg='red' key={`e${i}`}>
-              {'  '}• {err}
-            </text>
-          ))}
-        </>
-      ) : null}
-      {warnings.length > 0 ? (
-        <>
-          <text fg='yellow'>
-            <b>⚠ Warnings:</b>
-          </text>
-          {warnings.map((warn, i) => (
-            // eslint-disable-next-line react/no-array-index-key
-            <text fg='yellow' key={`w${i}`}>
-              {'  '}• {warn}
-            </text>
-          ))}
-        </>
-      ) : null}
-      {errors.length > 0 ? <text fg={DIM}>Fix the errors above and restart.</text> : null}
-    </box>
-  )
-}
-
-// eslint-disable-next-line max-statements
-const TitleBarTop = ({
-  allDone,
-  backgroundOcr,
-  failed,
-  pipelineStartedAt,
-  runningCommand,
-  stepsData
-}: {
-  allDone: boolean
-  backgroundOcr: boolean
-  failed: boolean
-  pipelineStartedAt: number
-  runningCommand: CommandKey | null
-  stepsData: AllStepsData | null
-}) => {
-  const [elapsed, setElapsed] = useState(0)
-
-  useEffect(() => {
-    if (pipelineStartedAt <= 0) return
-    const tick = (): void => {
-      setElapsed(Math.max(0, Math.floor((Date.now() - pipelineStartedAt) / 1000)))
-    }
-    tick()
-    const timer = setInterval(tick, 1000)
-    return () => clearInterval(timer)
-  }, [pipelineStartedAt])
-
-  let statusText = ''
-  if (allDone) statusText = '✓ Complete'
-  else if (failed) statusText = '✗ Failed'
-  else if (runningCommand && stepsData) {
-    let currentIdx = 0
-    let currentName = ''
-    for (const s of STEPS)
-      if (s.command === runningCommand) {
-        currentIdx = s.stepNum
-        currentName = s.name
-        break
-      }
-    if (currentIdx > 0) {
-      const parallelLabel = backgroundOcr && runningCommand === 'pipeline' ? '2+3/5 Convert+OCR' : null
-      statusText = parallelLabel ?? `${currentIdx}/5 ${currentName}`
-    }
-  }
-
-  const statusColor = allDone ? 'green' : failed ? 'red' : 'cyan'
-
-  return (
-    <box justifyContent='space-between' paddingLeft={1} paddingRight={1}>
-      <text fg='#e0a040'>
-        <b>anymd</b>
-      </text>
-      <box gap={2}>
-        {statusText === '' ? null : (
-          <text fg={statusColor}>
-            <b>{statusText}</b>
-          </text>
-        )}
-        {pipelineStartedAt > 0 ? <text fg={DIM}>{formatDuration(elapsed)}</text> : null}
-      </box>
-    </box>
-  )
-}
-
-const formatChars = (chars: number): string => {
-  if (chars >= 1_000_000) return `${(chars / 1_000_000).toFixed(1)}M`
-  if (chars >= 1000) return `${(chars / 1000).toFixed(1)}K`
-  return String(chars)
-}
-
-const SidebarSummary = ({
-  allDone,
-  datasetResult,
-  stepDurations
-}: {
-  allDone: boolean
-  datasetResult: DatasetResult | null
-  stepDurations: Partial<Record<CommandKey, number>>
-}) => {
-  if (!allDone) return null
-  return (
-    <box flexDirection='column' paddingLeft={1} paddingTop={1}>
-      <text fg='green'>
-        <b>✓ All 5 steps complete</b>
-      </text>
-      {datasetResult ? (
-        <box flexDirection='column' paddingLeft={1}>
-          <text>
-            <span fg={DIM}>entries </span>
-            <b fg='green'>{datasetResult.entries.toLocaleString()}</b>
-          </text>
-          <text>
-            <span fg={DIM}>chars </span>
-            <b>{formatChars(datasetResult.totalChars)}</b>
-          </text>
-          {datasetResult.skipped > 0 ? (
-            <text>
-              <span fg={DIM}>skipped </span>
-              <span fg='yellow'>{datasetResult.skipped}</span>
-            </text>
-          ) : null}
-          {datasetResult.duplicates > 0 ? (
-            <text>
-              <span fg={DIM}>deduped </span>
-              <span fg='yellow'>{datasetResult.duplicates}</span>
-            </text>
-          ) : null}
-        </box>
-      ) : null}
-      <box flexDirection='column' paddingLeft={1}>
-        {STEPS.map(step => {
-          const dur = stepDurations[step.command]
-          if (dur === undefined) return null
-          return (
-            <text key={step.command}>
-              <span fg={DIM}>{step.name.slice(0, 14).padEnd(14)} </span>
-              <span fg='cyan'>{formatDuration(dur)}</span>
-            </text>
-          )
-        })}
-      </box>
-    </box>
-  )
-}
-
-const HelpDialog = ({ height, width }: { height: number; width: number }) => {
-  const boxW = 40
-  const boxH = 12
-  const left = Math.max(0, Math.floor((width - boxW) / 2))
-  const top = Math.max(0, Math.floor((height - boxH) / 2))
-
-  return (
-    <box
-      border
-      borderColor='#e0a040'
-      borderStyle='rounded'
-      flexDirection='column'
-      height={boxH}
-      marginLeft={left}
-      marginTop={top}
-      paddingLeft={2}
-      paddingRight={2}
-      width={boxW}>
-      <text fg='#e0a040'>
-        <b>Keybinds</b>
-      </text>
-      <text> </text>
-      <text>
-        <b fg='cyan'>Q</b>
-        <span fg={DIM}>{'  '}Quit</span>
-      </text>
-      <text>
-        <b fg='cyan'>L</b>
-        <span fg={DIM}>{'  '}Toggle log / output view</span>
-      </text>
-      <text>
-        <b fg='cyan'>R</b>
-        <span fg={DIM}>{'  '}Retry failed step</span>
-      </text>
-      <text>
-        <b fg='cyan'>S</b>
-        <span fg={DIM}>{'  '}Skip failed step</span>
-      </text>
-      <text>
-        <b fg='cyan'>?</b>
-        <span fg={DIM}>{'  '}Toggle this help</span>
-      </text>
-      <text> </text>
-      <text fg={DIM}>Press ? or Esc to close</text>
-    </box>
-  )
-}
-
-const computeTerminalTitle = (s: AppState): string => {
-  if (s.allDone) return 'Doc Pipeline \u2014 \u2713 Complete'
-  if (s.failed) return 'Doc Pipeline \u2014 \u2717 Failed'
-  if (!s.runningCommand) return 'Doc Pipeline'
-  const step = STEPS.find(st => st.command === s.runningCommand)
-  if (!step) return 'Doc Pipeline'
-  const sd = s.stepsData?.[s.runningCommand]
-  const pct = sd && sd.total > 0 ? Math.round((sd.done / sd.total) * 100) : 0
-  const label =
-    s.backgroundOcr && s.runningCommand === 'pipeline'
-      ? `Steps 2+3/5 \u2014 Convert + OCR ${pct}%`
-      : `Step ${step.stepNum}/5 \u2014 ${step.name} ${pct}%`
-  return `Doc Pipeline \u2014 ${label}`
-}
-
-// eslint-disable-next-line max-statements
-const readStream = async (stream: ReadableStream<Uint8Array>, onLine: (line: string) => void): Promise<void> => {
-  const reader = stream.getReader()
-  const decoder = new TextDecoder()
-  let buffer = ''
-  try {
-    for (;;) {
-      // biome-ignore lint/performance/noAwaitInLoops: streaming reads
-      const { done, value } = await reader.read() // eslint-disable-line no-await-in-loop
-      if (done) break
-      buffer += decoder.decode(value, { stream: true })
-      const parts = buffer.split('\n')
-      buffer = parts.pop() ?? ''
-      for (const part of parts) if (part.trim() !== '') onLine(part)
-    }
-    if (buffer.trim() !== '') onLine(buffer)
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-// eslint-disable-next-line max-statements, complexity
-const App = () => {
-  const [state, dispatch] = useReducer(reducer, initialState)
-  const procRef = useRef<null | ReturnType<typeof Bun.spawn>>(null)
-  const ocrProcRef = useRef<null | ReturnType<typeof Bun.spawn>>(null)
-  const busyRef = useRef(false)
-  const errorLogClearedRef = useRef(false)
-  const [showHelp, setShowHelp] = useState(false)
-  const { height, width } = useTerminalDimensions()
-
-  useEffect(() => {
-    setTerminalTitle(computeTerminalTitle(state))
-  }, [state.allDone, state.failed, state.runningCommand, state.backgroundOcr, state.stepsData])
-
-  const refreshSteps = useCallback(async (): Promise<AllStepsData> => {
-    const data = await fetchStepData()
-    dispatch({ data, type: 'SET_STEPS' })
-    return data
-  }, [])
-
-  const refreshLog = useCallback(async () => {
-    const lines = await readLogTail(200)
-    dispatch({ lines, type: 'SET_LOG' })
-  }, [])
-
-  const executeCommand = useCallback(
-    // eslint-disable-next-line complexity, max-statements
-    async (key: CommandKey): Promise<number> => {
-      if (busyRef.current) return -1
-      busyRef.current = true
-
-      try {
-        if (key === 'classify') {
-          dispatch({ label: 'Classifying PDFs...', stepCommand: key, type: 'START_COMMAND' })
-          await runClassify(prog => {
-            const statusLine = `${prog.done}/${prog.total} \u2014 native=${prog.native} scanned=${prog.scanned} mixed=${prog.mixed}`
-            dispatch({ status: statusLine, type: 'SET_RUNNING_STATUS' })
-            dispatch({ line: `${prog.file} \u2192 ${prog.category}`, type: 'APPEND_OUTPUT' })
-            if (prog.category === 'error') appendErrorLog('classify', `Failed: ${prog.file}`)
-          })
-          dispatch({ code: 0, type: 'COMMAND_DONE' })
-          return 0
-        }
-
-        if (key === 'dataset') {
-          dispatch({ label: 'Building dataset...', stepCommand: key, type: 'START_COMMAND' })
-          const result: DatasetResult = await buildDataset({
-            onFileResult: prog => {
-              const icon = prog.status === 'added' ? '\u2713' : prog.status === 'duplicate' ? '\u2261' : '\u2192'
-              const charStr = prog.chars >= 1000 ? `${(prog.chars / 1000).toFixed(1)}K` : `${prog.chars}`
-              dispatch({ line: `${icon} ${prog.file} \u2192 ${prog.status} (${charStr} chars)`, type: 'APPEND_OUTPUT' })
-            },
-            onReadProgress: (readDone, total) => {
-              dispatch({ status: `Reading ${readDone}/${total} files...`, type: 'SET_RUNNING_STATUS' })
-            }
-          })
-          dispatch({ result, type: 'SET_DATASET_RESULT' })
-          const dupStr = result.duplicates > 0 ? `, ${result.duplicates} duplicates removed` : ''
-          dispatch({
-            line: `Dataset: ${result.entries} entries, ${result.skipped} skipped${dupStr}, ${result.totalChars.toLocaleString()} chars`,
-            type: 'APPEND_OUTPUT'
-          })
-          dispatch({ code: 0, type: 'COMMAND_DONE' })
-          return 0
-        }
-
-        if (key === 'ocr') {
-          const stats = await getOcrStats()
-          if (stats.total === 0) {
-            dispatch({ label: 'OCR', stepCommand: key, type: 'START_COMMAND' })
-            dispatch({ line: 'No classification found. Classify PDFs first.', type: 'APPEND_OUTPUT' })
-            dispatch({ code: 1, type: 'COMMAND_DONE' })
-            return 1
-          }
-          if (stats.remaining === 0) {
-            dispatch({ label: 'OCR', stepCommand: key, type: 'START_COMMAND' })
-            dispatch({ line: "All files already OCR'd.", type: 'APPEND_OUTPUT' })
-            dispatch({ code: 0, type: 'COMMAND_DONE' })
-            return 0
-          }
-        }
-
-        if (key === 'enhance') {
-          dispatch({ label: 'Enhancing OCR markdown...', stepCommand: key, type: 'START_COMMAND' })
-          const result = await runEnhanceOcr(prog => {
-            const statusLine = `${prog.done}/${prog.total} files enhanced`
-            dispatch({ status: statusLine, type: 'SET_RUNNING_STATUS' })
-            const icon = prog.status === 'enhanced' ? '\u2713' : prog.status === 'skipped' ? '\u2192' : '\u2717'
-            dispatch({ line: `${icon} ${prog.file} \u2192 ${prog.status}`, type: 'APPEND_OUTPUT' })
-            if (prog.status === 'failed') appendErrorLog('enhance', `Failed: ${prog.file}`)
-          })
-          dispatch({ command: 'enhance', count: result.failed, type: 'RECORD_FAILURES' })
-          const enhanceLine =
-            result.skipped > 0
-              ? `Enhanced: ${result.enhanced}, Skipped: ${result.skipped}, Failed: ${result.failed}`
-              : `Enhanced: ${result.enhanced}, Failed: ${result.failed}`
-          dispatch({ line: enhanceLine, type: 'APPEND_OUTPUT' })
-          dispatch({ code: 0, type: 'COMMAND_DONE' })
-          return 0
-        }
-
-        if (key === 'pipeline') {
-          await clearPipelineLog()
-          await writeNativeFileList()
-        }
-
-        const spawned = spawnCommand(key)
-        if (!spawned) return -1
-        dispatch({ label: spawned.label, stepCommand: key, type: 'START_COMMAND' })
-        procRef.current = spawned.proc
-
-        const onLine = (line: string): void => {
-          dispatch({ line, type: 'APPEND_OUTPUT' })
-          if (key === 'pipeline') appendPipelineLog(line)
-          if (ERROR_PATTERN.test(line)) appendErrorLog(key, line)
-        }
-
-        const { stderr, stdout } = spawned.proc
-        const stdoutPromise = stdout instanceof ReadableStream ? readStream(stdout, onLine) : noop()
-        const stderrPromise = stderr instanceof ReadableStream ? readStream(stderr, onLine) : noop()
-
-        await Promise.all([stdoutPromise, stderrPromise])
-        const code = await spawned.proc.exited
-        dispatch({ code, type: 'COMMAND_DONE' })
-        procRef.current = null
-        return code
-      } catch (execError) {
-        const msg = String(execError)
-        dispatch({ line: `Error: ${msg}`, type: 'APPEND_OUTPUT' })
-        appendErrorLog(key, msg)
-        dispatch({ code: 1, type: 'COMMAND_DONE' })
-        return 1
-      } finally {
-        busyRef.current = false // eslint-disable-line require-atomic-updates
-      }
-    },
-    []
-  )
-
-  // eslint-disable-next-line max-statements
-  const runParallelConvertOcr = useCallback(async (): Promise<number> => {
-    busyRef.current = true
-    const parallelStart = Date.now()
-    try {
-      const ocrStats = await getOcrStats()
-      let ocrSpawned: ReturnType<typeof spawnCommand> = null
-      if (ocrStats.remaining > 0) {
-        ocrSpawned = spawnCommand('ocr')
-        if (ocrSpawned) {
-          ocrProcRef.current = ocrSpawned.proc
-          dispatch({ active: true, type: 'SET_BACKGROUND_OCR' })
-          const { stderr: ocrErr, stdout: ocrOut } = ocrSpawned.proc
-          const ocrErrorLine = (line: string): void => {
-            if (ERROR_PATTERN.test(line)) appendErrorLog('ocr', line)
-          }
-          if (ocrOut instanceof ReadableStream) readStream(ocrOut, ocrErrorLine)
-          if (ocrErr instanceof ReadableStream) readStream(ocrErr, ocrErrorLine)
-        }
-      }
-
-      await clearPipelineLog()
-      await writeNativeFileList()
-      const pipelineSpawned = spawnCommand('pipeline')
-      if (!pipelineSpawned) return -1
-
-      dispatch({ label: pipelineSpawned.label, stepCommand: 'pipeline', type: 'START_COMMAND' })
-      procRef.current = pipelineSpawned.proc
-
-      const onLine = (line: string): void => {
-        dispatch({ line, type: 'APPEND_OUTPUT' })
-        appendPipelineLog(line)
-        if (ERROR_PATTERN.test(line)) appendErrorLog('pipeline', line)
-      }
-      const { stderr, stdout } = pipelineSpawned.proc
-      const stdoutP = stdout instanceof ReadableStream ? readStream(stdout, onLine) : noop()
-      const stderrP = stderr instanceof ReadableStream ? readStream(stderr, onLine) : noop()
-
-      // biome-ignore lint/performance/noAwaitInLoops: awaiting parallel streams
-      await Promise.all([stdoutP, stderrP]) // eslint-disable-line no-await-in-loop
-      const pipeCode = await pipelineSpawned.proc.exited
-      procRef.current = null
-      dispatch({ code: pipeCode, type: 'COMMAND_DONE' })
-
-      if (pipeCode !== 0) {
-        if (ocrProcRef.current) {
-          ocrProcRef.current.kill()
-          ocrProcRef.current = null
-        }
-        dispatch({ active: false, type: 'SET_BACKGROUND_OCR' })
-        return pipeCode
-      }
-
-      if (ocrProcRef.current) {
-        dispatch({ label: 'Chandra OCR', stepCommand: 'ocr', type: 'START_COMMAND' })
-        procRef.current = ocrProcRef.current
-        const ocrCode = await ocrProcRef.current.exited
-        procRef.current = null
-        ocrProcRef.current = null // eslint-disable-line require-atomic-updates
-        dispatch({ active: false, type: 'SET_BACKGROUND_OCR' })
-        dispatch({ command: 'ocr', seconds: Math.floor((Date.now() - parallelStart) / 1000), type: 'RECORD_DURATION' })
-        dispatch({ code: ocrCode, type: 'COMMAND_DONE' })
-        return ocrCode
-      }
-
-      dispatch({ active: false, type: 'SET_BACKGROUND_OCR' })
-      return 0
-    } finally {
-      busyRef.current = false // eslint-disable-line require-atomic-updates
-    }
-  }, [])
-
-  // eslint-disable-next-line max-statements
-  const autoRun = useCallback(async () => {
-    if (busyRef.current) return
-
-    if (!errorLogClearedRef.current) {
-      errorLogClearedRef.current = true
-      await clearErrorLog()
-    }
-
-    dispatch({ line: 'Checking Python environment...', type: 'APPEND_OUTPUT' })
-    const ok = await bootstrapPython({
-      onDone: () => {
-        dispatch({ line: 'Python environment ready.', type: 'APPEND_OUTPUT' })
-      },
-      onStep: (msg: string) => {
-        dispatch({ line: msg, type: 'APPEND_OUTPUT' })
-      }
-    })
-    if (!ok) {
-      dispatch({
-        errors: ['Python bootstrap failed. Install uv and try again.'],
-        type: 'SET_PREFLIGHT',
-        warnings: []
-      })
-      return
-    }
-
-    const preflight = await runPreflight()
-    dispatch({ errors: preflight.errors, type: 'SET_PREFLIGHT', warnings: preflight.warnings })
-    if (preflight.errors.length > 0) return
-
-    const data = await refreshSteps()
-    const nextStep = findFirstIncomplete(data)
-
-    if (!nextStep) {
-      dispatch({ type: 'SET_ALL_DONE' })
-      process.stdout.write('\u0007')
-      Bun.spawn(['osascript', '-e', 'display notification "Pipeline complete" with title "Doc Pipeline"'])
-      return
-    }
-
-    let code: number
-    const classifyDone = isStepDone('classify', data)
-    const pipelineNeeded = !isStepDone('pipeline', data)
-    const ocrNeeded = !isStepDone('ocr', data)
-
-    if (nextStep === 'pipeline' && classifyDone && pipelineNeeded && ocrNeeded) code = await runParallelConvertOcr()
-    else code = await executeCommand(nextStep)
-
-    if (code === 0) {
-      await refreshSteps()
-      setTimeout(() => {
-        autoRun()
-      }, 500)
-    }
-  }, [refreshSteps, executeCommand, runParallelConvertOcr])
-
-  useEffect(() => {
-    autoRun()
-  }, [autoRun])
-
-  useEffect(() => {
-    const interval = setInterval(() => {
-      refreshSteps()
-      if (state.showLog) refreshLog()
-    }, 2000)
-    return () => clearInterval(interval)
-  }, [refreshSteps, refreshLog, state.showLog])
-
-  // eslint-disable-next-line max-statements
-  const skipCurrentStep = useCallback(async () => {
-    const currentCmd = state.runningCommand
-    dispatch({ type: 'CLEAR_FAILURE' })
-    if (!currentCmd) return
-
-    const idx = STEP_ORDER.indexOf(currentCmd)
-    const data = await refreshSteps()
-    const remaining = STEP_ORDER.slice(idx + 1)
-    let nextKey: CommandKey | null = null
-    for (const k of remaining)
-      if (!isStepDone(k, data)) {
-        nextKey = k
-        break
-      }
-
-    if (!nextKey) {
-      dispatch({ type: 'SET_ALL_DONE' })
-      return
-    }
-
-    const code = await executeCommand(nextKey)
-    if (code === 0) {
-      await refreshSteps()
-      autoRun()
-    }
-  }, [state.runningCommand, refreshSteps, executeCommand, autoRun])
-
-  // eslint-disable-next-line complexity, max-statements
-  useKeyboard(key => {
-    if (showHelp) {
-      if (key.name === '?' || key.name === 'escape') setShowHelp(false)
-      return
-    }
-
-    if (key.name === '?') {
-      setShowHelp(true)
-      return
-    }
-
-    if (key.name === 'q' || key.name === 'escape') {
-      if (procRef.current) {
-        procRef.current.kill()
-        procRef.current = null
-      }
-      if (ocrProcRef.current) {
-        ocrProcRef.current.kill()
-        ocrProcRef.current = null
-      }
-      setTerminalTitle('')
-      process.exit(0)
-      return
-    }
-
-    if (key.name === 'l') {
-      refreshLog()
-      dispatch({ type: 'TOGGLE_LOG' })
-      return
-    }
-
-    if (state.failed) {
-      if (key.name === 'r') {
-        dispatch({ type: 'CLEAR_FAILURE' })
-        autoRun()
-        return
-      }
-      if (key.name === 's') skipCurrentStep()
-    }
-  })
-
-  const logHeight = Math.max(5, height - 3)
-  const displayLines = state.showLog ? state.logLines : state.runningLines
-
-  return (
-    <box flexDirection='column' height={height}>
-      <TitleBarTop
-        allDone={state.allDone}
-        backgroundOcr={state.backgroundOcr}
-        failed={state.failed}
-        pipelineStartedAt={state.pipelineStartedAt}
-        runningCommand={state.runningCommand}
-        stepsData={state.stepsData}
-      />
-      <box flexGrow={1}>
-        <box flexDirection='column' paddingLeft={1} width={SIDEBAR_WIDTH}>
-          {state.stepsData ? (
-            <box flexDirection='column'>
-              {STEPS.map(step => {
-                const isFg = state.runningCommand === step.command
-                const isBgOcr = step.command === 'ocr' && state.backgroundOcr
-                const isActive = isFg || isBgOcr
-                const sd = state.stepsData ? state.stepsData[step.command] : undefined
-                const failures = sd?.failed ?? state.stepFailures[step.command]
-                return (
-                  <SidebarStep
-                    completedDuration={state.stepDurations[step.command]}
-                    failedCount={failures}
-                    isFailed={state.failed ? isFg : false}
-                    isRunning={!state.failed && isActive}
-                    key={step.command}
-                    ocrProgress={step.command === 'ocr' ? state.stepsData?.ocr.progress : undefined}
-                    runningStatus={isFg ? state.runningStatus : ''}
-                    step={step}
-                    stepData={sd}
-                    stepStartedAt={isActive ? state.stepStartedAt : 0}
-                  />
-                )
-              })}
-            </box>
-          ) : (
-            <text fg={DIM}>Loading...</text>
-          )}
-          <SidebarSummary
-            allDone={state.allDone}
-            datasetResult={state.datasetResult}
-            stepDurations={state.stepDurations}
-          />
-        </box>
-        <box flexDirection='column' flexGrow={1} paddingLeft={2}>
-          {state.preflightErrors.length > 0 || state.preflightWarnings.length > 0 ? (
-            <PreflightBanner errors={state.preflightErrors} warnings={state.preflightWarnings} />
-          ) : null}
-          <scrollbox focused height={logHeight} paddingLeft={1} stickyScroll>
-            {displayLines.length > 0 ? (
-              displayLines.map((line, i) => {
-                const isError = ERROR_PATTERN.test(line)
-                return (
-                  // eslint-disable-next-line react/no-array-index-key
-                  <text fg={isError ? 'red' : DIM} key={i}>
-                    {line}
-                  </text>
-                )
-              })
-            ) : (
-              <text fg={DIM}>Waiting for output...</text>
-            )}
-          </scrollbox>
-        </box>
-      </box>
-      {showHelp ? <HelpDialog height={height} width={width} /> : null}
-    </box>
-  )
-}
-
-const start = async () => {
-  const renderer = await createCliRenderer({ exitOnCtrlC: false })
-  createRoot(renderer).render(<App />)
-}
-
-const isDirectRun = process.argv[1]?.endsWith('tui.tsx') ?? false
-if (isDirectRun) {
-  const { resolve } = await import('node:path')
-  const { initPaths } = await import('~/paths')
-  try {
-    getPaths()
-  } catch {
-    initPaths(resolve('data'), resolve('output'))
-  }
-  // oxlint-disable-next-line unicorn/prefer-top-level-await
-  start()
-}
-
-export { start }