feat(cli): enhance --version outputs for merod cli

Cargo.toml

@@ -32,6 +32,7 @@ members = [
     "./crates/store/impl/rocksdb",
     "./crates/store/blobs",
     "./crates/utils/actix",
+    "./crates/version",
 
     "./apps/kv-store",
 
@@ -169,6 +170,7 @@ calimero-store-rocksdb = { path = "./crates/store/impl/rocksdb" }
 calimero-blobstore = { path = "./crates/store/blobs" }
 e2e-tests = { path = "./e2e-tests" }
 calimero-utils-actix = { path = "./crates/utils/actix" }
+calimero-version = { path = "./crates/version" }
 
 kv-store = { path = "./apps/kv-store" }
 

crates/meroctl/Cargo.toml

@@ -35,6 +35,7 @@ calimero-config.workspace = true
 calimero-context-config.workspace = true
 calimero-primitives.workspace = true
 calimero-server-primitives.workspace = true
+calimero-version.workspace = true
 
 [lints]
 workspace = true

crates/meroctl/src/cli.rs

@@ -21,6 +21,7 @@ mod proxy;
 
 use app::AppCommand;
 use call::CallCommand;
+use calimero_version::CalimeroVersion;
 use context::ContextCommand;
 use peers::PeersCommand;
 use proxy::ProxyCommand;
@@ -38,7 +39,7 @@ pub const EXAMPLES: &str = r"
 ";
 
 #[derive(Debug, Parser)]
-#[command(author, version, about, long_about = None)]
+#[command(author, version = CalimeroVersion::current_str(), about, long_about = None)]
 #[command(after_help = concatcp!(
     "Environment variables:\n",
     "  CALIMERO_HOME    Directory for config and data\n\n",

crates/merod/Cargo.toml

@@ -45,6 +45,7 @@ calimero-network-primitives.workspace = true
 calimero-server = { workspace = true, features = ["jsonrpc", "websocket", "admin"] }
 calimero-store.workspace = true
 calimero-store-rocksdb.workspace = true
+calimero-version.workspace = true
 calimero-utils-actix.workspace = true
 
 [lints]

crates/merod/src/cli.rs

@@ -2,6 +2,7 @@ use camino::Utf8PathBuf;
 use clap::{Parser, Subcommand};
 use const_format::concatcp;
 use eyre::Result as EyreResult;
+use calimero_version::CalimeroVersion;
 
 use crate::defaults;
 
@@ -31,7 +32,7 @@ pub const EXAMPLES: &str = r"
 ";
 
 #[derive(Debug, Parser)]
-#[command(author, version, about, long_about = None)]
+#[command(author, version = CalimeroVersion::current_str(), about, long_about = None)]
 #[command(after_help = concatcp!(
     "Environment variables:\n",
     "  CALIMERO_HOME    Directory for config and data\n\n",

crates/version/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "calimero-version"
+version = "0.6.0"
+authors.workspace = true
+edition.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[build-dependencies]
+rustc_version = "0.4"
+eyre = "0.6"

crates/version/build.rs

@@ -0,0 +1,54 @@
+use std::process::Command;
+use eyre::{eyre, Result as EyreResult};
+
+fn main() {
+    if let Err(err) = try_main() {
+        eprintln!("build.rs error: {err}");
+        std::process::exit(1);
+    }
+}
+
+fn try_main() -> EyreResult<()> {
+    let git_describe = run_command(
+        "git",
+        &[
+            "describe",
+            "--always",
+            "--dirty=-modified",
+            "--tags",
+            "--match",
+            "[0-9]*",
+        ],
+    )?;
+
+    let git_commit = run_command("git", &["rev-parse", "--short", "HEAD"])?;
+
+    let rustc_version = rustc_version::version()
+        .map(|v| v.to_string())
+        .unwrap_or_else(|_| "unknown".to_string());
+
+    println!("cargo:rustc-env=CALIMERO_BUILD={}", git_describe.trim());
+    println!("cargo:rustc-env=CALIMERO_COMMIT={}", git_commit.trim());
+    println!(
+        "cargo:rustc-env=CALIMERO_RUSTC_VERSION={}",
+        rustc_version.trim()
+    );
+
+    Ok(())
+}
+
+fn run_command(command: &str, args: &[&str]) -> EyreResult<String> {
+    let output = Command::new(command)
+        .args(args)
+        .output()
+        .map_err(|e| eyre!("failed to execute `{}`: {}", command, e))?;
+
+    if !output.status.success() {
+        return Err(eyre!("`{}` failed with status: {}", command, output.status));
+    }
+
+    let stdout = String::from_utf8(output.stdout)
+        .map_err(|e| eyre!("invalid UTF-8 output from `{}`: {}", command, e))?;
+
+    Ok(stdout)
+}

crates/version/src/lib.rs

@@ -0,0 +1,43 @@
+use std::borrow::Cow;
+use std::fmt;
+use std::sync::LazyLock;
+
+#[cfg(test)]
+mod tests;
+
+static CURRENT: LazyLock<CalimeroVersion<'static>> = LazyLock::new(|| CalimeroVersion {
+    release: env!("CARGO_PKG_VERSION").into(),
+    build: env!("CALIMERO_BUILD").into(),
+    commit: env!("CALIMERO_COMMIT").into(),
+    rustc: env!("CALIMERO_RUSTC_VERSION").into(),
+});
+
+static CURRENT_STRING: LazyLock<String> = LazyLock::new(|| CURRENT.to_string());
+
+#[derive(Clone)]
+pub struct CalimeroVersion<'a> {
+    pub release: Cow<'a, str>,
+    pub build: Cow<'a, str>,
+    pub commit: Cow<'a, str>,
+    pub rustc: Cow<'a, str>,
+}
+
+impl CalimeroVersion<'static> {
+    pub fn current() -> Self {
+        CURRENT.clone()
+    }
+
+    pub fn current_str() -> &'static str {
+        &*CURRENT_STRING
+    }
+}
+
+impl fmt::Display for CalimeroVersion<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "(release {}) (build {}) (commit {}) (rustc {})",
+            self.release, self.build, self.commit, self.rustc,
+        )
+    }
+}

crates/version/src/tests.rs

@@ -0,0 +1,47 @@
+use crate::CalimeroVersion;
+
+#[test]
+fn version_info_contains_crate_version() {
+    let info = CalimeroVersion::current_str();
+    let expected = env!("CARGO_PKG_VERSION");
+    assert!(
+        info.contains(expected),
+        "version_info does not contain crate version: expected `{}` in `{}`",
+        expected,
+        info
+    );
+}
+
+#[test]
+fn version_info_contains_commit_hash() {
+    let info = CalimeroVersion::current_str();
+    let expected = env!("CALIMERO_COMMIT");
+    assert!(
+        info.contains(expected),
+        "version_info does not contain commit hash: expected `{}` in `{}`",
+        expected,
+        info
+    );
+}
+
+#[test]
+fn version_info_contains_rustc_version() {
+    let info = CalimeroVersion::current_str();
+    let expected = env!("CALIMERO_RUSTC_VERSION");
+    assert!(
+        info.contains(expected),
+        "version_info does not contain rustc version: expected `{}` in `{}`",
+        expected,
+        info
+    );
+}
+
+#[test]
+fn version_info_has_no_unknown_values() {
+    let info = CalimeroVersion::current_str();
+    assert!(
+        !info.contains("unknown"),
+        "version_info contains 'unknown': {}",
+        info
+    );
+}