add command line parameter to print the version

The version is defined in build.zig. We use git describe to the
the build version. For release versions we enforce that the version
in build.zig and build.zig.zon must be equal to the output of
git describe.

build.zig

@@ -1,11 +1,16 @@
 const std = @import("std");
 
-// TODO TODO
+// Must match the version in build.zig.zon
+const totp_version: std.SemanticVersion = .{ .major = 0, .minor = 1, .patch = 0, .pre = "dev" };
 
 // Although this function looks imperative, note that its job is to
 // declaratively construct a build graph that will be executed by an external
 // runner.
 pub fn build(b: *std.Build) void {
+    const version = getVersion(b);
+    const options = b.addOptions();
+    options.addOption(std.SemanticVersion, "version", version);
+
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
     // means any target is allowed, and the default is native. Other options
@@ -37,6 +42,7 @@ pub fn build(b: *std.Build) void {
         .target = target,
         .optimize = optimize,
     });
+    exe.root_module.addOptions("config", options);
 
     // This declares intent for the executable to be installed into the
     // standard location when the user invokes the "install" step (the default
@@ -91,3 +97,51 @@ pub fn build(b: *std.Build) void {
     test_step.dependOn(&run_lib_unit_tests.step);
     test_step.dependOn(&run_exe_unit_tests.step);
 }
+
+fn getVersion(b: *std.Build) std.SemanticVersion {
+    // if this is a release version , aka this is not a pre-release or build version,
+    // then use the specified version
+    if (totp_version.pre == null and totp_version.build == null) return totp_version;
+
+    // for pre-release version we use the git version
+    const args: []const []const u8 = &.{ "git", "-C", b.pathFromRoot("."), "describe", "--match", "*.*.*", "--tags" };
+    var out_code: u8 = undefined;
+    const output_untrimmed = b.runAllowFail(args, &out_code, .Ignore) catch |err| {
+        std.log.warn(
+            \\ failed to run git describe: {}
+        , .{err});
+        return totp_version;
+    };
+
+    const output_trimmed = std.mem.trim(u8, output_untrimmed, " \r\n");
+    switch (std.mem.count(u8, output_trimmed, "-")) {
+        0 => {
+            // release version, e.g. 1.0.0
+            if (!std.mem.eql(u8, output_trimmed, b.fmt("{}", .{totp_version}))) {
+                std.debug.panic("the version in build.zig and build.zig.zon must match the tag in git", .{});
+            }
+            return totp_version;
+        },
+        2 => {
+            // development version, e.g. 1.0.0-7-64es356
+            var iter = std.mem.splitScalar(u8, output_trimmed, '-');
+            const tag = iter.first();
+            const commits_since_tag = iter.next().?;
+            const commit_hash = iter.next().?;
+
+            const v: std.SemanticVersion = std.SemanticVersion.parse(tag) catch unreachable;
+
+            return .{
+                .major = v.major,
+                .minor = v.minor,
+                .patch = v.patch,
+                .pre = b.fmt("dev.{s}", .{commits_since_tag}),
+                .build = commit_hash[1..],
+            };
+        },
+        else => {
+            std.debug.print("unexpected output of git describe: '{s}'\n", .{output_untrimmed});
+            std.process.exit(1);
+        },
+    }
+}