veza/PROMPT_V0101_ITERATIF.md

# 🎯 PROMPT ITÉRATIF V0.101 - Veza Publication Readiness

## INSTRUCTIONS POUR L'IA

Tu es un expert en développement full-stack (Go, React/TypeScript, PostgreSQL). Ta mission est d'amener Veza à la version **v0.101 stable** — une proof of concept parfaite sans dette technique.

### RÈGLES ABSOLUES

1. **TOUJOURS lire `V0101_STATE.json` en premier** pour connaître l'état actuel
2. **TOUJOURS mettre à jour `V0101_STATE.json`** après chaque action
3. **UNE SEULE TÂCHE PAR ITÉRATION** — ne pas sauter d'étapes
4. **VALIDER avant de passer à la suite** — exécuter la commande de validation
5. **DOCUMENTER dans `history`** — chaque itération laisse une trace

### MODULES EXCLUS (v0.101)

- `chat-server/` (Rust) — sera intégré en v0.202
- `stream-server/` (Rust) — sera intégré en v0.202

Ne touche JAMAIS à ces dossiers. Ignore toute erreur les concernant.

---

## WORKFLOW À CHAQUE EXÉCUTION

### ÉTAPE 1 : Lire l'état actuel

```bash
cat V0101_STATE.json | jq '.meta, .objective.current_score, .phases[].status'
```

### ÉTAPE 2 : Identifier la prochaine tâche

Logique de sélection :
1. Chercher la première tâche avec `"status": "TODO"` dans la phase en cours
2. Si toutes les tâches d'une phase sont `DONE`, passer à la phase suivante
3. Si toutes les phases sont `DONE`, passer à la validation finale

### ÉTAPE 3 : Exécuter la tâche

Pour chaque tâche :

1. **Lire les fichiers concernés** (`files_to_check`)
2. **Comprendre le problème** en analysant le code
3. **Implémenter la correction** 
4. **Exécuter la validation** (`validation.command`)
5. **Mettre à jour le JSON** :
   - `status`: `"TODO"` → `"IN_PROGRESS"` → `"DONE"` ou `"BLOCKED"`
   - `validation.actual`: résultat réel
   - `validation.passed`: `true` ou `false`
   - `subtasks[].done`: cocher les sous-tâches terminées
   - `notes`: ajouter observations importantes

### ÉTAPE 4 : Mettre à jour l'historique

Ajouter une entrée dans `history` :

```json
{
  "iteration": 1,
  "timestamp": "2025-01-27T15:30:00Z",
  "task_id": "TASK-001",
  "action": "Description de ce qui a été fait",
  "result": "SUCCESS | PARTIAL | BLOCKED",
  "files_modified": ["path/to/file.go"],
  "next_step": "Ce qu'il reste à faire"
}
```

### ÉTAPE 5 : Recalculer le score

Après chaque tâche terminée :

```
Score = 68 + (tâches_complétées / tâches_totales) * 32
```

Mettre à jour `objective.current_score`.

---

## COMMANDES DE VALIDATION PAR TÂCHE

### TASK-001 : Inscription via UI

```bash
# Test API inscription
API="http://localhost:8080/api/v1"
for i in {1..5}; do
  TS=$(date +%s%N)
  RESULT=$(curl -s -X POST "$API/auth/register" \
    -H "Content-Type: application/json" \
    -d "{\"email\":\"test${TS}@test.com\",\"username\":\"user${TS}\",\"password\":\"SecureP@ss123!\",\"password_confirm\":\"SecureP@ss123!\"}")
  echo "Test $i: $(echo $RESULT | jq -r '.success // .error.message // .')"
done

# Vérifier les erreurs frontend (ouvrir DevTools > Console)
# Tester manuellement : http://localhost:5173/register
```

### TASK-002 : Tests backend

```bash
cd backend
go test ./... -v 2>&1 | tee test_results.txt
# Compter les PASS/FAIL
grep -c "PASS" test_results.txt
grep -c "FAIL" test_results.txt
```

### TASK-003 : Messages d'erreur

```bash
# Tester inscription avec email existant
curl -s -X POST "$API/auth/register" \
  -H "Content-Type: application/json" \
  -d '{"email":"existing@test.com","username":"existing","password":"SecureP@ss123!","password_confirm":"SecureP@ss123!"}'
# Le message doit être spécifique, pas "Failed to create user"

# Tester login avec mauvais password
curl -s -X POST "$API/auth/login" \
  -H "Content-Type: application/json" \
  -d '{"email":"existing@test.com","password":"wrongpassword"}'
# Le message doit être "Email ou mot de passe incorrect"
```

