cleanup config

Author: kujtimiihoxha

internal/config/config.go

@@ -1,200 +1,284 @@
+// Package config manages application configuration from various sources.
 package config
 
 import (
 	"fmt"
+	"log/slog"
 	"os"
 	"strings"
 
 	"github.com/kujtimiihoxha/termai/internal/llm/models"
+	"github.com/kujtimiihoxha/termai/internal/logging"
 	"github.com/spf13/viper"
 )
 
+// MCPType defines the type of MCP (Model Control Protocol) server.
 type MCPType string
 
+// Supported MCP types
 const (
 	MCPStdio MCPType = "stdio"
 	MCPSse   MCPType = "sse"
 )
 
+// MCPServer defines the configuration for a Model Control Protocol server.
 type MCPServer struct {
 	Command string            `json:"command"`
 	Env     []string          `json:"env"`
 	Args    []string          `json:"args"`
 	Type    MCPType           `json:"type"`
 	URL     string            `json:"url"`
 	Headers map[string]string `json:"headers"`
-	// TODO: add permissions configuration
-	// TODO: add the ability to specify the tools to import
 }
 
+// Model defines configuration for different LLM models and their token limits.
 type Model struct {
 	Coder          models.ModelID `json:"coder"`
 	CoderMaxTokens int64          `json:"coderMaxTokens"`
-
-	Task          models.ModelID `json:"task"`
-	TaskMaxTokens int64          `json:"taskMaxTokens"`
-	// TODO: Maybe support multiple models for different purposes
-}
-
-type AnthropicConfig struct {
-	DisableCache bool `json:"disableCache"`
-	UseBedrock   bool `json:"useBedrock"`
+	Task           models.ModelID `json:"task"`
+	TaskMaxTokens  int64          `json:"taskMaxTokens"`
 }
 
+// Provider defines configuration for an LLM provider.
 type Provider struct {
-	APIKey  string `json:"apiKey"`
-	Enabled bool   `json:"enabled"`
+	APIKey   string `json:"apiKey"`
+	Disabled bool   `json:"disabled"`
 }
 
+// Data defines storage configuration.
 type Data struct {
 	Directory string `json:"directory"`
 }
 
-type Log struct {
-	Level string `json:"level"`
-}
-
+// LSPConfig defines configuration for Language Server Protocol integration.
 type LSPConfig struct {
 	Disabled bool     `json:"enabled"`
 	Command  string   `json:"command"`
 	Args     []string `json:"args"`
 	Options  any      `json:"options"`
 }
 
+// Config is the main configuration structure for the application.
 type Config struct {
-	Data       *Data                             `json:"data,omitempty"`
-	Log        *Log                              `json:"log,omitempty"`
+	Data       Data                              `json:"data"`
+	WorkingDir string                            `json:"wd,omitempty"`
 	MCPServers map[string]MCPServer              `json:"mcpServers,omitempty"`
 	Providers  map[models.ModelProvider]Provider `json:"providers,omitempty"`
-
-	LSP map[string]LSPConfig `json:"lsp,omitempty"`
-
-	Model *Model `json:"model,omitempty"`
-
-	Debug bool `json:"debug,omitempty"`
+	LSP        map[string]LSPConfig              `json:"lsp,omitempty"`
+	Model      Model                             `json:"model"`
+	Debug      bool                              `json:"debug,omitempty"`
 }
 
-var cfg *Config
-
+// Application constants
 const (
-	defaultDataDirectory = ".termai"
+	defaultDataDirectory = ".opencode"
 	defaultLogLevel      = "info"
 	defaultMaxTokens     = int64(5000)
-	termai               = "termai"
+	appName              = "opencode"
 )
 
