xtrm-tools 2.0.0

package/project-skills/tdd-guard/reporters/go/internal/transformer/transformer.go

@@ -0,0 +1,103 @@
+package transformer
+
+import (
+	"github.com/nizos/tdd-guard/reporters/go/internal/parser"
+)
+
+// TestError represents an error from a test
+type TestError struct {
+	Message string `json:"message"`
+}
+
+// Test represents a single test
+type Test struct {
+	Name     string      `json:"name"`
+	FullName string      `json:"fullName"`
+	State    string      `json:"state"`
+	Errors   []TestError `json:"errors,omitempty"`
+}
+
+// TestModule represents a module with its tests
+type TestModule struct {
+	ModuleID string `json:"moduleId"`
+	Tests    []Test `json:"tests"`
+}
+
+// TestResult represents the TDD Guard test result format
+type TestResult struct {
+	TestModules []TestModule `json:"testModules"`
+	Reason      string       `json:"reason,omitempty"`
+}
+
+// Transformer transforms parser results to TDD Guard format
+type Transformer struct{}
+
+// NewTransformer creates a new transformer
+func NewTransformer() *Transformer {
+	return &Transformer{}
+}
+
+// Transform converts parser results to TDD Guard format
+func (t *Transformer) Transform(results parser.Results, p *parser.Parser, compilationError *parser.CompilationError) *TestResult {
+	modules := []TestModule{}
+	reason := "passed"
+
+	for pkg, tests := range results {
+		module := TestModule{
+			ModuleID: pkg,
+			Tests:    transformTests(pkg, tests, p, compilationError),
+		}
+		modules = append(modules, module)
+
+		// Update reason if any test failed
+		for _, state := range tests {
+			if state == parser.StateFailed {
+				reason = "failed"
+			}
+		}
+	}
+
+	return &TestResult{
+		TestModules: modules,
+		Reason:      reason,
+	}
+}
+
+// transformTests converts package test results to Test structs
+func transformTests(pkg string, tests parser.PackageResults, p *parser.Parser, compilationError *parser.CompilationError) []Test {
+	result := make([]Test, 0, len(tests))
+
+	for name, state := range tests {
+		test := Test{
+			Name:     name,
+			FullName: pkg + "/" + name,
+			State:    string(state),
+		}
+
+		// Add error messages for failed tests
+		if state == parser.StateFailed {
+			test.Errors = getTestErrors(pkg, name, p, compilationError)
+		}
+
+		result = append(result, test)
+	}
+
+	return result
+}
+
+// getTestErrors gets the error messages for a failed test
+func getTestErrors(pkg, name string, p *parser.Parser, compilationError *parser.CompilationError) []TestError {
+	// Special case: synthetic CompilationError test
+	if name == "CompilationError" && compilationError != nil {
+		errors := make([]TestError, 0, len(compilationError.Messages))
+		for _, msg := range compilationError.Messages {
+			errors = append(errors, TestError{Message: msg})
+		}
+		return errors
+	}
+	// Regular test failure
+	if output := p.GetTestOutput(pkg, name); output != "" {
+		return []TestError{{Message: output}}
+	}
+	return nil
+}

package/project-skills/tdd-guard/reporters/go/internal/transformer/transformer_test.go

