Extract common patterns to centralized helper utilities

Create cmd/helpers package to consolidate repeated patterns across commands
and reduce code duplication by ~200 lines while improving consistency.

New helpers package includes:
- error.go: Centralized error handling with ExitWithError() and ExitOnError()
- config.go: Config/StackEntry types and LoadConfig() functions
- fs.go: Filesystem utilities (WithWorkingDir, ResolveAbsPath, GetConfigDir)
- env.go: Environment variable utilities (GetEnvRequired, GetEnvOrDefault)

Updated commands to use helpers:
- init.go: Move Config types to helpers, use WithWorkingDir, ExitOnError
- check.go: Use LoadConfig, WithWorkingDir, ExitOnError, helpers.StackEntry
- update.go: Use LoadConfig, WithWorkingDir, ExitOnError, helpers.StackEntry
- push.go: Use LoadConfig, GetEnvRequired, ExitOnError, helpers.StackEntry
- fetch_catalog.go: Use ExitOnError for error handling
- autodetect.go: Use WithWorkingDir, ExitOnError
- root.go: Use ExitWithError for error handling
- check_test.go: Update tests to use helpers.StackEntry

Benefits:
- Consistent error handling with standardized exit codes
- Single source of truth for config loading and validation
- Cleaner directory context management
- Better code reusability and maintainability
- All tests passing, build successful

🤖 Generated with Claude Code

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

Author: ceritium

cmd/autodetect.go

@@ -2,8 +2,8 @@ package cmd
 
 import (
 	"fmt"
-	"os"
 
+	"github.com/stacktodate/stacktodate-cli/cmd/helpers"
 	"github.com/spf13/cobra"
 )
 
@@ -19,25 +19,18 @@ var autodetectCmd = &cobra.Command{
 			targetDir = args[0]
 		}
 
-		// Change to target directory for detection
-		originalDir, err := os.Getwd()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting current directory: %v\n", err)
-			os.Exit(1)
-		}
-
-		if targetDir != "." {
-			if err := os.Chdir(targetDir); err != nil {
-				fmt.Fprintf(os.Stderr, "Error changing to directory %s: %v\n", targetDir, err)
-				os.Exit(1)
-			}
-			defer os.Chdir(originalDir)
-		}
-
 		fmt.Printf("Scanning directory: %s\n", targetDir)
 
-		// Detect project information
-		info := DetectProjectInfo()
-		PrintDetectedInfo(info)
+		// Execute detection in target directory
+		err := helpers.WithWorkingDir(targetDir, func() error {
+			// Detect project information
+			info := DetectProjectInfo()
+			PrintDetectedInfo(info)
+			return nil
+		})
+
+		if err != nil {
+			helpers.ExitOnError(err, "failed to scan directory")
+		}
 	},
 }

cmd/check.go

@@ -4,10 +4,9 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"path/filepath"
 
+	"github.com/stacktodate/stacktodate-cli/cmd/helpers"
 	"github.com/spf13/cobra"
