corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
use crate::{
    collector::RefreshResult,
    event,
    model::{
        ServiceStatus, cpu::CpuTopology, gpu::GpuSnapshot, memory::MemorySnapshot,
        ollama::OllamaModel, process::ProcessSnapshot,
    },
};
use crossterm::event::{KeyCode, KeyEvent};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Focus {
    Cpu,
    Workload,
    Gpu,
    Ollama,
    ProcessBrowser,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CpuView {
    MatrixTiles,
    MicroHeatmap,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProcessSort {
    Cpu,
    Memory,
    Pid,
    Name,
}

pub struct App {
    pub cpu: CpuTopology,
    pub processes: Vec<ProcessSnapshot>,
    pub gpu: ServiceStatus<Vec<GpuSnapshot>>,
    pub ollama: ServiceStatus<Vec<OllamaModel>>,
    pub memory: MemorySnapshot,
    pub focus: Focus,
    pub cpu_view: CpuView,
    pub process_sort: ProcessSort,
    pub selected_process: usize,
    pub selected_core: usize,
    pub process_browser: bool,
    pub diagnostics: bool,
    pub show_help: bool,
    pub status: Vec<String>,
}

impl Default for App {
    fn default() -> Self {
        Self {
            cpu: CpuTopology::default(),
            processes: Vec::new(),
            gpu: ServiceStatus::Loading,
            ollama: ServiceStatus::Loading,
            memory: MemorySnapshot::default(),
            focus: Focus::Cpu,
            cpu_view: CpuView::MatrixTiles,
            process_sort: ProcessSort::Cpu,
            selected_process: 0,
            selected_core: 0,
            process_browser: false,
            diagnostics: false,
            show_help: false,
            status: vec!["Collecting system data…".into()],
        }
    }
}

impl App {
    pub fn apply(&mut self, refresh: RefreshResult) {
        let selected_pid = self.processes.get(self.selected_process).map(|p| p.pid);
        self.cpu = refresh.cpu;
        self.processes = refresh.processes;
        self.gpu = refresh.gpu;
        self.ollama = refresh.ollama;
        self.memory = refresh.memory;
        self.status = refresh.errors;
        if self.status.is_empty() {
            self.status.push("Live".into());
        }
        self.sort_processes();
        self.selected_process = selected_pid
            .and_then(|pid| self.processes.iter().position(|process| process.pid == pid))
            .unwrap_or_else(|| {
                self.selected_process
                    .min(self.processes.len().saturating_sub(1))
            });
        self.selected_core = self
            .selected_core
            .min(self.cpu.cores.len().saturating_sub(1));
    }

    pub fn handle_key(&mut self, key: KeyEvent) -> bool {
        if event::is_quit(key) {
            return true;
        }
        if self.show_help {
            if matches!(key.code, KeyCode::Char('?') | KeyCode::Esc) {
                self.show_help = false;
            }
            return false;
        }
        if self.process_browser {
            match key.code {
                KeyCode::Char('p') | KeyCode::Esc => {
                    self.process_browser = false;
                    self.focus = Focus::Cpu;
                }
                KeyCode::Down | KeyCode::Char('j') => {
                    self.selected_process =
                        (self.selected_process + 1).min(self.processes.len().saturating_sub(1));
                }
                KeyCode::Up | KeyCode::Char('k') => {
                    self.selected_process = self.selected_process.saturating_sub(1)
                }
                KeyCode::Enter => {
                    self.process_browser = false;
                    self.focus = Focus::Cpu;
                }
                _ => {}
            }
            self.sort_processes();
            return false;
        }
        match key.code {
            KeyCode::Tab => {
                self.focus = match self.focus {
                    Focus::Cpu => Focus::Workload,
                    Focus::Workload => Focus::Gpu,
                    Focus::Gpu => Focus::Ollama,
                    Focus::Ollama => Focus::Cpu,
                    Focus::ProcessBrowser => Focus::Cpu,
                }
            }
            KeyCode::Char('?') => self.show_help = true,
            KeyCode::Char('c') => {
                self.cpu_view = match self.cpu_view {
                    CpuView::MatrixTiles => CpuView::MicroHeatmap,
                    CpuView::MicroHeatmap => CpuView::MatrixTiles,
                }
            }
            KeyCode::Char('p') => {
                self.process_browser = true;
                self.focus = Focus::ProcessBrowser;
            }
            KeyCode::Char('d') => self.diagnostics = !self.diagnostics,
            KeyCode::Char('s') if self.process_browser => {
                self.process_sort = match self.process_sort {
                    ProcessSort::Cpu => ProcessSort::Memory,
                    ProcessSort::Memory => ProcessSort::Pid,
                    ProcessSort::Pid => ProcessSort::Name,
                    ProcessSort::Name => ProcessSort::Cpu,
                }
            }
            KeyCode::Down | KeyCode::Char('j') if self.focus == Focus::Cpu => {
                self.selected_core =
                    (self.selected_core + 1).min(self.cpu.cores.len().saturating_sub(1));
            }
            KeyCode::Up | KeyCode::Char('k') if self.focus == Focus::Cpu => {
                self.selected_core = self.selected_core.saturating_sub(1);
            }
            KeyCode::Right if self.focus == Focus::Cpu => {
                self.selected_core =
                    (self.selected_core + 1).min(self.cpu.cores.len().saturating_sub(1));
            }
            KeyCode::Left if self.focus == Focus::Cpu => {
                self.selected_core = self.selected_core.saturating_sub(1)
            }
            KeyCode::Down | KeyCode::Char('j') if self.focus == Focus::ProcessBrowser => {
                self.selected_process =
                    (self.selected_process + 1).min(self.processes.len().saturating_sub(1))
            }
            KeyCode::Up | KeyCode::Char('k') if self.focus == Focus::ProcessBrowser => {
                self.selected_process = self.selected_process.saturating_sub(1)
            }
            KeyCode::Enter if self.focus == Focus::Cpu || self.focus == Focus::Workload => {
                self.status = vec![format!("Selected core {}", self.selected_core)]
            }
            KeyCode::Enter if self.focus == Focus::ProcessBrowser => {
                self.process_browser = false;
                self.focus = Focus::Cpu;
                self.status = vec![format!(
                    "Selected PID {}",
                    self.processes
                        .get(self.selected_process)
                        .map(|p| p.pid)
                        .unwrap_or_default()
                )]
            }
            _ => {}
        }
        self.sort_processes();
        false
    }

    fn sort_processes(&mut self) {
        match self.process_sort {
            ProcessSort::Cpu => self.processes.sort_by(|a, b| {
                b.cpu_percent
                    .unwrap_or_default()
                    .total_cmp(&a.cpu_percent.unwrap_or_default())
            }),
            ProcessSort::Memory => self
                .processes
                .sort_by_key(|p| std::cmp::Reverse(p.rss_bytes)),
            ProcessSort::Pid => self.processes.sort_by_key(|p| p.pid),
            ProcessSort::Name => self.processes.sort_by_key(|a| a.name.to_lowercase()),
        }
    }

    pub fn selected_process(&self) -> Option<&ProcessSnapshot> {
        self.processes.get(self.selected_process)
    }
}