barra-cache

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    // Quello che disegnano le altre mod nella banda resta sotto le nostre righe
    const theirs = await next(e)
    if (!enabled) return theirs
    // L'ora si rilegge a ogni disegno: non dipende dal timer, che può fermarsi
    try {
      now = await $.clock.now()
    } catch {}
    const { Box, Text, Button } = $.ui.resolve(e)
    const dim = (text) => Text({ dimColor: true, children: [text] })
    const strong = (text, color) => Text(color ? { bold: true, color, children: [text] } : { bold: true, children: [text] })
    const row = (children) => Box({ flexDirection: 'row', flexWrap: 'wrap', children: children.filter(Boolean) })
    const gap = Text({ children: ['  '] })
    // Con lo stato di git i bottoni compaiono solo se c'è qualcosa da fare
    const hasChanges = git === null || git.changed > 0
    const canPush = git !== null && git.changed === 0 && (git.ahead > 0 || !git.hasUpstream)
    const buttons = Box({
      flexDirection: 'row',
      children: [
        noRepo && Button({ key: 'create-repo', label: 'Crea repo', hotkey: 'g', onPress: () => $.prompt.submit({ text: CREATE_REPO_PROMPT }) }),
        noRepo && gap,
        !noRepo && hasChanges && Button({ key: 'commit', label: 'Commit e push', hotkey: 'g', onPress: () => $.prompt.submit({ text: COMMIT_PROMPT }) }),
        !noRepo && hasChanges && gap,
        !noRepo && canPush && Button({ key: 'push', label: 'Push', hotkey: 'p', onPress: () => pushNow($) }),
        !noRepo && canPush && gap,
        Button({
          key: 'fresh',
          label: 'Handoff',
          hotkey: 'n',
          onPress: () => startHandoff($),
        }),
      ].filter(Boolean),
    })
    // Niente props indefinite: il colore è scelto prima
    const paint = (text, color) => Text(color ? { color, children: [text] } : { dimColor: true, children: [text] })
    const barWidth = e.props.bodyColumns >= 110 ? 12 : 8

    // Una barra piena per la parte usata, vuota per il resto
    const bar = (fraction, color) => {
      const full = Math.min(barWidth, Math.max(0, Math.ceil(fraction * barWidth)))
      return [paint('█'.repeat(full), color), dim('░'.repeat(barWidth - full))]
    }

    // Riga 1: la memoria della chat, cioè il contesto occupato, e quanto è costata a listino
    const memory = usage
      ? row([
          dim('🧠 memoria della chat '),
          ...bar(usage.percent / 100, contextColor(usage.percent)),
          dim(' '),
          strong(tokensIt(usage.tokens) + ' token'),
          usage.usd !== undefined && dim(' · speso ' + dollars(usage.usd) + ' a listino'),
          usage.percent > CONTEXT_BAD && paint(' · Nuova chat?', 'red'),
        ])
      : null

    // Riga 2: i consumi dell'abbonamento, ognuno solo se il motore ha riportato la cifra
    const limitRow = (kind, icon, label) => {
      const found = limits.find((l) => l.kind === kind)
      if (!found) return null
      const percent = Math.round(found.percentUsed)
      const reset = resetLabel(found.resetsAt, now)
      return row([
        dim(icon + ' ' + label + ' '),
        ...bar(found.percentUsed / 100, contextColor(percent)),
        dim(' '),
        strong(percent + '%', percent > CONTEXT_BAD ? 'red' : null),
        reset && dim(' scade ' + reset),
      ])
    }
    // Le finestre note hanno un'etichetta; una finestra che il motore aggiunge in futuro (un mese, per esempio) compare con il suo nome
    const known = ['five_hour', 'seven_day', 'spend_limit']
    const windows = [
      limitRow('five_hour', '⏳', 'uso 5 ore'),
      limitRow('seven_day', '📅', 'uso settimana'),
      limitRow('spend_limit', '💳', 'limite di spesa'),
      ...limits.filter((l) => !known.includes(l.kind)).map((l) => limitRow(l.kind, '📆', windowName(l.kind))),
    ].filter(Boolean)
    const usageRow = windows.length ? row(windows.flatMap((w, i) => (i === 0 ? [w] : [gap, w]))) : null

    // Riga 3: da quanto è aperta la sessione e quanto resta della cache
    let isCold = false
    let cacheSeg
    if (lastAt === null) {
      cacheSeg = dim('🔥 cache in attesa della prima richiesta')
    } else {
      const leftMs = Math.max(0, ttlMs - (now - lastAt))
      if (leftMs === 0) {
        isCold = true
        cacheSeg = row([dim('🧊 cache '), paint('scaduta', 'red')])
      } else {
        const minutes = Math.ceil(leftMs / 60000)
        cacheSeg = row([dim('🔥 cache calda ancora '), strong(minutes + ' min', leftColor(minutes) === 'green' ? null : leftColor(minutes))])
      }
    }
    const sessionRow = row([startedAt !== null && dim('🕒 sessione aperta da '), startedAt !== null && strong(duration(Math.max(0, now - startedAt))), startedAt !== null && gap, cacheSeg])

    // Cache scaduta con un contesto grande: il prossimo prompt riscrive tutto a prezzo pieno
    const coldWarn =
      isCold && usage && usage.tokens >= 20000
        ? Box({ flexDirection: 'row', children: [paint('Cache scaduta · il prossimo prompt riscrive ' + tokensIt(usage.tokens) + ' token', 'red'), dim(' · se cambi argomento conviene Nuova chat')] })
        : null

    const lines = [memory, usageRow, sessionRow]
    return Box({
      flexDirection: 'column',
      children: (e.props.isWorking ? [...lines, theirs] : [...lines, coldWarn, buttons, theirs]).filter(Boolean),
    })
  })