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 "regexp"
14 "runtime"
15 "slices"
16 "strconv"
17 "strings"
18 "testing"
19
20 "charm.land/catwalk/pkg/catwalk"
21 "github.com/charmbracelet/crush/internal/agent/hyper"
22 "github.com/charmbracelet/crush/internal/csync"
23 "github.com/charmbracelet/crush/internal/env"
24 "github.com/charmbracelet/crush/internal/filepathext"
25 "github.com/charmbracelet/crush/internal/fsext"
26 "github.com/charmbracelet/crush/internal/home"
27 powernapConfig "github.com/charmbracelet/x/powernap/pkg/config"
28 "github.com/qjebbs/go-jsons"
29)
30
31const defaultCatwalkURL = "https://catwalk.charm.land"
32
33// Load loads the configuration from the default paths and returns a
34// ConfigStore that owns both the pure-data Config and all runtime state.
35func Load(workingDir, dataDir string, debug bool) (*ConfigStore, error) {
36 configPaths := lookupConfigs(workingDir)
37
38 cfg, loadedPaths, err := loadFromConfigPaths(configPaths)
39 if err != nil {
40 return nil, fmt.Errorf("failed to load config from paths %v: %w", configPaths, err)
41 }
42
43 cfg.setDefaults(workingDir, dataDir)
44
45 store := &ConfigStore{
46 config: cfg,
47 workingDir: workingDir,
48 globalDataPath: GlobalConfigData(),
49 workspacePath: filepath.Join(cfg.Options.DataDirectory, fmt.Sprintf("%s.json", appName)),
50 loadedPaths: loadedPaths,
51 }
52
53 if debug {
54 cfg.Options.Debug = true
55 }
56
57 // Load workspace config last so it has highest priority.
58 if wsData, err := os.ReadFile(store.workspacePath); err == nil && len(wsData) > 0 {
59 if !json.Valid(wsData) {
60 return nil, fmt.Errorf("invalid JSON in config file %s", store.workspacePath)
61 }
62 merged, mergeErr := loadFromBytes(append([][]byte{mustMarshalConfig(cfg)}, wsData))
63 if mergeErr == nil {
64 // Preserve defaults that setDefaults already applied.
65 dataDir := cfg.Options.DataDirectory
66 *cfg = *merged
67 cfg.setDefaults(workingDir, dataDir)
68 store.config = cfg
69 store.loadedPaths = append(store.loadedPaths, store.workspacePath)
70 }
71 }
72
73 // Validate hooks after all config merging is complete so workspace
74 // hooks also get their matcher regexes compiled.
75 if err := cfg.ValidateHooks(); err != nil {
76 return nil, fmt.Errorf("invalid hook configuration: %w", err)
77 }
78
79 if !isInsideWorktree() {
80 const depth = 2
81 const items = 100
82 slog.Warn("No git repository detected in working directory, will limit file walk operations", "depth", depth, "items", items)
83 assignIfNil(&cfg.Tools.Ls.MaxDepth, depth)
84 assignIfNil(&cfg.Tools.Ls.MaxItems, items)
85 assignIfNil(&cfg.Options.TUI.Completions.MaxDepth, depth)
86 assignIfNil(&cfg.Options.TUI.Completions.MaxItems, items)
87 }
88
89 if isAppleTerminal() {
90 slog.Warn("Detected Apple Terminal, enabling transparent mode")
91 assignIfNil(&cfg.Options.TUI.Transparent, true)
92 }
93
94 // Load known providers, this loads the config from catwalk
95 providers, err := Providers(cfg)
96 if err != nil {
97 return nil, err
98 }
99 store.knownProviders = providers
100
101 env := env.New()
102 // Configure providers
103 valueResolver := NewShellVariableResolver(env)
104 store.resolver = valueResolver
105
106 // Disable auto-reload during initial load to prevent nested calls from
107 // config-modifying operations inside configureProviders.
108 store.autoReloadDisabled = true
109 defer func() { store.autoReloadDisabled = false }()
110
111 if err := cfg.configureProviders(store, env, valueResolver, store.knownProviders); err != nil {
112 return nil, fmt.Errorf("failed to configure providers: %w", err)
113 }
114
115 if !cfg.IsConfigured() {
116 slog.Warn("No providers configured")
117 return store, nil
118 }
119
120 if err := configureSelectedModels(store, store.knownProviders, true); err != nil {
121 return nil, fmt.Errorf("failed to configure selected models: %w", err)
122 }
123 store.SetupAgents()
124
125 // Capture initial staleness snapshot
126 store.captureStalenessSnapshot(loadedPaths)
127
128 return store, nil
129}
130
131// mustMarshalConfig marshals the config to JSON bytes, returning empty JSON on
132// error.
133func mustMarshalConfig(cfg *Config) []byte {
134 data, err := json.Marshal(cfg)
135 if err != nil {
136 return []byte("{}")
137 }
138 return data
139}
140
141func PushPopCrushEnv() func() {
142 var found []string
143 for _, ev := range os.Environ() {
144 if strings.HasPrefix(ev, "CRUSH_") {
145 pair := strings.SplitN(ev, "=", 2)
146 if len(pair) != 2 {
147 continue
148 }
149 found = append(found, strings.TrimPrefix(pair[0], "CRUSH_"))
150 }
151 }
152 backups := make(map[string]string)
153 for _, ev := range found {
154 backups[ev] = os.Getenv(ev)
155 }
156
157 for _, ev := range found {
158 os.Setenv(ev, os.Getenv("CRUSH_"+ev))
159 }
160
161 restore := func() {
162 for k, v := range backups {
163 os.Setenv(k, v)
164 }
165 }
166 return restore
167}
168
169func (c *Config) configureProviders(store *ConfigStore, env env.Env, resolver VariableResolver, knownProviders []catwalk.Provider) error {
170 knownProviderNames := make(map[string]bool)
171 restore := PushPopCrushEnv()
172 defer restore()
173
174 // When disable_default_providers is enabled, skip all default/embedded
175 // providers entirely. Users must fully specify any providers they want.
176 // We skip to the custom provider validation loop which handles all
177 // user-configured providers uniformly.
178 if c.Options.DisableDefaultProviders {
179 knownProviders = nil
180 }
181
182 for _, p := range knownProviders {
183 knownProviderNames[string(p.ID)] = true
184 config, configExists := c.Providers.Get(string(p.ID))
185 // if the user configured a known provider we need to allow it to override a couple of parameters
186 if configExists {
187 if config.BaseURL != "" {
188 p.APIEndpoint = config.BaseURL
189 }
190 if config.APIKey != "" {
191 p.APIKey = config.APIKey
192 }
193 if len(config.Models) > 0 {
194 models := []catwalk.Model{}
195 seen := make(map[string]bool)
196
197 for _, model := range config.Models {
198 if seen[model.ID] {
199 continue
200 }
201 seen[model.ID] = true
202 if model.Name == "" {
203 model.Name = model.ID
204 }
205 models = append(models, model)
206 }
207 for _, model := range p.Models {
208 if seen[model.ID] {
209 continue
210 }
211 seen[model.ID] = true
212 if model.Name == "" {
213 model.Name = model.ID
214 }
215 models = append(models, model)
216 }
217
218 p.Models = models
219 }
220 }
221
222 headers := map[string]string{}
223 if len(p.DefaultHeaders) > 0 {
224 maps.Copy(headers, p.DefaultHeaders)
225 }
226 if len(config.ExtraHeaders) > 0 {
227 maps.Copy(headers, config.ExtraHeaders)
228 }
229 // Provider headers use the same error contract as MCP headers:
230 // a failing $(...) aborts the provider load with a clear
231 // message, and a header that resolves to the empty string
232 // (unset bare $VAR under lenient nounset, $(echo), or literal
233 // "") is dropped from the outgoing request.
234 for k, v := range headers {
235 resolved, err := resolver.ResolveValue(v)
236 if err != nil {
237 return fmt.Errorf("resolving provider %s header %q: %w", p.ID, k, err)
238 }
239 if resolved == "" {
240 delete(headers, k)
241 continue
242 }
243 headers[k] = resolved
244 }
245 prepared := ProviderConfig{
246 ID: string(p.ID),
247 Name: p.Name,
248 BaseURL: p.APIEndpoint,
249 APIKey: p.APIKey,
250 APIKeyTemplate: p.APIKey, // Store original template for re-resolution
251 OAuthToken: config.OAuthToken,
252 Type: p.Type,
253 Disable: config.Disable,
254 SystemPromptPrefix: config.SystemPromptPrefix,
255 ExtraHeaders: headers,
256 ExtraBody: config.ExtraBody,
257 ExtraParams: make(map[string]string),
258 Models: p.Models,
259 }
260
261 switch {
262 case p.ID == catwalk.InferenceProviderAnthropic && config.OAuthToken != nil:
263 // Claude Code subscription is not supported anymore. Remove to show onboarding.
264 if !store.reloadInProgress {
265 store.RemoveConfigField(ScopeGlobal, "providers.anthropic")
266 }
267 c.Providers.Del(string(p.ID))
268 continue
269 case p.ID == catwalk.InferenceProviderCopilot && config.OAuthToken != nil:
270 prepared.SetupGitHubCopilot()
271 }
272
273 switch p.ID {
274 // Handle specific providers that require additional configuration
275 case catwalk.InferenceProviderVertexAI:
276 var (
277 project = env.Get("VERTEXAI_PROJECT")
278 location = env.Get("VERTEXAI_LOCATION")
279 )
280 if project == "" || location == "" {
281 if configExists {
282 slog.Warn("Skipping Vertex AI provider due to missing credentials")
283 c.Providers.Del(string(p.ID))
284 }
285 continue
286 }
287 prepared.ExtraParams["project"] = project
288 prepared.ExtraParams["location"] = location
289 case catwalk.InferenceProviderAzure:
290 endpoint, err := resolver.ResolveValue(p.APIEndpoint)
291 if err != nil || endpoint == "" {
292 if configExists {
293 slog.Warn("Skipping Azure provider due to missing API endpoint", "provider", p.ID, "error", err)
294 c.Providers.Del(string(p.ID))
295 }
296 continue
297 }
298 prepared.BaseURL = endpoint
299 prepared.ExtraParams["apiVersion"] = env.Get("AZURE_OPENAI_API_VERSION")
300 case catwalk.InferenceProviderBedrock:
301 if p.APIKey == "" && !hasAWSCredentials(env) {
302 if configExists {
303 slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
304 c.Providers.Del(string(p.ID))
305 }
306 continue
307 }
308 case catwalk.InferenceProvider("hyper"):
309 if apiKey := env.Get("HYPER_API_KEY"); apiKey != "" {
310 prepared.APIKey = apiKey
311 prepared.APIKeyTemplate = apiKey
312 } else {
313 v, err := resolver.ResolveValue(p.APIKey)
314 if v == "" || err != nil {
315 if configExists {
316 slog.Warn("Skipping Hyper provider due to missing API key", "provider", p.ID)
317 c.Providers.Del(string(p.ID))
318 }
319 continue
320 }
321 }
322 default:
323 // if the provider api or endpoint are missing we skip them
324 v, err := resolver.ResolveValue(p.APIKey)
325 if v == "" || err != nil {
326 if configExists {
327 slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
328 c.Providers.Del(string(p.ID))
329 }
330 continue
331 }
332 }
333 c.Providers.Set(string(p.ID), prepared)
334 }
335
336 // validate the custom providers
337 for id, providerConfig := range c.Providers.Seq2() {
338 if knownProviderNames[id] {
339 continue
340 }
341
342 // Make sure the provider ID is set
343 providerConfig.ID = id
344 providerConfig.Name = cmp.Or(providerConfig.Name, id) // Use ID as name if not set
345 // default to OpenAI if not set
346 providerConfig.Type = cmp.Or(providerConfig.Type, catwalk.TypeOpenAICompat)
347 if !slices.Contains(catwalk.KnownProviderTypes(), providerConfig.Type) && providerConfig.Type != hyper.Name {
348 slog.Warn("Skipping custom provider due to unsupported provider type", "provider", id)
349 c.Providers.Del(id)
350 continue
351 }
352
353 if providerConfig.Disable {
354 slog.Debug("Skipping custom provider due to disable flag", "provider", id)
355 c.Providers.Del(id)
356 continue
357 }
358 if providerConfig.APIKey == "" {
359 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
360 }
361 if providerConfig.BaseURL == "" {
362 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
363 c.Providers.Del(id)
364 continue
365 }
366 if len(providerConfig.Models) == 0 {
367 slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
368 c.Providers.Del(id)
369 continue
370 }
371 apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
372 if apiKey == "" || err != nil {
373 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
374 }
375 baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
376 if baseURL == "" || err != nil {
377 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
378 c.Providers.Del(id)
379 continue
380 }
381
382 // Custom-provider headers share the MCP error contract; see
383 // the known-provider loop above.
384 for k, v := range providerConfig.ExtraHeaders {
385 resolved, err := resolver.ResolveValue(v)
386 if err != nil {
387 return fmt.Errorf("resolving provider %s header %q: %w", id, k, err)
388 }
389 if resolved == "" {
390 delete(providerConfig.ExtraHeaders, k)
391 continue
392 }
393 providerConfig.ExtraHeaders[k] = resolved
394 }
395
396 c.Providers.Set(id, providerConfig)
397 }
398
399 if c.Providers.Len() == 0 && c.Options.DisableDefaultProviders {
400 return fmt.Errorf("default providers are disabled and there are no custom providers are configured")
401 }
402
403 return nil
404}
405
406func (c *Config) setDefaults(workingDir, dataDir string) {
407 if c.Options == nil {
408 c.Options = &Options{}
409 }
410 if c.Options.TUI == nil {
411 c.Options.TUI = &TUIOptions{}
412 }
413 if dataDir != "" {
414 c.Options.DataDirectory = dataDir
415 } else if c.Options.DataDirectory == "" {
416 if path, ok := fsext.LookupClosestBounded(workingDir, projectBoundary(workingDir), defaultDataDirectory); ok {
417 c.Options.DataDirectory = path
418 } else {
419 c.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
420 }
421 }
422 c.Options.DataDirectory = filepath.Clean(filepathext.SmartJoin(workingDir, c.Options.DataDirectory))
423 if c.Providers == nil {
424 c.Providers = csync.NewMap[string, ProviderConfig]()
425 }
426 if c.Models == nil {
427 c.Models = make(map[SelectedModelType]SelectedModel)
428 }
429 if c.RecentModels == nil {
430 c.RecentModels = make(map[SelectedModelType][]SelectedModel)
431 }
432 if c.MCP == nil {
433 c.MCP = make(map[string]MCPConfig)
434 }
435 if c.LSP == nil {
436 c.LSP = make(map[string]LSPConfig)
437 }
438
439 // Apply defaults to LSP configurations
440 c.applyLSPDefaults()
441
442 // Add the default context paths if they are not already present
443 c.Options.ContextPaths = append(defaultContextPaths, c.Options.ContextPaths...)
444 slices.Sort(c.Options.ContextPaths)
445 c.Options.ContextPaths = slices.Compact(c.Options.ContextPaths)
446
447 // Add the default skills directories if not already present.
448 for _, dir := range GlobalSkillsDirs() {
449 if !slices.Contains(c.Options.SkillsPaths, dir) {
450 c.Options.SkillsPaths = append(c.Options.SkillsPaths, dir)
451 }
452 }
453
454 // Project specific skills dirs.
455 c.Options.SkillsPaths = append(c.Options.SkillsPaths, ProjectSkillsDir(workingDir)...)
456
457 if str, ok := os.LookupEnv("CRUSH_DISABLE_PROVIDER_AUTO_UPDATE"); ok {
458 c.Options.DisableProviderAutoUpdate, _ = strconv.ParseBool(str)
459 }
460
461 if str, ok := os.LookupEnv("CRUSH_DISABLE_DEFAULT_PROVIDERS"); ok {
462 c.Options.DisableDefaultProviders, _ = strconv.ParseBool(str)
463 }
464
465 if c.Options.Attribution == nil {
466 c.Options.Attribution = &Attribution{
467 TrailerStyle: TrailerStyleAssistedBy,
468 GeneratedWith: true,
469 }
470 } else if c.Options.Attribution.TrailerStyle == "" {
471 // Migrate deprecated co_authored_by or apply default
472 if c.Options.Attribution.CoAuthoredBy != nil {
473 if *c.Options.Attribution.CoAuthoredBy {
474 c.Options.Attribution.TrailerStyle = TrailerStyleCoAuthoredBy
475 } else {
476 c.Options.Attribution.TrailerStyle = TrailerStyleNone
477 }
478 } else {
479 c.Options.Attribution.TrailerStyle = TrailerStyleAssistedBy
480 }
481 }
482 c.Options.InitializeAs = cmp.Or(c.Options.InitializeAs, defaultInitializeAs)
483}
484
485// applyLSPDefaults applies default values from powernap to LSP configurations
486func (c *Config) applyLSPDefaults() {
487 // Get powernap's default configuration
488 configManager := powernapConfig.NewManager()
489 configManager.LoadDefaults()
490
491 // Apply defaults to each LSP configuration
492 for name, cfg := range c.LSP {
493 // Try to get defaults from powernap based on name or command name.
494 base, ok := configManager.GetServer(name)
495 if !ok {
496 base, ok = configManager.GetServer(cfg.Command)
497 if !ok {
498 continue
499 }
500 }
501 if cfg.Options == nil {
502 cfg.Options = base.Settings
503 }
504 if cfg.InitOptions == nil {
505 cfg.InitOptions = base.InitOptions
506 }
507 if len(cfg.FileTypes) == 0 {
508 cfg.FileTypes = base.FileTypes
509 }
510 if len(cfg.RootMarkers) == 0 {
511 cfg.RootMarkers = base.RootMarkers
512 }
513 cfg.Command = cmp.Or(cfg.Command, base.Command)
514 if len(cfg.Args) == 0 {
515 cfg.Args = base.Args
516 }
517 if len(cfg.Env) == 0 {
518 cfg.Env = base.Environment
519 }
520 // Update the config in the map
521 c.LSP[name] = cfg
522 }
523}
524
525func (c *Config) defaultModelSelection(knownProviders []catwalk.Provider) (largeModel SelectedModel, smallModel SelectedModel, err error) {
526 if len(knownProviders) == 0 && c.Providers.Len() == 0 {
527 err = fmt.Errorf("no providers configured, please configure at least one provider")
528 return largeModel, smallModel, err
529 }
530
531 // Use the first provider enabled based on the known providers order
532 // if no provider found that is known use the first provider configured
533 for _, p := range knownProviders {
534 providerConfig, ok := c.Providers.Get(string(p.ID))
535 if !ok || providerConfig.Disable {
536 continue
537 }
538 defaultLargeModel := c.GetModel(string(p.ID), p.DefaultLargeModelID)
539 if defaultLargeModel == nil {
540 err = fmt.Errorf("default large model %s not found for provider %s", p.DefaultLargeModelID, p.ID)
541 return largeModel, smallModel, err
542 }
543 largeModel = SelectedModel{
544 Provider: string(p.ID),
545 Model: defaultLargeModel.ID,
546 MaxTokens: defaultLargeModel.DefaultMaxTokens,
547 ReasoningEffort: defaultLargeModel.DefaultReasoningEffort,
548 }
549
550 defaultSmallModel := c.GetModel(string(p.ID), p.DefaultSmallModelID)
551 if defaultSmallModel == nil {
552 err = fmt.Errorf("default small model %s not found for provider %s", p.DefaultSmallModelID, p.ID)
553 return largeModel, smallModel, err
554 }
555 smallModel = SelectedModel{
556 Provider: string(p.ID),
557 Model: defaultSmallModel.ID,
558 MaxTokens: defaultSmallModel.DefaultMaxTokens,
559 ReasoningEffort: defaultSmallModel.DefaultReasoningEffort,
560 }
561 return largeModel, smallModel, err
562 }
563
564 enabledProviders := c.EnabledProviders()
565 slices.SortFunc(enabledProviders, func(a, b ProviderConfig) int {
566 return strings.Compare(a.ID, b.ID)
567 })
568
569 if len(enabledProviders) == 0 {
570 err = fmt.Errorf("no providers configured, please configure at least one provider")
571 return largeModel, smallModel, err
572 }
573
574 providerConfig := enabledProviders[0]
575 if len(providerConfig.Models) == 0 {
576 err = fmt.Errorf("provider %s has no models configured", providerConfig.ID)
577 return largeModel, smallModel, err
578 }
579 defaultLargeModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
580 largeModel = SelectedModel{
581 Provider: providerConfig.ID,
582 Model: defaultLargeModel.ID,
583 MaxTokens: defaultLargeModel.DefaultMaxTokens,
584 }
585 defaultSmallModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
586 smallModel = SelectedModel{
587 Provider: providerConfig.ID,
588 Model: defaultSmallModel.ID,
589 MaxTokens: defaultSmallModel.DefaultMaxTokens,
590 }
591 return largeModel, smallModel, err
592}
593
594func configureSelectedModels(store *ConfigStore, knownProviders []catwalk.Provider, persist bool) error {
595 c := store.config
596 defaultLarge, defaultSmall, err := c.defaultModelSelection(knownProviders)
597 if err != nil {
598 return fmt.Errorf("failed to select default models: %w", err)
599 }
600 large, small := defaultLarge, defaultSmall
601
602 largeModelSelected, largeModelConfigured := c.Models[SelectedModelTypeLarge]
603 if largeModelConfigured {
604 if largeModelSelected.Model != "" {
605 large.Model = largeModelSelected.Model
606 }
607 if largeModelSelected.Provider != "" {
608 large.Provider = largeModelSelected.Provider
609 }
610 model := c.GetModel(large.Provider, large.Model)
611 if model == nil {
612 large = defaultLarge
613 if persist {
614 if err := store.UpdatePreferredModel(ScopeGlobal, SelectedModelTypeLarge, large); err != nil {
615 return fmt.Errorf("failed to update preferred large model: %w", err)
616 }
617 }
618 } else {
619 if largeModelSelected.MaxTokens > 0 {
620 large.MaxTokens = largeModelSelected.MaxTokens
621 } else {
622 large.MaxTokens = model.DefaultMaxTokens
623 }
624 if largeModelSelected.ReasoningEffort != "" {
625 large.ReasoningEffort = largeModelSelected.ReasoningEffort
626 }
627 large.Think = largeModelSelected.Think
628 if largeModelSelected.Temperature != nil {
629 large.Temperature = largeModelSelected.Temperature
630 }
631 if largeModelSelected.TopP != nil {
632 large.TopP = largeModelSelected.TopP
633 }
634 if largeModelSelected.TopK != nil {
635 large.TopK = largeModelSelected.TopK
636 }
637 if largeModelSelected.FrequencyPenalty != nil {
638 large.FrequencyPenalty = largeModelSelected.FrequencyPenalty
639 }
640 if largeModelSelected.PresencePenalty != nil {
641 large.PresencePenalty = largeModelSelected.PresencePenalty
642 }
643 }
644 }
645 smallModelSelected, smallModelConfigured := c.Models[SelectedModelTypeSmall]
646 if smallModelConfigured {
647 if smallModelSelected.Model != "" {
648 small.Model = smallModelSelected.Model
649 }
650 if smallModelSelected.Provider != "" {
651 small.Provider = smallModelSelected.Provider
652 }
653
654 model := c.GetModel(small.Provider, small.Model)
655 if model == nil {
656 small = defaultSmall
657 if persist {
658 if err := store.UpdatePreferredModel(ScopeGlobal, SelectedModelTypeSmall, small); err != nil {
659 return fmt.Errorf("failed to update preferred small model: %w", err)
660 }
661 }
662 } else {
663 if smallModelSelected.MaxTokens > 0 {
664 small.MaxTokens = smallModelSelected.MaxTokens
665 } else {
666 small.MaxTokens = model.DefaultMaxTokens
667 }
668 if smallModelSelected.ReasoningEffort != "" {
669 small.ReasoningEffort = smallModelSelected.ReasoningEffort
670 }
671 if smallModelSelected.Temperature != nil {
672 small.Temperature = smallModelSelected.Temperature
673 }
674 if smallModelSelected.TopP != nil {
675 small.TopP = smallModelSelected.TopP
676 }
677 if smallModelSelected.TopK != nil {
678 small.TopK = smallModelSelected.TopK
679 }
680 if smallModelSelected.FrequencyPenalty != nil {
681 small.FrequencyPenalty = smallModelSelected.FrequencyPenalty
682 }
683 if smallModelSelected.PresencePenalty != nil {
684 small.PresencePenalty = smallModelSelected.PresencePenalty
685 }
686 small.Think = smallModelSelected.Think
687 }
688 }
689
690 // When small isn't explicitly configured and the provider isn't a
691 // known built-in, use the large model as the small model. This
692 // prevents two different models from being requested concurrently
693 // for local/openai-compat providers.
694 if !smallModelConfigured {
695 isKnownProvider := false
696 for _, kp := range knownProviders {
697 if string(kp.ID) == small.Provider {
698 isKnownProvider = true
699 break
700 }
701 }
702 if !isKnownProvider {
703 slog.Warn("Using large model as small model for unknown provider", "provider", large.Provider, "model", large.Model)
704 small = large
705 }
706 }
707
708 c.Models[SelectedModelTypeLarge] = large
709 c.Models[SelectedModelTypeSmall] = small
710 return nil
711}
712
713// lookupConfigs searches config files starting at cwd and walking up
714// through the current project. The upward walk stops at the git
715// working tree root when one can be detected, otherwise at cwd itself,
716// so an unrelated crush.json placed above the project is never picked
717// up. Global user-level config locations are always included
718// regardless of the boundary.
719func lookupConfigs(cwd string) []string {
720 // prepend default config paths
721 configPaths := []string{
722 GlobalConfig(),
723 GlobalConfigData(),
724 }
725
726 configNames := []string{appName + ".json", "." + appName + ".json"}
727
728 foundConfigs, err := fsext.LookupBounded(cwd, projectBoundary(cwd), configNames...)
729 if err != nil {
730 // returns at least default configs
731 return configPaths
732 }
733
734 // reverse order so last config has more priority
735 slices.Reverse(foundConfigs)
736
737 return append(configPaths, foundConfigs...)
738}
739
740func loadFromConfigPaths(configPaths []string) (*Config, []string, error) {
741 var configs [][]byte
742 var loaded []string
743
744 for _, path := range configPaths {
745 data, err := os.ReadFile(path)
746 if err != nil {
747 if os.IsNotExist(err) {
748 continue
749 }
750 return nil, nil, fmt.Errorf("failed to open config file %s: %w", path, err)
751 }
752 if len(data) == 0 {
753 continue
754 }
755 if !json.Valid(data) {
756 return nil, nil, fmt.Errorf("invalid JSON in config file %s", path)
757 }
758 configs = append(configs, data)
759 loaded = append(loaded, path)
760 }
761
762 cfg, err := loadFromBytes(configs)
763 if err != nil {
764 return nil, nil, err
765 }
766 return cfg, loaded, nil
767}
768
769func loadFromBytes(configs [][]byte) (*Config, error) {
770 if len(configs) == 0 {
771 return &Config{}, nil
772 }
773
774 data, err := jsons.Merge(configs)
775 if err != nil {
776 return nil, err
777 }
778 var config Config
779 if err := json.Unmarshal(data, &config); err != nil {
780 return nil, err
781 }
782 return &config, nil
783}
784
785func hasAWSCredentials(env env.Env) bool {
786 if env.Get("AWS_BEARER_TOKEN_BEDROCK") != "" {
787 return true
788 }
789
790 if env.Get("AWS_ACCESS_KEY_ID") != "" && env.Get("AWS_SECRET_ACCESS_KEY") != "" {
791 return true
792 }
793
794 if env.Get("AWS_PROFILE") != "" || env.Get("AWS_DEFAULT_PROFILE") != "" {
795 return true
796 }
797
798 if env.Get("AWS_REGION") != "" || env.Get("AWS_DEFAULT_REGION") != "" {
799 return true
800 }
801
802 if env.Get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
803 env.Get("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
804 return true
805 }
806
807 if _, err := os.Stat(filepath.Join(home.Dir(), ".aws/credentials")); err == nil && !testing.Testing() {
808 return true
809 }
810
811 return false
812}
813
814// GlobalConfig returns the global configuration file path for the application.
815func GlobalConfig() string {
816 if crushGlobal := os.Getenv("CRUSH_GLOBAL_CONFIG"); crushGlobal != "" {
817 return filepath.Join(crushGlobal, fmt.Sprintf("%s.json", appName))
818 }
819 return filepath.Join(home.Config(), appName, fmt.Sprintf("%s.json", appName))
820}
821
822// GlobalCacheDir returns the path to the global cache directory for the
823// application.
824func GlobalCacheDir() string {
825 if crushCache := os.Getenv("CRUSH_CACHE_DIR"); crushCache != "" {
826 return crushCache
827 }
828 if xdgCacheHome := os.Getenv("XDG_CACHE_HOME"); xdgCacheHome != "" {
829 return filepath.Join(xdgCacheHome, appName)
830 }
831 if runtime.GOOS == "windows" {
832 localAppData := cmp.Or(
833 os.Getenv("LOCALAPPDATA"),
834 filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
835 )
836 return filepath.Join(localAppData, appName, "cache")
837 }
838 return filepath.Join(home.Dir(), ".cache", appName)
839}
840
841// ProjectConfigs returns list of current project configs paths.
842func ProjectConfigs(cwd string) []string {
843 return lookupConfigs(cwd)
844}
845
846// GlobalConfigData returns the path to the main data directory for the application.
847// this config is used when the app overrides configurations instead of updating the global config.
848func GlobalConfigData() string {
849 if crushData := os.Getenv("CRUSH_GLOBAL_DATA"); crushData != "" {
850 return filepath.Join(crushData, fmt.Sprintf("%s.json", appName))
851 }
852 if xdgDataHome := os.Getenv("XDG_DATA_HOME"); xdgDataHome != "" {
853 return filepath.Join(xdgDataHome, appName, fmt.Sprintf("%s.json", appName))
854 }
855
856 // return the path to the main data directory
857 // for windows, it should be in `%LOCALAPPDATA%/crush/`
858 // for linux and macOS, it should be in `$HOME/.local/share/crush/`
859 if runtime.GOOS == "windows" {
860 localAppData := cmp.Or(
861 os.Getenv("LOCALAPPDATA"),
862 filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
863 )
864 return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
865 }
866
867 return filepath.Join(home.Dir(), ".local", "share", appName, fmt.Sprintf("%s.json", appName))
868}
869
870// GlobalWorkspaceDir returns the path to the global server workspace
871// directory. This directory acts as a meta-workspace for the server
872// process, giving it a real workingDir so that config loading, scoped
873// writes, and provider resolution behave identically to project
874// workspaces.
875func GlobalWorkspaceDir() string {
876 return filepath.Dir(GlobalConfigData())
877}
878
879func assignIfNil[T any](ptr **T, val T) {
880 if *ptr == nil {
881 *ptr = &val
882 }
883}
884
885func isInsideWorktree() bool {
886 bts, err := exec.CommandContext(
887 context.Background(),
888 "git", "rev-parse",
889 "--is-inside-work-tree",
890 ).CombinedOutput()
891 return err == nil && strings.TrimSpace(string(bts)) == "true"
892}
893
894// worktreeRoot returns the absolute path of the git working tree root for
895// dir, or the empty string if dir is not inside a working tree (bare
896// repositories, missing git binary, plain directories, or any other
897// failure mode). Linked worktrees and submodules each report their own
898// top-level, which is what callers want when bounding lookups.
899func worktreeRoot(dir string) string {
900 cmd := exec.CommandContext(
901 context.Background(),
902 "git", "rev-parse", "--show-toplevel",
903 )
904 cmd.Dir = dir
905 out, err := cmd.Output()
906 if err != nil {
907 return ""
908 }
909 root := strings.TrimSpace(string(out))
910 if root == "" {
911 return ""
912 }
913 abs, err := filepath.Abs(root)
914 if err != nil {
915 return ""
916 }
917 return abs
918}
919
920// projectBoundary returns the directory at which an upward configuration
921// search rooted at dir should stop. It is the git working tree root when
922// one can be detected, otherwise dir itself. Returning dir as a
923// fallback keeps Crush from silently adopting state files placed above
924// the current project.
925func projectBoundary(dir string) string {
926 if root := worktreeRoot(dir); root != "" {
927 return root
928 }
929 abs, err := filepath.Abs(dir)
930 if err != nil {
931 return dir
932 }
933 return abs
934}
935
936// GlobalSkillsDirs returns the default directories for Agent Skills.
937// Skills in these directories are auto-discovered and their files can be read
938// without permission prompts.
939func GlobalSkillsDirs() []string {
940 if crushSkills := os.Getenv("CRUSH_SKILLS_DIR"); crushSkills != "" {
941 return []string{crushSkills}
942 }
943
944 paths := []string{
945 filepath.Join(home.Config(), appName, "skills"),
946 filepath.Join(home.Config(), "agents", "skills"),
947 // Per the Agent Skills spec, scan ~/.agents/skills
948 filepath.Join(home.Dir(), ".agents", "skills"),
949 filepath.Join(home.Dir(), ".claude", "skills"),
950 }
951
952 // On Windows, also load from app data on top of `$HOME/.config/crush`.
953 // This is here mostly for backwards compatibility.
954 if runtime.GOOS == "windows" {
955 appData := cmp.Or(
956 os.Getenv("LOCALAPPDATA"),
957 filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
958 )
959 paths = append(
960 paths,
961 filepath.Join(appData, appName, "skills"),
962 filepath.Join(appData, "agents", "skills"),
963 )
964 }
965
966 return paths
967}
968
969// ProjectSkillsDir returns the default project directories for which Crush
970// will look for skills.
971func ProjectSkillsDir(workingDir string) []string {
972 return []string{
973 filepath.Join(workingDir, ".agents/skills"),
974 filepath.Join(workingDir, ".crush/skills"),
975 filepath.Join(workingDir, ".claude/skills"),
976 filepath.Join(workingDir, ".cursor/skills"),
977 }
978}
979
980func isAppleTerminal() bool { return os.Getenv("TERM_PROGRAM") == "Apple_Terminal" }
981
982// normalizeHookEvent maps user-provided event names to their canonical
983// form. Matching is case-insensitive and accepts snake_case variants
984// (e.g. "pre_tool_use" → "PreToolUse").
985func normalizeHookEvent(name string) string {
986 switch strings.ToLower(strings.ReplaceAll(name, "_", "")) {
987 case "pretooluse":
988 return "PreToolUse"
989 default:
990 return name
991 }
992}
993
994// ValidateHooks normalizes event names and checks that every configured
995// hook has a command and a syntactically valid matcher regex. Matcher
996// compilation used for matching is owned by hooks.Runner; this function
997// only validates up front so the user sees config errors at load time
998// rather than on the first tool call.
999func (c *Config) ValidateHooks() error {
1000 // Normalize event name keys.
1001 for event, eventHooks := range c.Hooks {
1002 canonical := normalizeHookEvent(event)
1003 if canonical != event {
1004 c.Hooks[canonical] = append(c.Hooks[canonical], eventHooks...)
1005 delete(c.Hooks, event)
1006 }
1007 }
1008
1009 for event, eventHooks := range c.Hooks {
1010 for i, h := range eventHooks {
1011 if h.Command == "" {
1012 return fmt.Errorf("hook %s[%d]: command is required", event, i)
1013 }
1014 if h.Matcher == "" {
1015 continue
1016 }
1017 if _, err := regexp.Compile(h.Matcher); err != nil {
1018 return fmt.Errorf("hook %s[%d]: invalid matcher regex %q: %w", event, i, h.Matcher, err)
1019 }
1020 }
1021 }
1022 return nil
1023}