xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,103 +0,0 @@
-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

@@ -1,303 +0,0 @@
-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

@@ -1,102 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-{
-  "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"
-  }
-}