Générateur de Plan Directeur d'Architecture Globale de Projet

Variables de Configuration

${PROJECT_TYPE="Détection automatique|.NET|Java|React|Angular|Python|Node.js|Flutter|Autre"}  ${ARCHITECTURE_PATTERN="Détection automatique|Architecture Propre|Microservices|En Couches|MVVM|MVC|Hexagonale|Événementielle|Serverless|Monolithique|Autre"}  ${DIAGRAM_TYPE="C4|UML|Flow|Component|Aucun"}  ${DETAIL_LEVEL="Haut niveau|Détaillé|Complet|Prêt pour l'implémentation"}  ${INCLUDES_CODE_EXAMPLES=true|false}  ${INCLUDES_IMPLEMENTATION_PATTERNS=true|false}  ${INCLUDES_DECISION_RECORDS=true|false}  ${FOCUS_ON_EXTENSIBILITY=true|false}

Prompt Généré

« Créez un document exhaustif « Project_Architecture_Blueprint.md » qui analyse de manière approfondie les motifs architecturaux de la base de code pour servir de référence définitive au maintien de la cohérence architecturale. Utilisez l'approche suivante :

1. Détection et Analyse de l'Architecture

${PROJECT_TYPE == "Détection automatique" ? "Analysez la structure du projet pour identifier tous les stacks technologiques et frameworks en utilisant en examinant :
- Les fichiers de configuration et projet
- Les dépendances de paquet et déclarations d'importation
- Les motifs et conventions spécifiques au framework
- Les configurations de build et déploiement" : "Concentrez-vous sur les motifs et pratiques spécifiques à ${PROJECT_TYPE}"}
${ARCHITECTURE_PATTERN == "Détection automatique" ? "Déterminez le(s) motif(s) architectural(aux) en analysant :
- L'organisation des dossiers et l'espace de noms
- Le flux de dépendances et les limites des composants
- Les motifs de ségrégation d'interfaces et d'abstraction
- Les mécanismes de communication entre composants" : "Documentez la façon dont l'architecture ${ARCHITECTURE_PATTERN} est implémentée"}

2. Aperçu Architectural

Fournissez une explication claire et concise de l'approche architecturale globale
Documentez les principes directeurs évidents dans les choix architecturaux
Identifiez les limites architecturales et la façon dont elles sont appliquées
Notez tout motif architectural hybride ou adaptations de motifs standards

3. Visualisation de l'Architecture

${DIAGRAM_TYPE != "Aucun" ? `Créez des diagrammes ${DIAGRAM_TYPE} à plusieurs niveaux d'abstraction :

Aperçu architectural de haut niveau montrant les sous-systèmes majeurs
Diagrammes d'interaction des composants montrant les relations et dépendances
Diagrammes de flux de données montrant comment l'information circule dans le système
Assurez-vous que les diagrammes reflètent fidèlement l'implémentation réelle, pas les motifs théoriques` : "Décrivez les relations entre composants en fonction des dépendances réelles du code, en fournissant des explications textuelles claires de :
L'organisation et les limites des sous-systèmes
Les directions de dépendances et les interactions entre composants
Le flux de données et les séquences de processus"}

4. Composants Architecturaux Essentiels

Pour chaque composant architectural découvert dans la base de code :

Objectif et Responsabilité :
- Fonction principale dans l'architecture
- Domaines métier ou préoccupations techniques abordés
- Limites et restrictions de portée
Structure Interne :
- Organisation des classes/modules au sein du composant
- Abstractions clés et leurs implémentations
- Motifs de conception utilisés
Motifs d'Interaction :
- La façon dont le composant communique avec d'autres
- Interfaces exposées et consommées
- Motifs d'injection de dépendances
- Mécanismes de publication/abonnement d'événements
Motifs d'Évolution :
- La façon dont le composant peut être étendu
- Points de variation et mécanismes de plugin
- Approches de configuration et de personnalisation

5. Couches Architecturales et Dépendances

Cartographiez la structure en couches telle qu'implémentée dans la base de code
Documentez les règles de dépendance entre couches
Identifiez les mécanismes d'abstraction qui permettent la séparation des couches
Notez toute dépendance circulaire ou violation de couche
Documentez les motifs d'injection de dépendances utilisés pour maintenir la séparation

6. Architecture des Données

Documentez la structure et l'organisation du modèle de domaine
Cartographiez les relations d'entités et les motifs d'agrégation
Identifiez les motifs d'accès aux données (référentiels, mappeurs de données, etc.)
Documentez les approches de transformation et de mappage des données
Notez les stratégies de mise en cache et les implémentations
Documentez les motifs de validation des données

7. Implémentation des Préoccupations Transversales

Documentez les motifs d'implémentation pour les préoccupations transversales :

Authentification & Autorisation :
- Implémentation du modèle de sécurité
- Motifs d'application des permissions
- Approche de gestion d'identité
- Motifs de limite de sécurité
Gestion des Erreurs & Résilience :
- Motifs de gestion des exceptions
- Implémentations de retry et circuit breaker
- Stratégies de fallback et dégradation gracieuse
- Approches de signalement et monitoring d'erreurs
Journalisation & Monitoring :
- Motifs d'instrumentation
- Implémentation de l'observabilité
- Flux d'informations de diagnostic
- Approche de monitoring des performances
Validation :
- Stratégies de validation des entrées
- Implémentation de validation des règles métier
- Distribution des responsabilités de validation
- Motifs de signalement d'erreurs
Gestion de la Configuration :
- Motifs de source de configuration
- Stratégies de configuration spécifiques à l'environnement
- Approche de gestion des secrets
- Implémentation des feature flags

8. Motifs de Communication entre Services

Documentez les définitions de limites de services
Identifiez les protocoles et formats de communication
Cartographiez les motifs de communication synchrone vs. asynchrone
Documentez les stratégies de versioning d'API
Identifiez les mécanismes de découverte de services
Notez les motifs de résilience dans la communication inter-services

9. Motifs Architecturaux Spécifiques à la Technologie

${PROJECT_TYPE == "Détection automatique" ? "Pour chaque stack technologique détecté, documentez les motifs architecturaux spécifiques :" : Documentez les motifs architecturaux spécifiques à ${PROJECT_TYPE} :}

${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Détection automatique") ? "#### Motifs Architecturaux .NET (s'ils sont détectés)

Implémentation du modèle d'hôte et d'application
Organisation du pipeline de middleware
Motifs d'intégration des services du framework
Approches d'accès aux données et ORM
Motifs d'implémentation d'API (contrôleurs, API minimales, etc.)
Configuration du conteneur d'injection de dépendances" : ""}

${(PROJECT_TYPE == "Java" || PROJECT_TYPE == "Détection automatique") ? "#### Motifs Architecturaux Java (s'ils sont détectés)

Conteneur d'application et processus de bootstrap
Utilisation du framework d'injection de dépendances (Spring, CDI, etc.)
Motifs d'implémentation d'AOP
Gestion des limites transactionnelles
Motifs de configuration et utilisation d'ORM
Motifs d'implémentation de services" : ""}

${(PROJECT_TYPE == "React" || PROJECT_TYPE == "Détection automatique") ? "#### Motifs Architecturaux React (s'ils sont détectés)

Stratégies de composition et réutilisation de composants
Architecture de gestion d'état
Motifs de gestion des effets secondaires
Approche de routage et navigation
Motifs de récupération et mise en cache des données
Stratégies d'optimisation du rendu" : ""}

${(PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Détection automatique") ? "#### Motifs Architecturaux Angular (s'ils sont détectés)

Stratégie d'organisation des modules
Conception de la hiérarchie des composants
Motifs de services et d'injection de dépendances
Approche de gestion d'état
Motifs de programmation réactive
Implémentation des gardes de route" : ""}

${(PROJECT_TYPE == "Python" || PROJECT_TYPE == "Détection automatique") ? "#### Motifs Architecturaux Python (s'ils sont détectés)

Approche d'organisation des modules
Stratégie de gestion des dépendances
Motifs d'implémentation OOP vs. fonctionnels
Motifs d'intégration du framework
Approche de programmation asynchrone" : ""}

10. Motifs d'Implémentation

${INCLUDES_IMPLEMENTATION_PATTERNS ? "Documentez les motifs d'implémentation concrets pour les composants architecturaux clés :

Motifs de Conception d'Interfaces :
- Approches de ségrégation d'interfaces
- Décisions de niveaux d'abstraction
- Motifs d'interfaces génériques vs. spécifiques
- Motifs d'implémentation par défaut
Motifs d'Implémentation de Services :
- Gestion de la durée de vie des services
- Motifs de composition de services
- Modèles d'implémentation d'opérations
- Gestion des erreurs au sein des services
Motifs d'Implémentation de Référentiels :
- Implémentations de motifs de requête
- Gestion des transactions
- Gestion de la concurrence
- Motifs d'opérations en masse
Motifs d'Implémentation de Contrôleurs/API :
- Motifs de gestion des requêtes
- Approches de formatage des réponses
- Validation des paramètres
- Implémentation du versioning d'API
Implémentation du Modèle de Domaine :
- Motifs d'implémentation d'entités
- Motifs d'objets valeur
- Implémentation d'événements de domaine
- Application des règles métier" : "Mentionnez que les motifs d'implémentation détaillés varient dans la base de code."}

11. Architecture de Test

Documentez les stratégies de test alignées avec l'architecture
Identifiez les motifs de limite de test (unitaire, intégration, système)
Cartographiez les approches de doublures de test et mocking
Documentez les stratégies de données de test
Notez l'intégration des outils et frameworks de test

12. Architecture de Déploiement

Documentez la topologie de déploiement dérivée de la configuration
Identifiez les adaptations architecturales spécifiques à l'environnement
Cartographiez les motifs de résolution des dépendances à l'exécution
Documentez la gestion de la configuration entre les environnements
Identifiez les approches de conteneurisation et d'orchestration
Notez les motifs d'intégration des services cloud

13. Motifs d'Extension et d'Évolution

${FOCUS_ON_EXTENSIBILITY ? "Fournissez des directives détaillées pour étendre l'architecture :

Motifs d'Ajout de Fonctionnalités :
- Comment ajouter de nouvelles fonctionnalités tout en préservant l'intégrité architecturale
- Où placer les nouveaux composants selon leur type
- Directives d'introduction de dépendances
- Motifs d'extension de configuration
Motifs de Modification :
- Comment modifier en toute sécurité les composants existants
- Stratégies de maintien de la compatibilité rétroactive
- Motifs de dépréciation
- Approches de migration
Motifs d'Intégration :
- Comment intégrer les nouveaux systèmes externes
- Motifs d'implémentation d'adaptateurs
- Motifs de couches anti-corruption
- Implémentation de façade de service" : "Documentez les points d'extension clés de l'architecture."}

${INCLUDES_CODE_EXAMPLES ? "### 14. Exemples de Motifs Architecturaux Extrayez les exemples de code représentatifs qui illustrent les motifs architecturaux clés :

Exemples de Séparation des Couches :
- Définition d'interface et séparation d'implémentation
- Motifs de communication entre couches
- Exemples d'injection de dépendances
Exemples de Communication entre Composants :
- Motifs d'invocation de services
- Publication et gestion d'événements
- Implémentation du passage de messages
Exemples de Points d'Extension :
- Enregistrement et découverte de plugins
- Implémentations d'interfaces d'extension
- Motifs d'extension pilotés par configuration

Incluez assez de contexte avec chaque exemple pour montrer clairement le motif, mais gardez les exemples concis et axés sur les concepts architecturaux." : ""}

${INCLUDES_DECISION_RECORDS ? "### 15. Enregistrements de Décisions Architecturales Documentez les décisions architecturales clés évidentes dans la base de code :

Décisions de Style Architectural :
- Pourquoi le motif architectural actuel a été choisi
- Alternatives considérées (basé sur l'évolution du code)
- Contraintes qui ont influencé la décision
Décisions de Sélection Technologique :
- Choix technologiques clés et leur impact architectural
- Justifications de la sélection du framework
- Décisions de composants personnalisés vs. standard
Décisions d'Approche d'Implémentation :
- Motifs d'implémentation spécifiques choisis
- Adaptations de motifs standards
- Compromis performance vs. maintenabilité

Pour chaque décision, notez :

Le contexte qui a rendu la décision nécessaire
Les facteurs considérés dans la prise de décision
Les conséquences résultantes (positives et négatives)
La flexibilité future ou les limitations introduites" : ""}

${INCLUDES_DECISION_RECORDS ? "16" : INCLUDES_CODE_EXAMPLES ? "15" : "14"}. Gouvernance de l'Architecture

Documentez comment la cohérence architecturale est maintenue
Identifiez les vérifications automatisées pour la conformité architecturale
Notez les processus de révision architecturale évidents dans la base de code
Documentez les pratiques de documentation architecturale

${INCLUDES_DECISION_RECORDS ? "17" : INCLUDES_CODE_EXAMPLES ? "16" : "15"}. Plan Directeur pour le Nouveau Développement

Créez un guide architectural clair pour implémenter les nouvelles fonctionnalités :

Flux de Travail de Développement :
- Points de départ pour différents types de fonctionnalités
- Séquence de création de composants
- Étapes d'intégration avec l'architecture existante
- Approche de test par couche architecturale
Modèles d'Implémentation :
- Modèles de classe/interface de base pour les composants architecturaux clés
- Organisation standard des fichiers pour les nouveaux composants
- Motifs de déclaration de dépendances
- Exigences en matière de documentation
Pièges Courants :
- Violations architecturales à éviter
- Erreurs architecturales courantes
- Considérations de performance
- Points faibles des tests

Incluez des informations sur le moment où ce plan directeur a été généré et des recommandations pour le maintenir à jour à mesure que l'architecture évolue. »

architecture-blueprint-generator