xtrm-tools 2.0.0

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

@@ -0,0 +1,102 @@
+{
+  "name": "tdd-guard",
+  "version": "1.1.0",
+  "description": "Automated Test-Driven Development enforcement for Claude Code",
+  "author": "Nizar Selander",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nizos/tdd-guard.git"
+  },
+  "keywords": [
+    "tdd",
+    "test-driven-development",
+    "claude",
+    "claude-code",
+    "hooks",
+    "testing",
+    "ai-tools",
+    "code-quality",
+    "linting"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "workspaces": [
+    "reporters/vitest",
+    "reporters/jest",
+    "reporters/storybook"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "tdd-guard": "dist/cli/tdd-guard.js"
+  },
+  "files": [
+    "dist",
+    "!dist/*.tsbuildinfo",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build:workspaces": "npm run build --workspaces --if-present",
+    "build": "tsc --build tsconfig.build.json && npm run build:workspaces",
+    "test": "vitest run --project default --project golangci-lint",
+    "test:unit": "vitest run --project unit --project golangci-lint",
+    "test:integration": "vitest run --project integration",
+    "pretest:reporters": "npx playwright install chromium --only-shell 2>/dev/null || true",
+    "test:reporters": "vitest run --project reporters",
+    "test:coverage": "vitest run --coverage",
+    "lint": "npm run build:workspaces && eslint . --fix --report-unused-disable-directives --max-warnings 0",
+    "lint:check": "npm run build:workspaces && eslint . --report-unused-disable-directives --max-warnings 0",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "npm run build:workspaces && tsc --noEmit",
+    "checks": "npm run typecheck && npm run lint && npm run format && npm run test",
+    "pre-commit": "npm run format:check && npm run lint:check && npm run typecheck && npm run test:unit",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.25",
+    "@anthropic-ai/sdk": "^0.72.1",
+    "@types/uuid": "^10.0.0",
+    "dotenv": "^17.2.3",
+    "minimatch": "^10.0.3",
+    "uuid": "^13.0.0",
+    "zod": "^4.3.6"
+  },
+  "lint-staged": {
+    "*.{js,jsx,ts,tsx}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{json,md,css,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.4.2",
+    "@commitlint/config-conventional": "^20.4.2",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.0",
+    "@typescript-eslint/parser": "^8.56.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^10.0.1",
+    "eslint-plugin-sonarjs": "^4.0.0",
+    "get-port": "^7.1.0",
+    "globals": "^17.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
+    "tdd-guard-vitest": "*",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "overrides": {
+    "js-yaml": "^4.1.1",
+    "minimatch": "$minimatch",
+    "test-exclude@^6.0.0": "^7.0.2"
+  }
+}

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

@@ -0,0 +1,67 @@
+# TDD Guard Go Reporter
+
+Go test reporter that captures test results for TDD Guard validation.
+
+## Requirements
+
+- Go 1.24+
+- [TDD Guard](https://github.com/nizos/tdd-guard) installed globally
+
+## Installation
+
+```bash
+go install github.com/nizos/tdd-guard/reporters/go/cmd/tdd-guard-go@latest
+```
+
+## Configuration
+
+### Basic Usage
+
+Pipe `go test -json` output to the reporter:
+
+```bash
+go test -json ./... 2>&1 | tdd-guard-go
+```
+
+### Project Root Configuration
+
+For projects where tests run in subdirectories, specify the project root:
+
+```bash
+go test -json ./... 2>&1 | tdd-guard-go -project-root /absolute/path/to/project/root
+```
+
+### Configuration Rules
+
+- Path must be absolute when using `-project-root` flag
+- Current directory must be within the configured project root
+- Falls back to current directory if not specified
+
+### Makefile Integration
+
+Add to your `Makefile`:
+
+```makefile
+test:
+	go test -json ./... 2>&1 | tdd-guard-go -project-root /absolute/path/to/project/root
+```
+
+## How It Works
+
+The reporter acts as a filter that:
+
+1. Reads `go test -json` output from stdin
+2. Passes the output through to stdout unchanged
+3. Parses test results and transforms them to TDD Guard format
+4. Saves results to `.claude/tdd-guard/data/test.json`
+
+This design allows it to be inserted into existing test pipelines without disrupting output.
+
+## 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/go/cmd/tdd-guard-go/main.go

@@ -0,0 +1,127 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/nizos/tdd-guard/reporters/go/internal/formatter"
+	tddio "github.com/nizos/tdd-guard/reporters/go/internal/io"
+	"github.com/nizos/tdd-guard/reporters/go/internal/parser"
+	"github.com/nizos/tdd-guard/reporters/go/internal/storage"
+	"github.com/nizos/tdd-guard/reporters/go/internal/transformer"
+)
+
+func main() {
+	var projectRoot string
+	flag.StringVar(&projectRoot, "project-root", "", "Project root directory (absolute path)")
+	flag.Parse()
+
+	if err := process(os.Stdin, projectRoot, os.Stdout); err != nil {
+		os.Exit(1)
+	}
+}
+
+func process(input io.Reader, projectRoot string, output io.Writer) error {
+	if err := validateProjectRoot(projectRoot); err != nil {
+		return err
+	}
+
+	// Buffer to collect input
+	buffer := &bytes.Buffer{}
+	teeReader := tddio.NewTeeReader(input, buffer)
+
+	// Read all input to buffer
+	io.ReadAll(teeReader)
+
+	// Format and output
+	formatAndOutput(bytes.NewReader(buffer.Bytes()), output)
+
+	// Parse test output from buffer
+	mixedReader := parser.NewMixedReader(buffer)
+	results, p, err := parseTestResults(mixedReader)
+	if err != nil {
+		return err
+	}
+
+	// Add synthetic test for compilation errors
+	if shouldAddCompilationError(results, mixedReader.CompilationError) {
+		addCompilationError(results, mixedReader.CompilationError)
+	}
+
+	// Transform and save results
+	t := transformer.NewTransformer()
+	result := t.Transform(results, p, mixedReader.CompilationError)
+
+	s := storage.NewStorage(projectRoot)
+	return s.Save(result)
+}
+
+func formatAndOutput(input io.Reader, output io.Writer) {
+	f := formatter.NewFormatter()
+	scanner := bufio.NewScanner(input)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		// Try to parse as JSON
+		var event parser.TestEvent
+		if err := json.Unmarshal([]byte(line), &event); err == nil {
+			// It's JSON - format it
+			formatted := f.Format(event)
+			if formatted != "" {
+				fmt.Fprintln(output, formatted)
+			}
+		} else {
+			// Not JSON - pass through as-is
+			fmt.Fprintln(output, line)
+		}
+	}
+}
+
+func validateProjectRoot(projectRoot string) error {
+	if projectRoot == "" {
+		return nil
+	}
+
+	if !filepath.IsAbs(projectRoot) {
+		return errors.New("project root must be an absolute path")
+	}
+
+	cwd, _ := os.Getwd()
+	if !strings.HasPrefix(cwd, projectRoot) {
+		return errors.New("current directory must be within project root")
+	}
+
+	return nil
+}
+
+func parseTestResults(mixedReader *parser.MixedReader) (parser.Results, *parser.Parser, error) {
+	p := parser.NewParser()
+
+	jsonInput := strings.Join(mixedReader.JSONLines, "\n")
+	if jsonInput != "" {
+		if err := p.Parse(strings.NewReader(jsonInput)); err != nil {
+			return nil, nil, err
+		}
+	}
+
+	return p.GetResults(), p, nil
+}
+
+func shouldAddCompilationError(results parser.Results, compilationError *parser.CompilationError) bool {
+	return len(results) == 0 && compilationError != nil
+}
+
+func addCompilationError(results parser.Results, compilationError *parser.CompilationError) {
+	results[compilationError.Package] = parser.PackageResults{
+		"CompilationError": parser.StateFailed,
+	}
+}

