corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
use anyhow::Result;
use clap::Parser;
use corelens::{
    app::App,
    collector::{self, cpu::CpuCollector},
    config::Config,
    event::{Event, spawn_event_reader},
    ui,
};
use crossterm::{
    cursor::{Hide, Show},
    event::KeyCode,
    execute,
    terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};
use std::io;
use tokio::sync::mpsc;
use tracing_subscriber::EnvFilter;

struct TerminalGuard;
impl TerminalGuard {
    fn enter() -> Result<Self> {
        enable_raw_mode()?;
        execute!(io::stdout(), EnterAlternateScreen, Hide)?;
        Ok(Self)
    }
}
impl Drop for TerminalGuard {
    fn drop(&mut self) {
        let _ = disable_raw_mode();
        let _ = execute!(io::stdout(), Show, LeaveAlternateScreen);
    }
}

fn restore_terminal() {
    let _ = disable_raw_mode();
    let _ = execute!(io::stdout(), Show, LeaveAlternateScreen);
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_target(false)
        .init();
    let config = Config::parse();
    if config.debug_topology {
        let mut collector = CpuCollector::new();
        let topology = collector.collect()?;
        let diagnostics = &topology.diagnostics;
        println!("Online logical CPUs: {}", diagnostics.online_logical_cpus);
        println!(
            "Assigned logical CPUs: {}",
            diagnostics.assigned_logical_cpus
        );
        println!("Physical cores: {}", diagnostics.physical_core_count);
        println!("P-cores: {}", diagnostics.performance_core_count);
        println!("E-cores: {}", diagnostics.efficiency_core_count);
        println!("Unknown: {}", diagnostics.unknown_core_count);
        for (index, core) in topology.cores.iter().enumerate() {
            println!(
                "C{index}: package={:?} die={:?} core_id={:?} logical={:?}",
                core.package_id, core.die_id, core.core_id, core.logical_cpus
            );
        }
        return Ok(());
    }
    let _guard = TerminalGuard::enter()?;
    let previous_hook = std::panic::take_hook();
    std::panic::set_hook(Box::new(move |panic| {
        restore_terminal();
        previous_hook(panic);
    }));
    let mut terminal = Terminal::new(CrosstermBackend::new(io::stdout()))?;
    let (event_tx, mut event_rx) = mpsc::unbounded_channel();
    let (refresh_tx, mut refresh_rx) = mpsc::unbounded_channel();
    let (force_tx, force_rx) = mpsc::unbounded_channel();
    spawn_event_reader(event_tx);
    tokio::spawn(collector::run_collection_loop(config, refresh_tx, force_rx));
    let mut sigint = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::interrupt())?;
    let mut app = App::default();
    loop {
        terminal.draw(|frame| ui::draw(frame, &app))?;
        tokio::select! {
            Some(Event::Key(key)) = event_rx.recv() => {
                if key.code == KeyCode::Char('r') { let _ = force_tx.send(()); app.status = vec!["Refresh requested".into()]; }
                else if app.handle_key(key) { break; }
            }
            Some(refresh) = refresh_rx.recv() => app.apply(refresh),
            _ = sigint.recv() => break,
        }
    }
    drop(terminal);
    Ok(())
}