-func Load(debug bool) error {
+// Global configuration instance
+var cfg *Config
+
+// Load initializes the configuration from environment variables and config files.
+// If debug is true, debug mode is enabled and log level is set to debug.
+// It returns an error if configuration loading fails.
+func Load(workingDir string, debug bool) error {
 	if cfg != nil {
 		return nil
 	}
 
-	viper.SetConfigName(fmt.Sprintf(".%s", termai))
+	cfg = &Config{
+		WorkingDir: workingDir,
+		MCPServers: make(map[string]MCPServer),
+		Providers:  make(map[models.ModelProvider]Provider),
+		LSP:        make(map[string]LSPConfig),
+	}
+
+	configureViper()
+	setDefaults(debug)
+	setProviderDefaults()
+
+	// Read global config
+	if err := readConfig(viper.ReadInConfig()); err != nil {
+		return err
+	}
+
+	// Load and merge local config
+	mergeLocalConfig(workingDir)
+
+	// Apply configuration to the struct
+	if err := viper.Unmarshal(cfg); err != nil {
+		return err
+	}
+
+	applyDefaultValues()
+
+	defaultLevel := slog.LevelInfo
+	if cfg.Debug {
+		defaultLevel = slog.LevelDebug
+	}
+	// Configure logger
+	logger := slog.New(slog.NewTextHandler(logging.NewWriter(), &slog.HandlerOptions{
+		Level: defaultLevel,
+	}))
+	slog.SetDefault(logger)
+	return nil
+}
+
+// configureViper sets up viper's configuration paths and environment variables.
+func configureViper() {
+	viper.SetConfigName(fmt.Sprintf(".%s", appName))
 	viper.SetConfigType("json")
 	viper.AddConfigPath("$HOME")
-	viper.AddConfigPath(fmt.Sprintf("$XDG_CONFIG_HOME/%s", termai))
-	viper.SetEnvPrefix(strings.ToUpper(termai))
+	viper.AddConfigPath(fmt.Sprintf("$XDG_CONFIG_HOME/%s", appName))
+	viper.SetEnvPrefix(strings.ToUpper(appName))
+	viper.AutomaticEnv()
+}
 
-	// Add defaults
+// setDefaults configures default values for configuration options.
+func setDefaults(debug bool) {
 	viper.SetDefault("data.directory", defaultDataDirectory)
+
 	if debug {
 		viper.SetDefault("debug", true)
 		viper.Set("log.level", "debug")
 	} else {
 		viper.SetDefault("debug", false)
 		viper.SetDefault("log.level", defaultLogLevel)
 	}
+}
+
+// setProviderDefaults configures LLM provider defaults based on environment variables.
+// the default model priority is:
+// 1. Anthropic
+// 2. OpenAI
+// 3. Google Gemini
+// 4. AWS Bedrock
+func setProviderDefaults() {
+	// Groq configuration
+	if apiKey := os.Getenv("GROQ_API_KEY"); apiKey != "" {
+		viper.SetDefault("providers.groq.apiKey", apiKey)
+		viper.SetDefault("model.coder", models.QWENQwq)
+		viper.SetDefault("model.coderMaxTokens", defaultMaxTokens)
+		viper.SetDefault("model.task", models.QWENQwq)
+		viper.SetDefault("model.taskMaxTokens", defaultMaxTokens)
+	}
+
+	// Google Gemini configuration
+	if apiKey := os.Getenv("GEMINI_API_KEY"); apiKey != "" {
+		viper.SetDefault("providers.gemini.apiKey", apiKey)
+		viper.SetDefault("model.coder", models.GRMINI20Flash)
+		viper.SetDefault("model.coderMaxTokens", defaultMaxTokens)
+		viper.SetDefault("model.task", models.GRMINI20Flash)
+		viper.SetDefault("model.taskMaxTokens", defaultMaxTokens)
+	}
 
-	defaultModelSet := false
-	if os.Getenv("ANTHROPIC_API_KEY") != "" {
-		viper.SetDefault("providers.anthropic.apiKey", os.Getenv("ANTHROPIC_API_KEY"))
-		viper.SetDefault("providers.anthropic.enabled", true)
+	// OpenAI configuration
+	if apiKey := os.Getenv("OPENAI_API_KEY"); apiKey != "" {
+		viper.SetDefault("providers.openai.apiKey", apiKey)
+		viper.SetDefault("model.coder", models.GPT4o)
+		viper.SetDefault("model.coderMaxTokens", defaultMaxTokens)
+		viper.SetDefault("model.task", models.GPT4o)
+		viper.SetDefault("model.taskMaxTokens", defaultMaxTokens)
+	}
+
+	// Anthropic configuration
+	if apiKey := os.Getenv("ANTHROPIC_API_KEY"); apiKey != "" {
+		viper.SetDefault("providers.anthropic.apiKey", apiKey)
 		viper.SetDefault("model.coder", models.Claude37Sonnet)
+		viper.SetDefault("model.coderMaxTokens", defaultMaxTokens)
 		viper.SetDefault("model.task", models.Claude37Sonnet)
-		defaultModelSet = true
-	}
-	if os.Getenv("OPENAI_API_KEY") != "" {
-		viper.SetDefault("providers.openai.apiKey", os.Getenv("OPENAI_API_KEY"))
-		viper.SetDefault("providers.openai.enabled", true)
-		if !defaultModelSet {
-			viper.SetDefault("model.coder", models.GPT41)
-			viper.SetDefault("model.task", models.GPT41)
-			defaultModelSet = true
-		}
+		viper.SetDefault("model.taskMaxTokens", defaultMaxTokens)
 	}
-	if os.Getenv("GEMINI_API_KEY") != "" {
-		viper.SetDefault("providers.gemini.apiKey", os.Getenv("GEMINI_API_KEY"))
-		viper.SetDefault("providers.gemini.enabled", true)
-		if !defaultModelSet {
-			viper.SetDefault("model.coder", models.GRMINI20Flash)
-			viper.SetDefault("model.task", models.GRMINI20Flash)
-			defaultModelSet = true
-		}
+
+	if hasAWSCredentials() {
+		viper.SetDefault("model.coder", models.BedrockClaude37Sonnet)
+		viper.SetDefault("model.coderMaxTokens", defaultMaxTokens)
+		viper.SetDefault("model.task", models.BedrockClaude37Sonnet)
+		viper.SetDefault("model.taskMaxTokens", defaultMaxTokens)
 	}
-	if os.Getenv("GROQ_API_KEY") != "" {
-		viper.SetDefault("providers.groq.apiKey", os.Getenv("GROQ_API_KEY"))
-		viper.SetDefault("providers.groq.enabled", true)
-		if !defaultModelSet {
-			viper.SetDefault("model.coder", models.QWENQwq)
-			viper.SetDefault("model.task", models.QWENQwq)
-			defaultModelSet = true
-		}
+}
+
+// hasAWSCredentials checks if AWS credentials are available in the environment.
+func hasAWSCredentials() bool {
+	// Check for explicit AWS credentials
+	if os.Getenv("AWS_ACCESS_KEY_ID") != "" && os.Getenv("AWS_SECRET_ACCESS_KEY") != "" {
+		return true
 	}
 
-	viper.SetDefault("providers.bedrock.enabled", true)
-	// TODO: add more providers
-	cfg = &Config{}
+	// Check for AWS profile
+	if os.Getenv("AWS_PROFILE") != "" || os.Getenv("AWS_DEFAULT_PROFILE") != "" {
+		return true
+	}
 
-	err := viper.ReadInConfig()
-	if err != nil {
-		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
-			return err
-		}
+	// Check for AWS region
+	if os.Getenv("AWS_REGION") != "" || os.Getenv("AWS_DEFAULT_REGION") != "" {
+		return true
 	}
-	local := viper.New()
-	local.SetConfigName(fmt.Sprintf(".%s", termai))
-	local.SetConfigType("json")
-	local.AddConfigPath(".")
-	// load local config, this will override the global config
-	if err = local.ReadInConfig(); err == nil {
-		viper.MergeConfigMap(local.AllSettings())
+
+	// Check if running on EC2 with instance profile
+	if os.Getenv("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
+		os.Getenv("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
+		return true
+	}
+
+	return false
+}
+
+// readConfig handles the result of reading a configuration file.
+func readConfig(err error) error {
+	if err == nil {
+		return nil
 	}
-	viper.Unmarshal(cfg)
 
-	if cfg.Model != nil && cfg.Model.CoderMaxTokens <= 0 {
-		cfg.Model.CoderMaxTokens = defaultMaxTokens
+	// It's okay if the config file doesn't exist
+	if _, ok := err.(viper.ConfigFileNotFoundError); ok {
+		return nil
 	}
-	if cfg.Model != nil && cfg.Model.TaskMaxTokens <= 0 {
-		cfg.Model.TaskMaxTokens = defaultMaxTokens
+
+	return err
+}
+
+// mergeLocalConfig loads and merges configuration from the local directory.
+func mergeLocalConfig(workingDir string) {
+	local := viper.New()
+	local.SetConfigName(fmt.Sprintf(".%s", appName))
+	local.SetConfigType("json")
+	local.AddConfigPath(workingDir)
+
+	// Merge local config if it exists
+	if err := local.ReadInConfig(); err == nil {
+		viper.MergeConfigMap(local.AllSettings())
 	}
+}
 
-	for _, v := range cfg.MCPServers {
+// applyDefaultValues sets default values for configuration fields that need processing.
+func applyDefaultValues() {
+	// Set default MCP type if not specified
+	for k, v := range cfg.MCPServers {
 		if v.Type == "" {
 			v.Type = MCPStdio
+			cfg.MCPServers[k] = v
 		}
 	}
+}
 
+// setWorkingDirectory stores the current working directory in the configuration.
+func setWorkingDirectory() {
 	workdir, err := os.Getwd()
-	if err != nil {
-		return err
+	if err == nil {
+		viper.Set("wd", workdir)
 	}
-	viper.Set("wd", workdir)
-	return nil
 }
 
+// Get returns the current configuration.
+// It's safe to call this function multiple times.
 func Get() *Config {
-	if cfg == nil {
-		err := Load(false)
-		if err != nil {
-			panic(err)
-		}
-	}
 	return cfg
 }
 
+// WorkingDirectory returns the current working directory from the configuration.
 func WorkingDirectory() string {
 	return viper.GetString("wd")
 }
-
-func Write() error {
-	return viper.WriteConfig()
-}