xtrm-tools 2.2.0 → 2.4.0

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

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

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

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

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

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