145 lines
3.6 KiB
Go
145 lines
3.6 KiB
Go
package profile
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"gitea.maximumdirect.net/eric/scriptorium/internal/domain"
|
|
"gitea.maximumdirect.net/eric/scriptorium/internal/filecatalog"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
var (
|
|
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 {
|
|
dir string
|
|
}
|
|
|
|
func NewFilesystemRepository(dir string) Repository {
|
|
return &filesystemRepository{dir: dir}
|
|
}
|
|
|
|
func (r *filesystemRepository) GetProfile(ctx context.Context, id string) (*domain.ExecutionProfile, error) {
|
|
if strings.TrimSpace(id) == "" {
|
|
return nil, fmt.Errorf("%w: profile id is required", ErrInvalidProfile)
|
|
}
|
|
|
|
files, err := filecatalog.FindYAMLFiles(ctx, r.dir)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read profile directory: %w", err)
|
|
}
|
|
|
|
var matches []profileMatch
|
|
for _, fullPath := range files {
|
|
select {
|
|
case <-ctx.Done():
|
|
return nil, ctx.Err()
|
|
default:
|
|
}
|
|
|
|
relPath := filecatalog.RelativePath(r.dir, fullPath)
|
|
fileMatch := filecatalog.Stem(filepath.Base(fullPath)) == id
|
|
data, err := os.ReadFile(fullPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read profile file %s: %w", relPath, err)
|
|
}
|
|
|
|
var prof domain.ExecutionProfile
|
|
decoder := yaml.NewDecoder(bytes.NewReader(data))
|
|
decoder.KnownFields(true)
|
|
if err := decoder.Decode(&prof); err != nil {
|
|
idMatch := fileMatch || profileFileHasID(data, id)
|
|
if strings.Contains(err.Error(), "field api_key not found") {
|
|
if idMatch {
|
|
return nil, fmt.Errorf("%w: %s", ErrRawAPIKeyNotAllowed, relPath)
|
|
}
|
|
continue
|
|
}
|
|
if idMatch {
|
|
return nil, fmt.Errorf("%w: %s: %v", ErrInvalidYAML, relPath, err)
|
|
}
|
|
continue
|
|
}
|
|
|
|
if prof.ID != id {
|
|
continue
|
|
}
|
|
if err := validateProfile(&prof); err != nil {
|
|
if errors.Is(err, ErrRawAPIKeyNotAllowed) {
|
|
return nil, fmt.Errorf("%w: %s", err, relPath)
|
|
}
|
|
return nil, fmt.Errorf("%w: %s: %v", ErrInvalidProfile, relPath, err)
|
|
}
|
|
matches = append(matches, profileMatch{
|
|
profile: &prof,
|
|
path: relPath,
|
|
})
|
|
}
|
|
|
|
if len(matches) > 1 {
|
|
paths := make([]string, 0, len(matches))
|
|
for _, match := range matches {
|
|
paths = append(paths, match.path)
|
|
}
|
|
return nil, fmt.Errorf("%w: duplicate execution profile id %q found in: %s", ErrInvalidProfile, id, strings.Join(paths, ", "))
|
|
}
|
|
|
|
if len(matches) == 1 {
|
|
return matches[0].profile, nil
|
|
}
|
|
|
|
return nil, ErrProfileNotFound
|
|
}
|
|
|
|
type profileMatch struct {
|
|
profile *domain.ExecutionProfile
|
|
path string
|
|
}
|
|
|
|
func profileFileHasID(data []byte, id string) bool {
|
|
var raw struct {
|
|
ID string `yaml:"id"`
|
|
}
|
|
if err := yaml.NewDecoder(bytes.NewReader(data)).Decode(&raw); err != nil {
|
|
return false
|
|
}
|
|
return strings.TrimSpace(raw.ID) == id
|
|
}
|
|
|
|
func validateProfile(p *domain.ExecutionProfile) error {
|
|
if strings.TrimSpace(p.ID) == "" {
|
|
return errors.New("id is required")
|
|
}
|
|
if strings.TrimSpace(p.Endpoint) == "" {
|
|
return errors.New("endpoint is required")
|
|
}
|
|
if strings.TrimSpace(p.Model) == "" {
|
|
return errors.New("model is required")
|
|
}
|
|
|
|
if p.Temperature < 0 || p.Temperature > 2 {
|
|
return errors.New("temperature must be between 0 and 2")
|
|
}
|
|
if p.MaxTokens < 0 {
|
|
return errors.New("max_tokens must be greater than or equal to 0")
|
|
}
|
|
if p.TopP < 0 || p.TopP > 1 {
|
|
return errors.New("top_p must be between 0 and 1")
|
|
}
|
|
if p.TimeoutSeconds < 0 {
|
|
return errors.New("timeout_seconds must be greater than or equal to 0")
|
|
}
|
|
|
|
return nil
|
|
}
|