Refactor codebase to modular architecture with multi-format output

- Migrate from structopt to clap v4 for argument parsing
- Add JSON and CSV output formats alongside text
- Introduce trait-based GPU abstraction (GpuDevice, GpuManager)
- Create comprehensive GpuMetrics struct with all NVML metrics
- Add structured error handling with GpuError enum
- Update dependencies (nvml-wrapper 0.10, sysinfo 0.32, serde)
- Expose library crate for programmatic use
- Bump version to 0.2.0 and edition to 2021

Author: BDHU

Cargo.toml

@@ -1,29 +1,33 @@
 [package]
 name = "gpuinfo"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Edward Hu <bodunhu@utexas.edu>"]
-edition = "2018"
+edition = "2021"
 license = "MIT"
 description = "A minimal command-line utility for querying GPU status"
 homepage = "https://github.com/BDHU/gpuinfo"
 repository = "https://github.com/BDHU/gpuinfo"
 readme = "README.md"
 keywords = ["rust", "gpu", "nvidia-smi", "command-line", "monitoring"]
-categories = ["command-line-utilities", "gpu"]
+categories = ["command-line-utilities"]
 exclude = ["*.png", "*.jpg"]
 
 [[bin]]
 name = "gpu-info"
 path = "src/main.rs"
 
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "gpuinfo"
+path = "src/lib.rs"
 
 [dependencies]
-structopt = "^0.3"
-nvml-wrapper = "^0.7.0"
-nvml-wrapper-sys = "^0.5.0"
-sysinfo = "^0.19.0"
+clap = { version = "4", features = ["derive"] }
+nvml-wrapper = "0.10"
+sysinfo = "0.32"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+atty = "0.2"
 
 [profile.release]
 opt-level = "s"
+lto = true

README.md

@@ -9,22 +9,38 @@ A small command-line tool used to query and monitor GPU status.
 
 ![gpuinfo-screenshot](gpuinfo.png)
 
-NOTE: We only support NVIDIA GPU currently, AMD GPU is not yet supported. All contributions are welcome! This is an ongoing project and there might be changes in the future. The tool is tested on Linux. It might also work on macOS and Windows with some features missing.
+NOTE: We only support NVIDIA GPUs currently. All contributions are welcome! This is an ongoing project and there might be changes in the future. The tool is tested on Linux. It might also work on macOS and Windows with some features missing.
 
 Usage
 -----
 
-
 ```bash
 $ gpu-info
 ```
 
-Options:
+Common options:
 
 * `-w`, `--watch`: Prints GPU information to terminal every second
-* `-i`, `--interval <interval>`: Prints GPU information to terminal according to given interval (integer seconds)
+* `-i`, `--interval <seconds>`: Prints GPU information to terminal at the given interval
+* `-f`, `--format <text|json|csv>`: Output format (default: text)
+* `--no-color`: Disable ANSI colors in text output
+* `--no-header`: Disable CSV header row
+* `-g`, `--gpu <index>`: Select a specific GPU by index
+* `-v`, `--verbose`: Verbose output (text)
+* `-q`, `--quiet`: Minimal output (text)
+
+Examples:
+
+```bash
+# Watch with default text output
+gpu-info --watch
+
+# Output JSON for tooling
+gpu-info --format json
 
-NOTE: more options are to be added.
+# Output CSV without a header (useful for appending)
+gpu-info --format csv --no-header
+```
 
 Installation
 ------------
@@ -38,15 +54,27 @@ cargo install gpuinfo
 Output
 ------
 
-> [0]: Tesla P100-SXM2-16GB | 60 |   0 % |  1544 / 16280 MB |  37°C | No running processes found
+Text output (default):
+
+> [0] RTX 4090 | SM8.9 |  12% |  2048/24576MB |  45C | Fan:30% | 120/450W | 2100MHz/10500MHz | Gen4x16 | python:512MB
+
+* `[0]`: GPU index
+* `RTX 4090`: GPU name
+* `SM8.9`: Compute capability
+* `12%`: GPU utilization
+* `2048/24576MB`: Memory used/total
+* `45C`: Temperature
+* `Fan:30%`: Fan speed (if available)
+* `120/450W`: Power usage/limit (if available)
+* `2100MHz/10500MHz`: Graphics/memory clocks (if available)
+* `Gen4x16`: PCIe link info (if available)
+* `python:512MB`: Running processes and their GPU memory use
 
-* `[0]`: PCI_BUS_ID of the GPU. Beware that CUDA might assign different device ID. Ensure `CUDA_DEVICE_ORDER` is assigned `PCI_BUS_ID` will guarantee both `gpu-info` and CUDA yield the same result
-* `Tesla P100-SXM2-16GB`: Name of the GPU
-* `60`: Major and minor number of the GPU
-* `0 %`: Current GPU utilization rate
-* `1544 / 16280 MB`: GPU device memory usage
-* `37°C`: GPU temperature
-* `No running processes found`: Currently running processes on the GPU (note: only processes the user have privilege to access are shown).
+CSV output (with header by default):
+
+```text
+index,name,uuid,gpu_util%,mem_util%,mem_used_mb,mem_total_mb,temp_c,power_w,power_limit_w,clock_graphics_mhz,clock_memory_mhz,fan%,pcie_gen,pcie_width,process_count
+```
 
 License
 -------

