xtrm-tools 2.0.0

package/project-skills/tdd-guard/reporters/rust/src/main.rs

@@ -0,0 +1,464 @@
+// src/main.rs - Simplified main module with unified execution paths
+
+use clap::Parser;
+use std::fs;
+use std::io::{self, BufRead, BufReader, IsTerminal, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Stdio};
+
+mod error_parser;
+mod parser;
+mod transformer;
+
+use error_parser::parse_error_buffer;
+use parser::TestEvent;
+use transformer::{transform_events, TddGuardOutput};
+
+#[derive(Parser, Debug)]
+#[command(name = "tdd-guard-rust")]
+#[command(about = "Rust test reporter for TDD Guard validation")]
+#[command(version = "0.1.0")]
+#[command(
+    long_about = "A test reporter that captures Rust test results for TDD Guard validation. \
+    Supports both cargo test and cargo nextest with optional JSON output for detailed reporting."
+)]
+struct Args {
+    /// Absolute path to project root directory
+    #[arg(long, value_name = "PATH")]
+    project_root: String,
+
+    /// Pass through mode - read from stdin instead of running tests
+    #[arg(long, default_value_t = false)]
+    passthrough: bool,
+
+    /// Disable implicit passthrough when stdin is piped (auto on by default)
+    #[arg(long, default_value_t = false)]
+    no_auto_passthrough: bool,
+
+    /// Test runner to use (nextest, cargo, auto)
+    #[arg(long, default_value = "auto")]
+    runner: String,
+
+    /// Pass remaining args to test runner
+    #[arg(trailing_var_arg = true)]
+    test_args: Vec<String>,
+}
+
+fn main() -> io::Result<()> {
+    let args = Args::parse();
+
+    let project_root = PathBuf::from(&args.project_root);
+    if !project_root.is_absolute() {
+        eprintln!("Error: project-root must be an absolute path");
+        std::process::exit(1);
+    }
+
+    if !project_root.exists() {
+        eprintln!(
+            "Error: project-root does not exist: {}",
+            project_root.display()
+        );
+        std::process::exit(1);
+    }
+
+    let auto_enabled = !args.no_auto_passthrough && env_auto_enabled();
+    let use_pass = should_passthrough(args.passthrough, auto_enabled);
+
+    let exit_code = if use_pass {
+        process_passthrough(&project_root)?
+    } else {
+        run_and_process(&args, &project_root)?
+    };
+
+    std::process::exit(exit_code);
+}
+
+/// Unified function to run tests and process output
+fn run_and_process(args: &Args, project_root: &Path) -> io::Result<i32> {
+    let runner = detect_runner(&args.runner);
+
+    let mut cmd = build_test_command(&runner, &args.test_args);
+
+    // Execute and collect output
+    let mut child = cmd.stdout(Stdio::piped()).stderr(Stdio::piped()).spawn()?;
+
+    let (test_lines, stderr_lines) = read_output(&mut child, false)?;
+
+    process_output(&test_lines, &stderr_lines, project_root)?;
+
+    let status = child.wait()?;
+    Ok(status.code().unwrap_or(1))
+}
+
+/// Build test command based on runner type
+fn build_test_command(runner: &str, test_args: &[String]) -> Command {
+    let mut cmd = Command::new("cargo");
+
+    match runner {
+        "nextest" => {
+            cmd.arg("nextest").arg("run");
+            cmd.env("NEXTEST_EXPERIMENTAL_LIBTEST_JSON", "1");
+            cmd.arg("--message-format").arg("libtest-json");
+            cmd.arg("--no-fail-fast");
+        }
+        _ => {
+            cmd.arg("test");
+            cmd.arg("--no-fail-fast");
+
+            // Add test arguments
+            for arg in test_args {
+                cmd.arg(arg);
+            }
+
+            // Add JSON output flags (best effort - may require nightly)
+            cmd.arg("--");
+            cmd.arg("-Z").arg("unstable-options");
+            cmd.arg("--format").arg("json");
+            cmd.arg("--show-output");
+
+            // Return here to avoid adding test_args twice
+            return cmd;
+        }
+    }
+
+    // Add test arguments for nextest
+    for arg in test_args {
+        cmd.arg(arg);
+    }
+
+    cmd
+}
+
+/// Process passthrough mode - read from stdin and echo
+fn process_passthrough(project_root: &Path) -> io::Result<i32> {
+    let stdin = io::stdin();
+    let reader = stdin.lock();
+
+    let mut all_lines = Vec::new();
+    for line in reader.lines() {
+        let line = line?;
+        println!("{}", line);
+        io::stdout().flush()?;
+        all_lines.push(line);
+    }
+
+    // Separate JSON and non-JSON lines
+    let (json_lines, other_lines): (Vec<_>, Vec<_>) = all_lines
+        .into_iter()
+        .partition(|line| line.trim().starts_with('{') && line.contains("\"type\":"));
+
+    process_output(&json_lines, &other_lines, project_root)?;
+    Ok(0)
+}
+
+/// Read output from child process, optionally echoing to stdout/stderr
+fn read_output(child: &mut Child, echo: bool) -> io::Result<(Vec<String>, Vec<String>)> {
+    let stdout = child.stdout.take().expect("Failed to capture stdout");
+    let stderr = child.stderr.take().expect("Failed to capture stderr");
+
+    let mut test_lines = Vec::new();
+    let mut stderr_lines = Vec::new();
+
+    for line in BufReader::new(stdout).lines() {
+        let line = line?;
+        if echo {
+            println!("{}", line);
+            io::stdout().flush()?;
+        }
+        test_lines.push(line);
+    }
+
+    for line in BufReader::new(stderr).lines() {
+        let line = line?;
+        if echo {
+            eprintln!("{}", line);
+        }
+        stderr_lines.push(line);
+    }
+
+    if !echo {
+        for line in &test_lines {
+            println!("{}", line);
+        }
+        for line in &stderr_lines {
+            eprintln!("{}", line);
+        }
+        io::stdout().flush()?;
+    }
+
+    Ok((test_lines, stderr_lines))
+}
+
+/// Process test output and save results
+fn process_output(
+    test_lines: &[String],
+    stderr_lines: &[String],
+    project_root: &Path,
+) -> io::Result<()> {
+    // Parse JSON events
+    let mut events = Vec::new();
+    for line in test_lines {
+        if let Ok(event) = serde_json::from_str::<TestEvent>(line) {
+            events.push(event);
+        }
+    }
+
+    let mut compilation_errors = parse_error_buffer(stderr_lines);
+
+    // If no JSON events found, also check test output for errors
+    if events.is_empty() && !test_lines.is_empty() {
+        let test_errors = parse_error_buffer(test_lines);
+        compilation_errors.extend(test_errors);
+    }
+
+    // Transform to TDD Guard format
+    let output = transform_events(events, compilation_errors);
+
+    save_results(project_root, &output)?;
+
+    Ok(())
+}
+
+/// Save test results to TDD Guard format
+fn save_results(project_root: &Path, output: &TddGuardOutput) -> io::Result<()> {
+    let output_dir = project_root.join(".claude").join("tdd-guard").join("data");
+    fs::create_dir_all(&output_dir)?;
+
+    let output_file = output_dir.join("test.json");
+    let temp_file = output_dir.join("test.json.tmp");
+
+    let json = serde_json::to_string_pretty(output)?;
+    fs::write(&temp_file, json)?;
+    fs::rename(&temp_file, &output_file)?;
+
+    Ok(())
+}
+
+/// Detect which test runner to use
+fn detect_runner(preference: &str) -> String {
+    match preference {
+        "nextest" => "nextest".to_string(),
+        "cargo" => "cargo".to_string(),
+        "auto" => {
+            // Check if nextest is available (cache this in real impl)
+            if Command::new("cargo")
+                .args(&["nextest", "--version"])
+                .output()
+                .map(|output| output.status.success())
+                .unwrap_or(false)
+            {
+                "nextest".to_string()
+            } else {
+                "cargo".to_string()
+            }
+        }
+        _ => "cargo".to_string(),
+    }
+}
+
+fn env_auto_enabled() -> bool {
+    match std::env::var("TDD_GUARD_AUTO_PASSTHROUGH") {
+        Ok(val) => {
+            let v = val.trim().to_ascii_lowercase();
+            !(v == "0" || v == "false" || v == "no" || v == "off")
+        }
+        Err(_) => true,
+    }
+}
+
+fn decide_passthrough(explicit: bool, auto_enabled: bool, stdin_is_terminal: bool) -> bool {
+    if explicit {
+        return true;
+    }
+    if auto_enabled {
+        return !stdin_is_terminal;
+    }
+    false
+}
+
+fn should_passthrough(explicit: bool, auto_enabled: bool) -> bool {
+    let stdin_is_terminal = io::stdin().is_terminal();
+    decide_passthrough(explicit, auto_enabled, stdin_is_terminal)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_save_results() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path();
+
+        let output = TddGuardOutput {
+            test_modules: vec![],
+            reason: Some("passed".to_string()),
+        };
+
+        save_results(project_root, &output).unwrap();
+
+        let expected_file = project_root
+            .join(".claude")
+            .join("tdd-guard")
+            .join("data")
+            .join("test.json");
+
+        assert!(expected_file.exists());
+
+        let content = fs::read_to_string(expected_file).unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&content).unwrap();
+
+        assert_eq!(parsed["reason"], "passed");
+    }
+
+    #[test]
+    fn test_env_auto_enabled() {
+        use std::env;
+        let key = "TDD_GUARD_AUTO_PASSTHROUGH";
+
+        // Unset -> true
+        env::remove_var(key);
+        assert!(super::env_auto_enabled());
+
+        env::set_var(key, "0");
+        assert!(!super::env_auto_enabled());
+        env::set_var(key, "false");
+        assert!(!super::env_auto_enabled());
+        env::set_var(key, "no");
+        assert!(!super::env_auto_enabled());
+        env::set_var(key, "off");
+        assert!(!super::env_auto_enabled());
+
+        env::set_var(key, "1");
+        assert!(super::env_auto_enabled());
+        env::set_var(key, "true");
+        assert!(super::env_auto_enabled());
+        env::set_var(key, "yes");
+        assert!(super::env_auto_enabled());
+        env::set_var(key, "on");
+        assert!(super::env_auto_enabled());
+
+        env::remove_var(key);
+    }
+
+    #[test]
+    fn test_decide_passthrough_matrix() {
+        // explicit always wins
+        assert!(super::decide_passthrough(true, true, true));
+        assert!(super::decide_passthrough(true, true, false));
+        assert!(super::decide_passthrough(true, false, true));
+        assert!(super::decide_passthrough(true, false, false));
+
+        // auto disabled: never passthrough unless explicit
+        assert!(!super::decide_passthrough(false, false, true));
+        assert!(!super::decide_passthrough(false, false, false));
+
+        // auto enabled: passthrough when stdin is not a terminal
+        assert!(!super::decide_passthrough(false, true, true));
+        assert!(super::decide_passthrough(false, true, false));
+    }
+
+    #[test]
+    fn test_detect_runner() {
+        assert_eq!(detect_runner("nextest"), "nextest");
+        assert_eq!(detect_runner("cargo"), "cargo");
+        assert_eq!(detect_runner("invalid"), "cargo");
+    }
+
+    #[test]
+    fn test_process_empty_output() {
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path();
+
+        process_output(&[], &[], project_root).unwrap();
+
+        let expected_file = project_root
+            .join(".claude")
+            .join("tdd-guard")
+            .join("data")
+            .join("test.json");
+
+        assert!(expected_file.exists());
+    }
+
+    #[test]
+    fn test_process_output_merges_stderr_compilation_errors_when_no_json() {
+        use tempfile::TempDir;
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path();
+
+        // No JSON events, only stderr with a compilation error
+        let test_lines: Vec<String> = vec![
+            // stdout
+            "running 0 tests".to_string(),
+        ];
+        let stderr_lines: Vec<String> = vec![
+            // stderr from rustc
+            "error[E0425]: cannot find value `x` in this scope".to_string(),
+            " --> src/lib.rs:2:9".to_string(),
+        ];
+
+        super::process_output(&test_lines, &stderr_lines, project_root).unwrap();
+
+        // Verify output file exists and contains a compilation module failed
+        let out = project_root
+            .join(".claude")
+            .join("tdd-guard")
+            .join("data")
+            .join("test.json");
+        let content = std::fs::read_to_string(out).unwrap();
+        let v: serde_json::Value = serde_json::from_str(&content).unwrap();
+        assert_eq!(v["reason"], "failed");
+        assert!(v["testModules"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|m| m["moduleId"] == "compilation"));
+    }
+
+    #[test]
+    fn test_process_passthrough_partitions_json_and_non_json() {
+        use crate::parser::TestEvent;
+        use tempfile::TempDir;
+
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path();
+
+        // Simulate passthrough partition logic by calling process_output directly with mixed lines.
+        // JSON-like lines need a "type" key to be parsed as events.
+        let json_test_event = serde_json::to_string(&TestEvent::Test {
+            name: "crate::tests::adds$works".to_string(),
+            event: "failed".to_string(),
+            stdout: Some("assertion `left == right` failed\n  left: 1\n  right: 2".to_string()),
+            stderr: None,
+        })
+        .unwrap();
+
+        let non_json_error = vec![
+            "error[E0599]: no method named `foo` found for type `u8`".to_string(),
+            " --> src/main.rs:10:5".to_string(),
+        ];
+
+        let test_lines = vec![json_test_event]; // stdin JSON goes here
+        let stderr_lines = non_json_error; // other lines treated as stderr here
+
+        super::process_output(&test_lines, &stderr_lines, project_root).unwrap();
+
+        let out = project_root
+            .join(".claude")
+            .join("tdd-guard")
+            .join("data")
+            .join("test.json");
+        let content = std::fs::read_to_string(out).unwrap();
+        let v: serde_json::Value = serde_json::from_str(&content).unwrap();
+
+        // Expect both a normal module (crate) and compilation module
+        assert_eq!(v["reason"], "failed");
+        let modules = v["testModules"].as_array().unwrap();
+        assert!(modules
+            .iter()
+            .any(|m| m["moduleId"].as_str().unwrap().contains("crate")));
+        assert!(modules.iter().any(|m| m["moduleId"] == "compilation"));
+    }
+}

