@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/de/Python/commands/check-architecture.md

@@ -0,0 +1,138 @@
+---
+description: Python-Architektur prüfen
+argument-hint: [arguments]
+---
+
+# Python-Architektur prüfen
+
+## Argumente
+
+$ARGUMENTS (optional: Pfad zum zu analysierenden Projekt)
+
+## MISSION
+
+Führen Sie ein vollständiges Architektur-Audit des Python-Projekts gemäß den in den Projektregeln definierten Clean Architecture- und Hexagonal Architecture-Prinzipien durch.
+
+### Schritt 1: Projektstruktur analysieren
+
+Untersuchen Sie die Verzeichnisstruktur und identifizieren Sie:
+- [ ] Vorhandensein von Domain/Application/Infrastructure/Presentation-Layern
+- [ ] Klare Trennung zwischen Layern (keine invertierten Abhängigkeiten)
+- [ ] Organisation der Module nach Geschäftsdomäne
+- [ ] Package-Struktur konsistent mit Architekturregeln
+
+**Referenz**: `rules/02-architecture.md` Abschnitte "Clean Architecture" und "Hexagonal Architecture"
+
+### Schritt 2: Abhängigkeiten zwischen Layern überprüfen
+
+Analysieren Sie Imports und Abhängigkeiten:
+- [ ] Domain hängt von keinem anderen Layer ab
+- [ ] Application hängt nur von Domain ab
+- [ ] Infrastructure hängt nur von Domain und Application ab
+- [ ] Presentation enthält keine Geschäftslogik
+- [ ] Dependency Rule eingehalten (nur nach innen)
+
+**Überprüfen**: Keine Imports von externen Layern in Domain/Application
+
+### Schritt 3: Interfaces und Ports
+
+Überprüfen Sie die Implementierung von Ports und Adaptern:
+- [ ] Interfaces (Ports) in Domain/Application definiert
+- [ ] Implementierungen (Adapter) in Infrastructure
+- [ ] Verwendung von Dependency Injection
+- [ ] Keine enge Kopplung mit externen Frameworks
+
+**Referenz**: `rules/02-architecture.md` Abschnitt "Ports and Adapters"
+
+### Schritt 4: Entities und Value Objects
+
+Prüfen Sie Domain-Modellierung:
+- [ ] Reichhaltige Entities mit gekapselter Geschäftslogik
+- [ ] Unveränderliche Value Objects
+- [ ] Ordnungsgemäß abgegrenzte Aggregate
+- [ ] Domain Events falls zutreffend
+- [ ] Keine Infrastructure-Logik in Entities
+
+**Referenz**: `rules/02-architecture.md` Abschnitt "Domain Layer"
+
+### Schritt 5: Services und Use Cases
+
+Analysieren Sie die Organisation der Anwendungslogik:
+- [ ] Use Cases/Application Services klar identifiziert
+- [ ] Ein Use Case = Eine Geschäftsaktion
+- [ ] Domain Services für komplexe Geschäftslogik
+- [ ] Keine Geschäftslogik in Controllern/Handlern
+- [ ] Transaktionen auf Application-Ebene verwaltet
+
+**Referenz**: `rules/02-architecture.md` Abschnitt "Application Layer"
+
+### Schritt 6: SOLID-Prinzipien
+
+Überprüfen Sie die Anwendung der SOLID-Prinzipien:
+- [ ] Single Responsibility: Eine Klasse = Ein Grund zur Änderung
+- [ ] Open/Closed: Erweiterung durch Vererbung/Komposition, nicht Änderung
+- [ ] Liskov Substitution: Subtypen sind substituierbar
+- [ ] Interface Segregation: Spezifische und minimale Schnittstellen
+- [ ] Dependency Inversion: Abhängigkeit von Abstraktionen
+
+**Referenz**: `rules/04-solid-principles.md`
+
+### Schritt 7: Bewertung berechnen
+
+Punktevergabe (von 25):
+- Struktur und Layer-Trennung: 6 Punkte
+- Dependency-Einhaltung: 6 Punkte
+- Ports und Adapter: 4 Punkte
+- Domain-Modellierung: 4 Punkte
+- Use Cases und Services: 3 Punkte
+- SOLID-Prinzipien: 2 Punkte
+
+## AUSGABEFORMAT
+
+```
+PYTHON-ARCHITEKTUR-AUDIT
+================================
+
+GESAMTBEWERTUNG: XX/25
+
+STÄRKEN:
+- [Liste der identifizierten positiven Punkte]
+
+VERBESSERUNGEN:
+- [Liste geringfügiger Verbesserungen]
+
+KRITISCHE PROBLEME:
+- [Liste schwerwiegender Architektumverletzungen]
+
+DETAILS NACH KATEGORIE:
+
+1. STRUKTUR UND LAYER (XX/6)
+   Status: [Details der Struktur]
+
+2. ABHÄNGIGKEITEN (XX/6)
+   Status: [Abhängigkeitsanalyse]
+
+3. PORTS UND ADAPTER (XX/4)
+   Status: [Interface-Implementierung]
+
+4. DOMAIN-MODELLIERUNG (XX/4)
+   Status: [Qualität der Entities und VOs]
+
+5. USE CASES (XX/3)
+   Status: [Organisation der Anwendungslogik]
+
+6. SOLID-PRINZIPIEN (XX/2)
+   Status: [Anwendung der SOLID-Prinzipien]
+
+TOP 3 PRIORITÄTS-AKTIONEN:
+1. [Kritischste Aktion mit geschätzter Auswirkung]
+2. [Zweite Prioritätsaktion]
+3. [Dritte Prioritätsaktion]
+```
+
+## HINWEISE
+
+- `grep`, `find` und Code-Analyse verwenden, um Verletzungen zu erkennen
+- Konkrete Beispiele problematischer Dateien/Klassen bereitstellen
+- Präzise Refactorings für jedes identifizierte Problem vorschlagen
+- Aktionen nach Wartbarkeitsauswirkung priorisieren