package/project-skills/tdd-guard/reporters/go/cmd/tdd-guard-go/main_test.go

@@ -0,0 +1,280 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/nizos/tdd-guard/reporters/go/internal/storage"
+)
+
+func TestProcess(t *testing.T) {
+	// Setup temp directory for all tests
+	oldWd, _ := os.Getwd()
+	tempDir := t.TempDir()
+	os.Chdir(tempDir)
+	t.Cleanup(func() {
+		os.Chdir(oldWd)
+	})
+
+	t.Run("without project root", func(t *testing.T) {
+		t.Run("creates output file", func(t *testing.T) {
+			runProcess(t, "")
+			assertFileExists(t, tempDir)
+		})
+	})
+
+	t.Run("with valid project root", func(t *testing.T) {
+		t.Run("uses provided project root", func(t *testing.T) {
+			runProcess(t, tempDir)
+			assertFileExists(t, tempDir)
+		})
+
+		t.Run("parses and transforms input", func(t *testing.T) {
+			input := `{"Action":"pass","Package":"example.com/pkg","Test":"TestExample"}`
+			data := processAndReadOutput(t, input, tempDir)
+
+			// Check it contains expected transformed data
+			if !bytes.Contains(data, []byte(`"state":"passed"`)) {
+				t.Fatalf("Expected output to contain transformed test state, got: %s", data)
+			}
+		})
+
+		t.Run("accepts project root equal to current directory", func(t *testing.T) {
+			cwd, _ := os.Getwd()
+
+			err := runProcess(t, cwd)
+			if err != nil {
+				t.Fatalf("Expected no error when project root equals cwd, got: %v", err)
+			}
+
+			assertFileExists(t, cwd)
+		})
+
+		t.Run("accepts project root as ancestor of current directory", func(t *testing.T) {
+			// Create a subdirectory and change to it
+			subDir := filepath.Join(tempDir, "subdir")
+			os.MkdirAll(subDir, 0755)
+			oldCwd, _ := os.Getwd()
+			os.Chdir(subDir)
+			defer os.Chdir(oldCwd)
+
+			// Use tempDir (parent) as project root
+			err := runProcess(t, tempDir)
+			if err != nil {
+				t.Fatalf("Expected no error when project root is ancestor, got: %v", err)
+			}
+
+			assertFileExists(t, tempDir)
+		})
+	})
+
+	t.Run("project root validation", func(t *testing.T) {
+		t.Run("rejects relative project root", func(t *testing.T) {
+			err := runProcess(t, "../relative/path")
+			assertErrorContains(t, err, "project root must be an absolute path")
+		})
+
+		t.Run("rejects project root outside current directory", func(t *testing.T) {
+			outsideRoot := filepath.Join(filepath.Dir(tempDir), "outside")
+			os.MkdirAll(outsideRoot, 0755)
+
+			err := runProcess(t, outsideRoot)
+			assertErrorContains(t, err, "current directory must be within project root")
+		})
+	})
+
+	t.Run("formatted output", func(t *testing.T) {
+		t.Run("formats package pass event", func(t *testing.T) {
+			input := `{"Action":"pass","Package":"example.com/pkg","Elapsed":0.003}`
+			output := &bytes.Buffer{}
+
+			err := process(bytes.NewReader([]byte(input)), tempDir, output)
+			if err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			expected := "ok  \texample.com/pkg\t0.003s\n"
+			if output.String() != expected {
+				t.Errorf("Expected formatted output '%s', got '%s'", expected, output.String())
+			}
+		})
+
+		t.Run("passes through compilation errors", func(t *testing.T) {
+			input := "# command-line-arguments"
+			output := &bytes.Buffer{}
+
+			err := process(bytes.NewReader([]byte(input)), tempDir, output)
+			if err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			expected := "# command-line-arguments\n"
+			if output.String() != expected {
+				t.Errorf("Expected '%s', got '%s'", expected, output.String())
+			}
+		})
+
+		t.Run("filters out JSON start events", func(t *testing.T) {
+			input := `{"Action":"start","Package":"example.com/pkg"}`
+			output := &bytes.Buffer{}
+
+			err := process(bytes.NewReader([]byte(input)), tempDir, output)
+			if err != nil {
+				t.Fatalf("Expected no error, got: %v", err)
+			}
+
+			if output.String() != "" {
+				t.Errorf("Expected empty output for start event, got '%s'", output.String())
+			}
+		})
+	})
+
+	t.Run("compilation error handling", func(t *testing.T) {
+		t.Run("handles JSON-only build failure correctly", func(t *testing.T) {
+			// This simulates a build failure that produces JSON output
+			// The package fails but has no test entries
+			input := `{"Action":"fail","Package":"example.com/pkg","Elapsed":0}`
+			data := processAndReadOutput(t, input, tempDir)
+
+			// Should mark as failed
+			if !bytes.Contains(data, []byte(`"reason":"failed"`)) {
+				t.Fatalf("Expected reason to be 'failed' for build failure, got: %s", data)
+			}
+
+			// Should add CompilationError test entry
+			if !bytes.Contains(data, []byte(`"CompilationError"`)) {
+				t.Fatalf("Expected CompilationError test entry for JSON-only failure, got: %s", data)
+			}
+		})
+
+		t.Run("captures each compilation error as separate error entry", func(t *testing.T) {
+			// Multiple error lines should each be a separate error in the errors array
+			input := `# example.com/pkg
+example.go:9:8: undefined: NewFormatter
+example.go:10:12: undefined: TestEvent
+{"Action":"fail","Package":"example.com/pkg","Elapsed":0}`
+			data := processAndReadOutput(t, input, tempDir)
+
+			// Check for separate error entries in the JSON structure
+			if !bytes.Contains(data, []byte(`"message":"example.go:9:8: undefined: NewFormatter"`)) {
+				t.Fatalf("Expected first error as separate entry, got: %s", data)
+			}
+			if !bytes.Contains(data, []byte(`"message":"example.go:10:12: undefined: TestEvent"`)) {
+				t.Fatalf("Expected second error as separate entry, got: %s", data)
+			}
+			// Ensure they're not concatenated
+			if bytes.Contains(data, []byte(`NewFormatter\nexample.go`)) {
+				t.Fatalf("Errors should not be concatenated, got: %s", data)
+			}
+		})
+
+		t.Run("produces non-empty output for compilation error", func(t *testing.T) {
+			input := `# command-line-arguments`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if bytes.Contains(data, []byte(`"testModules":[]`)) {
+				t.Fatalf("Expected non-empty testModules, got: %s", data)
+			}
+		})
+
+		t.Run("only adds synthetic test for lines starting with #", func(t *testing.T) {
+			input := `some random error text`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if !bytes.Contains(data, []byte(`"testModules":[]`)) {
+				t.Fatalf("Expected empty testModules for non-# input, got: %s", data)
+			}
+		})
+
+		t.Run("uses package name from compilation error", func(t *testing.T) {
+			input := `# command-line-arguments`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if !bytes.Contains(data, []byte("command-line-arguments")) {
+				t.Fatalf("Expected command-line-arguments in output, got: %s", data)
+			}
+		})
+
+		t.Run("names the test CompilationError", func(t *testing.T) {
+			input := `# command-line-arguments`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if !bytes.Contains(data, []byte("CompilationError")) {
+				t.Fatalf("Expected CompilationError in output, got: %s", data)
+			}
+		})
+
+		t.Run("includes compilation error message", func(t *testing.T) {
+			input := `# command-line-arguments
+single_import_error_test.go:5:2: no required module`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if !bytes.Contains(data, []byte("single_import_error_test.go:5:2")) {
+				t.Fatalf("Expected error message in output, got: %s", data)
+			}
+		})
+
+		t.Run("uses actual error message from input", func(t *testing.T) {
+			input := `# command-line-arguments
+main.go:10:5: undefined: SomeFunction`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if !bytes.Contains(data, []byte("main.go:10:5: undefined: SomeFunction")) {
+				t.Fatalf("Expected actual error message in output, got: %s", data)
+			}
+		})
+
+		t.Run("does not add CompilationError for passing package with no tests", func(t *testing.T) {
+			// Package passes but has no tests (like an empty test file)
+			input := `{"Action":"pass","Package":"example.com/pkg","Elapsed":0}`
+			data := processAndReadOutput(t, input, tempDir)
+
+			if bytes.Contains(data, []byte(`"CompilationError"`)) {
+				t.Fatalf("Should not add CompilationError for passing package, got: %s", data)
+			}
+			if !bytes.Contains(data, []byte(`"reason":"passed"`)) {
+				t.Fatalf("Expected reason to be 'passed' for empty passing package, got: %s", data)
+			}
+		})
+	})
+}
+
+// Test helpers
+func runProcess(t *testing.T, projectRoot string) error {
+	t.Helper()
+	json := `{"Action":"pass","Package":"example.com/pkg","Test":"TestExample"}`
+	return process(bytes.NewReader([]byte(json)), projectRoot, io.Discard)
+}
+
+func assertFileExists(t *testing.T, projectRoot string) {
+	t.Helper()
+	expectedPath := getTestFilePath(projectRoot)
+	if _, err := os.Stat(expectedPath); os.IsNotExist(err) {
+		t.Fatal("Expected output file to be created")
+	}
+}
+
+func assertErrorContains(t *testing.T, err error, expected string) {
+	t.Helper()
+	if err == nil || err.Error() != expected {
+		t.Fatalf("Expected error '%s', got: %v", expected, err)
+	}
+}
+
+func getTestFilePath(projectRoot string) string {
+	parts := append([]string{projectRoot}, storage.TestResultsPath...)
+	return filepath.Join(parts...)
+}
+
+func processAndReadOutput(t *testing.T, input string, projectRoot string) []byte {
+	t.Helper()
+	err := process(bytes.NewReader([]byte(input)), projectRoot, io.Discard)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, _ := os.ReadFile(getTestFilePath(projectRoot))
+	return data
+}

package/project-skills/tdd-guard/reporters/go/go.mod

@@ -0,0 +1,3 @@
+module github.com/nizos/tdd-guard/reporters/go
+
+go 1.24