feat: Regulatory News Dashboard — proaktive Compliance-Alerts

Zeigt anstehende regulatorische Fristen im Dashboard an, abgeleitet
aus den bestehenden Obligation v2 JSON-Dateien. Keine neue DB-Tabelle.

Erster News-Eintrag: Widerrufsbutton-Pflicht ab 19.06.2026
(EU-RL 2023/2673, §356a BGB) — eigener Text, keine externe Quelle.

Features:
- Go Service: scannt Obligations nach Fristen, berechnet Urgency
- API: GET /sdk/v1/regulatory-news mit Countdown + Farbcodierung
- Dashboard: RegulatoryNewsFeed Sektion mit Countdown-Badges
- Vorlage: news-Feld in v2 JSON fuer zukuenftige regulatorische Updates
- 11 Tests (Sortierung, Urgency, Deadline-Parsing, Real-File-Test)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

ai-compliance-sdk/internal/ucca/regulatory_news.go

@@ -0,0 +1,146 @@
+package ucca
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+)
+
+// RegulatoryNewsItem is a single news item for dashboard display.
+type RegulatoryNewsItem struct {
+	ID             string `json:"id"`
+	Headline       string `json:"headline"`
+	Summary        string `json:"summary"`
+	LegalReference string `json:"legal_reference"`
+	Deadline       string `json:"deadline"`
+	DaysRemaining  int    `json:"days_remaining"`
+	Urgency        string `json:"urgency"` // critical, high, medium, low
+	Affected       string `json:"affected"`
+	ActionRequired string `json:"action_required"`
+	ActionLink     string `json:"action_link"`
+	Regulation     string `json:"regulation"`
+	Sanctions      string `json:"sanctions,omitempty"`
+}
+
+// RegulatoryNewsFilter controls which news items are returned.
+type RegulatoryNewsFilter struct {
+	BusinessModel string `json:"business_model,omitempty"`
+	HorizonDays   int    `json:"horizon_days,omitempty"` // default 365
+	Limit         int    `json:"limit,omitempty"`         // default 5
+}
+
+// GetRegulatoryNews scans all v2 obligations for upcoming deadlines
+// and returns formatted news items sorted by urgency.
+func GetRegulatoryNews(regulations map[string]*V2RegulationFile, filter RegulatoryNewsFilter) []RegulatoryNewsItem {
+	if filter.HorizonDays <= 0 {
+		filter.HorizonDays = 365
+	}
+	if filter.Limit <= 0 {
+		filter.Limit = 5
+	}
+
+	today := time.Now().UTC().Truncate(24 * time.Hour)
+	horizon := today.AddDate(0, 0, filter.HorizonDays)
+	var items []RegulatoryNewsItem
+
+	for _, reg := range regulations {
+		for _, obl := range reg.Obligations {
+			deadline, ok := resolveDeadline(obl)
+			if !ok || deadline.Before(today) || deadline.After(horizon) {
+				continue
+			}
+
+			days := int(deadline.Sub(today).Hours() / 24)
+			item := buildNewsItem(obl, reg.Regulation, deadline, days)
+			items = append(items, item)
+		}
+	}
+
+	sort.Slice(items, func(i, j int) bool {
+		return items[i].DaysRemaining < items[j].DaysRemaining
+	})
+
+	if len(items) > filter.Limit {
+		items = items[:filter.Limit]
+	}
+	return items
+}
+
+func buildNewsItem(obl V2Obligation, regulation string, deadline time.Time, days int) RegulatoryNewsItem {
+	item := RegulatoryNewsItem{
+		ID:            obl.ID,
+		Deadline:      deadline.Format("2006-01-02"),
+		DaysRemaining: days,
+		Urgency:       computeUrgency(days),
+		Regulation:    regulation,
+	}
+
+	// Use hand-crafted news if available
+	if obl.News != nil {
+		item.Headline = obl.News.Headline
+		item.Summary = obl.News.Summary
+		item.ActionRequired = obl.News.ActionRequired
+		item.Affected = obl.News.Affected
+		item.ActionLink = obl.News.ActionLink
+	} else {
+		// Auto-generate from obligation data
+		item.Headline = fmt.Sprintf("%s — ab %s", obl.Title, deadline.Format("02.01.2006"))
+		item.Summary = obl.Description
+		item.ActionRequired = "Pruefen Sie die Anforderungen und ergreifen Sie Massnahmen."
+		item.ActionLink = obl.BreakpilotFeature
+	}
+
+	item.LegalReference = formatLegalReference(obl.LegalBasis)
+
+	if obl.Sanctions != nil {
+		item.Sanctions = obl.Sanctions.MaxFine
+	}
+	return item
+}
+
+func resolveDeadline(obl V2Obligation) (time.Time, bool) {
+	// Check explicit deadline.date first
+	if obl.Deadline != nil && obl.Deadline.Date != "" {
+		t, err := time.Parse("2006-01-02", obl.Deadline.Date)
+		if err == nil {
+			return t, true
+		}
+	}
+	// Fallback to valid_from
+	if obl.ValidFrom != "" {
+		t, err := time.Parse("2006-01-02", obl.ValidFrom)
+		if err == nil {
+			return t, true
+		}
+	}
+	return time.Time{}, false
+}
+
+func computeUrgency(daysRemaining int) string {
+	switch {
+	case daysRemaining <= 30:
+		return "critical"
+	case daysRemaining <= 90:
+		return "high"
+	case daysRemaining <= 180:
+		return "medium"
+	default:
+		return "low"
+	}
+}
+
+func formatLegalReference(bases []V2LegalBasis) string {
+	if len(bases) == 0 {
+		return ""
+	}
+	var refs []string
+	for _, b := range bases {
+		ref := b.Article
+		if b.Norm != "" {
+			ref = b.Article + " " + b.Norm
+		}
+		refs = append(refs, ref)
+	}
+	return strings.Join(refs, ", ")
+}

