Publish harness and TUI open-source

initial sync from the monorepo

crates/codegen/xai-tracing-macros/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+license = "Apache-2.0"
+name = "xai-tracing-macros"
+version = "0.1.0"
+edition.workspace = true
+description = "Tracing-based utility macros for timestamped logging and timing"
+
+[dependencies]
+
+[lints]
+workspace = true

crates/codegen/xai-tracing-macros/src/lib.rs

@@ -0,0 +1,31 @@
+//! Tracing-based utility macros.
+//!
+//! This crate provides macros for:
+//! - Timestamped logging (`tprintln!`, `teprintln!`)
+//! - Execution timing with automatic logging (`timed!`)
+//!
+//! # Examples
+//!
+//! ```ignore
+//! use xai_tracing_macros::{tprintln, teprintln, timed};
+//!
+//! // Timestamped logging
+//! tprintln!("Hello, world!");
+//! teprintln!("Warning: something happened");
+//!
+//! // Execution timing
+//! let result = timed!(log: "expensive_operation", {
+//!     // ... expensive work ...
+//!     42
+//! });
+//!
+//! // Timing with Result handling
+//! let result: Result<i32, String> = timed!(try: "fallible_operation", {
+//!     Ok(42)
+//! });
+//! ```
+
+mod timed;
+mod timestamp;
+
+// Macros are automatically exported at crate root via #[macro_export]

crates/codegen/xai-tracing-macros/src/timed.rs

@@ -0,0 +1,117 @@
+//! Macros for measuring and logging execution time.
+
+/// Measure and optionally log execution time of a block.
+///
+/// # Variants
+///
+/// - `timed!({ ... })` - Returns `(value, elapsed_ms)` tuple
+/// - `timed!(log: "name", { ... })` - Logs at debug level, returns value
+/// - `timed!(log: info, "name", { ... })` - Logs at specified level, returns value
+/// - `timed!(try: "name", { ... })` - For sync Result blocks, logs and returns Result
+/// - `timed!(try: info, "name", { ... })` - For sync Result blocks with level
+/// - `timed!(try: "name", async { ... })` - For async Result blocks
+/// - `timed!(try: info, "name", async { ... })` - For async Result blocks with level
+#[macro_export]
+macro_rules! timed {
+    (@log_ok $lvl:ident, $name:expr, $elapsed_ms:expr) => {{
+        ::tracing::$lvl!(elapsed_ms = $elapsed_ms as u64, "{}", $name);
+    }};
+    (@log_err $lvl:ident, $name:expr, $elapsed_ms:expr, $err:expr) => {{
+        ::tracing::$lvl!(elapsed_ms = $elapsed_ms as u64, error = ?$err, "{}", $name);
+    }};
+
+    ($block:block) => {{
+        let start = ::std::time::Instant::now();
+        let value = $block;
+        let elapsed_ms = start.elapsed().as_millis();
+        (value, elapsed_ms)
+    }};
+
+    (log: $name:expr, $block:block) => {{
+        let start = ::std::time::Instant::now();
+        let value = $block;
+        let elapsed_ms = start.elapsed().as_millis();
+        $crate::timed!(@log_ok debug, $name, elapsed_ms);
+        value
+    }};
+
+    // Logging-only variant with explicit log level:
+    // `timed!(log: info, "something", { ... })`
+    (log: $lvl:ident, $name:expr, $block:block) => {{
+        let start = ::std::time::Instant::now();
+        let value = $block;
+        let elapsed_ms = start.elapsed().as_millis();
+        $crate::timed!(@log_ok $lvl, $name, elapsed_ms);
+        value
+    }};
+
+    // Sync Result variant (no `.await` inside the block)
+    (try: $name:expr, $block:block) => {{
+        let start = ::std::time::Instant::now();
+        let result = (|| $block)();
+        let elapsed_ms = start.elapsed().as_millis();
+        match result {
+            Ok(value) => {
+                $crate::timed!(@log_ok debug, $name, elapsed_ms);
+                Ok(value)
+            }
+            Err(err) => {
+                $crate::timed!(@log_err debug, $name, elapsed_ms, err);
+                Err(err)
+            }
+        }
+    }};
+
+    // Sync Result variant with explicit log level:
+    // `timed!(try: info, "something", { ... })?`
+    (try: $lvl:ident, $name:expr, $block:block) => {{
+        let start = ::std::time::Instant::now();
+        let result = (|| $block)();
+        let elapsed_ms = start.elapsed().as_millis();
+        match result {
+            Ok(value) => {
+                $crate::timed!(@log_ok $lvl, $name, elapsed_ms);
+                Ok(value)
+            }
+            Err(err) => {
+                $crate::timed!(@log_err $lvl, $name, elapsed_ms, err);
+                Err(err)
+            }
+        }
+    }};
+
+    // Async Result variant, for blocks that use `.await` / `?`.
+    (try: $name:expr, async $block:block) => {{
+        let start = ::std::time::Instant::now();
+        let result = (async $block).await;
+        let elapsed_ms = start.elapsed().as_millis();
+        match result {
+            Ok(value) => {
+                $crate::timed!(@log_ok debug, $name, elapsed_ms);
+                Ok(value)
+            }
+            Err(err) => {
+                $crate::timed!(@log_err debug, $name, elapsed_ms, err);
+                Err(err)
+            }
+        }
+    }};
+
+    // Async Result variant with explicit log level:
+    // `timed!(try: info, "something", async { ... })?`
+    (try: $lvl:ident, $name:expr, async $block:block) => {{
+        let start = ::std::time::Instant::now();
+        let result = (async $block).await;
+        let elapsed_ms = start.elapsed().as_millis();
+        match result {
+            Ok(value) => {
+                $crate::timed!(@log_ok $lvl, $name, elapsed_ms);
+                Ok(value)
+            }
+            Err(err) => {
+                $crate::timed!(@log_err $lvl, $name, elapsed_ms, err);
+                Err(err)
+            }
+        }
+    }};
+}

