1package config
  2
  3import (
  4	"cmp"
  5	"context"
  6	"encoding/json"
  7	"fmt"
  8	"log/slog"
  9	"maps"
 10	"os"
 11	"os/exec"
 12	"path/filepath"
 13	"runtime"
 14	"slices"
 15	"strconv"
 16	"strings"
 17	"testing"
 18
 19	"charm.land/catwalk/pkg/catwalk"
 20	"git.secluded.site/crush/internal/agent/hyper"
 21	"git.secluded.site/crush/internal/csync"
 22	"git.secluded.site/crush/internal/env"
 23	"git.secluded.site/crush/internal/fsext"
 24	"git.secluded.site/crush/internal/home"
 25	"git.secluded.site/crush/internal/log"
 26	powernapConfig "github.com/charmbracelet/x/powernap/pkg/config"
 27	"github.com/qjebbs/go-jsons"
 28)
 29
 30const defaultCatwalkURL = "https://catwalk.charm.sh"
 31
 32// Load loads the configuration from the default paths.
 33func Load(workingDir, dataDir string, debug bool) (*Config, error) {
 34	configPaths := lookupConfigs(workingDir)
 35
 36	cfg, err := loadFromConfigPaths(configPaths)
 37	if err != nil {
 38		return nil, fmt.Errorf("failed to load config from paths %v: %w", configPaths, err)
 39	}
 40
 41	cfg.dataConfigDir = GlobalConfigData()
 42
 43	cfg.setDefaults(workingDir, dataDir)
 44
 45	if debug {
 46		cfg.Options.Debug = true
 47	}
 48
 49	// Setup logs
 50	log.Setup(
 51		filepath.Join(cfg.Options.DataDirectory, "logs", fmt.Sprintf("%s.log", appName)),
 52		cfg.Options.Debug,
 53	)
 54
 55	if !isInsideWorktree() {
 56		const depth = 2
 57		const items = 100
 58		slog.Warn("No git repository detected in working directory, will limit file walk operations", "depth", depth, "items", items)
 59		assignIfNil(&cfg.Tools.Ls.MaxDepth, depth)
 60		assignIfNil(&cfg.Tools.Ls.MaxItems, items)
 61		assignIfNil(&cfg.Options.TUI.Completions.MaxDepth, depth)
 62		assignIfNil(&cfg.Options.TUI.Completions.MaxItems, items)
 63	}
 64
 65	if isAppleTerminal() {
 66		slog.Warn("Detected Apple Terminal, enabling transparent mode")
 67		assignIfNil(&cfg.Options.TUI.Transparent, true)
 68	}
 69
 70	// Load known providers, this loads the config from catwalk
 71	providers, err := Providers(cfg)
 72	if err != nil {
 73		return nil, err
 74	}
 75	cfg.knownProviders = providers
 76
 77	env := env.New()
 78	// Configure providers
 79	valueResolver := NewShellVariableResolver(env)
 80	cfg.resolver = valueResolver
 81	if err := cfg.configureProviders(env, valueResolver, cfg.knownProviders); err != nil {
 82		return nil, fmt.Errorf("failed to configure providers: %w", err)
 83	}
 84
 85	if !cfg.IsConfigured() {
 86		slog.Warn("No providers configured")
 87		return cfg, nil
 88	}
 89
 90	if err := cfg.configureSelectedModels(cfg.knownProviders); err != nil {
 91		return nil, fmt.Errorf("failed to configure selected models: %w", err)
 92	}
 93	cfg.SetupAgents()
 94	return cfg, nil
 95}
 96
 97func PushPopCrushEnv() func() {
 98	var found []string
 99	for _, ev := range os.Environ() {
100		if strings.HasPrefix(ev, "CRUSH_") {
101			pair := strings.SplitN(ev, "=", 2)
102			if len(pair) != 2 {
103				continue
104			}
105			found = append(found, strings.TrimPrefix(pair[0], "CRUSH_"))
106		}
107	}
108	backups := make(map[string]string)
109	for _, ev := range found {
110		backups[ev] = os.Getenv(ev)
111	}
112
113	for _, ev := range found {
114		os.Setenv(ev, os.Getenv("CRUSH_"+ev))
115	}
116
117	restore := func() {
118		for k, v := range backups {
119			os.Setenv(k, v)
120		}
121	}
122	return restore
123}
124
125func (c *Config) configureProviders(env env.Env, resolver VariableResolver, knownProviders []catwalk.Provider) error {
126	knownProviderNames := make(map[string]bool)
127	restore := PushPopCrushEnv()
128	defer restore()
129
130	// When disable_default_providers is enabled, skip all default/embedded
131	// providers entirely. Users must fully specify any providers they want.
132	// We skip to the custom provider validation loop which handles all
133	// user-configured providers uniformly.
134	if c.Options.DisableDefaultProviders {
135		knownProviders = nil
136	}
137
138	for _, p := range knownProviders {
139		knownProviderNames[string(p.ID)] = true
140		config, configExists := c.Providers.Get(string(p.ID))
141		// if the user configured a known provider we need to allow it to override a couple of parameters
142		if configExists {
143			if config.BaseURL != "" {
144				p.APIEndpoint = config.BaseURL
145			}
146			if config.APIKey != "" {
147				p.APIKey = config.APIKey
148			}
149			if len(config.Models) > 0 {
150				models := []catwalk.Model{}
151				seen := make(map[string]bool)
152
153				for _, model := range config.Models {
154					if seen[model.ID] {
155						continue
156					}
157					seen[model.ID] = true
158					if model.Name == "" {
159						model.Name = model.ID
160					}
161					models = append(models, model)
162				}
163				for _, model := range p.Models {
164					if seen[model.ID] {
165						continue
166					}
167					seen[model.ID] = true
168					if model.Name == "" {
169						model.Name = model.ID
170					}
171					models = append(models, model)
172				}
173
174				p.Models = models
175			}
176		}
177
178		headers := map[string]string{}
179		if len(p.DefaultHeaders) > 0 {
180			maps.Copy(headers, p.DefaultHeaders)
181		}
182		if len(config.ExtraHeaders) > 0 {
183			maps.Copy(headers, config.ExtraHeaders)
184		}
185		for k, v := range headers {
186			resolved, err := resolver.ResolveValue(v)
187			if err != nil {
188				slog.Error("Could not resolve provider header", "err", err.Error())
189				continue
190			}
191			headers[k] = resolved
192		}
193		prepared := ProviderConfig{
194			ID:                 string(p.ID),
195			Name:               p.Name,
196			BaseURL:            p.APIEndpoint,
197			APIKey:             p.APIKey,
198			APIKeyTemplate:     p.APIKey, // Store original template for re-resolution
199			OAuthToken:         config.OAuthToken,
200			Type:               p.Type,
201			Disable:            config.Disable,
202			SystemPromptPrefix: config.SystemPromptPrefix,
203			ExtraHeaders:       headers,
204			ExtraBody:          config.ExtraBody,
205			ExtraParams:        make(map[string]string),
206			Models:             p.Models,
207		}
208
209		switch {
210		case p.ID == catwalk.InferenceProviderAnthropic && config.OAuthToken != nil:
211			// Claude Code subscription is not supported anymore. Remove to show onboarding.
212			c.RemoveConfigField("providers.anthropic")
213			c.Providers.Del(string(p.ID))
214			continue
215		case p.ID == catwalk.InferenceProviderCopilot && config.OAuthToken != nil:
216			prepared.SetupGitHubCopilot()
217		}
218
219		switch p.ID {
220		// Handle specific providers that require additional configuration
221		case catwalk.InferenceProviderVertexAI:
222			var (
223				project  = env.Get("VERTEXAI_PROJECT")
224				location = env.Get("VERTEXAI_LOCATION")
225			)
226			if project == "" || location == "" {
227				if configExists {
228					slog.Warn("Skipping Vertex AI provider due to missing credentials")
229					c.Providers.Del(string(p.ID))
230				}
231				continue
232			}
233			prepared.ExtraParams["project"] = project
234			prepared.ExtraParams["location"] = location
235		case catwalk.InferenceProviderAzure:
236			endpoint, err := resolver.ResolveValue(p.APIEndpoint)
237			if err != nil || endpoint == "" {
238				if configExists {
239					slog.Warn("Skipping Azure provider due to missing API endpoint", "provider", p.ID, "error", err)
240					c.Providers.Del(string(p.ID))
241				}
242				continue
243			}
244			prepared.BaseURL = endpoint
245			prepared.ExtraParams["apiVersion"] = env.Get("AZURE_OPENAI_API_VERSION")
246		case catwalk.InferenceProviderBedrock:
247			if !hasAWSCredentials(env) {
248				if configExists {
249					slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
250					c.Providers.Del(string(p.ID))
251				}
252				continue
253			}
254			prepared.ExtraParams["region"] = env.Get("AWS_REGION")
255			if prepared.ExtraParams["region"] == "" {
256				prepared.ExtraParams["region"] = env.Get("AWS_DEFAULT_REGION")
257			}
258			for _, model := range p.Models {
259				if !strings.HasPrefix(model.ID, "anthropic.") {
260					return fmt.Errorf("bedrock provider only supports anthropic models for now, found: %s", model.ID)
261				}
262			}
263		default:
264			// if the provider api or endpoint are missing we skip them
265			v, err := resolver.ResolveValue(p.APIKey)
266			if v == "" || err != nil {
267				if configExists {
268					slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
269					c.Providers.Del(string(p.ID))
270				}
271				continue
272			}
273		}
274		c.Providers.Set(string(p.ID), prepared)
275	}
276
277	// validate the custom providers
278	for id, providerConfig := range c.Providers.Seq2() {
279		if knownProviderNames[id] {
280			continue
281		}
282
283		// Make sure the provider ID is set
284		providerConfig.ID = id
285		providerConfig.Name = cmp.Or(providerConfig.Name, id) // Use ID as name if not set
286		// default to OpenAI if not set
287		providerConfig.Type = cmp.Or(providerConfig.Type, catwalk.TypeOpenAICompat)
288		if !slices.Contains(catwalk.KnownProviderTypes(), providerConfig.Type) && providerConfig.Type != hyper.Name {
289			slog.Warn("Skipping custom provider due to unsupported provider type", "provider", id)
290			c.Providers.Del(id)
291			continue
292		}
293
294		if providerConfig.Disable {
295			slog.Debug("Skipping custom provider due to disable flag", "provider", id)
296			c.Providers.Del(id)
297			continue
298		}
299		if providerConfig.APIKey == "" {
300			slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
301		}
302		if providerConfig.BaseURL == "" {
303			slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
304			c.Providers.Del(id)
305			continue
306		}
307		if len(providerConfig.Models) == 0 {
308			slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
309			c.Providers.Del(id)
310			continue
311		}
312		apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
313		if apiKey == "" || err != nil {
314			slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
315		}
316		baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
317		if baseURL == "" || err != nil {
318			slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
319			c.Providers.Del(id)
320			continue
321		}
322
323		for k, v := range providerConfig.ExtraHeaders {
324			resolved, err := resolver.ResolveValue(v)
325			if err != nil {
326				slog.Error("Could not resolve provider header", "err", err.Error())
327				continue
328			}
329			providerConfig.ExtraHeaders[k] = resolved
330		}
331
332		c.Providers.Set(id, providerConfig)
333	}
334
335	if c.Providers.Len() == 0 && c.Options.DisableDefaultProviders {
336		return fmt.Errorf("default providers are disabled and there are no custom providers are configured")
337	}
338
339	return nil
340}
341
342func (c *Config) setDefaults(workingDir, dataDir string) {
343	c.workingDir = workingDir
344	if c.Options == nil {
345		c.Options = &Options{}
346	}
347	if c.Options.TUI == nil {
348		c.Options.TUI = &TUIOptions{}
349	}
350	if c.Options.ContextPaths == nil {
351		c.Options.ContextPaths = []string{}
352	}
353	if c.Options.MemoryPaths == nil {
354		crushConfigDir := filepath.Dir(GlobalConfig())
355		c.Options.MemoryPaths = []string{
356			filepath.Join(crushConfigDir, "CRUSH.md"),
357			filepath.Join(filepath.Dir(crushConfigDir), "AGENTS.md"),
358		}
359	}
360	c.Options.ContextPaths = append(c.Options.ContextPaths, c.Options.MemoryPaths...)
361	if c.Options.SkillsPaths == nil {
362		c.Options.SkillsPaths = []string{}
363	}
364	if dataDir != "" {
365		c.Options.DataDirectory = dataDir
366	} else if c.Options.DataDirectory == "" {
367		if path, ok := fsext.LookupClosest(workingDir, defaultDataDirectory); ok {
368			c.Options.DataDirectory = path
369		} else {
370			c.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
371		}
372	}
373	if c.Providers == nil {
374		c.Providers = csync.NewMap[string, ProviderConfig]()
375	}
376	if c.Models == nil {
377		c.Models = make(map[SelectedModelType]SelectedModel)
378	}
379	if c.RecentModels == nil {
380		c.RecentModels = make(map[SelectedModelType][]SelectedModel)
381	}
382	if c.MCP == nil {
383		c.MCP = make(map[string]MCPConfig)
384	}
385	if c.LSP == nil {
386		c.LSP = make(map[string]LSPConfig)
387	}
388
389	// Apply defaults to LSP configurations
390	c.applyLSPDefaults()
391
392	// Add the default context paths if they are not already present
393	c.Options.ContextPaths = append(defaultContextPaths, c.Options.ContextPaths...)
394
395	slices.Sort(c.Options.ContextPaths)
396	c.Options.ContextPaths = slices.Compact(c.Options.ContextPaths)
397
398	// Add the default skills directories if not already present.
399	for _, dir := range GlobalSkillsDirs() {
400		if !slices.Contains(c.Options.SkillsPaths, dir) {
401			c.Options.SkillsPaths = append(c.Options.SkillsPaths, dir)
402		}
403	}
404
405	if str, ok := os.LookupEnv("CRUSH_DISABLE_PROVIDER_AUTO_UPDATE"); ok {
406		c.Options.DisableProviderAutoUpdate, _ = strconv.ParseBool(str)
407	}
408
409	if str, ok := os.LookupEnv("CRUSH_DISABLE_DEFAULT_PROVIDERS"); ok {
410		c.Options.DisableDefaultProviders, _ = strconv.ParseBool(str)
411	}
412
413	if c.Options.Attribution == nil {
414		c.Options.Attribution = &Attribution{
415			TrailerStyle:  TrailerStyleAssistedBy,
416			GeneratedWith: true,
417		}
418	} else if c.Options.Attribution.TrailerStyle == "" {
419		// Migrate deprecated co_authored_by or apply default
420		if c.Options.Attribution.CoAuthoredBy != nil {
421			if *c.Options.Attribution.CoAuthoredBy {
422				c.Options.Attribution.TrailerStyle = TrailerStyleCoAuthoredBy
423			} else {
424				c.Options.Attribution.TrailerStyle = TrailerStyleNone
425			}
426		} else {
427			c.Options.Attribution.TrailerStyle = TrailerStyleAssistedBy
428		}
429	}
430	c.Options.InitializeAs = cmp.Or(c.Options.InitializeAs, defaultInitializeAs)
431}
432
433// applyLSPDefaults applies default values from powernap to LSP configurations
434func (c *Config) applyLSPDefaults() {
435	// Get powernap's default configuration
436	configManager := powernapConfig.NewManager()
437	configManager.LoadDefaults()
438
439	// Apply defaults to each LSP configuration
440	for name, cfg := range c.LSP {
441		// Try to get defaults from powernap based on name or command name.
442		base, ok := configManager.GetServer(name)
443		if !ok {
444			base, ok = configManager.GetServer(cfg.Command)
445			if !ok {
446				continue
447			}
448		}
449		if cfg.Options == nil {
450			cfg.Options = base.Settings
451		}
452		if cfg.InitOptions == nil {
453			cfg.InitOptions = base.InitOptions
454		}
455		if len(cfg.FileTypes) == 0 {
456			cfg.FileTypes = base.FileTypes
457		}
458		if len(cfg.RootMarkers) == 0 {
459			cfg.RootMarkers = base.RootMarkers
460		}
461		cfg.Command = cmp.Or(cfg.Command, base.Command)
462		if len(cfg.Args) == 0 {
463			cfg.Args = base.Args
464		}
465		if len(cfg.Env) == 0 {
466			cfg.Env = base.Environment
467		}
468		// Update the config in the map
469		c.LSP[name] = cfg
470	}
471}
472
473func (c *Config) defaultModelSelection(knownProviders []catwalk.Provider) (largeModel SelectedModel, smallModel SelectedModel, err error) {
474	if len(knownProviders) == 0 && c.Providers.Len() == 0 {
475		err = fmt.Errorf("no providers configured, please configure at least one provider")
476		return largeModel, smallModel, err
477	}
478
479	// Use the first provider enabled based on the known providers order
480	// if no provider found that is known use the first provider configured
481	for _, p := range knownProviders {
482		providerConfig, ok := c.Providers.Get(string(p.ID))
483		if !ok || providerConfig.Disable {
484			continue
485		}
486		defaultLargeModel := c.GetModel(string(p.ID), p.DefaultLargeModelID)
487		if defaultLargeModel == nil {
488			err = fmt.Errorf("default large model %s not found for provider %s", p.DefaultLargeModelID, p.ID)
489			return largeModel, smallModel, err
490		}
491		largeModel = SelectedModel{
492			Provider:        string(p.ID),
493			Model:           defaultLargeModel.ID,
494			MaxTokens:       defaultLargeModel.DefaultMaxTokens,
495			ReasoningEffort: defaultLargeModel.DefaultReasoningEffort,
496		}
497
498		defaultSmallModel := c.GetModel(string(p.ID), p.DefaultSmallModelID)
499		if defaultSmallModel == nil {
500			err = fmt.Errorf("default small model %s not found for provider %s", p.DefaultSmallModelID, p.ID)
501			return largeModel, smallModel, err
502		}
503		smallModel = SelectedModel{
504			Provider:        string(p.ID),
505			Model:           defaultSmallModel.ID,
506			MaxTokens:       defaultSmallModel.DefaultMaxTokens,
507			ReasoningEffort: defaultSmallModel.DefaultReasoningEffort,
508		}
509		return largeModel, smallModel, err
510	}
511
512	enabledProviders := c.EnabledProviders()
513	slices.SortFunc(enabledProviders, func(a, b ProviderConfig) int {
514		return strings.Compare(a.ID, b.ID)
515	})
516
517	if len(enabledProviders) == 0 {
518		err = fmt.Errorf("no providers configured, please configure at least one provider")
519		return largeModel, smallModel, err
520	}
521
522	providerConfig := enabledProviders[0]
523	if len(providerConfig.Models) == 0 {
524		err = fmt.Errorf("provider %s has no models configured", providerConfig.ID)
525		return largeModel, smallModel, err
526	}
527	defaultLargeModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
528	largeModel = SelectedModel{
529		Provider:  providerConfig.ID,
530		Model:     defaultLargeModel.ID,
531		MaxTokens: defaultLargeModel.DefaultMaxTokens,
532	}
533	defaultSmallModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
534	smallModel = SelectedModel{
535		Provider:  providerConfig.ID,
536		Model:     defaultSmallModel.ID,
537		MaxTokens: defaultSmallModel.DefaultMaxTokens,
538	}
539	return largeModel, smallModel, err
540}
541
542func (c *Config) configureSelectedModels(knownProviders []catwalk.Provider) error {
543	defaultLarge, defaultSmall, err := c.defaultModelSelection(knownProviders)
544	if err != nil {
545		return fmt.Errorf("failed to select default models: %w", err)
546	}
547	large, small := defaultLarge, defaultSmall
548
549	largeModelSelected, largeModelConfigured := c.Models[SelectedModelTypeLarge]
550	if largeModelConfigured {
551		if largeModelSelected.Model != "" {
552			large.Model = largeModelSelected.Model
553		}
554		if largeModelSelected.Provider != "" {
555			large.Provider = largeModelSelected.Provider
556		}
557		model := c.GetModel(large.Provider, large.Model)
558		if model == nil {
559			large = defaultLarge
560			// override the model type to large
561			err := c.UpdatePreferredModel(SelectedModelTypeLarge, large)
562			if err != nil {
563				return fmt.Errorf("failed to update preferred large model: %w", err)
564			}
565		} else {
566			if largeModelSelected.MaxTokens > 0 {
567				large.MaxTokens = largeModelSelected.MaxTokens
568			} else {
569				large.MaxTokens = model.DefaultMaxTokens
570			}
571			if largeModelSelected.ReasoningEffort != "" {
572				large.ReasoningEffort = largeModelSelected.ReasoningEffort
573			}
574			large.Think = largeModelSelected.Think
575			if largeModelSelected.Temperature != nil {
576				large.Temperature = largeModelSelected.Temperature
577			}
578			if largeModelSelected.TopP != nil {
579				large.TopP = largeModelSelected.TopP
580			}
581			if largeModelSelected.TopK != nil {
582				large.TopK = largeModelSelected.TopK
583			}
584			if largeModelSelected.FrequencyPenalty != nil {
585				large.FrequencyPenalty = largeModelSelected.FrequencyPenalty
586			}
587			if largeModelSelected.PresencePenalty != nil {
588				large.PresencePenalty = largeModelSelected.PresencePenalty
589			}
590		}
591	}
592	smallModelSelected, smallModelConfigured := c.Models[SelectedModelTypeSmall]
593	if smallModelConfigured {
594		if smallModelSelected.Model != "" {
595			small.Model = smallModelSelected.Model
596		}
597		if smallModelSelected.Provider != "" {
598			small.Provider = smallModelSelected.Provider
599		}
600
601		model := c.GetModel(small.Provider, small.Model)
602		if model == nil {
603			small = defaultSmall
604			// override the model type to small
605			err := c.UpdatePreferredModel(SelectedModelTypeSmall, small)
606			if err != nil {
607				return fmt.Errorf("failed to update preferred small model: %w", err)
608			}
609		} else {
610			if smallModelSelected.MaxTokens > 0 {
611				small.MaxTokens = smallModelSelected.MaxTokens
612			} else {
613				small.MaxTokens = model.DefaultMaxTokens
614			}
615			if smallModelSelected.ReasoningEffort != "" {
616				small.ReasoningEffort = smallModelSelected.ReasoningEffort
617			}
618			if smallModelSelected.Temperature != nil {
619				small.Temperature = smallModelSelected.Temperature
620			}
621			if smallModelSelected.TopP != nil {
622				small.TopP = smallModelSelected.TopP
623			}
624			if smallModelSelected.TopK != nil {
625				small.TopK = smallModelSelected.TopK
626			}
627			if smallModelSelected.FrequencyPenalty != nil {
628				small.FrequencyPenalty = smallModelSelected.FrequencyPenalty
629			}
630			if smallModelSelected.PresencePenalty != nil {
631				small.PresencePenalty = smallModelSelected.PresencePenalty
632			}
633			small.Think = smallModelSelected.Think
634		}
635	}
636	c.Models[SelectedModelTypeLarge] = large
637	c.Models[SelectedModelTypeSmall] = small
638	return nil
639}
640
641// lookupConfigs searches config files recursively from CWD up to FS root
642func lookupConfigs(cwd string) []string {
643	// prepend default config paths
644	configPaths := []string{
645		GlobalConfig(),
646		GlobalConfigData(),
647	}
648
649	configNames := []string{appName + ".json", "." + appName + ".json"}
650
651	foundConfigs, err := fsext.Lookup(cwd, configNames...)
652	if err != nil {
653		// returns at least default configs
654		return configPaths
655	}
656
657	// reverse order so last config has more priority
658	slices.Reverse(foundConfigs)
659
660	return append(configPaths, foundConfigs...)
661}
662
663func loadFromConfigPaths(configPaths []string) (*Config, error) {
664	var configs [][]byte
665
666	for _, path := range configPaths {
667		data, err := os.ReadFile(path)
668		if err != nil {
669			if os.IsNotExist(err) {
670				continue
671			}
672			return nil, fmt.Errorf("failed to open config file %s: %w", path, err)
673		}
674		if len(data) == 0 {
675			continue
676		}
677		configs = append(configs, data)
678	}
679
680	return loadFromBytes(configs)
681}
682
683func loadFromBytes(configs [][]byte) (*Config, error) {
684	if len(configs) == 0 {
685		return &Config{}, nil
686	}
687
688	data, err := jsons.Merge(configs)
689	if err != nil {
690		return nil, err
691	}
692	var config Config
693	if err := json.Unmarshal(data, &config); err != nil {
694		return nil, err
695	}
696	return &config, nil
697}
698
699func hasAWSCredentials(env env.Env) bool {
700	if env.Get("AWS_BEARER_TOKEN_BEDROCK") != "" {
701		return true
702	}
703
704	if env.Get("AWS_ACCESS_KEY_ID") != "" && env.Get("AWS_SECRET_ACCESS_KEY") != "" {
705		return true
706	}
707
708	if env.Get("AWS_PROFILE") != "" || env.Get("AWS_DEFAULT_PROFILE") != "" {
709		return true
710	}
711
712	if env.Get("AWS_REGION") != "" || env.Get("AWS_DEFAULT_REGION") != "" {
713		return true
714	}
715
716	if env.Get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
717		env.Get("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
718		return true
719	}
720
721	if _, err := os.Stat(filepath.Join(home.Dir(), ".aws/credentials")); err == nil && !testing.Testing() {
722		return true
723	}
724
725	return false
726}
727
728// GlobalConfig returns the global configuration file path for the application.
729func GlobalConfig() string {
730	if crushGlobal := os.Getenv("CRUSH_GLOBAL_CONFIG"); crushGlobal != "" {
731		return filepath.Join(crushGlobal, fmt.Sprintf("%s.json", appName))
732	}
733	if xdgConfigHome := os.Getenv("XDG_CONFIG_HOME"); xdgConfigHome != "" {
734		return filepath.Join(xdgConfigHome, appName, fmt.Sprintf("%s.json", appName))
735	}
736	return filepath.Join(home.Dir(), ".config", appName, fmt.Sprintf("%s.json", appName))
737}
738
739// GlobalConfigData returns the path to the main data directory for the application.
740// this config is used when the app overrides configurations instead of updating the global config.
741func GlobalConfigData() string {
742	if crushData := os.Getenv("CRUSH_GLOBAL_DATA"); crushData != "" {
743		return filepath.Join(crushData, fmt.Sprintf("%s.json", appName))
744	}
745	if xdgDataHome := os.Getenv("XDG_DATA_HOME"); xdgDataHome != "" {
746		return filepath.Join(xdgDataHome, appName, fmt.Sprintf("%s.json", appName))
747	}
748
749	// return the path to the main data directory
750	// for windows, it should be in `%LOCALAPPDATA%/crush/`
751	// for linux and macOS, it should be in `$HOME/.local/share/crush/`
752	if runtime.GOOS == "windows" {
753		localAppData := cmp.Or(
754			os.Getenv("LOCALAPPDATA"),
755			filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
756		)
757		return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
758	}
759
760	return filepath.Join(home.Dir(), ".local", "share", appName, fmt.Sprintf("%s.json", appName))
761}
762
763func assignIfNil[T any](ptr **T, val T) {
764	if *ptr == nil {
765		*ptr = &val
766	}
767}
768
769func isInsideWorktree() bool {
770	bts, err := exec.CommandContext(
771		context.Background(),
772		"git", "rev-parse",
773		"--is-inside-work-tree",
774	).CombinedOutput()
775	return err == nil && strings.TrimSpace(string(bts)) == "true"
776}
777
778// GlobalSkillsDirs returns the default directories for Agent Skills.
779// Skills in these directories are auto-discovered and their files can be read
780// without permission prompts.
781func GlobalSkillsDirs() []string {
782	if crushSkills := os.Getenv("CRUSH_SKILLS_DIR"); crushSkills != "" {
783		return []string{crushSkills}
784	}
785
786	// Determine the base config directory.
787	var configBase string
788	if xdgConfigHome := os.Getenv("XDG_CONFIG_HOME"); xdgConfigHome != "" {
789		configBase = xdgConfigHome
790	} else if runtime.GOOS == "windows" {
791		configBase = cmp.Or(
792			os.Getenv("LOCALAPPDATA"),
793			filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
794		)
795	} else {
796		configBase = filepath.Join(home.Dir(), ".config")
797	}
798
799	return []string{
800		filepath.Join(configBase, appName, "skills"),
801		filepath.Join(configBase, "agents", "skills"),
802	}
803}
804
805func isAppleTerminal() bool { return os.Getenv("TERM_PROGRAM") == "Apple_Terminal" }