expensive 0.5.5

Terminal dashboard for AI coding harness token usage and spend
Documentation
use ratatui::{
    layout::{Margin, Rect},
    style::{Modifier, Style},
    text::{Line, Span},
    widgets::{Block, Borders, Paragraph},
    Frame,
};

use crate::{
    app::GraphMetric,
    db::{TokenBucket, UsageStats},
    format,
    time_window::Mode,
};

use super::{local_date, rect_contains, Palette};

#[derive(Clone, Copy)]
struct GraphBucket {
    start_idx: usize,
    end_idx: usize,
    start_millis: i64,
    end_millis: i64,
    tokens: u64,
    cost: f64,
}

#[derive(Clone, Copy)]
struct GraphColumn {
    bucket: GraphBucket,
    visible: bool,
}

pub(super) fn draw_token_graph(
    frame: &mut Frame<'_>,
    area: Rect,
    stats: &UsageStats,
    selected_bucket: Option<usize>,
    metric: GraphMetric,
    palette: Palette,
) {
    let inner = token_graph_inner_area(area);
    let (visible_start, visible_end) = visible_token_bucket_range(stats.mode, &stats.token_buckets);
    let columns = token_graph_columns(
        &stats.token_buckets[visible_start..visible_end],
        inner.width as usize,
        visible_start,
    );
    let max_value = columns
        .iter()
        .map(|column| graph_bucket_value(column.bucket, metric))
        .fold(0.0_f64, f64::max);
    let axis_height = usize::from(inner.height > 1);
    let graph_height = (inner.height as usize).saturating_sub(axis_height).max(1);
    let selected_bucket = selected_bucket.filter(|idx| *idx < stats.token_buckets.len());

    let mut lines = (0..graph_height)
        .map(|row| {
            let level = graph_height.saturating_sub(row);
            let spans = columns
                .iter()
                .map(|column| {
                    let bucket = column.bucket;
                    let value = graph_bucket_value(bucket, metric);
                    let filled_height = if max_value <= 0.0 || value <= 0.0 {
                        0
                    } else {
                        ((value / max_value) * graph_height as f64).ceil() as usize
                    };
                    let selected = selected_bucket
                        .map(|idx| idx >= bucket.start_idx && idx < bucket.end_idx)
                        .unwrap_or(false);
                    let color = if selected {
                        palette.calendar_accent
                    } else if value <= 0.0 {
                        palette.muted
                    } else {
                        match metric {
                            GraphMetric::Tokens => palette.tokens,
                            GraphMetric::Cost => palette.cost,
                        }
                    };
                    let mut style = Style::default().fg(color);
                    if selected {
                        style = style.add_modifier(Modifier::BOLD);
                    }
                    Span::styled(
                        if column.visible && filled_height >= level {
                            "â–ˆ"
                        } else {
                            " "
                        },
                        style,
                    )
                })
                .collect::<Vec<_>>();
            Line::from(spans)
        })
        .collect::<Vec<_>>();
    if axis_height > 0 {
        lines.push(token_graph_axis_line(&columns, stats.mode, palette));
    }

    let block = Block::default()
        .borders(Borders::ALL)
        .title(token_graph_title(stats, selected_bucket, metric))
        .title_style(Style::default().fg(palette.title))
        .border_style(Style::default().fg(palette.border));
    frame.render_widget(Paragraph::new(lines).block(block), area);
}

pub(super) fn draw_token_graph_loading(
    frame: &mut Frame<'_>,
    area: Rect,
    metric: GraphMetric,
    palette: Palette,
) {
    let label = match metric {
        GraphMetric::Tokens => "Token usage",
        GraphMetric::Cost => "Cost",
    };
    let block = Block::default()
        .borders(Borders::ALL)
        .title(format!(" {label} over time "))
        .title_style(Style::default().fg(palette.title))
        .border_style(Style::default().fg(palette.border));
    let loading = match metric {
        GraphMetric::Tokens => "Loading token graph...",
        GraphMetric::Cost => "Loading cost graph...",
    };
    let paragraph = Paragraph::new(loading)
        .block(block)
        .style(Style::default().fg(palette.tokens));

    frame.render_widget(paragraph, area);
}

