1package config
2
3import (
4 "encoding/json"
5 "fmt"
6 "io"
7 "log/slog"
8 "maps"
9 "os"
10 "path/filepath"
11 "runtime"
12 "slices"
13 "strconv"
14 "strings"
15
16 "github.com/charmbracelet/catwalk/pkg/catwalk"
17 "github.com/charmbracelet/crush/internal/csync"
18 "github.com/charmbracelet/crush/internal/fsext"
19 "github.com/charmbracelet/crush/internal/home"
20 "github.com/charmbracelet/crush/internal/version"
21 uv "github.com/charmbracelet/ultraviolet"
22 powernapConfig "github.com/charmbracelet/x/powernap/pkg/config"
23)
24
25type environ = uv.Environ
26
27const defaultCatwalkURL = "https://catwalk.charm.sh"
28
29// LoadReader config via io.Reader.
30func LoadReader(fd io.Reader) (*Config, error) {
31 data, err := io.ReadAll(fd)
32 if err != nil {
33 return nil, err
34 }
35
36 var config Config
37 err = json.Unmarshal(data, &config)
38 if err != nil {
39 return nil, err
40 }
41 return &config, err
42}
43
44// Load loads the configuration from the default paths.
45func Load(workingDir, dataDir string, debug bool, envs []string) (*Config, error) {
46 configPaths := lookupConfigs(workingDir)
47
48 cfg, err := loadFromConfigPaths(configPaths)
49 if err != nil {
50 return nil, fmt.Errorf("failed to load config from paths %v: %w", configPaths, err)
51 }
52
53 cfg.dataConfigDir = GlobalConfigData()
54
55 cfg.setDefaults(workingDir, dataDir)
56
57 if debug {
58 cfg.Options.Debug = true
59 }
60
61 // Load known providers, this loads the config from catwalk
62 providers, err := Providers(cfg)
63 if err != nil {
64 return nil, err
65 }
66 cfg.knownProviders = providers
67
68 // Configure providers
69 valueResolver := NewShellVariableResolver(envs)
70 cfg.resolver = valueResolver
71 if err := cfg.configureProviders(envs, valueResolver, cfg.knownProviders); err != nil {
72 return nil, fmt.Errorf("failed to configure providers: %w", err)
73 }
74
75 if !cfg.IsConfigured() {
76 slog.Warn("No providers configured")
77 return cfg, nil
78 }
79
80 if err := cfg.configureSelectedModels(cfg.knownProviders); err != nil {
81 return nil, fmt.Errorf("failed to configure selected models: %w", err)
82 }
83 cfg.SetupAgents()
84 return cfg, nil
85}
86
87func PushPopCrushEnv() func() {
88 found := []string{}
89 for _, ev := range os.Environ() {
90 if strings.HasPrefix(ev, "CRUSH_") {
91 pair := strings.SplitN(ev, "=", 2)
92 if len(pair) != 2 {
93 continue
94 }
95 found = append(found, strings.TrimPrefix(pair[0], "CRUSH_"))
96 }
97 }
98 backups := make(map[string]string)
99 for _, ev := range found {
100 backups[ev] = os.Getenv(ev)
101 }
102
103 for _, ev := range found {
104 os.Setenv(ev, os.Getenv("CRUSH_"+ev))
105 }
106
107 restore := func() {
108 for k, v := range backups {
109 os.Setenv(k, v)
110 }
111 }
112 return restore
113}
114
115func (c *Config) configureProviders(env environ, resolver VariableResolver, knownProviders []catwalk.Provider) error {
116 knownProviderNames := make(map[string]bool)
117 restore := PushPopCrushEnv()
118 defer restore()
119 for _, p := range knownProviders {
120 knownProviderNames[string(p.ID)] = true
121 config, configExists := c.Providers.Get(string(p.ID))
122 // if the user configured a known provider we need to allow it to override a couple of parameters
123 if configExists {
124 if config.BaseURL != "" {
125 p.APIEndpoint = config.BaseURL
126 }
127 if config.APIKey != "" {
128 p.APIKey = config.APIKey
129 }
130 if len(config.Models) > 0 {
131 models := []catwalk.Model{}
132 seen := make(map[string]bool)
133
134 for _, model := range config.Models {
135 if seen[model.ID] {
136 continue
137 }
138 seen[model.ID] = true
139 if model.Name == "" {
140 model.Name = model.ID
141 }
142 models = append(models, model)
143 }
144 for _, model := range p.Models {
145 if seen[model.ID] {
146 continue
147 }
148 seen[model.ID] = true
149 if model.Name == "" {
150 model.Name = model.ID
151 }
152 models = append(models, model)
153 }
154
155 p.Models = models
156 }
157 }
158
159 headers := map[string]string{}
160 if len(p.DefaultHeaders) > 0 {
161 maps.Copy(headers, p.DefaultHeaders)
162 }
163 if len(config.ExtraHeaders) > 0 {
164 maps.Copy(headers, config.ExtraHeaders)
165 }
166 prepared := ProviderConfig{
167 ID: string(p.ID),
168 Name: p.Name,
169 BaseURL: p.APIEndpoint,
170 APIKey: p.APIKey,
171 Type: p.Type,
172 Disable: config.Disable,
173 SystemPromptPrefix: config.SystemPromptPrefix,
174 ExtraHeaders: headers,
175 ExtraBody: config.ExtraBody,
176 ExtraParams: make(map[string]string),
177 Models: p.Models,
178 }
179
180 switch p.ID {
181 // Handle specific providers that require additional configuration
182 case catwalk.InferenceProviderVertexAI:
183 if !hasVertexCredentials(env) {
184 if configExists {
185 slog.Warn("Skipping Vertex AI provider due to missing credentials")
186 c.Providers.Del(string(p.ID))
187 }
188 continue
189 }
190 prepared.ExtraParams["project"] = env.Getenv("VERTEXAI_PROJECT")
191 prepared.ExtraParams["location"] = env.Getenv("VERTEXAI_LOCATION")
192 case catwalk.InferenceProviderAzure:
193 endpoint, err := resolver.ResolveValue(p.APIEndpoint)
194 if err != nil || endpoint == "" {
195 if configExists {
196 slog.Warn("Skipping Azure provider due to missing API endpoint", "provider", p.ID, "error", err)
197 c.Providers.Del(string(p.ID))
198 }
199 continue
200 }
201 prepared.BaseURL = endpoint
202 prepared.ExtraParams["apiVersion"] = env.Getenv("AZURE_OPENAI_API_VERSION")
203 case catwalk.InferenceProviderBedrock:
204 if !hasAWSCredentials(env) {
205 if configExists {
206 slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
207 c.Providers.Del(string(p.ID))
208 }
209 continue
210 }
211 prepared.ExtraParams["region"] = env.Getenv("AWS_REGION")
212 if prepared.ExtraParams["region"] == "" {
213 prepared.ExtraParams["region"] = env.Getenv("AWS_DEFAULT_REGION")
214 }
215 for _, model := range p.Models {
216 if !strings.HasPrefix(model.ID, "anthropic.") {
217 return fmt.Errorf("bedrock provider only supports anthropic models for now, found: %s", model.ID)
218 }
219 }
220 default:
221 // if the provider api or endpoint are missing we skip them
222 v, err := resolver.ResolveValue(p.APIKey)
223 if v == "" || err != nil {
224 if configExists {
225 slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
226 c.Providers.Del(string(p.ID))
227 }
228 continue
229 }
230 }
231 c.Providers.Set(string(p.ID), prepared)
232 }
233
234 // validate the custom providers
235 for id, providerConfig := range c.Providers.Seq2() {
236 if knownProviderNames[id] {
237 continue
238 }
239
240 // Make sure the provider ID is set
241 providerConfig.ID = id
242 if providerConfig.Name == "" {
243 providerConfig.Name = id // Use ID as name if not set
244 }
245 // default to OpenAI if not set
246 if providerConfig.Type == "" {
247 providerConfig.Type = catwalk.TypeOpenAI
248 }
249
250 if providerConfig.Disable {
251 slog.Debug("Skipping custom provider due to disable flag", "provider", id)
252 c.Providers.Del(id)
253 continue
254 }
255 if providerConfig.APIKey == "" {
256 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
257 }
258 if providerConfig.BaseURL == "" {
259 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
260 c.Providers.Del(id)
261 continue
262 }
263 if len(providerConfig.Models) == 0 {
264 slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
265 c.Providers.Del(id)
266 continue
267 }
268 if providerConfig.Type != catwalk.TypeOpenAI && providerConfig.Type != catwalk.TypeAnthropic && providerConfig.Type != catwalk.TypeGemini {
269 slog.Warn("Skipping custom provider because the provider type is not supported", "provider", id, "type", providerConfig.Type)
270 c.Providers.Del(id)
271 continue
272 }
273
274 apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
275 if apiKey == "" || err != nil {
276 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
277 }
278 baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
279 if baseURL == "" || err != nil {
280 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
281 c.Providers.Del(id)
282 continue
283 }
284
285 c.Providers.Set(id, providerConfig)
286 }
287 return nil
288}
289
290func (c *Config) setDefaults(workingDir, dataDir string) {
291 c.workingDir = workingDir
292 if c.Options == nil {
293 c.Options = &Options{}
294 }
295 if c.Options.TUI == nil {
296 c.Options.TUI = &TUIOptions{}
297 }
298 if c.Options.ContextPaths == nil {
299 c.Options.ContextPaths = []string{}
300 }
301 if dataDir != "" {
302 c.Options.DataDirectory = dataDir
303 } else if c.Options.DataDirectory == "" {
304 if path, ok := fsext.LookupClosest(workingDir, defaultDataDirectory); ok {
305 c.Options.DataDirectory = path
306 } else {
307 c.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
308 }
309 }
310 if c.Providers == nil {
311 c.Providers = csync.NewMap[string, ProviderConfig]()
312 }
313 if c.Models == nil {
314 c.Models = make(map[SelectedModelType]SelectedModel)
315 }
316 if c.MCP == nil {
317 c.MCP = make(map[string]MCPConfig)
318 }
319 if c.LSP == nil {
320 c.LSP = make(map[string]LSPConfig)
321 }
322
323 // Apply defaults to LSP configurations
324 c.applyLSPDefaults()
325
326 // Add the default context paths if they are not already present
327 c.Options.ContextPaths = append(defaultContextPaths, c.Options.ContextPaths...)
328 slices.Sort(c.Options.ContextPaths)
329 c.Options.ContextPaths = slices.Compact(c.Options.ContextPaths)
330
331 if str, ok := os.LookupEnv("CRUSH_DISABLE_PROVIDER_AUTO_UPDATE"); ok {
332 c.Options.DisableProviderAutoUpdate, _ = strconv.ParseBool(str)
333 }
334}
335
336// applyLSPDefaults applies default values from powernap to LSP configurations
337func (c *Config) applyLSPDefaults() {
338 // Get powernap's default configuration
339 configManager := powernapConfig.NewManager()
340 configManager.LoadDefaults()
341
342 // Apply defaults to each LSP configuration
343 for name, cfg := range c.LSP {
344 // Try to get defaults from powernap based on name or command name.
345 base, ok := configManager.GetServer(name)
346 if !ok {
347 base, ok = configManager.GetServer(cfg.Command)
348 if !ok {
349 continue
350 }
351 }
352 if cfg.Options == nil {
353 cfg.Options = base.Settings
354 }
355 if cfg.InitOptions == nil {
356 cfg.InitOptions = base.InitOptions
357 }
358 if len(cfg.FileTypes) == 0 {
359 cfg.FileTypes = base.FileTypes
360 }
361 if len(cfg.RootMarkers) == 0 {
362 cfg.RootMarkers = base.RootMarkers
363 }
364 if cfg.Command == "" {
365 cfg.Command = base.Command
366 }
367 if len(cfg.Args) == 0 {
368 cfg.Args = base.Args
369 }
370 if len(cfg.Env) == 0 {
371 cfg.Env = base.Environment
372 }
373 // Update the config in the map
374 c.LSP[name] = cfg
375 }
376}
377
378func (c *Config) defaultModelSelection(knownProviders []catwalk.Provider) (largeModel SelectedModel, smallModel SelectedModel, err error) {
379 if len(knownProviders) == 0 && c.Providers.Len() == 0 {
380 err = fmt.Errorf("no providers configured, please configure at least one provider")
381 return largeModel, smallModel, err
382 }
383
384 // Use the first provider enabled based on the known providers order
385 // if no provider found that is known use the first provider configured
386 for _, p := range knownProviders {
387 providerConfig, ok := c.Providers.Get(string(p.ID))
388 if !ok || providerConfig.Disable {
389 continue
390 }
391 defaultLargeModel := c.GetModel(string(p.ID), p.DefaultLargeModelID)
392 if defaultLargeModel == nil {
393 err = fmt.Errorf("default large model %s not found for provider %s", p.DefaultLargeModelID, p.ID)
394 return largeModel, smallModel, err
395 }
396 largeModel = SelectedModel{
397 Provider: string(p.ID),
398 Model: defaultLargeModel.ID,
399 MaxTokens: defaultLargeModel.DefaultMaxTokens,
400 ReasoningEffort: defaultLargeModel.DefaultReasoningEffort,
401 }
402
403 defaultSmallModel := c.GetModel(string(p.ID), p.DefaultSmallModelID)
404 if defaultSmallModel == nil {
405 err = fmt.Errorf("default small model %s not found for provider %s", p.DefaultSmallModelID, p.ID)
406 return largeModel, smallModel, err
407 }
408 smallModel = SelectedModel{
409 Provider: string(p.ID),
410 Model: defaultSmallModel.ID,
411 MaxTokens: defaultSmallModel.DefaultMaxTokens,
412 ReasoningEffort: defaultSmallModel.DefaultReasoningEffort,
413 }
414 return largeModel, smallModel, err
415 }
416
417 enabledProviders := c.EnabledProviders()
418 slices.SortFunc(enabledProviders, func(a, b ProviderConfig) int {
419 return strings.Compare(a.ID, b.ID)
420 })
421
422 if len(enabledProviders) == 0 {
423 err = fmt.Errorf("no providers configured, please configure at least one provider")
424 return largeModel, smallModel, err
425 }
426
427 providerConfig := enabledProviders[0]
428 if len(providerConfig.Models) == 0 {
429 err = fmt.Errorf("provider %s has no models configured", providerConfig.ID)
430 return largeModel, smallModel, err
431 }
432 defaultLargeModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
433 largeModel = SelectedModel{
434 Provider: providerConfig.ID,
435 Model: defaultLargeModel.ID,
436 MaxTokens: defaultLargeModel.DefaultMaxTokens,
437 }
438 defaultSmallModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
439 smallModel = SelectedModel{
440 Provider: providerConfig.ID,
441 Model: defaultSmallModel.ID,
442 MaxTokens: defaultSmallModel.DefaultMaxTokens,
443 }
444 return largeModel, smallModel, err
445}
446
447func (c *Config) configureSelectedModels(knownProviders []catwalk.Provider) error {
448 defaultLarge, defaultSmall, err := c.defaultModelSelection(knownProviders)
449 if err != nil {
450 return fmt.Errorf("failed to select default models: %w", err)
451 }
452 large, small := defaultLarge, defaultSmall
453
454 largeModelSelected, largeModelConfigured := c.Models[SelectedModelTypeLarge]
455 if largeModelConfigured {
456 if largeModelSelected.Model != "" {
457 large.Model = largeModelSelected.Model
458 }
459 if largeModelSelected.Provider != "" {
460 large.Provider = largeModelSelected.Provider
461 }
462 model := c.GetModel(large.Provider, large.Model)
463 if model == nil {
464 large = defaultLarge
465 // override the model type to large
466 err := c.UpdatePreferredModel(SelectedModelTypeLarge, large)
467 if err != nil {
468 return fmt.Errorf("failed to update preferred large model: %w", err)
469 }
470 } else {
471 if largeModelSelected.MaxTokens > 0 {
472 large.MaxTokens = largeModelSelected.MaxTokens
473 } else {
474 large.MaxTokens = model.DefaultMaxTokens
475 }
476 if largeModelSelected.ReasoningEffort != "" {
477 large.ReasoningEffort = largeModelSelected.ReasoningEffort
478 }
479 large.Think = largeModelSelected.Think
480 }
481 }
482 smallModelSelected, smallModelConfigured := c.Models[SelectedModelTypeSmall]
483 if smallModelConfigured {
484 if smallModelSelected.Model != "" {
485 small.Model = smallModelSelected.Model
486 }
487 if smallModelSelected.Provider != "" {
488 small.Provider = smallModelSelected.Provider
489 }
490
491 model := c.GetModel(small.Provider, small.Model)
492 if model == nil {
493 small = defaultSmall
494 // override the model type to small
495 err := c.UpdatePreferredModel(SelectedModelTypeSmall, small)
496 if err != nil {
497 return fmt.Errorf("failed to update preferred small model: %w", err)
498 }
499 } else {
500 if smallModelSelected.MaxTokens > 0 {
501 small.MaxTokens = smallModelSelected.MaxTokens
502 } else {
503 small.MaxTokens = model.DefaultMaxTokens
504 }
505 small.ReasoningEffort = smallModelSelected.ReasoningEffort
506 small.Think = smallModelSelected.Think
507 }
508 }
509 c.Models[SelectedModelTypeLarge] = large
510 c.Models[SelectedModelTypeSmall] = small
511 return nil
512}
513
514// lookupConfigs searches config files recursively from CWD up to FS root
515func lookupConfigs(cwd string) []string {
516 // prepend default config paths
517 configPaths := []string{
518 globalConfig(),
519 GlobalConfigData(),
520 }
521
522 if cwd == "" {
523 return configPaths
524 }
525
526 configNames := []string{version.AppName + ".json", "." + version.AppName + ".json"}
527
528 foundConfigs, err := fsext.Lookup(cwd, configNames...)
529 if err != nil {
530 // returns at least default configs
531 return configPaths
532 }
533
534 // reverse order so last config has more priority
535 slices.Reverse(foundConfigs)
536
537 return append(configPaths, foundConfigs...)
538}
539
540func loadFromConfigPaths(configPaths []string) (*Config, error) {
541 var configs []io.Reader
542
543 for _, path := range configPaths {
544 fd, err := os.Open(path)
545 if err != nil {
546 if os.IsNotExist(err) {
547 continue
548 }
549 return nil, fmt.Errorf("failed to open config file %s: %w", path, err)
550 }
551 defer fd.Close()
552
553 configs = append(configs, fd)
554 }
555
556 return loadFromReaders(configs)
557}
558
559func loadFromReaders(readers []io.Reader) (*Config, error) {
560 if len(readers) == 0 {
561 return &Config{}, nil
562 }
563
564 merged, err := Merge(readers)
565 if err != nil {
566 return nil, fmt.Errorf("failed to merge configuration readers: %w", err)
567 }
568
569 return LoadReader(merged)
570}
571
572func hasVertexCredentials(env environ) bool {
573 hasProject := env.Getenv("VERTEXAI_PROJECT") != ""
574 hasLocation := env.Getenv("VERTEXAI_LOCATION") != ""
575 return hasProject && hasLocation
576}
577
578func hasAWSCredentials(env environ) bool {
579 if env.Getenv("AWS_ACCESS_KEY_ID") != "" && env.Getenv("AWS_SECRET_ACCESS_KEY") != "" {
580 return true
581 }
582
583 if env.Getenv("AWS_PROFILE") != "" || env.Getenv("AWS_DEFAULT_PROFILE") != "" {
584 return true
585 }
586
587 if env.Getenv("AWS_REGION") != "" || env.Getenv("AWS_DEFAULT_REGION") != "" {
588 return true
589 }
590
591 if env.Getenv("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
592 env.Getenv("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
593 return true
594 }
595 return false
596}
597
598func globalConfig() string {
599 xdgConfigHome := os.Getenv("XDG_CONFIG_HOME")
600 if xdgConfigHome != "" {
601 return filepath.Join(xdgConfigHome, version.AppName, fmt.Sprintf("%s.json", version.AppName))
602 }
603
604 // return the path to the main config directory
605 // for windows, it should be in `%LOCALAPPDATA%/crush/`
606 // for linux and macOS, it should be in `$HOME/.config/crush/`
607 if runtime.GOOS == "windows" {
608 localAppData := os.Getenv("LOCALAPPDATA")
609 if localAppData == "" {
610 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
611 }
612 return filepath.Join(localAppData, version.AppName, fmt.Sprintf("%s.json", version.AppName))
613 }
614
615 return filepath.Join(home.Dir(), ".config", version.AppName, fmt.Sprintf("%s.json", version.AppName))
616}
617
618// GlobalConfigData returns the path to the main data directory for the application.
619// this config is used when the app overrides configurations instead of updating the global config.
620func GlobalConfigData() string {
621 xdgDataHome := os.Getenv("XDG_DATA_HOME")
622 if xdgDataHome != "" {
623 return filepath.Join(xdgDataHome, version.AppName, fmt.Sprintf("%s.json", version.AppName))
624 }
625
626 // return the path to the main data directory
627 // for windows, it should be in `%LOCALAPPDATA%/crush/`
628 // for linux and macOS, it should be in `$HOME/.local/share/crush/`
629 if runtime.GOOS == "windows" {
630 localAppData := os.Getenv("LOCALAPPDATA")
631 if localAppData == "" {
632 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
633 }
634 return filepath.Join(localAppData, version.AppName, fmt.Sprintf("%s.json", version.AppName))
635 }
636
637 return filepath.Join(home.Dir(), ".local", "share", version.AppName, fmt.Sprintf("%s.json", version.AppName))
638}
639
640// GlobalCacheDir returns the path to the main cache directory for the application.
641func GlobalCacheDir() string {
642 xdgCacheHome := os.Getenv("XDG_CACHE_HOME")
643 if xdgCacheHome != "" {
644 return filepath.Join(xdgCacheHome, version.AppName)
645 }
646
647 // return the path to the main cache directory
648 // for windows, it should be in `%LOCALAPPDATA%/crush/Cache`
649 // for linux and macOS, it should be in `$HOME/.cache/crush/`
650 if runtime.GOOS == "windows" {
651 localAppData := os.Getenv("LOCALAPPDATA")
652 if localAppData == "" {
653 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
654 }
655 return filepath.Join(localAppData, version.AppName, "Cache")
656 }
657
658 return filepath.Join(home.Dir(), ".cache", version.AppName)
659}