corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CoreKind {
    Performance,
    Efficiency,
    LowPowerEfficiency,
    Homogeneous,
    Unknown,
}

impl CoreKind {
    pub fn short_name(self) -> &'static str {
        match self {
            Self::Performance => "P",
            Self::Efficiency => "E",
            Self::LowPowerEfficiency => "LPE",
            Self::Homogeneous => "CPU",
            Self::Unknown => "?",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DetectionSource {
    KernelMetadata,
    #[allow(dead_code)]
    Cpuid,
    Capacity,
    FrequencyHeuristic,
    Unsupported,
}

impl DetectionSource {
    pub fn label(self) -> &'static str {
        match self {
            Self::KernelMetadata => "kernel",
            Self::Cpuid => "cpuid",
            Self::Capacity => "capacity heuristic",
            Self::FrequencyHeuristic => "frequency heuristic",
            Self::Unsupported => "unknown",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CoreKindDetection {
    pub kind: CoreKind,
    pub source: DetectionSource,
    pub confidence_percent: u8,
}

#[derive(Debug, Clone)]
pub struct LogicalCpu {
    pub logical_id: u32,
    pub core_id: Option<u32>,
    pub die_id: Option<u32>,
    pub package_id: Option<u32>,
    pub siblings: Vec<u32>,
    pub core_kind: CoreKind,
    pub detection: CoreKindDetection,
    pub utilization: Option<f64>,
    pub current_frequency_khz: Option<u64>,
    pub max_frequency_khz: Option<u64>,
    pub temperature_celsius: Option<f64>,
}

#[derive(Debug, Clone)]
pub struct PhysicalCore {
    pub package_id: Option<u32>,
    pub die_id: Option<u32>,
    pub core_id: Option<u32>,
    pub logical_cpus: Vec<u32>,
}

#[derive(Debug, Clone, Default)]
pub struct TopologyDiagnostics {
    pub online_logical_cpus: usize,
    pub assigned_logical_cpus: usize,
    pub duplicate_assignments: usize,
    pub missing_assignments: usize,
    pub physical_core_count: usize,
    pub performance_core_count: usize,
    pub efficiency_core_count: usize,
    pub unknown_core_count: usize,
}

impl TopologyDiagnostics {
    pub fn has_mismatch(&self) -> bool {
        self.duplicate_assignments > 0
            || self.missing_assignments > 0
            || self.online_logical_cpus != self.assigned_logical_cpus
    }
}

#[derive(Debug, Clone, Default)]
pub struct CpuTopology {
    pub cpus: Vec<LogicalCpu>,
    pub cores: Vec<PhysicalCore>,
    pub diagnostics: TopologyDiagnostics,
}