# 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