refactor(go): simplify codebase through systematic cleanup

- Removed unnecessary getter methods in MixedReader (Go anti-pattern)
- Made struct fields public for direct access (idiomatic Go)
- Extracted complex logic into focused, single-responsibility functions
- Reduced nesting throughout codebase using early returns
- Fixed potential panic bug with string slicing using strings.HasPrefix()
- Removed setter pattern in Transformer for cleaner data flow
- Simplified Transform method and reduced complexity
- Improved separation of concerns in main process function

All tests pass. Code is now more idiomatic Go, easier to maintain,
and follows the principle of simplicity over premature abstraction.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: nizos

reporters/go/cmd/tdd-guard-go/main.go

@@ -24,48 +24,66 @@ func main() {
 }
 
 func process(input io.Reader, projectRoot string) error {
-	// Validate project root if provided
-	if projectRoot != "" {
-		if !filepath.IsAbs(projectRoot) {
-			return errors.New("project root must be an absolute path")
-		}
-
-		// Check if current directory is within project root
-		cwd, _ := os.Getwd()
-		if !strings.HasPrefix(cwd, projectRoot) {
-			return errors.New("current directory must be within project root")
-		}
+	if err := validateProjectRoot(projectRoot); err != nil {
+		return err
 	}
 
-	// Use MixedReader to check for compilation errors
+	// Parse test output
 	mixedReader := parser.NewMixedReader(input)
+	results, p, err := parseTestResults(mixedReader)
+	if err != nil {
+		return err
+	}
 
-	p := parser.NewParser()
-
-	// Parse JSON lines
-	jsonInput := strings.Join(mixedReader.GetJSONLines(), "\n")
-	if jsonInput != "" {
-		err := p.Parse(strings.NewReader(jsonInput))
-		if err != nil {
-			return err
-		}
+	// Add synthetic test for compilation errors
+	if shouldAddCompilationError(results, mixedReader.CompilationError) {
+		addCompilationError(results, mixedReader.CompilationError)
 	}
 
-	// Only add syntthetic test if compilation error detected
-	results := p.GetResults()
+	// Transform and save results
 	t := transformer.NewTransformer()
+	result := t.Transform(results, p, mixedReader.CompilationError)
 
-	if len(results) == 0 && mixedReader.HasCompilationError() {
-		pkg := mixedReader.GetCompilationErrorPackage()
-		results[pkg] = parser.PackageResults{
-			"CompilationError": parser.StateFailed,
+	s := storage.NewStorage(projectRoot)
+	return s.Save(result)
+}
+
+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
 		}
-		// Pass error message to transformer
-		t.SetCompilationErrorMessage(mixedReader.GetCompilationErrorMessage())
 	}
 
-	result := t.Transform(results, p)
+	return p.GetResults(), p, nil
+}
 
-	s := storage.NewStorage(projectRoot)
-	return s.Save(result)
+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,
+	}
 }

reporters/go/cmd/tdd-guard-go/main_test.go

@@ -99,7 +99,6 @@ func TestProcess(t *testing.T) {
 			outputPath := getTestFilePath(tempDir)
 			data, _ := os.ReadFile(outputPath)
 
-
 			if bytes.Contains(data, []byte(`"testModules":[]`)) {
 				t.Fatalf("Expected non-empty testModules, got: %s", data)
 			}

reporters/go/internal/parser/mixed_reader.go

@@ -4,73 +4,90 @@ import (
 	"bufio"
 	"encoding/json"
 	"io"
+	"strings"
 )
 
 // MixedReader handles both JSON and plain text input from go test
 type MixedReader struct {
-	jsonLines         []string
-	nonJSONLines      []string
-	hasCompilationErr bool
-	errorPackage      string
-	errorMessage      string
+	JSONLines        []string
+	NonJSONLines     []string
+	CompilationError *CompilationError
+}
+
+// CompilationError represents a compilation error if one occurred
+type CompilationError struct {
+	Package string
+	Message string
 }
 
 // NewMixedReader creates a new MixedReader and processes the input
 func NewMixedReader(reader io.Reader) *MixedReader {
 	mr := &MixedReader{}
 	scanner := bufio.NewScanner(reader)
 	foundErrorHeader := false
+	var errorPkg string
 
 	for scanner.Scan() {
 		line := scanner.Text()
 
 		// Try to parse as JSON
-		var event TestEvent
-		if err := json.Unmarshal([]byte(line), &event); err == nil {
-			// It's valid JSON
-			mr.jsonLines = append(mr.jsonLines, line)
-		} else {
-			// It's not JSON
-			mr.nonJSONLines = append(mr.nonJSONLines, line)
-
-			// Check for compilation error pattern
-			if len(line) > 0 && line[0] == '#' {
-				mr.hasCompilationErr = true
-				foundErrorHeader = true
-				// Extract package name (everything after "# ")
-				if len(line) > 2 {
-					mr.errorPackage = line[2:]
-				}
-			} else if foundErrorHeader && mr.errorMessage == "" && line != "" && line[:4] != "FAIL" {
-				// The next non-empty line after # is the error message
-				mr.errorMessage = line
-			}
+		if isJSON(line) {
+			mr.JSONLines = append(mr.JSONLines, line)
+			continue
+		}
+
+		// Not JSON - store it
+		mr.NonJSONLines = append(mr.NonJSONLines, line)
+
+		// Check for compilation error pattern
+		if isErrorHeader(line) {
+			foundErrorHeader = true
+			errorPkg = extractPackageName(line)
+			continue
+		}
+
+		// Capture error message (first non-FAIL line after header)
+		if foundErrorHeader && mr.CompilationError == nil && isErrorMessage(line) {
+			mr.CompilationError = newCompilationError(errorPkg, line)
 		}
 	}
+
+	// If we found error header but no error message, still create CompilationError
+	if foundErrorHeader && mr.CompilationError == nil {
+		mr.CompilationError = newCompilationError(errorPkg, "")
+	}
+
 	return mr
 }
 
-// GetJSONLines returns the collected JSON lines
-func (mr *MixedReader) GetJSONLines() []string {
-	return mr.jsonLines
+// isJSON checks if a line is valid JSON
+func isJSON(line string) bool {
+	var event TestEvent
+	return json.Unmarshal([]byte(line), &event) == nil
 }
 
-// GetNonJSONLines returns the collected non-JSON lines
-func (mr *MixedReader) GetNonJSONLines() []string {
-	return mr.nonJSONLines
+// isErrorHeader checks if line starts with # (compilation error header)
+func isErrorHeader(line string) bool {
+	return len(line) > 0 && line[0] == '#'
 }
 
-// HasCompilationError checks if compilation error was detected
-func (mr *MixedReader) HasCompilationError() bool {
-	return mr.hasCompilationErr
+// extractPackageName extracts package name from error header line
+func extractPackageName(line string) string {
+	if len(line) > 2 {
+		return line[2:] // Everything after "# "
+	}
+	return ""
 }
 
-// GetCompilationErrorPackage returns the package name from compilation error
-func (mr *MixedReader) GetCompilationErrorPackage() string {
-	return mr.errorPackage
+// isErrorMessage checks if line is a valid error message
+func isErrorMessage(line string) bool {
+	return line != "" && !strings.HasPrefix(line, "FAIL")
 }
 
-// GetCompilationErrorMessage returns the compilation error message
-func (mr *MixedReader) GetCompilationErrorMessage() string {
-	return mr.errorMessage
+// newCompilationError creates a new CompilationError
+func newCompilationError(pkg, msg string) *CompilationError {
+	return &CompilationError{
+		Package: pkg,
+		Message: msg,
+	}
 }