@@ -0,0 +1,303 @@
+package transformer
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/nizos/tdd-guard/reporters/go/internal/parser"
+)
+
+// Test constants
+const (
+	testPackage = "example.com/pkg"
+	testName    = "TestExample"
+)
+
+func TestTransformer(t *testing.T) {
+	t.Run("Creation", func(t *testing.T) {
+		t.Run("creates new transformer", func(t *testing.T) {
+			transformer := NewTransformer()
+			if transformer == nil {
+				t.Fatal("Expected transformer to be created")
+			}
+		})
+	})
+
+	t.Run("Transform", func(t *testing.T) {
+		t.Run("Empty results", func(t *testing.T) {
+			emptyResults := make(parser.Results)
+			output := transformResults(t, emptyResults)
+
+			t.Run("returns non-nil output", func(t *testing.T) {
+				if output == nil {
+					t.Fatal("Expected non-nil output")
+				}
+			})
+
+			t.Run("initializes testModules", func(t *testing.T) {
+				if output.TestModules == nil {
+					t.Fatal("Expected TestModules to be initialized")
+				}
+			})
+		})
+
+		t.Run("Module structure", func(t *testing.T) {
+			results := createSingleTest(testName, parser.StatePassed)
+			output := transformResults(t, results)
+			module := getFirstModule(t, output)
+
+			t.Run("creates one module per package", func(t *testing.T) {
+				if len(output.TestModules) != 1 {
+					t.Fatalf("Expected 1 module, got %d", len(output.TestModules))
+				}
+			})
+
+			t.Run("sets correct moduleId", func(t *testing.T) {
+				if module.ModuleID != testPackage {
+					t.Errorf("Expected moduleId %q, got %q", testPackage, module.ModuleID)
+				}
+			})
+
+			t.Run("initializes tests array", func(t *testing.T) {
+				if module.Tests == nil {
+					t.Fatal("Expected Tests to be initialized")
+				}
+			})
+
+			t.Run("creates entry for each test", func(t *testing.T) {
+				if len(module.Tests) != 1 {
+					t.Fatalf("Expected 1 test, got %d", len(module.Tests))
+				}
+			})
+		})
+
+		t.Run("Test properties", func(t *testing.T) {
+			test := transformAndGetFirstTest(t, parser.StatePassed)
+
+			t.Run("sets name correctly", func(t *testing.T) {
+				if test.Name != testName {
+					t.Errorf("Expected test name %q, got %q", testName, test.Name)
+				}
+			})
+
+			t.Run("sets fullName with package path", func(t *testing.T) {
+				expectedFullName := testPackage + "/" + testName
+				if test.FullName != expectedFullName {
+					t.Errorf("Expected fullName %q, got %q", expectedFullName, test.FullName)
+				}
+			})
+		})
+
+		t.Run("Test states", func(t *testing.T) {
+			testCases := []struct {
+				name     string
+				input    parser.TestState
+				expected string
+			}{
+				{"passed state", parser.StatePassed, "passed"},
+				{"failed state", parser.StateFailed, "failed"},
+			}
+
+			for _, tc := range testCases {
+				t.Run("maps "+tc.name, func(t *testing.T) {
+					test := transformAndGetFirstTest(t, tc.input)
+					if test.State != tc.expected {
+						t.Errorf("Expected state %q, got %q", tc.expected, test.State)
+					}
+				})
+			}
+		})
+
+		t.Run("Error messages", func(t *testing.T) {
+			t.Run("failed test has errors field", func(t *testing.T) {
+				results := createSingleTest("TestFail", parser.StateFailed)
+				output := transformResults(t, results)
+				test := getFirstTest(t, output)
+
+				// Check if the Errors field exists (will fail compilation if not)
+				if test.Errors == nil {
+					// This is OK - errors can be nil if no error message
+				}
+			})
+
+			t.Run("Transform accepts parser parameter", func(t *testing.T) {
+				p := parser.NewParser()
+				results := createSingleTest("TestFail", parser.StateFailed)
+				transformer := NewTransformer()
+
+				output := transformer.Transform(results, p, nil)
+				if output == nil {
+					t.Fatal("Expected non-nil output")
+				}
+			})
+
+			t.Run("includes error message for failed test", func(t *testing.T) {
+				// Create a parser with a failed test and output
+				p := parser.NewParser()
+				input := strings.Join([]string{
+					`{"Action":"output","Package":"example.com/pkg","Test":"TestFail","Output":"Expected 6 but got 5\n"}`,
+					`{"Action":"fail","Package":"example.com/pkg","Test":"TestFail"}`,
+				}, "\n")
+
+				err := p.Parse(strings.NewReader(input))
+				if err != nil {
+					t.Fatalf("Parse failed: %v", err)
+				}
+
+				results := p.GetResults()
+				transformer := NewTransformer()
+				output := transformer.Transform(results, p, nil)
+
+				test := getFirstTest(t, output)
+				if len(test.Errors) == 0 {
+					t.Fatal("Expected errors to be populated for failed test with output")
+				}
+			})
+		})
+
+		t.Run("Result reason", func(t *testing.T) {
+			t.Run("is always set", func(t *testing.T) {
+				results := createSingleTest(testName, parser.StatePassed)
+				output := transformResults(t, results)
+				if output.Reason == "" {
+					t.Fatal("Expected Reason field to be set")
+				}
+			})
+
+			reasonTestCases := []struct {
+				name     string
+				tests    parser.PackageResults
+				expected string
+			}{
+				{
+					name: "all tests pass",
+					tests: parser.PackageResults{
+						"TestOne": parser.StatePassed,
+						"TestTwo": parser.StatePassed,
+					},
+					expected: "passed",
+				},
+				{
+					name: "one test fails",
+					tests: parser.PackageResults{
+						"TestOne": parser.StatePassed,
+						"TestTwo": parser.StateFailed,
+					},
+					expected: "failed",
+				},
+				{
+					name: "all tests fail",
+					tests: parser.PackageResults{
+						"TestOne": parser.StateFailed,
+						"TestTwo": parser.StateFailed,
+					},
+					expected: "failed",
+				},
+			}
+
+			for _, tc := range reasonTestCases {
+				t.Run(tc.name, func(t *testing.T) {
+					results := createMultipleTests(tc.tests)
+					output := transformResults(t, results)
+					if output.Reason != tc.expected {
+						t.Errorf("Expected reason %q, got %q", tc.expected, output.Reason)
+					}
+				})
+			}
+		})
+	})
+}
+
+// Helper functions
+
+func transformResults(t *testing.T, results parser.Results) *TestResult {
+	t.Helper()
+	transformer := NewTransformer()
+	p := parser.NewParser()
+	return transformer.Transform(results, p, nil)
+}
+
+func createSingleTest(name string, state parser.TestState) parser.Results {
+	return parser.Results{
+		testPackage: parser.PackageResults{
+			name: state,
+		},
+	}
+}
+
+func createMultipleTests(tests parser.PackageResults) parser.Results {
+	return parser.Results{
+		testPackage: tests,
+	}
+}
+
+func getFirstModule(t *testing.T, output *TestResult) TestModule {
+	t.Helper()
+	if len(output.TestModules) == 0 {
+		t.Fatal("No modules in output")
+	}
+	return output.TestModules[0]
+}
+
+func getFirstTest(t *testing.T, output *TestResult) Test {
+	t.Helper()
+	module := getFirstModule(t, output)
+	if len(module.Tests) == 0 {
+		t.Fatal("No tests in module")
+	}
+	return module.Tests[0]
+}
+
+func transformAndGetFirstTest(t *testing.T, state parser.TestState) Test {
+	t.Helper()
+	results := createSingleTest(testName, state)
+	output := transformResults(t, results)
+	return getFirstTest(t, output)
+}
+
+func TestTransformer_CompilationErrorWithMultipleMessages(t *testing.T) {
+	// Test that multiple compilation error messages are transformed correctly
+	results := parser.Results{
+		"example.com/pkg": parser.PackageResults{
+			"CompilationError": parser.StateFailed,
+		},
+	}
+
+	compilationError := &parser.CompilationError{
+		Package: "example.com/pkg",
+		Messages: []string{
+			"example.go:9:8: undefined: NewFormatter",
+			"example.go:10:12: undefined: TestEvent",
+		},
+	}
+
+	transformer := NewTransformer()
+	output := transformer.Transform(results, parser.NewParser(), compilationError)
+
+	if len(output.TestModules) != 1 {
+		t.Fatalf("Expected 1 module, got %d", len(output.TestModules))
+	}
+
+	module := output.TestModules[0]
+	if len(module.Tests) != 1 {
+		t.Fatalf("Expected 1 test, got %d", len(module.Tests))
+	}
+
+	test := module.Tests[0]
+	if test.Name != "CompilationError" {
+		t.Errorf("Expected test name 'CompilationError', got %q", test.Name)
+	}
+
+	// Check that we have multiple error entries
+	if len(test.Errors) != 2 {
+		t.Fatalf("Expected 2 error messages, got %d", len(test.Errors))
+	}
+
+	if test.Errors[0].Message != "example.go:9:8: undefined: NewFormatter" {
+		t.Errorf("Expected first error message to be 'example.go:9:8: undefined: NewFormatter', got %q", test.Errors[0].Message)
+	}
+
+	if test.Errors[1].Message != "example.go:10:12: undefined: TestEvent" {
+		t.Errorf("Expected second error message to be 'example.go:10:12: undefined: TestEvent', got %q", test.Errors[1].Message)
+	}
+}

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