fn token_graph_title(
    stats: &UsageStats,
    selected_bucket: Option<usize>,
    metric: GraphMetric,
) -> String {
    let (label, value) = match metric {
        GraphMetric::Tokens => (
            "Token usage",
            selected_bucket
                .and_then(|idx| stats.token_buckets.get(idx))
                .map(|bucket| format::tokens(bucket.tokens)),
        ),
        GraphMetric::Cost => (
            "Cost",
            selected_bucket
                .and_then(|idx| stats.token_buckets.get(idx))
                .map(|bucket| format::precise_cost(bucket.cost)),
        ),
    };
    if let Some(bucket) = selected_bucket.and_then(|idx| stats.token_buckets.get(idx)) {
        return format!(
            " {label} over time | {} {} ",
            token_bucket_range_label(bucket, stats.mode),
            value.unwrap_or_default()
        );
    }

    format!(" {label} over time | g toggles ")
}

fn graph_bucket_value(bucket: GraphBucket, metric: GraphMetric) -> f64 {
    match metric {
        GraphMetric::Tokens => bucket.tokens as f64,
        GraphMetric::Cost => bucket.cost,
    }
}

fn token_graph_axis_line(columns: &[GraphColumn], mode: Mode, palette: Palette) -> Line<'static> {
    if columns.is_empty() {
        return Line::from("");
    }

    let mut cells = vec![' '; columns.len()];
    let tick_count = if columns.len() >= 36 { 4 } else { 3 }.min(columns.len());
    for tick_idx in 0..tick_count {
        let column_idx = if tick_count == 1 {
            0
        } else {
            tick_idx * (columns.len() - 1) / (tick_count - 1)
        };
        let label = token_axis_label(&columns[column_idx].bucket, mode);
        place_axis_label(&mut cells, column_idx, &label);
    }

    Line::from(Span::styled(
        cells.into_iter().collect::<String>(),
        Style::default().fg(palette.muted),
    ))
}

fn place_axis_label(cells: &mut [char], center: usize, label: &str) {
    if cells.is_empty() || label.is_empty() {
        return;
    }

    let label_width = label.chars().count();
    if label_width > cells.len() {
        return;
    }

    let start = center
        .saturating_sub(label_width / 2)
        .min(cells.len().saturating_sub(label_width));
    if cells[start..start + label_width]
        .iter()
        .any(|value| *value != ' ')
    {
        return;
    }

    for (idx, ch) in label.chars().enumerate() {
        cells[start + idx] = ch;
    }
}

fn token_axis_label(bucket: &GraphBucket, mode: Mode) -> String {
    let Some(start) = local_date(bucket.start_millis) else {
        return String::new();
    };

    match mode {
        Mode::Daily => start.format("%H").to_string(),
        Mode::Weekly | Mode::Monthly => start.format("%b %d").to_string(),
        Mode::AllTime => {
            let span = bucket.end_millis.saturating_sub(bucket.start_millis);
            if span <= 7 * 24 * 60 * 60 * 1000 {
                start.format("%b %d").to_string()
            } else {
                start.format("%b").to_string()
            }
        }
    }
}

pub(super) fn token_bucket_range_label(bucket: &TokenBucket, mode: Mode) -> String {
    let Some(start) = local_date(bucket.start_millis) else {
        return "bucket".to_string();
    };
    let end = local_date(bucket.end_millis);

    match mode {
        Mode::Daily => end
            .map(|end| format!("{}-{}", start.format("%H:%M"), end.format("%H:%M")))
            .unwrap_or_else(|| start.format("%H:%M").to_string()),
        Mode::Weekly | Mode::Monthly => start.format("%b %d").to_string(),
        Mode::AllTime => {
            let span = bucket.end_millis.saturating_sub(bucket.start_millis);
            if span <= 7 * 24 * 60 * 60 * 1000 {
                start.format("%b %d").to_string()
            } else {
                start.format("%b %Y").to_string()
            }
        }
    }
}

