Add files using upload-large-folder tool

projects/ui/crush/internal/cmd/root.go

@@ -0,0 +1,187 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log/slog"
+	"os"
+	"path/filepath"
+
+	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/crush/internal/app"
+	"github.com/charmbracelet/crush/internal/config"
+	"github.com/charmbracelet/crush/internal/db"
+	"github.com/charmbracelet/crush/internal/tui"
+	"github.com/charmbracelet/crush/internal/version"
+	"github.com/charmbracelet/fang"
+	"github.com/charmbracelet/x/term"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	rootCmd.PersistentFlags().StringP("cwd", "c", "", "Current working directory")
+	rootCmd.PersistentFlags().StringP("data-dir", "D", "", "Custom crush data directory")
+	rootCmd.PersistentFlags().BoolP("debug", "d", false, "Debug")
+
+	rootCmd.Flags().BoolP("help", "h", false, "Help")
+	rootCmd.Flags().BoolP("yolo", "y", false, "Automatically accept all permissions (dangerous mode)")
+
+	rootCmd.AddCommand(runCmd)
+}
+
+var rootCmd = &cobra.Command{
+	Use:   "crush",
+	Short: "Terminal-based AI assistant for software development",
+	Long: `Crush is a powerful terminal-based AI assistant that helps with software development tasks.
+It provides an interactive chat interface with AI capabilities, code analysis, and LSP integration
+to assist developers in writing, debugging, and understanding code directly from the terminal.`,
+	Example: `
+# Run in interactive mode
+crush
+
+# Run with debug logging
+crush -d
+
+# Run with debug logging in a specific directory
+crush -d -c /path/to/project
+
+# Run with custom data directory
+crush -D /path/to/custom/.crush
+
+# Print version
+crush -v
+
+# Run a single non-interactive prompt
+crush run "Explain the use of context in Go"
+
+# Run in dangerous mode (auto-accept all permissions)
+crush -y
+  `,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		app, err := setupApp(cmd)
+		if err != nil {
+			return err
+		}
+		defer app.Shutdown()
+
+		// Set up the TUI.
+		program := tea.NewProgram(
+			tui.New(app),
+			tea.WithAltScreen(),
+			tea.WithContext(cmd.Context()),
+			tea.WithMouseCellMotion(),            // Use cell motion instead of all motion to reduce event flooding
+			tea.WithFilter(tui.MouseEventFilter), // Filter mouse events based on focus state
+		)
+
+		go app.Subscribe(program)
+
+		if _, err := program.Run(); err != nil {
+			slog.Error("TUI run error", "error", err)
+			return fmt.Errorf("TUI error: %v", err)
+		}
+		return nil
+	},
+}
+
+func Execute() {
+	if err := fang.Execute(
+		context.Background(),
+		rootCmd,
+		fang.WithVersion(version.Version),
+		fang.WithNotifySignal(os.Interrupt),
+	); err != nil {
+		os.Exit(1)
+	}
+}
+
+// setupApp handles the common setup logic for both interactive and non-interactive modes.
+// It returns the app instance, config, cleanup function, and any error.
+func setupApp(cmd *cobra.Command) (*app.App, error) {
+	debug, _ := cmd.Flags().GetBool("debug")
+	yolo, _ := cmd.Flags().GetBool("yolo")
+	dataDir, _ := cmd.Flags().GetString("data-dir")
+	ctx := cmd.Context()
+
+	cwd, err := ResolveCwd(cmd)
+	if err != nil {
+		return nil, err
+	}
+
+	cfg, err := config.Init(cwd, dataDir, debug)
+	if err != nil {
+		return nil, err
+	}
+
+	if cfg.Permissions == nil {
+		cfg.Permissions = &config.Permissions{}
+	}
+	cfg.Permissions.SkipRequests = yolo
+
+	if err := createDotCrushDir(cfg.Options.DataDirectory); err != nil {
+		return nil, err
+	}
+
+	// Connect to DB; this will also run migrations.
+	conn, err := db.Connect(ctx, cfg.Options.DataDirectory)
+	if err != nil {
+		return nil, err
+	}
+
+	appInstance, err := app.New(ctx, conn, cfg)
+	if err != nil {
+		slog.Error("Failed to create app instance", "error", err)
+		return nil, err
+	}
+
+	return appInstance, nil
+}
+
+func MaybePrependStdin(prompt string) (string, error) {
+	if term.IsTerminal(os.Stdin.Fd()) {
+		return prompt, nil
+	}
+	fi, err := os.Stdin.Stat()
+	if err != nil {
+		return prompt, err
+	}
+	if fi.Mode()&os.ModeNamedPipe == 0 {
+		return prompt, nil
+	}
+	bts, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		return prompt, err
+	}
+	return string(bts) + "\n\n" + prompt, nil
+}
+
+func ResolveCwd(cmd *cobra.Command) (string, error) {
+	cwd, _ := cmd.Flags().GetString("cwd")
+	if cwd != "" {
+		err := os.Chdir(cwd)
+		if err != nil {
+			return "", fmt.Errorf("failed to change directory: %v", err)
+		}
+		return cwd, nil
+	}
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("failed to get current working directory: %v", err)
+	}
+	return cwd, nil
+}
+
+func createDotCrushDir(dir string) error {
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return fmt.Errorf("failed to create data directory: %q %w", dir, err)
+	}
+
+	gitIgnorePath := filepath.Join(dir, ".gitignore")
+	if _, err := os.Stat(gitIgnorePath); os.IsNotExist(err) {
+		if err := os.WriteFile(gitIgnorePath, []byte("*\n"), 0o644); err != nil {
+			return fmt.Errorf("failed to create .gitignore file: %q %w", gitIgnorePath, err)
+		}
+	}
+
+	return nil
+}

projects/ui/crush/internal/cmd/run.go

@@ -0,0 +1,58 @@
+package cmd
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"github.com/spf13/cobra"
+)
+
+var runCmd = &cobra.Command{
+	Use:   "run [prompt...]",
+	Short: "Run a single non-interactive prompt",
+	Long: `Run a single prompt in non-interactive mode and exit.
+The prompt can be provided as arguments or piped from stdin.`,
+	Example: `
+# Run a simple prompt
+crush run Explain the use of context in Go
+
+# Pipe input from stdin
+echo "What is this code doing?" | crush run
+
+# Run with quiet mode (no spinner)
+crush run -q "Generate a README for this project"
+  `,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		quiet, _ := cmd.Flags().GetBool("quiet")
+
+		app, err := setupApp(cmd)
+		if err != nil {
+			return err
+		}
+		defer app.Shutdown()
+
+		if !app.Config().IsConfigured() {
+			return fmt.Errorf("no providers configured - please run 'crush' to set up a provider interactively")
+		}
+
+		prompt := strings.Join(args, " ")
+
+		prompt, err = MaybePrependStdin(prompt)
+		if err != nil {
+			slog.Error("Failed to read from stdin", "error", err)
+			return err
+		}
+
+		if prompt == "" {
+			return fmt.Errorf("no prompt provided")
+		}
+
+		// Run non-interactive flow using the App method
+		return app.RunNonInteractive(cmd.Context(), prompt, quiet)
+	},
+}
+
+func init() {
+	runCmd.Flags().BoolP("quiet", "q", false, "Hide spinner")
+}

projects/ui/crush/internal/cmd/schema.go

@@ -0,0 +1,30 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/charmbracelet/crush/internal/config"
+	"github.com/invopop/jsonschema"
+	"github.com/spf13/cobra"
+)
+
+var schemaCmd = &cobra.Command{
+	Use:    "schema",
+	Short:  "Generate JSON schema for configuration",
+	Long:   "Generate JSON schema for the crush configuration file",
+	Hidden: true,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		reflector := new(jsonschema.Reflector)
+		bts, err := json.MarshalIndent(reflector.Reflect(&config.Config{}), "", "  ")
+		if err != nil {
+			return fmt.Errorf("failed to marshal schema: %w", err)
+		}
+		fmt.Println(string(bts))
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(schemaCmd)
+}

projects/ui/crush/internal/config/config.go

