Ce guide couvre le workflow de développement quotidien pour contribuer à Bedrud.

Structure du dépôt

bedrud/
├── server/          # Backend Go
├── apps/
│   ├── web/         # Frontend React (TanStack Start)
│   ├── android/     # Application Android
│   ├── ios/         # Application iOS
│   └── desktop/     # Application de bureau (Rust + Slint)
├── agents/          # Agents bots Python
├── packages/        # Types TypeScript partagés
├── tools/cli/       # CLI de déploiement
├── docs/            # Documentation (MkDocs)
├── Cargo.toml       # Racine de l'espace de travail Rust
├── Makefile         # Orchestration des builds
└── Dockerfile       # Build conteneur

Prérequis

Configuration initiale

git clone https://github.com/bedrud-ir/bedrud.git
cd bedrud
make init

Développement full-stack

Pour exécuter toute la pile localement :

make dev

Cela démarre LiveKit, le serveur Go et le serveur de développement React simultanément. Appuyez sur Ctrl+C pour arrêter tous les processus.

Exécution des services individuellement

make dev-web

make dev-server

make dev-livekit

Développement du serveur

Le point d’entrée du serveur Go est server/cmd/server/main.go.

Ajout d’un point de terminaison API

1. Définir le handler dans server/internal/handlers/
2. Ajouter des méthodes de dépôt dans server/internal/repository/ si de nouvelles requêtes DB sont nécessaires
3. Enregistrer la route dans la configuration du serveur (généralement dans main.go ou un fichier de routes)
4. Ajouter un middleware si le point de terminaison nécessite une vérification d’authentification ou d’administrateur

Modifications de la base de données

Ajoutez ou modifiez les structs de modèles GORM dans server/internal/models/. GORM effectue une auto-migration au démarrage.

Documentation Swagger

Les annotations de documentation API utilisent le format swaggo. Après les modifications, régénérez :

cd server
swag init -g cmd/server/main.go

Consultez Architecture du serveur pour la structure complète des répertoires et la conception en couches.

Développement du frontend web

Le frontend se trouve dans apps/web/ et utilise React 19 avec TanStack Start.

Ajout d’une page

Créez un nouveau fichier sous src/routes/ en suivant la convention de routage basée sur les fichiers de TanStack Router (par exemple src/routes/settings.tsx). Exportez une Route créée avec createFileRoute.

Ajout d’une fonction client API

1. Ajoutez la fonction dans src/lib/api.ts en utilisant authFetch
2. Définissez les types TypeScript en ligne ou dans un fichier de types partagé
3. Utilisez la fonction depuis votre composant de route, généralement via un hook useQuery de TanStack Query

Vérification des types

cd apps/web
bun run check    # exécute le lint Biome + la vérification des types TypeScript

Consultez Architecture du frontend web pour la structure et les modèles complets du frontend.

Développement Android

make dev-android    # Ouvre dans Android Studio

Modèles clés

• Tous les écrans sont des fonctions Composable
• Les dépendances proviennent de InstanceManager via koinInject()
• Utilisez collectAsState().value ?: return pour les valeurs StateFlow nullables
• La navigation est gérée dans MainActivity.kt

Construction

make build-android-debug    # APK de débogage
make build-android          # APK de release (nécessite keystore)
make release-android        # Build + installation sur l'appareil

Consultez Architecture de l’application Android pour l’architecture détaillée de l’application mobile.

Développement iOS

make dev-ios    # Ouvre dans Xcode

Modèles clés

• Les vues sont des structs SwiftUI
• Les dépendances proviennent de InstanceManager via @EnvironmentObject
• Utilisez une liaison facultative pour les propriétés publiées nullables
• La navigation utilise la pile de navigation native de SwiftUI

Génération de projet

Si vous modifiez project.yml, régénérez le projet Xcode :

cd apps/ios
xcodegen generate

Construction

make build-ios          # Archive de release
make build-ios-sim      # Build simulateur
make export-ios         # Exporter l'IPA

Consultez Architecture de l’application iOS pour l’architecture détaillée de l’application mobile.

Développement de l’application de bureau

L’application de bureau se trouve dans apps/desktop/ et est un crate Rust dans l’espace de travail.

Prérequis (Linux)

sudo apt-get install -y \
  libfontconfig1-dev libxkbcommon-dev libxkbcommon-x11-dev \
  libwayland-dev libgles2-mesa-dev libegl1-mesa-dev \
  libdbus-1-dev libsecret-1-dev \
  libasound2-dev

Windows nécessite Visual Studio Build Tools avec la charge de travail C++ (MSVC).

Exécution

make dev-desktop    # cargo run -p bedrud-desktop

Construction

make build-desktop           # binaire optimisé pour la plateforme actuelle

Modèles clés

• Toute l’interface utilisateur est définie dans les fichiers .slint sous apps/desktop/ui/ ; compilée en Rust au moment du build par build.rs
• apps/desktop/src/ui/bridge.rs est le seul endroit où les callbacks Slint sont connectés à la logique Rust - gardez la logique métier en dehors des fichiers .slint
• Utilisez Weak<AppWindow> lors du lancement de tâches en arrière-plan qui doivent mettre à jour l’interface utilisateur

Consultez Architecture de l’application de bureau pour l’architecture détaillée de l’application de bureau.

Développement d’agents bots

Les agents se trouvent dans agents/ avec un répertoire par agent.

cd agents/music_agent
pip install -r requirements.txt
python agent.py "http://localhost:8090/m/test-room"

Tous les agents ont besoin d’un serveur Bedrud en cours d’exécution pour s’authentifier.

CI/CD

GitHub Actions s’exécute à chaque push vers main et sur les pull requests :

Les builds de release sont déclenchés par les balises de version (v*).

Style de code

• Go : Formatage standard gofmt
• TypeScript/React : Biome (configuré dans apps/web/biome.json)
• Kotlin : Formatage par défaut d’Android Studio
• Swift : Formatage par défaut de Xcode

Tests

cd server
go test ./...

cd apps/web
bun run check

cd apps/android
./gradlew test

make build-ios-sim   # Build et exécute les tests

Voir aussi

• Référence du Makefile - toutes les commandes de build et de développement
• Aperçu de l’architecture - comment les composants s’assemblent