### TASK-004 : Loading states

```bash
# Audit automatique des composants sans loading
cd frontend
grep -rL "isLoading\|loading\|pending" src/pages/ --include="*.tsx" | head -20
# Ces fichiers nécessitent probablement un loading state
```

### TASK-005 : UI upload track

```bash
# Vérifier que le composant a une indication claire
cd frontend
grep -r "required\|obligatoire\|fichier\|audio\|upload" src/pages/tracks/ src/components/tracks/
```

### TASK-006 : Logging

```bash
cd backend
# Chercher les doubles initialisations
grep -rn "NewLogger\|InitLogger\|log.New" --include="*.go" | wc -l
# Doit être 1 seule initialisation

# Chercher les secrets potentiellement loggés
grep -rn "password\|token\|secret" pkg/logger/ internal/middleware/logging.go
```

### TASK-007 : Tests E2E

```bash
cd frontend
npm run test:e2e -- --reporter=list 2>&1 | head -50
```

---

## VALIDATION FINALE v0.101

Quand toutes les tâches sont `DONE`, exécuter :

```bash
#!/bin/bash
echo "=== VALIDATION FINALE v0.101 ==="

# 1. Tests backend
echo "1. Tests backend..."
cd backend && go test ./... -short
BACKEND_TESTS=$?

# 2. Tests E2E
echo "2. Tests E2E..."
cd ../frontend && npm run test:e2e -- --reporter=dot
E2E_TESTS=$?

# 3. Parcours utilisateur complet
echo "3. Parcours utilisateur..."
cd .. && bash test_user_journey.sh
USER_JOURNEY=$?

# 4. Vérification logs
echo "4. Vérification logs..."
cd backend && LOG_LEVEL=error go run cmd/api/main.go &
PID=$!
sleep 5
kill $PID 2>/dev/null

# Résumé
echo ""
echo "=== RÉSUMÉ ==="
echo "Backend tests: $([ $BACKEND_TESTS -eq 0 ] && echo '✅ PASS' || echo '❌ FAIL')"
echo "E2E tests: $([ $E2E_TESTS -eq 0 ] && echo '✅ PASS' || echo '❌ FAIL')"
echo "User journey: $([ $USER_JOURNEY -eq 0 ] && echo '✅ PASS' || echo '❌ FAIL')"

if [ $BACKEND_TESTS -eq 0 ] && [ $E2E_TESTS -eq 0 ] && [ $USER_JOURNEY -eq 0 ]; then
  echo ""
  echo "🎉 v0.101 READY FOR RELEASE!"
  echo "Prochaine étape: git tag v0.101 && git push --tags"
else
  echo ""
  echo "❌ Des corrections sont encore nécessaires"
fi
```

---

## FORMAT DE RÉPONSE ATTENDU

À chaque exécution, réponds avec :

```markdown
## 📍 Itération #N

### État actuel
- Phase: [PHASE-X]
- Tâche en cours: [TASK-XXX]
- Score: XX/100

### Action effectuée
[Description détaillée de ce qui a été fait]

### Fichiers modifiés
- `path/to/file.go` : [description du changement]

### Résultat validation
```
[Output de la commande de validation]
```

### Statut
- [ ] Sous-tâche 1
- [x] Sous-tâche 2
- ...

### Prochaine étape
[Ce qui sera fait à la prochaine itération]

### JSON mis à jour
[Extrait du JSON avec les champs modifiés]
```

---

## DÉMARRER L'ITÉRATION

Commence par :

```bash
# 1. Lire l'état
cat V0101_STATE.json | jq '.'

# 2. Identifier la prochaine tâche TODO
cat V0101_STATE.json | jq '.phases[].tasks[] | select(.status == "TODO") | {id, title, priority}' | head -20

# 3. Commencer le travail sur cette tâche
```

**IMPORTANT** : Ne commence PAS à coder avant d'avoir lu et compris l'état actuel du JSON.

---

## EN CAS DE BLOCAGE

Si une tâche est bloquée :

1. Mettre `status: "BLOCKED"` avec une note explicative
2. Ajouter dans `notes` la raison du blocage
3. Passer à la tâche suivante si possible
4. Signaler le blocage dans la réponse

---

## RAPPEL DES OBJECTIFS v0.101

✅ App fonctionnelle sans modules Rust
✅ Tous les tests passent (Go + E2E)  
✅ UX professionnelle (loading, erreurs, navigation)
✅ Zero dette technique sur le périmètre
✅ Prête pour un tag Git et une release GitHub

**Score cible : 95/100 minimum**

---

*Prompt version 1.0 - Veza v0.101*