ai-compliance-sdk/internal/ucca/regulatory_news_test.go

@@ -0,0 +1,191 @@
+package ucca
+
+import (
+	"testing"
+	"time"
+)
+
+func makeTestRegulations() map[string]*V2RegulationFile {
+	future30 := time.Now().AddDate(0, 0, 30).Format("2006-01-02")
+	future90 := time.Now().AddDate(0, 0, 90).Format("2006-01-02")
+	past := time.Now().AddDate(0, 0, -10).Format("2006-01-02")
+
+	return map[string]*V2RegulationFile{
+		"TestReg": {
+			Regulation: "TestReg",
+			Obligations: []V2Obligation{
+				{
+					ID: "TR-001", Title: "Upcoming Critical",
+					Deadline: &V2Deadline{Date: future30},
+					News: &V2ObligationNews{
+						Headline: "Critical Deadline", Summary: "Test summary",
+						ActionRequired: "Do something", Affected: "All", ActionLink: "/sdk/test",
+					},
+					LegalBasis: []V2LegalBasis{{Norm: "TestLaw", Article: "Art. 1"}},
+				},
+				{
+					ID: "TR-002", Title: "Upcoming Medium",
+					Description: "Medium priority regulation change.",
+					Deadline: &V2Deadline{Date: future90},
+					LegalBasis: []V2LegalBasis{{Norm: "TestLaw", Article: "Art. 2"}},
+				},
+				{
+					ID: "TR-003", Title: "Past Deadline",
+					Deadline: &V2Deadline{Date: past},
+				},
+				{
+					ID: "TR-004", Title: "No Deadline",
+				},
+			},
+		},
+	}
+}
+
+func TestGetRegulatoryNews_SortedByUrgency(t *testing.T) {
+	regs := makeTestRegulations()
+	items := GetRegulatoryNews(regs, RegulatoryNewsFilter{Limit: 10})
+
+	if len(items) != 2 {
+		t.Fatalf("expected 2 items (future only), got %d", len(items))
+	}
+	// First item should be the more urgent one (30 days)
+	if items[0].ID != "TR-001" {
+		t.Errorf("expected TR-001 first (most urgent), got %s", items[0].ID)
+	}
+	if items[1].ID != "TR-002" {
+		t.Errorf("expected TR-002 second, got %s", items[1].ID)
+	}
+}
+
+func TestGetRegulatoryNews_UsesNewsField(t *testing.T) {
+	regs := makeTestRegulations()
+	items := GetRegulatoryNews(regs, RegulatoryNewsFilter{Limit: 10})
+
+	// TR-001 has hand-crafted news
+	if items[0].Headline != "Critical Deadline" {
+		t.Errorf("expected hand-crafted headline, got %q", items[0].Headline)
+	}
+	if items[0].ActionLink != "/sdk/test" {
+		t.Errorf("expected /sdk/test, got %q", items[0].ActionLink)
+	}
+}
+
+func TestGetRegulatoryNews_AutoGeneratesWithoutNews(t *testing.T) {
+	regs := makeTestRegulations()
+	items := GetRegulatoryNews(regs, RegulatoryNewsFilter{Limit: 10})
+
+	// TR-002 has no news field — should auto-generate
+	if items[1].Headline == "" {
+		t.Error("expected auto-generated headline")
+	}
+	if items[1].Summary == "" {
+		t.Error("expected auto-generated summary from description")
+	}
+}
+
+func TestGetRegulatoryNews_ExcludesPastDeadlines(t *testing.T) {
+	regs := makeTestRegulations()
+	items := GetRegulatoryNews(regs, RegulatoryNewsFilter{Limit: 10})
+
+	for _, item := range items {
+		if item.ID == "TR-003" {
+			t.Error("past deadline should be excluded")
+		}
+		if item.ID == "TR-004" {
+			t.Error("no-deadline obligation should be excluded")
+		}
+	}
+}
+
+func TestGetRegulatoryNews_LimitWorks(t *testing.T) {
+	regs := makeTestRegulations()
+	items := GetRegulatoryNews(regs, RegulatoryNewsFilter{Limit: 1})
+
+	if len(items) != 1 {
+		t.Errorf("expected 1 item with limit=1, got %d", len(items))
+	}
+}
+
+func TestComputeUrgency(t *testing.T) {
+	tests := []struct {
+		days     int
+		expected string
+	}{
+		{5, "critical"},
+		{30, "critical"},
+		{31, "high"},
+		{90, "high"},
+		{91, "medium"},
+		{180, "medium"},
+		{181, "low"},
+		{365, "low"},
+	}
+	for _, tc := range tests {
+		got := computeUrgency(tc.days)
+		if got != tc.expected {
+			t.Errorf("computeUrgency(%d) = %q, want %q", tc.days, got, tc.expected)
+		}
+	}
+}
+
+func TestResolveDeadline_DeadlineDate(t *testing.T) {
+	obl := V2Obligation{Deadline: &V2Deadline{Date: "2026-06-19"}}
+	d, ok := resolveDeadline(obl)
+	if !ok {
+		t.Fatal("expected deadline resolved")
+	}
+	if d.Format("2006-01-02") != "2026-06-19" {
+		t.Errorf("got %s", d.Format("2006-01-02"))
+	}
+}
+
+func TestResolveDeadline_ValidFrom(t *testing.T) {
+	obl := V2Obligation{ValidFrom: "2026-08-02"}
+	d, ok := resolveDeadline(obl)
+	if !ok {
+		t.Fatal("expected deadline resolved from valid_from")
+	}
+	if d.Format("2006-01-02") != "2026-08-02" {
+		t.Errorf("got %s", d.Format("2006-01-02"))
+	}
+}
+
+func TestResolveDeadline_NoDate(t *testing.T) {
+	obl := V2Obligation{}
+	_, ok := resolveDeadline(obl)
+	if ok {
+		t.Error("expected no deadline for empty obligation")
+	}
+}
+
+func TestFormatLegalReference(t *testing.T) {
+	bases := []V2LegalBasis{
+		{Norm: "DSGVO", Article: "Art. 22"},
+		{Norm: "BGB", Article: "§ 356a"},
+	}
+	ref := formatLegalReference(bases)
+	if ref != "Art. 22 DSGVO, § 356a BGB" {
+		t.Errorf("got %q", ref)
+	}
+}
+
+func TestGetRegulatoryNews_FromRealFiles(t *testing.T) {
+	regs, err := LoadAllV2Regulations()
+	if err != nil {
+		t.Skipf("could not load v2 regulations: %v", err)
+	}
+	items := GetRegulatoryNews(regs, RegulatoryNewsFilter{Limit: 20, HorizonDays: 730})
+	// Should find at least the Widerrufsbutton obligation
+	found := false
+	for _, item := range items {
+		if item.ID == "VBR-OBL-001" {
+			found = true
+			if item.Headline != "Widerrufsbutton-Pflicht ab 19. Juni 2026" {
+				t.Errorf("unexpected headline: %q", item.Headline)
+			}
+		}
+	}
+	if !found {
+		t.Error("expected VBR-OBL-001 in regulatory news")
+	}
+}

ai-compliance-sdk/internal/ucca/v2_loader.go

@@ -58,6 +58,17 @@ type V2Obligation struct {
 	Version               string            `json:"version,omitempty"`
 	ISO27001Mapping       []string          `json:"iso27001_mapping,omitempty"`
 	HowToImplement        string            `json:"how_to_implement,omitempty"`
+	News                  *V2ObligationNews `json:"news,omitempty"`
+}
+
+// V2ObligationNews is news metadata for dashboard display.
+// Own text referencing legal basis — never copied from external sources.
+type V2ObligationNews struct {
+	Headline       string `json:"headline"`
+	Summary        string `json:"summary"`
+	ActionRequired string `json:"action_required"`
+	Affected       string `json:"affected,omitempty"`
+	ActionLink     string `json:"action_link,omitempty"`
 }
 
 // V2LegalBasis is a legal reference in v2 format