chore(workflow): complete step 13 (retrospective), v1.4.0 done

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
chore(workflow): complete step 11 (release v1.4.0), skip step 12
2026-03-13 04:24:22 +01:00 · 2026-03-13 04:22:35 +01:00 · 2026-03-13 04:20:36 +01:00 · 2026-03-13 04:18:37 +01:00 · 2026-03-13 04:02:19 +01:00 · 2026-03-13 03:58:38 +01:00
21 changed files with 2238 additions and 74 deletions
--- a/.claude/workflow-progress.md
+++ b/.claude/workflow-progress.md
@@ -7,10 +7,10 @@
 | Chemin | /home/sylvain/nas/perso/sylvain/conserver/code/application_temp/gitea-dashboard |
 | Date de creation | 2026-03-10 |
 | Origine | gitea@192.168.0.106:admin/gitea-dashboard.git |
-| Version courante | v1.3.0 |
+| Version courante | v1.4.0 |
 | Track | minor |
-| Phase courante | 2 — DEV |
+| Phase courante | 5 — POST-RELEASE |
-| Etape courante | 9 (done) |
+| Etape courante | 13 (done) |
 | workflow_version | v1.1 |
 ---
@@ -87,10 +87,23 @@
 | 7 | Developpement | done | 2026-03-12 | orchestrator | Auto (tests passent) | step_7: done, commits: 3, files_modified: 5, tests: 118 passed (88 existing + 30 new), fixes #11-#15 |
 | 8 | Audit + corrections | done | 2026-03-12 | reviewer + guardian + fixer | Auto (score 100) | step_8: done, audit_initial: 81 (reviewer) / 87 (guardian), audit_final: 100, rounds: 2, corrections: 3 (Retry-After cap/fallback, test health partial) |
 | 9 | Smoke test | done | 2026-03-12 | tester + checklist | Auto (E2E + checklist) | step_9: done, mode: cli, rounds: 1, tests: 8/8 passed, coverage: 99% |
-| 10 | Documentation | - | - | - | - | A determiner (fusion avec 11 probable) |
+| 10 | Documentation | merged_with_11 | 2026-03-12 | - | - | Pas de docs/guides ni OpenAPI |
-| 11 | Release | - | - | /release | Auto (release creee) | - |
+| 11 | Release | done | 2026-03-12 | /release | Auto (release creee) | step_11: done, tag: v1.3.0, mode: lightweight, guardian: APPROVED, issues: #11-#15 closed |
-| 12 | Deploy (optionnel) | - | - | - | - | CLI local, pas de deploy |
+| 12 | Deploy (optionnel) | skipped | 2026-03-12 | - | - | CLI local, pas de deploy |
-| 13 | Retrospective | - | - | documenter | Auto (metriques et analyse) | - |
+| 13 | Retrospective | done | 2026-03-12 | documenter | Auto (metriques et analyse) | step_13: done, metrics_written: true, analysis_written: true, gitea_milestone: closed |
 ## Phase 2 — DEV (v1.4.0)
 | # | Etape | Statut | Date | Agent/Skill | Validation | Notes |
 |---|-------|--------|------|-------------|------------|-------|
 | 6 | Plan de version | done | 2026-03-13 | architect | Auto (plan avec phases, budget scope) | step_6: done, plan: docs/plans/v1.4.0-plan.md, phases: 2, ADR-012/013/014/015, gitea_milestone: exists (id:48) |
 | 7 | Developpement | done | 2026-03-13 | orchestrator | Auto (tests passent) | step_7: done, commits: 4 (2 RED + 2 GREEN), files_modified: 5, files_created: 1, tests: 162 passed (122 existing + 40 new), fixes #16-#19 |
 | 8 | Audit + corrections | done | 2026-03-13 | reviewer + guardian + fixer | Auto (score 100) | step_8: done, audit_initial: 68 (reviewer) / 87 (guardian), audit_final: 100, rounds: 2, corrections: 6 (activity col, token/auth key, unresolved vars, tests), 166 tests |
 | 9 | Smoke test | done | 2026-03-13 | tester + checklist | Auto (E2E + checklist) | step_9: done, mode: cli, rounds: 1, tests: 11/12 passed (1 syntaxe argparse attendue), finding mineur: columns YAML ignoree |
 | 10 | Documentation | merged_with_11 | 2026-03-13 | - | - | Pas de docs/guides ni OpenAPI |
 | 11 | Release | done | 2026-03-13 | /release | Auto (release creee) | step_11: done, tag: v1.4.0, mode: lightweight, guardian: APPROVED, issues: #16-#19 closed |
 | 12 | Deploy (optionnel) | skipped | 2026-03-13 | - | - | CLI local, pas de deploy |
 | 13 | Retrospective | done | 2026-03-13 | documenter | Auto (metriques et analyse) | step_13: done, metrics_written: true, analysis_written: true, gitea_milestone: closed |
 ---
@@ -144,6 +157,19 @@
 | 2026-03-12 | step 7 done | 3 commits (1/phase), 5 fichiers modifiés, 118 tests (30 nouveaux), fixes #11-#15 |
 | 2026-03-12 | step 8 done | Audit: reviewer 81→100, guardian 87→100, 2 rounds, 3 corrections (Retry-After), 122 tests |
 | 2026-03-12 | step 9 done | Smoke test CLI réel, 8/8 tests E2E, rétrocompat OK, --health OK, description OK, JSON pipe OK |
 | 2026-03-12 | step 10 merged_with_11 | Pas de docs/guides ni OpenAPI |
 | 2026-03-12 | step 11 done | Tag v1.3.0, release Gitea, push origin, guardian APPROVED, lightweight mode, issues #11-#15 closed |
 | 2026-03-12 | step 12 skipped | CLI local, pas de deploy |
 | 2026-03-12 | step 13 done | Retrospective, metriques, analyse, milestone fermee |
 | 2026-03-13 | Start v1.4.0 at step 6 | Minor track, 4 issues ouvertes: #16 (--milestones), #17 (YAML config), #18 (timeout pagination), #19 (--columns) |
 | 2026-03-13 | step 6 done | Plan v1.4.0 (2 phases, 10 fichiers, ADR-012/013/014/015), milestone exists (id:48) |
 | 2026-03-13 | step 7 done | 4 commits TDD (2 RED + 2 GREEN), 5 fichiers modifiés, 1 créé, 162 tests (40 nouveaux), fixes #16-#19 |
 | 2026-03-13 | step 8 done | Audit: reviewer 68→100, guardian 87→100, 2 rounds, 6 corrections, 166 tests |
 | 2026-03-13 | step 9 done | Smoke test CLI réel, 11/12 tests E2E, milestones OK, columns OK, config YAML OK, JSON pipe OK |
 | 2026-03-13 | step 10 merged_with_11 | Pas de docs/guides ni OpenAPI |
 | 2026-03-13 | step 11 done | Tag v1.4.0, release Gitea, push origin, guardian APPROVED, lightweight mode, issues #16-#19 closed |
 | 2026-03-13 | step 12 skipped | CLI local, pas de deploy |
 | 2026-03-13 | step 13 done | Retrospective, metriques, analyse, milestone fermee |
 ## Versions completees
@@ -152,4 +178,5 @@
 | v1.0.0 | 2026-03-10 | 2026-03-10 | major-initial, 12/13 steps, audit 97, 37 tests |
 | v1.1.0 | 2026-03-11 | 2026-03-11 | minor, 7/8 steps (10 merged, 12 skipped), audit 100, 53 tests |
 | v1.2.0 | 2026-03-12 | 2026-03-12 | minor, 7/8 steps (10 merged, 12 skipped), audit 100, 88 tests |
-| v1.3.0 | 2026-03-12 | - | minor, en cours |
+| v1.3.0 | 2026-03-12 | 2026-03-12 | minor, 7/8 steps (10 merged, 12 skipped), audit 100, 122 tests |
 | v1.4.0 | 2026-03-13 | 2026-03-13 | minor, 7/8 steps (10 merged, 12 skipped), audit 100, 166 tests |
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,40 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 ## [Unreleased]
 ## [1.4.0] - 2026-03-13
 ### Added
 - Vue milestones dédiée avec `--milestones` (tableau Repo/Milestone/Open/Closed/Progress)
 - Support de fichier de configuration YAML (`~/.config/gitea-dashboard/config.yml`)
 - Option `--config` pour spécifier un fichier de configuration alternatif
 - Résolution des variables d'environnement `${VAR}` dans les fichiers de configuration
 - Priorité de configuration : CLI > variables d'environnement > fichier config > défauts
 - Colonnes configurables avec `--columns` (inclusion, exclusion par préfixe `-`, `--columns help`)
 - Rétrocompatibilité `--no-desc` maintenue avec `--columns`
 - Export JSON des milestones via `--milestones --format json`
 - Paramètre `state` dans `client.get_milestones()` (défaut : "open", supporte "all" pour la vue milestones)
 ### Changed
 - Colonne `activity` désormais rendue dans le tableau principal
 ### Fixed
 - Dégradation gracieuse sur timeout réseau pendant la pagination (retourne les données partielles au lieu de crasher)
 - Incohérence clé `token`/`auth` corrigée dans le chargement du fichier de configuration YAML
 - Détection et rejet des variables `${VAR}` non résolues dans le token
 ### Technical
 - Nouveau module `config.py` pour la gestion de configuration YAML (ADR-013)
 - Nouvelle dépendance PyYAML >= 6.0
 - Dataclass `MilestoneData` dans `collector.py` (ADR-014)
 - Fonction `collect_milestones()` avec filtrage include/exclude et state=all
 - Fonctions `render_milestones()`, `parse_columns()`, `AVAILABLE_COLUMNS` dans `display.py`
 - Fonctions `milestones_to_dicts()`, `export_milestones_json()` dans `exporter.py`
 - Refactoring : `_filter_repos()` extrait la logique de filtrage partagée dans `collector.py`
 ## [1.3.0] - 2026-03-12
 ### Added
@@ -61,6 +95,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - Gestion des erreurs réseau (connexion refusée, timeout, erreurs API)
 - Masquage du token dans les messages d'erreur
 [Unreleased]: https://gitea.tsmse.fr/admin/gitea-dashboard/compare/v1.4.0...HEAD
 [1.4.0]: https://gitea.tsmse.fr/admin/gitea-dashboard/compare/v1.3.0...v1.4.0
 [1.3.0]: https://gitea.tsmse.fr/admin/gitea-dashboard/compare/v1.2.0...v1.3.0
 [1.2.0]: https://gitea.tsmse.fr/admin/gitea-dashboard/compare/v1.1.0...v1.2.0
 [1.1.0]: https://gitea.tsmse.fr/admin/gitea-dashboard/compare/v1.0.0...v1.1.0
--- a/README.md
+++ b/README.md
@@ -6,6 +6,7 @@ Dashboard CLI affichant en une commande l'état de tous les repos d'une instance
 - Python >= 3.10
 - Accès à une instance Gitea avec un token API
 - Dépendances : `requests`, `rich`, `PyYAML`
 ## Installation
@@ -15,7 +16,7 @@ pip install -e .
 ## Configuration
-Le dashboard se configure via deux variables d'environnement :
+### Variables d'environnement
 | Variable | Description | Défaut |
 |----------|-------------|--------|
@@ -24,19 +25,36 @@ Le dashboard se configure via deux variables d'environnement :
 Pour créer un token : Gitea > Settings > Applications > Generate Token.
 Exemple de configuration dans votre shell :
 ```bash
 export GITEA_URL=https://gitea.tsmse.fr
 # Définir GITEA_TOKEN avec la valeur obtenue depuis Gitea > Settings > Applications
 ```
 ### Fichier de configuration YAML
 Le dashboard peut être configuré via un fichier YAML, évitant de répéter les variables d'environnement à chaque session. Le fichier est recherché dans l'ordre suivant :
 1. Chemin spécifié via `--config`
 2. `~/.config/gitea-dashboard/config.yml`
 Les variables d'environnement `${VAR}` sont résolues automatiquement dans le fichier.
 ```yaml
 url: https://gitea.tsmse.fr
 token: ${GITEA_TOKEN}
 ```
 La priorité de résolution est : options CLI > variables d'environnement > fichier de configuration > valeurs par défaut.
 ## Usage
 ```bash
 gitea-dashboard
 # ou
 python -m gitea_dashboard
 # Avec un fichier de configuration spécifique
 gitea-dashboard --config /chemin/vers/config.yml
 ```
 ### Vérification de la connexion
@@ -87,12 +105,32 @@ gitea-dashboard --sort issues
 gitea-dashboard -s activity
 ```
-### Colonne Description
+### Colonnes configurables
-Le tableau affiche par défaut une colonne "Description" (tronquée à 40 caractères). Pour la masquer :
+L'option `--columns` permet de choisir les colonnes affichées dans le tableau :
 ```bash
