Clair

Clair est un projet personnel de gestion de finances développé nativement pour macOS (et iOS) avec Swift et SwiftUI. L'application permet à l'utilisateur de gérer ses comptes bancaires ("coffres"), ses transactions, ses catégories de dépenses, ses budgets, ses prévisions financières, sa liste de souhaits et des alertes, le tout stocké localement via SQLite, sans aucune donnée envoyée à un serveur.

L'architecture suit une approche en couches (Domain / Data / Presentation / Infrastructure), inspirée de la Clean Architecture, avec le pattern MVVM, le Repository Pattern et des Use Cases pour encapsuler la logique métier. L'interface utilise une navigation en sidebar latérale et un design system cohérent défini maison.

voir sur github
Swift iOS SQLite
Clair

Compte rendu

Clair est une application de gestion de finances personnelles native macOS / iOS, développée entièrement en Swift et SwiftUI. Elle adopte une architecture en couches stricte (Domain, Data, Presentation, Infrastructure) et repose sur SQLite comme base de données locale — aucune donnée ne transite par un serveur externe.

Le projet est en cours de développement. À ce stade, les fonctionnalités de gestion des comptes (coffres), des transactions et des catégories sont implémentées et fonctionnelles de bout en bout. Les sections Budgets, Prévisions, Liste de souhaits et Alertes disposent d'une interface graphique mais sont encore alimentées par des données statiques en attente d'être connectées aux repositories. L'export / import de données et la gestion complète des dépenses récurrentes sont également en cours de conception.

L'application n'est pas encore distribuée via un installeur : elle doit être compilée et lancée localement via Xcode.

