{
"tool_response": {
"filePath": "\/var\/www\/dev.campus.systemische-tools.de\/docs\/plan-code-quality-gates.md",
"oldString": "# Prüfung 6\n\n*Wird nach Abnahme von Prüfung 5 definiert.*",
"newString": "# Prüfung 6: SOLID + DIP\n\n## Ziel\n\n**SOLID Prinzipien:**\n- **S**ingle Responsibility → bereits in Prüfung 1\n- **O**pen\/Closed → Klassen offen für Erweiterung, geschlossen für Modifikation\n- **L**iskov Substitution → Unterklassen substituierbar für Oberklassen\n- **I**nterface Segregation → Kleine, fokussierte Interfaces\n- **D**ependency Inversion → High-level abhängig von Abstraktionen, nicht Implementierungen\n\n## Grundsatz\n\nSOLID ist größtenteils semantisch. Nur wenige Aspekte sind per Regex prüfbar:\n\n| Prinzip | Prüfbar? | Methode |\n|---------|----------|---------|\n| S | Ja | Prüfung 1 (SRP) |\n| O | Nein | Semantisch, erfordert Design-Review |\n| L | Nein | Typ-Analyse, PHPStan |\n| I | Teilweise | Interface-Größe zählbar |\n| D | Teilweise | Import-Richtung prüfbar |\n\n**Konsequenz:** Prüfung 6 fokussiert auf DIP (Abhängigkeitsrichtung) und ISP (Interface-Größe).\n\n## Beziehung zu bestehenden H-Regeln\n\nDie folgenden H-Regeln wurden in früherer Implementierung definiert und gehören konzeptionell zu DIP:\n\n| H-Regel | Beschreibung | DIP-Aspekt |\n|---------|--------------|------------|\n| H2 | Domain ohne Infrastructure | Domain kennt keine Implementierung |\n| H3 | DatabaseFactory nur in Factory | Erzeugung zentralisiert |\n| H4 | Kein new Repository in Controller | Controller nutzt DI |\n| H5 | Kein new Infrastructure in Controller | Controller nutzt DI |\n\n**Diese H-Regeln werden nicht dupliziert.** Prüfung 6 ergänzt um zusätzliche Layer-Regeln.\n\n## Abgrenzung zu anderen Prüfungen\n\n| Aspekt | Prüfung | Begründung |\n|--------|---------|------------|\n| SRP | 1 | Verantwortungstrennung |\n| Rollen (MVC) | 2 | Controller\/View\/Model |\n| DB-Artefakte in Code | 2 (P2.4) | SQL-Strings, PDO-Nutzung |\n| Typen | 3 | Typdisziplin |\n| OOP-Integrität | 4 | Verhalten+Zustand |\n| **Import-Richtung** | **6 (DIP)** | Layer-Abhängigkeiten |\n| **Interface-Größe** | **6 (ISP)** | Fokussierte Interfaces |\n\n**Unterschied P2.4 vs P6.1:**\n- P2.4: Prüft DB-Artefakte im Code (SQL-Strings, PDO, DatabaseFactory)\n- P6.1: Prüft Import-Statements (`use Infrastructure\\...`)\n\nP6.1 ist allgemeiner und fängt auch andere Infrastructure-Abhängigkeiten (HttpClient, FileSystem, etc.).\n\n---\n\n## Pre-Hook (BLOCK)\n\n### P6.1: UseCases\/Application darf Infrastructure nicht importieren\n\n**Regel:** Application-Layer (UseCases, Application) darf keine Infrastructure direkt importieren.\n\n**Scope:** `\/UseCases\/`, `\/Application\/`\n\n**Pattern:**\n```python\nif \"\/UseCases\/\" in file_path or \"\/Application\/\" in file_path:\n if re.search(r\"use\\s+Infrastructure\\\\\", content):\n block(\"Application layer must not import Infrastructure directly (DIP)\")\n```\n\n**Begründung:**\n- DIP: High-level Module (UseCases) sollen von Abstraktionen abhängen\n- UseCases definieren WAS passiert\n- Infrastructure implementiert WIE (Abstraktionen in Domain\/Contract)\n- Import-Verletzung = Dependency in falsche Richtung\n\n**Was ist erlaubt:**\n- `use Domain\\Contract\\UserRepositoryInterface` (Abstraktion)\n- `use Domain\\Entity\\User` (Domain-Objekt)\n\n**Was ist verboten:**\n- `use Infrastructure\\Persistence\\MySqlUserRepository`\n- `use Infrastructure\\Http\\GuzzleClient`\n\n---\n\n### P6.2: Domain darf Application-Layer nicht importieren\n\n**Regel:** Domain-Layer darf keine Abhängigkeiten zum Application-Layer haben.\n\n**Scope:** `\/Domain\/`\n\n**Pattern:**\n```python\nif \"\/Domain\/\" in file_path:\n if re.search(r\"use\\s+(UseCases|Application)\\\\\", content):\n block(\"Domain must not import Application layer (layer violation)\")\n```\n\n**Begründung:**\n- Layer-Richtung: außen → innen\n- Domain ist die innerste Schicht\n- Domain definiert Geschäftsregeln, kennt keine Orchestrierung\n- Zyklische Abhängigkeit wäre fatal\n\n**Layer-Hierarchie:**\n```\nPresentation (Controller, View)\n ↓\nApplication (UseCases)\n ↓\nDomain (Entities, Value Objects, Contracts)\n ↓\nInfrastructure (Implementations) ← darf alles sehen, wird von niemandem importiert\n```\n\n---\n\n### P6.3: Infrastructure darf nicht in Domain-Interfaces (gestrichen)\n\n**Ursprüngliche Idee:** Prüfen ob Domain-Interfaces Infrastructure-Typen als Parameter haben.\n\n**Warum gestrichen:**\n- Erfordert Typ-Analyse\n- Interface-Parameter-Parsing per Regex fehleranfällig\n- PHPStan kann das besser\n\n---\n\n## Post-Hook (WARN)\n\n### W6.1: Interface mit zu vielen Methoden (ISP)\n\n**Regel:** Warnung wenn ein Interface mehr als 7 Methoden deklariert.\n\n**Schwelle:** > 7 Methoden\n\n**Pattern:**\n```python\n# Finde Interface-Definitionen\ninterface_match = re.search(r\"interface\\s+\\w+[^{]*\\{\", content)\nif interface_match:\n # Zähle function-Deklarationen (Methoden-Signaturen)\n interface_content = content[interface_match.end():]\n # Bis zur schließenden Klammer\n brace_count = 1\n end_pos = 0\n for i, char in enumerate(interface_content):\n if char == '{':\n brace_count += 1\n elif char == '}':\n brace_count -= 1\n if brace_count == 0:\n end_pos = i\n break\n\n interface_body = interface_content[:end_pos]\n method_count = len(re.findall(r\"public\\s+function\\s+\\w+\", interface_body))\n\n if method_count > 7:\n warn(f\"Interface has {method_count} methods. Consider splitting (ISP).\")\n```\n\n**Warum 7:**\n- 1-5: Normal, fokussiert\n- 6-7: Grenzwertig\n- 8+: Wahrscheinlich zu breit\n\n**Begründung:**\n- ISP: Clients sollten nicht von Methoden abhängen die sie nicht nutzen\n- Große Interfaces zwingen Implementierer zur Stub-Implementierung\n- Besser: Mehrere kleine, fokussierte Interfaces\n\n**Nicht gewarnt:**\n- Abstrakte Klassen (haben oft mehr Methoden)\n- Traits (mischen Verhalten, andere Semantik)\n\n---\n\n### W6.2: Klasse implementiert viele Interfaces\n\n**Regel:** Warnung wenn eine Klasse mehr als 5 Interfaces implementiert.\n\n**Pattern:**\n```python\nimplements_match = re.search(r\"implements\\s+([^{]+)\", content)\nif implements_match:\n interfaces = implements_match.group(1).split(',')\n if len(interfaces) > 5:\n warn(f\"Class implements {len(interfaces)} interfaces. Potential role confusion.\")\n```\n\n**Warum 5:**\n- 1-3: Normal\n- 4-5: Grenzwertig\n- 6+: Klasse hat zu viele Verantwortungen\n\n**Warum Warnung:**\n- Kann legitim sein (Marker-Interfaces, Framework-Konventionen)\n- Aber: Oft Zeichen für SRP-Verletzung\n\n---\n\n### W6.3: Konkrete Klasse als Dependency (gestrichen)\n\n**Ursprüngliche Idee:** Warnung wenn Constructor-Parameter konkrete Klassen statt Interfaces sind.\n\n**Warum gestrichen:**\n- Unterscheidung Interface vs. Klasse per Regex nicht zuverlässig\n- Namenskonventionen (XxxInterface, IXxx) nicht universell\n- PHPStan ist das richtige Tool\n\n---\n\n## Gestrichen\n\n### Open\/Closed Principle\n\n**Warum gestrichen:**\n- Rein semantisch\n- \"Offen für Erweiterung, geschlossen für Modifikation\" erfordert Design-Review\n- Keine Regex-basierte Prüfung möglich\n\n### Liskov Substitution Principle\n\n**Warum gestrichen:**\n- Erfordert Typ-Hierarchie-Analyse\n- Prüft ob Unterklassen Verträge der Oberklassen einhalten\n- PHPStan kann das (return type covariance, parameter contravariance)\n- Hooks können das nicht\n\n### Interface-Implementierungs-Vollständigkeit\n\n**Warum gestrichen:**\n- PHP-Compiler prüft das bereits\n- Hooks wären redundant\n\n---\n\n## Zusammenfassung\n\n### Pre-Hook\n\n| ID | Prüfung | Scope | Aktion |\n|----|---------|-------|--------|\n| P6.1 | `use Infrastructure\\` | \/UseCases\/, \/Application\/ | BLOCK |\n| P6.2 | `use UseCases\\|Application\\` | \/Domain\/ | BLOCK |\n\n### Post-Hook\n\n| ID | Prüfung | Schwelle | Aktion |\n|----|---------|----------|--------|\n| W6.1 | Interface-Methoden | > 7 | WARN |\n| W6.2 | Implementierte Interfaces | > 5 | WARN |\n\n### Allowlist\n\n| Pfad | Grund |\n|------|-------|\n| \/vendor\/ | Third-party |\n| \/tests\/ | Test-Code darf Mocks nutzen |\n| \/Test\/ | PHPUnit |\n| \/Bootstrap\/ | Bootstrap darf alles verdrahten |\n| \/Factory\/ | Factories kennen Implementierungen |\n\n---\n\n## Layer-Regeln Gesamtübersicht\n\nNach allen Prüfungen gelten folgende Layer-Regeln:\n\n| Layer | Darf importieren | Darf nicht importieren |\n|-------|------------------|------------------------|\n| Domain | Nichts | UseCases, Application, Infrastructure, Presentation |\n| UseCases\/Application | Domain | Infrastructure, Presentation |\n| Infrastructure | Domain, Application | Presentation |\n| Presentation (Controller) | Domain, Application | - |\n| Factory | Alles | - |\n\n**Durchsetzung:**\n- H2: Domain → Infrastructure (architecture_guard)\n- P6.2: Domain → Application (Prüfung 6)\n- P6.1: Application → Infrastructure (Prüfung 6)\n- Controller → Infrastructure: Via DI, nicht direkt (H4, H5)\n\n---\n\n## Selbstkritik und Entscheidungen\n\n| Frage | Entscheidung | Begründung |\n|-------|--------------|------------|\n| Warum O\/L nicht prüfen? | Nicht per Regex möglich | Semantisch \/ Typ-Analyse |\n| Überschneidet P6.1 mit P2.4? | Nein | P2.4 = Code-Artefakte, P6.1 = Imports |\n| Warum H-Regeln nicht duplizieren? | Bereits implementiert | Eine Quelle der Wahrheit |\n| Ist > 7 Methods zu strikt? | Konservativ | Warnung, nicht Block |\n| Warum keine Constructor-Analyse? | Zu fehleranfällig | PHPStan ist besser |\n\n---\n\n## SOLID vs. Prüfbarkeit\n\n| Prinzip | Was Hook kann | Was PHPStan kann |\n|---------|---------------|------------------|\n| S | Metriken, Header (P1) | - |\n| O | Nichts | Nichts (Design-Review) |\n| L | Nichts | Return type covariance |\n| I | Methodenzahl (W6.1) | - |\n| D | Import-Richtung (P6.1, P6.2) | Typ-basierte Analyse |\n\n**Fazit:** SOLID ist nur teilweise automatisierbar. Hooks prüfen strukturelle Symptome (Imports, Größe). Semantische Prinzipien (O, L) erfordern menschliches Design-Review oder statische Typ-Analyse (PHPStan).\n\n---\n\n# Implementierungs-Übersicht\n\n## Alle Prüfungen\n\n| # | Prüfung | Pre-Hook (BLOCK) | Post-Hook (WARN) |\n|---|---------|------------------|------------------|\n| 1 | SRP + KISS | P1.1 (Header), P1.2 (Müllhalden) | W1.1-W1.5 (Metriken) |\n| 2 | MVC + CRUD | P2.1-P2.4 (SQL, Trans, echo, DB) | W2.1-W2.2 (Keywords, Private) |\n| 3 | PSR + Types | P3.1-P3.4 (strict, NS, Class, Return) | W3.1, W3.3 (Params, mixed) |\n| 4 | OOP | P4.1 (Public Property) | W4.1-... [TRUNCATED-04faf063c1a6ac7b]",
"originalFile": "# Code Quality Gates\n\n## Prüfungsreihenfolge\n\n| # | Prinzip | Begründung der Reihenfolge |\n|---|---------|---------------------------|\n| 1 | SRP + KISS | Grundlage für alles. Ohne klare Verantwortung ist nichts anderes prüfbar. |\n| 2 | MVC + CRUD | Strukturelle Trennung. Setzt SRP voraus. |\n| 3 | PSR + Types | Typdisziplin. Muss VOR DIP kommen, weil Interfaces ohne Typen wirkungslos sind. |\n| 4 | OOP | Verhalten + Zustand. Setzt Typen voraus. |\n| 5 | DRY | Duplikationserkennung. Setzt funktionierende Struktur voraus. |\n| 6 | SOLID + DIP | Abhängigkeitsrichtung. Setzt Typen und Interfaces voraus. Kommt zuletzt. |\n\n---\n\n# Prüfung 1: SRP + KISS\n\n## Ziel\n\n**SRP:** Eine Klasse hat genau einen Grund sich zu ändern.\n\n**KISS:** Einfachste Lösung die funktioniert. Keine vorzeitigen Abstraktionen.\n\n## Grundsatz\n\nSRP ist semantisch. Maschinen können \"Verantwortung\" nicht verstehen.\n\nDaher:\n- **Pre-Hook:** Erzwingt explizite Deklaration + blockiert eindeutige Symptome\n- **Post-Hook:** Warnt bei statistischen Indikatoren\n\n---\n\n## Pre-Hook (BLOCK)\n\n### P1.1: Verantwortungs-Header\n\n**Regel:** Jede PHP-Datei muss ihre Verantwortung explizit deklarieren.\n\n**Format:**\n```php\n<?php\ndeclare(strict_types=1);\n\n\/\/ @responsibility: <genau-eine-verantwortung>\n```\n\n**Validierung:**\n\n| Check | Begründung |\n|-------|------------|\n| Header vorhanden | Ohne Deklaration entsteht Scope Creep |\n| Nicht leer | Leerer Header ist wertlos |\n| Keine Multi-Responsibility-Wörter | \"und\", \"sowie\", \"außerdem\", \"zusätzlich\" im Header = mehrere Verantwortungen |\n\n**Pattern:**\n```python\nheader_pattern = r\"\/\/\\s*@responsibility:\\s*(.+)\"\nmulti_words = r\"\\b(und|sowie|außerdem|also|zusätzlich)\\b\"\n\nmatch = re.search(header_pattern, content)\nif not match:\n block(\"Missing @responsibility header\")\n\nresponsibility_text = match.group(1)\nif re.search(multi_words, responsibility_text, re.IGNORECASE):\n block(\"@responsibility contains multi-responsibility indicator\")\n```\n\n**Warum diese Wörter:**\n- \"Validiert Benutzer und erstellt Sessions\" = 2 Verantwortungen\n- \"Lädt Daten sowie formatiert Ausgabe\" = 2 Verantwortungen\n- Erzwingt Nachdenken über Singular-Verantwortung\n\n**Allowlist:** `\/vendor\/`, `\/tests\/`, `\/Test\/`\n\n---\n\n### P1.2: Müllhalden-Namen\n\n**Regel:** Bestimmte Begriffe im Dateinamen sind immer Symptome für fehlende klare Verantwortung.\n\n**Blockiert (case-insensitive):**\n\n| Begriff | Begründung |\n|---------|------------|\n| Helper | \"Hilft bei allem\" = keine klare Verantwortung |\n| Utils | Sammelbecken für Funktionen ohne Heimat |\n| Common | \"Wird überall gebraucht\" = gehört nirgends hin |\n| Misc | Explizit: \"Verschiedenes\" |\n| Base | Oft Gott-Klasse mit Shared-State |\n\n**Nicht blockiert:**\n- \"Manager\" → Kann legitim sein (TransactionManager, EntityManager)\n- \"And\" im Namen → Sprachlich, nicht strukturell\n\n**Pattern:**\n```python\nforbidden = [\"helper\", \"utils\", \"common\", \"misc\", \"base\"]\nfilename_lower = filename.lower()\nfor term in forbidden:\n if term in filename_lower:\n block(f\"Forbidden name: '{term}' indicates unclear responsibility\")\n```\n\n**Keine Ausnahmen.** Diese Begriffe sind niemals architektonisch sauber.\n\n---\n\n## Post-Hook (WARN)\n\n### W1.1: Klassengröße (LOC)\n\n**Regel:** Große Klassen haben oft mehrere Verantwortungen.\n\n| LOC | Aktion |\n|-----|--------|\n| > 200 | Hinweis |\n| > 300 | Warnung |\n\n**Warum zwei Schwellen:**\n- 200: \"Du näherst dich dem Limit\"\n- 300: \"Hier stimmt strukturell etwas nicht\"\n\n**Messung:** Nicht-leere Zeilen.\n\n---\n\n### W1.2: Public-Method-Count\n\n**Regel:** Viele öffentliche Methoden = viele Interaktionspunkte = breite Verantwortung.\n\n| Count | Aktion |\n|-------|--------|\n| > 10 | Warnung |\n\n**Warum 10:**\n- Ein fokussiertes Interface hat 3-7 Methoden\n- 10+ deutet auf Feature Creep\n\n---\n\n### W1.3: Constructor-Parameter\n\n**Regel:** Viele Dependencies = viele Gründe sich zu ändern.\n\n| Count | Aktion |\n|-------|--------|\n| > 5 | Warnung |\n\n**Warum 5:**\n- 1-3: Normal\n- 4-5: Grenzwertig\n- 6+: Fast immer strukturelles Problem\n\n---\n\n### W1.4: Dependency-Count (use-Statements)\n\n**Regel:** Viele Imports = Kopplung an viele Module = viele Änderungsgründe.\n\n| Count | Aktion |\n|-------|--------|\n| > 10 | Warnung |\n\n**Warum 10:**\n- PHP-interne Classes zählen mit\n- Framework-Imports zählen mit\n- 10+ externe Abhängigkeiten ist ein Warnsignal\n\n---\n\n### W1.5: Verdächtige Namen\n\n**Regel:** Manche Begriffe sind nicht eindeutig Müll, aber verdächtig.\n\n| Begriff | Aktion |\n|---------|--------|\n| Manager | Hinweis |\n| And (als Wort) | Hinweis |\n\n**Warum Hinweis statt Block:**\n- \"UserManager\" kann legitim sein\n- \"ReadAndWrite\" kann legitim sein (obwohl fragwürdig)\n- Menschliche Entscheidung erforderlich\n\n---\n\n## Gestrichen\n\n### Verschachtelungstiefe\n\n**Ursprüngliche Idee:** > 4 Ebenen = Warnung\n\n**Warum gestrichen:**\n- Indent-basierte Messung ist nicht zuverlässig\n- PHP erlaubt verschiedene Styles (2, 4, Tabs)\n- Fluent Interfaces erzeugen tiefe Indents ohne Kontrollfluss\n- Array-Definitionen erzeugen tiefe Indents\n- False Positives zu hoch\n\n**Alternative:** Erst implementieren wenn AST-Parsing verfügbar.\n\n---\n\n## Zusammenfassung\n\n### Pre-Hook\n\n| ID | Prüfung | Aktion |\n|----|---------|--------|\n| P1.1 | @responsibility fehlt oder Multi-Responsibility | BLOCK |\n| P1.2 | Müllhalden-Name (Helper, Utils, Common, Misc, Base) | BLOCK |\n\n### Post-Hook\n\n| ID | Prüfung | Schwelle | Aktion |\n|----|---------|----------|--------|\n| W1.1 | LOC | > 300 | WARN |\n| W1.2 | Public Methods | > 10 | WARN |\n| W1.3 | Constructor Params | > 5 | WARN |\n| W1.4 | Dependencies (use) | > 10 | WARN |\n| W1.5 | Verdächtige Namen | Manager, And | HINT |\n\n### Allowlist\n\n| Pfad | Grund |\n|------|-------|\n| \/vendor\/ | Third-party Code |\n| \/tests\/ | Test-Konventionen anders |\n| \/Test\/ | PHPUnit |\n\n---\n\n## Selbstkritik und Entscheidungen\n\n| Frage | Entscheidung | Begründung |\n|-------|--------------|------------|\n| Ist Multi-Word-Check im Header Over-Engineering? | Nein | Ein Regex. Verhindert \"Macht A und B\". Minimaler Aufwand, hoher Nutzen. |\n| Ist Dependency-Count SRP? | Ja | Viele Dependencies = viele Änderungsgründe = SRP-Verletzung per Definition. |\n| Sollen Factories in Allowlist? | Nein | Auch Factories sollten nicht 50 Methoden haben. Wenn zu groß, aufteilen. |\n| Warum keine Kontext-Schwellen für Repositories? | YAGNI | Komplexität ohne klaren Nutzen. Wer > 10 Methoden braucht, soll bewusst entscheiden. |\n\n---\n\n## Implementierung\n\n**Dateien:**\n- `\/var\/www\/tools\/ki-protokoll\/claude-hook\/srp_kiss_guard.py` (Pre-Hook)\n- `\/var\/www\/tools\/ki-protokoll\/claude-hook\/srp_kiss_metrics.py` (Post-Hook)\n\n**Hooks in settings.json:**\n```json\n{\n \"PreToolUse\": [\n {\n \"matcher\": \"Write\",\n \"hooks\": [\n {\n \"type\": \"command\",\n \"command\": \"\/var\/www\/tools\/ki-protokoll\/claude-hook\/srp_kiss_guard.py\",\n \"timeout\": 5\n }\n ]\n }\n ],\n \"PostToolUse\": [\n {\n \"matcher\": \"Write|Edit\",\n \"hooks\": [\n {\n \"type\": \"command\",\n \"command\": \"\/var\/www\/tools\/ki-protokoll\/claude-hook\/srp_kiss_metrics.py\",\n \"timeout\": 5\n }\n ]\n }\n ]\n}\n```\n\n---\n\n# Prüfung 2: MVC + CRUD\n\n## Ziel\n\n**MVC:** Klare Rollentrennung.\n- Controller: Orchestrierung (nimmt Request, ruft UseCase, gibt Response)\n- View: Darstellung (keine Logik)\n- Model: Geschäftslogik (Domain + UseCases)\n\n**CRUD:** Persistenz-Disziplin.\n- Create\/Read\/Update\/Delete gehören in Repository\n- Transaktionen gehören in UseCase oder Repository, nicht Controller\n- Controller orchestriert, persistiert nicht\n\n## Grundsatz\n\nMVC ist strukturell. Die Rollen sind durch Pfade definiert:\n- `\/Controller\/` = Presentation Layer\n- `\/View\/`, `\/templates\/` = Templates\n- `\/Domain\/` = Business Logic\n- `\/UseCases\/`, `\/Application\/` = Application Logic\n- `\/Infrastructure\/Persistence\/` = Repositories\n\n## Abgrenzung zu anderen Prüfungen\n\n| Aspekt | Prüfung | Begründung |\n|--------|---------|------------|\n| Klassen-Größe | 1 (SRP) | Strukturelle Metrik |\n| Methoden-Anzahl | 1 (SRP) | Strukturelle Metrik |\n| Abhängigkeits-Richtung | 6 (DIP) | Dependency Inversion |\n| **Rollen-Einhaltung** | **2 (MVC)** | Controller\/View\/Model Trennung |\n| **Persistenz-Ort** | **2 (CRUD)** | Wer darf DB anfassen |\n\n---\n\n## Pre-Hook (BLOCK)\n\n### P2.1: Keine SQL-Statements in Controller\n\n**Regel:** Controller dürfen keine direkten SQL-Queries enthalten.\n\n**Scope:** `\/Controller\/`\n\n**Pattern:**\n```python\nsql_patterns = [\n r\"\\bSELECT\\s+.+\\s+FROM\\b\",\n r\"\\bINSERT\\s+INTO\\b\",\n r\"\\bUPDATE\\s+\\w+\\s+SET\\b\",\n r\"\\bDELETE\\s+FROM\\b\",\n]\n```\n\n**Warum diese Pattern:**\n- Spezifisch genug um False Positives zu vermeiden\n- `SELECT your country` matcht nicht (kein FROM)\n- `INSERT INTO users` matcht (eindeutig SQL)\n\n**Unterschied zu Prüfung 1\/6:**\n- H-Regeln prüfen Objekte (new Repository, DatabaseFactory)\n- P2.1 prüft String-Literale (SQL-Statements)\n\n---\n\n### P2.2: Keine Transaktionen in Controller\n\n**Regel:** Transaktions-Kontrolle gehört nicht in Controller.\n\n**Scope:** `\/Controller\/`\n\n**Pattern:**\n```python\ntransaction_patterns = [\n r\"\\bbeginTransaction\\s*\\(\",\n r\"\\bcommit\\s*\\(\",\n r\"\\brollBack\\s*\\(\",\n r\"\\brollback\\s*\\(\",\n]\n```\n\n**Begründung:**\n- Transaktionen sind Infrastruktur-Concern\n- Controller soll Request→Response orchestrieren, nicht DB-Konsistenz managen\n- Transaktionen gehören in UseCase oder Repository\n\n---\n\n### P2.3: Kein direktes Rendering in Controller\n\n**Regel:** Controller erzeugen keine direkte Ausgabe.\n\n**Scope:** `\/Controller\/`\n\n**Pattern:**\n```python\noutput_patterns = [\n r\"\\becho\\s\",\n r\"\\becho\\(\",\n r\"\\bprint\\s\",\n r\"\\bprint\\(\",\n]\n```\n\n**Nicht blockiert:**\n- `print_r` (Debug)\n- `printf` (Formatierung, selten)\n- `return json_encode()` (Response-Objekt)\n\n**Begründung:**\n- Output gehört in View oder Response-Objekt\n- echo\/print in Controller = MVC-Verletzung\n- CLI-Code gehört in `\/Console\/` oder `\/Command\/`, nicht `\/Controller\/`\n\n---\n\n### P2.4: Keine DB-Artefakte in UseCases\n\n**Regel:** UseCases nutzen Repository-Interfaces, nicht direkte DB.\n\n**Scope:** `\/UseC... [TRUNCATED-69238a3a852dde42]",
"structuredPatch": [
{
"oldStart": 1341,
"oldLines": 6,
"newStart": 1341,
"newLines": 349,
"lines": [
" ",
" ---",
" ",
"-# Prüfung 6",
"+# Prüfung 6: SOLID + DIP",
" ",
"-*Wird nach Abnahme von Prüfung 5 definiert.*",
"+## Ziel",
"+",
"+**SOLID Prinzipien:**",
"+- **S**ingle Responsibility → bereits in Prüfung 1",
"+- **O**pen\/Closed → Klassen offen für Erweiterung, geschlossen für Modifikation",
"+- **L**iskov Substitution → Unterklassen substituierbar für Oberklassen",
"+- **I**nterface Segregation → Kleine, fokussierte Interfaces",
"+- **D**ependency Inversion → High-level abhängig von Abstraktionen, nicht Implementierungen",
"+",
"+## Grundsatz",
"+",
"+SOLID ist größtenteils semantisch. Nur wenige Aspekte sind per Regex prüfbar:",
"+",
"+| Prinzip | Prüfbar? | Methode |",
"+|---------|----------|---------|",
"+| S | Ja | Prüfung 1 (SRP) |",
"+| O | Nein | Semantisch, erfordert Design-Review |",
"+| L | Nein | Typ-Analyse, PHPStan |",
"+| I | Teilweise | Interface-Größe zählbar |",
"+| D | Teilweise | Import-Richtung prüfbar |",
"+",
"+**Konsequenz:** Prüfung 6 fokussiert auf DIP (Abhängigkeitsrichtung) und ISP (Interface-Größe).",
"+",
"+## Beziehung zu bestehenden H-Regeln",
"+",
"+Die folgenden H-Regeln wurden in früherer Implementierung definiert und gehören konzeptionell zu DIP:",
"+",
"+| H-Regel | Beschreibung | DIP-Aspekt |",
"+|---------|--------------|------------|",
"+| H2 | Domain ohne Infrastructure | Domain kennt keine Implementierung |",
"+| H3 | DatabaseFactory nur in Factory | Erzeugung zentralisiert |",
"+| H4 | Kein new Repository in Controller | Controller nutzt DI |",
"+| H5 | Kein new Infrastructure in Controller | Controller nutzt DI |",
"+",
"+**Diese H-Regeln werden nicht dupliziert.** Prüfung 6 ergänzt um zusätzliche Layer-Regeln.",
"+",
"+## Abgrenzung zu anderen Prüfungen",
"+",
"+| Aspekt | Prüfung | Begründung |",
"+|--------|---------|------------|",
"+| SRP | 1 | Verantwortungstrennung |",
"+| Rollen (MVC) | 2 | Controller\/View\/Model |",
"+| DB-Artefakte in Code | 2 (P2.4) | SQL-Strings, PDO-Nutzung |",
"+| Typen | 3 | Typdisziplin |",
"+| OOP-Integrität | 4 | Verhalten+Zustand |",
"+| **Import-Richtung** | **6 (DIP)** | Layer-Abhängigkeiten |",
"+| **Interface-Größe** | **6 (ISP)** | Fokussierte Interfaces |",
"+",
"+**Unterschied P2.4 vs P6.1:**",
"+- P2.4: Prüft DB-Artefakte im Code (SQL-Strings, PDO, DatabaseFactory)",
"+- P6.1: Prüft Import-Statements (`use Infrastructure\\...`)",
"+",
"+P6.1 ist allgemeiner und fängt auch andere Infrastructure-Abhängigkeiten (HttpClient, FileSystem, etc.).",
"+",
"+---",
"+",
"+## Pre-Hook (BLOCK)",
"+",
"+### P6.1: UseCases\/Application darf Infrastructure nicht importieren",
"+",
"+**Regel:** Application-Layer (UseCases, Application) darf keine Infrastructure direkt importieren.",
"+",
"+**Scope:** `\/UseCases\/`, `\/Application\/`",
"+",
"+**Pattern:**",
"+```python",
"+if \"\/UseCases\/\" in file_path or \"\/Application\/\" in file_path:",
"+ if re.search(r\"use\\s+Infrastructure\\\\\", content):",
"+ block(\"Application layer must not import Infrastructure directly (DIP)\")",
"+```",
"+",
"+**Begründung:**",
"+- DIP: High-level Module (UseCases) sollen von Abstraktionen abhängen",
"+- UseCases definieren WAS passiert",
"+- Infrastructure implementiert WIE (Abstraktionen in Domain\/Contract)",
"+- Import-Verletzung = Dependency in falsche Richtung",
"+",
"+**Was ist erlaubt:**",
"+- `use Domain\\Contract\\UserRepositoryInterface` (Abstraktion)",
"+- `use Domain\\Entity\\User` (Domain-Objekt)",
"+",
"+**Was ist verboten:**",
"+- `use Infrastructure\\Persistence\\MySqlUserRepository`",
"+- `use Infrastructure\\Http\\GuzzleClient`",
"+",
"+---",
"+",
"+### P6.2: Domain darf Application-Layer nicht importieren",
"+",
"+**Regel:** Domain-Layer darf keine Abhängigkeiten zum Application-Layer haben.",
"+",
"+**Scope:** `\/Domain\/`",
"+",
"+**Pattern:**",
"+```python",
"+if \"\/Domain\/\" in file_path:",
"+ if re.search(r\"use\\s+(UseCases|Application)\\\\\", content):",
"+ block(\"Domain must not import Application layer (layer violation)\")",
"+```",
"+",
"+**Begründung:**",
"+- Layer-Richtung: außen → innen",
"+- Domain ist die innerste Schicht",
"+- Domain definiert Geschäftsregeln, kennt keine Orchestrierung",
"+- Zyklische Abhängigkeit wäre fatal",
"+",
"+**Layer-Hierarchie:**",
"+```",
"+Presentation (Controller, View)",
"+ ↓",
"+Application (UseCases)",
"+ ↓",
"+Domain (Entities, Value Objects, Contracts)",
"+ ↓",
"+Infrastructure (Implementations) ← darf alles sehen, wird von niemandem importiert",
"+```",
"+",
"+---",
"+",
"+### P6.3: Infrastructure darf nicht in Domain-Interfaces (gestrichen)",
"+",
"+**Ursprüngliche Idee:** Prüfen ob Domain-Interfaces Infrastructure-Typen als Parameter haben.",
"+",
"+**Warum gestrichen:**",
"+- Erfordert Typ-Analyse",
"+- Interface-Parameter-Parsing per Regex fehleranfällig",
"+- PHPStan kann das besser",
"+",
"+---",
"+",
"+## Post-Hook (WARN)",
"+",
"+### W6.1: Interface mit zu vielen Methoden (ISP)",
"+",
"+**Regel:** Warnung wenn ein Interface mehr als 7 Methoden deklariert.",
"+",
"+**Schwelle:** > 7 Methoden",
"+",
"+**Pattern:**",
"+```python",
"+# Finde Interface-Definitionen",
"+interface_match = re.search(r\"interface\\s+\\w+[^{]*\\{\", content)",
"+if interface_match:",
"+ # Zähle function-Deklarationen (Methoden-Signaturen)",
"+ interface_content = content[interface_match.end():]",
"+ # Bis zur schließenden Klammer",
"+ brace_count = 1",
"+ end_pos = 0",
"+ for i, char in enumerate(interface_content):",
"+ if char == '{':",
"+ brace_count += 1",
"+ elif char == '}':",
"+ brace_count -= 1",
"+ if brace_count == 0:",
"+ end_pos = i",
"+ break",
"+",
"+ interface_body = interface_content[:end_pos]",
"+ method_count = len(re.findall(r\"public\\s+function\\s+\\w+\", interface_body))",
"+",
"+ if method_count > 7:",
"+ warn(f\"Interface has {method_count} methods. Consider splitting (ISP).\")",
"+```",
"+",
"+**Warum 7:**",
"+- 1-5: Normal, fokussiert",
"+- 6-7: Grenzwertig",
"+- 8+: Wahrscheinlich zu breit",
"+",
"+**Begründung:**",
"+- ISP: Clients sollten nicht von Methoden abhängen die sie nicht nutzen",
"+- Große Interfaces zwingen Implementierer zur Stub-Implementierung",
"+- Besser: Mehrere kleine, fokussierte Interfaces",
"+",
"+**Nicht gewarnt:**",
"+- Abstrakte Klassen (haben oft mehr Methoden)",
"+- Traits (mischen Verhalten, andere Semantik)",
"+",
"+---",
"+",
"+### W6.2: Klasse implementiert viele Interfaces",
"+",
"+**Regel:** Warnung wenn eine Klasse mehr als 5 Interfaces implementiert.",
"+",
"+**Pattern:**",
"+```python",
"+implements_match = re.search(r\"implements\\s+([^{]+)\", content)",
"+if implements_match:",
"+ interfaces = implements_match.group(1).split(',')",
"+ if len(interfaces) > 5:",
"+ warn(f\"Class implements {len(interfaces)} interfaces. Potential role confusion.\")",
"+```",
"+",
"+**Warum 5:**",
"+- 1-3: Normal",
"+- 4-5: Grenzwertig",
"+- 6+: Klasse hat zu viele Verantwortungen",
"+",
"+**Warum Warnung:**",
"+- Kann legitim sein (Marker-Interfaces, Framework-Konventionen)",
"+- Aber: Oft Zeichen für SRP-Verletzung",
"+",
"+---",
"+",
"+### W6.3: Konkrete Klasse als Dependency (gestrichen)",
"+",
"+**Ursprüngliche Idee:** Warnung wenn Constructor-Parameter konkrete Klassen statt Interfaces sind.",
"+",
"+**Warum gestrichen:**",
"+- Unterscheidung Interface vs. Klasse per Regex nicht zuverlässig",
"+- Namenskonventionen (XxxInterface, IXxx) nicht universell",
"+- PHPStan ist das richtige Tool",
"+",
"+---",
"+",
"+## Gestrichen",
"+",
"+### Open\/Closed Principle",
"+",
"+**Warum gestrichen:**",
"+- Rein semantisch",
"+- \"Offen für Erweiterung, geschlossen für Modifikation\" erfordert Design-Review",
"+- Keine Regex-basierte Prüfung möglich",
"+",
"+### Liskov Substitution Principle",
"+",
"+**Warum gestrichen:**",
"+- Erfordert Typ-Hierarchie-Analyse",
"+- Prüft ob Unterklassen Verträge der Oberklassen einhalten",
"+- PHPStan kann das (return type covariance, parameter contravariance)",
"+- Hooks können das nicht",
"+",
"+### Interface-Implementierungs-Vollständigkeit",
"+",
"+**Warum gestrichen:**",
"+- PHP-Compiler prüft das bereits",
"+- Hooks wären redundant",
"+",
"+---",
"+",
"+## Zusammenfassung",
"+",
"+### Pre-Hook",
"+",
"+| ID | Prüfung | Scope | Aktion |",
"+|----|---------|-------|--------|",
"+| P6.1 | `use Infrastructure\\` | \/UseCases\/, \/Application\/ | BLOCK |",
"+| P6.2 | `use UseCases\\|Application\\` | \/Domain\/ | BLOCK |",
"+",
"+### Post-Hook",
"+",
"+| ID | Prüfung | Schwelle | Aktion |",
"+|----|---------|----------|--------|",
"+| W6.1 | Interface-Methoden | > 7 | WARN |",
"+| W6.2 | Implementierte Interfaces | > 5 | WARN |",
"+",
"+### Allowlist",
"+",
"+| Pfad | Grund |",
"+|------|-------|",
"+| \/vendor\/ | Third-party |",
"+| \/tests\/ | Test-Code darf Mocks nutzen |",
"+| \/Test\/ | PHPUnit |",
"+| \/Bootstrap\/ | Bootstrap darf alles verdrahten |",
"+| \/Factory\/ | Factories kennen Implementierungen |",
"+",
"+---",
"+",
"+## Layer-Regeln Gesamtübersicht",
"+",
"+Nach allen Prüfungen gelten folgende Layer-Regeln:",
"+",
"+| Layer | Darf importieren | Darf nicht importieren |",
"+|-------|------------------|------------------------|",
"+| Domain | Nichts | UseCases, Application, Infrastructure, Presentation |",
"+| UseCases\/Application | Domain | Infrastructure, Presentation |",
"+| Infrastructure | Domain, Application | Presentation |",
"+| Presentation (Controller) | Domain, Application | - |",
"+| Factory | Alles | - |",
"+",
"+**Durchsetzung:**",
"+- H2: Domain → Infrastructure (architecture_guard)",
"+- P6.2: Domain → Application (Prüfung 6)",
"+- P6.1: Application → Infrastructure (Prüfung 6)",
"+- Controller → Infrastructure: Via DI, nicht direkt (H4, H5)",
"+",
"+---",
"+",
"+## Selbstkritik und Entscheidungen",
"+",
"+| Frage | Entscheidung | Begründung |",
"+|-------|--------------|------------|",
"+| Warum O\/L nicht prüfen? | Nicht per Regex möglich | Semantisch \/ Typ-Analyse |",
"+| Überschneidet P6.1 mit P2.4? | Nein | P2.4 = Code-Artefakte, P6.1 = Imports |",
"+| Warum H-Regeln nicht duplizieren? | Bereits implementiert | Eine Quelle der Wahrheit |",
"+| Ist > 7 Methods zu strikt? | Konservativ | Warnung, nicht Block |",
"+| Warum keine Constructor-Analyse? | Zu fehleranfällig | PHPStan ist besser |",
"+",
"+---",
"+",
"+## SOLID vs. Prüfbarkeit",
"+",
"+| Prinzip | Was Hook kann | Was PHPStan kann |",
"+|---------|---------------|------------------|",
"+| S | Metriken, Header (P1) | - |",
"+| O | Nichts | Nichts (Design-Review) |",
"+| L | Nichts | Return type covariance |",
"+| I | Methodenzahl (W6.1) | - |",
"+| D | Import-Richtung (P6.1, P6.2) | Typ-basierte Analyse |",
"+",
"+**Fazit:** SOLID ist nur teilweise automatisierbar. Hooks prüfen strukturelle Symptome (Imports, Größe). Semantische Prinzipien (O, L) erfordern menschliches Design-Review oder statische Typ-Analyse (PHPStan).",
"+",
"+---",
"+",
"+# Implementierungs-Übersicht",
"+",
"+## Alle Prüfungen",
"+",
"+| # | Prüfung | Pre-Hook (BLOCK) | Post-Hook (WARN) |",
"+|---|---------|------------------|------------------|",
"+| 1 | SRP + KISS | P1.1 (Header), P1.2 (Müllhalden) | W1.1-W1.5 (Metriken) |",
"+| 2 | MVC + CRUD | P2.1-P2.4 (SQL, Trans, echo, DB) | W2.1-W2.2 (Keywords, Private) |",
"+| 3 | PSR + Types | P3.1-P3.4 (strict, NS, Class, Return) | W3.1, W3.3 (Params, mixed) |",
"+| 4 | OOP | P4.1 (Public Property) | W4.1-W4.4 (Anämie, Kapselung) |",
"+| 5 | DRY | - | W5.1-W5.2 (Strings, Numbers) |",
"+| 6 | SOLID + DIP | P6.1-P6.2 (Layer-Imports) | W6.1-W6.2 (Interface-Größe) |",
"+",
"+## Hook-Dateien (geplant)",
"+",
"+| Prüfung | Pre-Hook | Post-Hook |",
"+|---------|----------|-----------|",
"+| 1 | srp_kiss_guard.py | srp_kiss_metrics.py |",
"+| 2 | mvc_crud_guard.py | mvc_crud_metrics.py |",
"+| 3 | psr_types_guard.py | psr_types_metrics.py |",
"+| 4 | oop_guard.py | oop_metrics.py |",
"+| 5 | - | dry_metrics.py |",
"+| 6 | solid_dip_guard.py | solid_dip_metrics.py |",
"+",
"+## Nächste Schritte",
"+",
"+1. Supervision-Abnahme aller 6 Prüfungen",
"+2. Implementierung der Hook-Dateien",
"+3. Registrierung in settings.json",
"+4. Testphase mit echtem Code"
]
}
],
"userModified": false,
"replaceAll": false
}
}