feat(claude): Add testing, documentation rules and project hooks

- rules/testing.md: TDD workflow for Go and Python
- rules/documentation.md: Auto-documentation guidelines
- plans/embedding-service-separation.md: Migration plan
- settings.json: Post-edit hooks for docs/tests validation
- .gitignore: Exclude settings.local.json (contains API keys)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.claude/rules/documentation.md

@@ -0,0 +1,91 @@
+# Dokumentations-Regeln
+
+## Automatische Dokumentations-Aktualisierung
+
+**WICHTIG:** Bei JEDER Code-Änderung muss die entsprechende Dokumentation aktualisiert werden!
+
+## Wann Dokumentation aktualisieren?
+
+### API-Änderungen
+Wenn du einen Endpoint änderst, hinzufügst oder entfernst:
+- Aktualisiere `/docs/api/consent-service-api.md` (Go Endpoints)
+- Aktualisiere `/docs/api/backend-api.md` (Python Endpoints)
+
+### Neue Funktionen/Klassen
+Wenn du neue Funktionen, Klassen oder Module erstellst:
+- Aktualisiere `/docs/consent-service/README.md` (für Go)
+- Aktualisiere `/docs/backend/README.md` (für Python)
+
+### Architektur-Änderungen
+Wenn du die Systemarchitektur änderst:
+- Aktualisiere `/docs/architecture/system-architecture.md`
+- Aktualisiere `/docs/architecture/data-model.md` (bei DB-Änderungen)
+
+### Neue Konfigurationsoptionen
+Wenn du neue Umgebungsvariablen oder Konfigurationen hinzufügst:
+- Aktualisiere die entsprechende README
+- Füge zur `guides/local-development.md` hinzu
+
+## Dokumentations-Format
+
+### API-Endpoints dokumentieren
+
+```markdown
+### METHOD /path/to/endpoint
+
+Kurze Beschreibung.
+
+**Request Body:**
+\`\`\`json
+{
+  "field": "value"
+}
+\`\`\`
+
+**Response (200):**
+\`\`\`json
+{
+  "result": "value"
+}
+\`\`\`
+
+**Errors:**
+- `400`: Beschreibung
+- `401`: Beschreibung
+```
+
+### Funktionen dokumentieren
+
+```markdown
+### FunctionName (file.go:123)
+
+\`\`\`go
+func FunctionName(param Type) ReturnType
+\`\`\`
+
+**Beschreibung:** Was macht die Funktion?
+
+**Parameter:**
+- `param`: Beschreibung
+
+**Rückgabe:** Beschreibung
+```
+
+## Checkliste nach Code-Änderungen
+
+Vor dem Abschluss einer Aufgabe prüfe:
+
+- [ ] Wurden neue API-Endpoints hinzugefügt? → API-Docs aktualisieren
+- [ ] Wurden Datenmodelle geändert? → data-model.md aktualisieren
+- [ ] Wurden neue Konfigurationen hinzugefügt? → README aktualisieren
+- [ ] Wurden neue Abhängigkeiten hinzugefügt? → requirements.txt/go.mod UND Docs
+- [ ] Wurde die Architektur geändert? → architecture/ aktualisieren
+
+## Beispiel: Vollständige Dokumentation einer neuen Funktion
+
+Wenn du z.B. `GetUserStats()` im Go Service hinzufügst:
+
+1. **Code schreiben** in `internal/services/stats_service.go`
+2. **API-Doc aktualisieren** in `docs/api/consent-service-api.md`
+3. **Service-Doc aktualisieren** in `docs/consent-service/README.md`
+4. **Test schreiben** (siehe testing.md)

.claude/rules/testing.md

