style: apply cargo fmt

Formatted Rust code to pass CI style checks.

src/alert.rs

@@ -17,7 +17,10 @@ impl AlertSystem {
     pub fn check_cpu_alert(&mut self, cpu_percent: f32) -> bool {
         let threshold = self.config.alert_thresholds.cpu_percent;
         if cpu_percent > threshold {
-            let message = format!("CPU usage is {:.2}% (threshold: {:.2}%)", cpu_percent, threshold);
+            let message = format!(
+                "CPU usage is {:.2}% (threshold: {:.2}%)",
+                cpu_percent, threshold
+            );
             self.trigger_alert("CPU", &message);
             return true;
         }
@@ -27,7 +30,10 @@ impl AlertSystem {
     pub fn check_memory_alert(&mut self, memory_percent: f32) -> bool {
         let threshold = self.config.alert_thresholds.memory_percent;
         if memory_percent > threshold {
-            let message = format!("Memory usage is {:.2}% (threshold: {:.2}%)", memory_percent, threshold);
+            let message = format!(
+                "Memory usage is {:.2}% (threshold: {:.2}%)",
+                memory_percent, threshold
+            );
             self.trigger_alert("Memory", &message);
             return true;
         }
@@ -37,7 +43,10 @@ impl AlertSystem {
     pub fn check_disk_alert(&mut self, disk_percent: f32) -> bool {
         let threshold = self.config.alert_thresholds.disk_percent;
         if disk_percent > threshold {
-            let message = format!("Disk usage is {:.2}% (threshold: {:.2}%)", disk_percent, threshold);
+            let message = format!(
+                "Disk usage is {:.2}% (threshold: {:.2}%)",
+                disk_percent, threshold
+            );
             self.trigger_alert("Disk", &message);
             return true;
         }
@@ -45,7 +54,8 @@ impl AlertSystem {
     }
 
     fn trigger_alert(&mut self, alert_type: &str, message: &str) {
-        self.logger.log_alert(&format!("{}: {}", alert_type, message));
+        self.logger
+            .log_alert(&format!("{}: {}", alert_type, message));
         println!("\n⚠️  ALERT: {}", message);
     }
 }

src/config.rs

@@ -1,7 +1,7 @@
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use std::fs;
 use std::path::Path;
-use anyhow::Result;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {

src/main.rs

@@ -2,12 +2,12 @@ use clap::Parser;
 use std::thread;
 use std::time::Duration;
 
+mod alert;
 mod config;
+mod logger;
 mod monitor;
 mod process;
 mod temperature;
-mod alert;
-mod logger;
 
 use config::Config;
 use monitor::SystemMonitor;
@@ -41,7 +41,10 @@ fn main() {
     let mut monitor = SystemMonitor::new(config);
 
     if args.continuous {
-        log::info!("Starting continuous monitoring mode with {}s interval", args.interval);
+        log::info!(
+            "Starting continuous monitoring mode with {}s interval",
+            args.interval
+        );
         loop {
             monitor.display_stats();
             thread::sleep(Duration::from_secs(args.interval));

src/monitor.rs

@@ -1,10 +1,10 @@
+use crate::alert::AlertSystem;
 use crate::config::Config;
+use crate::logger::TrackerLogger;
 use crate::process::ProcessMonitor;
 use crate::temperature::TemperatureMonitor;
-use crate::alert::AlertSystem;
-use crate::logger::TrackerLogger;
-use sysinfo::{System, Disks, Networks};
 use chrono::Local;
+use sysinfo::{Disks, Networks, System};
 
 pub struct SystemMonitor {
     config: Config,
@@ -99,7 +99,10 @@ impl SystemMonitor {
 
     pub fn display_stats(&mut self) {
         println!("\n{}", "=".repeat(50));
-        println!("System Tracker - {}", Local::now().format("%Y-%m-%d %H:%M:%S"));
+        println!(
+            "System Tracker - {}",
+            Local::now().format("%Y-%m-%d %H:%M:%S")
+        );
         println!("{}\n", "=".repeat(50));
 
         if self.config.display.show_cpu {
@@ -111,37 +114,46 @@ impl SystemMonitor {
 
         if self.config.display.show_memory {
             let mem = self.get_memory_info();
-            println!("Memory: {:.2}% ({:.2}GB / {:.2}GB)", 
+            println!(
+                "Memory: {:.2}% ({:.2}GB / {:.2}GB)",
                 mem.percent,
                 mem.used as f64 / (1024_f64.powi(3)),
                 mem.total as f64 / (1024_f64.powi(3))
             );
-            self.logger.log_stats("Memory", &format!("{:.2}%", mem.percent));
+            self.logger
+                .log_stats("Memory", &format!("{:.2}%", mem.percent));
             self.alert_system.check_memory_alert(mem.percent);
         }
 
         if self.config.display.show_disk {
             let disk = self.get_disk_usage();
-            println!("Disk: {:.2}% ({:.2}GB / {:.2}GB)", 
+            println!(
+                "Disk: {:.2}% ({:.2}GB / {:.2}GB)",
                 disk.percent,
                 disk.used as f64 / (1024_f64.powi(3)),
                 disk.total as f64 / (1024_f64.powi(3))
             );
-            self.logger.log_stats("Disk", &format!("{:.2}%", disk.percent));
+            self.logger
+                .log_stats("Disk", &format!("{:.2}%", disk.percent));
             self.alert_system.check_disk_alert(disk.percent);
         }
 
         if self.config.display.show_network {
             let net = self.get_network_stats();
-            println!("Network: Sent {:.2}MB | Recv {:.2}MB", 
+            println!(
+                "Network: Sent {:.2}MB | Recv {:.2}MB",
                 net.bytes_sent as f64 / (1024_f64.powi(2)),
                 net.bytes_recv as f64 / (1024_f64.powi(2))
             );
-            self.logger.log_stats("Network", &format!("Sent: {} Recv: {}", net.bytes_sent, net.bytes_recv));
+            self.logger.log_stats(
+                "Network",
+                &format!("Sent: {} Recv: {}", net.bytes_sent, net.bytes_recv),
+            );
         }
 
         if self.config.display.show_processes {
-            self.process_monitor.display_processes(self.config.process_limit);
+            self.process_monitor
+                .display_processes(self.config.process_limit);
         }
 
         if self.config.display.show_temperatures {

src/process.rs

@@ -22,7 +22,9 @@ impl ProcessMonitor {
     pub fn get_top_processes(&mut self, limit: usize) -> Vec<ProcessInfo> {
         self.sys.refresh_all();
 
-        let mut processes: Vec<ProcessInfo> = self.sys.processes()
+        let mut processes: Vec<ProcessInfo> = self
+            .sys
+            .processes()
             .iter()
             .map(|(pid, process)| {
                 let total_memory = self.sys.total_memory() as f32;
@@ -57,8 +59,10 @@ impl ProcessMonitor {
         println!("{}", "-".repeat(60));
 
         for proc in self.get_top_processes(limit) {
-            println!("{:<10}{:<30}{:<10.2}{:<10.2}", 
+            println!(
-                proc.pid, proc.name, proc.cpu_percent, proc.memory_percent);
+                "{:<10}{:<30}{:<10.2}{:<10.2}",
+                proc.pid, proc.name, proc.cpu_percent, proc.memory_percent
+            );
         }
 
         println!("\nTotal Processes: {}", self.get_process_count());