fix: Prevent early exit in directory comparison with --exit-code flag

**Issue**: When using --exit-code flag with directory comparison, the
program would exit immediately upon finding the first file with
differences, preventing comparison of remaining files and display of
the summary.

**Root Cause**: Both compareFiles() and compareDirectories() were
calling os.Exit(1) directly when --exit-code was set and changes were
found. When compareFiles() was called from compareDirectories(), this
caused premature termination.

**Previous Behavior**:
1. Start comparing directory files
2. First file with differences triggers os.Exit(1) in compareFiles()
3. Program terminates immediately
4. Remaining files never compared
5. Summary never displayed

**Fixed Behavior**:
1. All files are compared
2. Summary is displayed
3. Then exit with code 1 if any changes were found

**Changes**:
- Refactored compareFiles() to return bool indicating if changes found
- Refactored compareDirectories() to return bool indicating if changes found
- Moved exit code handling to compare() function (main entry point)
- Both functions now return results instead of calling os.Exit directly
- The compare() function aggregates results and handles os.Exit

**Tests Added**:
- TestCompareFilesReturnValue: Verifies compareFiles returns correct boolean
- TestDirectoryComparisonDoesNotExitEarly: Ensures all files are compared
  before exit, even with --exit-code flag set

**Verification**:
- All existing tests pass
- New tests verify the fix
- Manual testing confirms all files compared before exit
- Coverage remains above threshold (84.1%)

Fixes issue #2 from PR review comments.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: pfrederiksen

cmd/configdiff/compare.go

@@ -21,7 +21,17 @@ func compare(oldFile, newFile string) error {
 		if !recursive {
 			return fmt.Errorf("comparing directories requires --recursive flag")
 		}
-		return compareDirectories(oldFile, newFile)
+		hasChanges, err := compareDirectories(oldFile, newFile)
+		if err != nil {
+			return err
+		}
+
+		// Handle exit code mode for directory comparison
+		if exitCode && hasChanges {
+			os.Exit(1)
+		}
+
+		return nil
 	}
 
 	// One is a directory and one isn't
@@ -33,11 +43,22 @@ func compare(oldFile, newFile string) error {
 	}
 
 	// Both are files (or stdin), proceed with normal comparison
-	return compareFiles(oldFile, newFile)
+	hasChanges, err := compareFiles(oldFile, newFile)
+	if err != nil {
+		return err
+	}
+
+	// Handle exit code mode for single file comparison
+	if exitCode && hasChanges {
+		os.Exit(1)
+	}
+
+	return nil
 }
 
