mitai-jinkendo/.claude/commands/document.md

192 lines
3.9 KiB
Markdown
Raw Normal View History

# Dokumentation erstellen
Erstelle oder aktualisiere die technisch-fachliche Dokumentation der App.
Lies zuerst den aktuellen Code, dann generiere die Dokumentation.
## Wichtig
- Dokumentation basiert auf dem ECHTEN Code – nicht auf Annahmen
- Jede Datei einzeln erstellen, nicht alles auf einmal
- Bestehende Dateien aktualisieren wenn sie existieren
## Schritt 1: Architektur-Übersicht
Lies folgende Dateien:
- `backend/main.py`
- `backend/db.py`
- `backend/auth.py`
- `backend/schema.sql`
- `frontend/src/App.jsx`
- `frontend/src/app.css`
- `frontend/src/utils/api.js`
- `docker-compose.yml`
Erstelle `.claude/docs/technical/ARCHITECTURE.md` mit:
```markdown
# Architektur-Übersicht – Mitai Jinkendo
## System-Überblick
[Kurze Beschreibung der Gesamtarchitektur]
## Tech-Stack
[Tabelle mit allen Technologien + Versionen]
## Deployment-Architektur
[Infrastruktur: Raspberry Pi, Docker, Synology, Domains]
## Komponenten-Übersicht
[Alle Module/Router mit Kurzbeschreibung]
## Datenfluss
[Wie fließen Daten: Frontend → API → DB]
## Sicherheitsarchitektur
[Auth, CORS, Rate Limiting, bcrypt]
## Versions-Historie
[v9a, v9b, v9c – was wurde wann eingeführt]
```
## Schritt 2: Frontend-Seiten + Komponenten
Lies alle Dateien in:
- `frontend/src/pages/`
- `frontend/src/context/`
- `frontend/src/utils/`
Erstelle `.claude/docs/technical/FRONTEND.md` mit:
```markdown
# Frontend-Dokumentation
## Seiten-Übersicht
[Tabelle: Seite | Route | Beschreibung | Auth erforderlich]
## Komponenten
[Wiederverwendbare Komponenten mit Props]
## Context / State Management
[AuthContext, ProfileContext – was wird wo verwaltet]
## API-Integration (api.js)
[Alle API-Methoden mit Parametern]
## CSS-System
[CSS-Variablen, globale Klassen, Design-Tokens]
## PWA-Konfiguration
[Service Worker, Manifest, Icons]
```
## Schritt 3: Auth-Flow + Sicherheit
Lies:
- `backend/auth.py`
- `backend/routers/auth.py`
- `frontend/src/context/AuthContext.jsx`
Erstelle `.claude/docs/technical/AUTH.md` mit:
```markdown
# Auth-Flow & Sicherheit
## Login-Flow (Schritt für Schritt)
[Sequenz: Frontend → Backend → DB → Token]
## Session-Management
[Token-Format, Lebensdauer, Speicherort]
## Passwort-Sicherheit
[bcrypt, SHA256-Migration, Salting]
## Rate Limiting
[Welche Endpoints, Limits, slowapi-Konfiguration]
## CORS-Konfiguration
[Allowed Origins, Umgebungsvariablen]
## Öffentliche vs. geschützte Endpoints
[Tabelle: Endpoint | Public/Protected | Admin-only]
## Bekannte Sicherheitsentscheidungen
[Warum welche Entscheidung getroffen wurde]
```
## Schritt 4: API-Referenz
Lies alle Dateien in `backend/routers/`.
Erstelle `.claude/docs/technical/API_REFERENCE.md` mit:
```markdown
# API-Referenz
## Basis-URL
- Prod: https://mitai.jinkendo.de/api
- Dev: https://dev.mitai.jinkendo.de/api
## Authentifizierung
[Header-Format, Token-Handling]
## Endpoints nach Modul
### Auth (/api/auth/...)
| Method | Path | Auth | Parameter | Response |
...
### Profile (/api/profiles/...)
...
### Gewicht (/api/weight/...)
...
[alle 14 Router]
## Fehler-Codes
[Standard-Fehlercodes und Bedeutung]
## Rate Limits
[Tabelle: Endpoint | Limit | Zeitfenster]
```
## Schritt 5: Datenbankschema
Lies `backend/schema.sql`.
Erstelle `.claude/docs/technical/DATABASE.md` mit:
```markdown
# Datenbankschema
## Übersicht
[Alle Tabellen mit Kurzbeschreibung]
## Tabellen-Details
[Je Tabelle: Spalten, Typen, Constraints, Indizes]
## Beziehungen
[Foreign Keys, Beziehungsdiagramm als ASCII]
## Migrations-Historie
[Was wurde wann geändert]
## Design-Entscheidungen
[Warum PostgreSQL, warum welche Struktur]
## Wichtige Abfragen
[Häufig verwendete Queries als Referenz]
```
## Nach jeder Datei
Sage mir:
- Welche Datei wurde erstellt/aktualisiert
- Wie viele Zeilen
- Was war überraschend oder unklar im Code
## Starten
Beginne mit Schritt 1 (ARCHITECTURE.md).
Frage nach jedem Schritt ob du weitermachen sollst.
EOF