fix: align build and release versioning

Author: seasonyuu

.github/workflows/ci.yml

@@ -42,6 +42,18 @@ jobs:
         with:
           target: ${{ matrix.target }}
 
+      - name: Derive build version
+        id: version
+        shell: bash
+        run: |
+          if [[ "${GITHUB_REF}" == refs/tags/* ]]; then
+            VERSION="${GITHUB_REF#refs/tags/}"
+          else
+            VERSION="${GITHUB_SHA::7}"
+          fi
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "DSVIEW_BUILD_VERSION=$VERSION" >> "$GITHUB_ENV"
+
       - name: Build workspace
         run: cargo build --release --target ${{ matrix.target }}
 
@@ -75,6 +87,6 @@ jobs:
         uses: ./.github/actions/package-and-validate
         with:
           target: ${{ matrix.target }}
-          version: v0.1.0-ci
+          version: ${{ steps.version.outputs.version }}
           exe-path: ${{ steps.exe-path.outputs.exe }}
           runtime-path: ${{ steps.find-runtime.outputs.runtime-lib }}

.github/workflows/release.yml

@@ -45,7 +45,10 @@ jobs:
       - name: Extract version from tag
         id: version
         shell: bash
-        run: echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+        run: |
+          VERSION="${GITHUB_REF#refs/tags/}"
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+          echo "DSVIEW_BUILD_VERSION=$VERSION" >> "$GITHUB_ENV"
 
       - name: Build workspace
         run: cargo build --release --target ${{ matrix.target }}
@@ -83,14 +86,6 @@ jobs:
           version: ${{ steps.version.outputs.version }}
           exe-path: ${{ steps.exe-path.outputs.exe }}
           runtime-path: ${{ steps.find-runtime.outputs.runtime-lib }}
-
-      - name: Upload release bundle
-        uses: actions/upload-artifact@v4
-        with:
-          name: dsview-cli-${{ steps.version.outputs.version }}-${{ matrix.target }}
-          path: dsview-cli-${{ steps.version.outputs.version }}-${{ matrix.target }}.tar.gz
-          retention-days: 90
-
   publish-release:
     name: publish-release
     needs: build-release

crates/dsview-cli/build.rs

@@ -0,0 +1,103 @@
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+fn main() {
+    println!("cargo:rerun-if-env-changed=DSVIEW_BUILD_VERSION");
+
+    if let Some(workspace_root) = workspace_root() {
+        emit_git_rerun_hints(&workspace_root);
+    }
+
+    let version = env::var("DSVIEW_BUILD_VERSION")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+        .or_else(detect_git_version)
+        .unwrap_or_else(|| env::var("CARGO_PKG_VERSION").expect("CARGO_PKG_VERSION should be set"));
+
+    println!("cargo:rustc-env=DSVIEW_BUILD_VERSION={version}");
+}
+
+fn workspace_root() -> Option<PathBuf> {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").ok()?);
+    manifest_dir.parent()?.parent().map(Path::to_path_buf)
+}
+
+fn emit_git_rerun_hints(workspace_root: &Path) {
+    let git_metadata = workspace_root.join(".git");
+    println!("cargo:rerun-if-changed={}", git_metadata.display());
+
+    if git_metadata.is_dir() {
+        emit_git_dir_rerun_hints(&git_metadata);
+        return;
+    }
+
+    if git_metadata.is_file() {
+        if let Ok(contents) = fs::read_to_string(&git_metadata) {
+            if let Some(git_dir) = parse_gitdir_path(&git_metadata, &contents) {
+                emit_git_dir_rerun_hints(&git_dir);
+            }
+        }
+    }
+}
+
+fn emit_git_dir_rerun_hints(git_dir: &Path) {
+    let head_path = git_dir.join("HEAD");
+    println!("cargo:rerun-if-changed={}", head_path.display());
+
+    let refs_path = git_dir.join("refs");
+    println!("cargo:rerun-if-changed={}", refs_path.display());
+
+    let packed_refs_path = git_dir.join("packed-refs");
+    println!("cargo:rerun-if-changed={}", packed_refs_path.display());
+
+    if let Ok(head_contents) = fs::read_to_string(&head_path) {
+        if let Some(reference) = head_contents.strip_prefix("ref: ") {
+            println!(
+                "cargo:rerun-if-changed={}",
+                git_dir.join(reference.trim()).display()
+            );
+        }
+    }
+}
+
+fn parse_gitdir_path(git_metadata: &Path, contents: &str) -> Option<PathBuf> {
+    let git_dir = contents.strip_prefix("gitdir: ")?.trim();
+    let git_dir_path = Path::new(git_dir);
+
+    if git_dir_path.is_absolute() {
+        Some(git_dir_path.to_path_buf())
+    } else {
+        git_metadata
+            .parent()
+            .map(|parent| parent.join(git_dir_path))
+    }
+}
+
+fn detect_git_version() -> Option<String> {
+    let workspace_root = workspace_root()?;
+
+    git_output(&workspace_root, &["describe", "--tags", "--exact-match"])
+        .or_else(|| git_output(&workspace_root, &["rev-parse", "--short", "HEAD"]))
+}
+
+fn git_output(workspace_root: &Path, args: &[&str]) -> Option<String> {
+    let output = Command::new("git")
+        .args(args)
+        .current_dir(workspace_root)
+        .output()
+        .ok()?;
+
+    if !output.status.success() {
+        return None;
+    }
+
+    let value = String::from_utf8(output.stdout).ok()?;
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}

crates/dsview-cli/src/main.rs

@@ -5,14 +5,20 @@ use std::time::Duration;
 
 use clap::{Args, Parser, Subcommand, ValueEnum};
 use dsview_core::{
-    resolve_capture_artifact_paths, AcquisitionSummary, AcquisitionTerminalEvent,
-    BringUpError, CaptureArtifactPathError, CaptureCleanup, CaptureCompletion,
-    CaptureConfigRequest, CaptureExportError, CaptureRunError, CaptureRunRequest, Discovery,
-    NativeErrorCode, RuntimeError, SelectionHandle, SupportedDevice, describe_native_error,
+    describe_native_error, resolve_capture_artifact_paths, AcquisitionSummary,
+    AcquisitionTerminalEvent, BringUpError, CaptureArtifactPathError, CaptureCleanup,
+    CaptureCompletion, CaptureConfigRequest, CaptureExportError, CaptureRunError,
+    CaptureRunRequest, Discovery, NativeErrorCode, RuntimeError, SelectionHandle, SupportedDevice,
 };
 use serde::Serialize;
 
+const BUILD_VERSION: &str = match option_env!("DSVIEW_BUILD_VERSION") {
+    Some(version) => version,
+    None => env!("CARGO_PKG_VERSION"),
+};
+
 #[derive(Parser, Debug)]
+#[command(version = BUILD_VERSION)]
 #[command(name = "dsview-cli")]
 #[command(about = "Scriptable DSLogic bring-up CLI")]
 struct Cli {
@@ -223,8 +229,10 @@ fn run_open(args: OpenArgs) -> Result<(), FailedCommand> {
 }
 
 fn run_capture(args: CaptureArgs) -> Result<(), FailedCommand> {
-    let artifact_paths = resolve_capture_artifact_paths(&args.output, args.metadata_output.as_ref())
-        .map_err(|error| command_error(args.runtime.format, classify_artifact_path_error(&error)))?;
+    let artifact_paths =
+        resolve_capture_artifact_paths(&args.output, args.metadata_output.as_ref()).map_err(
+            |error| command_error(args.runtime.format, classify_artifact_path_error(&error)),
+        )?;
     let discovery = connect_runtime(&args.runtime)?;
     let handle = SelectionHandle::new(args.handle)
         .ok_or_else(|| command_error(args.runtime.format, invalid_handle_error()))?;
@@ -239,12 +247,14 @@ fn run_capture(args: CaptureArgs) -> Result<(), FailedCommand> {
         wait_timeout: Duration::from_millis(args.wait_timeout_ms),
         poll_interval: Duration::from_millis(args.poll_interval_ms),
     };
-    let validated_config = discovery.validate_capture_config(&run_request.config).map_err(|error| {
-        command_error(
-            args.runtime.format,
-            classify_runtime_error(&RuntimeError::InvalidArgument(error.to_string())),
-        )
-    })?;
+    let validated_config = discovery
+        .validate_capture_config(&run_request.config)
+        .map_err(|error| {
+            command_error(
+                args.runtime.format,
+                classify_runtime_error(&RuntimeError::InvalidArgument(error.to_string())),
+            )
+        })?;
     let result = discovery
         .run_capture(&run_request)
         .map_err(|error| command_error(args.runtime.format, classify_capture_error(&error)))?;
@@ -255,7 +265,7 @@ fn run_capture(args: CaptureArgs) -> Result<(), FailedCommand> {
             vcd_path: artifact_paths.vcd_path,
             metadata_path: Some(artifact_paths.metadata_path),
             tool_name: env!("CARGO_PKG_NAME").to_string(),
-            tool_version: env!("CARGO_PKG_VERSION").to_string(),
+            tool_version: BUILD_VERSION.to_string(),
             capture_started_at: std::time::SystemTime::now(),
             device_model: "DSLogic Plus".to_string(),
             device_stable_id: "dslogic-plus".to_string(),
@@ -297,7 +307,10 @@ fn classify_artifact_path_error(error: &CaptureArtifactPathError) -> ErrorRespon
     match error {
         CaptureArtifactPathError::InvalidVcdExtension { path } => ErrorResponse {
             code: "capture_output_path_invalid",
-            message: format!("VCD output path `{}` must use the .vcd extension", path.display()),
+            message: format!(
+                "VCD output path `{}` must use the .vcd extension",
+                path.display()
+            ),
             detail: None,
             native_error: None,
             terminal_event: None,
@@ -726,9 +739,7 @@ pub(crate) fn capture_success_text(
     vcd_path: &str,
     metadata_path: &str,
 ) -> String {
-    format!(
-        "capture {completion}\nvcd {vcd_path}\nmetadata {metadata_path}"
-    )
+    format!("capture {completion}\nvcd {vcd_path}\nmetadata {metadata_path}")
 }
 
 fn render_error(format: OutputFormat, error: &ErrorResponse) {
@@ -997,7 +1008,10 @@ mod tests {
             completion_name(CaptureCompletion::CleanSuccess),
             "clean_success"
         );
-        assert_eq!(completion_name(CaptureCompletion::RunFailure), "run_failure");
+        assert_eq!(
+            completion_name(CaptureCompletion::RunFailure),
+            "run_failure"
+        );
         assert_eq!(completion_name(CaptureCompletion::Detached), "detach");
         assert_eq!(completion_name(CaptureCompletion::Timeout), "timeout");
     }

crates/dsview-cli/tests/devices_cli.rs

@@ -5,6 +5,22 @@ fn cli_command() -> Command {
     Command::cargo_bin("dsview-cli").expect("dsview-cli binary should build for CLI tests")
 }
 
+fn expected_build_version() -> &'static str {
+    match option_env!("DSVIEW_BUILD_VERSION") {
+        Some(version) => version,
+        None => env!("CARGO_PKG_VERSION"),
+    }
+}
+
+#[test]
+fn version_flag_reports_the_resolved_build_version() {
+    cli_command()
+        .arg("--version")
+        .assert()
+        .success()
+        .stdout(predicate::str::contains(expected_build_version()));
+}
+
 #[test]
 fn devices_help_does_not_expose_runtime_selection_flags() {
     cli_command()
@@ -25,7 +41,9 @@ fn devices_list_help_keeps_resource_override_only() {
         .assert()
         .success()
         .stdout(predicate::str::contains("--resource-dir <PATH>"))
-        .stdout(predicate::str::contains("bundled resources are used by default"))
+        .stdout(predicate::str::contains(
+            "bundled resources are used by default",
+        ))
         .stdout(predicate::str::contains("--library").not())
         .stdout(predicate::str::contains("--use-source-runtime").not());
 }
@@ -45,10 +63,17 @@ fn devices_open_help_keeps_resource_override_only() {
 #[test]
 fn devices_list_rejects_removed_library_flag() {
     cli_command()
-        .args(["devices", "list", "--library", "runtime/libdsview_runtime.so"])
+        .args([
+            "devices",
+            "list",
+            "--library",
+            "runtime/libdsview_runtime.so",
+        ])
         .assert()
         .failure()
-        .stderr(predicate::str::contains("unexpected argument '--library' found"));
+        .stderr(predicate::str::contains(
+            "unexpected argument '--library' found",
+        ));
 }
 
 #[test]