libvirt: Standardize table output with comfy_table, add JSON format support

Replace manual printf-style table formatting with comfy_table for consistent,
well-formatted output across all list commands. Add --format=json support to
base-disks list command to match the pattern used by other list commands,
enabling machine-readable output for integration and scripting.

Assisted-By: Claude Code
Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

crates/kit/src/libvirt/base_disks.rs

@@ -363,7 +363,7 @@ pub fn list_base_disks(connect_uri: Option<&String>) -> Result<Vec<BaseDiskInfo>
 }
 
 /// Information about a base disk
-#[derive(Debug)]
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct BaseDiskInfo {
     pub path: Utf8PathBuf,
     pub image_digest: Option<String>,

crates/kit/src/libvirt/base_disks_cli.rs

@@ -5,8 +5,11 @@
 
 use clap::{Parser, Subcommand};
 use color_eyre::Result;
+use comfy_table::{presets::UTF8_FULL, Table};
+use serde_json;
 
 use super::base_disks::{list_base_disks, prune_base_disks};
+use super::OutputFormat;
 
 /// Options for base-disks command
 #[derive(Debug, Parser)]
@@ -19,11 +22,19 @@ pub struct LibvirtBaseDisksOpts {
 #[derive(Debug, Subcommand)]
 pub enum BaseDisksSubcommand {
     /// List all base disk images
-    List,
+    List(ListOpts),
     /// Prune unreferenced base disk images
     Prune(PruneOpts),
 }
 
+/// Options for list command
+#[derive(Debug, Parser)]
+pub struct ListOpts {
+    /// Output format
+    #[clap(long, value_enum, default_value_t = OutputFormat::Table)]
+    pub format: OutputFormat,
+}
+
 /// Options for prune command
 #[derive(Debug, Parser)]
 pub struct PruneOpts {
@@ -37,59 +48,69 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtBaseDisksO
     let connect_uri = global_opts.connect.as_ref();
 
     match opts.command {
-        BaseDisksSubcommand::List => run_list(connect_uri),
+        BaseDisksSubcommand::List(list_opts) => run_list(connect_uri, list_opts),
         BaseDisksSubcommand::Prune(prune_opts) => run_prune(connect_uri, prune_opts),
     }
 }
 
 /// Execute the list subcommand
-fn run_list(connect_uri: Option<&String>) -> Result<()> {
+fn run_list(connect_uri: Option<&String>, opts: ListOpts) -> Result<()> {
     let base_disks = list_base_disks(connect_uri)?;
 
-    if base_disks.is_empty() {
-        println!("No base disk images found");
-        return Ok(());
+    match opts.format {
+        OutputFormat::Table => {
+            if base_disks.is_empty() {
+                println!("No base disk images found");
+                return Ok(());
+            }
+
+            let mut table = Table::new();
+            table.load_preset(UTF8_FULL);
+            table.set_header(vec!["NAME", "SIZE", "REFS", "IMAGE DIGEST"]);
+
+            for disk in &base_disks {
+                let name = disk.path.file_name().unwrap_or("unknown");
+
+                let size = disk
+                    .size
+                    .map(|bytes| indicatif::BinaryBytes(bytes).to_string())
+                    .unwrap_or_else(|| "unknown".to_string());
+
+                let refs = disk.ref_count.to_string();
+
+                let digest = disk
+                    .image_digest
+                    .as_ref()
+                    .map(|d| {
+                        // Truncate long digests for display
+                        if d.len() > 56 {
+                            format!("{}...", &d[..53])
+                        } else {
+                            d.clone()
+                        }
+                    })
+                    .unwrap_or_else(|| "<no metadata>".to_string());
+
+                table.add_row(vec![name, &size, &refs, &digest]);
+            }
+
+            println!("{}", table);
+            println!(
+                "\nFound {} base disk{}",
+                base_disks.len(),
+                if base_disks.len() == 1 { "" } else { "s" }
+            );
+        }
+        OutputFormat::Json => {
+            println!("{}", serde_json::to_string_pretty(&base_disks)?);
+        }
+        OutputFormat::Yaml => {
+            return Err(color_eyre::eyre::eyre!(
+                "YAML format is not supported for base-disks list command"
+            ))
+        }
     }
 
-    // Print table header
-    println!(
-        "{:<40} {:<10} {:<10} {:<58}",
-        "NAME", "SIZE", "REFS", "IMAGE DIGEST"
-    );
-    println!("{}", "=".repeat(118));
-
-    for disk in &base_disks {
-        let name = disk.path.file_name().unwrap_or("unknown");
-
-        let size = disk
-            .size
-            .map(|bytes| indicatif::BinaryBytes(bytes).to_string())
-            .unwrap_or_else(|| "unknown".to_string());
-
-        let refs = disk.ref_count.to_string();
-
-        let digest = disk
-            .image_digest
-            .as_ref()
-            .map(|d| {
-                // Truncate long digests for display
-                if d.len() > 56 {
-                    format!("{}...", &d[..53])
-                } else {
-                    d.clone()
-                }
-            })
-            .unwrap_or_else(|| "<no metadata>".to_string());
-
-        println!("{:<40} {:<10} {:<10} {:<58}", name, size, refs, digest);
-    }
-
-    println!(
-        "\nFound {} base disk{}",
-        base_disks.len(),
-        if base_disks.len() == 1 { "" } else { "s" }
-    );
-
     Ok(())
 }
 

crates/kit/src/libvirt/inspect.rs

@@ -6,15 +6,17 @@
 use clap::Parser;
 use color_eyre::Result;
 
+use super::OutputFormat;
+
 /// Options for inspecting a libvirt domain
 #[derive(Debug, Parser)]
 pub struct LibvirtInspectOpts {
     /// Name of the domain to inspect
     pub name: String,
 
     /// Output format
-    #[clap(long, default_value = "yaml")]
-    pub format: String,
+    #[clap(long, value_enum, default_value_t = OutputFormat::Yaml)]
+    pub format: OutputFormat,
 }
 
 /// Execute the libvirt inspect command
@@ -33,8 +35,8 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtInspectOpt
         .get_domain_info(&opts.name)
         .map_err(|_| color_eyre::eyre::eyre!("VM '{}' not found", opts.name))?;
 
-    match opts.format.as_str() {
-        "yaml" => {
+    match opts.format {
+        OutputFormat::Yaml => {
             println!("name: {}", vm.name);
             if let Some(ref image) = vm.image {
                 println!("image: {}", image);
@@ -50,17 +52,16 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtInspectOpt
                 println!("disk_path: {}", disk_path);
             }
         }
-        "json" => {
+        OutputFormat::Json => {
             println!(
                 "{}",
                 serde_json::to_string_pretty(&vm)
                     .with_context(|| "Failed to serialize VM as JSON")?
             );
         }
-        _ => {
+        OutputFormat::Table => {
             return Err(color_eyre::eyre::eyre!(
-                "Unsupported format: {}",
-                opts.format
+                "Table format is not supported for inspect command"
             ))
         }
     }

crates/kit/src/libvirt/list.rs

@@ -5,13 +5,16 @@
 
 use clap::Parser;
 use color_eyre::Result;
+use comfy_table::{presets::UTF8_FULL, Table};
+
+use super::OutputFormat;
 
 /// Options for listing libvirt domains
 #[derive(Debug, Parser)]
 pub struct LibvirtListOpts {
     /// Output format
-    #[clap(long, default_value = "table")]
-    pub format: String,
+    #[clap(long, value_enum, default_value_t = OutputFormat::Table)]
+    pub format: OutputFormat,
 
     /// Show all domains including stopped ones
     #[clap(long, short = 'a')]
@@ -40,8 +43,8 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtListOpts)
             .with_context(|| "Failed to list running bootc domains from libvirt")?
     };
 
-    match opts.format.as_str() {
-        "table" => {
+    match opts.format {
+        OutputFormat::Table => {
             if domains.is_empty() {
                 if opts.all {
                     println!("No VMs found");
@@ -54,11 +57,11 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtListOpts)
                 }
                 return Ok(());
             }
-            println!(
-                "{:<20} {:<40} {:<12} {:<20}",
-                "NAME", "IMAGE", "STATUS", "MEMORY"
-            );
-            println!("{}", "=".repeat(92));
+
+            let mut table = Table::new();
+            table.load_preset(UTF8_FULL);
+            table.set_header(vec!["NAME", "IMAGE", "STATUS", "MEMORY"]);
+
             for domain in &domains {
                 let image = match &domain.image {
                     Some(img) => {
@@ -74,31 +77,26 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtListOpts)
                     Some(mem) => format!("{}MB", mem),
                     None => "unknown".to_string(),
                 };
-                println!(
-                    "{:<20} {:<40} {:<12} {:<20}",
-                    domain.name,
-                    image,
-                    domain.status_string(),
-                    memory
-                );
+                table.add_row(vec![&domain.name, &image, &domain.status_string(), &memory]);
             }
+
+            println!("{}", table);
             println!(
                 "\nFound {} domain{} (source: libvirt)",
                 domains.len(),
                 if domains.len() == 1 { "" } else { "s" }
             );
         }
-        "json" => {
+        OutputFormat::Json => {
             println!(
                 "{}",
                 serde_json::to_string_pretty(&domains)
                     .with_context(|| "Failed to serialize domains as JSON")?
             );
         }
-        _ => {
+        OutputFormat::Yaml => {
             return Err(color_eyre::eyre::eyre!(
-                "Unsupported format: {}",
-                opts.format
+                "YAML format is not supported for list command"
             ))
         }
     }

crates/kit/src/libvirt/mod.rs

@@ -8,6 +8,15 @@
 
 use clap::Subcommand;
 
+/// Output format options for libvirt commands
+#[derive(Debug, Clone, clap::ValueEnum)]
+#[clap(rename_all = "kebab-case")]
+pub enum OutputFormat {
+    Table,
+    Json,
+    Yaml,
+}
+
 /// Default memory allocation for libvirt VMs
 pub const LIBVIRT_DEFAULT_MEMORY: &str = "4G";