mitai-jinkendo/.claude/commands/document.md
Lars 7940dc7560 docs: Struktur .claude/docs versionieren, working/, Gitea-Index, Regeln
- .gitignore: .claude/docs, rules, commands tracken; settings.local weiter ignorieren
- DOCUMENTATION.md: verbindliche Ablage functional/technical/working/issues
- .claude/README.md: Agent-Einstieg; GITEA_ISSUES_INDEX aus MCP (Stand 2026-04-08)
- Arbeitspapiere von docs/ nach .claude/docs/working/ verschoben
- docs/MEMBERSHIP_SYSTEM.md als Stub; kanonisch technical/MEMBERSHIP_SYSTEM.md
- CLAUDE.md Pflichtlektüre und Links angepasst; docs/README.md vereinfacht

Made-with: Cursor
2026-04-08 13:01:49 +02:00

192 lines
3.9 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# 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