nexarch/ai/internal/threadsummarize/threadsummarize.go

// Package threadsummarize fasst einen E-Mail-Thread über mehrere Nachrichten
// hinweg zusammen (SUM-02), aufbauend auf dem Einzeldokument-Modell aus
// ai/internal/summarize (SUM-01). Zitierte Altnachrichten innerhalb einer
// Antwort werden vor dem Modellaufruf entfernt, damit ihr Inhalt nicht doppelt
// zusammengefasst wird (AK2) — er ist bereits durch die zitierte Nachricht
// selbst im Thread vertreten.
package threadsummarize

import (
	"context"
	"errors"
	"fmt"
	"regexp"
	"strings"

	"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
)

// Message ist eine einzelne Nachricht innerhalb eines Threads.
type Message struct {
	ID   string
	From string
	Body string
}

// Thread ist eine geordnete Folge von Nachrichten (älteste zuerst).
type Thread struct {
	Messages []Message
}

// Result ist die Zusammenfassung eines Threads.
type Result struct {
	Summary        string
	MessageCount   int
	LastMessageID  string
}

// Options steuert die Zusammenfassung.
type Options struct {
	MaxWords int
	Language string
}

func (o Options) maxWords() int {
	if o.MaxWords > 0 {
		return o.MaxWords
	}
	return 120
}

// Summarizer fasst E-Mail-Threads über einen Provider (ENG-01) zusammen.
type Summarizer struct {
	Provider provider.Provider
	Model    string
}

// Summarize fasst den gesamten Thread zusammen (AK1). Zitierte Altnachrichten
// in jeder Nachricht werden vor dem Modellaufruf entfernt (AK2).
func (s *Summarizer) Summarize(ctx context.Context, thread Thread, opts Options) (Result, error) {
	if s.Provider == nil {
		return Result{}, errors.New("threadsummarize: kein provider konfiguriert")
	}
	if len(thread.Messages) == 0 {
		return Result{}, errors.New("threadsummarize: leerer thread")
	}

	body := buildThreadBody(thread.Messages)
	summary, err := s.callModel(ctx, body, opts, "")
	if err != nil {
		return Result{}, err
	}

	last := thread.Messages[len(thread.Messages)-1]
	return Result{
		Summary:       summary,
		MessageCount:  len(thread.Messages),
		LastMessageID: last.ID,
	}, nil
}

// Update aktualisiert eine bestehende Zusammenfassung um eine neue Nachricht
// (AK3), statt den gesamten Thread erneut zu verarbeiten. Die bisherige
// Zusammenfassung dient dem Modell als Ausgangspunkt.
func (s *Summarizer) Update(ctx context.Context, previous Result, newMessage Message, opts Options) (Result, error) {
	if s.Provider == nil {
		return Result{}, errors.New("threadsummarize: kein provider konfiguriert")
	}
	if strings.TrimSpace(previous.Summary) == "" {
		return Result{}, errors.New("threadsummarize: keine bisherige zusammenfassung zum aktualisieren")
	}

	body := stripQuoted(newMessage.Body)
	summary, err := s.callModel(ctx, body, opts, previous.Summary)
	if err != nil {
		return Result{}, err
	}

	return Result{
		Summary:       summary,
		MessageCount:  previous.MessageCount + 1,
		LastMessageID: newMessage.ID,
	}, nil
}

func (s *Summarizer) callModel(ctx context.Context, body string, opts Options, previousSummary string) (string, error) {
	prompt := buildPrompt(body, opts, previousSummary)
	resp, err := s.Provider.Chat(ctx, provider.ChatRequest{
		Model: s.Model,
		Messages: []provider.Message{
			{Role: provider.RoleSystem, Content: "Du fasst E-Mail-Threads kurz und belegbar zusammen. Erfinde niemals Inhalte, die nicht in den Nachrichten stehen. Antworte ausschließlich mit der Zusammenfassung, ohne Einleitung oder Meta-Kommentar."},
			{Role: provider.RoleUser, Content: prompt},
		},
		Temperature: 0,
	})
	if err != nil {
		return "", fmt.Errorf("threadsummarize: modellaufruf: %w", err)
	}
	return strings.TrimSpace(resp.Message.Content), nil
}

func buildPrompt(body string, opts Options, previousSummary string) string {
	var b strings.Builder
	if previousSummary != "" {
		fmt.Fprintf(&b, "Bisherige Zusammenfassung des Threads:\n%s\n\n", previousSummary)
		b.WriteString("Aktualisiere diese Zusammenfassung um die folgende neue Nachricht. ")
		b.WriteString("Berücksichtige weiterhin nur bereits genannte und neu hinzugekommene Inhalte, erfinde nichts hinzu. ")
	} else {
		b.WriteString("Fasse den folgenden E-Mail-Thread zusammen und bilde seinen Verlauf korrekt ab. ")
	}
	fmt.Fprintf(&b, "Höchstens %d Wörter. ", opts.maxWords())
	if opts.Language != "" {
		fmt.Fprintf(&b, "Antworte in der Sprache mit dem Code %q. ", opts.Language)
	} else {
		b.WriteString("Antworte in der Sprache des Threads. ")
	}
	b.WriteString("\n\n")
	if previousSummary != "" {
		b.WriteString("Neue Nachricht:\n")
	} else {
		b.WriteString("Thread:\n")
	}
	b.WriteString(body)
	return b.String()
}

// buildThreadBody verkettet alle Nachrichten eines Threads, wobei zitierte
// Altnachrichten aus jeder Nachricht entfernt werden (AK2) — ihr Inhalt ist
// bereits durch die zitierte Originalnachricht selbst im Thread vertreten.
func buildThreadBody(messages []Message) string {
	var b strings.Builder
	for i, m := range messages {
		if i > 0 {
			b.WriteString("\n---\n")
		}
		fmt.Fprintf(&b, "Von: %s\n", m.From)
		b.WriteString(stripQuoted(m.Body))
	}
	return b.String()
}

var quoteReplyHeaderRe = regexp.MustCompile(`(?i)^(Am .+ schrieb.*:|On .+ wrote:|-----Ursprüngliche Nachricht-----|-----Original Message-----).*$`)

// stripQuoted entfernt zitierte Altnachrichten aus einer Nachricht: Zeilen,
// die mit ">" beginnen (klassisches E-Mail-Zitat), sowie alles ab einer
// erkannten Zitat-Kopfzeile ("Am ... schrieb:", "On ... wrote:",
// "-----Ursprüngliche Nachricht-----").
func stripQuoted(body string) string {
	lines := strings.Split(body, "\n")
	var out []string
	for _, line := range lines {
		trimmed := strings.TrimSpace(line)
		if strings.HasPrefix(trimmed, ">") {
			continue
		}
		if quoteReplyHeaderRe.MatchString(trimmed) {
			break
		}
		out = append(out, line)
	}
	return strings.TrimSpace(strings.Join(out, "\n"))
}