crates/codegen/xai-tracing-macros/src/timestamp.rs

@@ -0,0 +1,66 @@
+//! Macros for printing messages with Unix timestamps.
+//!
+//! These macros use tracing for output, which is safe to use in headless mode
+//! (no terminal attached). The timestamp is included in the message.
+
+/// Prints a message via tracing::info with a Unix timestamp prefix.
+///
+/// The format is: `{unix_timestamp}::{message}`
+///
+/// # Examples
+///
+/// ```ignore
+/// tprintln!("Hello, world!");
+/// // Logs: 1234567890::Hello, world!
+///
+/// tprintln!("Value: {}", 42);
+/// // Logs: 1234567890::Value: 42
+/// ```
+#[macro_export]
+macro_rules! tprintln {
+    () => {{
+        let ts = ::std::time::SystemTime::now()
+            .duration_since(::std::time::UNIX_EPOCH)
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+        ::tracing::info!("{}::", ts)
+    }};
+    ($($arg:tt)*) => {{
+        let ts = ::std::time::SystemTime::now()
+            .duration_since(::std::time::UNIX_EPOCH)
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+        ::tracing::info!("{}::{}", ts, ::std::format_args!($($arg)*))
+    }};
+}
+
+/// Prints a message via tracing::warn with a Unix timestamp prefix.
+///
+/// The format is: `{unix_timestamp}::{message}`
+///
+/// # Examples
+///
+/// ```ignore
+/// teprintln!("Error occurred!");
+/// // Logs: 1234567890::Error occurred!
+///
+/// teprintln!("Error code: {}", 500);
+/// // Logs: 1234567890::Error code: 500
+/// ```
+#[macro_export]
+macro_rules! teprintln {
+    () => {{
+        let ts = ::std::time::SystemTime::now()
+            .duration_since(::std::time::UNIX_EPOCH)
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+        ::tracing::warn!("{}::", ts)
+    }};
+    ($($arg:tt)*) => {{
+        let ts = ::std::time::SystemTime::now()
+            .duration_since(::std::time::UNIX_EPOCH)
+            .map(|d| d.as_secs())
+            .unwrap_or(0);
+        ::tracing::warn!("{}::{}", ts, ::std::format_args!($($arg)*))
+    }};
+}