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