linux-optimizer 0.1.0

// src/main.rs
mod metrics;
mod newton;

use metrics::collector::MetricsCollector;
use newton::fluxio::FluxionCalculator;
use newton::hadden::HaddenDetector;
use std::thread;
use std::time::Duration;

fn main() {
    println!("=== NEWTON LINUX OPTIMIZER ===");
    println!("Starting...\n");
    
    let mut collector = MetricsCollector::new();
    let mut fluxion_calc = FluxionCalculator::new();
    let mut hadden = HaddenDetector::new(60);
    
    let min_mem_mb = 500.0;           // 500 MB minimum before OOM
    let warn_threshold_sec = 3600.0;   // Warn only if less than 1 hour left
    
    loop {
        let metrics = collector.collect();
        
        // Clear screen for better readability
        print!("\x1B[2J\x1B[1;1H");
        
        println!("╔══════════════════════════════════════════════════════════════╗");
        println!("║              NEWTON LINUX OPTIMIZER - MONITOR               ║");
        println!("╚══════════════════════════════════════════════════════════════╝");
        println!();
        
        println!("📊 CURRENT SYSTEM STATE:");
        println!("   ┌─────────────────────────────────────────────────┐");
        println!("   │ Free RAM:     {:>8.0} MB / {:.0} MB  ({:>5.1}%) │", 
            metrics.mem_free_mb, metrics.mem_total_mb, metrics.mem_used_percent());
        println!("   │ Free Swap:    {:>8.0} MB / {:.0} MB  ({:>5.1}%) │", 
            metrics.swap_free_mb, metrics.swap_total_mb, metrics.swap_used_percent());
        println!("   │ CPU Load:             1m: {:.2}  5m: {:.2}  15m: {:.2} │", 
            metrics.cpu_load_1, metrics.cpu_load_5, metrics.cpu_load_15);
        println!("   │ Disk Free:    {:>8.1} GB / {:.1} GB             │", 
            metrics.disk_free_gb, metrics.disk_total_gb);
        println!("   └─────────────────────────────────────────────────┘");
        
        // FLUXION: Calculate memory velocity
        if let Some(velocity) = fluxion_calc.calculate_velocity(&metrics) {
            let arrow = if velocity > 0.0 { "↑ freeing" } else { "↓ consuming" };
            println!("\n📈 MEMORY FLUXION (dx/dt): {:.1} MB/s {}", velocity.abs(), arrow);
            
            // ONLY warn if memory is being CONSUMED (velocity < 0)
            // AND time to exhaustion is less than threshold (1 hour)
            if velocity < 0.0 {
                if let Some(time) = FluxionCalculator::time_to_exhaustion(
                    metrics.mem_free_mb, velocity, min_mem_mb
                ) {
                    if time < warn_threshold_sec {
                        let minutes = time / 60.0;
                        let hours = minutes / 60.0;
                        
                        println!("\n╔══════════════════════════════════════════════════════════════╗");
                        if time < 300.0 {
                            println!("║ ⚠️⚠️⚠️  CRITICAL: RAM WILL EXHAUST IN {:.0} SECONDS!          ║", time);
                        } else if time < 3600.0 {
                            println!("║ ⚠️  WARNING: RAM will exhaust in {:.1} minutes ({:.1} hours)      ║", minutes, hours);
                        }
                        println!("╚══════════════════════════════════════════════════════════════╝");
                        println!("\n💡 RECOMMENDATIONS:");
                        println!("   1. Install zram for compressed swap:");
                        println!("      → sudo apt install zram-tools");
                        println!("   2. Check memory usage: ps aux --sort=-%mem | head -20");
                        println!("   3. Close memory-intensive applications");
                    }
                }
            }
        }
        
        // HADDEN: Detect CPU peaks
        hadden.add_value(metrics.cpu_load_1);
        if let Some((severity, peak_value)) = hadden.detect_peak(5.0) {
            if severity > 2.0 {
                println!("\n🔺 CPU PEAK DETECTED!");
                println!("   Severity: {:.2}x normal load", severity);
                println!("   Peak value: {:.2}", peak_value);
                println!("   💡 Check: top -b -n1 | head -20");
            }
        }
        
        println!("\n⏎ Monitoring... (updates every 5 seconds)");
        thread::sleep(Duration::from_secs(5));
    }
}