Application full-stack pour piloter un TPI CFC Informaticien de bout en bout : planification, suivi, documentation, analyse de risques et export complet du projet. Disponible en ligne (multi-utilisateurs, PostgreSQL) et en application desktop offline (Windows/Linux, SQLite, auto-update).

---

Pourquoi TPI Flow

TPI Flow centralise dans une seule application les besoins les plus chronophages d'un TPI : structuration du planning, suivi journalier, préparation de la documentation, gestion des risques, import des documents officiels et sauvegarde complète du projet.

Le dépôt contient un monorepo Bun avec un frontend React 19, une API Express 5, PostgreSQL via Drizzle ORM, l'authentification par email ou Google OAuth, et un contrat OpenAPI utilisé pour générer les clients TypeScript.

Points forts

• Diagramme de Gantt interactif avec création par glisser-déposer, dépendances, baselines et exports.
• Tableau Kanban avec filtres avancés, priorités, dépendances et export PDF.
• Journal de travail structuré avec pièces jointes, export JSON et PDF horodaté RFC 3161.
• Analyse de risques avec matrice interactive, KPIs et export PDF ou Excel.
• Dossier de projet TipTap avec sections prédéfinies pour le rapport TPI.
• Import du cahier des charges, import CSV GanttProject et import des critères d'évaluation.
• Export et restauration complète du projet au format .tpi.json.
• Authentification sécurisée par cookie HTTP-only, isolation stricte des données par utilisateur, réinitialisation de mot de passe et vérification d'email par lien (Postmark + React Email).
• FAQ intégrée et envoi de feedback (bugs, idées) directement depuis l'app.
• Notifications temps réel (WebSocket via Socket.io) : bannière de maintenance, annonces de nouvelles fonctionnalités, déconnexion forcée, avec panel d'administration dédié. Redis adapter pour la propagation multi-instances.

Prérequis

Outil	Version
Bun	>= 1.0
Docker	>= 20.0
Docker Compose	>= 2.0

Démarrage rapide

# 1. Installer les dépendances
bun install

# 2. Configurer l'environnement
cp .env.example .env

# 3. Rendre le fichier .env visible pour l'API
ln -s ../../.env apps/api/.env

# 4. Démarrer PostgreSQL et appliquer le schéma
docker compose up -d
bun run db:push

# 5. Charger les données de base puis lancer l'application
bun run db:seed
bun run dev

Application en local :

• Frontend : http://localhost:5173
• API : http://localhost:3001

Pour charger directement des données de démonstration :

bun run db:seed-sample

Application desktop (offline)

Chaque release fournit des installeurs desktop autonomes — aucun serveur ni base de données à installer, tout tourne en local avec SQLite.

Plateforme	Installeur
Windows x64	tpi-flow-desktop_x.y.z_windows-x64-setup.exe (NSIS) ou .msi
Debian/Ubuntu x64	tpi-flow-desktop_x.y.z_linux-x64.deb
Fedora/RHEL x64	tpi-flow-desktop_x.y.z_linux-x64.rpm

L'app se met à jour automatiquement à chaque nouvelle release via l'updater Tauri intégré (signature Ed25519).

Binaire serveur autonome

Chaque release fournit aussi un binaire serveur pour le déploiement hébergé (PostgreSQL requis) :

Plateforme	Archive
Linux x64	tpi-flow-server-linux-x64.tar.gz
Linux ARM64	tpi-flow-server-linux-arm64.tar.gz
Windows x64	tpi-flow-server-windows-x64.zip

# Linux
tar -xzf tpi-flow-server-linux-x64.tar.gz
chmod +x tpi-flow
./tpi-flow

# Windows (PowerShell)
Expand-Archive tpi-flow-server-windows-x64.zip -DestinationPath tpi-flow
.\tpi-flow\tpi-flow.exe

