xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,409 +0,0 @@
-// src/transformer.rs - Simplified transformer with priority-based logic
-
-use crate::error_parser::CompilationError;
-use crate::parser::TestEvent;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-/// TDD Guard output format
-#[derive(Debug, Serialize, Deserialize)]
-pub struct TddGuardOutput {
-    #[serde(rename = "testModules")]
-    pub test_modules: Vec<TestModule>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reason: Option<String>,
-}
-
-impl Default for TddGuardOutput {
-    fn default() -> Self {
-        Self {
-            test_modules: Vec::new(),
-            reason: None,
-        }
-    }
-}
-
-impl TddGuardOutput {
-    /// Add compilation errors to the output
-    #[allow(dead_code)]
-    pub fn add_compilation_errors(&mut self, errors: Vec<CompilationError>) {
-        if errors.is_empty() {
-            return;
-        }
-
-        // Check if compilation module exists
-        let module_exists = self
-            .test_modules
-            .iter()
-            .any(|m| m.module_id == "compilation");
-
-        if !module_exists {
-            self.test_modules.push(TestModule {
-                module_id: "compilation".to_string(),
-                tests: Vec::new(),
-            });
-        }
-
-        // Find the compilation module (it should exist now)
-        let module = self
-            .test_modules
-            .iter_mut()
-            .find(|m| m.module_id == "compilation")
-            .unwrap(); // Safe to unwrap since we just ensured it exists
-
-        // Add build test with detailed errors
-        module.tests.push(TestResult {
-            name: "build".to_string(),
-            full_name: "compilation::build".to_string(),
-            state: "failed".to_string(),
-            errors: errors.into_iter().map(format_compilation_error).collect(),
-        });
-
-        self.reason = Some("failed".to_string());
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct TestModule {
-    #[serde(rename = "moduleId")]
-    pub module_id: String,
-    pub tests: Vec<TestResult>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct TestResult {
-    pub name: String,
-    #[serde(rename = "fullName")]
-    pub full_name: String,
-    pub state: String,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub errors: Vec<TestError>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct TestError {
-    pub message: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub location: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub code: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub help: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub note: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub expected: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub actual: Option<String>,
-}
-
-/// Transform test events into TDD Guard format
-pub fn transform_events(
-    events: Vec<TestEvent>,
-    compilation_errors: Vec<CompilationError>,
-) -> TddGuardOutput {
-    let mut modules: HashMap<String, TestModule> = HashMap::new();
-
-    if !compilation_errors.is_empty() {
-        add_compilation_module(&mut modules, compilation_errors);
-    }
-
-    // Process test events
-    let mut has_test_failure = false;
-    let mut has_test_pass = false;
-
-    for event in events {
-        if let TestEvent::Test {
-            name,
-            event: event_type,
-            ..
-        } = &event
-        {
-            let module_name = event.module_name();
-            let simple_name = event.simple_test_name();
-
-            let state = match event_type.as_str() {
-                "ok" => {
-                    has_test_pass = true;
-                    "passed"
-                }
-                "failed" => {
-                    has_test_failure = true;
-                    "failed"
-                }
-                "ignored" => "skipped",
-                _ => continue,
-            };
-
-            let module = get_or_create_module(&mut modules, module_name);
-
-            module.tests.push(TestResult {
-                name: simple_name,
-                full_name: normalize_full_name(name),
-                state: state.to_string(),
-                errors: if state == "failed" {
-                    build_test_errors(&event)
-                } else {
-                    Vec::new()
-                },
-            });
-        }
-    }
-
-    // Determine overall reason with simple priority
-    let reason = if modules.contains_key("compilation") || has_test_failure {
-        "failed"
-    } else if has_test_pass || !modules.is_empty() {
-        "passed"
-    } else {
-        "passed"
-    };
-
-    let mut test_modules: Vec<TestModule> = modules.into_values().collect();
-    test_modules.sort_by(|a, b| a.module_id.cmp(&b.module_id));
-
-    TddGuardOutput {
-        test_modules,
-        reason: Some(reason.to_string()),
-    }
-}
-
-/// Add compilation errors as a special module
-fn add_compilation_module(
-    modules: &mut HashMap<String, TestModule>,
-    errors: Vec<CompilationError>,
-) {
-    let module = get_or_create_module(modules, "compilation".to_string());
-
-    module.tests.push(TestResult {
-        name: "build".to_string(),
-        full_name: "compilation::build".to_string(),
-        state: "failed".to_string(),
-        errors: errors.into_iter().map(format_compilation_error).collect(),
-    });
-}
-
-/// Get or create a module
-fn get_or_create_module(
-    modules: &mut HashMap<String, TestModule>,
-    name: String,
-) -> &mut TestModule {
-    modules.entry(name.clone()).or_insert_with(|| TestModule {
-        module_id: name,
-        tests: Vec::new(),
-    })
-}
-
-/// Format a compilation error for output
-fn format_compilation_error(error: CompilationError) -> TestError {
-    let mut message = error.message.clone();
-
-    // Add location to message if available
-    if let (Some(file), Some(line), Some(col)) = (&error.file, error.line, error.column) {
-        message = format!("{}:{}:{}: {}", file, line, col, message);
-    }
-
-    // Add error code if present
-    if let Some(code) = &error.code {
-        message = format!("[{}] {}", code, message);
-    }
-
-    TestError {
-        message,
-        location: error.file.as_ref().map(|f| {
-            if let (Some(line), Some(col)) = (error.line, error.column) {
-                format!("{}:{}:{}", f, line, col)
-            } else {
-                f.clone()
-            }
-        }),
-        code: error.code,
-        help: error.help,
-        note: error.note,
-        expected: None,
-        actual: None,
-    }
-}
-
-/// Build test errors from test event
-fn build_test_errors(event: &TestEvent) -> Vec<TestError> {
-    let message = event
-        .error_message()
-        .unwrap_or_else(|| "Test failed".to_string());
-
-    let (message, expected, actual) = extract_assertion_details(&message);
-
-    vec![TestError {
-        message,
-        location: None,
-        code: None,
-        help: None,
-        note: None,
-        expected,
-        actual,
-    }]
-}
-
-/// Normalize test name format (nextest uses $ separator)
-fn normalize_full_name(name: &str) -> String {
-    name.replace('$', "::")
-}
-
-/// Extract assertion details from error message
-fn extract_assertion_details(message: &str) -> (String, Option<String>, Option<String>) {
-    // Check for assert_eq!/assert_ne! pattern
-    if message.contains("assertion `left == right` failed")
-        || message.contains("assertion `left != right` failed")
-    {
-        let lines: Vec<&str> = message.lines().collect();
-        let mut expected = None;
-        let mut actual = None;
-
-        for line in &lines {
-            let trimmed = line.trim();
-            if trimmed.starts_with("left:") {
-                actual = Some(trimmed.trim_start_matches("left:").trim().to_string());
-            } else if trimmed.starts_with("right:") {
-                expected = Some(trimmed.trim_start_matches("right:").trim().to_string());
-            }
-        }
-
-        let main_message = lines
-            .get(0)
-            .map(|s| s.to_string())
-            .unwrap_or_else(|| message.to_string());
-
-        return (main_message, expected, actual);
-    }
-
-    // Check for panic pattern
-    if let Some(idx) = message.find("panicked at '") {
-        let start = idx + "panicked at '".len();
-        if let Some(rest) = message.get(start..) {
-            if let Some(end) = rest.find('\'') {
-                let panic_msg = format!("panic: {}", &rest[..end]);
-                return (panic_msg, None, None);
-            }
-        }
-    }
-
-    // Return message as-is
-    (message.to_string(), None, None)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_transform_with_compilation_errors() {
-        let errors = vec![CompilationError {
-            code: Some("E0432".to_string()),
-            file: Some("src/lib.rs".to_string()),
-            line: Some(1),
-            column: Some(5),
-            message: "unresolved import".to_string(),
-            help: None,
-            note: None,
-        }];
-
-        let output = transform_events(vec![], errors);
-
-        assert_eq!(output.reason, Some("failed".to_string()));
-        assert_eq!(output.test_modules.len(), 1);
-        assert_eq!(output.test_modules[0].module_id, "compilation");
-        assert_eq!(output.test_modules[0].tests[0].state, "failed");
-    }
-
-    #[test]
-    fn test_transform_passing_tests() {
-        let events = vec![TestEvent::Test {
-            name: "my_crate::tests::test_pass".to_string(),
-            event: "ok".to_string(),
-            stdout: None,
-            stderr: None,
-        }];
-
-        let output = transform_events(events, vec![]);
-
-        assert_eq!(output.reason, Some("passed".to_string()));
-        assert_eq!(output.test_modules.len(), 1);
-        assert_eq!(output.test_modules[0].tests[0].state, "passed");
-    }
-
-    #[test]
-    fn test_transform_failing_tests() {
-        let events = vec![TestEvent::Test {
-            name: "my_crate::tests::test_fail".to_string(),
-            event: "failed".to_string(),
-            stdout: Some("assertion failed".to_string()),
-            stderr: None,
-        }];
-
-        let output = transform_events(events, vec![]);
-
-        assert_eq!(output.reason, Some("failed".to_string()));
-        assert_eq!(output.test_modules[0].tests[0].state, "failed");
-        assert!(!output.test_modules[0].tests[0].errors.is_empty());
-    }
-
-    #[test]
-    fn test_extract_assertion_details() {
-        let message = "assertion `left == right` failed\n  left: 5\n  right: 6";
-        let (msg, expected, actual) = extract_assertion_details(message);
-
-        assert_eq!(msg, "assertion `left == right` failed");
-        assert_eq!(expected, Some("6".to_string()));
-        assert_eq!(actual, Some("5".to_string()));
-    }
-
-    #[test]
-    fn test_module_sorting() {
-        let events = vec![
-            TestEvent::Test {
-                name: "crate_b::test".to_string(),
-                event: "ok".to_string(),
-                stdout: None,
-                stderr: None,
-            },
-            TestEvent::Test {
-                name: "crate_a::test".to_string(),
-                event: "ok".to_string(),
-                stdout: None,
-                stderr: None,
-            },
-        ];
-
-        let output = transform_events(events, vec![]);
-
-        assert_eq!(output.test_modules[0].module_id, "crate_a");
-        assert_eq!(output.test_modules[1].module_id, "crate_b");
-    }
-
-    #[test]
-    fn test_empty_output() {
-        let output = transform_events(vec![], vec![]);
-        assert_eq!(output.test_modules.len(), 0);
-        assert_eq!(output.reason, Some("passed".to_string()));
-    }
-
-    #[test]
-    fn test_format_compilation_error_includes_code_and_location() {
-        use crate::error_parser::CompilationError;
-        let err = CompilationError {
-            code: Some("E0432".to_string()),
-            file: Some("src/lib.rs".to_string()),
-            line: Some(1),
-            column: Some(5),
-            message: "unresolved import".to_string(),
-            help: None,
-            note: None,
-        };
-        let te = super::format_compilation_error(err);
-        assert!(te.message.contains("[E0432]"));
-        assert!(te.message.contains("src/lib.rs:1:5"));
-        assert!(te.message.contains("unresolved import"));
-        assert_eq!(te.location.as_deref(), Some("src/lib.rs:1:5"));
-        assert_eq!(te.code.as_deref(), Some("E0432"));
-    }
-}

package/project-skills/tdd-guard/reporters/storybook/README.md

@@ -1,108 +0,0 @@
-# TDD Guard Storybook Reporter
-
-Storybook test-runner reporter that captures test results for TDD Guard validation.
-
-## Requirements
-
-- Node.js 18+
-- Storybook 7.x - 9.x
-- @storybook/test-runner 0.19.0+
-- [TDD Guard](https://github.com/nizos/tdd-guard) installed globally
-
-> [!IMPORTANT]
-> For Storybook v10.x, use the `tdd-guard-vitest` reporter w/ Vitest
-
-## Installation
-
-```bash
-npm install --save-dev tdd-guard-storybook
-```
-
-## Configuration
-
-### Basic Configuration
-
-Add the reporter to your `.storybook/test-runner.ts`:
-
-```typescript
-import { StorybookReporter } from 'tdd-guard-storybook'
-
-const reporter = new StorybookReporter()
-
-module.exports = {
-  async postVisit(page, context) {
-    await reporter.onStoryResult(context)
-  },
-}
-
-process.on('exit', () => {
-  reporter.onComplete()
-})
-```
-
-### Workspace/Monorepo Configuration
-
-For workspaces or monorepos, pass the project root path to the reporter:
-
-```typescript
-import { StorybookReporter } from 'tdd-guard-storybook'
-import path from 'path'
-
-const reporter = new StorybookReporter(path.resolve(__dirname, '../..'))
-
-module.exports = {
-  async postVisit(page, context) {
-    await reporter.onStoryResult(context)
-  },
-}
-
-process.on('exit', () => {
-  reporter.onComplete()
-})
-```
-
-If your test-runner config is in a subdirectory, pass the absolute path to your project root:
-
-```typescript
-new StorybookReporter('/Users/username/projects/my-app')
-```
-
-## How It Works
-
-The reporter captures results from stories that have `play` functions (interaction tests):
-
-- Stories with `play` functions are reported as tests
-- Stories without `play` functions are ignored
-- Test results are saved to `.claude/tdd-guard/data/test.json`
-
-## Output Format
-
-The reporter writes test results in a format compatible with TDD Guard validation:
-
-```json
-{
-  "testModules": [
-    {
-      "moduleId": "button--primary",
-      "tests": [
-        {
-          "name": "Primary",
-          "fullName": "Button > Primary",
-          "state": "passed"
-        }
-      ]
-    }
-  ],
-  "unhandledErrors": [],
-  "reason": "passed"
-}
-```
-
-## More Information
-
-- Test results are saved to `.claude/tdd-guard/data/test.json`
-- See [TDD Guard documentation](https://github.com/nizos/tdd-guard) for complete setup
-
-## License
-
-MIT