package/project-skills/tdd-guard/reporters/rust/src/parser.rs

@@ -0,0 +1,225 @@
+// src/parser.rs - Simplified parser for test events
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+/// Test event from cargo test/nextest JSON output
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum TestEvent {
+    Suite {
+        event: String,
+        #[serde(default)]
+        passed: u32,
+        #[serde(default)]
+        failed: u32,
+        #[serde(default)]
+        ignored: u32,
+    },
+    Test {
+        name: String,
+        event: String,
+        #[serde(default)]
+        stdout: Option<String>,
+        #[serde(default)]
+        stderr: Option<String>,
+    },
+    #[serde(untagged)]
+    Other(Value),
+}
+
+impl TestEvent {
+    /// Get error message from stdout/stderr
+    pub fn error_message(&self) -> Option<String> {
+        match self {
+            TestEvent::Test { stdout, stderr, .. } => {
+                let mut msg = String::new();
+
+                if let Some(out) = stdout {
+                    msg.push_str(out.trim());
+                }
+
+                if let Some(err) = stderr {
+                    if !msg.is_empty() {
+                        msg.push('\n');
+                    }
+                    msg.push_str(err.trim());
+                }
+
+                if msg.is_empty() {
+                    None
+                } else {
+                    Some(msg)
+                }
+            }
+            _ => None,
+        }
+    }
+
+    /// Extract module name from test path
+    pub fn module_name(&self) -> String {
+        match self {
+            TestEvent::Test { name, .. } => extract_module(name),
+            _ => "tests".to_string(),
+        }
+    }
+
+    /// Extract simple test name
+    pub fn simple_test_name(&self) -> String {
+        match self {
+            TestEvent::Test { name, .. } => extract_test_name(name),
+            _ => String::new(),
+        }
+    }
+}
+
+/// Extract module from test path
+fn extract_module(path: &str) -> String {
+    // Handle doc tests: "src/lib.rs - function (line X)"
+    if path.contains(" - ") && path.contains(" (line ") {
+        return "doctests".to_string();
+    }
+
+    // Handle integration tests: "tests/integration.rs: test_name"
+    if path.starts_with("tests/") && path.contains(':') {
+        if let Some(file) = path.split(':').next() {
+            return file.trim_end_matches(".rs").replace('/', "::");
+        }
+    }
+
+    // Handle nextest format with $
+    if let Some(pos) = path.find('$') {
+        let module = &path[..pos];
+        // Remove duplicate crate name if present
+        if let Some(colon_pos) = module.rfind("::") {
+            let prefix = &module[..colon_pos];
+            let suffix = &module[colon_pos + 2..];
+            if prefix == suffix {
+                return prefix.to_string();
+            }
+        }
+        return module.to_string();
+    }
+
+    // Standard format: extract first component
+    if let Some(pos) = path.find("::") {
+        return path[..pos].to_string();
+    }
+
+    "tests".to_string()
+}
+
+/// Extract test name from path
+fn extract_test_name(path: &str) -> String {
+    // Handle doc tests
+    if path.contains(" - ") && path.contains(" (line ") {
+        if let Some(start) = path.find(" - ") {
+            let after = &path[start + 3..];
+            if let Some(end) = after.find(" (line ") {
+                return after[..end].to_string();
+            }
+        }
+    }
+
+    // Handle integration tests
+    if path.starts_with("tests/") && path.contains(": ") {
+        if let Some(pos) = path.find(": ") {
+            return path[pos + 2..].to_string();
+        }
+    }
+
+    // Handle nextest format
+    if let Some(pos) = path.find('$') {
+        return path[pos + 1..].to_string();
+    }
+
+    // Standard format: last component
+    if let Some(pos) = path.rfind("::") {
+        return path[pos + 2..].to_string();
+    }
+
+    path.to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_module() {
+        assert_eq!(extract_module("src/lib.rs - add (line 7)"), "doctests");
+        assert_eq!(
+            extract_module("tests/integration: test_basic"),
+            "tests::integration"
+        );
+        assert_eq!(
+            extract_module("my_crate::my_crate$tests::test_fn"),
+            "my_crate"
+        );
+        assert_eq!(extract_module("my_crate::tests::test_fn"), "my_crate");
+    }
+
+    #[test]
+    fn test_extract_test_name() {
+        assert_eq!(
+            extract_test_name("src/lib.rs - module::add (line 7)"),
+            "module::add"
+        );
+        assert_eq!(
+            extract_test_name("tests/integration: test_basic"),
+            "test_basic"
+        );
+        assert_eq!(extract_test_name("crate$tests::test_fn"), "tests::test_fn");
+        assert_eq!(extract_test_name("crate::tests::test_fn"), "test_fn");
+    }
+
+    #[test]
+    fn test_error_message() {
+        let event = TestEvent::Test {
+            name: "test".to_string(),
+            event: "failed".to_string(),
+            stdout: Some("assertion failed".to_string()),
+            stderr: Some("error details".to_string()),
+        };
+
+        let msg = event.error_message().unwrap();
+        assert!(msg.contains("assertion failed"));
+        assert!(msg.contains("error details"));
+    }
+
+    #[test]
+    fn test_doctest_paths_module_and_name() {
+        let e = TestEvent::Test {
+            name: "src/lib.rs - my_mod::add (line 7)".to_string(),
+            event: "ok".to_string(),
+            stdout: None,
+            stderr: None,
+        };
+        assert_eq!(e.module_name(), "doctests");
+        assert_eq!(e.simple_test_name(), "my_mod::add");
+    }
+
+    #[test]
+    fn test_integration_test_paths() {
+        let e = TestEvent::Test {
+            name: "tests/integration.rs: test_basic".to_string(),
+            event: "ok".to_string(),
+            stdout: None,
+            stderr: None,
+        };
+        assert_eq!(e.module_name(), "tests::integration");
+        assert_eq!(e.simple_test_name(), "test_basic");
+    }
+
+    #[test]
+    fn test_nextest_dollar_format_and_duplicate_crate() {
+        let e = TestEvent::Test {
+            name: "my_crate::my_crate$tests::test_fn".to_string(),
+            event: "ok".to_string(),
+            stdout: None,
+            stderr: None,
+        };
+        assert_eq!(e.module_name(), "my_crate");
+        assert_eq!(e.simple_test_name(), "tests::test_fn");
+    }
+}