-	"gopkg.in/yaml.v3"
 )
 
 type CheckResult struct {
@@ -45,57 +44,39 @@ var checkCmd = &cobra.Command{
 	Short: "Check if detected versions match stacktodate.yml",
 	Long:  `Verify that the versions in stacktodate.yml match the currently detected versions in your project. Useful for CI/CD pipelines.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		// Determine config file
-		configPath := checkConfigFile
-		if configPath == "" {
-			configPath = "stacktodate.yml"
-		}
-
-		// Resolve absolute path
-		absConfigPath, err := filepath.Abs(configPath)
+		// Load config without requiring UUID
+		config, err := helpers.LoadConfig(checkConfigFile)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error resolving config path: %v\n", err)
-			os.Exit(2)
+			helpers.ExitWithError(2, "failed to load config: %v", err)
 		}
 
-		// Read config file
-		content, err := os.ReadFile(absConfigPath)
+		// Resolve absolute path for directory management
+		absConfigPath, err := helpers.ResolveAbsPath(checkConfigFile)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error reading config file %s: %v\n", configPath, err)
-			os.Exit(2)
-		}
-
-		// Parse YAML
-		var config Config
-		if err := yaml.Unmarshal(content, &config); err != nil {
-			fmt.Fprintf(os.Stderr, "Error parsing %s: %v\n", configPath, err)
-			os.Exit(2)
+			if checkConfigFile == "" {
+				absConfigPath, _ = helpers.ResolveAbsPath("stacktodate.yml")
+			} else {
+				helpers.ExitOnError(err, "failed to resolve config path")
+			}
 		}
 
-		// Change to config directory for detection
-		originalDir, err := os.Getwd()
+		// Get config directory
+		configDir, err := helpers.GetConfigDir(absConfigPath)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "Error getting current directory: %v\n", err)
-			os.Exit(2)
+			helpers.ExitOnError(err, "failed to get config directory")
 		}
 
-		configDir := filepath.Dir(absConfigPath)
-		if configDir == "" {
-			configDir = "."
-		}
-
-		if configDir != "." {
-			if err := os.Chdir(configDir); err != nil {
-				fmt.Fprintf(os.Stderr, "Error changing to directory: %v\n", err)
-				os.Exit(2)
-			}
-			defer os.Chdir(originalDir)
+		// Detect current versions in config directory
+		var detectedStack map[string]helpers.StackEntry
+		err = helpers.WithWorkingDir(configDir, func() error {
+			detectedInfo := DetectProjectInfo()
+			detectedStack = normalizeDetectedToStack(detectedInfo)
+			return nil
+		})
+		if err != nil {
+			helpers.ExitOnError(err, "failed to detect versions")
 		}
 
-		// Detect current versions
-		detectedInfo := DetectProjectInfo()
-		detectedStack := normalizeDetectedToStack(detectedInfo)
-
 		// Compare stacks
 		result := compareStacks(config.Stack, detectedStack)
 
@@ -113,39 +94,39 @@ var checkCmd = &cobra.Command{
 	},
 }
 
-func normalizeDetectedToStack(info DetectedInfo) map[string]StackEntry {
-	normalized := make(map[string]StackEntry)
+func normalizeDetectedToStack(info DetectedInfo) map[string]helpers.StackEntry {
+	normalized := make(map[string]helpers.StackEntry)
 
 	if len(info.Ruby) > 0 {
-		normalized["ruby"] = StackEntry{
+		normalized["ruby"] = helpers.StackEntry{
 			Version: info.Ruby[0].Value,
 			Source:  info.Ruby[0].Source,
 		}
 	}
 
 	if len(info.Rails) > 0 {
-		normalized["rails"] = StackEntry{
+		normalized["rails"] = helpers.StackEntry{
 			Version: info.Rails[0].Value,
 			Source:  info.Rails[0].Source,
 		}
 	}
 
 	if len(info.Node) > 0 {
-		normalized["nodejs"] = StackEntry{
+		normalized["nodejs"] = helpers.StackEntry{
 			Version: info.Node[0].Value,
 			Source:  info.Node[0].Source,
 		}
 	}
 
 	if len(info.Go) > 0 {
-		normalized["go"] = StackEntry{
+		normalized["go"] = helpers.StackEntry{
 			Version: info.Go[0].Value,
 			Source:  info.Go[0].Source,
 		}
 	}
 
 	if len(info.Python) > 0 {
-		normalized["python"] = StackEntry{
+		normalized["python"] = helpers.StackEntry{
 			Version: info.Python[0].Value,
 			Source:  info.Python[0].Source,
 		}
@@ -154,7 +135,7 @@ func normalizeDetectedToStack(info DetectedInfo) map[string]StackEntry {
 	return normalized
 }
 
-func compareStacks(configStack, detectedStack map[string]StackEntry) CheckResult {
+func compareStacks(configStack, detectedStack map[string]helpers.StackEntry) CheckResult {
 	result := CheckResult{
 		Results: CheckResults{
 			Matched:       []ComparisonEntry{},

cmd/check_test.go

@@ -2,6 +2,8 @@ package cmd
 
 import (
 	"testing"
+
+	"github.com/stacktodate/stacktodate-cli/cmd/helpers"
 )
 
 func TestNormalizeDetectedToStack(t *testing.T) {
@@ -55,12 +57,12 @@ func TestNormalizeDetectedToStack(t *testing.T) {
 }
 
 func TestCompareStacks_AllMatch(t *testing.T) {
-	configStack := map[string]StackEntry{
+	configStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"nodejs": {Version: "18.0.0", Source: ".nvmrc"},
 	}
 
-	detectedStack := map[string]StackEntry{
+	detectedStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"nodejs": {Version: "18.0.0", Source: ".nvmrc"},
 	}
@@ -81,12 +83,12 @@ func TestCompareStacks_AllMatch(t *testing.T) {
 }
 
 func TestCompareStacks_WithMismatch(t *testing.T) {
-	configStack := map[string]StackEntry{
+	configStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"rails":  {Version: "7.1.0", Source: "Gemfile"},
 	}
 
-	detectedStack := map[string]StackEntry{
+	detectedStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"rails":  {Version: "7.0.0", Source: "Gemfile"},
 	}
@@ -107,12 +109,12 @@ func TestCompareStacks_WithMismatch(t *testing.T) {
 }
 
 func TestCompareStacks_MissingConfig(t *testing.T) {
-	configStack := map[string]StackEntry{
+	configStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"nodejs": {Version: "18.0.0", Source: ".nvmrc"},
 	}
 
-	detectedStack := map[string]StackEntry{
+	detectedStack := map[string]helpers.StackEntry{
 		"ruby": {Version: "3.2.0", Source: ".ruby-version"},
 	}
 
@@ -132,14 +134,14 @@ func TestCompareStacks_MissingConfig(t *testing.T) {
 }
 
 func TestCompareStacks_Complex(t *testing.T) {
-	configStack := map[string]StackEntry{
+	configStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"rails":  {Version: "7.1.0", Source: "Gemfile"},
 		"nodejs": {Version: "18.0.0", Source: ".nvmrc"},
 		"python": {Version: "3.10", Source: ".python-version"},
 	}
 
-	detectedStack := map[string]StackEntry{
+	detectedStack := map[string]helpers.StackEntry{
 		"ruby":   {Version: "3.2.0", Source: ".ruby-version"},
 		"rails":  {Version: "7.0.0", Source: "Gemfile"},
 		"nodejs": {Version: "18.0.0", Source: ".nvmrc"},
@@ -166,8 +168,8 @@ func TestCompareStacks_Complex(t *testing.T) {
 }
 
 func TestCompareStacks_Empty(t *testing.T) {
-	configStack := map[string]StackEntry{}
-	detectedStack := map[string]StackEntry{}
+	configStack := map[string]helpers.StackEntry{}
+	detectedStack := map[string]helpers.StackEntry{}
 
 	result := compareStacks(configStack, detectedStack)
 

cmd/fetch_catalog.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/stacktodate/stacktodate-cli/cmd/helpers"
 	"github.com/stacktodate/stacktodate-cli/cmd/lib/cache"
 	"github.com/spf13/cobra"
 )
@@ -20,15 +21,13 @@ once every 24 hours. You can use this command to manually refresh the cache at a
 		fmt.Fprintf(os.Stderr, "Fetching product catalog from stacktodate.club...\n")
 
 		if err := cache.FetchAndCache(); err != nil {
-			fmt.Fprintf(os.Stderr, "✗ Error: %v\n", err)
-			os.Exit(1)
+			helpers.ExitOnError(err, "failed to fetch catalog")
 		}
 
 		// Load and display info about cached products
 		products, err := cache.LoadCache()
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "✗ Error loading cached products: %v\n", err)
-			os.Exit(1)
+			helpers.ExitOnError(err, "failed to load cached products")
 		}
 
 		cachePath, _ := cache.GetCachePath()

cmd/helpers/config.go

@@ -0,0 +1,55 @@
+package helpers
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+// Config represents the stacktodate.yml structure
+type Config struct {
+	UUID  string                `yaml:"uuid"`
+	Name  string                `yaml:"name"`
+	Stack map[string]StackEntry `yaml:"stack,omitempty"`
+}
+
+// StackEntry represents a single technology entry in the stack
+type StackEntry struct {
+	Version string `yaml:"version"`
+	Source  string `yaml:"source"`
+}
+
+// LoadConfig reads and parses a config file from the given path
+// If path is empty, uses "stacktodate.yml" as default
+func LoadConfig(configPath string) (*Config, error) {
+	if configPath == "" {
+		configPath = "stacktodate.yml"
+	}
+
+	content, err := os.ReadFile(configPath)
+	if err != nil {
+		return nil, fmt.Errorf("reading config file %s: %w", configPath, err)
+	}
+
+	var config Config
+	if err := yaml.Unmarshal(content, &config); err != nil {
+		return nil, fmt.Errorf("parsing config file %s: %w", configPath, err)
+	}
+
+	return &config, nil
+}
+
+// LoadConfigWithDefaults loads a config file with optional UUID validation
+func LoadConfigWithDefaults(configPath string, requireUUID bool) (*Config, error) {
+	config, err := LoadConfig(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	if requireUUID && config.UUID == "" {
+		return nil, fmt.Errorf("uuid not found in config file")
+	}
+
+	return config, nil
+}

cmd/helpers/env.go

@@ -0,0 +1,23 @@
+package helpers
+
+import (
+	"fmt"
+	"os"
+)
+
+// GetEnvRequired retrieves an environment variable or returns an error if not set
+func GetEnvRequired(key string) (string, error) {
+	value := os.Getenv(key)
+	if value == "" {
+		return "", fmt.Errorf("environment variable %s not set", key)
+	}
+	return value, nil
+}
+
+// GetEnvOrDefault retrieves an environment variable or returns the default value if not set
+func GetEnvOrDefault(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}