package/Dev/i18n/de/Python/commands/check-code-quality.md

@@ -0,0 +1,174 @@
+---
+description: Python-Codequalität prüfen
+argument-hint: [arguments]
+---
+
+# Python-Codequalität prüfen
+
+## Argumente
+
+$ARGUMENTS (optional: Pfad zum zu analysierenden Projekt)
+
+## MISSION
+
+Führen Sie ein vollständiges Codequalitäts-Audit des Python-Projekts durch, indem Sie PEP8-Konformität, Typisierung, Lesbarkeit und in den Projektregeln definierte Best Practices überprüfen.
+
+### Schritt 1: PEP8-Codierungsstandards
+
+Überprüfen Sie die Einhaltung der Python-Konventionen:
+- [ ] Benennung: snake_case für Funktionen/Variablen, PascalCase für Klassen
+- [ ] Einrückung: 4 Leerzeichen (keine Tabs)
+- [ ] Zeilenlänge: maximal 88 Zeichen (Black)
+- [ ] Imports: organisiert (stdlib, third-party, lokal) und sortiert
+- [ ] Leerzeichen: um Operatoren, nach Kommas
+- [ ] Docstrings: vorhanden für Module, Klassen, öffentliche Funktionen
+
+**Befehl**: `docker run --rm -v $(pwd):/app python:3.11 python -m flake8 /app --max-line-length=88`
+
+**Referenz**: `rules/03-coding-standards.md` Abschnitt "PEP 8 Compliance"
+
+### Schritt 2: Type Hints und MyPy
+
+Prüfen Sie die Verwendung statischer Typisierung:
+- [ ] Type Hints auf allen Funktionsparametern
+- [ ] Type Hints auf Rückgabewerten
+- [ ] Annotationen für Klassenattribute
+- [ ] Verwendung von `typing` für komplexe Typen (Optional, Union, List, Dict)
+- [ ] Keine MyPy-Fehler im Strict-Modus
+
+**Befehl**: `docker run --rm -v $(pwd):/app python:3.11 python -m mypy /app --strict`
+
+**Referenz**: `rules/03-coding-standards.md` Abschnitt "Type Hints"
+
+### Schritt 3: Linting mit Ruff
+
+Code mit Ruff analysieren (ersetzt Flake8, isort, pydocstyle):
+- [ ] Keine ungenutzten Imports
+- [ ] Keine ungenutzten Variablen
+- [ ] Kein toter Code (unerreichbarer Code)
+- [ ] Akzeptable zyklomatische Komplexität (<10)
+- [ ] Sicherheitsregeln eingehalten (S-Regeln)
+
+**Befehl**: `docker run --rm -v $(pwd):/app python:3.11 pip install ruff && ruff check /app`
+
+**Referenz**: `rules/06-tooling.md` Abschnitt "Linting and Formatting"
+
+### Schritt 4: Formatierung mit Black
+
+Formatierungskonsistenz überprüfen:
+- [ ] Code mit Black formatiert
+- [ ] Black-Konfiguration in pyproject.toml
+- [ ] Keine Unterschiede nach `black --check`
+- [ ] Konsistente Zeilenlänge (88 Zeichen)
+
+**Befehl**: `docker run --rm -v $(pwd):/app python:3.11 pip install black && black --check /app`
+
+**Referenz**: `rules/06-tooling.md` Abschnitt "Code Formatting"
+
+### Schritt 5: KISS, DRY, YAGNI-Prinzipien
+
+Code-Einfachheit und -Klarheit analysieren:
+- [ ] Kurze Funktionen (<20 Zeilen idealerweise)
+- [ ] Keine Code-Duplikation (DRY)
+- [ ] Keine Überentwicklung (YAGNI)
+- [ ] Explizite und selbstdokumentierende Benennung
+- [ ] Einzelne Abstraktionsebene pro Funktion
+- [ ] Frühe Returns zur Komplexitätsreduzierung
+
+**Referenz**: `rules/05-kiss-dry-yagni.md`
+
+### Schritt 6: Kommentare und Dokumentation
+
+Dokumentationsqualität bewerten:
+- [ ] Google- oder NumPy-Stil Docstrings
+- [ ] Kommentare nur für "Warum", nicht "Was"
+- [ ] Vollständiges README.md mit Setup und Verwendung
+- [ ] Kein auskommentierter Code (git verwenden)
+- [ ] Dokumentation wichtiger Architekturentscheidungen
+
+**Referenz**: `rules/03-coding-standards.md` Abschnitt "Documentation"
+
+### Schritt 7: Fehlerbehandlung
+
+Code-Robustheit überprüfen:
+- [ ] Spezifische Exceptions (nicht generisch Exception)
+- [ ] Kein stilles `pass` in except
+- [ ] Informative Fehlermeldungen
+- [ ] Benutzereingabe-Validierung
+- [ ] Ordnungsgemäße Ressourcenverwaltung (Context Manager)
+
+**Referenz**: `rules/03-coding-standards.md` Abschnitt "Error Handling"
+
+### Schritt 8: Bewertung berechnen
+
+Punktevergabe (von 25):
+- PEP8 und Formatierung: 5 Punkte
+- Type Hints und MyPy: 5 Punkte
+- Ruff-Linting: 4 Punkte
+- KISS/DRY/YAGNI: 4 Punkte
+- Dokumentation: 4 Punkte
+- Fehlerbehandlung: 3 Punkte
+
+## AUSGABEFORMAT
+
+```
+PYTHON-CODEQUALITÄTS-AUDIT
+================================
+
+GESAMTBEWERTUNG: XX/25
+
+STÄRKEN:
+- [Liste beobachteter guter Praktiken]
+
+VERBESSERUNGEN:
+- [Liste geringfügiger Verbesserungen]
+
+KRITISCHE PROBLEME:
+- [Liste schwerwiegender Standards-Verletzungen]
+
+DETAILS NACH KATEGORIE:
+
+1. PEP8 UND FORMATIERUNG (XX/5)
+   Status: [Python-Standards-Konformität]
+   Flake8-Fehler: XX
+   Black-Unterschiede: XX Dateien
+
+2. TYPE HINTS (XX/5)
+   Status: [Statische Typisierungsabdeckung]
+   MyPy-Fehler: XX
+   Abdeckung: XX%
+
+3. RUFF-LINTING (XX/4)
+   Status: [Codequalität]
+   Warnungen: XX
+   Ungenutzte Imports: XX
+   Max. Komplexität: XX
+
+4. KISS/DRY/YAGNI (XX/4)
+   Status: [Einfachheit und Klarheit]
+   Funktionen >20 Zeilen: XX
+   Duplizierter Code: XX Instanzen
+
+5. DOKUMENTATION (XX/4)
+   Status: [Dokumentationsqualität]
+   Fehlende Docstrings: XX
+   Abdeckung: XX%
+
+6. FEHLERBEHANDLUNG (XX/3)
+   Status: [Code-Robustheit]
+   Generische Exceptions: XX
+   `except pass`: XX
+
+TOP 3 PRIORITÄTS-AKTIONEN:
+1. [Kritischste Aktion zur Qualitätsverbesserung]
+2. [Zweite Prioritätsaktion]
+3. [Dritte Prioritätsaktion]
+```
+
+## HINWEISE
+
+- Alle verfügbaren Linting-Tools im Projekt ausführen
+- Docker verwenden, um von lokaler Umgebung zu abstrahieren
+- Beispiele problematischer Dateien/Zeilen bereitstellen
+- Automatisierbare Korrekturen vorschlagen (Pre-Commit-Hooks)
+- Quick Wins (Auto-Formatierung) vs. tiefes Refactoring priorisieren

