corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
use crate::{
    app::{App, Focus},
    model::cpu::{CoreKind, PhysicalCore},
    ui::{cpu_matrix_tile, cpu_status::core_type_status, layout},
};
use ratatui::{
    prelude::*,
    widgets::{Block, Borders, Paragraph, Wrap},
};

pub fn render(frame: &mut Frame<'_>, area: Rect, app: &App) {
    let block = Block::default()
        .title(format!(" CPU MATRIX · {} ", core_type_status(app)))
        .borders(Borders::ALL);
    let inner = block.inner(area);
    frame.render_widget(block, area);
    if app.cpu.cores.is_empty() {
        frame.render_widget(Paragraph::new("Waiting for CPU topology…"), inner);
        return;
    }
    let (dimension, rects) = layout::matrix_layout(inner, app.cpu.cores.len());
    for (index, rect) in rects.iter().enumerate() {
        cpu_matrix_tile::render(
            frame,
            *rect,
            app,
            index,
            dimension,
            app.focus == Focus::Cpu && app.selected_core == index,
        );
    }
}

pub fn render_micro(frame: &mut Frame<'_>, area: Rect, app: &App) {
    let block = Block::default()
        .title(" CPU MICRO HEATMAP ")
        .borders(Borders::ALL);
    let inner = block.inner(area);
    let mut lines = Vec::new();
    let mut line = Vec::new();
    for (index, core) in app.cpu.cores.iter().enumerate() {
        if index > 0 {
            line.push(Span::raw(" "));
        }
        let util = core
            .logical_cpus
            .iter()
            .filter_map(|id| {
                app.cpu
                    .cpus
                    .iter()
                    .find(|cpu| cpu.logical_id == *id)
                    .and_then(|cpu| cpu.utilization)
            })
            .sum::<f64>()
            / core.logical_cpus.len().max(1) as f64;
        line.push(Span::raw(format!(
            "[{} {} {util:02.0}%]",
            display_label(app, index),
            micro_gauge(util)
        )));
        if line.len() > inner.width as usize / 4 {
            lines.push(Line::from(std::mem::take(&mut line)));
        }
    }
    if !line.is_empty() {
        lines.push(Line::from(line));
    }
    frame.render_widget(
        Paragraph::new(Text::from(lines))
            .block(block)
            .wrap(Wrap { trim: true }),
        area,
    );
}

fn micro_gauge(util: f64) -> String {
    let filled = (util.clamp(0.0, 100.0) / 25.0).round() as usize;
    format!("{}{}", "█".repeat(filled), "·".repeat(4 - filled))
}

pub fn display_label(app: &App, index: usize) -> String {
    let Some(core) = app.cpu.cores.get(index) else {
        return format!("C{index}");
    };
    let kind = core_kind(app, core);
    let ordinal = app
        .cpu
        .cores
        .iter()
        .take(index)
        .filter(|candidate| core_kind(app, candidate) == kind)
        .count();
    format!(
        "{}{}",
        match kind {
            CoreKind::Performance => "P",
            CoreKind::Efficiency | CoreKind::LowPowerEfficiency => "E",
            _ => "C",
        },
        ordinal
    )
}

fn core_kind(app: &App, core: &PhysicalCore) -> CoreKind {
    core.logical_cpus
        .iter()
        .find_map(|id| {
            app.cpu
                .cpus
                .iter()
                .find(|cpu| cpu.logical_id == *id)
                .map(|cpu| cpu.core_kind)
        })
        .unwrap_or(CoreKind::Unknown)
}