corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
use crate::{
    model::{ServiceStatus, gpu::GpuSnapshot},
    ui::{gpu_matrix_tile, memory_bars},
};
use ratatui::{
    prelude::*,
    widgets::{Block, Borders, Paragraph, Wrap},
};

pub fn render(frame: &mut Frame<'_>, area: Rect, status: &ServiceStatus<Vec<GpuSnapshot>>) {
    let block = Block::default().title(" GPU MATRIX ").borders(Borders::ALL);
    let inner = block.inner(area);
    frame.render_widget(block, area);
    match status {
        ServiceStatus::Loading => frame.render_widget(Paragraph::new("Loading GPU…"), inner),
        ServiceStatus::Unavailable(reason) => frame.render_widget(
            Paragraph::new(format!("GPU unavailable\n{reason}")).wrap(Wrap { trim: true }),
            inner,
        ),
        ServiceStatus::Available(gpus) if gpus.is_empty() => {
            frame.render_widget(Paragraph::new("No DRM GPU devices detected"), inner)
        }
        ServiceStatus::Available(gpus) => {
            let split = Layout::vertical([
                Constraint::Min(6),
                Constraint::Length((gpus.len() as u16).saturating_add(1)),
            ])
            .split(inner);
            let matrix = split[0];
            let bars = split[1];
            let tile_width = (matrix.width / gpus.len().max(1) as u16).max(1);
            for (index, gpu) in gpus.iter().enumerate() {
                let x = matrix.x + index as u16 * tile_width;
                let rect = Rect::new(
                    x,
                    matrix.y,
                    tile_width.min(matrix.right().saturating_sub(x)),
                    matrix.height,
                );
                let dimension = if rect.width >= 16 && rect.height >= 8 {
                    5
                } else if rect.width >= 12 && rect.height >= 7 {
                    4
                } else {
                    3
                };
                gpu_matrix_tile::render(frame, rect, gpu, dimension, false);
            }
            let width = bars.width.saturating_sub(1) as usize;
            let lines = gpus
                .iter()
                .map(|gpu| format!("{} · {}", memory_bars::vram_line(gpu, width), power(gpu)))
                .collect::<Vec<_>>()
                .join("\n");
            frame.render_widget(Paragraph::new(lines).wrap(Wrap { trim: true }), bars);
        }
    }
}

fn power(gpu: &GpuSnapshot) -> String {
    match (gpu.power_draw_milliwatts, gpu.power_limit_milliwatts) {
        (Some(draw), Some(limit)) => {
            format!("{:.0}/{:.0}W", draw as f64 / 1000.0, limit as f64 / 1000.0)
        }
        _ => "power --".into(),
    }
}