package/Dev/i18n/de/Python/commands/check-compliance.md

@@ -0,0 +1,84 @@
+---
+description: Vollständige Python-Konformität prüfen
+argument-hint: [arguments]
+---
+
+# Vollständige Python-Konformität prüfen
+
+## Argumente
+
+$ARGUMENTS (optional: Pfad zum zu analysierenden Projekt)
+
+## MISSION
+
+Führen Sie ein vollständiges Konformitäts-Audit des Python-Projekts durch, indem Sie die 4 Hauptprüfungen orchestrieren: Architektur, Codequalität, Tests und Sicherheit. Erstellen Sie einen konsolidierten Bericht mit einer Gesamtbewertung von 100 Punkten.
+
+### Schritt 1: Audit-Vorbereitung
+
+Audit-Umgebung vorbereiten:
+- [ ] Zu prüfenden Projektpfad identifizieren
+- [ ] Vorhandensein von Konfigurationsdateien überprüfen (pyproject.toml, requirements.txt)
+- [ ] Hauptverzeichnisse auflisten (src/, tests/, etc.)
+- [ ] Projektstruktur identifizieren
+
+**Hinweis**: Wenn $ARGUMENTS angegeben, als Projektpfad verwenden, andernfalls aktuelles Verzeichnis.
+
+### Schritt 2: Architektur-Audit (25 Punkte)
+
+Vollständige Architekturprüfung ausführen:
+
+**Befehl**: Slash-Befehl `/check-architecture` verwenden oder Schritte in `check-architecture.md` manuell folgen
+
+**Bewertete Kriterien**:
+- Struktur und Layer-Trennung (6 Pkt)
+- Dependency-Einhaltung (6 Pkt)
+- Ports und Adapter (4 Pkt)
+- Domain-Modellierung (4 Pkt)
+- Use Cases und Services (3 Pkt)
+- SOLID-Prinzipien (2 Pkt)
+
+**Referenz**: `claude-commands/python/check-architecture.md`
+
+### Schritt 3-6: [Weitere Audits...]
+
+### Schritt 7: Empfehlungen und Aktionsplan
+
+Endgültige Empfehlungen erstellen:
+- [ ] Top 3 Prioritätsaktionen über alle Kategorien identifizieren
+- [ ] Aufwand (Niedrig/Mittel/Hoch) für jede Aktion schätzen
+- [ ] Auswirkung (Niedrig/Mittel/Hoch) für jede Aktion schätzen
+- [ ] Implementierungsreihenfolge vorschlagen
+- [ ] Quick Wins vorschlagen (hohes Auswirkungs-/Aufwandsverhältnis)
+
+## AUSGABEFORMAT
+
+```
+PYTHON-KONFORMITÄTS-AUDIT - VOLLSTÄNDIGER BERICHT
+=============================================
+
+GESAMTBEWERTUNG: XX/100
+
+KONFORMITÄTSSTUFE: [Exzellent/Sehr gut/Akzeptabel/Unzureichend/Kritisch]
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+BEWERTUNGEN NACH KATEGORIE:
+
+ARCHITEKTUR       : XX/25  [██████████░░░░░░░░░░] XX%
+CODEQUALITÄT      : XX/25  [██████████░░░░░░░░░░] XX%
+TESTS             : XX/25  [██████████░░░░░░░░░░] XX%
+SICHERHEIT        : XX/25  [██████████░░░░░░░░░░] XX%
+
+[...]
+```
+
+## WICHTIGE HINWEISE
+
+- Dieser Befehl orchestriert die 4 spezialisierten Audits
+- Docker für alle Analyse-Tools verwenden
+- Konkrete Beispiele mit Datei:Zeile für jedes Problem bereitstellen
+- Aktionen nach Impact/Effort-Matrix priorisieren
+- Sicherheitsprobleme haben IMMER höchste Priorität
+- Automatisierbare Korrekturen vorschlagen (Skripte, Pre-Commit-Hooks)
+- Bericht muss umsetzbar sein, nicht nur beschreibend
+- Empfehlungen an Geschäftskontext des Projekts anpassen

