1package config
2
3import (
4 "encoding/json"
5 "fmt"
6 "io"
7 "log/slog"
8 "os"
9 "path/filepath"
10 "runtime"
11 "slices"
12 "strings"
13
14 "github.com/charmbracelet/catwalk/pkg/catwalk"
15 "github.com/charmbracelet/crush/internal/csync"
16 "github.com/charmbracelet/crush/internal/env"
17 "github.com/charmbracelet/crush/internal/llm/agent"
18 "github.com/charmbracelet/crush/internal/llm/provider"
19 "github.com/charmbracelet/crush/internal/log"
20 "github.com/charmbracelet/crush/internal/resolver"
21)
22
23const defaultCatwalkURL = "https://catwalk.charm.sh"
24
25// LoadReader config via io.Reader.
26func LoadReader(fd io.Reader) (*Config, error) {
27 data, err := io.ReadAll(fd)
28 if err != nil {
29 return nil, err
30 }
31
32 var config Config
33 err = json.Unmarshal(data, &config)
34 if err != nil {
35 return nil, err
36 }
37 return &config, err
38}
39
40// Load loads the configuration from the default paths.
41func Load(workingDir string, debug bool) (*Config, error) {
42 // uses default config paths
43 configPaths := []string{
44 globalConfig(),
45 GlobalConfigData(),
46 filepath.Join(workingDir, fmt.Sprintf("%s.json", appName)),
47 filepath.Join(workingDir, fmt.Sprintf(".%s.json", appName)),
48 }
49 cfg, err := loadFromConfigPaths(configPaths)
50 if err != nil {
51 return nil, fmt.Errorf("failed to load config from paths %v: %w", configPaths, err)
52 }
53
54 cfg.dataConfigDir = GlobalConfigData()
55
56 cfg.setDefaults(workingDir)
57
58 if debug {
59 cfg.Options.Debug = true
60 }
61
62 // Setup logs
63 log.Setup(
64 filepath.Join(cfg.Options.DataDirectory, "logs", fmt.Sprintf("%s.log", appName)),
65 cfg.Options.Debug,
66 )
67
68 // Load known providers, this loads the config from catwalk
69 providers, err := Providers()
70 if err != nil || len(providers) == 0 {
71 return nil, fmt.Errorf("failed to load providers: %w", err)
72 }
73 cfg.knownProviders = providers
74
75 env := env.New()
76 // Configure providers
77 valueResolver := resolver.NewShellVariableResolver(env)
78 cfg.resolver = valueResolver
79 if err := cfg.configureProviders(env, valueResolver, providers); err != nil {
80 return nil, fmt.Errorf("failed to configure providers: %w", err)
81 }
82
83 if !cfg.IsConfigured() {
84 slog.Warn("No providers configured")
85 return cfg, nil
86 }
87
88 if err := cfg.configureSelectedModels(providers); err != nil {
89 return nil, fmt.Errorf("failed to configure selected models: %w", err)
90 }
91 return cfg, nil
92}
93
94func (c *Config) configureProviders(env env.Env, resolver resolver.Resolver, knownProviders []catwalk.Provider) error {
95 knownProviderNames := make(map[string]bool)
96 for _, p := range knownProviders {
97 knownProviderNames[string(p.ID)] = true
98 config, configExists := c.Providers.Get(string(p.ID))
99 // if the user configured a known provider we need to allow it to override a couple of parameters
100 if configExists {
101 if config.Disable {
102 slog.Debug("Skipping provider due to disable flag", "provider", p.ID)
103 c.Providers.Del(string(p.ID))
104 continue
105 }
106 if config.BaseURL != "" {
107 p.APIEndpoint = config.BaseURL
108 }
109 if config.APIKey != "" {
110 p.APIKey = config.APIKey
111 }
112 if len(config.Models) > 0 {
113 models := []catwalk.Model{}
114 seen := make(map[string]bool)
115
116 for _, model := range config.Models {
117 if seen[model.ID] {
118 continue
119 }
120 seen[model.ID] = true
121 if model.Name == "" {
122 model.Name = model.ID
123 }
124 models = append(models, model)
125 }
126 for _, model := range p.Models {
127 if seen[model.ID] {
128 continue
129 }
130 seen[model.ID] = true
131 if model.Name == "" {
132 model.Name = model.ID
133 }
134 models = append(models, model)
135 }
136
137 p.Models = models
138 }
139 }
140 prepared := provider.Config{
141 ID: string(p.ID),
142 Name: p.Name,
143 BaseURL: p.APIEndpoint,
144 APIKey: p.APIKey,
145 Type: p.Type,
146 Disable: config.Disable,
147 ExtraHeaders: config.ExtraHeaders,
148 ExtraBody: config.ExtraBody,
149 ExtraParams: make(map[string]string),
150 Models: p.Models,
151 }
152
153 switch p.ID {
154 // Handle specific providers that require additional configuration
155 case catwalk.InferenceProviderVertexAI:
156 if !hasVertexCredentials(env) {
157 if configExists {
158 slog.Warn("Skipping Vertex AI provider due to missing credentials")
159 c.Providers.Del(string(p.ID))
160 }
161 continue
162 }
163 prepared.ExtraParams["project"] = env.Get("GOOGLE_CLOUD_PROJECT")
164 prepared.ExtraParams["location"] = env.Get("GOOGLE_CLOUD_LOCATION")
165 case catwalk.InferenceProviderAzure:
166 endpoint, err := resolver.ResolveValue(p.APIEndpoint)
167 if err != nil || endpoint == "" {
168 if configExists {
169 slog.Warn("Skipping Azure provider due to missing API endpoint", "provider", p.ID, "error", err)
170 c.Providers.Del(string(p.ID))
171 }
172 continue
173 }
174 prepared.BaseURL = endpoint
175 prepared.ExtraParams["apiVersion"] = env.Get("AZURE_OPENAI_API_VERSION")
176 case catwalk.InferenceProviderBedrock:
177 if !hasAWSCredentials(env) {
178 if configExists {
179 slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
180 c.Providers.Del(string(p.ID))
181 }
182 continue
183 }
184 for _, model := range p.Models {
185 if !strings.HasPrefix(model.ID, "anthropic.") {
186 return fmt.Errorf("bedrock provider only supports anthropic models for now, found: %s", model.ID)
187 }
188 }
189 default:
190 // if the provider api or endpoint are missing we skip them
191 v, err := resolver.ResolveValue(p.APIKey)
192 if v == "" || err != nil {
193 if configExists {
194 slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
195 c.Providers.Del(string(p.ID))
196 }
197 continue
198 }
199 }
200 c.Providers.Set(string(p.ID), prepared)
201 }
202
203 // validate the custom providers
204 for id, providerConfig := range c.Providers.Seq2() {
205 if knownProviderNames[id] {
206 continue
207 }
208
209 // Make sure the provider ID is set
210 providerConfig.ID = id
211 if providerConfig.Name == "" {
212 providerConfig.Name = id // Use ID as name if not set
213 }
214 // default to OpenAI if not set
215 if providerConfig.Type == "" {
216 providerConfig.Type = catwalk.TypeOpenAI
217 }
218
219 if providerConfig.Disable {
220 slog.Debug("Skipping custom provider due to disable flag", "provider", id)
221 c.Providers.Del(id)
222 continue
223 }
224 if providerConfig.APIKey == "" {
225 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
226 }
227 if providerConfig.BaseURL == "" {
228 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
229 c.Providers.Del(id)
230 continue
231 }
232 if len(providerConfig.Models) == 0 {
233 slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
234 c.Providers.Del(id)
235 continue
236 }
237 if providerConfig.Type != catwalk.TypeOpenAI && providerConfig.Type != catwalk.TypeAnthropic {
238 slog.Warn("Skipping custom provider because the provider type is not supported", "provider", id, "type", providerConfig.Type)
239 c.Providers.Del(id)
240 continue
241 }
242
243 apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
244 if apiKey == "" || err != nil {
245 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
246 }
247 baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
248 if baseURL == "" || err != nil {
249 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
250 c.Providers.Del(id)
251 continue
252 }
253
254 c.Providers.Set(id, providerConfig)
255 }
256 return nil
257}
258
259func (c *Config) setDefaults(workingDir string) {
260 c.workingDir = workingDir
261 if c.Options == nil {
262 c.Options = &Options{}
263 }
264 if c.Options.TUI == nil {
265 c.Options.TUI = &TUIOptions{}
266 }
267 if c.Options.ContextPaths == nil {
268 c.Options.ContextPaths = []string{}
269 }
270 if c.Options.DataDirectory == "" {
271 c.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
272 }
273 if c.Providers == nil {
274 c.Providers = csync.NewMap[string, provider.Config]()
275 }
276 if c.Models == nil {
277 c.Models = make(map[SelectedModelType]agent.Model)
278 }
279 if c.MCP == nil {
280 c.MCP = make(map[string]agent.MCPConfig)
281 }
282 if c.LSP == nil {
283 c.LSP = make(map[string]LSPConfig)
284 }
285
286 // Add the default context paths if they are not already present
287 c.Options.ContextPaths = append(defaultContextPaths, c.Options.ContextPaths...)
288 slices.Sort(c.Options.ContextPaths)
289 c.Options.ContextPaths = slices.Compact(c.Options.ContextPaths)
290}
291
292func (c *Config) defaultModelSelection(knownProviders []catwalk.Provider) (largeModel, smallModel agent.Model, err error) {
293 if len(knownProviders) == 0 && c.Providers.Len() == 0 {
294 err = fmt.Errorf("no providers configured, please configure at least one provider")
295 return
296 }
297
298 // Use the first provider enabled based on the known providers order
299 // if no provider found that is known use the first provider configured
300 for _, p := range knownProviders {
301 providerConfig, ok := c.Providers.Get(string(p.ID))
302 if !ok || providerConfig.Disable {
303 continue
304 }
305 defaultLargeModel := c.GetModel(string(p.ID), p.DefaultLargeModelID)
306 if defaultLargeModel == nil {
307 err = fmt.Errorf("default large model %s not found for provider %s", p.DefaultLargeModelID, p.ID)
308 return
309 }
310 largeModel = agent.Model{
311 Provider: string(p.ID),
312 Model: defaultLargeModel.ID,
313 MaxTokens: defaultLargeModel.DefaultMaxTokens,
314 ReasoningEffort: defaultLargeModel.DefaultReasoningEffort,
315 }
316
317 defaultSmallModel := c.GetModel(string(p.ID), p.DefaultSmallModelID)
318 if defaultSmallModel == nil {
319 err = fmt.Errorf("default small model %s not found for provider %s", p.DefaultSmallModelID, p.ID)
320 return
321 }
322 smallModel = agent.Model{
323 Provider: string(p.ID),
324 Model: defaultSmallModel.ID,
325 MaxTokens: defaultSmallModel.DefaultMaxTokens,
326 ReasoningEffort: defaultSmallModel.DefaultReasoningEffort,
327 }
328 return
329 }
330
331 enabledProviders := c.EnabledProviders()
332 slices.SortFunc(enabledProviders, func(a, b provider.Config) int {
333 return strings.Compare(a.ID, b.ID)
334 })
335
336 if len(enabledProviders) == 0 {
337 err = fmt.Errorf("no providers configured, please configure at least one provider")
338 return
339 }
340
341 providerConfig := enabledProviders[0]
342 if len(providerConfig.Models) == 0 {
343 err = fmt.Errorf("provider %s has no models configured", providerConfig.ID)
344 return
345 }
346 defaultLargeModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
347 largeModel = agent.Model{
348 Provider: providerConfig.ID,
349 Model: defaultLargeModel.ID,
350 MaxTokens: defaultLargeModel.DefaultMaxTokens,
351 }
352 defaultSmallModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
353 smallModel = agent.Model{
354 Provider: providerConfig.ID,
355 Model: defaultSmallModel.ID,
356 MaxTokens: defaultSmallModel.DefaultMaxTokens,
357 }
358 return
359}
360
361func (c *Config) configureSelectedModels(knownProviders []catwalk.Provider) error {
362 defaultLarge, defaultSmall, err := c.defaultModelSelection(knownProviders)
363 if err != nil {
364 return fmt.Errorf("failed to select default models: %w", err)
365 }
366 large, small := defaultLarge, defaultSmall
367
368 largeModelSelected, largeModelConfigured := c.Models[SelectedModelTypeLarge]
369 if largeModelConfigured {
370 if largeModelSelected.Model != "" {
371 large.Model = largeModelSelected.Model
372 }
373 if largeModelSelected.Provider != "" {
374 large.Provider = largeModelSelected.Provider
375 }
376 model := c.GetModel(large.Provider, large.Model)
377 if model == nil {
378 large = defaultLarge
379 // override the model type to large
380 err := c.UpdatePreferredModel(SelectedModelTypeLarge, large)
381 if err != nil {
382 return fmt.Errorf("failed to update preferred large model: %w", err)
383 }
384 } else {
385 if largeModelSelected.MaxTokens > 0 {
386 large.MaxTokens = largeModelSelected.MaxTokens
387 } else {
388 large.MaxTokens = model.DefaultMaxTokens
389 }
390 if largeModelSelected.ReasoningEffort != "" {
391 large.ReasoningEffort = largeModelSelected.ReasoningEffort
392 }
393 large.Think = largeModelSelected.Think
394 }
395 }
396 smallModelSelected, smallModelConfigured := c.Models[SelectedModelTypeSmall]
397 if smallModelConfigured {
398 if smallModelSelected.Model != "" {
399 small.Model = smallModelSelected.Model
400 }
401 if smallModelSelected.Provider != "" {
402 small.Provider = smallModelSelected.Provider
403 }
404
405 model := c.GetModel(small.Provider, small.Model)
406 if model == nil {
407 small = defaultSmall
408 // override the model type to small
409 err := c.UpdatePreferredModel(SelectedModelTypeSmall, small)
410 if err != nil {
411 return fmt.Errorf("failed to update preferred small model: %w", err)
412 }
413 } else {
414 if smallModelSelected.MaxTokens > 0 {
415 small.MaxTokens = smallModelSelected.MaxTokens
416 } else {
417 small.MaxTokens = model.DefaultMaxTokens
418 }
419 small.ReasoningEffort = smallModelSelected.ReasoningEffort
420 small.Think = smallModelSelected.Think
421 }
422 }
423 c.Models[SelectedModelTypeLarge] = large
424 c.Models[SelectedModelTypeSmall] = small
425 return nil
426}
427
428func loadFromConfigPaths(configPaths []string) (*Config, error) {
429 var configs []io.Reader
430
431 for _, path := range configPaths {
432 fd, err := os.Open(path)
433 if err != nil {
434 if os.IsNotExist(err) {
435 continue
436 }
437 return nil, fmt.Errorf("failed to open config file %s: %w", path, err)
438 }
439 defer fd.Close()
440
441 configs = append(configs, fd)
442 }
443
444 return loadFromReaders(configs)
445}
446
447func loadFromReaders(readers []io.Reader) (*Config, error) {
448 if len(readers) == 0 {
449 return &Config{}, nil
450 }
451
452 merged, err := Merge(readers)
453 if err != nil {
454 return nil, fmt.Errorf("failed to merge configuration readers: %w", err)
455 }
456
457 return LoadReader(merged)
458}
459
460func hasVertexCredentials(env env.Env) bool {
461 useVertex := env.Get("GOOGLE_GENAI_USE_VERTEXAI") == "true"
462 hasProject := env.Get("GOOGLE_CLOUD_PROJECT") != ""
463 hasLocation := env.Get("GOOGLE_CLOUD_LOCATION") != ""
464 return useVertex && hasProject && hasLocation
465}
466
467func hasAWSCredentials(env env.Env) bool {
468 if env.Get("AWS_ACCESS_KEY_ID") != "" && env.Get("AWS_SECRET_ACCESS_KEY") != "" {
469 return true
470 }
471
472 if env.Get("AWS_PROFILE") != "" || env.Get("AWS_DEFAULT_PROFILE") != "" {
473 return true
474 }
475
476 if env.Get("AWS_REGION") != "" || env.Get("AWS_DEFAULT_REGION") != "" {
477 return true
478 }
479
480 if env.Get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
481 env.Get("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
482 return true
483 }
484
485 return false
486}
487
488func globalConfig() string {
489 xdgConfigHome := os.Getenv("XDG_CONFIG_HOME")
490 if xdgConfigHome != "" {
491 return filepath.Join(xdgConfigHome, appName, fmt.Sprintf("%s.json", appName))
492 }
493
494 // return the path to the main config directory
495 // for windows, it should be in `%LOCALAPPDATA%/crush/`
496 // for linux and macOS, it should be in `$HOME/.config/crush/`
497 if runtime.GOOS == "windows" {
498 localAppData := os.Getenv("LOCALAPPDATA")
499 if localAppData == "" {
500 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
501 }
502 return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
503 }
504
505 return filepath.Join(os.Getenv("HOME"), ".config", appName, fmt.Sprintf("%s.json", appName))
506}
507
508// GlobalConfigData returns the path to the main data directory for the application.
509// this config is used when the app overrides configurations instead of updating the global config.
510func GlobalConfigData() string {
511 xdgDataHome := os.Getenv("XDG_DATA_HOME")
512 if xdgDataHome != "" {
513 return filepath.Join(xdgDataHome, appName, fmt.Sprintf("%s.json", appName))
514 }
515
516 // return the path to the main data directory
517 // for windows, it should be in `%LOCALAPPDATA%/crush/`
518 // for linux and macOS, it should be in `$HOME/.local/share/crush/`
519 if runtime.GOOS == "windows" {
520 localAppData := os.Getenv("LOCALAPPDATA")
521 if localAppData == "" {
522 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
523 }
524 return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
525 }
526
527 return filepath.Join(os.Getenv("HOME"), ".local", "share", appName, fmt.Sprintf("%s.json", appName))
528}
529
530func HomeDir() string {
531 homeDir := os.Getenv("HOME")
532 if homeDir == "" {
533 homeDir = os.Getenv("USERPROFILE") // For Windows compatibility
534 }
535 if homeDir == "" {
536 homeDir = os.Getenv("HOMEPATH") // Fallback for some environments
537 }
538 return homeDir
539}