Fix physical drive grouping logic for unified pool visualization

Updated filesystem grouping to use extract_base_device method for proper
partition-to-drive mapping. This ensures nvme0n1p1 and nvme0n1p2 are
correctly grouped under nvme0n1 drive pool instead of separate pools.

Cargo.lock

@@ -279,7 +279,7 @@ checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "cm-dashboard"
-version = "0.1.102"
+version = "0.1.108"
 dependencies = [
  "anyhow",
  "chrono",
@@ -301,7 +301,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-agent"
-version = "0.1.102"
+version = "0.1.108"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -324,7 +324,7 @@ dependencies = [
 
 [[package]]
 name = "cm-dashboard-shared"
-version = "0.1.103"
+version = "0.1.108"
 dependencies = [
  "chrono",
  "serde",

agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-agent"
-version = "0.1.103"
+version = "0.1.109"
 edition = "2021"
 
 [dependencies]

agent/src/collectors/disk.rs

@@ -419,13 +419,22 @@ impl DiskCollector {
             // Get the physical drive name for this mount point
             if let Some(devices) = self.detected_devices.get(&fs.mount_point) {
                 if let Some(device_name) = devices.first() {
-                    // Extract drive name (e.g., "nvme0n1" from "nvme0n1")
-                    let drive_name = device_name.clone();
+                    // Extract base drive name from detected device
+                    let drive_name = Self::extract_base_device(device_name)
+                        .unwrap_or_else(|| device_name.clone());
+                    
+                    debug!("Grouping filesystem {} (device: {}) under drive: {}", 
+                           fs.mount_point, device_name, drive_name);
+                    
                     grouped.entry(drive_name).or_insert_with(Vec::new).push(fs.clone());
                 }
             }
         }
         
+        debug!("Filesystem grouping result: {} drives with filesystems: {:?}", 
+               grouped.len(), 
+               grouped.keys().collect::<Vec<_>>());
+        
         Ok(grouped)
     }
 

dashboard/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard"
-version = "0.1.103"
+version = "0.1.109"
 edition = "2021"
 
 [dependencies]

dashboard/src/ui/widgets/system.rs

@@ -70,6 +70,7 @@ struct FileSystem {
     usage_percent: Option<f32>,
     used_gb: Option<f32>,
     total_gb: Option<f32>,
+    available_gb: Option<f32>,
     status: Status,
 }
 
@@ -255,15 +256,25 @@ impl SystemWidget {
                             });
 
                             if !fs_exists {
-                                // Extract actual mount point from mount_point metric if available
+                                // Create filesystem entry with correct mount point
                                 let mount_point = if metric_type == "mount_point" {
                                     if let MetricValue::String(mount) = &metric.value {
                                         mount.clone()
                                     } else {
-                                        format!("/{}", fs_name.replace('_', "/"))
+                                        // Fallback: handle special cases
+                                        if fs_name == "root" {
+                                            "/".to_string()
+                                        } else {
+                                            format!("/{}", fs_name.replace('_', "/"))
+                                        }
                                     }
                                 } else {
-                                    format!("/{}", fs_name.replace('_', "/"))
+                                    // Fallback for non-mount_point metrics: generate mount point from fs_name
+                                    if fs_name == "root" {
+                                        "/".to_string()
+                                    } else {
+                                        format!("/{}", fs_name.replace('_', "/"))
+                                    }
                                 };
 
                                 pool.filesystems.push(FileSystem {
@@ -271,6 +282,7 @@ impl SystemWidget {
                                     usage_percent: None,
                                     used_gb: None,
                                     total_gb: None,
+                                    available_gb: None,
                                     status: Status::Unknown,
                                 });
                             }
@@ -301,6 +313,11 @@ impl SystemWidget {
                                             filesystem.total_gb = Some(total);
                                         }
                                     }
+                                    "available_gb" => {
+                                        if let MetricValue::Float(available) = metric.value {
+                                            filesystem.available_gb = Some(available);
+                                        }
+                                    }
                                     "mount_point" => {
                                         if let MetricValue::String(mount) = &metric.value {
                                             filesystem.mount_point = mount.clone();
@@ -336,10 +353,17 @@ impl SystemWidget {
                     return Some(metric_name[5..drive_start].to_string()); // Skip "disk_"
                 }
             }
+            // Handle filesystem metrics: disk_{pool}_fs_{filesystem}_{metric}
+            else if metric_name.contains("_fs_") {
+                if let Some(fs_pos) = metric_name.find("_fs_") {
+                    return Some(metric_name[5..fs_pos].to_string()); // Skip "disk_", extract pool name before "_fs_"
+                }
+            }
             // For pool-level metrics (usage_percent, used_gb, total_gb), take everything before the metric suffix
             else if let Some(suffix_pos) = metric_name.rfind("_usage_percent")
                 .or_else(|| metric_name.rfind("_used_gb"))
-                .or_else(|| metric_name.rfind("_total_gb")) {
+                .or_else(|| metric_name.rfind("_total_gb"))
+                .or_else(|| metric_name.rfind("_available_gb")) {
                 return Some(metric_name[5..suffix_pos].to_string()); // Skip "disk_"
             }
             // Fallback to old behavior for unknown patterns
@@ -360,11 +384,14 @@ impl SystemWidget {
             if let Some(fs_start) = metric_name.find("_fs_") {
                 let after_fs = &metric_name[fs_start + 4..]; // Skip "_fs_"
                 
-                // Find the last underscore to separate filesystem name from metric type
-                if let Some(last_underscore) = after_fs.rfind('_') {
-                    let fs_name = after_fs[..last_underscore].to_string();
-                    let metric_type = after_fs[last_underscore + 1..].to_string();
-                    return (Some(fs_name), Some(metric_type));
+                // Look for known metric suffixes (these can contain underscores)
+                let known_suffixes = ["usage_percent", "used_gb", "total_gb", "available_gb", "mount_point"];
+                
+                for suffix in known_suffixes {
+                    if after_fs.ends_with(suffix) {
+                        let fs_name = after_fs[..after_fs.len() - suffix.len() - 1].to_string(); // Remove suffix + underscore
+                        return (Some(fs_name), Some(suffix.to_string()));
+                    }
                 }
             }
         }
@@ -535,6 +562,15 @@ impl SystemWidget {
                         (Some(pct), Some(used), Some(total)) => {
                             format!("{}: {:.0}% {:.1}GB/{:.1}GB", filesystem.mount_point, pct, used, total)
                         }
+                        (Some(pct), _, Some(total)) => {
+                            format!("{}: {:.0}% —GB/{:.1}GB", filesystem.mount_point, pct, total)
+                        }
+                        (Some(pct), _, _) => {
+                            format!("{}: {:.0}% —GB/—GB", filesystem.mount_point, pct)
+                        }
+                        (_, Some(used), Some(total)) => {
+                            format!("{}: —% {:.1}GB/{:.1}GB", filesystem.mount_point, used, total)
+                        }
                         _ => format!("{}: —% —GB/—GB", filesystem.mount_point),
                     };
 

shared/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cm-dashboard-shared"
-version = "0.1.103"
+version = "0.1.109"
 edition = "2021"
 
 [dependencies]