package/Dev/i18n/de/Python/commands/check-security.md

@@ -0,0 +1,91 @@
+---
+description: Python-Sicherheit prüfen
+argument-hint: [arguments]
+---
+
+# Python-Sicherheit prüfen
+
+## Argumente
+
+$ARGUMENTS (optional: Pfad zum zu analysierenden Projekt)
+
+## MISSION
+
+Führen Sie ein vollständiges Sicherheits-Audit des Python-Projekts durch, indem Sie Schwachstellen, offengelegte Geheimnisse und in den Projektregeln definierte Sicherheits-Bad-Practices identifizieren.
+
+### Schritt 1: Sicherheitsanalyse mit Bandit
+
+Code mit Bandit scannen, um Schwachstellen zu erkennen:
+- [ ] Keine fest codierten Passwörter/Geheimnisse
+- [ ] Keine Verwendung von `eval()` oder `exec()`
+- [ ] Keine unsichere Deserialisierung (pickle)
+- [ ] Keine SQL-Injection (ORM oder parametrisierte Abfragen)
+- [ ] Keine Shell-Befehlsinjektion
+- [ ] Sichere Kryptographie (nicht MD5/SHA1)
+
+**Befehl**: `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install bandit && bandit -r /app -f json"`
+
+**Referenz**: `rules/06-tooling.md` Abschnitt "Security Analysis"
+
+### Schritt 2: Geheimnis-Erkennung
+
+Nach Geheimnissen und Anmeldedaten im Code suchen:
+- [ ] Keine API-Schlüssel im Quellcode
+- [ ] Keine Token in Dateien
+- [ ] Keine Passwörter im Klartext
+- [ ] Umgebungsvariablen für sensible Konfiguration
+- [ ] .env in .gitignore
+- [ ] .env.example bereitgestellt (ohne echte Werte)
+
+**Befehl**: grep/Suche verwenden, um Geheimnismuster zu erkennen
+
+**Zu suchende Muster**:
+- `password\s*=\s*["'][^"']+["']`
+- `api_key\s*=\s*["'][^"']+["']`
+- `secret\s*=\s*["'][^"']+["']`
+- `token\s*=\s*["'][^"']+["']`
+
+**Referenz**: `rules/03-coding-standards.md` Abschnitt "Security Best Practices"
+
+### Schritt 3-9: [Weitere Sicherheitsprüfungen...]
+
+### Schritt 9: Bewertung berechnen
+
+Punktevergabe (von 25):
+- Bandit (Schwachstellen): 6 Punkte
+- Geheimnisse und Anmeldedaten: 5 Punkte
+- Eingabevalidierung: 4 Punkte
+- Sichere Abhängigkeiten: 4 Punkte
+- Fehlerbehandlung: 3 Punkte
+- Auth/Authz: 2 Punkte
+- Injection/XSS: 1 Punkt
+
+## AUSGABEFORMAT
+
+```
+PYTHON-SICHERHEITS-AUDIT
+================================
+
+GESAMTBEWERTUNG: XX/25
+
+STÄRKEN:
+- [Liste beobachteter Sicherheits-Good-Practices]
+
+VERBESSERUNGEN:
+- [Liste geringfügiger Sicherheitsverbesserungen]
+
+KRITISCHE PROBLEME:
+- [Liste kritischer Schwachstellen, die SOFORT behoben werden müssen]
+
+[...]
+```
+
+## HINWEISE
+
+- Sicherheitsprobleme MÜSSEN mit absoluter Priorität behandelt werden
+- Docker zum Ausführen von Sicherheitstools verwenden
+- Genaue Datei und Zeile für jede Schwachstelle bereitstellen
+- Konkrete Korrekturen für jedes Problem vorschlagen
+- Risiken und potenzielle Auswirkungen dokumentieren
+- Vorgeschlagene Fixes testen
+- NIEMALS Geheimnisse im Code committen

