feat: Improve verbose output, add colors

Author: dialvarezs

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2024"
 anyhow = "1.0.100"
 bgzip = { version = "0.3.1", features = ["zlib-ng"] }
 clap = { version = "4.5.50", features = ["derive"] }
+console = "0.16.1"
 needletail = "0.6.3"
 rand = "0.9.2"
 uuid = { version = "1.18.1", features = ["v4"] }

Cargo.toml

@@ -1,12 +1,24 @@
 use clap::Parser;
+use clap::builder::styling::{AnsiColor, Effects, Styles};
+use console::style;
+use std::fmt::Display;
 use std::path::PathBuf;
 
+fn get_styles() -> Styles {
+    Styles::styled()
+        .header(AnsiColor::Cyan.on_default() | Effects::BOLD)
+        .usage(AnsiColor::Cyan.on_default() | Effects::BOLD)
+        .literal(AnsiColor::Green.on_default() | Effects::BOLD)
+        .placeholder(AnsiColor::Yellow.on_default())
+}
+
 #[derive(Parser)]
 #[command(
     name = "readfaker",
     version,
     about = "Simulate Oxford Nanopore reads with realistic quality profiles",
-    long_about = None
+    long_about = None,
+    styles = get_styles()
 )]
 pub struct Cli {
     /// Reference sequences (FASTA format) to sample reads from
@@ -22,7 +34,7 @@ pub struct Cli {
     pub output: PathBuf,
 
     /// Number of reads to generate
-    #[arg(short = 'n', long, default_value = "10000")]
+    #[arg(short = 'n', long, default_value = "100000")]
     pub num_reads: usize,
 
     /// Random seed for reproducibility
@@ -33,3 +45,29 @@ pub struct Cli {
     #[arg(short, long)]
     pub verbose: bool,
 }
+
+/// Formatting utilities for console output
+pub mod fmt {
+    use super::*;
+
+    pub fn header(text: impl Display) -> String {
+        style(text).bold().cyan().to_string()
+    }
+
+    pub fn param(text: impl Display) -> String {
+        style(text).bold().to_string()
+    }
+
+    /// Format a parameter with proper alignment (width must account for raw text length)
+    pub fn param_aligned(text: &str, width: usize) -> String {
+        format!("{:<width$}", style(text).bold(), width = width + style(text).to_string().len() - text.len())
+    }
+
+    pub fn progress(text: impl Display) -> String {
+        format!("{} {}", style("→").cyan(), style(text).dim())
+    }
+
+    pub fn success(text: impl Display) -> String {
+        format!("{} {}", style("✓").green().bold(), style(text).green())
+    }
+}

src/cli.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use clap::Parser;
-use readfaker::cli::Cli;
+use readfaker::cli::{fmt, Cli};
 use readfaker::generator::ReadGenerator;
 use readfaker::io::{FastaReader, FastqWriter};
 use readfaker::models::ErrorModel;
@@ -10,18 +10,22 @@ fn main() -> Result<()> {
     let cli = Cli::parse();
 
     if cli.verbose {
-        eprintln!("=== ReadFaker Configuration ===");
-        eprintln!("Reference: {}", cli.reference.display());
-        eprintln!("Input: {}", cli.input.display());
-        eprintln!("Output: {}", cli.output.display());
-        eprintln!("Number of reads: {}", cli.num_reads);
+        eprintln!("{}", fmt::header("ReadFaker Configuration"));
+        eprintln!("{}: {}", fmt::param_aligned("Reference", 16), cli.reference.display());
+        eprintln!("{}: {}", fmt::param_aligned("Input", 16), cli.input.display());
+        eprintln!("{}: {}", fmt::param_aligned("Output", 16), cli.output.display());
+        eprintln!("{}: {}", fmt::param_aligned("Number of reads", 16), cli.num_reads);
         if let Some(seed) = cli.seed {
-            eprintln!("Random seed: {}", seed);
+            eprintln!("{}: {}", fmt::param_aligned("Random seed", 16), seed);
         }
-        eprintln!("================================\n");
+        eprintln!();
     }
 
+    if cli.verbose {
+        eprintln!("{}", fmt::progress("Creating models from input FASTQ..."));
+    }
     let (length_model, quality_model) = load_models(&cli.input, cli.seed)?;
+
     let error_model = ErrorModel::new(None, None, None)?;
     let mut generator = ReadGenerator::new(
         FastaReader::read(&cli.reference)?,
@@ -32,10 +36,18 @@ fn main() -> Result<()> {
     )?;
     let mut writer = FastqWriter::new(&cli.output)?;
 
+    if cli.verbose {
+        eprintln!("{}", fmt::progress(format!("Generating {} reads...", cli.num_reads)));
+    }
+
     for _ in 0..cli.num_reads {
         let read = generator.generate_read()?;
         writer.write_record(&read)?;
     }
 
+    if cli.verbose {
+        eprintln!("{}", fmt::success(format!("Output written to {}", cli.output.display())));
+    }
+
     Ok(())
 }

src/main.rs

@@ -196,15 +196,15 @@ mod tests {
         let mut rng = StdRng::seed_from_u64(42);
 
         // Add quality strings at different lengths
-        model.add_value(50, vec![b'A'; 50], &mut rng);    // Bucket 0 (0-99)
-        model.add_value(150, vec![b'B'; 150], &mut rng);  // Bucket 1 (100-199)
-        model.add_value(350, vec![b'C'; 350], &mut rng);  // Bucket 3 (300-399)
+        model.add_value(50, vec![b'A'; 50], &mut rng); // Bucket 0 (0-99)
+        model.add_value(150, vec![b'B'; 150], &mut rng); // Bucket 1 (100-199)
+        model.add_value(350, vec![b'C'; 350], &mut rng); // Bucket 3 (300-399)
         model.add_value(25000, vec![b'D'; 25000], &mut rng); // Catch-all bucket
 
         // Verify buckets contain the expected reads
-        assert_eq!(model.batches[0].qualities.len(), 1);   // Bucket 0 has 1 read
-        assert_eq!(model.batches[1].qualities.len(), 1);   // Bucket 1 has 1 read
-        assert_eq!(model.batches[3].qualities.len(), 1);   // Bucket 3 has 1 read
+        assert_eq!(model.batches[0].qualities.len(), 1); // Bucket 0 has 1 read
+        assert_eq!(model.batches[1].qualities.len(), 1); // Bucket 1 has 1 read
+        assert_eq!(model.batches[3].qualities.len(), 1); // Bucket 3 has 1 read
         assert_eq!(model.batches.last().unwrap().qualities.len(), 1); // Catch-all has 1 read
     }