Langages et technologies utilisés

  • Swift 5.9+ — langage principal
  • SwiftUI — interface graphique déclarative (macOS 13+ / iOS 16+)
  • Combine — gestion des flux asynchrones et réactifs
  • SQLite3 — base de données locale (accès bas niveau via libsqlite3)
  • Apple Charts — visualisation des données financières (graphiques)
  • AppKit — personnalisation de la fenêtre macOS (titre masqué, taille minimale)
  • LucideIcons (Swift) — bibliothèque d'icônes vectorielles
  • SwiftUIX — extensions SwiftUI (intégré, en cours d'utilisation progressive)
  • Swift Package Manager — gestion des dépendances
  • Xcode — IDE et outil de build

Présentation du contexte

La plupart des applications de finances personnelles disponibles sur le marché reposent sur des services cloud, des abonnements ou des connexions à des agrégateurs bancaires. Ces modèles posent des questions légitimes de confidentialité et de pérennité des données.

Clair est né du souhait de disposer d'un outil simple, local, entièrement sous contrôle de l'utilisateur, sans compte à créer et sans données envoyées à l'extérieur. L'interface est volontairement en français et pensée pour un usage quotidien minimaliste : consulter son solde, enregistrer une dépense, visualiser ses habitudes.

Le projet sert également de terrain d'exploration de l'architecture Clean en Swift natif, avec une séparation stricte des couches et l'utilisation de patterns éprouvés (Repository, UseCase, MVVM).

Cahier des charges

Fonctionnalités cibles

  • Gestion des comptes (Coffres) : création, édition, archivage, suppression de comptes bancaires ou d'épargne
  • Transactions : saisie, édition, suppression, filtrage et catégorisation des dépenses et revenus
  • Catégories : arbre de catégories personnalisable avec icônes, utilisé pour classifier les transactions
  • Budgets : définition de plafonds mensuels par catégorie
  • Prévisions : projections de solde à court et moyen terme
  • Liste de souhaits : suivi d'objectifs d'épargne
  • Alertes : notifications ou rappels paramétrables
  • Dépenses / revenus récurrents : automatisation des transactions périodiques
  • Export / Import : sauvegarde et restauration des données (CSV ou JSON)
  • Tableau de bord : synthèse visuelle avec graphiques (solde, dépenses par catégorie, évolution)

Contraintes techniques

  • Application 100 % locale : aucune donnée réseau
  • Support macOS 13+ en priorité, iOS 16+ en cible secondaire
  • SQLite comme unique source de vérité
  • Architecture en couches : Domain, Data, Presentation, Infrastructure
  • Interface en français

Missions

Les développements réalisés dans le cadre de ce projet couvrent :


  1. Conception de l'architecture : mise en place des couches Domain / Data / Presentation / Infrastructure, définition des protocoles Repository génériques, des Use Cases et du pattern MVVM.
  2. Base de données SQLite : implémentation du SQLiteDatabase, du DatabaseSchema, des migrations et des repositories pour toutes les entités (comptes, transactions, catégories, budgets, prévisions, wishlist, alertes, revenus et dépenses récurrents).
  3. Mappers : couche de conversion entre objets SQLite bruts et modèles Domain.
  4. Use Cases : implémentation complète des use cases pour la gestion des comptes, des catégories et des transactions (CRUD + archivage + vérification de dépendances).
  5. Interface graphique :
  • Navigation latérale (Sidebar) avec toutes les destinations
  • Tableau de bord avec graphiques Apple Charts
  • Vue Coffres (comptes) — entièrement fonctionnelle
  • Vue Transactions — CRUD complet, sélection de catégorie, filtres
  • Vue Catégories — arbre, icônes, modales de création / édition / suppression
  • Vues Budgets, Prévisions, Wishlist, Alertes — interfaces réalisées (données statiques en attente de connexion)
  • Vue Paramètres — interface réalisée
  1. Design system : composants réutilisables (Card, Badge, Skeleton, PageHeader, GridLayout), styles typographiques et palette de couleurs cohérente.
  2. Infrastructure : RepositoryContainer (singleton d'accès aux données), ServiceContainer, extensions SwiftUI / AppKit, DebugLogger, UserHelper.
  3. Gestion des icônes : mapping LucideIcons personnalisé pour les catégories et la navigation.

État actuel du développement et contributions

Le projet est en cours de développement et n'est pas encore dans un état de release.

Ce qui est fonctionnel de bout en bout

  • Gestion des comptes (coffres) : CRUD complet, archivage
  • Gestion des catégories : CRUD complet, icônes, arbre hiérarchique
  • Gestion des transactions : CRUD complet, catégorisation, filtres

Ce qui est en cours / non connecté

  • Budgets — interface réalisée, non connectée au BudgetRepository
  • Prévisions — interface réalisée, données statiques
  • Liste de souhaits — interface réalisée, données statiques
  • Alertes — interface réalisée, données statiques
  • Dépenses / revenus récurrents — modèles et repositories créés, non exposés en UI
  • Export / Import — boutons présents, logique non implémentée
  • Tableau de bord — graphiques présents, KPIs en partie statiques
  • ViewModels par feature — seul BaseViewModel existe, les vues utilisent encore @State directement
  • Settings (suppression de données) — interface présente, action non implémentée

Contributions acceptées

Les contributions sont les bienvenues sur les points suivants :


  • Connexion des vues Budgets, Prévisions, Wishlist et Alertes à leurs repositories respectifs
  • Implémentation des Use Cases manquants (budgets, prévisions, wishlist, alertes, récurrents)
  • Implémentation de la fonctionnalité Export / Import (CSV ou JSON)
  • Création des ViewModels par feature (pour remplacer le @State direct dans les vues)
  • Support iOS (adaptation de la navigation et des composants)
  • Corrections de bugs et améliorations UI/UX

Avant de soumettre une Pull Request, merci de respecter l'architecture décrite dans [AGENTS.md](./AGENTS.md) : toute logique métier passe par un UseCase, toute dépendance est exprimée en protocole, le Domain ne dépend jamais de Data ou Presentation.

nstallation et test local

L'application ne dispose pas d'installeur distribué. Pour la tester, il est nécessaire de la compiler localement via Xcode.

Prérequis

  • macOS 13 Ventura ou supérieur
  • Xcode 15 ou supérieur
  • Connexion internet lors de la première ouverture (pour télécharger les dépendances SPM)

Étapes

# 1. Cloner le dépôt
git clone https://github.com/rabarijoy/clair.git
cd clair

# 2. Ouvrir le projet Xcode
open ClairApp.xcodeproj

Dans Xcode :


  1. Attendre la résolution des packages Swift Package Manager (automatique au premier lancement)
  2. Sélectionner le scheme ClairApp et la destination My Mac
  3. Appuyer sur ⌘ + R pour compiler et lancer l'application
Aucune configuration de base de données n'est nécessaire : SQLite est initialisé automatiquement au premier lancement de l'app dans le répertoire Application Support de l'utilisateur.