package/Dev/i18n/de/Python/commands/check-testing.md

@@ -0,0 +1,79 @@
+---
+description: Python-Testing prüfen
+argument-hint: [arguments]
+---
+
+# Python-Testing prüfen
+
+## Argumente
+
+$ARGUMENTS (optional: Pfad zum zu analysierenden Projekt)
+
+## MISSION
+
+Führen Sie ein vollständiges Audit der Teststrategie des Python-Projekts durch, indem Sie Coverage, Testqualität und Einhaltung der in den Projektregeln definierten Best Practices überprüfen.
+
+### Schritt 1: Struktur und Test-Organisation
+
+Test-Organisation untersuchen:
+- [ ] `tests/` Ordner im Projektstamm
+- [ ] Spiegelstruktur des Quellcodes (tests/domain, tests/application, etc.)
+- [ ] Testdateien benannt `test_*.py` oder `*_test.py`
+- [ ] Pytest-Fixtures in `conftest.py`
+- [ ] Trennung von Unit- / Integrations- / E2E-Tests
+
+**Referenz**: `rules/07-testing.md` Abschnitt "Test Organization"
+
+### Schritt 2: Code-Coverage
+
+Test-Coverage messen:
+- [ ] Gesamt-Coverage ≥ 80%
+- [ ] Domain-Layer-Coverage ≥ 90%
+- [ ] Application-Layer-Coverage ≥ 85%
+- [ ] Kritische Dateien bei 100%
+- [ ] Coverage-Konfiguration in pyproject.toml
+
+**Befehl**: `docker run --rm -v $(pwd):/app python:3.11 sh -c "pip install pytest pytest-cov && pytest /app --cov=/app --cov-report=term-missing"`
+
+**Referenz**: `rules/07-testing.md` Abschnitt "Code Coverage"
+
+### Schritt 3-9: [Weitere Testprüfungen...]
+
+### Schritt 9: Bewertung berechnen
+
+Punktevergabe (von 25):
+- Code-Coverage: 7 Punkte
+- Unit-Tests: 6 Punkte
+- Integrationstests: 4 Punkte
+- Assertion-Qualität: 3 Punkte
+- Fixtures und Organisation: 3 Punkte
+- Performance: 2 Punkte
+
+## AUSGABEFORMAT
+
+```
+PYTHON-TESTING-AUDIT
+================================
+
+GESAMTBEWERTUNG: XX/25
+
+STÄRKEN:
+- [Liste beobachteter guter Testpraktiken]
+
+VERBESSERUNGEN:
+- [Liste geringfügiger Verbesserungen]
+
+KRITISCHE PROBLEME:
+- [Liste kritischer Testlücken]
+
+[...]
+```
+
+## HINWEISE
+
+- pytest mit Coverage ausführen, um Metriken zu erhalten
+- Docker verwenden, um von lokaler Umgebung zu abstrahieren
+- Kritische Dateien ohne Tests identifizieren
+- Fehlende Tests für Schlüsselfunktionalitäten vorschlagen
+- Konkrete Verbesserungen für bestehende Tests vorschlagen
+- Tests nach Geschäftsrisiko priorisieren

