SimpleClient-releases/.claude/commands/dev.md

# Workflow de développement SimpleConnect

Guide complet de A à Z pour le développement et la publication de nouvelles versions.

---

## 📑 Table des matières

1. [Résumé rapide](#résumé-rapide)
2. [Phase 1 : Développement itératif](#phase-1--développement-itératif)
3. [Phase 2 : Préparation de la release](#phase-2--préparation-de-la-release)
4. [Phase 3 : Fusion dans main](#phase-3--fusion-dans-main)
5. [Phase 4 : Build des exécutables](#phase-4--build-des-exécutables)
6. [Phase 5 : Documentation](#phase-5--documentation)
7. [Phase 6 : Publication sur Gitea](#phase-6--publication-sur-gitea)
8. [Phase 7 : Déploiement](#phase-7--déploiement-optionnel)
9. [Phase 8 : Nettoyage](#phase-8--nettoyage-des-branches)
10. [Référence des commandes](#référence-des-commandes)

---

## Résumé rapide

```
Phase 1 : Développement
  1. Créer branche feature
  2. Développer → Tester → Committer (répéter)

Phase 2 : Release
  3. Mettre à jour changelog
  4. Bumper version package.json
  5. Commit de release

Phase 3 : Fusion
  6. Merger dans main (--no-ff)
  7. Push vers origin

Phase 4 : Build
  8. Build exécutables (macOS, Linux, Windows)
  9. Organiser dans dist/vX.X.X/

Phase 5 : Documentation
  10. Créer notes de release
  11. Commit + push docs

Phase 6 : Publication
  12. Créer tag Git
  13. Push tag vers Gitea
  14. Créer release avec tea
  15. Vérifier assets

Phase 7 : Déploiement (optionnel)
  16. Déployer sur serveur

Phase 8 : Nettoyage
  17. Supprimer branches locales mergées
  18. Supprimer branches distantes mergées
  19. Prune références locales
```

---

## Phase 1 : Développement itératif

### Principe : Petit à petit, commit par commit

**Une fonctionnalité = plusieurs petits commits atomiques**

Découper le travail en petites étapes testables plutôt qu'un gros commit :

```
Exemple : Ajouter un bouton "Pause" avec confirmation

❌ MAUVAIS : 1 gros commit
git commit -m "feat: Ajouter bouton Pause avec modal et gestion IPBX"

✅ BON : 5 petits commits
1. feat: Ajouter le bouton Pause dans le header
2. style: Ajouter l'icône SVG pour le bouton Pause
3. feat: Implémenter la modal de confirmation
4. feat: Connecter le bouton à SignalR pour pause IPBX
5. docs: Documenter la fonctionnalité de pause
```

### Étape 1 : Créer une branche feature

```bash
git checkout -b feature/nom-de-la-fonctionnalite
```

### Étape 2 : Cycle itératif

Répéter jusqu'à complétion de la fonctionnalité :

#### a) Développer une petite partie
- Faire UNE modification logique à la fois
- Ne pas chercher à tout finir d'un coup
- Rester concentré sur une seule tâche

#### b) Tester

**IMPORTANT : Toujours tester AVANT de committer**

```bash
npm run dev  # Test en mode développement
```

- Vérifier que la modification fonctionne
- Tester les cas limites
- S'assurer qu'aucune régression n'a été introduite

#### c) Committer

Seulement après avoir testé avec succès :

```bash
git commit -m "feat: Ajouter le bouton Pause dans le header"
```

**Préfixes de commit** : `feat:`, `fix:`, `refactor:`, `docs:`, `style:`, `test:`, `chore:`

**Pourquoi tester avant de committer ?**
- Historique Git propre (chaque commit = code fonctionnel)
- Rollback facile vers un état stable
- `git bisect` fonctionne correctement

#### d) Continuer

Retour à l'étape **a)** jusqu'à ce que la fonctionnalité soit complète.

### Exception : WIP commits

Pour sauvegarder un travail en cours :

```bash
git commit -m "wip: Travail en cours sur la fonctionnalité X"
# Plus tard, après tests réussis :
git commit --amend -m "feat: Ajouter la fonctionnalité X"
```

---

## Phase 2 : Préparation de la release

### Étape 3 : Mettre à jour le changelog

Fichier : `docs/changelog.md`

```bash
# Obtenir la date
date +%Y-%m-%d
```

**Format** :
```markdown
## [X.X.X] - AAAA-MM-JJ

### Ajouté
- Fonctionnalité 1

### Modifié
- Changement 1

### Corrigé
- Bug 1
```

Catégories : **Ajouté**, **Modifié**, **Corrigé**, **Supprimé**, **Technique**, **Documentation**

### Étape 4 : Bumper la version

Fichier : `package.json`

**Semantic Versioning** :
- **PATCH** (x.x.+1) : Corrections, petits ajustements
- **MINOR** (x.+1.0) : Nouvelles fonctionnalités compatibles
- **MAJOR** (+1.0.0) : Changements majeurs incompatibles

Modifier le champ `"version": "X.X.X"`

### Étape 5 : Commit de release

```bash
git add docs/changelog.md package.json
git commit -m "release: Version X.X.X - Titre court

- Fonctionnalité 1
- Fonctionnalité 2
- Correction 1
- Bump version X.X.X"
```

**Important** : Ne jamais mentionner Claude, Anthropic ou des adresses emails relatives à ces entités.

---

## Phase 3 : Fusion dans main

### Étape 6 : Merger dans main

```bash
git checkout main
git merge feature/nom-de-la-fonctionnalite --no-ff
```

**Option `--no-ff`** : Force un merge commit pour un historique propre et tracé

### Étape 7 : Push vers origin

```bash
git push origin main
```

---

## Phase 4 : Build des exécutables

### Étape 8 : Build pour les plateformes

```bash
# macOS (si développement sur Mac)
npm run build

# Linux x64 (production principale)
npm run build:linux-x64

# Windows (si nécessaire)
npm run build:win
```

### Étape 9 : Organiser les builds

```bash
# Créer le dossier de version
mkdir -p dist/vX.X.X

# Copier le changelog
cp docs/changelog.md dist/vX.X.X/CHANGELOG.md

# Déplacer les builds
mv dist/SimpleConnect-X.X.X*.{AppImage,dmg,zip,exe} dist/vX.X.X/ 2>/dev/null
mv dist/SimpleConnect-X.X.X*.blockmap dist/vX.X.X/ 2>/dev/null

# Vérifier le contenu
ls -lh dist/vX.X.X/
```

---

## Phase 5 : Documentation

### Étape 10 : Créer les notes de release

Fichier : `releases/vX.X.X.md`

**Structure markdown** :
- Titre et date
- Résumé des changements
- Nouveautés principales
- Corrections
- Fichiers disponibles
- Compatibilité
- Guide d'utilisation (si nécessaire)

### Étape 11 : Commit et push de la documentation

```bash
git add releases/vX.X.X.md
git commit -m "docs: Ajout des notes de release pour vX.X.X"
git push origin main
```

---

## Phase 6 : Publication sur Gitea

### Étape 12 : Créer le tag Git

```bash
# Trouver le commit de release
git log --oneline --grep="X.X.X" -5

# Créer le tag annoté
git tag -a vX.X.X <commit-hash> -m "Release vX.X.X - Titre court

Description des principales fonctionnalités
- Fonctionnalité 1
- Fonctionnalité 2
- Correction 1"
```

### Étape 13 : Push du tag

```bash
git push origin vX.X.X
```

### Étape 14 : Créer la release avec `tea`

**Prérequis** : `tea` configuré avec le login `simpleconnect`

```bash
# Vérifier la configuration
tea login list

# Créer la release avec tous les fichiers
tea release create \
  --login simpleconnect \
  --repo pierre/SimpleConnect-client-electron \
  --tag vX.X.X \
  --title "SimpleConnect vX.X.X - Titre de la release" \
  --note-file releases/vX.X.X.md \
  --asset dist/vX.X.X/SimpleConnect-X.X.X.AppImage \
  --asset dist/vX.X.X/SimpleConnect-X.X.X-arm64.dmg \
  --asset dist/vX.X.X/SimpleConnect-X.X.X-arm64-mac.zip
```

**Notes** :
- `--note-file` utilise le fichier markdown des notes
- Multiple `--asset` pour uploader tous les binaires
- Code source (TAR.GZ et ZIP) ajouté automatiquement par Gitea

### Étape 15 : Vérifier la release

```bash
# Lister toutes les releases
tea release list --login simpleconnect --repo pierre/SimpleConnect-client-electron

# Vérifier les assets d'une release
tea release assets --login simpleconnect --repo pierre/SimpleConnect-client-electron vX.X.X
```

**Résultat attendu** :
- ✅ SimpleConnect-X.X.X.AppImage (Linux x64)
- ✅ SimpleConnect-X.X.X-arm64.dmg (macOS)
- ✅ SimpleConnect-X.X.X-arm64-mac.zip (macOS)
- ✅ Code source (TAR.GZ et ZIP automatiques)

### Corrections éventuelles

**Ajouter des assets manquants** :
```bash
tea release assets create \
  --login simpleconnect \
  --repo pierre/SimpleConnect-client-electron \
  vX.X.X \
  dist/vX.X.X/fichier-supplementaire.ext
```

**Supprimer des doublons** :
```bash
tea release assets delete \
  --login simpleconnect \
  --repo pierre/SimpleConnect-client-electron \
  --confirm \
  vX.X.X \
  nom-du-fichier.ext
```

---

## Phase 7 : Déploiement (optionnel)

### Étape 16 : Déployer sur le serveur

```bash
scp dist/vX.X.X/SimpleConnect-X.X.X.AppImage user@server:/path/to/app/
```

---

## Phase 8 : Nettoyage des branches

Une fois la release publiée et déployée, nettoyer les branches mergées.

### Étape 17 : Supprimer les branches locales

```bash
# Vérifier les branches mergées
git branch --merged main

# Supprimer automatiquement toutes les branches mergées
git branch --merged main | grep -v "^\*" | grep -v "main" | xargs -n 1 git branch -d

# Ou manuellement
git branch -d feature/nom-de-la-fonctionnalite

# Forcer si la branche a un remote (option -D)
git branch -D feature/nom-de-la-fonctionnalite
```

**Pourquoi `-D` peut être nécessaire ?**
- Git refuse `-d` si la branche a encore un remote associé
- Même mergée dans main, Git veut s'assurer qu'elle est mergée dans origin/branche
- `-D` est sûr si on a vérifié le merge dans main

### Étape 18 : Supprimer les branches distantes

```bash
# Supprimer une ou plusieurs branches
git push origin --delete feature/nom-1 feature/nom-2 feature/nom-3

# Vérifier la suppression
git branch -a
```

### Étape 19 : Nettoyer les références locales

```bash
# Supprimer les références aux branches distantes supprimées
git remote prune origin

# Ou avec fetch
git fetch --prune
```

**Résultat attendu** : Seules les branches `main` et celles en cours de travail restent.

---

## Référence des commandes

### Commandes npm

```bash
npm start           # Lance l'application en production
npm run dev         # Mode développement avec DevTools
npm run build       # Build pour toutes les plateformes
npm run build:win   # Build Windows
npm run build:mac   # Build macOS
npm run build:linux # Build Linux
npm run build:linux-x64    # Build Linux x64
npm run build:linux-arm64  # Build Linux ARM64
```

### Commandes Git

```bash
# Branches
git checkout -b feature/XXX        # Créer une branche
git branch --merged main           # Lister branches mergées
git branch -d feature/XXX          # Supprimer branche locale
git branch -D feature/XXX          # Forcer suppression
git push origin --delete XXX       # Supprimer branche distante

# Tags
git tag -a vX.X.X <hash> -m "..."  # Créer tag annoté
git push origin vX.X.X             # Push tag
git tag -l                         # Lister tags

# Merge
git merge feature/XXX --no-ff      # Merge avec commit

# Nettoyage
git remote prune origin            # Nettoyer références
git fetch --prune                  # Fetch + nettoyage
```

### Commandes `tea` (Gitea CLI)

#### Logins
```bash
tea login list                     # Lister logins configurés
tea login add                      # Ajouter un login
tea login default <nom>            # Définir login par défaut
```

#### Releases
```bash
tea release list --login simpleconnect --repo pierre/SimpleConnect-client-electron
tea release create --help
tea release edit vX.X.X --title "Nouveau titre"
tea release delete vX.X.X --confirm
```

#### Assets
```bash
tea release assets list vX.X.X
tea release assets create vX.X.X fichier.ext
tea release assets delete vX.X.X fichier.ext --confirm
```

#### Options globales
```bash
--login simpleconnect              # Utiliser le login 'simpleconnect'
--repo pierre/SimpleConnect-client-electron  # Spécifier le repository
--output json                      # Format de sortie (json, yaml, table)
```

### Conventions de commits

```bash
feat:      # Nouvelle fonctionnalité
fix:       # Correction de bug
refactor:  # Refactoring
docs:      # Documentation
style:     # Formatage, style
test:      # Tests
chore:     # Maintenance, tâches diverses
release:   # Commit de release
wip:       # Work in progress (temporaire)
```

### Semantic Versioning

```
MAJOR.MINOR.PATCH

MAJOR (X.0.0)   # Changements incompatibles
MINOR (x.X.0)   # Nouvelles fonctionnalités compatibles
PATCH (x.x.X)   # Corrections de bugs
```

---

**Dernière mise à jour** : 2025-10-21