@@ -0,0 +1,520 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"os"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/env"
+	"github.com/tidwall/sjson"
+)
+
+const (
+	appName              = "crush"
+	defaultDataDirectory = ".crush"
+)
+
+var defaultContextPaths = []string{
+	".github/copilot-instructions.md",
+	".cursorrules",
+	".cursor/rules/",
+	"CLAUDE.md",
+	"CLAUDE.local.md",
+	"GEMINI.md",
+	"gemini.md",
+	"crush.md",
+	"crush.local.md",
+	"Crush.md",
+	"Crush.local.md",
+	"CRUSH.md",
+	"CRUSH.local.md",
+	"AGENTS.md",
+	"agents.md",
+	"Agents.md",
+}
+
+type SelectedModelType string
+
+const (
+	SelectedModelTypeLarge SelectedModelType = "large"
+	SelectedModelTypeSmall SelectedModelType = "small"
+)
+
+type SelectedModel struct {
+	// The model id as used by the provider API.
+	// Required.
+	Model string `json:"model" jsonschema:"required,description=The model ID as used by the provider API,example=gpt-4o"`
+	// The model provider, same as the key/id used in the providers config.
+	// Required.
+	Provider string `json:"provider" jsonschema:"required,description=The model provider ID that matches a key in the providers config,example=openai"`
+
+	// Only used by models that use the openai provider and need this set.
+	ReasoningEffort string `json:"reasoning_effort,omitempty" jsonschema:"description=Reasoning effort level for OpenAI models that support it,enum=low,enum=medium,enum=high"`
+
+	// Overrides the default model configuration.
+	MaxTokens int64 `json:"max_tokens,omitempty" jsonschema:"description=Maximum number of tokens for model responses,minimum=1,maximum=200000,example=4096"`
+
+	// Used by anthropic models that can reason to indicate if the model should think.
+	Think bool `json:"think,omitempty" jsonschema:"description=Enable thinking mode for Anthropic models that support reasoning"`
+}
+
+type ProviderConfig struct {
+	// The provider's id.
+	ID string `json:"id,omitempty" jsonschema:"description=Unique identifier for the provider,example=openai"`
+	// The provider's name, used for display purposes.
+	Name string `json:"name,omitempty" jsonschema:"description=Human-readable name for the provider,example=OpenAI"`
+	// The provider's API endpoint.
+	BaseURL string `json:"base_url,omitempty" jsonschema:"description=Base URL for the provider's API,format=uri,example=https://api.openai.com/v1"`
+	// The provider type, e.g. "openai", "anthropic", etc. if empty it defaults to openai.
+	Type catwalk.Type `json:"type,omitempty" jsonschema:"description=Provider type that determines the API format,enum=openai,enum=anthropic,enum=gemini,enum=azure,enum=vertexai,default=openai"`
+	// The provider's API key.
+	APIKey string `json:"api_key,omitempty" jsonschema:"description=API key for authentication with the provider,example=$OPENAI_API_KEY"`
+	// Marks the provider as disabled.
+	Disable bool `json:"disable,omitempty" jsonschema:"description=Whether this provider is disabled,default=false"`
+
+	// Custom system prompt prefix.
+	SystemPromptPrefix string `json:"system_prompt_prefix,omitempty" jsonschema:"description=Custom prefix to add to system prompts for this provider"`
+
+	// Extra headers to send with each request to the provider.
+	ExtraHeaders map[string]string `json:"extra_headers,omitempty" jsonschema:"description=Additional HTTP headers to send with requests"`
+	// Extra body
+	ExtraBody map[string]any `json:"extra_body,omitempty" jsonschema:"description=Additional fields to include in request bodies"`
+
+	// Used to pass extra parameters to the provider.
+	ExtraParams map[string]string `json:"-"`
+
+	// The provider models
+	Models []catwalk.Model `json:"models,omitempty" jsonschema:"description=List of models available from this provider"`
+}
+
+type MCPType string
+
+const (
+	MCPStdio MCPType = "stdio"
+	MCPSse   MCPType = "sse"
+	MCPHttp  MCPType = "http"
+)
+
+type MCPConfig struct {
+	Command  string            `json:"command,omitempty" jsonschema:"description=Command to execute for stdio MCP servers,example=npx"`
+	Env      map[string]string `json:"env,omitempty" jsonschema:"description=Environment variables to set for the MCP server"`
+	Args     []string          `json:"args,omitempty" jsonschema:"description=Arguments to pass to the MCP server command"`
+	Type     MCPType           `json:"type" jsonschema:"required,description=Type of MCP connection,enum=stdio,enum=sse,enum=http,default=stdio"`
+	URL      string            `json:"url,omitempty" jsonschema:"description=URL for HTTP or SSE MCP servers,format=uri,example=http://localhost:3000/mcp"`
+	Disabled bool              `json:"disabled,omitempty" jsonschema:"description=Whether this MCP server is disabled,default=false"`
+	Timeout  int               `json:"timeout,omitempty" jsonschema:"description=Timeout in seconds for MCP server connections,default=15,example=30,example=60,example=120"`
+
+	// TODO: maybe make it possible to get the value from the env
+	Headers map[string]string `json:"headers,omitempty" jsonschema:"description=HTTP headers for HTTP/SSE MCP servers"`
+}
+
+type LSPConfig struct {
+	Disabled  bool              `json:"enabled,omitempty" jsonschema:"description=Whether this LSP server is disabled,default=false"`
+	Command   string            `json:"command" jsonschema:"required,description=Command to execute for the LSP server,example=gopls"`
+	Args      []string          `json:"args,omitempty" jsonschema:"description=Arguments to pass to the LSP server command"`
+	Env       map[string]string `json:"env,omitempty" jsonschema:"description=Environment variables to set to the LSP server command"`
+	Options   any               `json:"options,omitempty" jsonschema:"description=LSP server-specific configuration options"`
+	FileTypes []string          `json:"filetypes,omitempty" jsonschema:"description=File types this LSP server handles,example=go,example=mod,example=rs,example=c,example=js,example=ts"`
+}
+
+type TUIOptions struct {
+	CompactMode bool   `json:"compact_mode,omitempty" jsonschema:"description=Enable compact mode for the TUI interface,default=false"`
+	DiffMode    string `json:"diff_mode,omitempty" jsonschema:"description=Diff mode for the TUI interface,enum=unified,enum=split"`
+	// Here we can add themes later or any TUI related options
+}
+
+type Permissions struct {
+	AllowedTools []string `json:"allowed_tools,omitempty" jsonschema:"description=List of tools that don't require permission prompts,example=bash,example=view"` // Tools that don't require permission prompts
+	SkipRequests bool     `json:"-"`                                                                                                                              // Automatically accept all permissions (YOLO mode)
+}
+
+type Options struct {
+	ContextPaths         []string    `json:"context_paths,omitempty" jsonschema:"description=Paths to files containing context information for the AI,example=.cursorrules,example=CRUSH.md"`
+	TUI                  *TUIOptions `json:"tui,omitempty" jsonschema:"description=Terminal user interface options"`
+	Debug                bool        `json:"debug,omitempty" jsonschema:"description=Enable debug logging,default=false"`
+	DebugLSP             bool        `json:"debug_lsp,omitempty" jsonschema:"description=Enable debug logging for LSP servers,default=false"`
+	DisableAutoSummarize bool        `json:"disable_auto_summarize,omitempty" jsonschema:"description=Disable automatic conversation summarization,default=false"`
+	DataDirectory        string      `json:"data_directory,omitempty" jsonschema:"description=Directory for storing application data (relative to working directory),default=.crush,example=.crush"` // Relative to the cwd
+}
+
+type MCPs map[string]MCPConfig
+
+type MCP struct {
+	Name string    `json:"name"`
+	MCP  MCPConfig `json:"mcp"`
+}
+
+func (m MCPs) Sorted() []MCP {
+	sorted := make([]MCP, 0, len(m))
+	for k, v := range m {
+		sorted = append(sorted, MCP{
+			Name: k,
+			MCP:  v,
+		})
+	}
+	slices.SortFunc(sorted, func(a, b MCP) int {
+		return strings.Compare(a.Name, b.Name)
+	})
+	return sorted
+}
+
+type LSPs map[string]LSPConfig
+
+type LSP struct {
+	Name string    `json:"name"`
+	LSP  LSPConfig `json:"lsp"`
+}
+
+func (l LSPs) Sorted() []LSP {
+	sorted := make([]LSP, 0, len(l))
+	for k, v := range l {
+		sorted = append(sorted, LSP{
+			Name: k,
+			LSP:  v,
+		})
+	}
+	slices.SortFunc(sorted, func(a, b LSP) int {
+		return strings.Compare(a.Name, b.Name)
+	})
+	return sorted
+}
+
+func (l LSPConfig) ResolvedEnv() []string {
+	return resolveEnvs(l.Env)
+}
+
+func (m MCPConfig) ResolvedEnv() []string {
+	return resolveEnvs(m.Env)
+}
+
+func (m MCPConfig) ResolvedHeaders() map[string]string {
+	resolver := NewShellVariableResolver(env.New())
+	for e, v := range m.Headers {
+		var err error
+		m.Headers[e], err = resolver.ResolveValue(v)
+		if err != nil {
+			slog.Error("error resolving header variable", "error", err, "variable", e, "value", v)
+			continue
+		}
+	}
+	return m.Headers
+}
+
+type Agent struct {
+	ID          string `json:"id,omitempty"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
+	// This is the id of the system prompt used by the agent
+	Disabled bool `json:"disabled,omitempty"`
+
+	Model SelectedModelType `json:"model" jsonschema:"required,description=The model type to use for this agent,enum=large,enum=small,default=large"`
+
+	// The available tools for the agent
+	//  if this is nil, all tools are available
+	AllowedTools []string `json:"allowed_tools,omitempty"`
+
+	// this tells us which MCPs are available for this agent
+	//  if this is empty all mcps are available
+	//  the string array is the list of tools from the AllowedMCP the agent has available
+	//  if the string array is nil, all tools from the AllowedMCP are available
+	AllowedMCP map[string][]string `json:"allowed_mcp,omitempty"`
+
+	// The list of LSPs that this agent can use
+	//  if this is nil, all LSPs are available
+	AllowedLSP []string `json:"allowed_lsp,omitempty"`
+
+	// Overrides the context paths for this agent
+	ContextPaths []string `json:"context_paths,omitempty"`
+}
+
+// Config holds the configuration for crush.
+type Config struct {
+	Schema string `json:"$schema,omitempty"`
+
+	// We currently only support large/small as values here.
+	Models map[SelectedModelType]SelectedModel `json:"models,omitempty" jsonschema:"description=Model configurations for different model types,example={\"large\":{\"model\":\"gpt-4o\",\"provider\":\"openai\"}}"`
+
+	// The providers that are configured
+	Providers *csync.Map[string, ProviderConfig] `json:"providers,omitempty" jsonschema:"description=AI provider configurations"`
+
+	MCP MCPs `json:"mcp,omitempty" jsonschema:"description=Model Context Protocol server configurations"`
+
+	LSP LSPs `json:"lsp,omitempty" jsonschema:"description=Language Server Protocol configurations"`
+
+	Options *Options `json:"options,omitempty" jsonschema:"description=General application options"`
+
+	Permissions *Permissions `json:"permissions,omitempty" jsonschema:"description=Permission settings for tool usage"`
+
+	// Internal
+	workingDir string `json:"-"`
+	// TODO: most likely remove this concept when I come back to it
+	Agents map[string]Agent `json:"-"`
+	// TODO: find a better way to do this this should probably not be part of the config
+	resolver       VariableResolver
+	dataConfigDir  string             `json:"-"`
+	knownProviders []catwalk.Provider `json:"-"`
+}
+
+func (c *Config) WorkingDir() string {
+	return c.workingDir
+}
+
+func (c *Config) EnabledProviders() []ProviderConfig {
+	var enabled []ProviderConfig
+	for p := range c.Providers.Seq() {
+		if !p.Disable {
+			enabled = append(enabled, p)
+		}
+	}
+	return enabled
+}
+
+// IsConfigured  return true if at least one provider is configured
+func (c *Config) IsConfigured() bool {
+	return len(c.EnabledProviders()) > 0
+}
+
+func (c *Config) GetModel(provider, model string) *catwalk.Model {
+	if providerConfig, ok := c.Providers.Get(provider); ok {
+		for _, m := range providerConfig.Models {
+			if m.ID == model {
+				return &m
+			}
+		}
+	}
+	return nil
+}
+
+func (c *Config) GetProviderForModel(modelType SelectedModelType) *ProviderConfig {
+	model, ok := c.Models[modelType]
+	if !ok {
+		return nil
+	}
+	if providerConfig, ok := c.Providers.Get(model.Provider); ok {
+		return &providerConfig
+	}
+	return nil
+}
+
+func (c *Config) GetModelByType(modelType SelectedModelType) *catwalk.Model {
+	model, ok := c.Models[modelType]
+	if !ok {
+		return nil
+	}
+	return c.GetModel(model.Provider, model.Model)
+}
+
+func (c *Config) LargeModel() *catwalk.Model {
+	model, ok := c.Models[SelectedModelTypeLarge]
+	if !ok {
+		return nil
+	}
+	return c.GetModel(model.Provider, model.Model)
+}
+
+func (c *Config) SmallModel() *catwalk.Model {
+	model, ok := c.Models[SelectedModelTypeSmall]
+	if !ok {
+		return nil
+	}
+	return c.GetModel(model.Provider, model.Model)
+}
+
+func (c *Config) SetCompactMode(enabled bool) error {
+	if c.Options == nil {
+		c.Options = &Options{}
+	}
+	c.Options.TUI.CompactMode = enabled
+	return c.SetConfigField("options.tui.compact_mode", enabled)
+}
+
+func (c *Config) Resolve(key string) (string, error) {
+	if c.resolver == nil {
+		return "", fmt.Errorf("no variable resolver configured")
+	}
+	return c.resolver.ResolveValue(key)
+}
+
+func (c *Config) UpdatePreferredModel(modelType SelectedModelType, model SelectedModel) error {
+	c.Models[modelType] = model
+	if err := c.SetConfigField(fmt.Sprintf("models.%s", modelType), model); err != nil {
+		return fmt.Errorf("failed to update preferred model: %w", err)
+	}
+	return nil
+}
+
+func (c *Config) SetConfigField(key string, value any) error {
+	// read the data
+	data, err := os.ReadFile(c.dataConfigDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			data = []byte("{}")
+		} else {
+			return fmt.Errorf("failed to read config file: %w", err)
+		}
+	}
+
+	newValue, err := sjson.Set(string(data), key, value)
+	if err != nil {
+		return fmt.Errorf("failed to set config field %s: %w", key, err)
+	}
+	if err := os.WriteFile(c.dataConfigDir, []byte(newValue), 0o600); err != nil {
+		return fmt.Errorf("failed to write config file: %w", err)
+	}
+	return nil
+}
+
+func (c *Config) SetProviderAPIKey(providerID, apiKey string) error {
+	// First save to the config file
+	err := c.SetConfigField("providers."+providerID+".api_key", apiKey)
+	if err != nil {
+		return fmt.Errorf("failed to save API key to config file: %w", err)
+	}
+
+	providerConfig, exists := c.Providers.Get(providerID)
+	if exists {
+		providerConfig.APIKey = apiKey
+		c.Providers.Set(providerID, providerConfig)
+		return nil
+	}
+
+	var foundProvider *catwalk.Provider
+	for _, p := range c.knownProviders {
+		if string(p.ID) == providerID {
+			foundProvider = &p
+			break
+		}
+	}
+
+	if foundProvider != nil {
+		// Create new provider config based on known provider
+		providerConfig = ProviderConfig{
+			ID:           providerID,
+			Name:         foundProvider.Name,
+			BaseURL:      foundProvider.APIEndpoint,
+			Type:         foundProvider.Type,
+			APIKey:       apiKey,
+			Disable:      false,
+			ExtraHeaders: make(map[string]string),
+			ExtraParams:  make(map[string]string),
+			Models:       foundProvider.Models,
+		}
+	} else {
+		return fmt.Errorf("provider with ID %s not found in known providers", providerID)
+	}
+	// Store the updated provider config
+	c.Providers.Set(providerID, providerConfig)
+	return nil
+}
+
+func (c *Config) SetupAgents() {
+	agents := map[string]Agent{
+		"coder": {
+			ID:           "coder",
+			Name:         "Coder",
+			Description:  "An agent that helps with executing coding tasks.",
+			Model:        SelectedModelTypeLarge,
+			ContextPaths: c.Options.ContextPaths,
+			// All tools allowed
+		},
+		"task": {
+			ID:           "task",
+			Name:         "Task",
+			Description:  "An agent that helps with searching for context and finding implementation details.",
+			Model:        SelectedModelTypeLarge,
+			ContextPaths: c.Options.ContextPaths,
+			AllowedTools: []string{
+				"glob",
+				"grep",
+				"ls",
+				"sourcegraph",
+				"view",
+			},
+			// NO MCPs or LSPs by default
+			AllowedMCP: map[string][]string{},
+			AllowedLSP: []string{},
+		},
+	}
+	c.Agents = agents
+}
+
+func (c *Config) Resolver() VariableResolver {
+	return c.resolver
+}
+
+func (c *ProviderConfig) TestConnection(resolver VariableResolver) error {
+	testURL := ""
+	headers := make(map[string]string)
+	apiKey, _ := resolver.ResolveValue(c.APIKey)
+	switch c.Type {
+	case catwalk.TypeOpenAI:
+		baseURL, _ := resolver.ResolveValue(c.BaseURL)
+		if baseURL == "" {
+			baseURL = "https://api.openai.com/v1"
+		}
+		testURL = baseURL + "/models"
+		headers["Authorization"] = "Bearer " + apiKey
+	case catwalk.TypeAnthropic:
+		baseURL, _ := resolver.ResolveValue(c.BaseURL)
+		if baseURL == "" {
+			baseURL = "https://api.anthropic.com/v1"
+		}
+		testURL = baseURL + "/models"
+		headers["x-api-key"] = apiKey
+		headers["anthropic-version"] = "2023-06-01"
+	case catwalk.TypeGemini:
+		baseURL, _ := resolver.ResolveValue(c.BaseURL)
+		if baseURL == "" {
+			baseURL = "https://generativelanguage.googleapis.com"
+		}
+		testURL = baseURL + "/v1beta/models?key=" + url.QueryEscape(apiKey)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	client := &http.Client{}
+	req, err := http.NewRequestWithContext(ctx, "GET", testURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request for provider %s: %w", c.ID, err)
+	}
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	for k, v := range c.ExtraHeaders {
+		req.Header.Set(k, v)
+	}
+	b, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to create request for provider %s: %w", c.ID, err)
+	}
+	if b.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to connect to provider %s: %s", c.ID, b.Status)
+	}
+	_ = b.Body.Close()
+	return nil
+}
+
+func resolveEnvs(envs map[string]string) []string {
+	resolver := NewShellVariableResolver(env.New())
+	for e, v := range envs {
+		var err error
+		envs[e], err = resolver.ResolveValue(v)
+		if err != nil {
+			slog.Error("error resolving environment variable", "error", err, "variable", e, "value", v)
+			continue
+		}
+	}
+
+	res := make([]string, 0, len(envs))
+	for k, v := range envs {
+		res = append(res, fmt.Sprintf("%s=%s", k, v))
+	}
+	return res
+}

projects/ui/crush/internal/config/init.go

@@ -0,0 +1,106 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+)
+
+const (
+	InitFlagFilename = "init"
+)
+
+type ProjectInitFlag struct {
+	Initialized bool `json:"initialized"`
+}
+
+// TODO: we need to remove the global config instance keeping it now just until everything is migrated
+var instance atomic.Pointer[Config]
+
+func Init(workingDir, dataDir string, debug bool) (*Config, error) {
+	cfg, err := Load(workingDir, dataDir, debug)
+	if err != nil {
+		return nil, err
+	}
+	instance.Store(cfg)
+	return instance.Load(), nil
+}
+
+func Get() *Config {
+	cfg := instance.Load()
+	return cfg
+}
+
+func ProjectNeedsInitialization() (bool, error) {
+	cfg := Get()
+	if cfg == nil {
+		return false, fmt.Errorf("config not loaded")
+	}
+
+	flagFilePath := filepath.Join(cfg.Options.DataDirectory, InitFlagFilename)
+
+	_, err := os.Stat(flagFilePath)
+	if err == nil {
+		return false, nil
+	}
+
+	if !os.IsNotExist(err) {
+		return false, fmt.Errorf("failed to check init flag file: %w", err)
+	}
+
+	crushExists, err := crushMdExists(cfg.WorkingDir())
+	if err != nil {
+		return false, fmt.Errorf("failed to check for CRUSH.md files: %w", err)
+	}
+	if crushExists {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func crushMdExists(dir string) (bool, error) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return false, err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+
+		name := strings.ToLower(entry.Name())
+		if name == "crush.md" {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+func MarkProjectInitialized() error {
+	cfg := Get()
+	if cfg == nil {
+		return fmt.Errorf("config not loaded")
+	}
+	flagFilePath := filepath.Join(cfg.Options.DataDirectory, InitFlagFilename)
+
+	file, err := os.Create(flagFilePath)
+	if err != nil {
+		return fmt.Errorf("failed to create init flag file: %w", err)
+	}
+	defer file.Close()
+
+	return nil
+}
+
+func HasInitialDataConfig() bool {
+	cfgPath := GlobalConfigData()
+	if _, err := os.Stat(cfgPath); err != nil {
+		return false
+	}
+	return Get().IsConfigured()
+}

projects/ui/crush/internal/config/load.go

@@ -0,0 +1,611 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log/slog"
+	"maps"
+	"os"
+	"path/filepath"
+	"runtime"
+	"slices"
+	"strings"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/env"
+	"github.com/charmbracelet/crush/internal/fsext"
+	"github.com/charmbracelet/crush/internal/home"
+	"github.com/charmbracelet/crush/internal/log"
+)
+
+const defaultCatwalkURL = "https://catwalk.charm.sh"
+
+// LoadReader config via io.Reader.
+func LoadReader(fd io.Reader) (*Config, error) {
+	data, err := io.ReadAll(fd)
+	if err != nil {
+		return nil, err
+	}
+
+	var config Config
+	err = json.Unmarshal(data, &config)
+	if err != nil {
+		return nil, err
+	}
+	return &config, err
+}
+
+// Load loads the configuration from the default paths.
+func Load(workingDir, dataDir string, debug bool) (*Config, error) {
+	// uses default config paths
+	configPaths := []string{
+		globalConfig(),
+		GlobalConfigData(),
+		filepath.Join(workingDir, fmt.Sprintf("%s.json", appName)),
+		filepath.Join(workingDir, fmt.Sprintf(".%s.json", appName)),
+	}
+	cfg, err := loadFromConfigPaths(configPaths)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load config from paths %v: %w", configPaths, err)
+	}
+
+	cfg.dataConfigDir = GlobalConfigData()
+
+	cfg.setDefaults(workingDir, dataDir)
+
+	if debug {
+		cfg.Options.Debug = true
+	}
+
+	// Setup logs
+	log.Setup(
+		filepath.Join(cfg.Options.DataDirectory, "logs", fmt.Sprintf("%s.log", appName)),
+		cfg.Options.Debug,
+	)
+
+	// Load known providers, this loads the config from catwalk
+	providers, err := Providers()
+	if err != nil || len(providers) == 0 {
+		return nil, fmt.Errorf("failed to load providers: %w", err)
+	}
+	cfg.knownProviders = providers
+
+	env := env.New()
+	// Configure providers
+	valueResolver := NewShellVariableResolver(env)
+	cfg.resolver = valueResolver
+	if err := cfg.configureProviders(env, valueResolver, providers); err != nil {
+		return nil, fmt.Errorf("failed to configure providers: %w", err)
+	}
+
+	if !cfg.IsConfigured() {
+		slog.Warn("No providers configured")
+		return cfg, nil
+	}
+
+	if err := cfg.configureSelectedModels(providers); err != nil {
+		return nil, fmt.Errorf("failed to configure selected models: %w", err)
+	}
+	cfg.SetupAgents()
+	return cfg, nil
+}
+
+func PushPopCrushEnv() func() {
+	found := []string{}
+	for _, ev := range os.Environ() {
+		if strings.HasPrefix(ev, "CRUSH_") {
+			pair := strings.SplitN(ev, "=", 2)
+			if len(pair) != 2 {
+				continue
+			}
+			found = append(found, strings.TrimPrefix(pair[0], "CRUSH_"))
+		}
+	}
+	backups := make(map[string]string)
+	for _, ev := range found {
+		backups[ev] = os.Getenv(ev)
+	}
+
+	for _, ev := range found {
+		os.Setenv(ev, os.Getenv("CRUSH_"+ev))
+	}
+
+	restore := func() {
+		for k, v := range backups {
+			os.Setenv(k, v)
+		}
+	}
+	return restore
+}
+
+func (c *Config) configureProviders(env env.Env, resolver VariableResolver, knownProviders []catwalk.Provider) error {
+	knownProviderNames := make(map[string]bool)
+	restore := PushPopCrushEnv()
+	defer restore()
+	for _, p := range knownProviders {
+		knownProviderNames[string(p.ID)] = true
+		config, configExists := c.Providers.Get(string(p.ID))
+		// if the user configured a known provider we need to allow it to override a couple of parameters
+		if configExists {
+			if config.Disable {
+				slog.Debug("Skipping provider due to disable flag", "provider", p.ID)
+				c.Providers.Del(string(p.ID))
+				continue
+			}
+			if config.BaseURL != "" {
+				p.APIEndpoint = config.BaseURL
+			}
+			if config.APIKey != "" {
+				p.APIKey = config.APIKey
+			}
+			if len(config.Models) > 0 {
+				models := []catwalk.Model{}
+				seen := make(map[string]bool)
+
+				for _, model := range config.Models {
+					if seen[model.ID] {
+						continue
+					}
+					seen[model.ID] = true
+					if model.Name == "" {
+						model.Name = model.ID
+					}
+					models = append(models, model)
+				}
+				for _, model := range p.Models {
+					if seen[model.ID] {
+						continue
+					}
+					seen[model.ID] = true
+					if model.Name == "" {
+						model.Name = model.ID
+					}
+					models = append(models, model)
+				}
+
+				p.Models = models
+			}
+		}
+
+		headers := map[string]string{}
+		if len(p.DefaultHeaders) > 0 {
+			maps.Copy(headers, p.DefaultHeaders)
+		}
+		if len(config.ExtraHeaders) > 0 {
+			maps.Copy(headers, config.ExtraHeaders)
+		}
+		prepared := ProviderConfig{
+			ID:                 string(p.ID),
+			Name:               p.Name,
+			BaseURL:            p.APIEndpoint,
+			APIKey:             p.APIKey,
+			Type:               p.Type,
+			Disable:            config.Disable,
+			SystemPromptPrefix: config.SystemPromptPrefix,
+			ExtraHeaders:       headers,
+			ExtraBody:          config.ExtraBody,
+			ExtraParams:        make(map[string]string),
+			Models:             p.Models,
+		}
+
+		switch p.ID {
+		// Handle specific providers that require additional configuration
+		case catwalk.InferenceProviderVertexAI:
+			if !hasVertexCredentials(env) {
+				if configExists {
+					slog.Warn("Skipping Vertex AI provider due to missing credentials")
+					c.Providers.Del(string(p.ID))
+				}
+				continue
+			}
+			prepared.ExtraParams["project"] = env.Get("VERTEXAI_PROJECT")
+			prepared.ExtraParams["location"] = env.Get("VERTEXAI_LOCATION")
+		case catwalk.InferenceProviderAzure:
+			endpoint, err := resolver.ResolveValue(p.APIEndpoint)
+			if err != nil || endpoint == "" {
+				if configExists {
+					slog.Warn("Skipping Azure provider due to missing API endpoint", "provider", p.ID, "error", err)
+					c.Providers.Del(string(p.ID))
+				}
+				continue
+			}
+			prepared.BaseURL = endpoint
+			prepared.ExtraParams["apiVersion"] = env.Get("AZURE_OPENAI_API_VERSION")
+		case catwalk.InferenceProviderBedrock:
+			if !hasAWSCredentials(env) {
+				if configExists {
+					slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
+					c.Providers.Del(string(p.ID))
+				}
+				continue
+			}
+			prepared.ExtraParams["region"] = env.Get("AWS_REGION")
+			if prepared.ExtraParams["region"] == "" {
+				prepared.ExtraParams["region"] = env.Get("AWS_DEFAULT_REGION")
+			}
+			for _, model := range p.Models {
+				if !strings.HasPrefix(model.ID, "anthropic.") {
+					return fmt.Errorf("bedrock provider only supports anthropic models for now, found: %s", model.ID)
+				}
+			}
+		default:
+			// if the provider api or endpoint are missing we skip them
+			v, err := resolver.ResolveValue(p.APIKey)
+			if v == "" || err != nil {
+				if configExists {
+					slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
+					c.Providers.Del(string(p.ID))
+				}
+				continue
+			}
+		}
+		c.Providers.Set(string(p.ID), prepared)
+	}
+
+	// validate the custom providers
+	for id, providerConfig := range c.Providers.Seq2() {
+		if knownProviderNames[id] {
+			continue
+		}
+
+		// Make sure the provider ID is set
+		providerConfig.ID = id
+		if providerConfig.Name == "" {
+			providerConfig.Name = id // Use ID as name if not set
+		}
+		// default to OpenAI if not set
+		if providerConfig.Type == "" {
+			providerConfig.Type = catwalk.TypeOpenAI
+		}
+
+		if providerConfig.Disable {
+			slog.Debug("Skipping custom provider due to disable flag", "provider", id)
+			c.Providers.Del(id)
+			continue
+		}
+		if providerConfig.APIKey == "" {
+			slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
+		}
+		if providerConfig.BaseURL == "" {
+			slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
+			c.Providers.Del(id)
+			continue
+		}
+		if len(providerConfig.Models) == 0 {
+			slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
+			c.Providers.Del(id)
+			continue
+		}
+		if providerConfig.Type != catwalk.TypeOpenAI && providerConfig.Type != catwalk.TypeAnthropic {
+			slog.Warn("Skipping custom provider because the provider type is not supported", "provider", id, "type", providerConfig.Type)
+			c.Providers.Del(id)
+			continue
+		}
+
+		apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
+		if apiKey == "" || err != nil {
+			slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
+		}
+		baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
+		if baseURL == "" || err != nil {
+			slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
+			c.Providers.Del(id)
+			continue
+		}
+
+		c.Providers.Set(id, providerConfig)
+	}
+	return nil
+}
+
+func (c *Config) setDefaults(workingDir, dataDir string) {
+	c.workingDir = workingDir
+	if c.Options == nil {
+		c.Options = &Options{}
+	}
+	if c.Options.TUI == nil {
+		c.Options.TUI = &TUIOptions{}
+	}
+	if c.Options.ContextPaths == nil {
+		c.Options.ContextPaths = []string{}
+	}
+	if dataDir != "" {
+		c.Options.DataDirectory = dataDir
+	} else if c.Options.DataDirectory == "" {
+		if path, ok := fsext.SearchParent(workingDir, defaultDataDirectory); ok {
+			c.Options.DataDirectory = path
+		} else {
+			c.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
+		}
+	}
+	if c.Providers == nil {
+		c.Providers = csync.NewMap[string, ProviderConfig]()
+	}
+	if c.Models == nil {
+		c.Models = make(map[SelectedModelType]SelectedModel)
+	}
+	if c.MCP == nil {
+		c.MCP = make(map[string]MCPConfig)
+	}
+	if c.LSP == nil {
+		c.LSP = make(map[string]LSPConfig)
+	}
+
+	// Apply default file types for known LSP servers if not specified
+	applyDefaultLSPFileTypes(c.LSP)
+
+	// Add the default context paths if they are not already present
+	c.Options.ContextPaths = append(defaultContextPaths, c.Options.ContextPaths...)
+	slices.Sort(c.Options.ContextPaths)
+	c.Options.ContextPaths = slices.Compact(c.Options.ContextPaths)
+}
+
+var defaultLSPFileTypes = map[string][]string{
+	"gopls":                      {"go", "mod", "sum", "work"},
+	"typescript-language-server": {"ts", "tsx", "js", "jsx", "mjs", "cjs"},
+	"vtsls":                      {"ts", "tsx", "js", "jsx", "mjs", "cjs"},
+	"bash-language-server":       {"sh", "bash", "zsh", "ksh"},
+	"rust-analyzer":              {"rs"},
+	"pyright":                    {"py", "pyi"},
+	"pylsp":                      {"py", "pyi"},
+	"clangd":                     {"c", "cpp", "cc", "cxx", "h", "hpp"},
+	"jdtls":                      {"java"},
+	"vscode-html-languageserver": {"html", "htm"},
+	"vscode-css-languageserver":  {"css", "scss", "sass", "less"},
+	"vscode-json-languageserver": {"json", "jsonc"},
+	"yaml-language-server":       {"yaml", "yml"},
+	"lua-language-server":        {"lua"},
+	"solargraph":                 {"rb"},
+	"elixir-ls":                  {"ex", "exs"},
+	"zls":                        {"zig"},
+}
+
+// applyDefaultLSPFileTypes sets default file types for known LSP servers
+func applyDefaultLSPFileTypes(lspConfigs map[string]LSPConfig) {
+	for name, config := range lspConfigs {
+		if len(config.FileTypes) != 0 {
+			continue
+		}
+		bin := strings.ToLower(filepath.Base(config.Command))
+		config.FileTypes = defaultLSPFileTypes[bin]
+		lspConfigs[name] = config
+	}
+}
+
+func (c *Config) defaultModelSelection(knownProviders []catwalk.Provider) (largeModel SelectedModel, smallModel SelectedModel, err error) {
+	if len(knownProviders) == 0 && c.Providers.Len() == 0 {
+		err = fmt.Errorf("no providers configured, please configure at least one provider")
+		return
+	}
+
+	// Use the first provider enabled based on the known providers order
+	// if no provider found that is known use the first provider configured
+	for _, p := range knownProviders {
+		providerConfig, ok := c.Providers.Get(string(p.ID))
+		if !ok || providerConfig.Disable {
+			continue
+		}
+		defaultLargeModel := c.GetModel(string(p.ID), p.DefaultLargeModelID)
+		if defaultLargeModel == nil {
+			err = fmt.Errorf("default large model %s not found for provider %s", p.DefaultLargeModelID, p.ID)
+			return
+		}
+		largeModel = SelectedModel{
+			Provider:        string(p.ID),
+			Model:           defaultLargeModel.ID,
+			MaxTokens:       defaultLargeModel.DefaultMaxTokens,
+			ReasoningEffort: defaultLargeModel.DefaultReasoningEffort,
+		}
+
+		defaultSmallModel := c.GetModel(string(p.ID), p.DefaultSmallModelID)
+		if defaultSmallModel == nil {
+			err = fmt.Errorf("default small model %s not found for provider %s", p.DefaultSmallModelID, p.ID)
+			return
+		}
+		smallModel = SelectedModel{
+			Provider:        string(p.ID),
+			Model:           defaultSmallModel.ID,
+			MaxTokens:       defaultSmallModel.DefaultMaxTokens,
+			ReasoningEffort: defaultSmallModel.DefaultReasoningEffort,
+		}
+		return
+	}
+
+	enabledProviders := c.EnabledProviders()
+	slices.SortFunc(enabledProviders, func(a, b ProviderConfig) int {
+		return strings.Compare(a.ID, b.ID)
+	})
+
+	if len(enabledProviders) == 0 {
+		err = fmt.Errorf("no providers configured, please configure at least one provider")
+		return
+	}
+
+	providerConfig := enabledProviders[0]
+	if len(providerConfig.Models) == 0 {
+		err = fmt.Errorf("provider %s has no models configured", providerConfig.ID)
+		return
+	}
+	defaultLargeModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
+	largeModel = SelectedModel{
+		Provider:  providerConfig.ID,
+		Model:     defaultLargeModel.ID,
+		MaxTokens: defaultLargeModel.DefaultMaxTokens,
+	}
+	defaultSmallModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
+	smallModel = SelectedModel{
+		Provider:  providerConfig.ID,
+		Model:     defaultSmallModel.ID,
+		MaxTokens: defaultSmallModel.DefaultMaxTokens,
+	}
+	return
+}
+
+func (c *Config) configureSelectedModels(knownProviders []catwalk.Provider) error {
+	defaultLarge, defaultSmall, err := c.defaultModelSelection(knownProviders)
+	if err != nil {
+		return fmt.Errorf("failed to select default models: %w", err)
+	}
+	large, small := defaultLarge, defaultSmall
+
+	largeModelSelected, largeModelConfigured := c.Models[SelectedModelTypeLarge]
+	if largeModelConfigured {
+		if largeModelSelected.Model != "" {
+			large.Model = largeModelSelected.Model
+		}
+		if largeModelSelected.Provider != "" {
+			large.Provider = largeModelSelected.Provider
+		}
+		model := c.GetModel(large.Provider, large.Model)
+		if model == nil {
+			large = defaultLarge
+			// override the model type to large
+			err := c.UpdatePreferredModel(SelectedModelTypeLarge, large)
+			if err != nil {
+				return fmt.Errorf("failed to update preferred large model: %w", err)
+			}
+		} else {
+			if largeModelSelected.MaxTokens > 0 {
+				large.MaxTokens = largeModelSelected.MaxTokens
+			} else {
+				large.MaxTokens = model.DefaultMaxTokens
+			}
+			if largeModelSelected.ReasoningEffort != "" {
+				large.ReasoningEffort = largeModelSelected.ReasoningEffort
+			}
+			large.Think = largeModelSelected.Think
+		}
+	}
+	smallModelSelected, smallModelConfigured := c.Models[SelectedModelTypeSmall]
+	if smallModelConfigured {
+		if smallModelSelected.Model != "" {
+			small.Model = smallModelSelected.Model
+		}
+		if smallModelSelected.Provider != "" {
+			small.Provider = smallModelSelected.Provider
+		}
+
+		model := c.GetModel(small.Provider, small.Model)
+		if model == nil {
+			small = defaultSmall
+			// override the model type to small
+			err := c.UpdatePreferredModel(SelectedModelTypeSmall, small)
+			if err != nil {
+				return fmt.Errorf("failed to update preferred small model: %w", err)
+			}
+		} else {
+			if smallModelSelected.MaxTokens > 0 {
+				small.MaxTokens = smallModelSelected.MaxTokens
+			} else {
+				small.MaxTokens = model.DefaultMaxTokens
+			}
+			small.ReasoningEffort = smallModelSelected.ReasoningEffort
+			small.Think = smallModelSelected.Think
+		}
+	}
+	c.Models[SelectedModelTypeLarge] = large
+	c.Models[SelectedModelTypeSmall] = small
+	return nil
+}
+
+func loadFromConfigPaths(configPaths []string) (*Config, error) {
+	var configs []io.Reader
+
+	for _, path := range configPaths {
+		fd, err := os.Open(path)
+		if err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return nil, fmt.Errorf("failed to open config file %s: %w", path, err)
+		}
+		defer fd.Close()
+
+		configs = append(configs, fd)
+	}
+
+	return loadFromReaders(configs)
+}
+
+func loadFromReaders(readers []io.Reader) (*Config, error) {
+	if len(readers) == 0 {
+		return &Config{}, nil
+	}
+
+	merged, err := Merge(readers)
+	if err != nil {
+		return nil, fmt.Errorf("failed to merge configuration readers: %w", err)
+	}
+
+	return LoadReader(merged)
+}
+
+func hasVertexCredentials(env env.Env) bool {
+	hasProject := env.Get("VERTEXAI_PROJECT") != ""
+	hasLocation := env.Get("VERTEXAI_LOCATION") != ""
+	return hasProject && hasLocation
+}
+
+func hasAWSCredentials(env env.Env) bool {
+	if env.Get("AWS_ACCESS_KEY_ID") != "" && env.Get("AWS_SECRET_ACCESS_KEY") != "" {
+		return true
+	}
+
+	if env.Get("AWS_PROFILE") != "" || env.Get("AWS_DEFAULT_PROFILE") != "" {
+		return true
+	}
+
+	if env.Get("AWS_REGION") != "" || env.Get("AWS_DEFAULT_REGION") != "" {
+		return true
+	}
+
+	if env.Get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
+		env.Get("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
+		return true
+	}
+	return false
+}
+
+func globalConfig() string {
+	xdgConfigHome := os.Getenv("XDG_CONFIG_HOME")
+	if xdgConfigHome != "" {
+		return filepath.Join(xdgConfigHome, appName, fmt.Sprintf("%s.json", appName))
+	}
+
+	// return the path to the main config directory
+	// for windows, it should be in `%LOCALAPPDATA%/crush/`
+	// for linux and macOS, it should be in `$HOME/.config/crush/`
+	if runtime.GOOS == "windows" {
+		localAppData := os.Getenv("LOCALAPPDATA")
+		if localAppData == "" {
+			localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
+		}
+		return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
+	}
+
+	return filepath.Join(home.Dir(), ".config", appName, fmt.Sprintf("%s.json", appName))
+}
+
+// GlobalConfigData returns the path to the main data directory for the application.
+// this config is used when the app overrides configurations instead of updating the global config.
+func GlobalConfigData() string {
+	xdgDataHome := os.Getenv("XDG_DATA_HOME")
+	if xdgDataHome != "" {
+		return filepath.Join(xdgDataHome, appName, fmt.Sprintf("%s.json", appName))
+	}
+
+	// return the path to the main data directory
+	// for windows, it should be in `%LOCALAPPDATA%/crush/`
+	// for linux and macOS, it should be in `$HOME/.local/share/crush/`
+	if runtime.GOOS == "windows" {
+		localAppData := os.Getenv("LOCALAPPDATA")
+		if localAppData == "" {
+			localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
+		}
+		return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
+	}
+
+	return filepath.Join(home.Dir(), ".local", "share", appName, fmt.Sprintf("%s.json", appName))
+}

projects/ui/crush/internal/config/load_test.go

@@ -0,0 +1,1186 @@
+package config
+
+import (
+	"io"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+	"github.com/charmbracelet/crush/internal/csync"
+	"github.com/charmbracelet/crush/internal/env"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMain(m *testing.M) {
+	slog.SetDefault(slog.New(slog.NewTextHandler(io.Discard, nil)))
+
+	exitVal := m.Run()
+	os.Exit(exitVal)
+}
+
+func TestConfig_LoadFromReaders(t *testing.T) {
+	data1 := strings.NewReader(`{"providers": {"openai": {"api_key": "key1", "base_url": "https://api.openai.com/v1"}}}`)
+	data2 := strings.NewReader(`{"providers": {"openai": {"api_key": "key2", "base_url": "https://api.openai.com/v2"}}}`)
+	data3 := strings.NewReader(`{"providers": {"openai": {}}}`)
+
+	loadedConfig, err := loadFromReaders([]io.Reader{data1, data2, data3})
+
+	require.NoError(t, err)
+	require.NotNil(t, loadedConfig)
+	require.Equal(t, 1, loadedConfig.Providers.Len())
+	pc, _ := loadedConfig.Providers.Get("openai")
+	require.Equal(t, "key2", pc.APIKey)
+	require.Equal(t, "https://api.openai.com/v2", pc.BaseURL)
+}
+
+func TestConfig_setDefaults(t *testing.T) {
+	cfg := &Config{}
+
+	cfg.setDefaults("/tmp", "")
+
+	require.NotNil(t, cfg.Options)
+	require.NotNil(t, cfg.Options.TUI)
+	require.NotNil(t, cfg.Options.ContextPaths)
+	require.NotNil(t, cfg.Providers)
+	require.NotNil(t, cfg.Models)
+	require.NotNil(t, cfg.LSP)
+	require.NotNil(t, cfg.MCP)
+	require.Equal(t, filepath.Join("/tmp", ".crush"), cfg.Options.DataDirectory)
+	for _, path := range defaultContextPaths {
+		require.Contains(t, cfg.Options.ContextPaths, path)
+	}
+	require.Equal(t, "/tmp", cfg.workingDir)
+}
+
+func TestConfig_configureProviders(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          "openai",
+			APIKey:      "$OPENAI_API_KEY",
+			APIEndpoint: "https://api.openai.com/v1",
+			Models: []catwalk.Model{{
+				ID: "test-model",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"OPENAI_API_KEY": "test-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	require.Equal(t, 1, cfg.Providers.Len())
+
+	// We want to make sure that we keep the configured API key as a placeholder
+	pc, _ := cfg.Providers.Get("openai")
+	require.Equal(t, "$OPENAI_API_KEY", pc.APIKey)
+}
+
+func TestConfig_configureProvidersWithOverride(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          "openai",
+			APIKey:      "$OPENAI_API_KEY",
+			APIEndpoint: "https://api.openai.com/v1",
+			Models: []catwalk.Model{{
+				ID: "test-model",
+			}},
+		},
+	}
+
+	cfg := &Config{
+		Providers: csync.NewMap[string, ProviderConfig](),
+	}
+	cfg.Providers.Set("openai", ProviderConfig{
+		APIKey:  "xyz",
+		BaseURL: "https://api.openai.com/v2",
+		Models: []catwalk.Model{
+			{
+				ID:   "test-model",
+				Name: "Updated",
+			},
+			{
+				ID: "another-model",
+			},
+		},
+	})
+	cfg.setDefaults("/tmp", "")
+
+	env := env.NewFromMap(map[string]string{
+		"OPENAI_API_KEY": "test-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	require.Equal(t, 1, cfg.Providers.Len())
+
+	// We want to make sure that we keep the configured API key as a placeholder
+	pc, _ := cfg.Providers.Get("openai")
+	require.Equal(t, "xyz", pc.APIKey)
+	require.Equal(t, "https://api.openai.com/v2", pc.BaseURL)
+	require.Len(t, pc.Models, 2)
+	require.Equal(t, "Updated", pc.Models[0].Name)
+}
+
+func TestConfig_configureProvidersWithNewProvider(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          "openai",
+			APIKey:      "$OPENAI_API_KEY",
+			APIEndpoint: "https://api.openai.com/v1",
+			Models: []catwalk.Model{{
+				ID: "test-model",
+			}},
+		},
+	}
+
+	cfg := &Config{
+		Providers: csync.NewMapFrom(map[string]ProviderConfig{
+			"custom": {
+				APIKey:  "xyz",
+				BaseURL: "https://api.someendpoint.com/v2",
+				Models: []catwalk.Model{
+					{
+						ID: "test-model",
+					},
+				},
+			},
+		}),
+	}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"OPENAI_API_KEY": "test-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	// Should be to because of the env variable
+	require.Equal(t, cfg.Providers.Len(), 2)
+
+	// We want to make sure that we keep the configured API key as a placeholder
+	pc, _ := cfg.Providers.Get("custom")
+	require.Equal(t, "xyz", pc.APIKey)
+	// Make sure we set the ID correctly
+	require.Equal(t, "custom", pc.ID)
+	require.Equal(t, "https://api.someendpoint.com/v2", pc.BaseURL)
+	require.Len(t, pc.Models, 1)
+
+	_, ok := cfg.Providers.Get("openai")
+	require.True(t, ok, "OpenAI provider should still be present")
+}
+
+func TestConfig_configureProvidersBedrockWithCredentials(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          catwalk.InferenceProviderBedrock,
+			APIKey:      "",
+			APIEndpoint: "",
+			Models: []catwalk.Model{{
+				ID: "anthropic.claude-sonnet-4-20250514-v1:0",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"AWS_ACCESS_KEY_ID":     "test-key-id",
+		"AWS_SECRET_ACCESS_KEY": "test-secret-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	require.Equal(t, cfg.Providers.Len(), 1)
+
+	bedrockProvider, ok := cfg.Providers.Get("bedrock")
+	require.True(t, ok, "Bedrock provider should be present")
+	require.Len(t, bedrockProvider.Models, 1)
+	require.Equal(t, "anthropic.claude-sonnet-4-20250514-v1:0", bedrockProvider.Models[0].ID)
+}
+
+func TestConfig_configureProvidersBedrockWithoutCredentials(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          catwalk.InferenceProviderBedrock,
+			APIKey:      "",
+			APIEndpoint: "",
+			Models: []catwalk.Model{{
+				ID: "anthropic.claude-sonnet-4-20250514-v1:0",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	// Provider should not be configured without credentials
+	require.Equal(t, cfg.Providers.Len(), 0)
+}
+
+func TestConfig_configureProvidersBedrockWithoutUnsupportedModel(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          catwalk.InferenceProviderBedrock,
+			APIKey:      "",
+			APIEndpoint: "",
+			Models: []catwalk.Model{{
+				ID: "some-random-model",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"AWS_ACCESS_KEY_ID":     "test-key-id",
+		"AWS_SECRET_ACCESS_KEY": "test-secret-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.Error(t, err)
+}
+
+func TestConfig_configureProvidersVertexAIWithCredentials(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          catwalk.InferenceProviderVertexAI,
+			APIKey:      "",
+			APIEndpoint: "",
+			Models: []catwalk.Model{{
+				ID: "gemini-pro",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"VERTEXAI_PROJECT":  "test-project",
+		"VERTEXAI_LOCATION": "us-central1",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	require.Equal(t, cfg.Providers.Len(), 1)
+
+	vertexProvider, ok := cfg.Providers.Get("vertexai")
+	require.True(t, ok, "VertexAI provider should be present")
+	require.Len(t, vertexProvider.Models, 1)
+	require.Equal(t, "gemini-pro", vertexProvider.Models[0].ID)
+	require.Equal(t, "test-project", vertexProvider.ExtraParams["project"])
+	require.Equal(t, "us-central1", vertexProvider.ExtraParams["location"])
+}
+
+func TestConfig_configureProvidersVertexAIWithoutCredentials(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          catwalk.InferenceProviderVertexAI,
+			APIKey:      "",
+			APIEndpoint: "",
+			Models: []catwalk.Model{{
+				ID: "gemini-pro",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"GOOGLE_GENAI_USE_VERTEXAI": "false",
+		"GOOGLE_CLOUD_PROJECT":      "test-project",
+		"GOOGLE_CLOUD_LOCATION":     "us-central1",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	// Provider should not be configured without proper credentials
+	require.Equal(t, cfg.Providers.Len(), 0)
+}
+
+func TestConfig_configureProvidersVertexAIMissingProject(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          catwalk.InferenceProviderVertexAI,
+			APIKey:      "",
+			APIEndpoint: "",
+			Models: []catwalk.Model{{
+				ID: "gemini-pro",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"GOOGLE_GENAI_USE_VERTEXAI": "true",
+		"GOOGLE_CLOUD_LOCATION":     "us-central1",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	// Provider should not be configured without project
+	require.Equal(t, cfg.Providers.Len(), 0)
+}
+
+func TestConfig_configureProvidersSetProviderID(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          "openai",
+			APIKey:      "$OPENAI_API_KEY",
+			APIEndpoint: "https://api.openai.com/v1",
+			Models: []catwalk.Model{{
+				ID: "test-model",
+			}},
+		},
+	}
+
+	cfg := &Config{}
+	cfg.setDefaults("/tmp", "")
+	env := env.NewFromMap(map[string]string{
+		"OPENAI_API_KEY": "test-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+	require.Equal(t, cfg.Providers.Len(), 1)
+
+	// Provider ID should be set
+	pc, _ := cfg.Providers.Get("openai")
+	require.Equal(t, "openai", pc.ID)
+}
+
+func TestConfig_EnabledProviders(t *testing.T) {
+	t.Run("all providers enabled", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"openai": {
+					ID:      "openai",
+					APIKey:  "key1",
+					Disable: false,
+				},
+				"anthropic": {
+					ID:      "anthropic",
+					APIKey:  "key2",
+					Disable: false,
+				},
+			}),
+		}
+
+		enabled := cfg.EnabledProviders()
+		require.Len(t, enabled, 2)
+	})
+
+	t.Run("some providers disabled", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"openai": {
+					ID:      "openai",
+					APIKey:  "key1",
+					Disable: false,
+				},
+				"anthropic": {
+					ID:      "anthropic",
+					APIKey:  "key2",
+					Disable: true,
+				},
+			}),
+		}
+
+		enabled := cfg.EnabledProviders()
+		require.Len(t, enabled, 1)
+		require.Equal(t, "openai", enabled[0].ID)
+	})
+
+	t.Run("empty providers map", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMap[string, ProviderConfig](),
+		}
+
+		enabled := cfg.EnabledProviders()
+		require.Len(t, enabled, 0)
+	})
+}
+
+func TestConfig_IsConfigured(t *testing.T) {
+	t.Run("returns true when at least one provider is enabled", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"openai": {
+					ID:      "openai",
+					APIKey:  "key1",
+					Disable: false,
+				},
+			}),
+		}
+
+		require.True(t, cfg.IsConfigured())
+	})
+
+	t.Run("returns false when no providers are configured", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMap[string, ProviderConfig](),
+		}
+
+		require.False(t, cfg.IsConfigured())
+	})
+
+	t.Run("returns false when all providers are disabled", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"openai": {
+					ID:      "openai",
+					APIKey:  "key1",
+					Disable: true,
+				},
+				"anthropic": {
+					ID:      "anthropic",
+					APIKey:  "key2",
+					Disable: true,
+				},
+			}),
+		}
+
+		require.False(t, cfg.IsConfigured())
+	})
+}
+
+func TestConfig_configureProvidersWithDisabledProvider(t *testing.T) {
+	knownProviders := []catwalk.Provider{
+		{
+			ID:          "openai",
+			APIKey:      "$OPENAI_API_KEY",
+			APIEndpoint: "https://api.openai.com/v1",
+			Models: []catwalk.Model{{
+				ID: "test-model",
+			}},
+		},
+	}
+
+	cfg := &Config{
+		Providers: csync.NewMapFrom(map[string]ProviderConfig{
+			"openai": {
+				Disable: true,
+			},
+		}),
+	}
+	cfg.setDefaults("/tmp", "")
+
+	env := env.NewFromMap(map[string]string{
+		"OPENAI_API_KEY": "test-key",
+	})
+	resolver := NewEnvironmentVariableResolver(env)
+	err := cfg.configureProviders(env, resolver, knownProviders)
+	require.NoError(t, err)
+
+	// Provider should be removed from config when disabled
+	require.Equal(t, cfg.Providers.Len(), 0)
+	_, exists := cfg.Providers.Get("openai")
+	require.False(t, exists)
+}
+
+func TestConfig_configureProvidersCustomProviderValidation(t *testing.T) {
+	t.Run("custom provider with missing API key is allowed, but not known providers", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					BaseURL: "https://api.custom.com/v1",
+					Models: []catwalk.Model{{
+						ID: "test-model",
+					}},
+				},
+				"openai": {
+					APIKey: "$MISSING",
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 1)
+		_, exists := cfg.Providers.Get("custom")
+		require.True(t, exists)
+	})
+
+	t.Run("custom provider with missing BaseURL is removed", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey: "test-key",
+					Models: []catwalk.Model{{
+						ID: "test-model",
+					}},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("custom")
+		require.False(t, exists)
+	})
+
+	t.Run("custom provider with no models is removed", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Models:  []catwalk.Model{},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("custom")
+		require.False(t, exists)
+	})
+
+	t.Run("custom provider with unsupported type is removed", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Type:    "unsupported",
+					Models: []catwalk.Model{{
+						ID: "test-model",
+					}},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("custom")
+		require.False(t, exists)
+	})
+
+	t.Run("valid custom provider is kept and ID is set", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Type:    catwalk.TypeOpenAI,
+					Models: []catwalk.Model{{
+						ID: "test-model",
+					}},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 1)
+		customProvider, exists := cfg.Providers.Get("custom")
+		require.True(t, exists)
+		require.Equal(t, "custom", customProvider.ID)
+		require.Equal(t, "test-key", customProvider.APIKey)
+		require.Equal(t, "https://api.custom.com/v1", customProvider.BaseURL)
+	})
+
+	t.Run("custom anthropic provider is supported", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom-anthropic": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.anthropic.com/v1",
+					Type:    catwalk.TypeAnthropic,
+					Models: []catwalk.Model{{
+						ID: "claude-3-sonnet",
+					}},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 1)
+		customProvider, exists := cfg.Providers.Get("custom-anthropic")
+		require.True(t, exists)
+		require.Equal(t, "custom-anthropic", customProvider.ID)
+		require.Equal(t, "test-key", customProvider.APIKey)
+		require.Equal(t, "https://api.anthropic.com/v1", customProvider.BaseURL)
+		require.Equal(t, catwalk.TypeAnthropic, customProvider.Type)
+	})
+
+	t.Run("disabled custom provider is removed", func(t *testing.T) {
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Type:    catwalk.TypeOpenAI,
+					Disable: true,
+					Models: []catwalk.Model{{
+						ID: "test-model",
+					}},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, []catwalk.Provider{})
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("custom")
+		require.False(t, exists)
+	})
+}
+
+func TestConfig_configureProvidersEnhancedCredentialValidation(t *testing.T) {
+	t.Run("VertexAI provider removed when credentials missing with existing config", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:          catwalk.InferenceProviderVertexAI,
+				APIKey:      "",
+				APIEndpoint: "",
+				Models: []catwalk.Model{{
+					ID: "gemini-pro",
+				}},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"vertexai": {
+					BaseURL: "custom-url",
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{
+			"GOOGLE_GENAI_USE_VERTEXAI": "false",
+		})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("vertexai")
+		require.False(t, exists)
+	})
+
+	t.Run("Bedrock provider removed when AWS credentials missing with existing config", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:          catwalk.InferenceProviderBedrock,
+				APIKey:      "",
+				APIEndpoint: "",
+				Models: []catwalk.Model{{
+					ID: "anthropic.claude-sonnet-4-20250514-v1:0",
+				}},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"bedrock": {
+					BaseURL: "custom-url",
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("bedrock")
+		require.False(t, exists)
+	})
+
+	t.Run("provider removed when API key missing with existing config", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:          "openai",
+				APIKey:      "$MISSING_API_KEY",
+				APIEndpoint: "https://api.openai.com/v1",
+				Models: []catwalk.Model{{
+					ID: "test-model",
+				}},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"openai": {
+					BaseURL: "custom-url",
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 0)
+		_, exists := cfg.Providers.Get("openai")
+		require.False(t, exists)
+	})
+
+	t.Run("known provider should still be added if the endpoint is missing the client will use default endpoints", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:          "openai",
+				APIKey:      "$OPENAI_API_KEY",
+				APIEndpoint: "$MISSING_ENDPOINT",
+				Models: []catwalk.Model{{
+					ID: "test-model",
+				}},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"openai": {
+					APIKey: "test-key",
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+
+		env := env.NewFromMap(map[string]string{
+			"OPENAI_API_KEY": "test-key",
+		})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		require.Equal(t, cfg.Providers.Len(), 1)
+		_, exists := cfg.Providers.Get("openai")
+		require.True(t, exists)
+	})
+}
+
+func TestConfig_defaultModelSelection(t *testing.T) {
+	t.Run("default behavior uses the default models for given provider", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "abc",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		large, small, err := cfg.defaultModelSelection(knownProviders)
+		require.NoError(t, err)
+		require.Equal(t, "large-model", large.Model)
+		require.Equal(t, "openai", large.Provider)
+		require.Equal(t, int64(1000), large.MaxTokens)
+		require.Equal(t, "small-model", small.Model)
+		require.Equal(t, "openai", small.Provider)
+		require.Equal(t, int64(500), small.MaxTokens)
+	})
+	t.Run("should error if no providers configured", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "$MISSING_KEY",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		_, _, err = cfg.defaultModelSelection(knownProviders)
+		require.Error(t, err)
+	})
+	t.Run("should error if model is missing", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "abc",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "not-large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+		_, _, err = cfg.defaultModelSelection(knownProviders)
+		require.Error(t, err)
+	})
+
+	t.Run("should configure the default models with a custom provider", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "$MISSING", // will not be included in the config
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "not-large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Models: []catwalk.Model{
+						{
+							ID:               "model",
+							DefaultMaxTokens: 600,
+						},
+					},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+		large, small, err := cfg.defaultModelSelection(knownProviders)
+		require.NoError(t, err)
+		require.Equal(t, "model", large.Model)
+		require.Equal(t, "custom", large.Provider)
+		require.Equal(t, int64(600), large.MaxTokens)
+		require.Equal(t, "model", small.Model)
+		require.Equal(t, "custom", small.Provider)
+		require.Equal(t, int64(600), small.MaxTokens)
+	})
+
+	t.Run("should fail if no model configured", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "$MISSING", // will not be included in the config
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "not-large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Models:  []catwalk.Model{},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+		_, _, err = cfg.defaultModelSelection(knownProviders)
+		require.Error(t, err)
+	})
+	t.Run("should use the default provider first", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "set",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{
+			Providers: csync.NewMapFrom(map[string]ProviderConfig{
+				"custom": {
+					APIKey:  "test-key",
+					BaseURL: "https://api.custom.com/v1",
+					Models: []catwalk.Model{
+						{
+							ID:               "large-model",
+							DefaultMaxTokens: 1000,
+						},
+					},
+				},
+			}),
+		}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+		large, small, err := cfg.defaultModelSelection(knownProviders)
+		require.NoError(t, err)
+		require.Equal(t, "large-model", large.Model)
+		require.Equal(t, "openai", large.Provider)
+		require.Equal(t, int64(1000), large.MaxTokens)
+		require.Equal(t, "small-model", small.Model)
+		require.Equal(t, "openai", small.Provider)
+		require.Equal(t, int64(500), small.MaxTokens)
+	})
+}
+
+func TestConfig_configureSelectedModels(t *testing.T) {
+	t.Run("should override defaults", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "abc",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "larger-model",
+						DefaultMaxTokens: 2000,
+					},
+					{
+						ID:               "large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{
+			Models: map[SelectedModelType]SelectedModel{
+				"large": {
+					Model: "larger-model",
+				},
+			},
+		}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		err = cfg.configureSelectedModels(knownProviders)
+		require.NoError(t, err)
+		large := cfg.Models[SelectedModelTypeLarge]
+		small := cfg.Models[SelectedModelTypeSmall]
+		require.Equal(t, "larger-model", large.Model)
+		require.Equal(t, "openai", large.Provider)
+		require.Equal(t, int64(2000), large.MaxTokens)
+		require.Equal(t, "small-model", small.Model)
+		require.Equal(t, "openai", small.Provider)
+		require.Equal(t, int64(500), small.MaxTokens)
+	})
+	t.Run("should be possible to use multiple providers", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "abc",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+			{
+				ID:                  "anthropic",
+				APIKey:              "abc",
+				DefaultLargeModelID: "a-large-model",
+				DefaultSmallModelID: "a-small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "a-large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "a-small-model",
+						DefaultMaxTokens: 200,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{
+			Models: map[SelectedModelType]SelectedModel{
+				"small": {
+					Model:     "a-small-model",
+					Provider:  "anthropic",
+					MaxTokens: 300,
+				},
+			},
+		}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		err = cfg.configureSelectedModels(knownProviders)
+		require.NoError(t, err)
+		large := cfg.Models[SelectedModelTypeLarge]
+		small := cfg.Models[SelectedModelTypeSmall]
+		require.Equal(t, "large-model", large.Model)
+		require.Equal(t, "openai", large.Provider)
+		require.Equal(t, int64(1000), large.MaxTokens)
+		require.Equal(t, "a-small-model", small.Model)
+		require.Equal(t, "anthropic", small.Provider)
+		require.Equal(t, int64(300), small.MaxTokens)
+	})
+
+	t.Run("should override the max tokens only", func(t *testing.T) {
+		knownProviders := []catwalk.Provider{
+			{
+				ID:                  "openai",
+				APIKey:              "abc",
+				DefaultLargeModelID: "large-model",
+				DefaultSmallModelID: "small-model",
+				Models: []catwalk.Model{
+					{
+						ID:               "large-model",
+						DefaultMaxTokens: 1000,
+					},
+					{
+						ID:               "small-model",
+						DefaultMaxTokens: 500,
+					},
+				},
+			},
+		}
+
+		cfg := &Config{
+			Models: map[SelectedModelType]SelectedModel{
+				"large": {
+					MaxTokens: 100,
+				},
+			},
+		}
+		cfg.setDefaults("/tmp", "")
+		env := env.NewFromMap(map[string]string{})
+		resolver := NewEnvironmentVariableResolver(env)
+		err := cfg.configureProviders(env, resolver, knownProviders)
+		require.NoError(t, err)
+
+		err = cfg.configureSelectedModels(knownProviders)
+		require.NoError(t, err)
+		large := cfg.Models[SelectedModelTypeLarge]
+		require.Equal(t, "large-model", large.Model)
+		require.Equal(t, "openai", large.Provider)
+		require.Equal(t, int64(100), large.MaxTokens)
+	})
+}

projects/ui/crush/internal/config/merge.go

@@ -0,0 +1,16 @@
+package config
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/qjebbs/go-jsons"
+)
+
+func Merge(data []io.Reader) (io.Reader, error) {
+	got, err := jsons.Merge(data)
+	if err != nil {
+		return nil, err
+	}
+	return bytes.NewReader(got), nil
+}

projects/ui/crush/internal/config/merge_test.go

@@ -0,0 +1,27 @@
+package config
+
+import (
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestMerge(t *testing.T) {
+	data1 := strings.NewReader(`{"foo": "bar"}`)
+	data2 := strings.NewReader(`{"baz": "qux"}`)
+
+	merged, err := Merge([]io.Reader{data1, data2})
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+
+	expected := `{"baz":"qux","foo":"bar"}`
+	got, err := io.ReadAll(merged)
+	if err != nil {
+		t.Fatalf("expected no error reading merged data, got %v", err)
+	}
+
+	if string(got) != expected {
+		t.Errorf("expected %s, got %s", expected, string(got))
+	}
+}

projects/ui/crush/internal/config/provider.go

@@ -0,0 +1,135 @@
+package config
+
+import (
+	"cmp"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+	"github.com/charmbracelet/crush/internal/home"
+)
+
+type ProviderClient interface {
+	GetProviders() ([]catwalk.Provider, error)
+}
+
+var (
+	providerOnce sync.Once
+	providerList []catwalk.Provider
+)
+
+// file to cache provider data
+func providerCacheFileData() string {
+	xdgDataHome := os.Getenv("XDG_DATA_HOME")
+	if xdgDataHome != "" {
+		return filepath.Join(xdgDataHome, appName, "providers.json")
+	}
+
+	// return the path to the main data directory
+	// for windows, it should be in `%LOCALAPPDATA%/crush/`
+	// for linux and macOS, it should be in `$HOME/.local/share/crush/`
+	if runtime.GOOS == "windows" {
+		localAppData := os.Getenv("LOCALAPPDATA")
+		if localAppData == "" {
+			localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
+		}
+		return filepath.Join(localAppData, appName, "providers.json")
+	}
+
+	return filepath.Join(home.Dir(), ".local", "share", appName, "providers.json")
+}
+
+func saveProvidersInCache(path string, providers []catwalk.Provider) error {
+	slog.Info("Saving cached provider data", "path", path)
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return fmt.Errorf("failed to create directory for provider cache: %w", err)
+	}
+
+	data, err := json.MarshalIndent(providers, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal provider data: %w", err)
+	}
+
+	if err := os.WriteFile(path, data, 0o644); err != nil {
+		return fmt.Errorf("failed to write provider data to cache: %w", err)
+	}
+	return nil
+}
+
+func loadProvidersFromCache(path string) ([]catwalk.Provider, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read provider cache file: %w", err)
+	}
+
+	var providers []catwalk.Provider
+	if err := json.Unmarshal(data, &providers); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal provider data from cache: %w", err)
+	}
+	return providers, nil
+}
+
+func Providers() ([]catwalk.Provider, error) {
+	catwalkURL := cmp.Or(os.Getenv("CATWALK_URL"), defaultCatwalkURL)
+	client := catwalk.NewWithURL(catwalkURL)
+	path := providerCacheFileData()
+	return loadProvidersOnce(client, path)
+}
+
+func loadProvidersOnce(client ProviderClient, path string) ([]catwalk.Provider, error) {
+	var err error
+	providerOnce.Do(func() {
+		providerList, err = loadProviders(client, path)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return providerList, nil
+}
+
+func loadProviders(client ProviderClient, path string) (providerList []catwalk.Provider, err error) {
+	// if cache is not stale, load from it
+	stale, exists := isCacheStale(path)
+	if !stale {
+		slog.Info("Using cached provider data", "path", path)
+		providerList, err = loadProvidersFromCache(path)
+		if len(providerList) > 0 && err == nil {
+			go func() {
+				slog.Info("Updating provider cache in background", "path", path)
+				updated, uerr := client.GetProviders()
+				if len(updated) > 0 && uerr == nil {
+					_ = saveProvidersInCache(path, updated)
+				}
+			}()
+			return
+		}
+	}
+
+	slog.Info("Getting live provider data", "path", path)
+	providerList, err = client.GetProviders()
+	if len(providerList) > 0 && err == nil {
+		err = saveProvidersInCache(path, providerList)
+		return
+	}
+	if !exists {
+		err = fmt.Errorf("failed to load providers")
+		return
+	}
+	slog.Info("Loading provider data from cache", "path", path)
+	providerList, err = loadProvidersFromCache(path)
+	return
+}
+
+func isCacheStale(path string) (stale, exists bool) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return true, false
+	}
+	return time.Since(info.ModTime()) > 24*time.Hour, true
+}

projects/ui/crush/internal/config/provider_empty_test.go

@@ -0,0 +1,47 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+	"github.com/stretchr/testify/require"
+)
+
+type emptyProviderClient struct{}
+
+func (m *emptyProviderClient) GetProviders() ([]catwalk.Provider, error) {
+	return []catwalk.Provider{}, nil
+}
+
+func TestProvider_loadProvidersEmptyResult(t *testing.T) {
+	client := &emptyProviderClient{}
+	tmpPath := t.TempDir() + "/providers.json"
+
+	providers, err := loadProviders(client, tmpPath)
+	require.EqualError(t, err, "failed to load providers")
+	require.Empty(t, providers)
+	require.Len(t, providers, 0)
+
+	// Check that no cache file was created for empty results
+	require.NoFileExists(t, tmpPath, "Cache file should not exist for empty results")
+}
+
+func TestProvider_loadProvidersEmptyCache(t *testing.T) {
+	client := &mockProviderClient{shouldFail: false}
+	tmpPath := t.TempDir() + "/providers.json"
+
+	// Create an empty cache file
+	emptyProviders := []catwalk.Provider{}
+	data, err := json.Marshal(emptyProviders)
+	require.NoError(t, err)
+	require.NoError(t, os.WriteFile(tmpPath, data, 0o644))
+
+	// Should refresh and get real providers instead of using empty cache
+	providers, err := loadProviders(client, tmpPath)
+	require.NoError(t, err)
+	require.NotNil(t, providers)
+	require.Len(t, providers, 1)
+	require.Equal(t, "Mock", providers[0].Name)
+}

projects/ui/crush/internal/config/provider_test.go

@@ -0,0 +1,73 @@
+package config
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"testing"
+
+	"github.com/charmbracelet/catwalk/pkg/catwalk"
+	"github.com/stretchr/testify/require"
+)
+
+type mockProviderClient struct {
+	shouldFail bool
+}
+
+func (m *mockProviderClient) GetProviders() ([]catwalk.Provider, error) {
+	if m.shouldFail {
+		return nil, errors.New("failed to load providers")
+	}
+	return []catwalk.Provider{
+		{
+			Name: "Mock",
+		},
+	}, nil
+}
+
+func TestProvider_loadProvidersNoIssues(t *testing.T) {
+	client := &mockProviderClient{shouldFail: false}
+	tmpPath := t.TempDir() + "/providers.json"
+	providers, err := loadProviders(client, tmpPath)
+	require.NoError(t, err)
+	require.NotNil(t, providers)
+	require.Len(t, providers, 1)
+
+	// check if file got saved
+	fileInfo, err := os.Stat(tmpPath)
+	require.NoError(t, err)
+	require.False(t, fileInfo.IsDir(), "Expected a file, not a directory")
+}
+
+func TestProvider_loadProvidersWithIssues(t *testing.T) {
+	client := &mockProviderClient{shouldFail: true}
+	tmpPath := t.TempDir() + "/providers.json"
+	// store providers to a temporary file
+	oldProviders := []catwalk.Provider{
+		{
+			Name: "OldProvider",
+		},
+	}
+	data, err := json.Marshal(oldProviders)
+	if err != nil {
+		t.Fatalf("Failed to marshal old providers: %v", err)
+	}
+
+	err = os.WriteFile(tmpPath, data, 0o644)
+	if err != nil {
+		t.Fatalf("Failed to write old providers to file: %v", err)
+	}
+	providers, err := loadProviders(client, tmpPath)
+	require.NoError(t, err)
+	require.NotNil(t, providers)
+	require.Len(t, providers, 1)
+	require.Equal(t, "OldProvider", providers[0].Name, "Expected to keep old provider when loading fails")
+}
+
+func TestProvider_loadProvidersWithIssuesAndNoCache(t *testing.T) {
+	client := &mockProviderClient{shouldFail: true}
+	tmpPath := t.TempDir() + "/providers.json"
+	providers, err := loadProviders(client, tmpPath)
+	require.Error(t, err)
+	require.Nil(t, providers, "Expected nil providers when loading fails and no cache exists")
+}

projects/ui/crush/internal/config/resolve.go

@@ -0,0 +1,176 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/crush/internal/env"
+	"github.com/charmbracelet/crush/internal/shell"
+)
+
+type VariableResolver interface {
+	ResolveValue(value string) (string, error)
+}
+
+type Shell interface {
+	Exec(ctx context.Context, command string) (stdout, stderr string, err error)
+}
+
+type shellVariableResolver struct {
+	shell Shell
+	env   env.Env
+}
+
+func NewShellVariableResolver(env env.Env) VariableResolver {
+	return &shellVariableResolver{
+		env: env,
+		shell: shell.NewShell(
+			&shell.Options{
+				Env: env.Env(),
+			},
+		),
+	}
+}
+
+// ResolveValue is a method for resolving values, such as environment variables.
+// it will resolve shell-like variable substitution anywhere in the string, including:
+// - $(command) for command substitution
+// - $VAR or ${VAR} for environment variables
+func (r *shellVariableResolver) ResolveValue(value string) (string, error) {
+	// Special case: lone $ is an error (backward compatibility)
+	if value == "$" {
+		return "", fmt.Errorf("invalid value format: %s", value)
+	}
+
+	// If no $ found, return as-is
+	if !strings.Contains(value, "$") {
+		return value, nil
+	}
+
+	result := value
+
+	// Handle command substitution: $(command)
+	for {
+		start := strings.Index(result, "$(")
+		if start == -1 {
+			break
+		}
+
+		// Find matching closing parenthesis
+		depth := 0
+		end := -1
+		for i := start + 2; i < len(result); i++ {
+			if result[i] == '(' {
+				depth++
+			} else if result[i] == ')' {
+				if depth == 0 {
+					end = i
+					break
+				}
+				depth--
+			}
+		}
+
+		if end == -1 {
+			return "", fmt.Errorf("unmatched $( in value: %s", value)
+		}
+
+		command := result[start+2 : end]
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+
+		stdout, _, err := r.shell.Exec(ctx, command)
+		cancel()
+		if err != nil {
+			return "", fmt.Errorf("command execution failed for '%s': %w", command, err)
+		}
+
+		// Replace the $(command) with the output
+		replacement := strings.TrimSpace(stdout)
+		result = result[:start] + replacement + result[end+1:]
+	}
+
+	// Handle environment variables: $VAR and ${VAR}
+	searchStart := 0
+	for {
+		start := strings.Index(result[searchStart:], "$")
+		if start == -1 {
+			break
+		}
+		start += searchStart // Adjust for the offset
+
+		// Skip if this is part of $( which we already handled
+		if start+1 < len(result) && result[start+1] == '(' {
+			// Skip past this $(...)
+			searchStart = start + 1
+			continue
+		}
+		var varName string
+		var end int
+
+		if start+1 < len(result) && result[start+1] == '{' {
+			// Handle ${VAR} format
+			closeIdx := strings.Index(result[start+2:], "}")
+			if closeIdx == -1 {
+				return "", fmt.Errorf("unmatched ${ in value: %s", value)
+			}
+			varName = result[start+2 : start+2+closeIdx]
+			end = start + 2 + closeIdx + 1
+		} else {
+			// Handle $VAR format - variable names must start with letter or underscore
+			if start+1 >= len(result) {
+				return "", fmt.Errorf("incomplete variable reference at end of string: %s", value)
+			}
+
+			if result[start+1] != '_' &&
+				(result[start+1] < 'a' || result[start+1] > 'z') &&
+				(result[start+1] < 'A' || result[start+1] > 'Z') {
+				return "", fmt.Errorf("invalid variable name starting with '%c' in: %s", result[start+1], value)
+			}
+
+			end = start + 1
+			for end < len(result) && (result[end] == '_' ||
+				(result[end] >= 'a' && result[end] <= 'z') ||
+				(result[end] >= 'A' && result[end] <= 'Z') ||
+				(result[end] >= '0' && result[end] <= '9')) {
+				end++
+			}
+			varName = result[start+1 : end]
+		}
+
+		envValue := r.env.Get(varName)
+		if envValue == "" {
+			return "", fmt.Errorf("environment variable %q not set", varName)
+		}
+
+		result = result[:start] + envValue + result[end:]
+		searchStart = start + len(envValue) // Continue searching after the replacement
+	}
+
+	return result, nil
+}
+
+type environmentVariableResolver struct {
+	env env.Env
+}
+
+func NewEnvironmentVariableResolver(env env.Env) VariableResolver {
+	return &environmentVariableResolver{
+		env: env,
+	}
+}
+
+// ResolveValue resolves environment variables from the provided env.Env.
+func (r *environmentVariableResolver) ResolveValue(value string) (string, error) {
+	if !strings.HasPrefix(value, "$") {
+		return value, nil
+	}
+
+	varName := strings.TrimPrefix(value, "$")
+	resolvedValue := r.env.Get(varName)
+	if resolvedValue == "" {
+		return "", fmt.Errorf("environment variable %q not set", varName)
+	}
+	return resolvedValue, nil
+}

projects/ui/crush/internal/config/resolve_test.go

@@ -0,0 +1,332 @@
+package config
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/charmbracelet/crush/internal/env"
+	"github.com/stretchr/testify/require"
+)
+
+// mockShell implements the Shell interface for testing
+type mockShell struct {
+	execFunc func(ctx context.Context, command string) (stdout, stderr string, err error)
+}
+
+func (m *mockShell) Exec(ctx context.Context, command string) (stdout, stderr string, err error) {
+	if m.execFunc != nil {
+		return m.execFunc(ctx, command)
+	}
+	return "", "", nil
+}
+
+func TestShellVariableResolver_ResolveValue(t *testing.T) {
+	tests := []struct {
+		name        string
+		value       string
+		envVars     map[string]string
+		shellFunc   func(ctx context.Context, command string) (stdout, stderr string, err error)
+		expected    string
+		expectError bool
+	}{
+		{
+			name:     "non-variable string returns as-is",
+			value:    "plain-string",
+			expected: "plain-string",
+		},
+		{
+			name:     "environment variable resolution",
+			value:    "$HOME",
+			envVars:  map[string]string{"HOME": "/home/user"},
+			expected: "/home/user",
+		},
+		{
+			name:        "missing environment variable returns error",
+			value:       "$MISSING_VAR",
+			envVars:     map[string]string{},
+			expectError: true,
+		},
+
+		{
+			name:  "shell command with whitespace trimming",
+			value: "$(echo '  spaced  ')",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				if command == "echo '  spaced  '" {
+					return "  spaced  \n", "", nil
+				}
+				return "", "", errors.New("unexpected command")
+			},
+			expected: "spaced",
+		},
+		{
+			name:  "shell command execution error",
+			value: "$(false)",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				return "", "", errors.New("command failed")
+			},
+			expectError: true,
+		},
+		{
+			name:        "invalid format returns error",
+			value:       "$",
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testEnv := env.NewFromMap(tt.envVars)
+			resolver := &shellVariableResolver{
+				shell: &mockShell{execFunc: tt.shellFunc},
+				env:   testEnv,
+			}
+
+			result, err := resolver.ResolveValue(tt.value)
+
+			if tt.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestShellVariableResolver_EnhancedResolveValue(t *testing.T) {
+	tests := []struct {
+		name        string
+		value       string
+		envVars     map[string]string
+		shellFunc   func(ctx context.Context, command string) (stdout, stderr string, err error)
+		expected    string
+		expectError bool
+	}{
+		{
+			name:  "command substitution within string",
+			value: "Bearer $(echo token123)",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				if command == "echo token123" {
+					return "token123\n", "", nil
+				}
+				return "", "", errors.New("unexpected command")
+			},
+			expected: "Bearer token123",
+		},
+		{
+			name:     "environment variable within string",
+			value:    "Bearer $TOKEN",
+			envVars:  map[string]string{"TOKEN": "sk-ant-123"},
+			expected: "Bearer sk-ant-123",
+		},
+		{
+			name:     "environment variable with braces within string",
+			value:    "Bearer ${TOKEN}",
+			envVars:  map[string]string{"TOKEN": "sk-ant-456"},
+			expected: "Bearer sk-ant-456",
+		},
+		{
+			name:  "mixed command and environment substitution",
+			value: "$USER-$(date +%Y)-$HOST",
+			envVars: map[string]string{
+				"USER": "testuser",
+				"HOST": "localhost",
+			},
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				if command == "date +%Y" {
+					return "2024\n", "", nil
+				}
+				return "", "", errors.New("unexpected command")
+			},
+			expected: "testuser-2024-localhost",
+		},
+		{
+			name:  "multiple command substitutions",
+			value: "$(echo hello) $(echo world)",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				switch command {
+				case "echo hello":
+					return "hello\n", "", nil
+				case "echo world":
+					return "world\n", "", nil
+				}
+				return "", "", errors.New("unexpected command")
+			},
+			expected: "hello world",
+		},
+		{
+			name:  "nested parentheses in command",
+			value: "$(echo $(echo inner))",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				if command == "echo $(echo inner)" {
+					return "nested\n", "", nil
+				}
+				return "", "", errors.New("unexpected command")
+			},
+			expected: "nested",
+		},
+		{
+			name:        "lone dollar with non-variable chars",
+			value:       "prefix$123suffix", // Numbers can't start variable names
+			expectError: true,
+		},
+		{
+			name:        "dollar with special chars",
+			value:       "a$@b$#c", // Special chars aren't valid in variable names
+			expectError: true,
+		},
+		{
+			name:        "empty environment variable substitution",
+			value:       "Bearer $EMPTY_VAR",
+			envVars:     map[string]string{},
+			expectError: true,
+		},
+		{
+			name:        "unmatched command substitution opening",
+			value:       "Bearer $(echo test",
+			expectError: true,
+		},
+		{
+			name:        "unmatched environment variable braces",
+			value:       "Bearer ${TOKEN",
+			expectError: true,
+		},
+		{
+			name:  "command substitution with error",
+			value: "Bearer $(false)",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				return "", "", errors.New("command failed")
+			},
+			expectError: true,
+		},
+		{
+			name:  "complex real-world example",
+			value: "Bearer $(cat /tmp/token.txt | base64 -w 0)",
+			shellFunc: func(ctx context.Context, command string) (stdout, stderr string, err error) {
+				if command == "cat /tmp/token.txt | base64 -w 0" {
+					return "c2stYW50LXRlc3Q=\n", "", nil
+				}
+				return "", "", errors.New("unexpected command")
+			},
+			expected: "Bearer c2stYW50LXRlc3Q=",
+		},
+		{
+			name:     "environment variable with underscores and numbers",
+			value:    "Bearer $API_KEY_V2",
+			envVars:  map[string]string{"API_KEY_V2": "sk-test-123"},
+			expected: "Bearer sk-test-123",
+		},
+		{
+			name:     "no substitution needed",
+			value:    "Bearer sk-ant-static-token",
+			expected: "Bearer sk-ant-static-token",
+		},
+		{
+			name:        "incomplete variable at end",
+			value:       "Bearer $",
+			expectError: true,
+		},
+		{
+			name:        "variable with invalid character",
+			value:       "Bearer $VAR-NAME", // Hyphen not allowed in variable names
+			expectError: true,
+		},
+		{
+			name:        "multiple invalid variables",
+			value:       "$1$2$3",
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testEnv := env.NewFromMap(tt.envVars)
+			resolver := &shellVariableResolver{
+				shell: &mockShell{execFunc: tt.shellFunc},
+				env:   testEnv,
+			}
+
+			result, err := resolver.ResolveValue(tt.value)
+
+			if tt.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestEnvironmentVariableResolver_ResolveValue(t *testing.T) {
+	tests := []struct {
+		name        string
+		value       string
+		envVars     map[string]string
+		expected    string
+		expectError bool
+	}{
+		{
+			name:     "non-variable string returns as-is",
+			value:    "plain-string",
+			expected: "plain-string",
+		},
+		{
+			name:     "environment variable resolution",
+			value:    "$HOME",
+			envVars:  map[string]string{"HOME": "/home/user"},
+			expected: "/home/user",
+		},
+		{
+			name:     "environment variable with complex value",
+			value:    "$PATH",
+			envVars:  map[string]string{"PATH": "/usr/bin:/bin:/usr/local/bin"},
+			expected: "/usr/bin:/bin:/usr/local/bin",
+		},
+		{
+			name:        "missing environment variable returns error",
+			value:       "$MISSING_VAR",
+			envVars:     map[string]string{},
+			expectError: true,
+		},
+		{
+			name:        "empty environment variable returns error",
+			value:       "$EMPTY_VAR",
+			envVars:     map[string]string{"EMPTY_VAR": ""},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testEnv := env.NewFromMap(tt.envVars)
+			resolver := NewEnvironmentVariableResolver(testEnv)
+
+			result, err := resolver.ResolveValue(tt.value)
+
+			if tt.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestNewShellVariableResolver(t *testing.T) {
+	testEnv := env.NewFromMap(map[string]string{"TEST": "value"})
+	resolver := NewShellVariableResolver(testEnv)
+
+	require.NotNil(t, resolver)
+	require.Implements(t, (*VariableResolver)(nil), resolver)
+}
+
+func TestNewEnvironmentVariableResolver(t *testing.T) {
+	testEnv := env.NewFromMap(map[string]string{"TEST": "value"})
+	resolver := NewEnvironmentVariableResolver(testEnv)
+
+	require.NotNil(t, resolver)
+	require.Implements(t, (*VariableResolver)(nil), resolver)
+}

projects/ui/crush/internal/csync/doc.go

@@ -0,0 +1,3 @@
+// Package csync provides concurrent data structures for safe access in
+// multi-threaded environments.
+package csync

projects/ui/crush/internal/csync/maps.go

@@ -0,0 +1,129 @@
+package csync
+
+import (
+	"encoding/json"
+	"iter"
+	"maps"
+	"sync"
+)
+
+// Map is a concurrent map implementation that provides thread-safe access.
+type Map[K comparable, V any] struct {
+	inner map[K]V
+	mu    sync.RWMutex
+}
+
+// NewMap creates a new thread-safe map with the specified key and value types.
+func NewMap[K comparable, V any]() *Map[K, V] {
+	return &Map[K, V]{
+		inner: make(map[K]V),
+	}
+}
+
+// NewMapFrom creates a new thread-safe map from an existing map.
+func NewMapFrom[K comparable, V any](m map[K]V) *Map[K, V] {
+	return &Map[K, V]{
+		inner: m,
+	}
+}
+
+// Set sets the value for the specified key in the map.
+func (m *Map[K, V]) Set(key K, value V) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.inner[key] = value
+}
+
+// Del deletes the specified key from the map.
+func (m *Map[K, V]) Del(key K) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	delete(m.inner, key)
+}
+
+// Get gets the value for the specified key from the map.
+func (m *Map[K, V]) Get(key K) (V, bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	v, ok := m.inner[key]
+	return v, ok
+}
+
+// Len returns the number of items in the map.
+func (m *Map[K, V]) Len() int {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return len(m.inner)
+}
+
+// GetOrSet gets and returns the key if it exists, otherwise, it executes the
+// given function, set its return value for the given key, and returns it.
+func (m *Map[K, V]) GetOrSet(key K, fn func() V) V {
+	got, ok := m.Get(key)
+	if ok {
+		return got
+	}
+	value := fn()
+	m.Set(key, value)
+	return value
+}
+
+// Take gets an item and then deletes it.
+func (m *Map[K, V]) Take(key K) (V, bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	v, ok := m.inner[key]
+	delete(m.inner, key)
+	return v, ok
+}
+
+// Seq2 returns an iter.Seq2 that yields key-value pairs from the map.
+func (m *Map[K, V]) Seq2() iter.Seq2[K, V] {
+	dst := make(map[K]V)
+	m.mu.RLock()
+	maps.Copy(dst, m.inner)
+	m.mu.RUnlock()
+	return func(yield func(K, V) bool) {
+		for k, v := range dst {
+			if !yield(k, v) {
+				return
+			}
+		}
+	}
+}
+
+// Seq returns an iter.Seq that yields values from the map.
+func (m *Map[K, V]) Seq() iter.Seq[V] {
+	return func(yield func(V) bool) {
+		for _, v := range m.Seq2() {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+var (
+	_ json.Unmarshaler = &Map[string, any]{}
+	_ json.Marshaler   = &Map[string, any]{}
+)
+
+func (Map[K, V]) JSONSchemaAlias() any { //nolint
+	m := map[K]V{}
+	return m
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (m *Map[K, V]) UnmarshalJSON(data []byte) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.inner = make(map[K]V)
+	return json.Unmarshal(data, &m.inner)
+}
+
+// MarshalJSON implements json.Marshaler.
+func (m *Map[K, V]) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.inner)
+}

projects/ui/crush/internal/csync/maps_test.go

@@ -0,0 +1,687 @@
+package csync
+
+import (
+	"encoding/json"
+	"maps"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewMap(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	require.NotNil(t, m)
+	require.NotNil(t, m.inner)
+	require.Equal(t, 0, m.Len())
+}
+
+func TestNewMapFrom(t *testing.T) {
+	t.Parallel()
+
+	original := map[string]int{
+		"key1": 1,
+		"key2": 2,
+	}
+
+	m := NewMapFrom(original)
+	require.NotNil(t, m)
+	require.Equal(t, original, m.inner)
+	require.Equal(t, 2, m.Len())
+
+	value, ok := m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 1, value)
+}
+
+func TestMap_Set(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	m.Set("key1", 42)
+	value, ok := m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 42, value)
+	require.Equal(t, 1, m.Len())
+
+	m.Set("key1", 100)
+	value, ok = m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 100, value)
+	require.Equal(t, 1, m.Len())
+}
+
+func TestMap_GetOrSet(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	require.Equal(t, 42, m.GetOrSet("key1", func() int { return 42 }))
+	require.Equal(t, 42, m.GetOrSet("key1", func() int { return 99999 }))
+	require.Equal(t, 1, m.Len())
+}
+
+func TestMap_Get(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	value, ok := m.Get("nonexistent")
+	require.False(t, ok)
+	require.Equal(t, 0, value)
+
+	m.Set("key1", 42)
+	value, ok = m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 42, value)
+}
+
+func TestMap_Del(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 42)
+	m.Set("key2", 100)
+
+	require.Equal(t, 2, m.Len())
+
+	m.Del("key1")
+	_, ok := m.Get("key1")
+	require.False(t, ok)
+	require.Equal(t, 1, m.Len())
+
+	value, ok := m.Get("key2")
+	require.True(t, ok)
+	require.Equal(t, 100, value)
+
+	m.Del("nonexistent")
+	require.Equal(t, 1, m.Len())
+}
+
+func TestMap_Len(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	require.Equal(t, 0, m.Len())
+
+	m.Set("key1", 1)
+	require.Equal(t, 1, m.Len())
+
+	m.Set("key2", 2)
+	require.Equal(t, 2, m.Len())
+
+	m.Del("key1")
+	require.Equal(t, 1, m.Len())
+
+	m.Del("key2")
+	require.Equal(t, 0, m.Len())
+}
+
+func TestMap_Take(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 42)
+	m.Set("key2", 100)
+
+	require.Equal(t, 2, m.Len())
+
+	value, ok := m.Take("key1")
+	require.True(t, ok)
+	require.Equal(t, 42, value)
+	require.Equal(t, 1, m.Len())
+
+	_, exists := m.Get("key1")
+	require.False(t, exists)
+
+	value, ok = m.Get("key2")
+	require.True(t, ok)
+	require.Equal(t, 100, value)
+}
+
+func TestMap_Take_NonexistentKey(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 42)
+
+	value, ok := m.Take("nonexistent")
+	require.False(t, ok)
+	require.Equal(t, 0, value)
+	require.Equal(t, 1, m.Len())
+
+	value, ok = m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 42, value)
+}
+
+func TestMap_Take_EmptyMap(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	value, ok := m.Take("key1")
+	require.False(t, ok)
+	require.Equal(t, 0, value)
+	require.Equal(t, 0, m.Len())
+}
+
+func TestMap_Take_SameKeyTwice(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 42)
+
+	value, ok := m.Take("key1")
+	require.True(t, ok)
+	require.Equal(t, 42, value)
+	require.Equal(t, 0, m.Len())
+
+	value, ok = m.Take("key1")
+	require.False(t, ok)
+	require.Equal(t, 0, value)
+	require.Equal(t, 0, m.Len())
+}
+
+func TestMap_Seq2(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 1)
+	m.Set("key2", 2)
+	m.Set("key3", 3)
+
+	collected := maps.Collect(m.Seq2())
+
+	require.Equal(t, 3, len(collected))
+	require.Equal(t, 1, collected["key1"])
+	require.Equal(t, 2, collected["key2"])
+	require.Equal(t, 3, collected["key3"])
+}
+
+func TestMap_Seq2_EarlyReturn(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 1)
+	m.Set("key2", 2)
+	m.Set("key3", 3)
+
+	count := 0
+	for range m.Seq2() {
+		count++
+		if count == 2 {
+			break
+		}
+	}
+
+	require.Equal(t, 2, count)
+}
+
+func TestMap_Seq2_EmptyMap(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	count := 0
+	for range m.Seq2() {
+		count++
+	}
+
+	require.Equal(t, 0, count)
+}
+
+func TestMap_Seq(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 1)
+	m.Set("key2", 2)
+	m.Set("key3", 3)
+
+	collected := make([]int, 0)
+	for v := range m.Seq() {
+		collected = append(collected, v)
+	}
+
+	require.Equal(t, 3, len(collected))
+	require.Contains(t, collected, 1)
+	require.Contains(t, collected, 2)
+	require.Contains(t, collected, 3)
+}
+
+func TestMap_Seq_EarlyReturn(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 1)
+	m.Set("key2", 2)
+	m.Set("key3", 3)
+
+	count := 0
+	for range m.Seq() {
+		count++
+		if count == 2 {
+			break
+		}
+	}
+
+	require.Equal(t, 2, count)
+}
+
+func TestMap_Seq_EmptyMap(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	count := 0
+	for range m.Seq() {
+		count++
+	}
+
+	require.Equal(t, 0, count)
+}
+
+func TestMap_MarshalJSON(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("key1", 1)
+	m.Set("key2", 2)
+
+	data, err := json.Marshal(m)
+	require.NoError(t, err)
+
+	result := &Map[string, int]{}
+	err = json.Unmarshal(data, result)
+	require.NoError(t, err)
+	require.Equal(t, 2, result.Len())
+	v1, _ := result.Get("key1")
+	v2, _ := result.Get("key2")
+	require.Equal(t, 1, v1)
+	require.Equal(t, 2, v2)
+}
+
+func TestMap_MarshalJSON_EmptyMap(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+
+	data, err := json.Marshal(m)
+	require.NoError(t, err)
+	require.Equal(t, "{}", string(data))
+}
+
+func TestMap_UnmarshalJSON(t *testing.T) {
+	t.Parallel()
+
+	jsonData := `{"key1": 1, "key2": 2}`
+
+	m := NewMap[string, int]()
+	err := json.Unmarshal([]byte(jsonData), m)
+	require.NoError(t, err)
+
+	require.Equal(t, 2, m.Len())
+	value, ok := m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 1, value)
+
+	value, ok = m.Get("key2")
+	require.True(t, ok)
+	require.Equal(t, 2, value)
+}
+
+func TestMap_UnmarshalJSON_EmptyJSON(t *testing.T) {
+	t.Parallel()
+
+	jsonData := `{}`
+
+	m := NewMap[string, int]()
+	err := json.Unmarshal([]byte(jsonData), m)
+	require.NoError(t, err)
+	require.Equal(t, 0, m.Len())
+}
+
+func TestMap_UnmarshalJSON_InvalidJSON(t *testing.T) {
+	t.Parallel()
+
+	jsonData := `{"key1": 1, "key2":}`
+
+	m := NewMap[string, int]()
+	err := json.Unmarshal([]byte(jsonData), m)
+	require.Error(t, err)
+}
+
+func TestMap_UnmarshalJSON_OverwritesExistingData(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[string, int]()
+	m.Set("existing", 999)
+
+	jsonData := `{"key1": 1, "key2": 2}`
+	err := json.Unmarshal([]byte(jsonData), m)
+	require.NoError(t, err)
+
+	require.Equal(t, 2, m.Len())
+	_, ok := m.Get("existing")
+	require.False(t, ok)
+
+	value, ok := m.Get("key1")
+	require.True(t, ok)
+	require.Equal(t, 1, value)
+}
+
+func TestMap_JSONRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	original := NewMap[string, int]()
+	original.Set("key1", 1)
+	original.Set("key2", 2)
+	original.Set("key3", 3)
+
+	data, err := json.Marshal(original)
+	require.NoError(t, err)
+
+	restored := NewMap[string, int]()
+	err = json.Unmarshal(data, restored)
+	require.NoError(t, err)
+
+	require.Equal(t, original.Len(), restored.Len())
+
+	for k, v := range original.Seq2() {
+		restoredValue, ok := restored.Get(k)
+		require.True(t, ok)
+		require.Equal(t, v, restoredValue)
+	}
+}
+
+func TestMap_ConcurrentAccess(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[int, int]()
+	const numGoroutines = 100
+	const numOperations = 100
+
+	var wg sync.WaitGroup
+	wg.Add(numGoroutines)
+
+	for i := range numGoroutines {
+		go func(id int) {
+			defer wg.Done()
+			for j := range numOperations {
+				key := id*numOperations + j
+				m.Set(key, key*2)
+				value, ok := m.Get(key)
+				require.True(t, ok)
+				require.Equal(t, key*2, value)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	require.Equal(t, numGoroutines*numOperations, m.Len())
+}
+
+func TestMap_ConcurrentReadWrite(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[int, int]()
+	const numReaders = 50
+	const numWriters = 50
+	const numOperations = 100
+
+	for i := range 1000 {
+		m.Set(i, i)
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(numReaders + numWriters)
+
+	for range numReaders {
+		go func() {
+			defer wg.Done()
+			for j := range numOperations {
+				key := j % 1000
+				value, ok := m.Get(key)
+				if ok {
+					require.Equal(t, key, value)
+				}
+				_ = m.Len()
+			}
+		}()
+	}
+
+	for i := range numWriters {
+		go func(id int) {
+			defer wg.Done()
+			for j := range numOperations {
+				key := 1000 + id*numOperations + j
+				m.Set(key, key)
+				if j%10 == 0 {
+					m.Del(key)
+				}
+			}
+		}(i)
+	}
+
+	wg.Wait()
+}
+
+func TestMap_ConcurrentSeq2(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[int, int]()
+	for i := range 100 {
+		m.Set(i, i*2)
+	}
+
+	var wg sync.WaitGroup
+	const numIterators = 10
+
+	wg.Add(numIterators)
+	for range numIterators {
+		go func() {
+			defer wg.Done()
+			count := 0
+			for k, v := range m.Seq2() {
+				require.Equal(t, k*2, v)
+				count++
+			}
+			require.Equal(t, 100, count)
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestMap_ConcurrentSeq(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[int, int]()
+	for i := range 100 {
+		m.Set(i, i*2)
+	}
+
+	var wg sync.WaitGroup
+	const numIterators = 10
+
+	wg.Add(numIterators)
+	for range numIterators {
+		go func() {
+			defer wg.Done()
+			count := 0
+			values := make(map[int]bool)
+			for v := range m.Seq() {
+				values[v] = true
+				count++
+			}
+			require.Equal(t, 100, count)
+			for i := range 100 {
+				require.True(t, values[i*2])
+			}
+		}()
+	}
+
+	wg.Wait()
+}
+
+func TestMap_ConcurrentTake(t *testing.T) {
+	t.Parallel()
+
+	m := NewMap[int, int]()
+	const numItems = 1000
+
+	for i := range numItems {
+		m.Set(i, i*2)
+	}
+
+	var wg sync.WaitGroup
+	const numWorkers = 10
+	taken := make([][]int, numWorkers)
+
+	wg.Add(numWorkers)
+	for i := range numWorkers {
+		go func(workerID int) {
+			defer wg.Done()
+			taken[workerID] = make([]int, 0)
+			for j := workerID; j < numItems; j += numWorkers {
+				if value, ok := m.Take(j); ok {
+					taken[workerID] = append(taken[workerID], value)
+				}
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	require.Equal(t, 0, m.Len())
+
+	allTaken := make(map[int]bool)
+	for _, workerTaken := range taken {
+		for _, value := range workerTaken {
+			require.False(t, allTaken[value], "Value %d was taken multiple times", value)
+			allTaken[value] = true
+		}
+	}
+
+	require.Equal(t, numItems, len(allTaken))
+	for i := range numItems {
+		require.True(t, allTaken[i*2], "Expected value %d to be taken", i*2)
+	}
+}
+
+func TestMap_TypeSafety(t *testing.T) {
+	t.Parallel()
+
+	stringIntMap := NewMap[string, int]()
+	stringIntMap.Set("key", 42)
+	value, ok := stringIntMap.Get("key")
+	require.True(t, ok)
+	require.Equal(t, 42, value)
+
+	intStringMap := NewMap[int, string]()
+	intStringMap.Set(42, "value")
+	strValue, ok := intStringMap.Get(42)
+	require.True(t, ok)
+	require.Equal(t, "value", strValue)
+
+	structMap := NewMap[string, struct{ Name string }]()
+	structMap.Set("key", struct{ Name string }{Name: "test"})
+	structValue, ok := structMap.Get("key")
+	require.True(t, ok)
+	require.Equal(t, "test", structValue.Name)
+}
+
+func TestMap_InterfaceCompliance(t *testing.T) {
+	t.Parallel()
+
+	var _ json.Marshaler = &Map[string, any]{}
+	var _ json.Unmarshaler = &Map[string, any]{}
+}
+
+func BenchmarkMap_Set(b *testing.B) {
+	m := NewMap[int, int]()
+
+	for i := 0; b.Loop(); i++ {
+		m.Set(i, i*2)
+	}
+}
+
+func BenchmarkMap_Get(b *testing.B) {
+	m := NewMap[int, int]()
+	for i := range 1000 {
+		m.Set(i, i*2)
+	}
+
+	for i := 0; b.Loop(); i++ {
+		m.Get(i % 1000)
+	}
+}
+
+func BenchmarkMap_Seq2(b *testing.B) {
+	m := NewMap[int, int]()
+	for i := range 1000 {
+		m.Set(i, i*2)
+	}
+
+	for b.Loop() {
+		for range m.Seq2() {
+		}
+	}
+}
+
+func BenchmarkMap_Seq(b *testing.B) {
+	m := NewMap[int, int]()
+	for i := range 1000 {
+		m.Set(i, i*2)
+	}
+
+	for b.Loop() {
+		for range m.Seq() {
+		}
+	}
+}
+
+func BenchmarkMap_Take(b *testing.B) {
+	m := NewMap[int, int]()
+	for i := range 1000 {
+		m.Set(i, i*2)
+	}
+
+	b.ResetTimer()
+	for i := 0; b.Loop(); i++ {
+		key := i % 1000
+		m.Take(key)
+		if i%1000 == 999 {
+			b.StopTimer()
+			for j := range 1000 {
+				m.Set(j, j*2)
+			}
+			b.StartTimer()
+		}
+	}
+}
+
+func BenchmarkMap_ConcurrentReadWrite(b *testing.B) {
+	m := NewMap[int, int]()
+	for i := range 1000 {
+		m.Set(i, i*2)
+	}
+
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			if i%2 == 0 {
+				m.Get(i % 1000)
+			} else {
+				m.Set(i+1000, i*2)
+			}
+			i++
+		}
+	})
+}

projects/ui/crush/internal/csync/slices.go

@@ -0,0 +1,145 @@
+package csync
+
+import (
+	"iter"
+	"slices"
+	"sync"
+)
+
+// LazySlice is a thread-safe lazy-loaded slice.
+type LazySlice[K any] struct {
+	inner []K
+	wg    sync.WaitGroup
+}
+
+// NewLazySlice creates a new slice and runs the [load] function in a goroutine
+// to populate it.
+func NewLazySlice[K any](load func() []K) *LazySlice[K] {
+	s := &LazySlice[K]{}
+	s.wg.Go(func() {
+		s.inner = load()
+	})
+	return s
+}
+
+// Seq returns an iterator that yields elements from the slice.
+func (s *LazySlice[K]) Seq() iter.Seq[K] {
+	s.wg.Wait()
+	return func(yield func(K) bool) {
+		for _, v := range s.inner {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// Slice is a thread-safe slice implementation that provides concurrent access.
+type Slice[T any] struct {
+	inner []T
+	mu    sync.RWMutex
+}
+
+// NewSlice creates a new thread-safe slice.
+func NewSlice[T any]() *Slice[T] {
+	return &Slice[T]{
+		inner: make([]T, 0),
+	}
+}
+
+// NewSliceFrom creates a new thread-safe slice from an existing slice.
+func NewSliceFrom[T any](s []T) *Slice[T] {
+	inner := make([]T, len(s))
+	copy(inner, s)
+	return &Slice[T]{
+		inner: inner,
+	}
+}
+
+// Append adds an element to the end of the slice.
+func (s *Slice[T]) Append(items ...T) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.inner = append(s.inner, items...)
+}
+
+// Prepend adds an element to the beginning of the slice.
+func (s *Slice[T]) Prepend(item T) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.inner = append([]T{item}, s.inner...)
+}
+
+// Delete removes the element at the specified index.
+func (s *Slice[T]) Delete(index int) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if index < 0 || index >= len(s.inner) {
+		return false
+	}
+	s.inner = slices.Delete(s.inner, index, index+1)
+	return true
+}
+
+// Get returns the element at the specified index.
+func (s *Slice[T]) Get(index int) (T, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	var zero T
+	if index < 0 || index >= len(s.inner) {
+		return zero, false
+	}
+	return s.inner[index], true
+}
+
+// Set updates the element at the specified index.
+func (s *Slice[T]) Set(index int, item T) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if index < 0 || index >= len(s.inner) {
+		return false
+	}
+	s.inner[index] = item
+	return true
+}
+
+// Len returns the number of elements in the slice.
+func (s *Slice[T]) Len() int {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return len(s.inner)
+}
+
+// SetSlice replaces the entire slice with a new one.
+func (s *Slice[T]) SetSlice(items []T) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.inner = make([]T, len(items))
+	copy(s.inner, items)
+}
+
+// Seq returns an iterator that yields elements from the slice.
+func (s *Slice[T]) Seq() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for _, v := range s.Seq2() {
+			if !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// Seq2 returns an iterator that yields index-value pairs from the slice.
+func (s *Slice[T]) Seq2() iter.Seq2[int, T] {
+	s.mu.RLock()
+	items := make([]T, len(s.inner))
+	copy(items, s.inner)
+	s.mu.RUnlock()
+	return func(yield func(int, T) bool) {
+		for i, v := range items {
+			if !yield(i, v) {
+				return
+			}
+		}
+	}
+}

projects/ui/crush/internal/csync/slices_test.go

@@ -0,0 +1,271 @@
+package csync
+
+import (
+	"slices"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"testing/synctest"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestLazySlice_Seq(t *testing.T) {
+	t.Parallel()
+
+	synctest.Test(t, func(t *testing.T) {
+		t.Helper()
+		data := []string{"a", "b", "c"}
+		s := NewLazySlice(func() []string {
+			time.Sleep(10 * time.Millisecond) // Small delay to ensure loading happens
+			return data
+		})
+		require.Equal(t, data, slices.Collect(s.Seq()))
+	})
+}
+
+func TestLazySlice_SeqWaitsForLoading(t *testing.T) {
+	t.Parallel()
+	synctest.Test(t, func(t *testing.T) {
+		t.Helper()
+
+		var loaded atomic.Bool
+		data := []string{"x", "y", "z"}
+
+		s := NewLazySlice(func() []string {
+			time.Sleep(100 * time.Millisecond)
+			loaded.Store(true)
+			return data
+		})
+
+		require.False(t, loaded.Load(), "should not be loaded immediately")
+		require.Equal(t, data, slices.Collect(s.Seq()))
+		require.True(t, loaded.Load(), "should be loaded after Seq")
+	})
+}
+
+func TestLazySlice_EmptySlice(t *testing.T) {
+	t.Parallel()
+	s := NewLazySlice(func() []string {
+		return []string{}
+	})
+	require.Empty(t, slices.Collect(s.Seq()))
+}
+
+func TestLazySlice_EarlyBreak(t *testing.T) {
+	t.Parallel()
+
+	synctest.Test(t, func(t *testing.T) {
+		t.Helper()
+		data := []string{"a", "b", "c", "d", "e"}
+		s := NewLazySlice(func() []string {
+			time.Sleep(10 * time.Millisecond) // Small delay to ensure loading happens
+			return data
+		})
+
+		var result []string
+		for v := range s.Seq() {
+			result = append(result, v)
+			if len(result) == 2 {
+				break
+			}
+		}
+
+		require.Equal(t, []string{"a", "b"}, result)
+	})
+}
+
+func TestSlice(t *testing.T) {
+	t.Run("NewSlice", func(t *testing.T) {
+		s := NewSlice[int]()
+		require.Equal(t, 0, s.Len())
+	})
+
+	t.Run("NewSliceFrom", func(t *testing.T) {
+		original := []int{1, 2, 3}
+		s := NewSliceFrom(original)
+		require.Equal(t, 3, s.Len())
+
+		// Verify it's a copy, not a reference
+		original[0] = 999
+		val, ok := s.Get(0)
+		require.True(t, ok)
+		require.Equal(t, 1, val)
+	})
+
+	t.Run("Append", func(t *testing.T) {
+		s := NewSlice[string]()
+		s.Append("hello")
+		s.Append("world")
+
+		require.Equal(t, 2, s.Len())
+		val, ok := s.Get(0)
+		require.True(t, ok)
+		require.Equal(t, "hello", val)
+
+		val, ok = s.Get(1)
+		require.True(t, ok)
+		require.Equal(t, "world", val)
+	})
+
+	t.Run("Prepend", func(t *testing.T) {
+		s := NewSlice[string]()
+		s.Append("world")
+		s.Prepend("hello")
+
+		require.Equal(t, 2, s.Len())
+		val, ok := s.Get(0)
+		require.True(t, ok)
+		require.Equal(t, "hello", val)
+
+		val, ok = s.Get(1)
+		require.True(t, ok)
+		require.Equal(t, "world", val)
+	})
+
+	t.Run("Delete", func(t *testing.T) {
+		s := NewSliceFrom([]int{1, 2, 3, 4, 5})
+
+		// Delete middle element
+		ok := s.Delete(2)
+		require.True(t, ok)
+		require.Equal(t, 4, s.Len())
+
+		expected := []int{1, 2, 4, 5}
+		actual := slices.Collect(s.Seq())
+		require.Equal(t, expected, actual)
+
+		// Delete out of bounds
+		ok = s.Delete(10)
+		require.False(t, ok)
+		require.Equal(t, 4, s.Len())
+
+		// Delete negative index
+		ok = s.Delete(-1)
+		require.False(t, ok)
+		require.Equal(t, 4, s.Len())
+	})
+
+	t.Run("Get", func(t *testing.T) {
+		s := NewSliceFrom([]string{"a", "b", "c"})
+
+		val, ok := s.Get(1)
+		require.True(t, ok)
+		require.Equal(t, "b", val)
+
+		// Out of bounds
+		_, ok = s.Get(10)
+		require.False(t, ok)
+
+		// Negative index
+		_, ok = s.Get(-1)
+		require.False(t, ok)
+	})
+
+	t.Run("Set", func(t *testing.T) {
+		s := NewSliceFrom([]string{"a", "b", "c"})
+
+		ok := s.Set(1, "modified")
+		require.True(t, ok)
+
+		val, ok := s.Get(1)
+		require.True(t, ok)
+		require.Equal(t, "modified", val)
+
+		// Out of bounds
+		ok = s.Set(10, "invalid")
+		require.False(t, ok)
+
+		// Negative index
+		ok = s.Set(-1, "invalid")
+		require.False(t, ok)
+	})
+
+	t.Run("SetSlice", func(t *testing.T) {
+		s := NewSlice[int]()
+		s.Append(1)
+		s.Append(2)
+
+		newItems := []int{10, 20, 30}
+		s.SetSlice(newItems)
+
+		require.Equal(t, 3, s.Len())
+		require.Equal(t, newItems, slices.Collect(s.Seq()))
+
+		// Verify it's a copy
+		newItems[0] = 999
+		val, ok := s.Get(0)
+		require.True(t, ok)
+		require.Equal(t, 10, val)
+	})
+
+	t.Run("Slice", func(t *testing.T) {
+		original := []int{1, 2, 3}
+		s := NewSliceFrom(original)
+
+		copied := slices.Collect(s.Seq())
+		require.Equal(t, original, copied)
+
+		// Verify it's a copy
+		copied[0] = 999
+		val, ok := s.Get(0)
+		require.True(t, ok)
+		require.Equal(t, 1, val)
+	})
+
+	t.Run("Seq", func(t *testing.T) {
+		s := NewSliceFrom([]int{1, 2, 3})
+
+		var result []int
+		for v := range s.Seq() {
+			result = append(result, v)
+		}
+
+		require.Equal(t, []int{1, 2, 3}, result)
+	})
+
+	t.Run("SeqWithIndex", func(t *testing.T) {
+		s := NewSliceFrom([]string{"a", "b", "c"})
+
+		var indices []int
+		var values []string
+		for i, v := range s.Seq2() {
+			indices = append(indices, i)
+			values = append(values, v)
+		}
+
+		require.Equal(t, []int{0, 1, 2}, indices)
+		require.Equal(t, []string{"a", "b", "c"}, values)
+	})
+
+	t.Run("ConcurrentAccess", func(t *testing.T) {
+		s := NewSlice[int]()
+		const numGoroutines = 100
+		const itemsPerGoroutine = 10
+
+		var wg sync.WaitGroup
+
+		// Concurrent appends
+		for i := range numGoroutines {
+			wg.Add(2)
+			go func(start int) {
+				defer wg.Done()
+				for j := range itemsPerGoroutine {
+					s.Append(start*itemsPerGoroutine + j)
+				}
+			}(i)
+			go func() {
+				defer wg.Done()
+				for range itemsPerGoroutine {
+					s.Len() // Just read the length
+				}
+			}()
+		}
+
+		wg.Wait()
+
+		// Should have all items
+		require.Equal(t, numGoroutines*itemsPerGoroutine, s.Len())
+	})
+}

projects/ui/crush/internal/db/connect.go

@@ -0,0 +1,62 @@
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"log/slog"
+	"path/filepath"
+
+	_ "github.com/ncruces/go-sqlite3/driver"
+	_ "github.com/ncruces/go-sqlite3/embed"
+
+	"github.com/pressly/goose/v3"
+)
+
+func Connect(ctx context.Context, dataDir string) (*sql.DB, error) {
+	if dataDir == "" {
+		return nil, fmt.Errorf("data.dir is not set")
+	}
+	dbPath := filepath.Join(dataDir, "crush.db")
+	// Open the SQLite database
+	db, err := sql.Open("sqlite3", dbPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open database: %w", err)
+	}
+
+	// Verify connection
+	if err = db.PingContext(ctx); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("failed to connect to database: %w", err)
+	}
+
+	// Set pragmas for better performance
+	pragmas := []string{
+		"PRAGMA foreign_keys = ON;",
+		"PRAGMA journal_mode = WAL;",
+		"PRAGMA page_size = 4096;",
+		"PRAGMA cache_size = -8000;",
+		"PRAGMA synchronous = NORMAL;",
+	}
+
+	for _, pragma := range pragmas {
+		if _, err = db.ExecContext(ctx, pragma); err != nil {
+			slog.Error("Failed to set pragma", pragma, err)
+		} else {
+			slog.Debug("Set pragma", "pragma", pragma)
+		}
+	}
+
+	goose.SetBaseFS(FS)
+
+	if err := goose.SetDialect("sqlite3"); err != nil {
+		slog.Error("Failed to set dialect", "error", err)
+		return nil, fmt.Errorf("failed to set dialect: %w", err)
+	}
+
+	if err := goose.Up(db, "migrations"); err != nil {
+		slog.Error("Failed to apply migrations", "error", err)
+		return nil, fmt.Errorf("failed to apply migrations: %w", err)
+	}
+	return db, nil
+}