-// compareFiles performs the diff operation between two files
-func compareFiles(oldFile, newFile string) error {
+// compareFiles performs the diff operation between two files.
+// Returns true if changes were found, false otherwise.
+func compareFiles(oldFile, newFile string) (bool, error) {
 	// Build CLI options from flags
 	cliOpts := cli.CLIOptions{
 		OldFile:        oldFile,
@@ -64,25 +85,25 @@ func compareFiles(oldFile, newFile string) error {
 
 	// Validate options
 	if err := cliOpts.Validate(); err != nil {
-		return err
+		return false, err
 	}
 
 	// Read old file
 	oldInput, err := cli.ReadInput(oldFile, cliOpts.GetOldFormat())
 	if err != nil {
-		return err
+		return false, err
 	}
 
 	// Read new file
 	newInput, err := cli.ReadInput(newFile, cliOpts.GetNewFormat())
 	if err != nil {
-		return err
+		return false, err
 	}
 
 	// Convert CLI options to library options
 	diffOpts, err := cliOpts.ToLibraryOptions()
 	if err != nil {
-		return err
+		return false, err
 	}
 
 	// Perform the diff
@@ -92,7 +113,7 @@ func compareFiles(oldFile, newFile string) error {
 		diffOpts,
 	)
 	if err != nil {
-		return fmt.Errorf("diff failed: %w", err)
+		return false, fmt.Errorf("diff failed: %w", err)
 	}
 
 	// Format and output results (unless quiet mode)
@@ -105,31 +126,28 @@ func compareFiles(oldFile, newFile string) error {
 			NewFile:        newFile,
 		})
 		if err != nil {
-			return err
+			return false, err
 		}
 
 		fmt.Println(output)
 	}
 
-	// Handle exit code mode
-	if exitCode && cli.HasChanges(result) {
-		os.Exit(1)
-	}
-
-	return nil
+	// Return whether changes were found
+	return cli.HasChanges(result), nil
 }
 
-// compareDirectories recursively compares two directories
-func compareDirectories(oldDir, newDir string) error {
+// compareDirectories recursively compares two directories.
+// Returns true if any changes were found, false otherwise.
+func compareDirectories(oldDir, newDir string) (bool, error) {
 	// Collect all config files from both directories
 	oldFiles, err := collectConfigFiles(oldDir)
 	if err != nil {
-		return fmt.Errorf("failed to scan old directory: %w", err)
+		return false, fmt.Errorf("failed to scan old directory: %w", err)
 	}
 
 	newFiles, err := collectConfigFiles(newDir)
 	if err != nil {
-		return fmt.Errorf("failed to scan new directory: %w", err)
+		return false, fmt.Errorf("failed to scan new directory: %w", err)
 	}
 
 	// Build set of all relative paths
@@ -163,14 +181,17 @@ func compareDirectories(oldDir, newDir string) error {
 				fmt.Printf("\n=== %s ===\n", relPath)
 			}
 
-			err := compareFiles(oldPath, newPath)
+			fileHasChanges, err := compareFiles(oldPath, newPath)
 			if err != nil {
 				if !quiet {
 					fmt.Printf("Error: %v\n", err)
 				}
 				continue
 			}
 			filesCompared++
+			if fileHasChanges {
+				hasAnyChanges = true
+			}
 		} else if newExists && !oldExists {
 			// File added
 			filesAdded++
@@ -195,12 +216,8 @@ func compareDirectories(oldDir, newDir string) error {
 			filesCompared, filesAdded, filesRemoved)
 	}
 
-	// Handle exit code mode
-	if exitCode && hasAnyChanges {
-		os.Exit(1)
-	}
-
-	return nil
+	// Return whether any changes were found
+	return hasAnyChanges, nil
 }
 
 // collectConfigFiles recursively finds all config files in a directory

cmd/configdiff/main_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@@ -226,7 +227,7 @@ func TestCompareDirectories(t *testing.T) {
 	quiet = true // Suppress output during test
 	exitCode = false
 
-	err := compareDirectories(oldDir, newDir)
+	_, err := compareDirectories(oldDir, newDir)
 	if err != nil {
 		t.Errorf("compareDirectories() error = %v", err)
 	}
@@ -306,3 +307,111 @@ func findSubstring(s, substr string) bool {
 	}
 	return false
 }
+
+func TestCompareFilesReturnValue(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Create files with no changes
+	sameFile1 := filepath.Join(tmpDir, "same1.yaml")
+	sameFile2 := filepath.Join(tmpDir, "same2.yaml")
+	if err := os.WriteFile(sameFile1, []byte("value: 1"), 0644); err != nil {
+		t.Fatalf("Failed to write file: %v", err)
+	}
+	if err := os.WriteFile(sameFile2, []byte("value: 1"), 0644); err != nil {
+		t.Fatalf("Failed to write file: %v", err)
+	}
+
+	// Create files with changes
+	diffFile1 := filepath.Join(tmpDir, "diff1.yaml")
+	diffFile2 := filepath.Join(tmpDir, "diff2.yaml")
+	if err := os.WriteFile(diffFile1, []byte("value: 1"), 0644); err != nil {
+		t.Fatalf("Failed to write file: %v", err)
+	}
+	if err := os.WriteFile(diffFile2, []byte("value: 2"), 0644); err != nil {
+		t.Fatalf("Failed to write file: %v", err)
+	}
+
+	tests := []struct {
+		name        string
+		oldFile     string
+		newFile     string
+		wantChanges bool
+		wantErr     bool
+	}{
+		{
+			name:        "no changes",
+			oldFile:     sameFile1,
+			newFile:     sameFile2,
+			wantChanges: false,
+			wantErr:     false,
+		},
+		{
+			name:        "with changes",
+			oldFile:     diffFile1,
+			newFile:     diffFile2,
+			wantChanges: true,
+			wantErr:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			quiet = true
+			exitCode = false
+
+			hasChanges, err := compareFiles(tt.oldFile, tt.newFile)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("compareFiles() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if hasChanges != tt.wantChanges {
+				t.Errorf("compareFiles() hasChanges = %v, want %v", hasChanges, tt.wantChanges)
+			}
+		})
+	}
+}
+
+func TestDirectoryComparisonDoesNotExitEarly(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	oldDir := filepath.Join(tmpDir, "old")
+	newDir := filepath.Join(tmpDir, "new")
+
+	if err := os.MkdirAll(oldDir, 0755); err != nil {
+		t.Fatalf("Failed to create old dir: %v", err)
+	}
+	if err := os.MkdirAll(newDir, 0755); err != nil {
+		t.Fatalf("Failed to create new dir: %v", err)
+	}
+
+	// Create multiple files with changes
+	// This tests that compareDirectories doesn't exit early when --exit-code is set
+	files := []string{"file1.yaml", "file2.yaml", "file3.yaml"}
+	for i, f := range files {
+		oldContent := fmt.Sprintf("value: %d", i)
+		newContent := fmt.Sprintf("value: %d", i+10)
+		if err := os.WriteFile(filepath.Join(oldDir, f), []byte(oldContent), 0644); err != nil {
+			t.Fatalf("Failed to write old file: %v", err)
+		}
+		if err := os.WriteFile(filepath.Join(newDir, f), []byte(newContent), 0644); err != nil {
+			t.Fatalf("Failed to write new file: %v", err)
+		}
+	}
+
+	// Run with quiet mode and exit-code flag
+	// The function should compare all files and return normally (not call os.Exit)
+	quiet = true
+	exitCode = true // This used to cause early exit, now it should work correctly
+
+	hasChanges, err := compareDirectories(oldDir, newDir)
+	if err != nil {
+		t.Errorf("compareDirectories() error = %v", err)
+	}
+
+	// Verify that changes were detected
+	if !hasChanges {
+		t.Error("compareDirectories() should have detected changes but didn't")
+	}
+
+	// If we get here, the function completed successfully without os.Exit
+	// The os.Exit would happen in the caller (compare function), not in compareDirectories
+}