-gitea-dashboard --no-desc
+# Afficher uniquement les colonnes repo et issues
 gitea-dashboard --columns repo,issues
 # Exclure la colonne description
 gitea-dashboard --columns -description
 # Lister les colonnes disponibles
 gitea-dashboard --columns help
 ```
 Pour masquer la colonne description, l'option historique `--no-desc` reste disponible (équivalent à `--columns -description`).
 ### Vue milestones
 L'option `--milestones` affiche un tableau dédié avec la progression de chaque milestone (colonnes Repo/Milestone/Open/Closed/Progress) :
 ```bash
 gitea-dashboard --milestones
 # Export JSON des milestones
 gitea-dashboard --milestones --format json
 ```
 ### Export JSON
--- a/docs/analyse/gitea-dashboard-v1.3.0-2026-03-12.md
+++ b/docs/analyse/gitea-dashboard-v1.3.0-2026-03-12.md
@@ -0,0 +1,92 @@
 # Analyse v1.3.0 — gitea-dashboard
 **Date** : 2026-03-12
 **Track** : minor
 **Issues** : #11, #12, #13, #14, #15 (5/5 fermees)
 ## Metriques
 | Metrique | v1.2.0 | v1.3.0 | Delta | Seuil | Alerte |
 |----------|--------|--------|-------|-------|--------|
 | Modules source | 7 | 7 | 0 | — | — |
 | Lignes source | ~530 | 664 | +25% | — | — |
 | Tests | 88 | 122 | +34 (+39%) | +50% | non |
 | LOC tests | ~1300 | 1706 | +31% | — | — |
 | Couverture | 93% | 99% | +6% | -5% | non |
 | Dependances | 2 | 2 | 0 | +5 | non |
 | Audit initial | 81 (reviewer) / 87 (guardian) | — | — | — | — |
 | Audit final | 100 | 100 | 0 | — | — |
 | Rounds audit | 3 | 2 | -1 | — | — |
 ### Seuils d'alerte : tous respectes
 - Tests +39% < seuil +50% : aucune action requise
 - Dependances stables (0 ajout)
 - Couverture en hausse (+6%) : progression notable, pas d'alerte
 ## Chronologie
 | Etape | Duree estimee | Notes |
 |-------|--------------|-------|
 | 6 Plan | rapide | architect, 3 phases, ADR-009/010/011 |
 | 7 Dev | moyen | orchestrator, 3 commits (1/phase), 5 fichiers modifies, 30 nouveaux tests |
 | 8 Audit | moyen | 2 rounds (81→100), 3 corrections (Retry-After cap, fallback, test) |
 | 9 Smoke | rapide | 8/8 E2E, --health OK, description OK, JSON pipe OK |
 | 10 Docs | fusionne avec 11 | — |
 | 11 Release | rapide | lightweight, tag v1.3.0 |
 | 12 Deploy | skip | CLI local |
 | 13 Retro | rapide | metriques + analyse |
 ## Findings d'audit corriges
 1. **Retry-After cap** : le header `Retry-After` n'etait pas plafonné, permettant des attentes
   arbitrairement longues — cap ajouté à 30 secondes
 2. **Retry-After fallback** : les dates HTTP (format RFC 2822) n'etaient pas gérées, entraînant
   une exception silencieuse — fallback sur backoff exponentiel ajouté
 3. **Test Retry-After** : absence de test couvrant le chemin fallback — test ajouté
 ## Decisions notables
 - **ADR-009** : gestion HTTP 429 avec `Retry-After` — respect du rate limiting Gitea,
  cap à 30 s pour eviter des blocages indefinis
 - **ADR-010** : colonne "Description" avec troncature à 40 caractères et option `--no-desc` —
  compromis lisibilité/densité d'information
 - **ADR-011** : sanitisation des caractères de contrôle JSON dans `exporter.py` —
  robustesse face aux descriptions de repos non conformes
 ## Ce qui a bien fonctionne
 - **Orchestrateur 3 phases** : la decomposition en phases distinctes (retry, description, edge
  cases) a produit 3 commits propres et lisibles, sans contamination entre les fonctionnalites
 - **Audit en 2 rounds** : le score initial de 81/87 a ete corrige en un seul cycle, contre
  3 rounds pour v1.2.0 — signe que la qualite initiale du code s'améliore
 - **Couverture 99%** : niveau exceptionnel atteint grace aux 30 tests edge cases (#13) —
  les branches de formatage de display.py, problematiques en v1.2.0 (86%), sont desormais couvertes
 - **--health integre naturellement** : la commande s'insere dans le flux CLI existant sans
  modifier l'architecture (pas de nouveau module)
 - **8/8 smoke tests** : pas de regression, tous les scenarios E2E valides du premier coup
 ## Ce qui peut etre ameliore
 - **Score initial 81** (reviewer) : bien que corrige rapidement, le score de depart reste en
  dessous du seuil optimal. L'orchestrateur devrait integrer une auto-review avant livraison
 - **Fusion 10+11** : recurrente depuis v1.2.0 — si c'est systematique sur ce projet, l'envisager
  comme convention plutot que comme exception
 - **LOC tests / LOC source = 2.6x** : le ratio tests/source continue de croitre (+31% vs +25%)
  — pas alarmant mais a surveiller pour eviter une dette de maintenance des tests
 ## Recommandations pour v1.4.0
 1. **Parallelisation API** (ADR-003, dette documentee depuis v1.2.0) : remplacer les 3 appels
   sequentiels par repo par des appels concurrents (`concurrent.futures.ThreadPoolExecutor`) —
   gain de performance significatif sur les instances avec de nombreux repos
 2. **Export CSV** : demande logique apres l'export JSON, meme architecture dans `exporter.py`
 3. **Cache API local** : eviter les requetes repetees pour des donnees stables (releases, descriptions)
 4. **Auto-review orchestrateur** : ajouter une passe reviewer apres dev avant audit formel,
   pour reduire le nombre de rounds et partir d'un score initial plus eleve
 ## Conclusion
 Version v1.3.0 livree avec les 5 fonctionnalites/corrections prevues. Audit final 100/100.
 Le cycle a ete le plus efficace depuis v1.0.0 : 2 rounds d'audit seulement, 8/8 smoke tests,
 couverture a 99%. La dette technique (N+1 API) reste la seule priorite ouverte pour v1.4.0.
--- a/docs/analyse/gitea-dashboard-v1.4.0-2026-03-13.md
+++ b/docs/analyse/gitea-dashboard-v1.4.0-2026-03-13.md
@@ -0,0 +1,72 @@
 # Analyse de version — gitea-dashboard v1.4.0
 **Date** : 2026-03-13
 **Track** : minor
 **Durée** : 1 session
 ## Métriques
 | Métrique | v1.3.0 | v1.4.0 | Delta |
 |----------|--------|--------|-------|
 | Fichiers source | 7 | 8 | +1 (+14%) |
 | Lignes source | ~850 | 1138 | +288 (+34%) |
 | Tests | 122 | 166 | +44 (+36%) |
 | Couverture | 99% | 94% | -5% |
 | Dépendances runtime | 2 | 3 | +1 (PyYAML) |
 | Audit initial (reviewer) | 68 | - | - |
 | Audit initial (guardian) | 87 | - | - |
 | Audit final | 100 | - | - |
 | Rounds d'audit | 2 | - | - |
 | Corrections d'audit | 6 | - | - |
 | Smoke tests E2E | 11/12 | - | - |
 ## Alertes
 | Métrique | Seuil | Valeur | Statut |
 |----------|-------|--------|--------|
 | Tests | +50% | +36% | OK |
 | Couverture | -5% | -5% | **ALERTE** |
 | Dépendances | +5 | +1 | OK |
 **Couverture -5%** : la baisse de 99% à 94% est due aux nouvelles branches dans `display.py` (rendu conditionnel des colonnes, coloration milestones) et `config.py` (chemins de fichier par défaut). Ces branches sont difficiles à tester sans infrastructure de capture console plus élaborée. Les fonctions critiques (collecte, export, retry) restent à 100%.
 ## Issues traitées
 | Issue | Titre | Type | Résultat |
 |-------|-------|------|----------|
 | #16 | Milestone progress view (--milestones) | feat | Fermée |
 | #17 | YAML configuration file support | feat | Fermée |
 | #18 | Handle API timeout during paginated requests | fix | Fermée |
 | #19 | Configurable column visibility (--columns) | improvement | Fermée |
 ## ADR produits
 - ADR-012 : Dégradation gracieuse sur timeout dans `_get_paginated`
 - ADR-013 : Nouveau module `config.py` pour la configuration YAML
 - ADR-014 : Dataclass `MilestoneData` pour la vue milestones
 - ADR-015 : Colonnes configurables par inclusion/exclusion
 ## Observations
 ### Ce qui a bien fonctionné
 - **TDD 4 commits** (2 RED + 2 GREEN) : les tests failing d'abord ont permis de détecter les interfaces manquantes avant l'implémentation
 - **Audit adversarial** : 6 findings détectés dont 2 majeurs (colonne activity non rendue, incohérence token/auth). Sans l'audit, ces bugs auraient été livrés en production
 - **Dégradation gracieuse** : le pattern timeout partiel est propre et réutilisable pour d'autres cas
 - **Configuration YAML** : architecture propre avec module dédié, résolution ${VAR}, et détection des variables non résolues
 ### Points d'attention
 - **Couverture en baisse** : la colonne `activity` duplique le rendu de `commit` — une future version pourrait différencier ces colonnes (fréquence vs date)
 - **Syntaxe `--columns`** : l'exclusion par préfixe `-` nécessite la syntaxe `--columns="-col"` à cause d'argparse — documenter dans l'aide CLI
 - **Clé `columns` dans YAML** : le fichier config YAML ne supporte pas encore la clé `columns` — finding mineur du smoke test, à traiter en v1.5
 ### Améliorations de workflow
 - L'orchestrator a produit les 4 commits TDD correctement malgré la complexité (10 fichiers)
 - Le fixer a corrigé les 6 findings en une seule passe sans régression
 - Le mode lightweight de release gate (audit_final=100) a permis d'accélérer la publication
 ## Conclusion
 Version v1.4.0 livrée avec 4 fonctionnalités majeures et 1 bugfix. Le projet atteint 8 modules source, 166 tests, et 3 dépendances runtime. La couverture a baissé de 5% mais reste à 94%. Le prochain cycle devrait prioriser la couverture des branches display.py et le support de `columns` dans la config YAML.
--- a/docs/plans/v1.4.0-plan.md
+++ b/docs/plans/v1.4.0-plan.md
@@ -0,0 +1,664 @@
 <!-- Type: reference (Diataxis). Style: factuel, structure par phases, actionnable par le builder. -->
 # Plan de version v1.4.0 — gitea-dashboard
 ## Objectif
 Ajouter une vue milestones dediee (`--milestones`), le support d'un fichier de configuration YAML, la visibilite configurable des colonnes (`--columns`), et corriger la gestion des timeouts reseau pendant la pagination.
 ## Track
 **Minor** : 6 -> 7 -> 8 -> 9 -> 10+11 -> (12) -> 13
 ---
 ## Budget de scope
 | Critere | Valeur |
 |---------|--------|
 | Max fichiers par phase | 5 |
 | Total fichiers estimes | 10 (6 modules source + 4 fichiers de tests) |
 | Fichiers crees | 1 (`config.py`) |
 | Tests estimes | ~45 nouveaux (total ~167) |
 ### Inclus
 - Vue milestones avec `--milestones` (#16)
 - Fichier de configuration YAML (#17)
 - Gestion des timeouts reseau pendant la pagination (#18)
 - Visibilite configurable des colonnes avec `--columns` (#19)
 ### Exclus
 - Parallelisation des appels API (ADR-003, differee)
 - Export CSV/YAML
 - Cache API local (fichier/SQLite)
 - Dashboard interactif TUI
 ### Differe (v1.5+)
 - Parallelisation des appels API
 - Export CSV
 - Cache API local
 - Dashboard interactif (TUI)
 - Sous-commandes CLI (ADR-011, a reconsiderer si modes alternatifs continuent de croitre)
 ---
 ## Etapes skippees
 | Etape | Nom | Raison |
 |-------|-----|--------|
 | 1 | Discovery | Projet existant, discovery v1.0.0 suffisante |
 | 2 | Project creation | Projet existant |
 | 3 | Specs | Minor -- specs couvertes par les issues #16-#19 et ce plan |
 | 4 | Research | API milestones deja utilisee (client.get_milestones). PyYAML est standard |
 | 5 | Roadmap | Minor -- milestone v1.4.0 deja creee sur Gitea |
 | 12 | Deploy | Outil CLI local, pas de deploiement serveur |
 ---
 ## Analyse des dependances entre issues
 ```
 #18 (timeout pagination) -- fondation, corrige _get_paginated dans client.py
 #17 (config YAML) -- nouveau module config.py, modifie cli.py
 #16 (--milestones) -- nouveau endpoint d'affichage, modifie collector.py + display.py
 #19 (--columns) -- modifie display.py + cli.py, depend de #16 (nouvelles colonnes)
 ```
 Dependances :
 - #18 est un bugfix independant, doit etre fait en premier (stabilite du collecteur)
 - #17 cree config.py et modifie cli.py ; #16 modifie aussi cli.py -> separer les phases
 - #19 depend de #16 car les colonnes de la vue milestones doivent etre connues avant de les rendre configurables
 - #17 et #19 modifient tous les deux cli.py mais dans des zones differentes (config resolution vs argparse columns)
 Ordre : #18 -> #17 -> #16 -> #19
 ---
 ## Evaluation de sous-versions
 4 issues dont 2 features independantes, 1 improvement, 1 bugfix. Scope < 10 fichiers.
 Les issues ne justifient pas de sous-versions : elles sont suffisamment couplees (toutes touchent cli.py) et le scope total reste gerable en une version.
 ---
 ## Phase 1 : Bugfix timeout pagination + configuration YAML (#18, #17)
 **Goal** : Corriger la degradation gracieuse sur timeout reseau pendant la pagination, et ajouter le support de configuration YAML.
 **Issues Gitea** : fixes #18, fixes #17
 ### Fichiers
 | Action | Fichier | Modifications | Cross-references |
 |--------|---------|---------------|------------------|
 | Modify | `src/gitea_dashboard/client.py` | `_get_paginated` : catch `ReadTimeout`/`ConnectTimeout` sur page intermediaire, retry avec backoff, degradation gracieuse (retourner les donnees partielles + warning) | `collector.py` (consomme _get_paginated) |
 | Create | `src/gitea_dashboard/config.py` | Nouveau module : lecture YAML, resolution `${VAR}`, merge des priorites (CLI > env > config > defaults) | `cli.py` (consomme pour initialiser les args) |
 | Modify | `src/gitea_dashboard/cli.py` | Ajouter `--config` dans argparse. Appeler `config.load_config()` avant le merge des args. Passer les valeurs resolues au reste du pipeline | `config.py` (load_config) |
 | Modify | `tests/test_client.py` | Tests timeout pendant pagination (mock ReadTimeout sur page 2), test degradation gracieuse, test retry avec backoff | `client.py` |
 | Modify | `tests/test_config.py` | Nouveau fichier tests : fixtures YAML (valide, invalide, partiel, vide), resolution `${VAR}`, priorite CLI > env > config > defaults | `config.py` |
 ### Interfaces
 #### client.py (modifications)
 ```python
 class GiteaClient:
    def _get_paginated(self, endpoint: str, params: dict | None = None) -> list[dict]:
        """Requete GET avec pagination automatique.
        Comportement actuel : boucle tant que len(page) == limit (50).
        Utilise _get_with_retry pour la resilience aux timeouts.
        Ajout v1.4.0 : si _get_with_retry leve une exception Timeout sur
        une page intermediaire (page > 1), catch l'exception et retourner
        les donnees collectees jusque-la au lieu de crasher.
        Emet un warning via warnings.warn() pour signaler les donnees partielles.
        Si la premiere page echoue (page == 1), l'exception remonte
        normalement (pas de donnees partielles possibles).
        """
 ```
 **Pourquoi modifier _get_paginated et non _get_with_retry** : le retry existe deja dans `_get_with_retry` (ADR-007/ADR-009). Le probleme est que quand _toutes_ les tentatives de retry echouent sur une page intermediaire, _get_paginated crashe au lieu de retourner les donnees partielles. La degradation gracieuse est une responsabilite de la pagination, pas du retry.
 **Pourquoi warnings.warn et non logging** : le projet n'utilise pas le module logging. `warnings.warn` est la convention stdlib pour signaler un probleme non-fatal sans dependance supplementaire. Le CLI peut capturer les warnings pour l'affichage Rich.
 #### config.py (nouveau module)
 ```python
 import os
 from pathlib import Path
 from typing import Any
 _DEFAULT_CONFIG_PATHS = [
    Path(".gitea-dashboard.yml"),
    Path.home() / ".config" / "gitea-dashboard" / "config.yml",
 ]
 def resolve_env_vars(value: str) -> str:
    """Resout les references ${VAR} dans une valeur string.
    Remplace ${VAR} par os.environ[VAR].
    Si VAR n'est pas defini, laisse la reference telle quelle.
    Ne resout pas les references imbriquees.
    """
 def load_config(config_path: str | None = None) -> dict[str, Any]:
    """Charge la configuration depuis un fichier YAML.
    Ordre de recherche si config_path est None :
    1. .gitea-dashboard.yml (repertoire courant)
    2. ~/.config/gitea-dashboard/config.yml
    Retourne un dict vide si aucun fichier trouve.
    Leve une erreur claire si config_path est fourni mais le fichier
    n'existe pas ou est invalide.
    Les valeurs string contenant ${VAR} sont resolues via resolve_env_vars.
    """
 def merge_config(
    cli_args: dict[str, Any],
    env_vars: dict[str, Any],
    file_config: dict[str, Any],
    defaults: dict[str, Any],
 ) -> dict[str, Any]:
    """Fusionne les sources de configuration par priorite.
    Priorite : cli_args > env_vars > file_config > defaults.
    Une valeur None dans une source de priorite superieure ne masque pas
    la valeur d'une source de priorite inferieure.
    """
 ```
 **Pourquoi un nouveau module plutot qu'une extension de cli.py** : la gestion de configuration YAML (lecture fichier, resolution de variables, merge de priorites) est une responsabilite distincte du parsing d'arguments. ADR-006 a deja montre que la creation de modules supplementaires est acceptable quand la responsabilite est clairement distincte. Le projet passe a 7 modules source (6 + config.py).
 **Pourquoi PyYAML et non la stdlib** : Python n'a pas de parseur YAML dans la stdlib. PyYAML est la dependance la plus legere et la plus utilisee pour ce besoin. C'est une nouvelle dependance explicite dans pyproject.toml.
 #### cli.py (modifications)
 ```python
 def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
    """Parse les arguments CLI.
    Ajout v1.4.0 :
        --config : chemin vers un fichier de configuration YAML alternatif
    """
 def _resolve_config(args: argparse.Namespace) -> argparse.Namespace:
    """Resout la configuration en appliquant la priorite CLI > env > config > defaults.
    1. Charge le fichier config (args.config ou chemin par defaut)
    2. Lit les variables d'environnement pertinentes (GITEA_URL, GITEA_TOKEN)
    3. Fusionne avec les valeurs CLI
    4. Retourne un Namespace enrichi
    """
 ```
 ### Comportement attendu
 1. Timeout sur page intermediaire pendant la pagination :
   ```
   GET /api/v1/user/repos?page=1 -> 200 OK (50 repos)
   GET /api/v1/user/repos?page=2 -> ReadTimeout (apres 2 retries)
   # Warning : "Donnees partielles : timeout sur la page 2 de /api/v1/user/repos"
   # Dashboard affiche les 50 premiers repos avec un avertissement
   ```
 2. Timeout sur la premiere page :
   ```
   GET /api/v1/user/repos?page=1 -> ReadTimeout (apres 2 retries)
   # Exception remonte normalement -> message d'erreur CLI
   ```
 3. Configuration YAML :
   ```yaml
   # ~/.config/gitea-dashboard/config.yml
   url: http://192.168.0.106:3000
   token: ${GITEA_TOKEN}
   sort: activity
   exclude:
     - archived-repo
   no_desc: false
   ```
 4. Priorite de configuration :
   ```bash
   # config.yml a sort: activity, CLI passe --sort name
   $ gitea-dashboard --sort name
   # -> tri par name (CLI gagne)
   ```
 ### Tests
 #### test_client.py (ajouts)
 - `test_get_paginated_timeout_page2_returns_partial` : mock page 1 OK (50 items), page 2 leve ReadTimeout -> retourne les 50 items de page 1.
 - `test_get_paginated_timeout_page1_raises` : mock page 1 leve ReadTimeout -> exception remonte.
 - `test_get_paginated_connect_timeout_graceful` : mock ConnectTimeout sur page 2 -> degradation gracieuse.
 - `test_get_paginated_partial_data_emits_warning` : verifie que `warnings.warn` est appele avec le message de donnees partielles.
 #### test_config.py (nouveau fichier)
 - `test_load_config_valid_yaml` : fixture YAML valide -> dict avec toutes les cles.
 - `test_load_config_partial_yaml` : fixture YAML avec seulement `url` et `sort` -> dict partiel.
 - `test_load_config_empty_file` : fichier vide -> dict vide.
 - `test_load_config_invalid_yaml` : YAML syntaxiquement invalide -> erreur claire.
 - `test_load_config_custom_path` : `--config /tmp/custom.yml` -> charge le fichier specifie.
 - `test_load_config_missing_custom_path` : `--config /inexistant.yml` -> erreur claire.
 - `test_load_config_default_paths` : fixture dans `.gitea-dashboard.yml` -> charge automatiquement.
 - `test_resolve_env_vars_simple` : `${GITEA_TOKEN}` -> valeur de la variable.
 - `test_resolve_env_vars_undefined` : `${UNDEFINED}` -> laisse la reference telle quelle.
 - `test_resolve_env_vars_in_list` : liste YAML avec `${VAR}` -> chaque element resolu.
 - `test_merge_config_priority` : CLI > env > config > defaults, verifie la precedence.
 - `test_merge_config_none_does_not_override` : CLI avec None ne masque pas config.
 ### Livrable
 Le timeout pendant la pagination ne crashe plus le collecteur -- les donnees partielles sont retournees avec un warning. Le fichier `.gitea-dashboard.yml` est supporte avec resolution de variables et priorite CLI > env > config > defaults. Tous les tests passent.
 ---
 ## Phase 2 : Vue milestones et colonnes configurables (#16, #19)
 **Goal** : Ajouter le flag `--milestones` pour une vue dediee des milestones par repo, et le flag `--columns` pour choisir les colonnes affichees.
 **Issues Gitea** : fixes #16, fixes #19
 ### Fichiers
 | Action | Fichier | Modifications | Cross-references |
 |--------|---------|---------------|------------------|
 | Modify | `src/gitea_dashboard/collector.py` | Nouvelle fonction `collect_milestones()` pour collecter les milestones de tous les repos (avec filtrage include/exclude) | `client.py` (get_milestones), `cli.py` (appelle si --milestones) |
 | Modify | `src/gitea_dashboard/display.py` | Nouvelle fonction `render_milestones()` pour le tableau milestones dedie. Constante `AVAILABLE_COLUMNS` et fonction `parse_columns()` pour le parsing de `--columns`. Modifier `render_dashboard()` pour respecter la visibilite des colonnes | `collector.py` (MilestoneData ou dicts), `cli.py` (passe les colonnes) |
 | Modify | `src/gitea_dashboard/exporter.py` | Supporter l'export JSON des milestones (`milestones_to_dicts()`) | `collector.py` (donnees milestones) |
 | Modify | `src/gitea_dashboard/cli.py` | Ajouter `--milestones` et `--columns` dans argparse. Router vers `render_milestones()` ou `export_json()` selon le mode. Gerer `--columns help`. Alias `--no-desc` vers `--columns -description` | `display.py` (render_milestones, parse_columns), `config.py` (colonnes dans config YAML) |
 | Modify | `tests/test_collector.py` | Tests `collect_milestones()` : repos avec/sans milestones, filtrage, repos vides | `collector.py` |
 ### Interfaces
 #### collector.py (ajouts)
 ```python