src/argparse.rs

@@ -1,18 +1,77 @@
-use structopt::StructOpt;
+use clap::{Parser, ValueEnum};
 
-#[derive(Debug, StructOpt)]
-#[structopt(name = "gpu-info", about = "A list of command line flags.")]
+/// Output format options
+#[derive(Debug, Clone, Copy, ValueEnum, Default)]
+pub enum OutputFormat {
+    /// Human-readable text with optional colors
+    #[default]
+    Text,
+    /// JSON format for programmatic consumption
+    Json,
+    /// CSV format for spreadsheets and data analysis
+    Csv,
+}
+
+/// A minimal command-line utility for querying GPU status
+#[derive(Debug, Parser)]
+#[command(
+    name = "gpu-info",
+    about = "A command-line GPU monitoring utility",
+    version,
+    author
+)]
 pub struct Opt {
-    /// Prints GPU information to terminal every second
-    #[structopt(short = "w", long = "watch", about = "watch over updated metrics.")]
+    /// Watch mode: refresh every second
+    #[arg(short = 'w', long = "watch", conflicts_with = "interval")]
     pub watch: bool,
 
-    /// Prints GPU information to terminal according to given interval (seconds)
-    #[structopt(short = "i", long = "interval", about = "updated metrics based on given interval.")]
+    /// Refresh interval in seconds
+    #[arg(
+        short = 'i',
+        long = "interval",
+        value_name = "SECONDS",
+        conflicts_with = "watch"
+    )]
     pub interval: Option<u64>,
+
+    /// Output format (text, json, csv)
+    #[arg(short = 'f', long = "format", value_enum, default_value = "text")]
+    pub format: OutputFormat,
+
+    /// Disable colored output
+    #[arg(long = "no-color")]
+    pub no_color: bool,
+
+    /// Disable CSV header row
+    #[arg(long = "no-header")]
+    pub no_header: bool,
+
+    /// Select specific GPU by index
+    #[arg(short = 'g', long = "gpu", value_name = "INDEX")]
+    pub gpu_index: Option<u32>,
+
+    /// Show verbose output with all available metrics
+    #[arg(short = 'v', long = "verbose")]
+    pub verbose: bool,
+
+    /// Quiet mode: minimal output
+    #[arg(short = 'q', long = "quiet", conflicts_with = "verbose")]
+    pub quiet: bool,
 }
 
-pub fn argparse() -> Opt {
-    let opt = Opt::from_args();
-    return opt;
-}
+impl Opt {
+    /// Parse command line arguments
+    pub fn parse_args() -> Self {
+        Opt::parse()
+    }
+}
+
+impl From<OutputFormat> for crate::output::OutputFormat {
+    fn from(value: OutputFormat) -> Self {
+        match value {
+            OutputFormat::Text => crate::output::OutputFormat::Text,
+            OutputFormat::Json => crate::output::OutputFormat::Json,
+            OutputFormat::Csv => crate::output::OutputFormat::Csv,
+        }
+    }
+}

src/device/mod.rs

@@ -0,0 +1,57 @@
+pub mod nvidia;
+
+use crate::error::GpuError;
+use crate::metrics::GpuMetrics;
+
+/// Trait for GPU device implementations
+///
+/// This trait provides a vendor-agnostic interface for querying GPU metrics.
+/// Each GPU vendor (NVIDIA, AMD, Intel) would implement this trait.
+pub trait GpuDevice: Send + Sync {
+    /// Collect all available metrics from the device
+    ///
+    /// Metrics that are unavailable will be set to None.
+    fn collect_metrics(&self) -> Result<GpuMetrics, GpuError>;
+
+    /// Get the device index (0, 1, 2, ...)
+    fn index(&self) -> u32;
+
+    /// Get the vendor name (e.g., "NVIDIA", "AMD", "Intel")
+    fn vendor(&self) -> &'static str;
+}
+
+/// Trait for GPU manager implementations
+///
+/// A manager handles initialization and enumeration of GPU devices
+/// for a specific vendor.
+pub trait GpuManager: Send + Sync {
+    /// Initialize the GPU manager
+    ///
+    /// This typically loads the vendor's management library.
+    fn init() -> Result<Self, GpuError>
+    where
+        Self: Sized;
+
+    /// Get the number of GPU devices available
+    fn device_count(&self) -> Result<u32, GpuError>;
+
+    /// Get a device by its index
+    fn device(&self, index: u32) -> Result<Box<dyn GpuDevice + '_>, GpuError>;
+
+    /// Collect metrics from all devices
+    fn collect_all_metrics(&self) -> Result<Vec<GpuMetrics>, GpuError> {
+        let count = self.device_count()?;
+        let mut metrics = Vec::with_capacity(count as usize);
+        for i in 0..count {
+            let device = self.device(i)?;
+            metrics.push(device.collect_metrics()?);
+        }
+        Ok(metrics)
+    }
+
+    /// Get the driver version
+    fn driver_version(&self) -> Result<String, GpuError>;
+
+    /// Get the CUDA version (for NVIDIA) or equivalent
+    fn cuda_version(&self) -> Result<String, GpuError>;
+}