Refactor: load execution profiles from YAML and split prompt definitions into promptdef repository

internal/profile/filesystem_repository.go

@@ -5,17 +5,19 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"gitea.maximumdirect.net/eric/scriptorium/internal/domain"
-	"gopkg.in/yaml.v3"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"gitea.maximumdirect.net/eric/scriptorium/internal/domain"
+	"gopkg.in/yaml.v3"
 )
 
 var (
-	ErrProfileNotFound = errors.New("prompt definition not found")
-	ErrInvalidYAML     = errors.New("invalid YAML format")
-	ErrInvalidProfile  = errors.New("invalid prompt definition configuration")
+	ErrProfileNotFound     = errors.New("execution profile not found")
+	ErrInvalidYAML         = errors.New("invalid YAML format")
+	ErrInvalidProfile      = errors.New("invalid execution profile configuration")
+	ErrRawAPIKeyNotAllowed = errors.New("raw api_key is not allowed; use api_key_env")
 )
 
 type filesystemRepository struct {
@@ -26,9 +28,9 @@ func NewFilesystemRepository(dir string) Repository {
 	return &filesystemRepository{dir: dir}
 }
 
-func (r *filesystemRepository) GetPromptDefinition(ctx context.Context, id string, version string) (*domain.PromptDefinition, error) {
+func (r *filesystemRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
 	if strings.TrimSpace(id) == "" {
-		return nil, fmt.Errorf("%w: prompt id is required", ErrInvalidProfile)
+		return nil, fmt.Errorf("%w: profile id is required", ErrInvalidProfile)
 	}
 
 	files, err := os.ReadDir(r.dir)
@@ -53,97 +55,60 @@ func (r *filesystemRepository) GetPromptDefinition(ctx context.Context, id strin
 			return nil, fmt.Errorf("failed to read profile file %s: %w", file.Name(), err)
 		}
 
-		var prof domain.PromptDefinition
+		var prof domain.ExecutionProfile
 		decoder := yaml.NewDecoder(bytes.NewReader(data))
 		decoder.KnownFields(true)
 		if err := decoder.Decode(&prof); err != nil {
+			if strings.Contains(err.Error(), "field api_key not found") {
+				if strings.TrimSuffix(strings.TrimSuffix(file.Name(), ".yaml"), ".yml") == id {
+					return nil, fmt.Errorf("%w: %s", ErrRawAPIKeyNotAllowed, file.Name())
+				}
+				continue
+			}
 			if strings.TrimSuffix(strings.TrimSuffix(file.Name(), ".yaml"), ".yml") == id {
 				return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, file.Name(), err)
 			}
 			continue
 		}
 
-		if prof.ID == id {
-			if version == "" || prof.Version == version {
-				if err := validateProfile(&prof); err != nil {
-					return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, file.Name(), err)
-				}
-				return &prof, nil
-			}
+		if prof.ID != id {
+			continue
 		}
-
+		if err := validateProfile(&prof); err != nil {
+			if errors.Is(err, ErrRawAPIKeyNotAllowed) {
+				return nil, fmt.Errorf("%w: %s", err, file.Name())
+			}
+			return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, file.Name(), err)
+		}
+		return &prof, nil
 	}
 
 	return nil, ErrProfileNotFound
 }
 
-func validateProfile(p *domain.PromptDefinition) error {
-	if p.ID == "" {
-		return errors.New("prompt id is required")
+func validateProfile(p *domain.ExecutionProfile) error {
+	if strings.TrimSpace(p.ID) == "" {
+		return errors.New("id is required")
 	}
-	if p.Version == "" {
-		return errors.New("prompt version is required")
+	if strings.TrimSpace(p.Endpoint) == "" {
+		return errors.New("endpoint is required")
 	}
-	if len(p.Templates) == 0 {
-		return errors.New("at least one prompt template message is required")
+	if strings.TrimSpace(p.Model) == "" {
+		return errors.New("model is required")
 	}
-	if len(p.Inputs) == 0 {
-		return errors.New("at least one prompt input is required")
+
+	if p.Temperature < 0 || p.Temperature > 2 {
+		return errors.New("temperature must be between 0 and 2")
 	}
-	for i, input := range p.Inputs {
-		if strings.TrimSpace(input.Name) == "" {
-			return fmt.Errorf("input %d has empty name", i)
-		}
+	if p.MaxTokens < 0 {
+		return errors.New("max_tokens must be greater than or equal to 0")
 	}
-	for i, t := range p.Templates {
-		if !isValidMessageRole(t.Role) {
-			return fmt.Errorf("template message %d has invalid role %q", i, t.Role)
-		}
-		if strings.TrimSpace(t.Content) == "" && strings.TrimSpace(t.ContentFile) == "" {
-			return fmt.Errorf("template message %d must provide content or content_file", i)
-		}
-		if strings.TrimSpace(t.Content) != "" && strings.TrimSpace(t.ContentFile) != "" {
-			return fmt.Errorf("template message %d cannot set both content and content_file", i)
-		}
+	if p.TopP < 0 || p.TopP > 1 {
+		return errors.New("top_p must be between 0 and 1")
 	}
-	if !isValidOutputFormat(p.OutputFormat) {
-		return fmt.Errorf("invalid output format: %s", p.OutputFormat)
-	}
-	if !isValidValidationMode(p.Validation.ValidationMode) {
-		return fmt.Errorf("invalid validation mode: %s", p.Validation.ValidationMode)
-	}
-	if p.Validation.RepairAttempts < 0 {
-		return errors.New("validation.repair_attempts must be greater than or equal to 0")
-	}
-	if p.Validation.ValidationMode == domain.ValidationJSONSchema && strings.TrimSpace(p.Validation.SchemaPath) == "" {
-		return errors.New("validation.schema_path is required when validation_mode is json_schema")
-	}
-	if p.Validation.Format != "" && p.Validation.Format != p.OutputFormat {
-		return fmt.Errorf("validation format %q does not match output format %q", p.Validation.Format, p.OutputFormat)
+	if p.TimeoutSeconds < 0 {
+		return errors.New("timeout_seconds must be greater than or equal to 0")
 	}
+
 	return nil
 }
-
-func isValidOutputFormat(f domain.OutputFormat) bool {
-	switch f {
-	case domain.FormatText, domain.FormatMarkdown, domain.FormatJSON:
-		return true
-	}
-	return false
-}
-
-func isValidValidationMode(m domain.ValidationMode) bool {
-	switch m {
-	case domain.ValidationNone, domain.ValidationBasic, domain.ValidationJSON, domain.ValidationJSONSchema:
-		return true
-	}
-	return false
-}
-
-func isValidMessageRole(role string) bool {
-	switch role {
-	case "system", "user", "assistant", "developer":
-		return true
-	}
-	return false
-}