@dataclass
 class MilestoneData:
    """Donnees agregees d'une milestone avec son repo parent."""
    repo_name: str
    title: str
    open_issues: int
    closed_issues: int
    progress_pct: int  # Pourcentage de completion (0-100)
    due_on: str | None  # ISO 8601 ou None
    state: str  # "open" ou "closed"
 def collect_milestones(
    client: GiteaClient,
    include: list[str] | None = None,
    exclude: list[str] | None = None,
 ) -> list[MilestoneData]:
    """Collecte les milestones de tous les repos accessibles.
    Reutilise la logique de filtrage de collect_all (include/exclude).
    Pour chaque repo filtre, appelle client.get_milestones() avec state=all
    (pas seulement open, pour afficher la progression globale).
    Retourne une liste plate de MilestoneData triee par repo puis milestone.
    """
 ```
 **Pourquoi un dataclass MilestoneData plutot que des dicts bruts** : coherent avec RepoData (ADR-002). Un dataclass documente les champs attendus et permet la validation. Le calcul de `progress_pct` est centralise dans le collecteur, pas dans l'affichage.
 **Pourquoi state=all et non state=open** : l'issue #16 demande une vue de progression des milestones. Les milestones fermees (100%) sont informatives pour voir l'historique. Le filtre open-only est deja dans `get_milestones()` actuel ; pour la vue dediee, on veut tout.
 #### display.py (ajouts)
 ```python
 AVAILABLE_COLUMNS: dict[str, str] = {
    "name": "Nom du repo",
    "description": "Description du repo",
    "issues": "Nombre d'issues ouvertes",
    "release": "Derniere release",
    "commit": "Date du dernier commit",
    "activity": "Indicateur d'activite",
 }
 def parse_columns(columns_arg: str | None, no_desc: bool = False) -> list[str]:
    """Parse l'argument --columns et retourne la liste des colonnes a afficher.
    Si columns_arg est None : retourne toutes les colonnes (sauf description si no_desc).
    Si columns_arg est "help" : retourne la liste speciale ["__help__"].
    Les colonnes sont separees par des virgules.
    Le prefixe "-" exclut une colonne (ex: "-description").
    Leve ValueError si une colonne inconnue est specifiee.
    """
 def render_milestones(
    milestones: list[MilestoneData],
    console: Console | None = None,
 ) -> None:
    """Affiche le tableau des milestones.
    Colonnes : Repo, Milestone, Open, Closed, Progress (%).
    La barre de progression utilise le pourcentage calcule.
    Coloration : vert > 80%, jaune 50-80%, rouge < 50%.
    """
 ```
 **Pourquoi AVAILABLE_COLUMNS est un dict et non une liste** : le dict mappe nom technique -> description lisible, utile pour `--columns help`. Une liste ne suffirait pas pour l'affichage d'aide.
 **Pourquoi parse_columns retourne ["__help__"]** : le CLI doit detecter le mode aide pour afficher les colonnes et quitter. Une valeur sentinelle est plus propre qu'un booleen supplementaire dans la signature.
 #### exporter.py (ajouts)
 ```python
 def milestones_to_dicts(milestones: list[MilestoneData]) -> list[dict]:
    """Convertit une liste de MilestoneData en liste de dicts serialisables.
    Sanitize les champs texte (repo_name, title) pour les caracteres de controle.
    """
 def export_milestones_json(milestones: list[MilestoneData], indent: int = 2) -> str:
    """Exporte les milestones en JSON formate."""
 ```
 #### cli.py (ajouts)
 ```python
 def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
    """Parse les arguments CLI.
    Ajout v1.4.0 :
        --milestones : affiche la vue milestones au lieu du dashboard repos
        --columns : liste des colonnes a afficher (separe par virgules)
                    Supporte l'exclusion par prefixe "-"
                    "--columns help" affiche les colonnes disponibles
    """
 ```
 ### Comportement attendu
 1. Vue milestones :
   ```
   $ gitea-dashboard --milestones
   +------------------+-------------+------+--------+----------+
   | Repo             | Milestone   | Open | Closed | Progress |
   +------------------+-------------+------+--------+----------+
   | gitea-dashboard  | v1.4.0      |    4 |      0 | 0%       |
   | gitea-dashboard  | v1.3.0      |    0 |      5 | 100%     |
   | workflow         | v2.6.1      |    0 |      5 | 100%     |
   +------------------+-------------+------+--------+----------+
   ```
 2. Vue milestones avec filtre :
   ```
   $ gitea-dashboard --milestones --repo gitea
   # Affiche uniquement les milestones des repos contenant "gitea"
   ```
 3. Vue milestones en JSON :
   ```
   $ gitea-dashboard --milestones --format json
   [{"repo_name": "gitea-dashboard", "title": "v1.4.0", ...}]
   ```
 4. Colonnes configurables :
   ```
   $ gitea-dashboard --columns name,issues,release
   # Affiche seulement les colonnes name, issues, release
   $ gitea-dashboard --columns -description,-commit
   # Affiche tout sauf description et commit
   $ gitea-dashboard --columns help
   # Colonnes disponibles : name, description, issues, release, commit, activity
   ```
 5. Retrocompatibilite `--no-desc` :
   ```
   $ gitea-dashboard --no-desc
   # Equivalent a --columns -description
   # Les deux flags coexistent
   ```
 ### Tests
 #### test_collector.py (ajouts)
 - `test_collect_milestones_basic` : 2 repos avec milestones -> liste plate de MilestoneData.
 - `test_collect_milestones_empty_repo` : repo sans milestone -> pas dans la liste.
 - `test_collect_milestones_progress_calculation` : 3 open, 7 closed -> progress_pct == 70.
 - `test_collect_milestones_with_include_filter` : filtre include respecte.
 - `test_collect_milestones_with_exclude_filter` : filtre exclude respecte.
 #### test_display.py (ajouts)
 - `test_render_milestones_basic` : capture console, verifie le tableau avec colonnes attendues.
 - `test_render_milestones_empty` : liste vide -> message "Aucune milestone trouvee."
 - `test_render_milestones_progress_colors` : verifie la coloration selon le pourcentage.
 - `test_parse_columns_all_default` : None -> toutes les colonnes.
 - `test_parse_columns_inclusion` : "name,issues" -> ["name", "issues"].
 - `test_parse_columns_exclusion` : "-description,-commit" -> toutes sauf description et commit.
 - `test_parse_columns_unknown_raises` : "unknown" -> ValueError.
 - `test_parse_columns_help` : "help" -> ["__help__"].
 - `test_parse_columns_no_desc_compat` : no_desc=True -> description exclue.
 - `test_render_dashboard_with_columns` : colonnes specifiques -> seules ces colonnes affichees.
 #### test_exporter.py (ajouts)
 - `test_export_milestones_json_basic` : MilestoneData -> JSON valide.
 - `test_export_milestones_json_empty` : liste vide -> "[]".
 #### test_cli.py (ajouts)
 - `test_parse_args_milestones` : `--milestones` -> `Namespace(milestones=True)`.
 - `test_main_milestones_mode` : mock collect_milestones + render_milestones, verifie le routage.
 - `test_parse_args_columns` : `--columns name,issues` -> `Namespace(columns="name,issues")`.
 - `test_main_columns_help` : `--columns help` -> affiche la liste et quitte.
 - `test_main_no_desc_and_columns_compat` : `--no-desc --columns -commit` -> les deux s'appliquent.
 ### Livrable
 Le flag `--milestones` affiche un tableau dedie avec la progression des milestones par repo. Le flag `--columns` permet de choisir les colonnes affichees avec support d'inclusion et d'exclusion. `--no-desc` reste fonctionnel comme alias. L'export JSON fonctionne pour les deux modes. Tous les tests passent.
 ---
 ## Phase 3 : Audit
 **Goal** : Audit de qualite (reviewer) et de securite (guardian). Score cible : 100. Plancher : 50.
 ## Phase 4 : Smoke test
 **Goal** : Tests E2E sur l'instance Gitea reelle. Verification manuelle des nouvelles fonctionnalites (--milestones, --columns, config YAML, degradation gracieuse timeout).
 ## Phase 5 : Documentation + Release
 **Goal** : Mise a jour README.md, CHANGELOG.md (format Keep a Changelog). Bump de version a 1.4.0. Creation du tag et de la release Gitea.
 ## Phase 6 : Retrospective
 **Goal** : Metriques, MEMORY.md, revue des issues Gitea, analyse du workflow.
 ---
 ## Architecture des modules (impact v1.4.0)
 ```
                         gitea-dashboard v1.4.0
                         =====================
  Terminal                    Application                     Gitea API
  --------                    -----------                     ---------
                      +------------------+
  $ gitea-dashboard   |     cli.py       |
  --milestones        | - parse args     |
  --columns           | - resolve config |
  --config            | - route modes    |
                      | - gere erreurs   |
                      +--------+---------+
                               |
                      +--------+---------+
                      |  --milestones?   |
                      +--+----------+----+
                         |          |
                    oui  |          | non
                         v          v
              collect_milestones()  collect_all()
                     |                  |
                     v          +-------+-------+
              render_milestones |               |
              ou export_json    v               v
                       +------------+  +-------------+
                       | display.py |  | exporter.py |
                       | + colonnes |  | + milestones|
  <--------------------| + --columns|  | + sanitize  |---------> stdout (JSON)
  Output Rich          | + milest.  |  +-------------+
  (tableaux)           +------------+
                      +------------------+
                      |   config.py      | <-- NEW
                      | + load YAML      |
                      | + resolve ${VAR} |
                      | + merge priority |
                      +------------------+
                      +------------------+
                      |   client.py      |
                      | + get_version()  |-----> GET /api/v1/version
                      | + retry HTTP 429 |-----> GET /api/v1/user/repos
                      | + timeout gracf. |-----> GET .../releases/latest
                      +------------------+-----> GET .../milestones (state=all)
                                          -----> GET .../commits?limit=1
 ```
 | Module | Impact v1.4.0 | Detail |
 |--------|--------------|--------|
 | `client.py` | Modifie | Degradation gracieuse dans `_get_paginated` sur timeout page intermediaire |
 | `collector.py` | Modifie | Nouveau dataclass `MilestoneData`, nouvelle fonction `collect_milestones()` |
 | `display.py` | Modifie | `render_milestones()`, `parse_columns()`, `AVAILABLE_COLUMNS`, colonnes configurables dans `render_dashboard()` |
 | `exporter.py` | Modifie | `milestones_to_dicts()`, `export_milestones_json()` |
 | `cli.py` | Modifie | Options `--milestones`, `--columns`, `--config`. Resolution config YAML. Routage du mode milestones |
 | `config.py` | Cree | Lecture YAML, resolution `${VAR}`, merge de priorites |
 ---
 ## Decisions architecturales
 ### ADR-012 : Degradation gracieuse sur timeout dans _get_paginated (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : Un timeout reseau sur une page intermediaire de la pagination fait crasher tout le collecteur. Le retry existant (ADR-007/ADR-009) retente les requetes individuelles, mais apres epuisement des retries, l'exception remonte et les donnees des pages precedentes sont perdues.
 **Decision** : Dans `_get_paginated`, catch les exceptions Timeout apres epuisement des retries uniquement pour les pages > 1. Retourner les donnees collectees jusque-la et emettre un `warnings.warn()`. Si la premiere page echoue, l'exception remonte normalement (pas de donnees partielles possibles).
 **Consequences** :
 - Le dashboard affiche un resultat partiel plutot qu'un crash
 - L'utilisateur est informe via un warning (visible dans la console)
 - La premiere page echouee reste un crash clair (pas de faux resultat vide)
 - Coherent avec le principe "Gestion gracieuse" de CLAUDE.md
 - Risque : l'utilisateur pourrait ne pas remarquer le warning -> l'affichage CLI devra etre explicite
 ### ADR-013 : Nouveau module config.py pour la configuration YAML (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : L'issue #17 demande un fichier de configuration YAML. La logique (lecture fichier, resolution variables, merge de priorites) est substantielle et distincte du parsing CLI.
 **Decision** : Creer `config.py` comme 7eme module source. ADR-002 (4 modules max) est relaxe pour la 3eme fois (apres ADR-006 pour exporter.py). Le principe "un module = une responsabilite" reste respecte.
 **Consequences** :
 - Separation claire : cli.py parse les args, config.py resout la configuration
 - Le module est testable independamment avec des fixtures YAML
 - Nouvelle dependance PyYAML dans pyproject.toml (premiere dependance ajoutee depuis la creation du projet)
 - Le merge de priorites (CLI > env > config > defaults) est centralise et testable
 - Si d'autres formats de config apparaissent (TOML, INI), le module absorbe la complexite
 ### ADR-014 : Dataclass MilestoneData pour la vue milestones (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : La vue `--milestones` collecte des milestones de tous les repos. Les milestones de l'API sont des dicts bruts sans reference au repo parent. Le calcul du pourcentage de progression est necessaire.
 **Decision** : Creer un dataclass `MilestoneData` dans collector.py, incluant `repo_name` et `progress_pct` pre-calcule. La collecte utilise `state=all` (pas seulement open) pour afficher l'historique complet.
 **Consequences** :
 - Coherent avec RepoData : donnees normalisees et documentees
 - Le calcul du pourcentage est centralise dans le collecteur (pas dans display.py)
 - `state=all` augmente le nombre d'appels API mais donne une vue complete
 - Le client.get_milestones() existant utilise `state=open` -> la nouvelle collecte appellera directement avec `state=all` ou une nouvelle methode
 ### ADR-015 : Colonnes configurables par inclusion/exclusion (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : L'issue #19 demande de pouvoir choisir les colonnes affichees. L'approche actuelle (`--no-desc`) est ad hoc pour une seule colonne. Un systeme generique est maintenant justifie.
 **Decision** : Ajouter `--columns` avec une syntaxe a virgules. Support de l'inclusion directe (`name,issues`) et de l'exclusion par prefixe `-` (`-description,-commit`). `--no-desc` reste fonctionnel comme alias de `--columns -description`.
 **Consequences** :
 - Remplace l'approche YAGNI de v1.3.0 (ADR-011 notait "un systeme generique serait over-engineere") -- maintenant justifie par l'issue #19
 - Retrocompatible : `--no-desc` continue de fonctionner
 - `--columns help` fournit une aide contextuelle sans documentation externe
 - Les deux syntaxes (inclusion et exclusion) couvrent les cas d'usage courants
 - Risque : `--no-desc` + `--columns` en meme temps doit etre gere (les deux s'appliquent cumulativement)
 ---
 ## Risques d'audit
 | Zone | Risque | Severite estimee |
 |------|--------|-----------------|
 | `client.py` -- degradation gracieuse | Le warning pourrait etre silencieux si capture par un framework de test. Doit etre visible dans la sortie CLI | major |
 | `config.py` -- resolution ${VAR} | Un `${VAR}` non resolu dans `token` pourrait envoyer une reference liteerale comme token API. Doit etre detecte et signale | critical |
 | `config.py` -- YAML injection | PyYAML `safe_load` requis pour eviter l'execution de code. `yaml.load` sans Loader est une faille connue | critical |
 | `config.py` -- token en clair dans le fichier | Si l'utilisateur ecrit `token: abc123` au lieu de `token: ${GITEA_TOKEN}`, le token est en clair sur le disque. Documenter le risque, recommander `${VAR}` | major |
 | `display.py` -- `--columns` + `--no-desc` | Les deux flags doivent etre cumulatifs, pas contradictoires. Tester la combinaison | minor |
 | `display.py` -- colonnes inconnues | `--columns unknown` doit lever une erreur claire, pas un KeyError silencieux | minor |
 | `collector.py` -- state=all milestones | Plus d'appels API que `state=open`. Risque de rate limiting sur les instances avec beaucoup de repos/milestones | minor |
 | `exporter.py` -- milestones JSON | Le format JSON des milestones doit etre coherent avec celui des repos (meme structure de sanitisation) | minor |
 | `pyproject.toml` -- PyYAML | Nouvelle dependance a auditer (pas de CVE connue sur les versions recentes) | minor |
 ---
 ## Issues Gitea rattachees
 | Issue | Titre | Phase |
 |-------|-------|-------|
 | [#18](https://gitea.tsmse.fr/admin/gitea-dashboard/issues/18) | fix: handle API timeout during paginated requests | Phase 1 |
 | [#17](https://gitea.tsmse.fr/admin/gitea-dashboard/issues/17) | feat: YAML configuration file support | Phase 1 |
 | [#16](https://gitea.tsmse.fr/admin/gitea-dashboard/issues/16) | feat: milestone progress view (--milestones) | Phase 2 |
 | [#19](https://gitea.tsmse.fr/admin/gitea-dashboard/issues/19) | improvement: configurable column visibility (--columns) | Phase 2 |
 ---
 ## Dependances
 | Dependance | Type | Version | Changement v1.4.0 |
 |------------|------|---------|--------------------|
 | Python | Runtime | >= 3.10 | Inchange |
 | requests | Librairie | >= 2.31 | Inchange |
 | rich | Librairie | >= 13.0 | Inchange |
 | PyYAML | Librairie | >= 6.0 | **Nouveau** (#17) |
 | pytest | Dev | >= 7.0 | Inchange |
 | ruff | Dev | >= 0.4 | Inchange |
 | Instance Gitea | Service externe | 192.168.0.106:3000 | Inchange |
 ---
 ## Criteres de validation par issue
 | Issue | Criteres de validation |
 |-------|----------------------|
 | #16 | `--milestones` affiche un tableau avec colonnes Repo/Milestone/Open/Closed/Progress. Compatible `--repo` et `--exclude`. Compatible `--format json`. Tests : collecte, affichage, filtrage, export JSON. |
 | #17 | `.gitea-dashboard.yml` ou `~/.config/gitea-dashboard/config.yml` charge. `--config <path>` fonctionne. Priorite CLI > env > config > defaults. Resolution `${VAR}`. Tests : YAML valide/invalide/partiel/vide, resolution vars, priorite. PyYAML dans pyproject.toml. |
 | #18 | Timeout sur page > 1 retourne donnees partielles + warning. Timeout sur page 1 crashe normalement. Retry (max 2) avec backoff lineaire (1s, 2s) sur ReadTimeout et ConnectTimeout. Tests : mock timeout page 2, degradation gracieuse, warning emis. |
 | #19 | `--columns name,issues` affiche seulement ces colonnes. `--columns -description` exclut la colonne. `--columns help` affiche la liste. `--no-desc` reste fonctionnel. Erreur claire si colonne inconnue. Tests : parsing, inclusion, exclusion, combinaison avec --no-desc, validation. |
--- a/docs/technical/ARCHITECTURE.md
+++ b/docs/technical/ARCHITECTURE.md
@@ -160,3 +160,9 @@ Decisions cles pour v1.3.0 :
 - **ADR-009** : Retry HTTP 429 avec Retry-After dans _get_with_retry
 - **ADR-010** : Sanitisation des caracteres de controle dans exporter.py
 - **ADR-011** : --health comme commande alternative, pas sous-commande
 Decisions cles pour v1.4.0 :
 - **ADR-012** : Degradation gracieuse sur timeout dans _get_paginated
 - **ADR-013** : Nouveau module config.py pour la configuration YAML
 - **ADR-014** : Dataclass MilestoneData pour la vue milestones
 - **ADR-015** : Colonnes configurables par inclusion/exclusion
--- a/docs/technical/decisions.md
+++ b/docs/technical/decisions.md
@@ -167,3 +167,62 @@
 - Un seul niveau d'arguments
 - `--health` est mutuellement exclusif avec le mode dashboard
 - Si d'autres modes alternatifs apparaissent, reconsiderer les sous-commandes
 ## ADR-012 : Degradation gracieuse sur timeout dans _get_paginated (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : Un timeout reseau sur une page intermediaire de la pagination fait crasher tout le collecteur. Le retry existant (ADR-007/ADR-009) retente les requetes individuelles, mais apres epuisement des retries, l'exception remonte et les donnees des pages precedentes sont perdues.
 **Decision** : Dans `_get_paginated`, catch les exceptions Timeout apres epuisement des retries uniquement pour les pages > 1. Retourner les donnees collectees jusque-la et emettre un `warnings.warn()`. Si la premiere page echoue, l'exception remonte normalement.
 **Consequences** :
 - Le dashboard affiche un resultat partiel plutot qu'un crash
 - L'utilisateur est informe via un warning
 - La premiere page echouee reste un crash clair
 - Coherent avec le principe "Gestion gracieuse" de CLAUDE.md
 ## ADR-013 : Nouveau module config.py pour la configuration YAML (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : L'issue #17 demande un fichier de configuration YAML. La logique (lecture fichier, resolution variables, merge de priorites) est distincte du parsing CLI.
 **Decision** : Creer `config.py` comme 7eme module source. Nouvelle dependance PyYAML. Le principe "un module = une responsabilite" de ADR-002 reste respecte.
 **Consequences** :
 - Separation claire : cli.py parse les args, config.py resout la configuration
 - Le module est testable independamment avec des fixtures YAML
 - Premiere nouvelle dependance ajoutee au projet (PyYAML)
 - Le merge de priorites (CLI > env > config > defaults) est centralise et testable
 ## ADR-014 : Dataclass MilestoneData pour la vue milestones (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : La vue `--milestones` collecte des milestones de tous les repos. Les milestones de l'API sont des dicts bruts sans reference au repo parent.
 **Decision** : Creer un dataclass `MilestoneData` dans collector.py. Collecte avec `state=all` pour afficher l'historique complet.
 **Consequences** :
 - Coherent avec RepoData : donnees normalisees et documentees
 - Le calcul du pourcentage de progression est centralise dans le collecteur
 - `state=all` augmente les appels API mais donne une vue complete
 ## ADR-015 : Colonnes configurables par inclusion/exclusion (v1.4.0)
 **Date** : 2026-03-13
 **Statut** : accepte
 **Contexte** : L'issue #19 demande de pouvoir choisir les colonnes affichees. L'approche actuelle (`--no-desc`) est ad hoc. Un systeme generique est maintenant justifie par le besoin.
 **Decision** : Ajouter `--columns` avec syntaxe a virgules. Support inclusion directe et exclusion par prefixe `-`. `--no-desc` reste fonctionnel comme alias.
 **Consequences** :
 - Remplace l'approche YAGNI de v1.3.0 (maintenant justifie)
 - Retrocompatible : `--no-desc` continue de fonctionner
 - `--columns help` fournit une aide contextuelle
 - Les deux flags combines s'appliquent cumulativement
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,12 +4,13 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "gitea-dashboard"
-version = "1.3.0"
+version = "1.4.0"
 description = "CLI dashboard for Gitea repos status"
 requires-python = ">=3.10"
 dependencies = [
    "requests>=2.31",
    "rich>=13.0",
    "pyyaml>=6.0",
 ]
 [project.optional-dependencies]
--- a/src/gitea_dashboard/cli.py
+++ b/src/gitea_dashboard/cli.py
@@ -10,9 +10,16 @@ import requests
 from rich.console import Console
 from gitea_dashboard.client import GiteaClient
-from gitea_dashboard.collector import collect_all
+from gitea_dashboard.collector import collect_all, collect_milestones
-from gitea_dashboard.display import render_dashboard, sort_repos
+from gitea_dashboard.config import load_config, merge_config
-from gitea_dashboard.exporter import export_json
+from gitea_dashboard.display import (
    AVAILABLE_COLUMNS,
    parse_columns,
    render_dashboard,
    render_milestones,
    sort_repos,
 )
 from gitea_dashboard.exporter import export_json, export_milestones_json
 _DEFAULT_URL = "http://192.168.0.106:3000"
@@ -23,9 +30,12 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
    Options:
        --repo / -r : noms de repos a inclure (repeatable)
        --exclude / -x : noms de repos a exclure (repeatable)
        --milestones : affiche la vue milestones au lieu du dashboard repos
        --columns : liste des colonnes a afficher
        --config : chemin vers un fichier de configuration YAML alternatif
    Returns:
-        Namespace avec .repo (list[str] | None) et .exclude (list[str] | None)
+        Namespace avec les options parsees.
    """
    parser = argparse.ArgumentParser(
        description="Dashboard CLI affichant l'etat des repos Gitea.",
@@ -71,9 +81,78 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
        default=False,
        help="Masque la colonne Description dans le tableau.",
    )
    parser.add_argument(
        "--config",
        default=None,
        help="Chemin vers un fichier de configuration YAML alternatif.",
    )
    parser.add_argument(
        "--milestones",
        action="store_true",
        default=False,
        help="Affiche la vue milestones au lieu du dashboard repos.",
    )
    parser.add_argument(
        "--columns",
        default=None,
        help="Colonnes a afficher (separees par virgules). Prefixe '-' pour exclure. 'help' pour lister.",
    )
    return parser.parse_args(argv)
 def _resolve_config(args: argparse.Namespace) -> argparse.Namespace:
    """Resout la configuration en appliquant la priorite CLI > env > config > defaults.
    1. Charge le fichier config (args.config ou chemin par defaut)
    2. Lit les variables d'environnement pertinentes
    3. Fusionne avec les valeurs CLI
    4. Retourne un Namespace enrichi
    """
    file_config = load_config(args.config)
    # Map YAML key "token" to internal key "auth" for merge consistency
    if "token" in file_config:
        file_config["auth"] = file_config.pop("token")
    env_vars: dict = {}
    gitea_url_env = os.environ.get("GITEA_URL")
    if gitea_url_env:
        env_vars["url"] = gitea_url_env
    gitea_auth_env = os.environ.get("GITEA_TOKEN")
    if gitea_auth_env:
        env_vars["auth"] = gitea_auth_env
    cli_args: dict = {}
    if args.sort != "name":
        cli_args["sort"] = args.sort
    if args.repo is not None:
        cli_args["include"] = args.repo
    if args.exclude is not None:
        cli_args["exclude"] = args.exclude
    if args.no_desc:
        cli_args["no_desc"] = True
    defaults = {
        "url": _DEFAULT_URL,
        "sort": "name",
        "no_desc": False,
    }
    merged = merge_config(cli_args, env_vars, file_config, defaults)
    args.resolved_url = merged.get("url", _DEFAULT_URL)
    args.resolved_auth = merged.get("auth")
    args.sort = merged.get("sort", args.sort)
    if merged.get("include") and args.repo is None:
        args.repo = merged["include"]
    if merged.get("exclude") and args.exclude is None:
        args.exclude = merged["exclude"]
    if merged.get("no_desc") and not args.no_desc:
        args.no_desc = merged["no_desc"]
    return args
 def _run_health_check(client: GiteaClient, console: Console) -> None:
    """Execute le health check et affiche les resultats.
@@ -88,38 +167,81 @@ def _run_health_check(client: GiteaClient, console: Console) -> None:
    console.print(f"{len(repos)} repos accessibles")
 def _print_columns_help(console: Console) -> None:
    """Affiche les colonnes disponibles."""
    console.print("Colonnes disponibles :")
    for name, desc in AVAILABLE_COLUMNS.items():
        console.print(f"  {name:15s} {desc}")
 def main(argv: list[str] | None = None) -> None:
    """Point d'entree principal.
    Args:
        argv: Arguments CLI. Si None, utilise sys.argv (via argparse).
-    1. Parse les options CLI (--repo, --exclude)
+    1. Parse les options CLI
-    2. Lit GITEA_URL (defaut: http://192.168.0.106:3000) et GITEA_TOKEN (requis)
+    2. Resout la configuration (CLI > env > config > defaults)
    3. Cree le GiteaClient
-    4. Collecte les donnees via collect_all() avec filtres
+    4. Route vers le mode appropriate (health, milestones, dashboard)
-    5. Affiche via render_dashboard()
+    5. Gere les erreurs : config manquante, connexion refusee, timeout
    6. Gere les erreurs : config manquante, connexion refusee, timeout
    """
    args = parse_args(argv)
    console = Console(stderr=True)
-    token = os.environ.get("GITEA_TOKEN")
+    try:
-    if not token:
+        args = _resolve_config(args)
    except (FileNotFoundError, ValueError) as exc:
        console.print(f"[red]Erreur config : {exc}[/red]")
        sys.exit(1)
    # Handle --columns help before auth check
    if args.columns is not None:
        cols = parse_columns(args.columns, no_desc=args.no_desc)
        if cols == ["__help__"]:
            _print_columns_help(Console())
            return
    else:
        cols = None
    auth = args.resolved_auth if hasattr(args, "resolved_auth") and args.resolved_auth else None
    if not auth:
        auth = os.environ.get("GITEA_TOKEN")
    if not auth:
        console.print(
            "[red]Erreur : GITEA_TOKEN non defini. Exportez la variable d'environnement.[/red]"
        )
        sys.exit(1)
-    url = os.environ.get("GITEA_URL", _DEFAULT_URL)
+    # Detect unresolved ${VAR} references in token (SEC-001)
    if "${" in auth:
        console.print(
            "[red]Erreur : le token contient une reference ${...} non resolue. "
            "Verifiez que la variable d'environnement est definie.[/red]"
        )
        sys.exit(1)
-    client = GiteaClient(url, token)
+    url = (
        args.resolved_url
        if hasattr(args, "resolved_url")
        else os.environ.get("GITEA_URL", _DEFAULT_URL)
    )
    client = GiteaClient(url, auth)
    try:
        if args.health:
            _run_health_check(client, console)
            return
        if args.milestones:
            milestones = collect_milestones(client, include=args.repo, exclude=args.exclude)
            if args.format == "json":
                print(export_milestones_json(milestones))  # noqa: T201
            else:
                render_milestones(milestones)
            return
        repos = collect_all(client, include=args.repo, exclude=args.exclude)
    except requests.ConnectionError:
        console.print("[red]Erreur : connexion refusee. Verifiez l'URL et le serveur Gitea.[/red]")
@@ -132,8 +254,8 @@ def main(argv: list[str] | None = None) -> None:
    except requests.RequestException as exc:
        # Ne jamais afficher le token dans les messages d'erreur
        msg = str(exc)
-        if token in msg:
+        if auth in msg:
-            msg = msg.replace(token, "***")
+            msg = msg.replace(auth, "***")
        console.print(f"[red]Erreur API : {msg}[/red]")
        sys.exit(1)
@@ -141,4 +263,11 @@ def main(argv: list[str] | None = None) -> None:
        sorted_repos = sort_repos(repos, args.sort)
        print(export_json(sorted_repos))  # noqa: T201
    else:
-        render_dashboard(repos, sort_key=args.sort, show_description=not args.no_desc)
+        # Resolve columns for dashboard
        active_cols = cols if cols is not None else parse_columns(None, no_desc=args.no_desc)
        render_dashboard(
            repos,
            sort_key=args.sort,
            show_description="description" in active_cols,
            columns=active_cols,
        )
--- a/src/gitea_dashboard/client.py
+++ b/src/gitea_dashboard/client.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 import time
 import warnings
 import requests
@@ -86,6 +87,11 @@ class GiteaClient:
        Boucle tant que len(page) == limit (50).
        Utilise _get_with_retry pour la resilience aux timeouts.
        Si _get_with_retry leve une exception Timeout sur une page
        intermediaire (page > 1), retourne les donnees collectees
        jusque-la et emet un warning via warnings.warn().
        Si la premiere page echoue, l'exception remonte normalement.
        """
        all_items: list[dict] = []
        page = 1
@@ -95,7 +101,17 @@ class GiteaClient:
            merged_params["limit"] = self._PAGE_LIMIT
            merged_params["page"] = page
            url = f"{self.base_url}{endpoint}"
            try:
                resp = self._get_with_retry(url, params=merged_params)
            except (requests.exceptions.ReadTimeout, requests.exceptions.ConnectTimeout):
                if page == 1:
                    raise
                warnings.warn(
                    f"Partial data: timeout on page {page} of {endpoint} "
                    f"(collected {len(all_items)} items so far)",
                    stacklevel=2,
                )
                return all_items
            resp.raise_for_status()
            items = resp.json()
            all_items.extend(items)
@@ -126,14 +142,17 @@ class GiteaClient:
        resp.raise_for_status()
        return resp.json()
-    def get_milestones(self, owner: str, repo: str) -> list[dict]:
+    def get_milestones(self, owner: str, repo: str, state: str = "open") -> list[dict]:
-        """Retourne les milestones ouvertes du repo.
+        """Retourne les milestones du repo.
-        Endpoint: GET /api/v1/repos/{owner}/{repo}/milestones?state=open
+        Endpoint: GET /api/v1/repos/{owner}/{repo}/milestones?state={state}
        Args:
            state: Filtre par etat ("open", "closed", "all"). Defaut: "open".
        """
        return self._get_paginated(
            f"/api/v1/repos/{owner}/{repo}/milestones",
-            params={"state": "open"},
+            params={"state": state},
        )
    def get_version(self) -> dict:
--- a/src/gitea_dashboard/collector.py
+++ b/src/gitea_dashboard/collector.py
@@ -23,6 +23,19 @@ class RepoData:
    last_commit_date: str | None  # ISO 8601, ex: "2026-03-10T14:30:00Z"
@dataclass
 class MilestoneData:
    """Donnees agregees d'une milestone avec son repo parent."""
    repo_name: str
    title: str
    open_issues: int
    closed_issues: int
    progress_pct: int  # Pourcentage de completion (0-100)
    due_on: str | None  # ISO 8601 ou None
    state: str  # "open" ou "closed"
 def _matches_any(name: str, patterns: list[str]) -> bool:
    """Return True if name contains any of the patterns (case-insensitive)."""
    name_lower = name.lower()
@@ -49,10 +62,7 @@ def collect_all(
    repos = client.get_repos()
    # Filtrage post-fetch : l'API Gitea ne supporte pas le filtre par nom
-    if include:
+    repos = _filter_repos(repos, include, exclude)
        repos = [r for r in repos if _matches_any(r["name"], include)]
    if exclude:
        repos = [r for r in repos if not _matches_any(r["name"], exclude)]
    result: list[RepoData] = []
@@ -79,3 +89,58 @@ def collect_all(
        )
    return result
 def _filter_repos(
    repos: list[dict],
    include: list[str] | None = None,
    exclude: list[str] | None = None,
 ) -> list[dict]:
    """Filtre les repos par include/exclude (logique partagee)."""
    if include:
        repos = [r for r in repos if _matches_any(r["name"], include)]
    if exclude:
        repos = [r for r in repos if not _matches_any(r["name"], exclude)]
    return repos
 def collect_milestones(
    client: GiteaClient,
    include: list[str] | None = None,
    exclude: list[str] | None = None,
 ) -> list[MilestoneData]:
    """Collecte les milestones de tous les repos accessibles.
    Reutilise la logique de filtrage de collect_all (include/exclude).
    Pour chaque repo filtre, appelle client.get_milestones() avec state=all.
    Retourne une liste plate de MilestoneData triee par repo puis milestone.
    """
    repos = client.get_repos()
    repos = _filter_repos(repos, include, exclude)
    result: list[MilestoneData] = []
    for repo in repos:
        owner = repo["owner"]["login"]
        name = repo["name"]
        milestones = client.get_milestones(owner, name, state="all")
        for ms in milestones:
            total = ms["open_issues"] + ms["closed_issues"]
            pct = round(ms["closed_issues"] / total * 100) if total > 0 else 0
            result.append(
                MilestoneData(
                    repo_name=name,
                    title=ms["title"],
                    open_issues=ms["open_issues"],
                    closed_issues=ms["closed_issues"],
                    progress_pct=pct,
                    due_on=ms.get("due_on"),
                    state=ms.get("state", "open"),
                )
            )
    return result
--- a/src/gitea_dashboard/config.py
+++ b/src/gitea_dashboard/config.py
@@ -0,0 +1,112 @@
 """Configuration YAML pour gitea-dashboard."""
 from __future__ import annotations
 import os
 import re
 from pathlib import Path
 from typing import Any
 import yaml
 _DEFAULT_CONFIG_PATHS = [
    Path(".gitea-dashboard.yml"),
    Path.home() / ".config" / "gitea-dashboard" / "config.yml",
 ]
 _ENV_VAR_RE = re.compile(r"\$\{([^}]+)\}")
 def resolve_env_vars(value: str) -> str:
    """Resout les references ${VAR} dans une valeur string.
    Remplace ${VAR} par os.environ[VAR].
    Si VAR n'est pas defini, laisse la reference telle quelle.
    Ne resout pas les references imbriquees.
    """
    def _replace(match: re.Match) -> str:
        var_name = match.group(1)
        return os.environ.get(var_name, match.group(0))
    return _ENV_VAR_RE.sub(_replace, value)
 def _resolve_values(data: Any) -> Any:
    """Resout recursivement les ${VAR} dans les valeurs string et listes."""
    if isinstance(data, str):
        return resolve_env_vars(data)
    if isinstance(data, list):
        return [_resolve_values(item) for item in data]
    if isinstance(data, dict):
        return {k: _resolve_values(v) for k, v in data.items()}
    return data
 def load_config(config_path: str | None = None) -> dict[str, Any]:
    """Charge la configuration depuis un fichier YAML.
    Ordre de recherche si config_path est None :
    1. .gitea-dashboard.yml (repertoire courant)
    2. ~/.config/gitea-dashboard/config.yml
    Retourne un dict vide si aucun fichier trouve.
    Leve FileNotFoundError si config_path est fourni mais n'existe pas.
    Leve ValueError si le YAML est syntaxiquement invalide.
    """
    if config_path is not None:
        path = Path(config_path)
        if not path.exists():
            msg = f"Config file not found: {config_path}"
            raise FileNotFoundError(msg)
        return _load_yaml_file(path)
    for path in _DEFAULT_CONFIG_PATHS:
        if path.exists():
            return _load_yaml_file(path)
    return {}
 def _load_yaml_file(path: Path) -> dict[str, Any]:
    """Charge et parse un fichier YAML avec resolution des variables."""
    try:
        raw = yaml.safe_load(path.read_text(encoding="utf-8"))
    except yaml.YAMLError as exc:
        msg = f"Invalid YAML in {path}: {exc}"
        raise ValueError(msg) from exc
    if raw is None:
        return {}
    if not isinstance(raw, dict):
        msg = f"Invalid config format in {path}: expected a mapping, got {type(raw).__name__}"
        raise ValueError(msg)
    return _resolve_values(raw)
 def merge_config(
    cli_args: dict[str, Any],
    env_vars: dict[str, Any],
    file_config: dict[str, Any],
    defaults: dict[str, Any],
 ) -> dict[str, Any]:
    """Fusionne les sources de configuration par priorite.
    Priorite : cli_args > env_vars > file_config > defaults.
    Une valeur None dans une source de priorite superieure ne masque pas
    la valeur d'une source de priorite inferieure.
    """
    all_keys = set()
    for source in (cli_args, env_vars, file_config, defaults):
        all_keys.update(source.keys())
    result: dict[str, Any] = {}
    for key in all_keys:
        for source in (cli_args, env_vars, file_config, defaults):
            value = source.get(key)
            if value is not None:
                result[key] = value
                break
    return result
--- a/src/gitea_dashboard/display.py
+++ b/src/gitea_dashboard/display.py
@@ -7,7 +7,66 @@ from datetime import datetime, timezone
 from rich.console import Console
 from rich.table import Table
-from gitea_dashboard.collector import RepoData
+from gitea_dashboard.collector import MilestoneData, RepoData
 AVAILABLE_COLUMNS: dict[str, str] = {
    "name": "Nom du repo",
    "description": "Description du repo",
    "issues": "Nombre d'issues ouvertes",
    "release": "Derniere release",
    "commit": "Date du dernier commit",
    "activity": "Indicateur d'activite",
 }
 def parse_columns(columns_arg: str | None, no_desc: bool = False) -> list[str]:
    """Parse l'argument --columns et retourne la liste des colonnes a afficher.
    Si columns_arg est None : retourne toutes les colonnes (sauf description si no_desc).
    Si columns_arg est "help" : retourne la liste speciale ["__help__"].
    Les colonnes sont separees par des virgules.
    Le prefixe "-" exclut une colonne (ex: "-description").
    Leve ValueError si une colonne inconnue est specifiee.
    """
    if columns_arg is not None and columns_arg.strip() == "help":
        return ["__help__"]
    all_cols = list(AVAILABLE_COLUMNS.keys())
    if columns_arg is None:
        result = list(all_cols)
        if no_desc and "description" in result:
            result.remove("description")
        return result
    parts = [p.strip() for p in columns_arg.split(",") if p.strip()]
    # Detect mode: exclusion if all parts start with "-"
    is_exclusion = all(p.startswith("-") for p in parts)
    if is_exclusion:
        result = list(all_cols)
        if no_desc and "description" in result:
            result.remove("description")
        for part in parts:
            col_name = part[1:]  # Remove "-" prefix
            if col_name not in AVAILABLE_COLUMNS:
                msg = f"Unknown column: '{col_name}'. Use --columns help for available columns."
                raise ValueError(msg)
            if col_name in result:
                result.remove(col_name)
        return result
    # Inclusion mode
    result = []
    for part in parts:
        if part not in AVAILABLE_COLUMNS:
            msg = f"Unknown column: '{part}'. Use --columns help for available columns."
            raise ValueError(msg)
        result.append(part)
    if no_desc and "description" in result:
        result.remove("description")
    return result
 def _format_repo_name(repo: RepoData) -> str:
@@ -134,6 +193,7 @@ def render_dashboard(
    console: Console | None = None,
    sort_key: str = "name",
    show_description: bool = True,
    columns: list[str] | None = None,
 ) -> None:
    """Affiche le dashboard complet dans le terminal.
@@ -145,6 +205,7 @@ def render_dashboard(
    Le parametre console permet l'injection pour les tests.
    Si show_description est True, ajoute une colonne "Description"
    entre "Repo" et "Issues", tronquee a 40 caracteres.
    Si columns est fourni, seules ces colonnes sont affichees.
    """
    if console is None:
        console = Console()
@@ -153,38 +214,60 @@ def render_dashboard(
        console.print("Aucun repo trouve.")
        return
    # Determine les colonnes a afficher
    if columns is not None:
        active_cols = columns
    else:
        active_cols = list(AVAILABLE_COLUMNS.keys())
        if not show_description and "description" in active_cols:
            active_cols.remove("description")
    # Tri des repos
    sorted_repos = sort_repos(repos, sort_key)
    # Tableau principal
    table = Table(title="Gitea Dashboard")
-    table.add_column("Repo", style="bold")
+
-    if show_description:
+    # Map colonne -> config Rich
-        table.add_column("Description")
+    col_config = {
-    table.add_column("Issues", justify="right")
+        "name": ("Repo", {"style": "bold"}),
-    table.add_column("Release")
+        "description": ("Description", {}),
-    table.add_column("Dernier commit")
+        "issues": ("Issues", {"justify": "right"}),
        "release": ("Release", {}),
        "commit": ("Dernier commit", {}),
        "activity": ("Activite", {}),
    }
    for col in active_cols:
        if col in col_config:
            label, kwargs = col_config[col]
            table.add_column(label, **kwargs)
    for repo in sorted_repos:
-        name = _format_repo_name(repo)
+        row: list[str] = []
        for col in active_cols:
            if col == "name":
                row.append(_format_repo_name(repo))
            elif col == "description":
                row.append(_truncate(repo.description or ""))
            elif col == "issues":
                issues_str = str(repo.open_issues)
                issues_style = "red" if repo.open_issues > 0 else "green"
-        release_str = _format_release(repo.latest_release)
+                row.append(f"[{issues_style}]{issues_str}[/{issues_style}]")
-        commit_str = (
+            elif col == "release":
-            _format_relative_date(repo.last_commit_date) if repo.last_commit_date else "\u2014"
+                row.append(_format_release(repo.latest_release))
            elif col == "commit":
                row.append(
                    _format_relative_date(repo.last_commit_date)
                    if repo.last_commit_date
                    else "\u2014"
                )
-
+            elif col == "activity":
-        row = [name]
+                row.append(
-        if show_description:
+                    _format_relative_date(repo.last_commit_date)
-            row.append(_truncate(repo.description or ""))
+                    if repo.last_commit_date
-        row.extend(
+                    else "\u2014"
            [
                f"[{issues_style}]{issues_str}[/{issues_style}]",
                release_str,
                commit_str,
            ]
                )
        table.add_row(*row)
    console.print(table)
@@ -220,3 +303,49 @@ def render_dashboard(
                    console.print(f"[{style}]{line}[/{style}]")
                else:
                    console.print(line)
 def render_milestones(
    milestones: list[MilestoneData],
    console: Console | None = None,
 ) -> None:
    """Affiche le tableau des milestones.
    Colonnes : Repo, Milestone, Open, Closed, Progress (%).
    La barre de progression utilise le pourcentage calcule.
    Coloration : vert > 80%, jaune 50-80%, rouge < 50%.
    """
    if console is None:
        console = Console()
    if not milestones:
        console.print("Aucune milestone trouvee.")
        return
    table = Table(title="Milestones")
    table.add_column("Repo", style="bold")
    table.add_column("Milestone")
    table.add_column("Open", justify="right")
    table.add_column("Closed", justify="right")
    table.add_column("Progress", justify="right")
    for ms in milestones:
        # Coloration du pourcentage
        if ms.progress_pct > 80:
            pct_style = "green"
        elif ms.progress_pct >= 50:
            pct_style = "yellow"
        else:
            pct_style = "red"
        pct_str = f"[{pct_style}]{ms.progress_pct}%[/{pct_style}]"
        table.add_row(
            ms.repo_name,
            ms.title,
            str(ms.open_issues),
            str(ms.closed_issues),
            pct_str,
        )
    console.print(table)
--- a/src/gitea_dashboard/exporter.py
+++ b/src/gitea_dashboard/exporter.py
@@ -6,7 +6,7 @@ import json
 import re
 from dataclasses import asdict
-from gitea_dashboard.collector import RepoData
+from gitea_dashboard.collector import MilestoneData, RepoData
 # Caracteres de controle ASCII (0x00-0x1F) sauf \t (0x09), \n (0x0A), \r (0x0D)
 _CONTROL_CHAR_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f]")
@@ -44,3 +44,23 @@ def export_json(repos: list[RepoData], indent: int = 2) -> str:
        Chaine JSON indentee, prete pour stdout ou ecriture fichier.
    """
    return json.dumps(repos_to_dicts(repos), indent=indent, ensure_ascii=False)
 def milestones_to_dicts(milestones: list[MilestoneData]) -> list[dict]:
    """Convertit une liste de MilestoneData en liste de dicts serialisables.
    Sanitize les champs texte (repo_name, title) pour les caracteres de controle.
    """
    result = []
    for ms in milestones:
        d = asdict(ms)
        for field in ("repo_name", "title"):
            if isinstance(d.get(field), str):
                d[field] = _sanitize_control_chars(d[field])
        result.append(d)
    return result
 def export_milestones_json(milestones: list[MilestoneData], indent: int = 2) -> str:
    """Exporte les milestones en JSON formate."""
    return json.dumps(milestones_to_dicts(milestones), indent=indent, ensure_ascii=False)
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -26,9 +26,10 @@ class TestMainNominal:
        mock_client_cls.assert_called_once_with("http://localhost:3000", "test-token-123")
        mock_collect.assert_called_once_with(mock_client, include=None, exclude=None)
-        mock_render.assert_called_once_with(
+        mock_render.assert_called_once()
-            mock_collect.return_value, sort_key="name", show_description=True
+        call_kwargs = mock_render.call_args
-        )
+        assert call_kwargs[1]["sort_key"] == "name"
        assert call_kwargs[1]["show_description"] is True
    @patch("gitea_dashboard.cli.render_dashboard")
    @patch("gitea_dashboard.cli.collect_all")
@@ -365,9 +366,10 @@ class TestMainNoDesc:
        with patch.dict("os.environ", env, clear=True):
            main(["--no-desc"])
-        mock_render.assert_called_once_with(
+        mock_render.assert_called_once()
-            mock_collect.return_value, sort_key="name", show_description=False
+        call_kwargs = mock_render.call_args
-        )
+        assert call_kwargs[1]["sort_key"] == "name"
        assert call_kwargs[1]["show_description"] is False
 class TestMainFormatJson:
@@ -389,3 +391,136 @@ class TestMainFormatJson:
        captured = capsys.readouterr()
        parsed = json.loads(captured.out)
        assert isinstance(parsed, list)
 class TestParseArgsMilestones:
    """Test --milestones argument parsing."""
    def test_parse_args_milestones(self):
        """--milestones sets milestones=True."""
        from gitea_dashboard.cli import parse_args
        args = parse_args(["--milestones"])
        assert args.milestones is True
    def test_parse_args_milestones_default(self):
        """Without --milestones, milestones is False."""
        from gitea_dashboard.cli import parse_args
        args = parse_args([])
        assert args.milestones is False
 class TestMainTokenFromConfig:
    """Test main() reads token from YAML config file."""
    @patch("gitea_dashboard.cli.render_dashboard")
    @patch("gitea_dashboard.cli.collect_all")
    @patch("gitea_dashboard.cli.GiteaClient")
    @patch("gitea_dashboard.cli.load_config")
    def test_yaml_token_key_mapped_to_auth(
        self, mock_load_config, mock_client_cls, mock_collect, mock_render
    ):
        """YAML 'token' key is properly mapped to auth for GiteaClient."""
        mock_load_config.return_value = {"token": "yaml-token-123", "url": "http://yaml:3000"}
        mock_client_cls.return_value = MagicMock()
        mock_collect.return_value = []
        with patch.dict("os.environ", {}, clear=True):
            main([])
        mock_client_cls.assert_called_once_with("http://yaml:3000", "yaml-token-123")
 class TestMainUnresolvedToken:
    """Test main() rejects unresolved ${VAR} in token."""
    def test_unresolved_env_var_in_token(self, capsys):
        """Token containing ${...} is rejected with clear error."""
        env = {"GITEA_TOKEN": "${GITEA_TOKEN}"}
        with patch.dict("os.environ", env, clear=True):
            with pytest.raises(SystemExit) as exc_info:
                main([])
        assert exc_info.value.code == 1
        captured = capsys.readouterr()
        assert "${" in captured.err
 class TestParseArgsColumns:
    """Test --columns argument parsing."""
    def test_parse_args_columns(self):
        """--columns name,issues sets columns='name,issues'."""
        from gitea_dashboard.cli import parse_args
        args = parse_args(["--columns", "name,issues"])
        assert args.columns == "name,issues"
    def test_parse_args_columns_default(self):
        """Without --columns, columns is None."""
        from gitea_dashboard.cli import parse_args
        args = parse_args([])
        assert args.columns is None
 class TestMainMilestonesMode:
    """Test main() with --milestones."""
    @patch("gitea_dashboard.cli.render_milestones")
    @patch("gitea_dashboard.cli.collect_milestones")
    @patch("gitea_dashboard.cli.GiteaClient")
    def test_main_milestones_mode(self, mock_client_cls, mock_collect_ms, mock_render_ms):
        """--milestones routes to collect_milestones + render_milestones."""
        env = {"GITEA_TOKEN": "test-tok"}
        mock_client_cls.return_value = MagicMock()
        mock_collect_ms.return_value = []
        with patch.dict("os.environ", env, clear=True):
            main(["--milestones"])
        mock_collect_ms.assert_called_once()
        mock_render_ms.assert_called_once()
 class TestMainColumnsHelp:
    """Test main() with --columns help."""
    @patch("gitea_dashboard.cli.GiteaClient")
    def test_main_columns_help(self, mock_client_cls, capsys):
        """--columns help displays ALL available columns and does not instantiate client."""
        from gitea_dashboard.display import AVAILABLE_COLUMNS
        env = {"GITEA_TOKEN": "test-tok"}
        mock_client_cls.return_value = MagicMock()
        with patch.dict("os.environ", env, clear=True):
            main(["--columns", "help"])
        captured = capsys.readouterr()
        combined = captured.out + captured.err
        # Every column key must appear in the output
        for col_name in AVAILABLE_COLUMNS:
            assert col_name in combined, f"Column '{col_name}' missing from --columns help output"
        # GiteaClient should NOT have been instantiated (help exits early)
        mock_client_cls.assert_not_called()
    @patch("gitea_dashboard.cli.render_dashboard")
    @patch("gitea_dashboard.cli.collect_all")
    @patch("gitea_dashboard.cli.GiteaClient")
    def test_main_no_desc_and_columns_compat(self, mock_client_cls, mock_collect, mock_render):
        """--no-desc and --columns -commit both apply cumulatively."""
        env = {"GITEA_TOKEN": "test-tok"}
        mock_client_cls.return_value = MagicMock()
        mock_collect.return_value = []
        with patch.dict("os.environ", env, clear=True):
            main(["--no-desc", "--columns=-commit"])
        # render_dashboard should be called with columns excluding both description and commit
        call_kwargs = mock_render.call_args
        columns = call_kwargs[1].get("columns") if call_kwargs[1] else None
        if columns is not None:
            assert "description" not in columns
            assert "commit" not in columns
--- a/tests/test_client.py
+++ b/tests/test_client.py
@@ -427,3 +427,90 @@ class TestGetLatestCommit:
            result = client.get_latest_commit("admin", "missing-repo")
        assert result is None
 class TestGetPaginatedGracefulTimeout:
    """Test graceful degradation on timeout during pagination."""
    def _make_client(self):
        return GiteaClient("http://gitea.local:3000", "tok")
    @patch("time.sleep")
    def test_get_paginated_timeout_page2_returns_partial(self, mock_sleep):
        """Timeout on page 2 returns partial data from page 1."""
        client = self._make_client()
        page1 = [{"id": i} for i in range(50)]  # Full page -> triggers page 2
        mock_resp1 = MagicMock()
        mock_resp1.raise_for_status = MagicMock()
        mock_resp1.json.return_value = page1
        # Page 2: _get_with_retry exhausts retries and raises ReadTimeout
        with patch.object(
            client,
            "_get_with_retry",
            side_effect=[mock_resp1, requests.exceptions.ReadTimeout("timeout page 2")],
        ):
            result = client._get_paginated("/api/v1/user/repos")
        assert result == page1
    @patch("time.sleep")
    def test_get_paginated_timeout_page1_raises(self, mock_sleep):
        """Timeout on page 1 raises the exception (no partial data possible)."""
        client = self._make_client()
        with patch.object(
            client,
            "_get_with_retry",
            side_effect=requests.exceptions.ReadTimeout("timeout page 1"),
        ):
            with pytest.raises(requests.exceptions.ReadTimeout):
                client._get_paginated("/api/v1/user/repos")
    @patch("time.sleep")
    def test_get_paginated_connect_timeout_graceful(self, mock_sleep):
        """ConnectTimeout on page 2 returns partial data gracefully."""
        client = self._make_client()
        page1 = [{"id": i} for i in range(50)]
        mock_resp1 = MagicMock()
        mock_resp1.raise_for_status = MagicMock()
        mock_resp1.json.return_value = page1
        with patch.object(
            client,
            "_get_with_retry",
            side_effect=[mock_resp1, requests.exceptions.ConnectTimeout("connect timeout")],
        ):
            result = client._get_paginated("/api/v1/user/repos")
        assert result == page1
    @patch("time.sleep")
    def test_get_paginated_partial_data_emits_warning(self, mock_sleep):
        """Graceful degradation emits a warning about partial data."""
        import warnings
        client = self._make_client()
        page1 = [{"id": i} for i in range(50)]
        mock_resp1 = MagicMock()
        mock_resp1.raise_for_status = MagicMock()
        mock_resp1.json.return_value = page1
        with patch.object(
            client,
            "_get_with_retry",
            side_effect=[mock_resp1, requests.exceptions.ReadTimeout("timeout")],
        ):
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                client._get_paginated("/api/v1/user/repos")
        assert len(w) == 1
        assert "Partial data" in str(w[0].message)
        assert "page 2" in str(w[0].message)
--- a/tests/test_collector.py
+++ b/tests/test_collector.py
@@ -2,7 +2,10 @@
 from unittest.mock import MagicMock
-from gitea_dashboard.collector import RepoData, collect_all
+from gitea_dashboard.collector import (
    RepoData,
    collect_all,
 )
 def _make_repo(
@@ -311,3 +314,158 @@ class TestCollectAllFiltering:
        result_empty = collect_all(client, include=[])
        assert [r.name for r in result_empty] == [r.name for r in result_none]
 class TestCollectMilestones:
    """Test collect_milestones function."""
    def _setup_client(self, repo_names, milestones_by_repo=None):
        """Create a mock client with repos and milestones."""
        client = MagicMock()
        client.get_repos.return_value = [
            _make_repo(name=n, full_name=f"admin/{n}") for n in repo_names
        ]
        if milestones_by_repo is None:
            milestones_by_repo = {}
        def get_milestones_side_effect(owner, repo, state="all"):
            return milestones_by_repo.get(repo, [])
        client.get_milestones.side_effect = get_milestones_side_effect
        return client
    def test_collect_milestones_basic(self):
        """2 repos with milestones returns flat list of MilestoneData."""
        from gitea_dashboard.collector import MilestoneData, collect_milestones
        client = self._setup_client(
            ["repo-a", "repo-b"],
            {
                "repo-a": [
                    {
                        "title": "v1.0",
                        "open_issues": 2,
                        "closed_issues": 3,
                        "due_on": None,
                        "state": "open",
                    },
                ],
                "repo-b": [
                    {
                        "title": "v2.0",
                        "open_issues": 0,
                        "closed_issues": 5,
                        "due_on": "2026-04-01T00:00:00Z",
                        "state": "closed",
                    },
                ],
            },
        )
        result = collect_milestones(client)
        assert len(result) == 2
        assert all(isinstance(m, MilestoneData) for m in result)
        assert result[0].repo_name == "repo-a"
        assert result[0].title == "v1.0"
        assert result[1].repo_name == "repo-b"
    def test_collect_milestones_empty_repo(self):
        """Repo without milestones produces no entries."""
        from gitea_dashboard.collector import collect_milestones
        client = self._setup_client(["empty-repo"], {"empty-repo": []})
        result = collect_milestones(client)
        assert result == []
    def test_collect_milestones_progress_calculation(self):
        """3 open + 7 closed = progress_pct 70."""
        from gitea_dashboard.collector import collect_milestones
        client = self._setup_client(
            ["repo"],
            {
                "repo": [
                    {
                        "title": "v1.0",
                        "open_issues": 3,
                        "closed_issues": 7,
                        "due_on": None,
                        "state": "open",
                    },
                ],
            },
        )
        result = collect_milestones(client)
        assert result[0].progress_pct == 70
    def test_collect_milestones_with_include_filter(self):
        """Include filter is respected."""
        from gitea_dashboard.collector import collect_milestones
        client = self._setup_client(
            ["gitea-dashboard", "infra"],
            {
                "gitea-dashboard": [
                    {
                        "title": "v1.0",
                        "open_issues": 1,
                        "closed_issues": 1,
                        "due_on": None,
                        "state": "open",
                    },
                ],
                "infra": [
                    {
                        "title": "v2.0",
                        "open_issues": 0,
                        "closed_issues": 5,
                        "due_on": None,
                        "state": "closed",
                    },
                ],
            },
        )
        result = collect_milestones(client, include=["dashboard"])
        assert len(result) == 1
        assert result[0].repo_name == "gitea-dashboard"
    def test_collect_milestones_with_exclude_filter(self):
        """Exclude filter is respected."""
        from gitea_dashboard.collector import collect_milestones
        client = self._setup_client(
            ["gitea-dashboard", "old-fork"],
            {
                "gitea-dashboard": [
                    {
                        "title": "v1.0",
                        "open_issues": 1,
                        "closed_issues": 1,
                        "due_on": None,
                        "state": "open",
                    },
                ],
                "old-fork": [
                    {
                        "title": "v2.0",
                        "open_issues": 0,
                        "closed_issues": 5,
                        "due_on": None,
                        "state": "closed",
                    },
                ],
            },
        )
        result = collect_milestones(client, exclude=["fork"])
        assert len(result) == 1
        assert result[0].repo_name == "gitea-dashboard"
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -0,0 +1,133 @@
 """Tests for YAML configuration module."""
 from __future__ import annotations
 import os
 from unittest.mock import patch
 import pytest
 from gitea_dashboard.config import load_config, merge_config, resolve_env_vars
 class TestResolveEnvVars:
    """Test resolve_env_vars function."""
    def test_resolve_env_vars_simple(self):
        """${VAR} is replaced by the environment variable value."""
        with patch.dict(os.environ, {"GITEA_TOKEN": "abc123"}):
            result = resolve_env_vars("${GITEA_TOKEN}")
        assert result == "abc123"
    def test_resolve_env_vars_undefined(self):
        """${UNDEFINED} is left as-is when the variable is not set."""
        with patch.dict(os.environ, {}, clear=True):
            result = resolve_env_vars("${UNDEFINED_VAR}")
        assert result == "${UNDEFINED_VAR}"
    def test_resolve_env_vars_in_list(self):
        """resolve_env_vars works on individual string elements."""
        with patch.dict(os.environ, {"MY_VAR": "resolved"}):
            result = resolve_env_vars("prefix-${MY_VAR}-suffix")
        assert result == "prefix-resolved-suffix"
 class TestLoadConfig:
    """Test load_config function."""
    def test_load_config_valid_yaml(self, tmp_path):
        """Valid YAML file is loaded as a dict with all keys."""
        config_file = tmp_path / "config.yml"
        config_file.write_text(
            "url: http://localhost:3000\ntoken: ${GITEA_TOKEN}\nsort: activity\n"
        )
        with patch.dict(os.environ, {"GITEA_TOKEN": "secret123"}):
            result = load_config(str(config_file))
        assert result["url"] == "http://localhost:3000"
        assert result["token"] == "secret123"
        assert result["sort"] == "activity"
    def test_load_config_partial_yaml(self, tmp_path):
        """YAML with only some keys returns a partial dict."""
        config_file = tmp_path / "config.yml"
        config_file.write_text("url: http://localhost:3000\nsort: name\n")
        result = load_config(str(config_file))
        assert result["url"] == "http://localhost:3000"
        assert result["sort"] == "name"
        assert "token" not in result
    def test_load_config_empty_file(self, tmp_path):
        """Empty YAML file returns an empty dict."""
        config_file = tmp_path / "config.yml"
        config_file.write_text("")
        result = load_config(str(config_file))
        assert result == {}
    def test_load_config_invalid_yaml(self, tmp_path):
        """Syntactically invalid YAML raises a clear error."""
        config_file = tmp_path / "config.yml"
        config_file.write_text("invalid: yaml: content: [unclosed")
        with pytest.raises(ValueError, match="[Ii]nvalid"):
            load_config(str(config_file))
    def test_load_config_custom_path(self, tmp_path):
        """--config /path/to/custom.yml loads the specified file."""
        config_file = tmp_path / "custom.yml"
        config_file.write_text("sort: issues\n")
        result = load_config(str(config_file))
        assert result["sort"] == "issues"
    def test_load_config_missing_custom_path(self):
        """--config with a nonexistent path raises FileNotFoundError."""
        with pytest.raises(FileNotFoundError):
            load_config("/nonexistent/path/config.yml")
    def test_load_config_default_paths(self, tmp_path, monkeypatch):
        """Config file in current directory is auto-discovered."""
        config_file = tmp_path / ".gitea-dashboard.yml"
        config_file.write_text("sort: activity\n")
        monkeypatch.chdir(tmp_path)
        result = load_config()
        assert result["sort"] == "activity"
 class TestMergeConfig:
    """Test merge_config function."""
    def test_merge_config_priority(self):
        """CLI > env > config > defaults — CLI wins."""
        cli = {"sort": "name", "url": None}
        env = {"sort": "issues", "url": "http://env:3000"}
        config = {"sort": "activity", "url": "http://config:3000", "exclude": ["old"]}
        defaults = {"sort": "name", "url": "http://default:3000", "exclude": None}
        result = merge_config(cli, env, config, defaults)
        assert result["sort"] == "name"  # CLI wins
        assert result["url"] == "http://env:3000"  # CLI is None, env wins
        assert result["exclude"] == ["old"]  # env has no exclude, config wins
    def test_merge_config_none_does_not_override(self):
        """None in a higher-priority source does not mask a lower-priority value."""
        cli = {"token": None}
        env = {"token": None}
        config = {"token": "from-config"}
        defaults = {"token": "default-token"}
        result = merge_config(cli, env, config, defaults)
        assert result["token"] == "from-config"
--- a/tests/test_display.py
+++ b/tests/test_display.py
@@ -2,6 +2,7 @@
 from io import StringIO
 import pytest
 from rich.console import Console
 from gitea_dashboard.display import (
@@ -401,3 +402,156 @@ class TestSortRepos:
        ]
        result = sort_repos(repos, "activity")
        assert [r.name for r in result] == ["recent", "old-commit", "inactive"]
 class TestRenderMilestones:
    """Test the dedicated milestones table rendering."""
    def test_render_milestones_basic(self):
        """Milestones table displays expected columns."""
        from gitea_dashboard.collector import MilestoneData
        from gitea_dashboard.display import render_milestones
        console, buf = _make_console()
        milestones = [
            MilestoneData(
                repo_name="my-repo",
                title="v1.0",
                open_issues=2,
                closed_issues=8,
                progress_pct=80,
                due_on="2026-04-01T00:00:00Z",
                state="open",
            ),
        ]
        render_milestones(milestones, console=console)
        output = buf.getvalue()
        assert "my-repo" in output
        assert "v1.0" in output
        assert "80" in output
    def test_render_milestones_empty(self):
        """Empty list shows informative message."""
        from gitea_dashboard.display import render_milestones
        console, buf = _make_console()
        render_milestones([], console=console)
        output = buf.getvalue()
        assert "Aucune milestone" in output
    def test_render_milestones_progress_colors(self):
        """Progress coloring: green > 80%, yellow 50-80%, red < 50%."""
        from gitea_dashboard.collector import MilestoneData
        from gitea_dashboard.display import render_milestones
        console, buf = _make_console()
        milestones = [
            MilestoneData("repo", "high", 1, 9, 90, None, "open"),
            MilestoneData("repo", "mid", 3, 3, 50, None, "open"),
            MilestoneData("repo", "low", 8, 2, 20, None, "open"),
        ]
        render_milestones(milestones, console=console)
        output = buf.getvalue()
        # All three should appear without crash
        assert "high" in output
        assert "mid" in output
        assert "low" in output
 class TestParseColumns:
    """Test parse_columns function."""
    def test_parse_columns_all_default(self):
        """None returns all columns."""
        from gitea_dashboard.display import AVAILABLE_COLUMNS, parse_columns
        result = parse_columns(None)
        assert result == list(AVAILABLE_COLUMNS.keys())
    def test_parse_columns_inclusion(self):
        """'name,issues' returns only those columns."""
        from gitea_dashboard.display import parse_columns
        result = parse_columns("name,issues")
        assert result == ["name", "issues"]
    def test_parse_columns_exclusion(self):
        """'-description,-commit' returns all except those."""
        from gitea_dashboard.display import AVAILABLE_COLUMNS, parse_columns
        result = parse_columns("-description,-commit")
        assert "description" not in result
        assert "commit" not in result
        assert len(result) == len(AVAILABLE_COLUMNS) - 2
    def test_parse_columns_unknown_raises(self):
        """Unknown column raises ValueError."""
        from gitea_dashboard.display import parse_columns
        with pytest.raises(ValueError, match="unknown"):
            parse_columns("unknown")
    def test_parse_columns_help(self):
        """'help' returns sentinel list."""
        from gitea_dashboard.display import parse_columns
        result = parse_columns("help")
        assert result == ["__help__"]
    def test_parse_columns_no_desc_compat(self):
        """no_desc=True excludes description column."""
        from gitea_dashboard.display import parse_columns
        result = parse_columns(None, no_desc=True)
        assert "description" not in result
    def test_render_dashboard_with_columns(self):
        """Only specified columns appear in the output."""
        from gitea_dashboard.display import render_dashboard
        console, buf = _make_console()
        repos = [_make_repo(name="test", open_issues=5)]
        render_dashboard(repos, console=console, columns=["name", "issues"])
        output = buf.getvalue()
        assert "test" in output
        assert "Description" not in output
        assert "Release" not in output
    def test_render_dashboard_activity_column(self):
        """Activity column renders relative date from last_commit_date."""
        from gitea_dashboard.display import render_dashboard
        console, buf = _make_console()
        repos = [_make_repo(name="active-repo", last_commit_date="2026-03-10T14:30:00Z")]
        render_dashboard(repos, console=console, columns=["name", "activity"])
        output = buf.getvalue()
        assert "Activite" in output
        assert "active-repo" in output
        assert "il y a" in output or "aujourd'hui" in output
    def test_render_dashboard_activity_column_no_commit(self):
        """Activity column shows dash when no commit date."""
        from gitea_dashboard.display import render_dashboard
        console, buf = _make_console()
        repos = [_make_repo(name="empty-repo", last_commit_date=None)]
        render_dashboard(repos, console=console, columns=["name", "activity"])
        output = buf.getvalue()
        assert "\u2014" in output or "\u2014" in output
--- a/tests/test_exporter.py
+++ b/tests/test_exporter.py
@@ -138,3 +138,31 @@ class TestExportJson:
        """Empty repo list produces '[]'."""
        output = export_json([])
        assert json.loads(output) == []
 class TestExportMilestonesJson:
    """Test milestones JSON export."""
    def test_export_milestones_json_basic(self):
        """MilestoneData list produces valid JSON."""
        from gitea_dashboard.collector import MilestoneData
        from gitea_dashboard.exporter import export_milestones_json
        milestones = [
            MilestoneData("repo", "v1.0", 2, 8, 80, "2026-04-01T00:00:00Z", "open"),
        ]
        output = export_milestones_json(milestones)
        parsed = json.loads(output)
        assert len(parsed) == 1
        assert parsed[0]["repo_name"] == "repo"
        assert parsed[0]["title"] == "v1.0"
        assert parsed[0]["progress_pct"] == 80
    def test_export_milestones_json_empty(self):
        """Empty milestone list produces '[]'."""
        from gitea_dashboard.exporter import export_milestones_json
        output = export_milestones_json([])
        assert json.loads(output) == []
Author	SHA1	Message	Date
sylvain	b43a1359e6	chore(workflow): complete step 13 (retrospective), v1.4.0 done Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 04:24:22 +01:00
sylvain	0e3dff86fa	chore(workflow): complete step 11 (release v1.4.0), skip step 12 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 04:22:35 +01:00
sylvain	5d3040a6ec	docs(v1.4.0): update README, freeze CHANGELOG, bump version Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-13 04:20:36 +01:00
sylvain	84c8809f94	chore(workflow): complete step 9 (smoke test v1.4.0), start step 10+11 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 04:18:37 +01:00
sylvain	5eaccb8601	chore(workflow): complete step 8 (audit v1.4.0), start step 9 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 04:02:19 +01:00
sylvain	e02e211d86	fix(audit): correct v1.4.0 findings (6 items) - FINDING-001: add activity column rendering in render_dashboard loop - FINDING-002: map YAML 'token' key to 'auth' in _resolve_config - FINDING-003/SEC-001: reject tokens containing unresolved ${...} refs - FINDING-004: add tests for activity column rendering - FINDING-006: strengthen test_main_columns_help assertions - SEC-002: enrich timeout warning with collected items count Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:58:38 +01:00
sylvain	6f2f02409e	chore(workflow): complete step 7 (dev v1.4.0), start step 8 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:52:02 +01:00
sylvain	60c6aaede3	feat(dashboard): add milestone view and configurable columns fixes #16, fixes #19 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:50:45 +01:00
sylvain	ebf72c9a56	test(v1.4.0-p2): add failing tests for milestones and columns RED phase: 5 tests in test_collector.py (collect_milestones), 10 tests in test_display.py (render_milestones, parse_columns), 2 tests in test_exporter.py (milestones JSON), 7 tests in test_cli.py (--milestones, --columns). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:46:09 +01:00
sylvain	fdd806abcd	feat(config): add YAML config and graceful pagination timeout fixes #17, fixes #18 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:43:48 +01:00
sylvain	94de64e09a	test(v1.4.0-p1): add failing tests for timeout and YAML config RED phase: 4 new tests in test_client.py for graceful timeout on pagination, 12 new tests in test_config.py for YAML config module (import fails, module not created yet). Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:40:27 +01:00
sylvain	670222e2fd	chore(workflow): complete step 6 (plan v1.4.0), start step 7 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:35:50 +01:00
sylvain	a1f613f3d8	docs(v1.4.0): version plan and ADR Plan 2 phases : bugfix timeout + config YAML, puis vue milestones + colonnes. ADR-012 a ADR-015 couvrant degradation gracieuse, config.py, MilestoneData, et colonnes configurables. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:34:55 +01:00
sylvain	98223e4995	chore(workflow): init v1.4.0 (minor) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-13 03:28:09 +01:00
sylvain	719b36a066	chore(workflow): complete step 13 (retrospective), v1.3.0 done Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-12 19:58:54 +01:00
sylvain	e3796f64f5	chore(workflow): complete step 11 (release v1.3.0), skip step 12 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-12 19:56:08 +01:00