pub(super) fn token_bucket_index_at_position(
    column: u16,
    row: u16,
    area: Rect,
    stats: &UsageStats,
) -> Option<usize> {
    if !rect_contains(area, column, row) {
        return None;
    }

    let inner = token_graph_inner_area(area);
    if inner.width == 0 || inner.height == 0 {
        return None;
    }

    let (visible_start, visible_end) = visible_token_bucket_range(stats.mode, &stats.token_buckets);
    let columns = token_graph_columns(
        &stats.token_buckets[visible_start..visible_end],
        inner.width as usize,
        visible_start,
    );
    if columns.is_empty() {
        return None;
    }

    let max_column_idx = columns.len().saturating_sub(1);
    let column_idx = if column < inner.x {
        0
    } else if column >= inner.x.saturating_add(inner.width) {
        max_column_idx
    } else {
        (column.checked_sub(inner.x)? as usize).min(max_column_idx)
    };
    columns
        .get(column_idx)
        .map(|column| column.bucket.start_idx)
}

fn token_graph_inner_area(area: Rect) -> Rect {
    area.inner(Margin {
        horizontal: 1,
        vertical: 1,
    })
}

pub(super) fn visible_token_bucket_range(mode: Mode, buckets: &[TokenBucket]) -> (usize, usize) {
    if buckets.is_empty() {
        return (0, 0);
    }

    if matches!(mode, Mode::Daily | Mode::Weekly | Mode::Monthly) {
        return (0, buckets.len());
    }

    let Some(first_used) = buckets.iter().position(|bucket| bucket.tokens > 0) else {
        return (0, buckets.len());
    };
    let last_used = buckets
        .iter()
        .rposition(|bucket| bucket.tokens > 0)
        .unwrap_or(first_used);

    (
        first_used.saturating_sub(1),
        last_used.saturating_add(2).min(buckets.len()),
    )
}

fn token_graph_columns(
    buckets: &[TokenBucket],
    width: usize,
    start_offset: usize,
) -> Vec<GraphColumn> {
    if width == 0 || buckets.is_empty() {
        return Vec::new();
    }

    let show_separators = buckets.len() < width && width / buckets.len() >= 3;
    let mut previous_start_idx = None;

    (0..width)
        .map(|column_idx| {
            let bucket = graph_bucket_for_column(buckets, width, start_offset, column_idx);
            let visible = !(show_separators
                && previous_start_idx
                    .map(|idx| idx != bucket.start_idx)
                    .unwrap_or(false));
            previous_start_idx = Some(bucket.start_idx);

            GraphColumn { bucket, visible }
        })
        .collect()
}

fn graph_bucket_for_column(
    buckets: &[TokenBucket],
    width: usize,
    start_offset: usize,
    column_idx: usize,
) -> GraphBucket {
    if buckets.len() < width {
        let bucket_idx = column_idx * buckets.len() / width;
        return GraphBucket {
            start_idx: start_offset + bucket_idx,
            end_idx: start_offset + bucket_idx + 1,
            start_millis: buckets[bucket_idx].start_millis,
            end_millis: buckets[bucket_idx].end_millis,
            tokens: buckets[bucket_idx].tokens,
            cost: buckets[bucket_idx].cost,
        };
    }

    let start_idx = column_idx * buckets.len() / width;
    let end_idx = ((column_idx + 1) * buckets.len() / width).max(start_idx + 1);
    let tokens = buckets[start_idx..end_idx]
        .iter()
        .fold(0_u64, |total, bucket| total.saturating_add(bucket.tokens));
    let cost = buckets[start_idx..end_idx]
        .iter()
        .map(|bucket| bucket.cost)
        .sum();

    GraphBucket {
        start_idx: start_offset + start_idx,
        end_idx: start_offset + end_idx,
        start_millis: buckets[start_idx].start_millis,
        end_millis: buckets[end_idx - 1].end_millis,
        tokens,
        cost,
    }
}