cache-meter

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    // Quello che disegnano le altre mod nella banda resta sotto la nostra riga
    const theirs = await next(e)
    // 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] })
    // 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 gap = Text({ children: ['  '] })
    const buttons = Box({
      flexDirection: 'row',
      children: [
        hasChanges && Button({ key: 'commit', label: 'Commit e push', hotkey: 'g', onPress: () => $.prompt.submit({ text: COMMIT_PROMPT }) }),
        hasChanges && gap,
        canPush && Button({ key: 'push', label: 'Push', hotkey: 'p', onPress: () => pushNow($) }),
        canPush && gap,
        Button({
          key: 'fresh',
          label: 'Nuova chat',
          hotkey: 'n',
          onPress: () => startHandoff($),
        }),
      ].filter(Boolean),
    })
    const gitLine =
      git === null
        ? null
        : Box({
            flexDirection: 'row',
            children: [
              dim('repo · ' + git.branch + ' · '),
              Text(git.changed > 0 ? { color: 'yellow', children: [git.changed + ' modificati'] } : { dimColor: true, children: ['0 modificati'] }),
              dim(' · '),
              Text(git.ahead > 0 ? { color: 'yellow', children: [git.ahead + ' da pushare'] } : { dimColor: true, children: ['0 da pushare'] }),
            ],
          })
    // Niente props indefinite: il colore è scelto prima
    const paint = (text, color) => Text(color ? { color, children: [text] } : { dimColor: true, children: [text] })
    const columns = e.props.bodyColumns
    const wide = columns >= 110
    const barWidth = wide ? 12 : 6

    // Una barra piena per la parte "buona": nel contesto è lo spazio usato, nella cache il tempo che resta
    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))]
    }

    // La cache: una barra che si svuota e i minuti che restano
    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 = Box({ flexDirection: 'row', children: [dim('cache ' + '░'.repeat(barWidth) + ' '), paint('scaduta', 'red')] })
      } else {
        const minutes = Math.ceil(leftMs / 60000)
        const color = leftColor(minutes)
        cacheSeg = Box({ flexDirection: 'row', children: [dim('cache '), ...bar(leftMs / ttlMs, color), dim(' '), paint(minutes + ' min', color)] })
      }
    }

    // Gli altri consumi, ognuno al suo posto solo se il motore ha riportato la cifra
    const others = []
    if (usage) {
      const c = contextColor(usage.percent)
      others.push(
        Box({
          flexDirection: 'row',
          children: [
            dim('contesto '),
            ...bar(usage.percent / 100, c),
            dim(' '),
            paint(usage.percent + '%', c),
            dim(' ' + short(usage.tokens) + '/' + short(usage.window)),
            usage.percent > CONTEXT_BAD && paint(' · Nuova chat?', 'red'),
          ].filter(Boolean),
        }),
      )
    }
    const secondary = []
    if (lastTurn) {
      const hot = lastTurn.usd !== null && lastTurn.usd >= COST_WARN
      secondary.push(
        Box({
          flexDirection: 'row',
          children: [
            dim('turno '),
            lastTurn.usd !== null && paint(dollars(lastTurn.usd), hot ? 'yellow' : null),
            lastTurn.usd !== null && dim(' · '),
            dim(short(lastTurn.fresh) + ' nuovi · ' + short(lastTurn.out) + ' generati'),
          ].filter(Boolean),
        }),
      )
    }
    if (startedAt !== null) secondary.push(dim('sessione ' + duration(Math.max(0, now - startedAt))))
    if (cacheReadPct !== null) {
      secondary.push(Box({ flexDirection: 'row', children: [dim('cache letta '), paint(cacheReadPct + '%', cacheColor(cacheReadPct))] }))
    }
    const joined = (list) => list.flatMap((p, i) => (i ? [dim(' · '), p] : [p]))

    // Tutto in una riga che va a capo da sola solo se manca lo spazio: le colonne di una finestra desktop non dicono quanto è larga
    const main = Box({ flexDirection: 'row', flexWrap: 'wrap', children: joined([cacheSeg, ...others, ...secondary]) })
    const extra = null

    // 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 ' + short(usage.tokens) + ' token', 'red'), dim(' · se cambi argomento conviene Nuova chat')] })
        : null

    return Box({
      flexDirection: 'column',
      children: (e.props.isWorking ? [main, extra, theirs] : [main, extra, coldWarn, gitLine, buttons, theirs]).filter(Boolean),
    })
  })