Une base PostgreSQL reste nécessaire. Le binaire attend au minimum la variable DATABASE_URL (ex : postgresql://tpi:tpi@localhost:5432/tpi_flow). Le port de l'API est configurable via PORT (défaut : 3001).

Commandes essentielles

Commande	Description
bun run dev	Lance le frontend et l'API en mode développement
bun run dev:web	Lance uniquement le frontend
bun run dev:api	Lance uniquement l'API
bun run build	Typecheck puis build de production
bun run lint	Vérifie ESLint sur le monorepo
bun run typecheck	Vérifie TypeScript sur tous les packages
bun run db:push	Applique le schéma Drizzle à PostgreSQL
bun run codegen	Régénère les artefacts client depuis OpenAPI
bun run build:desktop	Build frontend + sidecar desktop (auto-détecte l'OS)
bun run tauri:dev	Lance l'app desktop en mode développement
bun run tauri:build	Produit les installers desktop pour la plateforme courante
bun run tauri:build:appimage	Build AppImage Linux (workaround sidecar, cf. tauri#11898)

Le détail du workflow de développement est documenté dans docs/DEVELOPMENT.md.

Architecture

Mode web (hébergé)

React 19 + Vite
        |
        | fetch /api/* + React Query
        v
Express 5 sur Bun
        |
        | Drizzle ORM + better-auth
        v
PostgreSQL 18

Mode desktop (offline)

┌────────────────────────────────────────────────┐
│ Tauri Shell (.exe / AppImage / .deb)           │
│                                                │
│  WebView2/WebKitGTK → http://127.0.0.1:<port>/ │
│         ↕ same-origin HTTP (pas de CORS)       │
│  Bun sidecar compilé                           │
│  ├─ Express 5 (mêmes routes que le web)         │
│  ├─ localUserMiddleware (pas d'auth)            │
│  └─ Drizzle ORM → SQLite (local)              │
│                                                │
│  Données : %APPDATA%/TPI-Flow/ (Win)           │
│            ~/.local/share/TPI-Flow/ (Linux)     │
└────────────────────────────────────────────────┘

Le contrat API est maintenu dans packages/api-spec/openapi.yaml et les schémas de données dans packages/db/src/schema.

Documentation

Besoin	Document
Organisation des endpoints	docs/API.md
Modèle de données et enums métier	docs/DATABASE.md
Workflow de développement	docs/DEVELOPMENT.md
Application desktop (architecture, build, auto-update)	docs/TAURI-APP.md
Guide de contribution	CONTRIBUTING.md
Politique de sécurité	SECURITY.md
Contexte projet et stack	CLAUDE.md
Conventions du dépôt	AGENTS.md

Stack technique

Couche	Technologies
Runtime	Bun
Frontend	React 19, Vite 8, Tailwind CSS 4, Wouter
Backend	Express 5
Base de données (web)	PostgreSQL 18, Drizzle ORM
Base de données (desktop)	SQLite (bun:sqlite), Drizzle ORM
Desktop shell	Tauri v2 (Rust, WebView2/WebKitGTK)
Auth (web)	better-auth
Validation	Zod 4
Contrat API	OpenAPI 3.1, Orval
Outils UI	Radix UI, Lucide, Framer Motion, TipTap

Contribution

Avant de proposer une modification, exécutez au minimum :

bun run typecheck
bun run lint

Si vous modifiez la spec OpenAPI, relancez aussi :

bun run codegen

Outils de qualité

Le projet utilise plusieurs outils de vérification automatique :

Outil	Rôle
ESLint	Linting TypeScript et React
Semgrep	Analyse de sécurité statique (.semgrep.yml)
Snyk	Audit des vulnérabilités de dépendances
CodeRabbit	Review automatique des PRs (.coderabbit.yaml)
Commitlint	Validation des messages de commit (Conventional Commits)
Prettier	Formatage du code

Le guide de contribution complet est disponible dans CONTRIBUTING.md. Les conventions de structure, style et validation sont détaillées dans AGENTS.md.

Déploiement

Le dépôt inclut désormais :

• une pipeline CI (lint, typecheck, build, codegen check) dans .github/workflows/ci.yml ;
• un build et push Docker vers GHCR avec déploiement Railway automatique ;
• une automation de release et changelog via Release Please dans .github/workflows/release-please.yml, avec binaires serveur précompilés Linux (x64, ARM64) et Windows (x64), et des installers desktop Tauri (NSIS, MSI, deb, rpm) signés (Ed25519 pour l'auto-updater) ;
• un backup quotidien de la base PostgreSQL vers MEGA S4 dans .github/workflows/db-backup.yml ;
• un labelling automatique des PRs (type, taille, scope) dans .github/workflows/label-pr.yml ;
• un auto-merge Dependabot pour les patchs dans .github/workflows/dependabot-auto-merge.yml ;
• une configuration Railway dans railway.json.

Licence

Ce projet est distribué sous licence Elastic License 2.0 — source-available.

Ce que vous pouvez faire :

• Utiliser TPI Flow gratuitement pour votre usage personnel, académique ou interne
• Lire, modifier et redistribuer le code source
• Auto-héberger l'application pour votre propre usage

Ce qui est interdit sans accord écrit :

• Proposer TPI Flow (ou une version modifiée) comme service hébergé / managé à des tiers
• Retirer ou masquer les notices de licence et de copyright
• Contourner tout mécanisme de licence intégré au logiciel

Pour un usage commercial en dehors de ces limites, contactez l'éditeur pour une licence commerciale.

Le nom TPI Flow, le logo et les éléments graphiques associés restent des éléments de marque du projet.