@@ -0,0 +1,202 @@
+# Test-Regeln
+
+## Automatische Test-Erweiterung
+
+**WICHTIG:** Bei JEDER Code-Änderung müssen entsprechende Tests erstellt oder aktualisiert werden!
+
+## Wann Tests schreiben?
+
+### IMMER wenn du:
+1. **Neue Funktionen** erstellst → Unit Test
+2. **Neue API-Endpoints** hinzufügst → Handler Test
+3. **Bugs fixst** → Regression Test (der Bug sollte nie wieder auftreten)
+4. **Bestehenden Code änderst** → Bestehende Tests anpassen
+
+## Test-Struktur
+
+### Go Tests (Consent Service)
+
+**Speicherort:** Im gleichen Verzeichnis wie der Code
+
+```
+internal/
+├── services/
+│   ├── auth_service.go
+│   └── auth_service_test.go    ← Test hier
+├── handlers/
+│   ├── handlers.go
+│   └── handlers_test.go        ← Test hier
+└── middleware/
+    ├── auth.go
+    └── middleware_test.go      ← Test hier
+```
+
+**Test-Namenskonvention:**
+```go
+func TestFunctionName_Scenario_ExpectedResult(t *testing.T)
+
+// Beispiele:
+func TestHashPassword_ValidPassword_ReturnsHash(t *testing.T)
+func TestLogin_InvalidCredentials_Returns401(t *testing.T)
+func TestCreateDocument_MissingTitle_ReturnsError(t *testing.T)
+```
+
+**Test-Template:**
+```go
+func TestFunctionName(t *testing.T) {
+    // Arrange
+    service := &MyService{}
+    input := "test-input"
+
+    // Act
+    result, err := service.DoSomething(input)
+
+    // Assert
+    if err != nil {
+        t.Fatalf("Expected no error, got %v", err)
+    }
+    if result != expected {
+        t.Errorf("Expected %v, got %v", expected, result)
+    }
+}
+```
+
+**Table-Driven Tests bevorzugen:**
+```go
+func TestValidateEmail(t *testing.T) {
+    tests := []struct {
+        name     string
+        email    string
+        expected bool
+    }{
+        {"valid email", "test@example.com", true},
+        {"missing @", "testexample.com", false},
+        {"empty", "", false},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            result := ValidateEmail(tt.email)
+            if result != tt.expected {
+                t.Errorf("Expected %v, got %v", tt.expected, result)
+            }
+        })
+    }
+}
+```
+
+### Python Tests (Backend)
+
+**Speicherort:** `/backend/tests/`
+
+```
+backend/
+├── consent_client.py
+├── gdpr_api.py
+└── tests/
+    ├── __init__.py
+    ├── test_consent_client.py  ← Tests für consent_client.py
+    └── test_gdpr_api.py        ← Tests für gdpr_api.py
+```
+
+**Test-Namenskonvention:**
+```python
+class TestClassName:
+    def test_method_scenario_expected_result(self):
+        pass
+
+# Beispiele:
+class TestConsentClient:
+    def test_check_consent_valid_token_returns_status(self):
+        pass
+
+    def test_check_consent_expired_token_raises_error(self):
+        pass
+```
+
+**Test-Template:**
+```python
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+
+class TestMyFeature:
+    def test_sync_function(self):
+        # Arrange
+        input_data = "test"
+
+        # Act
+        result = my_function(input_data)
+
+        # Assert
+        assert result == expected
+
+    @pytest.mark.asyncio
+    async def test_async_function(self):
+        # Arrange
+        client = MyClient()
+
+        # Act
+        with patch("httpx.AsyncClient") as mock:
+            mock_instance = AsyncMock()
+            mock.return_value = mock_instance
+            result = await client.fetch_data()
+
+        # Assert
+        assert result is not None
+```
+
+## Test-Kategorien
+
+### 1. Unit Tests (Höchste Priorität)
+- Testen einzelne Funktionen/Methoden
+- Keine externen Abhängigkeiten (Mocks verwenden)
+- Schnell ausführbar
+
+### 2. Integration Tests
+- Testen Zusammenspiel mehrerer Komponenten
+- Können echte DB verwenden (Test-DB)
+
+### 3. Security Tests
+- Auth/JWT Validierung
+- Passwort-Hashing
+- Berechtigungsprüfung
+
+## Checkliste vor Abschluss
+
+Vor dem Abschluss einer Aufgabe:
+
+- [ ] Gibt es Tests für alle neuen Funktionen?
+- [ ] Gibt es Tests für alle Edge Cases?
+- [ ] Gibt es Tests für Fehlerfälle?
+- [ ] Laufen alle bestehenden Tests noch? (`go test ./...` / `pytest`)
+- [ ] Ist die Test-Coverage angemessen?
+
+## Tests ausführen
+
+```bash
+# Go - Alle Tests
+cd consent-service && go test -v ./...
+
+# Go - Mit Coverage
+cd consent-service && go test -cover ./...
+
+# Python - Alle Tests
+cd backend && source venv/bin/activate && pytest -v
+
+# Python - Mit Coverage
+cd backend && pytest --cov=. --cov-report=html
+```
+
+## Beispiel: Vollständiger Test-Workflow
+
+Wenn du z.B. eine neue `GetUserStats()` Funktion im Go Service hinzufügst:
+
+1. **Funktion schreiben** in `internal/services/stats_service.go`
+2. **Test erstellen** in `internal/services/stats_service_test.go`:
+   ```go
+   func TestGetUserStats_ValidUser_ReturnsStats(t *testing.T) {...}
+   func TestGetUserStats_InvalidUser_ReturnsError(t *testing.T) {...}
+   func TestGetUserStats_NoConsents_ReturnsEmptyStats(t *testing.T) {...}
+   ```
+3. **Tests ausführen**: `go test -v ./internal/services/...`
+4. **Dokumentation aktualisieren** (siehe documentation.md)