Apply ConfigKit operational configuration defaults

internal/core/config/validation.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"fmt"
-	"net/url"
 	"sort"
 	"strings"
 
@@ -17,8 +16,8 @@ func (c Config) Validate() error {
 	if err := validateStateSurfaces(c); err != nil {
 		return err
 	}
-	if c.Concurrency.TotalLLM <= 0 {
-		return fmt.Errorf("total LLM concurrency must be greater than zero")
+	if err := validateTotalLLMConcurrency(c.Concurrency.TotalLLM); err != nil {
+		return err
 	}
 	if err := validateStageWorkers(c.Concurrency); err != nil {
 		return err
@@ -33,70 +32,42 @@ func validateStageWorkers(cfg ConcurrencyConfig) error {
 	}
 	sort.Strings(keys)
 	for _, key := range keys {
-		if strings.TrimSpace(key) == "" {
-			return fmt.Errorf("concurrency.stage_workers key must not be empty")
-		}
-		if key != "extract" {
-			return fmt.Errorf("concurrency.stage_workers key %q is not supported", key)
+		if err := validateStageWorkerKey(key); err != nil {
+			return err
 		}
 	}
 	extractWorkers, ok := cfg.StageWorkers["extract"]
 	if !ok {
 		extractWorkers = cfg.TotalLLM
 	}
-	if extractWorkers < 1 || extractWorkers > cfg.TotalLLM {
-		return fmt.Errorf("concurrency.stage_workers.extract must be between 1 and concurrency.total_llm (%d)", cfg.TotalLLM)
-	}
-	return nil
+	return validateExtractWorkerCount(extractWorkers, cfg.TotalLLM)
 }
 
 func validatePromptKit(cfg PromptKitConfig) error {
-	if strings.TrimSpace(cfg.ProfileDir) != "" && strings.TrimSpace(cfg.ProfileFile) != "" {
-		return fmt.Errorf("promptkit profile_dir and profile_file are mutually exclusive")
+	if err := validatePromptKitProfileSources(cfg.ProfileDir, cfg.ProfileFile); err != nil {
+		return err
 	}
 	if cfg.LocalBackend == nil {
 		return nil
 	}
-	endpoint := strings.TrimSpace(cfg.LocalBackend.Endpoint)
-	if endpoint == "" {
-		return fmt.Errorf("promptkit.local_backend.endpoint must not be empty when set")
-	}
-	parsed, err := url.Parse(endpoint)
-	if err != nil ||
-		(!strings.EqualFold(parsed.Scheme, "http") && !strings.EqualFold(parsed.Scheme, "https")) ||
-		!parsed.IsAbs() ||
-		parsed.Hostname() == "" ||
-		parsed.User != nil ||
-		parsed.RawQuery != "" ||
-		parsed.ForceQuery ||
-		strings.Contains(endpoint, "#") {
-		return fmt.Errorf("promptkit.local_backend.endpoint must be an absolute HTTP or HTTPS URL with a host and no user information, query, or fragment")
-	}
-	if cfg.LocalBackend.ConcurrencyLimit < 0 {
-		return fmt.Errorf("promptkit.local_backend.concurrency_limit must not be negative")
-	}
-	return nil
+	return validatePromptKitLocalBackend(cfg.LocalBackend.Endpoint, cfg.LocalBackend.ConcurrencyLimit)
 }
 
 func validateStateSurfaces(cfg Config) error {
-	if strings.TrimSpace(cfg.Output.Directory) == "" {
-		return fmt.Errorf("output.directory must not be empty")
+	if err := validateRequiredPath("output.directory", cfg.Output.Directory); err != nil {
+		return err
 	}
-	if strings.TrimSpace(cfg.Debug.Directory) == "" {
-		return fmt.Errorf("debug.directory must not be empty")
+	if err := validateRequiredPath("debug.directory", cfg.Debug.Directory); err != nil {
+		return err
 	}
-	if err := cfg.Cache.ChunkPlans.Mode.Validate(); err != nil {
-		return fmt.Errorf("cache.chunk_plans.mode: %w", err)
+	if err := validateChunkPlanCacheMode(string(cfg.Cache.ChunkPlans.Mode)); err != nil {
+		return err
 	}
-	for name, value := range map[string]string{
-		"output.directory":            cfg.Output.Directory,
-		"cache.chunk_plans.directory": cfg.Cache.ChunkPlans.Directory,
-		"cache.checkpoints.directory": cfg.Cache.Checkpoints.Directory,
-		"debug.directory":             cfg.Debug.Directory,
-	} {
-		if strings.ContainsRune(value, '\x00') {
-			return fmt.Errorf("%s must not contain NUL", name)
-		}
+	if err := validateOptionalPath("cache.chunk_plans.directory", cfg.Cache.ChunkPlans.Directory); err != nil {
+		return err
+	}
+	if err := validateOptionalPath("cache.checkpoints.directory", cfg.Cache.Checkpoints.Directory); err != nil {
+		return err
 	}
 	return nil
 }