package/Dev/i18n/de/Python/commands/dependency-audit.md

@@ -0,0 +1,64 @@
+---
+description: Python Dependency-Audit
+argument-hint: [arguments]
+---
+
+# Python Dependency-Audit
+
+Sie sind ein Python-Sicherheitsexperte. Sie müssen Projektabhängigkeiten auf Schwachstellen, veraltete Pakete und Lizenzprobleme prüfen.
+
+## Argumente
+$ARGUMENTS
+
+Argumente:
+- (Optional) Fokus: security, outdated, licenses, all
+
+Beispiel: `/python:dependency-audit security` oder `/python:dependency-audit all`
+
+## MISSION
+
+### Schritt 1: Konfiguration identifizieren
+
+```bash
+# Mögliche Abhängigkeitsdateien
+ls -la requirements*.txt pyproject.toml setup.py Pipfile poetry.lock
+
+# Installierte Abhängigkeiten auflisten
+pip list --format=json
+pip freeze
+```
+
+### Schritt 2: Sicherheits-Audit
+
+```bash
+# pip-audit verwenden (empfohlen)
+pip install pip-audit
+pip-audit
+
+# Oder safety (Alternative)
+pip install safety
+safety check -r requirements.txt
+
+# Oder mit nativem pip (Python 3.12+)
+pip audit
+```
+
+### Schritt 3-6: [Weitere Prüfungen...]
+
+### Schritt 6: Bericht generieren
+
+```
+══════════════════════════════════════════════════════════════
+📦 PYTHON DEPENDENCY-AUDIT
+══════════════════════════════════════════════════════════════
+
+──────────────────────────────────────────────────────────────
+🔒 SICHERHEITSSCHWACHSTELLEN
+──────────────────────────────────────────────────────────────
+
+| Paket | Version | CVE | Schwere | Behoben in |
+|---------|---------|-----|----------|----------|
+| requests | 2.25.0 | CVE-2023-32681 | HIGH | 2.31.0 |
+
+[...]
+```

