rsspipe/internal/actions/ai/enrich.go

package ai

import (
	"context"
	"encoding/json"
	"time"

	"git.pengzhan.dev/haopengzhan/rsspipe/internal/ai"
	"git.pengzhan.dev/haopengzhan/rsspipe/internal/db"
	"git.pengzhan.dev/haopengzhan/rsspipe/internal/models"
	"git.pengzhan.dev/haopengzhan/rsspipe/internal/worker"
	"go.uber.org/zap"
)

// LoadConfig fetches current AI provider configuration from system settings.
func LoadConfig(database *db.DB) (ai.Config, []models.PromptTemplate) {
	raw, err := database.GetSetting("ai_settings")
	if err == nil && raw != "" {
		var s models.AISettings
		if err := json.Unmarshal([]byte(raw), &s); err == nil {
			provider := s.Provider
			if provider == "" {
				provider = "openai"
			}
			baseURL := s.BaseURL
			if baseURL == "" {
				baseURL = "https://api.openai.com/v1"
			}
			model := s.Model
			if model == "" {
				model = "gpt-4o-mini"
			}
			return ai.Config{
				Enabled:     s.Enabled,
				Provider:    provider,
				BaseURL:     baseURL,
				APIKey:      s.APIKey,
				Model:       model,
				Temperature: s.Temperature,
				MaxTokens:   s.MaxTokens,
			}, s.Prompts
		}
	}

	settings, _ := database.GetSettingsMap()
	enabled := settings["ai_enabled"] == "true" || settings["ai_enabled"] == "1"
	provider := settings["ai_provider"]
	if provider == "" {
		provider = "openai"
	}
	baseURL := settings["ai_base_url"]
	if baseURL == "" {
		baseURL = "https://api.openai.com/v1"
	}
	model := settings["ai_model"]
	if model == "" {
		model = "gpt-4o-mini"
	}
	return ai.Config{
		Enabled:  enabled,
		Provider: provider,
		BaseURL:  baseURL,
		APIKey:   settings["ai_api_key"],
		Model:    model,
	}, nil
}

// NewEnrichmentHandler creates a worker action handler for AI variant enrichment.
func NewEnrichmentHandler(database *db.DB, client *ai.Client, log *zap.Logger) worker.ActionHandler {
	return func(ctx context.Context, entry models.FeedEntry, params map[string]interface{}) (*worker.ActionResult, error) {
		cfg, prompts := LoadConfig(database)
		if !cfg.Enabled {
			log.Warn("AI action skipped: AI features are disabled in Settings",
				zap.String("entry_id", entry.ID),
			)
			return nil, nil
		}
		if cfg.APIKey == "" && cfg.Provider != "ollama" {
			log.Warn("AI action skipped: API key is not configured in Settings > AI & Integrations",
				zap.String("entry_id", entry.ID),
				zap.String("provider", cfg.Provider),
			)
			return nil, nil
		}

		prompt, _ := params["prompt"].(string)
		if prompt == "" {
			prompt, _ = params["custom_prompt"].(string)
		}
		if prompt == "" {
			for _, p := range prompts {
				if p.IsDefault {
					prompt = p.Prompt
					break
				}
			}
			if prompt == "" && len(prompts) > 0 {
				prompt = prompts[0].Prompt
			}
		}
		vKey, _ := params["variant_key"].(string)
		if vKey == "" {
			vKey = "ai_summary"
		}
		cType, _ := params["content_type"].(string)
		if cType == "" {
			cType = "text"
		}

		resultText, err := client.GenerateEnrichment(ctx, cfg, prompt, entry)
		if err != nil {
			log.Error("AI enrichment generation failed",
				zap.String("entry_id", entry.ID),
				zap.String("model", cfg.Model),
				zap.Error(err),
			)
			return nil, err
		}

		variant := models.EntryVariant{
			EntryID:     entry.ID,
			VariantKey:  vKey,
			ContentType: cType,
			TextValue:   resultText,
			Metadata: map[string]interface{}{
				"model":       cfg.Model,
				"provider":    cfg.Provider,
				"prompt_used": prompt,
			},
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		}

		log.Info("AI enrichment completed",
			zap.String("entry_id", entry.ID),
			zap.String("variant_key", vKey),
			zap.String("model", cfg.Model),
		)

		return &worker.ActionResult{
			ResultVariant: &variant,
		}, nil
	}
}