fix(repo): Package json generating

Author: pedronauck

cmd/container.go

@@ -1,14 +1,18 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 
 	"github.com/compozy/releasepr/internal/config"
+	"github.com/compozy/releasepr/internal/logger"
 	"github.com/compozy/releasepr/internal/orchestrator"
 	"github.com/compozy/releasepr/internal/repository"
 	"github.com/compozy/releasepr/internal/service"
 	"github.com/spf13/afero"
+	"github.com/spf13/cobra"
+	"go.uber.org/zap"
 )
 
 // container holds all the dependencies for the application.
@@ -65,11 +69,25 @@ func InitCommands() error {
 	if err != nil {
 		return err
 	}
+	ctx := rootCmd.Context()
+	if ctx == nil {
+		return fmt.Errorf("root command context not initialized")
+	}
+	ctx = config.IntoContext(ctx, c.cfg)
+	appLogger, err := logger.New(c.cfg.LoggerConfig())
+	if err != nil {
+		return fmt.Errorf("failed to initialize logger: %w", err)
+	}
+	ctx = logger.IntoContext(ctx, appLogger)
+	rootCmd.SetContext(ctx)
+	rootCmd.PersistentPostRunE = func(cmd *cobra.Command, _ []string) error {
+		return logger.Sync(logger.FromContext(cmd.Context()))
+	}
 
 	// Individual commands have been replaced by orchestrator commands
 
 	// Add orchestrator-based commands
-	if err := addOrchestratorCommands(c); err != nil {
+	if err := addOrchestratorCommands(ctx, c); err != nil {
 		return err
 	}
 
@@ -79,7 +97,8 @@ func InitCommands() error {
 }
 
 // addOrchestratorCommands adds the new consolidated commands
-func addOrchestratorCommands(c *container) error {
+func addOrchestratorCommands(ctx context.Context, c *container) error {
+	log := logger.FromContext(ctx).Named("cmd.container")
 	// Initialize extended repositories for orchestrators
 	gitExtRepo, err := repository.NewGitExtendedRepository()
 	if err != nil {
@@ -98,23 +117,28 @@ func addOrchestratorCommands(c *container) error {
 	}
 	owner := c.cfg.GithubOwner
 	repo := c.cfg.GithubRepo
-	fmt.Printf("GitHub configuration: owner=%s, repo=%s, token_source=%s, token_present=%t, token_length=%d\n",
-		owner, repo, tokenSource, token != "", len(token))
+	log.Info("GitHub configuration",
+		zap.String("owner", owner),
+		zap.String("repo", repo),
+		zap.String("token_source", tokenSource),
+		zap.Bool("token_present", token != ""),
+		zap.Int("token_length", len(token)),
+	)
 	if owner == "" || repo == "" {
 		return fmt.Errorf("github owner/repo not configured; set GITHUB_REPOSITORY or config values")
 	}
 	var githubExtRepo repository.GithubExtendedRepository
 	if token == "" {
-		fmt.Fprintln(os.Stderr, "GitHub token not provided; GitHub operations will be skipped")
+		log.Warn("GitHub token not provided; GitHub operations will be skipped")
 		githubExtRepo = repository.NewGithubNoopExtendedRepository(owner, repo)
 	} else {
-		fmt.Printf("Initializing GitHub extended repository with token (length=%d)\n", len(token))
+		log.Info("Initializing GitHub extended repository", zap.Int("token_length", len(token)))
 		var err error
 		githubExtRepo, err = repository.NewGithubExtendedRepository(token, owner, repo)
 		if err != nil {
 			return fmt.Errorf("failed to initialize GitHub extended repository: %w", err)
 		}
-		fmt.Printf("Successfully initialized GitHub extended repository for %s/%s\n", owner, repo)
+		log.Info("Initialized GitHub extended repository", zap.String("owner", owner), zap.String("repo", repo))
 	}
 
 	// Create PR Release orchestrator

cmd/root.go

@@ -1,6 +1,9 @@
 package cmd
 
 import (
+	"errors"
+
+	"github.com/compozy/releasepr/internal/logger"
 	"github.com/spf13/cobra"
 )
 
@@ -11,5 +14,13 @@ var rootCmd = &cobra.Command{
 }
 
 func Execute() error {
-	return rootCmd.Execute()
+	execErr := rootCmd.Execute()
+	syncErr := logger.Sync(logger.FromContext(rootCmd.Context()))
+	if execErr != nil {
+		if syncErr != nil {
+			return errors.Join(execErr, syncErr)
+		}
+		return execErr
+	}
+	return syncErr
 }

go.mod

@@ -13,6 +13,7 @@ require (
 	github.com/spf13/cobra v1.10.1
 	github.com/spf13/viper v1.21.0
 	github.com/stretchr/testify v1.11.1
+	go.uber.org/zap v1.27.0
 	golang.org/x/oauth2 v0.31.0
 )
 
@@ -45,6 +46,7 @@ require (
 	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
+	go.uber.org/multierr v1.10.0 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/crypto v0.37.0 // indirect
 	golang.org/x/net v0.39.0 // indirect

go.sum

@@ -111,6 +111,12 @@ github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
 github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ=
+go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
+go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
 golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=

internal/config/config.go

@@ -7,6 +7,7 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/compozy/releasepr/internal/logger"
 	"github.com/go-git/go-git/v5"
 	"github.com/spf13/viper"
 )
@@ -17,13 +18,15 @@ type Config struct {
 	GithubRepo  string `mapstructure:"github_repo"`
 	ToolsDir    string `mapstructure:"tools_dir"`
 	NpmToken    string `mapstructure:"npm_token"`
+	LogLevel    string `mapstructure:"log_level"`
+	LogFormat   string `mapstructure:"log_format"`
 }
 
 var configFileCandidates = []string{".pr-release", ".compozy-release"}
 
 // DefaultConfig returns a Config with default values.
 func DefaultConfig() *Config {
-	return &Config{ToolsDir: "tools"}
+	return &Config{ToolsDir: "tools", LogLevel: "info", LogFormat: "json"}
 }
 
 // Validate validates the configuration.
@@ -42,9 +45,35 @@ func (c *Config) Validate() error {
 	if strings.Contains(c.ToolsDir, "..") {
 		return fmt.Errorf("tools_dir contains invalid path traversal")
 	}
+	if err := validateLogLevel(c.LogLevel); err != nil {
+		return err
+	}
+	if err := validateLogFormat(c.LogFormat); err != nil {
+		return err
+	}
 	return nil
 }
 
+func (c *Config) LoggerConfig() logger.Config {
+	return logger.Config{Level: c.LogLevel, Format: c.LogFormat}
+}
+
+func validateLogLevel(level string) error {
+	switch strings.ToLower(strings.TrimSpace(level)) {
+	case "debug", "info", "warn", "error":
+		return nil
+	}
+	return fmt.Errorf("invalid log_level: %s", level)
+}
+
+func validateLogFormat(format string) error {
+	switch strings.ToLower(strings.TrimSpace(format)) {
+	case "json", "console":
+		return nil
+	}
+	return fmt.Errorf("invalid log_format: %s", format)
+}
+
 // ValidateForGitHubOperations validates that GitHub token is present for operations that require it.
 func (c *Config) ValidateForGitHubOperations() error {
 	if c.GithubToken == "" {
@@ -97,6 +126,8 @@ func LoadConfig() (*Config, error) {
 	v := viper.New()
 	v.SetConfigType("yaml")
 	v.AddConfigPath(".")
+	v.SetDefault("log_level", "info")
+	v.SetDefault("log_format", "json")
 	v.AutomaticEnv()
 	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
 	if err := v.BindEnv(
@@ -127,6 +158,22 @@ func LoadConfig() (*Config, error) {
 	if err := v.BindEnv("tools_dir", "TOOLS_DIR", "PR_RELEASE_TOOLS_DIR", "COMPOZY_RELEASE_TOOLS_DIR"); err != nil {
 		return nil, fmt.Errorf("failed to bind tools_dir env: %w", err)
 	}
+	if err := v.BindEnv(
+		"log_level",
+		"LOG_LEVEL",
+		"PR_RELEASE_LOG_LEVEL",
+		"COMPOZY_RELEASE_LOG_LEVEL",
+	); err != nil {
+		return nil, fmt.Errorf("failed to bind log_level env: %w", err)
+	}
+	if err := v.BindEnv(
+		"log_format",
+		"LOG_FORMAT",
+		"PR_RELEASE_LOG_FORMAT",
+		"COMPOZY_RELEASE_LOG_FORMAT",
+	); err != nil {
+		return nil, fmt.Errorf("failed to bind log_format env: %w", err)
+	}
 	if err := v.BindEnv("npm_token", "NPM_TOKEN", "PR_RELEASE_NPM_TOKEN", "COMPOZY_RELEASE_NPM_TOKEN"); err != nil {
 		return nil, fmt.Errorf("failed to bind npm_token env: %w", err)
 	}

internal/config/context.go

@@ -0,0 +1,20 @@
+package config
+
+import "context"
+
+type contextKey struct{}
+
+func IntoContext(ctx context.Context, cfg *Config) context.Context {
+	return context.WithValue(ctx, contextKey{}, cfg)
+}
+
+func FromContext(ctx context.Context) *Config {
+	if ctx == nil {
+		panic("config: nil context")
+	}
+	cfg, ok := ctx.Value(contextKey{}).(*Config)
+	if !ok || cfg == nil {
+		panic("config: configuration missing from context")
+	}
+	return cfg
+}

internal/logger/logger.go

@@ -0,0 +1,116 @@
+package logger
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"syscall"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+type Config struct {
+	Level  string
+	Format string
+}
+
+type contextKey struct{}
+
+func New(cfg Config) (*zap.Logger, error) {
+	zapCfg, err := buildZapConfig(cfg)
+	if err != nil {
+		return nil, err
+	}
+	return zapCfg.Build()
+}
+
+func buildZapConfig(cfg Config) (zap.Config, error) {
+	format := strings.ToLower(strings.TrimSpace(cfg.Format))
+	var zapCfg zap.Config
+	switch format {
+	case "json":
+		zapCfg = zap.NewProductionConfig()
+	case "console":
+		zapCfg = zap.NewDevelopmentConfig()
+	default:
+		return zap.Config{}, fmt.Errorf("logger: unsupported format %s", cfg.Format)
+	}
+	level, err := parseLevel(cfg.Level)
+	if err != nil {
+		return zap.Config{}, err
+	}
+	zapCfg.Level = zap.NewAtomicLevelAt(level)
+	zapCfg.Encoding = format
+	encoder := zapcore.EncoderConfig{
+		TimeKey:        "ts",
+		LevelKey:       "level",
+		NameKey:        "logger",
+		CallerKey:      "caller",
+		MessageKey:     "msg",
+		StacktraceKey:  "stacktrace",
+		LineEnding:     zapcore.DefaultLineEnding,
+		EncodeLevel:    zapcore.LowercaseLevelEncoder,
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.SecondsDurationEncoder,
+		EncodeCaller:   zapcore.ShortCallerEncoder,
+	}
+	if format == "console" {
+		encoder.EncodeLevel = zapcore.CapitalColorLevelEncoder
+	}
+	zapCfg.EncoderConfig = encoder
+	zapCfg.OutputPaths = []string{"stdout"}
+	zapCfg.ErrorOutputPaths = []string{"stderr"}
+	return zapCfg, nil
+}
+
+func parseLevel(level string) (zapcore.Level, error) {
+	switch strings.ToLower(strings.TrimSpace(level)) {
+	case "debug":
+		return zapcore.DebugLevel, nil
+	case "info":
+		return zapcore.InfoLevel, nil
+	case "warn":
+		return zapcore.WarnLevel, nil
+	case "error":
+		return zapcore.ErrorLevel, nil
+	}
+	return zapcore.InfoLevel, fmt.Errorf("logger: unsupported level %s", level)
+}
+
+func IntoContext(ctx context.Context, log *zap.Logger) context.Context {
+	return context.WithValue(ctx, contextKey{}, log)
+}
+
+func FromContext(ctx context.Context) *zap.Logger {
+	if ctx == nil {
+		return zap.NewNop()
+	}
+	log, ok := ctx.Value(contextKey{}).(*zap.Logger)
+	if !ok || log == nil {
+		return zap.NewNop()
+	}
+	return log
+}
+
+func With(ctx context.Context, fields ...zap.Field) *zap.Logger {
+	return FromContext(ctx).With(fields...)
+}
+
+func Sync(log *zap.Logger) error {
+	if log == nil {
+		return nil
+	}
+	err := log.Sync()
+	if err == nil {
+		return nil
+	}
+	if errors.Is(err, syscall.ENOTSUP) {
+		return nil
+	}
+	if errors.Is(err, syscall.EINVAL) {
+		return nil
+	}
+	return err
+}