Add @reproduce_failure support

RELEASE.md

@@ -0,0 +1,3 @@
+RELEASE_TYPE: patch
+
+Add support for @reproduce_failure and print blob.

include/hegel/json.h

@@ -47,6 +47,7 @@ namespace hegel::internal::json {
         bool is_array() const noexcept;
         bool is_object() const noexcept;
 
+        json_raw_ref& operator=(const std::string& other);
         json_raw_ref& operator=(const size_t& other);
         json_raw_ref& operator=(const double& other);
         json_raw_ref& operator=(const std::nullptr_t& other);

include/hegel/options.h

@@ -53,5 +53,9 @@ namespace hegel::options {
         std::optional<std::string> hegel_path;
 
         std::optional<uint64_t> seed;
+
+        std::optional<std::string> failure_blob;
+
+        bool print_blob;
     };
 } // namespace hegel::options

nix/flake.nix

@@ -4,7 +4,7 @@
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
     flake-compat.url = "https://flakehub.com/f/edolstra/flake-compat/1.tar.gz";
-    hegel.url = "git+https://github.com/hegeldev/hegel-core.git";
+    hegel.url = "git+https://github.com/hegeldev/hegel-core.git?dir=nix";
   };
 
   outputs =
@@ -126,6 +126,8 @@
             inputsFrom = [ self.packages.${system}.default ];
             packages = [
               pkgs.clang-tools
+              pkgs.uv
+              pkgs.just
             ];
           };
         }

src/hegel.cpp

@@ -23,6 +23,7 @@
 #include <cstdlib>
 #include <cstring>
 #include <exception>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -116,10 +117,20 @@ namespace hegel {
         } else {
             run_test_msg["seed"] = nullptr;
         }
+
+        if (options.failure_blob.has_value()) {
+            run_test_msg["failure_blob"] = options.failure_blob.value();
+        } else {
+            run_test_msg["failure_blob"] = nullptr;
+        }
+
         conn.request(0, run_test_msg);
 
         // Event loop on test channel
         bool test_passed = true;
+        std::vector<std::string> failure_blobs;
+        std::string health_check_msg;
+        std::string flaky_test_msg;
         int final_replays_remaining = 0;
         bool done = false;
         while (!done) {
@@ -194,8 +205,18 @@ namespace hegel {
                 if (payload.contains("results")) {
                     auto& results = ImplUtil::raw(payload["results"]);
                     test_passed = results.value("passed", true);
+                    health_check_msg =
+                        results.value("health_check_failure", "");
+                    flaky_test_msg = results.value("flaky", "");
                     final_replays_remaining =
                         results.value("interesting_test_cases", 0);
+                    for (const auto& blob : results["failure_blobs"]) {
+                        auto byte_sequence = blob.get_binary();
+                        std::string failure_blob_string(
+                            reinterpret_cast<const char*>(byte_sequence.data()),
+                            byte_sequence.size());
+                        failure_blobs.push_back(failure_blob_string);
+                    }
                 }
                 if (final_replays_remaining <= 0) {
                     done = true;
@@ -210,6 +231,21 @@ namespace hegel {
         waitpid(child_pid, &status, 0);
         std::filesystem::remove_all(temp_dir);
 
+        if (test_passed && options.failure_blob.has_value()) {
+            throw std::runtime_error("Failure blob did not cause a failure");
+        }
+        if (options.print_blob && !failure_blobs.empty()) {
+            std::cerr << "Failure blobs for reproduction:\n";
+            for (const auto& blob : failure_blobs) {
+                std::cerr << blob << "\n";
+            }
+        }
+        if (health_check_msg.length() > 0) {
+            std::cerr << health_check_msg << "\n";
+        }
+        if (flaky_test_msg.length() > 0) {
+            std::cerr << flaky_test_msg << "\n";
+        }
         if (!test_passed) {
             throw std::runtime_error("Hegel test failed");
         }

src/json.cpp

@@ -142,6 +142,10 @@ namespace hegel::internal::json {
 
     size_t json_raw_ref::size() const noexcept { return ref->data.size(); }
 
+    json_raw_ref& json_raw_ref::operator=(const std::string& other) {
+        ref->data = other;
+        return *this;
+    }
     json_raw_ref& json_raw_ref::operator=(const size_t& other) {
         ref->data = other;
         return *this;