package/Dev/i18n/de/Python/commands/generate-endpoint.md

@@ -0,0 +1,68 @@
+---
+description: FastAPI-Endpoint generieren
+argument-hint: [arguments]
+---
+
+# FastAPI-Endpoint generieren
+
+Sie sind ein erfahrener Python-Entwickler. Sie müssen einen vollständigen FastAPI-Endpoint mit Pydantic-Validierung, Fehlerbehandlung und Tests generieren.
+
+## Argumente
+$ARGUMENTS
+
+Argumente:
+- Ressourcenname (z.B. `user`, `product`, `order`)
+- (Optional) Typ (crud, list, detail, action)
+
+Beispiel: `/python:generate-endpoint user crud`
+
+## MISSION
+
+### Schritt 1: Endpoint-Struktur
+
+```
+app/
+├── api/
+│   └── v1/
+│       └── endpoints/
+│           └── {resource}.py
+├── schemas/
+│   └── {resource}.py
+├── crud/
+│   └── {resource}.py
+├── models/
+│   └── {resource}.py
+└── tests/
+    └── api/
+        └── v1/
+            └── test_{resource}.py
+```
+
+### Schritt 2-7: [Generierungsschritte...]
+
+### Zusammenfassung
+
+```
+══════════════════════════════════════════════════════════════
+✅ ENDPOINT GENERIERT - {resource}
+══════════════════════════════════════════════════════════════
+
+📁 Erstellte Dateien:
+- app/models/{resource}.py
+- app/schemas/{resource}.py
+- app/crud/{resource}.py
+- app/api/v1/endpoints/{resource}.py
+- app/tests/api/v1/test_{resource}.py
+
+🔗 Verfügbare Endpoints:
+- GET    /api/v1/{resource}s/     - Paginierte Liste
+- POST   /api/v1/{resource}s/     - Erstellung
+- GET    /api/v1/{resource}s/{id} - Detail
+- PATCH  /api/v1/{resource}s/{id} - Aktualisierung
+- DELETE /api/v1/{resource}s/{id} - Löschung
+
+🔧 Nächste Schritte:
+1. Router zu app/api/v1/api.py hinzufügen
+2. Alembic-Migration erstellen
+3. Tests ausführen: pytest app/tests/api/v1/test_{resource}.py
+```