@@ -0,0 +1,102 @@
+# TDD Guard Jest Reporter
+
+Jest reporter that captures test results for TDD Guard validation.
+
+## Requirements
+
+- Node.js 18+
+- Jest 30.0.5+
+- [TDD Guard](https://github.com/nizos/tdd-guard) installed globally
+
+## Installation
+
+```bash
+npm install --save-dev tdd-guard-jest
+```
+
+## Configuration
+
+### Jest Configuration
+
+Add the reporter to your `jest.config.js`:
+
+```javascript
+module.exports = {
+  reporters: [
+    'default',
+    [
+      'tdd-guard-jest',
+      {
+        projectRoot: __dirname,
+      },
+    ],
+  ],
+}
+```
+
+Or in `jest.config.ts`:
+
+```typescript
+import type { Config } from 'jest'
+import path from 'path'
+
+const config: Config = {
+  reporters: [
+    'default',
+    [
+      'tdd-guard-jest',
+      {
+        projectRoot: path.resolve(__dirname),
+      },
+    ],
+  ],
+}
+
+export default config
+```
+
+### Workspace/Monorepo Configuration
+
+For workspaces or monorepos, pass the project root path to the reporter:
+
+```javascript
+// jest.config.js in project root
+const path = require('path')
+
+module.exports = {
+  reporters: [
+    'default',
+    [
+      'tdd-guard-jest',
+      {
+        projectRoot: path.resolve(__dirname),
+      },
+    ],
+  ],
+}
+```
+
+If your jest config is in a workspace subdirectory, pass the absolute path to your project root:
+
+```javascript
+module.exports = {
+  reporters: [
+    'default',
+    [
+      'tdd-guard-jest',
+      {
+        projectRoot: '/Users/username/projects/my-app',
+      },
+    ],
+  ],
+}
+```
+
+## 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

package/project-skills/tdd-guard/reporters/jest/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "tdd-guard-jest",
+  "version": "0.1.4",
+  "description": "Jest reporter for TDD Guard",
+  "author": "Nizar Selander",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nizos/tdd-guard.git",
+    "directory": "reporters/jest"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/*.tsbuildinfo",
+    "!dist/*.test-data.*"
+  ],
+  "scripts": {
+    "build": "tsc --build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "tdd-guard": "^1.1.0"
+  },
+  "peerDependencies": {
+    "jest": ">=30.0.5"
+  },
+  "devDependencies": {
+    "@jest/reporters": "^30.0.5",
+    "@jest/test-result": "^30.0.5",
+    "@jest/types": "^30.0.5",
+    "@types/node": "^24.1.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}

package/project-skills/tdd-guard/reporters/phpunit/.php-cs-fixer.php

@@ -0,0 +1,28 @@
+<?php
+
+$finder = PhpCsFixer\Finder::create()
+    ->in(__DIR__ . '/src')
+    ->in(__DIR__ . '/tests')
+    ->exclude('vendor');
+
+$config = new PhpCsFixer\Config();
+return $config->setRules([
+        '@PSR12' => true,
+        'array_syntax' => ['syntax' => 'short'],
+        'ordered_imports' => ['sort_algorithm' => 'alpha'],
+        'no_unused_imports' => true,
+        'single_quote' => true,
+        'trailing_comma_in_multiline' => true,
+        'phpdoc_scalar' => true,
+        'unary_operator_spaces' => true,
+        'binary_operator_spaces' => true,
+        'blank_line_before_statement' => [
+            'statements' => ['break', 'continue', 'declare', 'return', 'throw', 'try'],
+        ],
+        'phpdoc_single_line_var_spacing' => true,
+        'phpdoc_var_without_name' => true,
+        'method_argument_space' => [
+            'on_multiline' => 'ensure_fully_multiline',
+        ],
+    ])
+    ->setFinder($finder);

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

@@ -0,0 +1,97 @@
+# TDD Guard PHPUnit Reporter
+
+PHPUnit reporter that captures test results for TDD Guard validation.
+
+## Requirements
+
+- PHP 8.1+
+- PHPUnit 9.0+ or 10.0+ or 11.0+ or 12.0+
+- [TDD Guard](https://github.com/nizos/tdd-guard) installed globally
+
+## Installation
+
+```bash
+composer require --dev tdd-guard/phpunit
+```
+
+## Configuration
+
+### PHPUnit 10+ Configuration
+
+Add the extension to your `phpunit.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php">
+    <testsuites>
+        <testsuite name="Application Test Suite">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    
+    <extensions>
+        <bootstrap class="TddGuard\PHPUnit\TddGuardExtension">
+            <parameter name="projectRoot" value="/absolute/path/to/project/root"/>
+        </bootstrap>
+    </extensions>
+</phpunit>
+```
+
+### PHPUnit 9.x Configuration
+
+Add the listener to your `phpunit.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="vendor/autoload.php">
+    <testsuites>
+        <testsuite name="Application Test Suite">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    
+    <listeners>
+        <listener class="TddGuard\PHPUnit\TddGuardListener">
+            <arguments>
+                <string>/absolute/path/to/project/root</string>
+            </arguments>
+        </listener>
+    </listeners>
+</phpunit>
+```
+
+### Project Root Configuration
+
+Set the project root using any ONE of these methods:
+
+**Option 1: PHPUnit Configuration (Recommended)**
+
+Use the `projectRoot` parameter in your `phpunit.xml` (see examples above).
+
+**Option 2: Environment Variable**
+
+```bash
+export TDD_GUARD_PROJECT_ROOT=/absolute/path/to/project/root
+```
+
+**Option 3: Automatic Detection**
+
+If not configured, the reporter will:
+- Use the directory containing `phpunit.xml`
+- Fall back to current working directory
+
+### Configuration Rules
+
+- Path must be absolute
+- Falls back to current directory if configuration is invalid
+
+## 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

package/project-skills/tdd-guard/reporters/phpunit/SYNC_README.md

@@ -0,0 +1,29 @@
+# TDD Guard PHPUnit Reporter
+
+This repository is automatically synchronized from the main [TDD Guard monorepo](https://github.com/nizos/tdd-guard).
+
+## Important Notice
+
+**This is a read-only mirror.** Please do not submit pull requests here.
+
+- **Source code**: https://github.com/nizos/tdd-guard/tree/main/reporters/phpunit
+- **Issues**: https://github.com/nizos/tdd-guard/issues
+- **Pull requests**: https://github.com/nizos/tdd-guard/pulls
+
+## Installation
+
+```bash
+composer require --dev tdd-guard/phpunit
+```
+
+## Why a Separate Repository?
+
+Packagist requires composer.json to be at the root of the repository. Since TDD Guard is a monorepo containing multiple packages (npm, Python, PHP), we maintain this synchronized copy specifically for Packagist distribution.
+
+## Synchronization
+
+This repository is automatically updated whenever changes are pushed to the `reporters/phpunit` directory in the main repository.
+
+## License
+
+MIT - See the main repository for details.