feat(enterprise): add comprehensive status command

Add 'status' command that displays cluster, nodes, databases, and shards
in a single view, similar to rladmin's 'status extra all' command.

Features:
- Single command shows all cluster information
- Optional section filtering (--cluster, --nodes, --databases, --shards)
- Calculates summary statistics (health, totals, active counts)
- Supports JSON, YAML, and table output formats
- Works with JMESPath queries for filtering
- Sequential API calls for simplicity and reliability

Also fixed:
- Shard.node_uid type changed from u32 to String (matches API response)

Closes #420

Author: joshrotenberg

crates/redis-enterprise/src/shards.rs

@@ -25,7 +25,7 @@ pub struct MetricResponse {
 pub struct Shard {
     pub uid: String,
     pub bdb_uid: u32,
-    pub node_uid: u32,
+    pub node_uid: String,
     pub role: String,
     pub status: String,
     #[serde(skip_serializing_if = "Option::is_none")]

crates/redisctl/src/cli.rs

@@ -1319,6 +1319,25 @@ pub enum EnterpriseCommands {
     #[command(subcommand)]
     Stats(EnterpriseStatsCommands),
 
+    /// Comprehensive cluster status (cluster, nodes, databases, shards)
+    Status {
+        /// Show only cluster information
+        #[arg(long)]
+        cluster: bool,
+
+        /// Show only nodes information
+        #[arg(long)]
+        nodes: bool,
+
+        /// Show only databases information
+        #[arg(long)]
+        databases: bool,
+
+        /// Show only shards information
+        #[arg(long)]
+        shards: bool,
+    },
+
     /// Support package generation for troubleshooting
     #[command(subcommand, name = "support-package")]
     SupportPackage(crate::commands::enterprise::support_package::SupportPackageCommands),

crates/redisctl/src/commands/enterprise/mod.rs

@@ -35,6 +35,7 @@ pub mod rbac_impl;
 pub mod services;
 pub mod shard;
 pub mod stats;
+pub mod status;
 pub mod suffix;
 pub mod support_package;
 pub mod usage_report;

crates/redisctl/src/commands/enterprise/status.rs

@@ -0,0 +1,213 @@
+//! Comprehensive status command implementation for Redis Enterprise
+//!
+//! Provides a single command to view cluster, nodes, databases, and shards status,
+//! similar to `rladmin status extra all`.
+
+use crate::cli::OutputFormat;
+use crate::connection::ConnectionManager;
+use crate::error::Result as CliResult;
+use anyhow::Context;
+use redis_enterprise::bdb::BdbHandler;
+use redis_enterprise::cluster::ClusterHandler;
+use redis_enterprise::nodes::NodeHandler;
+use redis_enterprise::shards::ShardHandler;
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+
+use super::utils::*;
+
+/// Comprehensive cluster status information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ClusterStatus {
+    /// Cluster information
+    pub cluster: Value,
+    /// List of nodes
+    pub nodes: Value,
+    /// List of databases
+    pub databases: Value,
+    /// List of shards
+    pub shards: Value,
+    /// Summary statistics
+    pub summary: StatusSummary,
+}
+
+/// Summary statistics for cluster health
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StatusSummary {
+    /// Total number of nodes
+    pub total_nodes: usize,
+    /// Number of healthy nodes
+    pub healthy_nodes: usize,
+    /// Total number of databases
+    pub total_databases: usize,
+    /// Number of active databases
+    pub active_databases: usize,
+    /// Total number of shards
+    pub total_shards: usize,
+    /// Cluster health status
+    pub cluster_health: String,
+}
+
+/// Sections to display in status output
+#[derive(Debug, Clone, Default)]
+pub struct StatusSections {
+    /// Show cluster information
+    pub cluster: bool,
+    /// Show nodes information
+    pub nodes: bool,
+    /// Show databases information
+    pub databases: bool,
+    /// Show shards information
+    pub shards: bool,
+}
+
+impl StatusSections {
+    /// Create sections showing all information
+    pub fn all() -> Self {
+        Self {
+            cluster: true,
+            nodes: true,
+            databases: true,
+            shards: true,
+        }
+    }
+
+    /// Check if any section is enabled
+    pub fn any_enabled(&self) -> bool {
+        self.cluster || self.nodes || self.databases || self.shards
+    }
+}
+
+/// Get comprehensive cluster status
+pub async fn get_status(
+    conn_mgr: &ConnectionManager,
+    profile_name: Option<&str>,
+    sections: StatusSections,
+    output_format: OutputFormat,
+    query: Option<&str>,
+) -> CliResult<()> {
+    let client = conn_mgr.create_enterprise_client(profile_name).await?;
+
+    // Use provided sections, or default to all if none specified
+    let sections = if sections.any_enabled() {
+        sections
+    } else {
+        StatusSections::all()
+    };
+
+    // Collect cluster info
+    let cluster_result = if sections.cluster {
+        ClusterHandler::new(client.clone())
+            .info()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!({})))
+            .context("Failed to get cluster info")?
+    } else {
+        json!({})
+    };
+
+    // Collect nodes
+    let nodes_result = if sections.nodes {
+        NodeHandler::new(client.clone())
+            .list()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!([])))
+            .context("Failed to list nodes")?
+    } else {
+        json!([])
+    };
+
+    // Collect databases
+    let databases_result = if sections.databases {
+        BdbHandler::new(client.clone())
+            .list()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!([])))
+            .context("Failed to list databases")?
+    } else {
+        json!([])
+    };
+
+    // Collect shards
+    let shards_result = if sections.shards {
+        ShardHandler::new(client.clone())
+            .list()
+            .await
+            .map(|v| serde_json::to_value(v).unwrap_or(json!([])))
+            .context("Failed to list shards")?
+    } else {
+        json!([])
+    };
+
+    // Calculate summary statistics
+    let summary = calculate_summary(&nodes_result, &databases_result, &shards_result);
+
+    // Build comprehensive status
+    let status = ClusterStatus {
+        cluster: cluster_result,
+        nodes: nodes_result,
+        databases: databases_result,
+        shards: shards_result,
+        summary,
+    };
+
+    let status_json = serde_json::to_value(status).context("Failed to serialize cluster status")?;
+
+    // Apply query if provided
+    let data = handle_output(status_json, output_format, query)?;
+
+    // Format and display
+    print_formatted_output(data, output_format)?;
+
+    Ok(())
+}
+
+/// Calculate summary statistics from collected data
+fn calculate_summary(nodes: &Value, databases: &Value, shards: &Value) -> StatusSummary {
+    let empty_vec = vec![];
+    let nodes_array = nodes.as_array().unwrap_or(&empty_vec);
+    let databases_array = databases.as_array().unwrap_or(&empty_vec);
+    let shards_array = shards.as_array().unwrap_or(&empty_vec);
+
+    let total_nodes = nodes_array.len();
+    let healthy_nodes = nodes_array
+        .iter()
+        .filter(|n| {
+            n.get("status")
+                .and_then(|s| s.as_str())
+                .map(|s| s == "active" || s == "ok")
+                .unwrap_or(false)
+        })
+        .count();
+
+    let total_databases = databases_array.len();
+    let active_databases = databases_array
+        .iter()
+        .filter(|db| {
+            db.get("status")
+                .and_then(|s| s.as_str())
+                .map(|s| s == "active")
+                .unwrap_or(false)
+        })
+        .count();
+
+    let total_shards = shards_array.len();
+
+    // Determine cluster health
+    let cluster_health = if healthy_nodes == total_nodes && active_databases == total_databases {
+        "healthy".to_string()
+    } else if healthy_nodes == 0 || active_databases == 0 {
+        "critical".to_string()
+    } else {
+        "degraded".to_string()
+    };
+
+    StatusSummary {
+        total_nodes,
+        healthy_nodes,
+        total_databases,
+        active_databases,
+        total_shards,
+        cluster_health,
+    }
+}

crates/redisctl/src/main.rs

@@ -479,6 +479,21 @@ async fn execute_enterprise_command(
             )
             .await
         }
+        Status {
+            cluster,
+            nodes,
+            databases,
+            shards,
+        } => {
+            let sections = commands::enterprise::status::StatusSections {
+                cluster: *cluster,
+                nodes: *nodes,
+                databases: *databases,
+                shards: *shards,
+            };
+            commands::enterprise::status::get_status(conn_mgr, profile, sections, output, query)
+                .await
+        }
         SupportPackage(support_cmd) => {
             commands::enterprise::support_package::handle_support_package_command(
                 conn_mgr,