Générateur de Plan de Structure de Dossiers de Projet

Variables de Configuration

${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"}

${INCLUDES_MICROSERVICES="Auto-detect|true|false"}

${INCLUDES_FRONTEND="Auto-detect|true|false"}

${IS_MONOREPO="Auto-detect|true|false"}

${VISUALIZATION_STYLE="ASCII|Markdown List|Table"}

${DEPTH_LEVEL=1-5}

${INCLUDE_FILE_COUNTS=true|false}

${INCLUDE_GENERATED_FOLDERS=true|false}

${INCLUDE_FILE_PATTERNS=true|false}

${INCLUDE_TEMPLATES=true|false}

Prompt Généré

"Analysez la structure de dossiers du projet et créez un document complet 'Project_Folders_Structure_Blueprint.md' qui serve de guide définitif pour maintenir une organisation cohérente du code. Utilisez l'approche suivante :

Phase de Détection Automatique Initiale

${PROJECT_TYPE == "Auto-detect" ? "Commencez par analyser la structure de dossiers pour identifier les fichiers clés qui déterminent le type de projet :

Recherchez les fichiers solution/projet (.sln, .csproj, .fsproj, .vbproj) pour identifier les projets .NET
Vérifiez les fichiers de construction (pom.xml, build.gradle, settings.gradle) pour les projets Java
Identifiez package.json avec les dépendances pour les projets JavaScript/TypeScript
Recherchez les fichiers de framework spécifiques (angular.json, entrées react-scripts, next.config.js)
Vérifiez les identifiants de projet Python (requirements.txt, setup.py, pyproject.toml)
Examinez les identifiants d'applications mobiles (pubspec.yaml, dossiers android/ios)
Notez toutes les signatures technologiques trouvées et leurs versions" : "Concentrez l'analyse sur la structure du projet ${PROJECT_TYPE}"}

${IS_MONOREPO == "Auto-detect" ? "Déterminez s'il s'agit d'un monorepo en recherchant :

Plusieurs projets distincts avec leurs propres fichiers de configuration
Fichiers de configuration d'espace de travail (lerna.json, nx.json, turborepo.json, etc.)
Références inter-projets et motifs de dépendances partagées
Scripts et configuration d'orchestration au niveau racine" : ""}

${INCLUDES_MICROSERVICES == "Auto-detect" ? "Vérifiez les indicateurs d'architecture microservices :

Plusieurs répertoires de services avec des structures similaires/répétées
Dockerfiles spécifiques au service ou configurations de déploiement
Motifs de communication inter-services (APIs, courtiers de messages)
Configuration de registre ou découverte de services
Fichiers de configuration de passerelle API
Bibliothèques partagées ou utilitaires entre services" : ""}

${INCLUDES_FRONTEND == "Auto-detect" ? "Identifiez les composants frontend en recherchant :

Répertoires d'actifs web (wwwroot, public, dist, static)
Fichiers de framework UI (composants, modules, pages)
Configuration de construction frontend (webpack, vite, rollup, etc.)
Organisation des feuilles de style (CSS, SCSS, styled-components)
Organisation des actifs statiques (images, polices, icônes)" : ""}

1. Aperçu Structurel

Fournissez un aperçu haut niveau des principes d'organisation et de la structure de dossiers du projet ${PROJECT_TYPE == "Auto-detect" ? "type(s) de projet détecté(s)" : PROJECT_TYPE} :

Documentez l'approche architecturale globale reflétée dans la structure de dossiers
Identifiez les principes organisationnels principaux (par fonctionnalité, par couche, par domaine, etc.)
Notez les motifs structurels qui se répètent dans la base de code
Documentez les raisons derrière la structure quand elles peuvent être déduites

${IS_MONOREPO == "Auto-detect" ? "Si détecté comme monorepo, expliquez comment le monorepo est organisé et la relation entre les projets." : IS_MONOREPO ? "Expliquez comment le monorepo est organisé et la relation entre les projets." : ""}

${INCLUDES_MICROSERVICES == "Auto-detect" ? "Si des microservices sont détectés, décrivez comment ils sont structurés et organisés." : INCLUDES_MICROSERVICES ? "Décrivez comment les microservices sont structurés et organisés." : ""}

2. Visualisation du Répertoire

${VISUALIZATION_STYLE == "ASCII" ? "Créez une représentation d'arbre ASCII de la hiérarchie de dossiers jusqu'au niveau de profondeur ${DEPTH_LEVEL}." : ""}

${VISUALIZATION_STYLE == "Markdown List" ? "Utilisez des listes markdown imbriquées pour représenter la hiérarchie de dossiers jusqu'au niveau de profondeur ${DEPTH_LEVEL}." : ""}

${VISUALIZATION_STYLE == "Table" ? "Créez un tableau avec des colonnes pour Chemin, Objectif, Types de Contenu et Conventions." : ""}

${INCLUDE_GENERATED_FOLDERS ? "Incluez tous les dossiers y compris les dossiers générés." : "Excluez les dossiers générés automatiquement comme bin/, obj/, node_modules/, etc."}

3. Analyse des Répertoires Clés

Documentez l'objectif, le contenu et les motifs de chaque répertoire significatif :

${PROJECT_TYPE == "Auto-detect" ? "Pour chaque technologie détectée, analysez les structures de répertoires basées sur les motifs d'utilisation observés :" : ""}

${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect") ? "#### Structure de Projet .NET (si détectée)

Organisation de la Solution :
- Comment les projets sont groupés et liés
- Motifs d'organisation des dossiers solution
- Motifs de projection multi-ciblage
Organisation du Projet :
- Motifs de structure de dossiers interne
- Approche d'organisation du code source
- Organisation des ressources
- Dépendances et références du projet
Organisation Domaine/Fonctionnalité :
- Comment les domaines commerciaux ou fonctionnalités sont séparés
- Motifs de mise en application des limites de domaine
Organisation par Couche :
- Séparation des préoccupations (Contrôleurs, Services, Référentiels, etc.)
- Motifs d'interaction et de dépendances entre couches
Gestion de la Configuration :
- Emplacements et objectifs des fichiers de configuration
- Configurations spécifiques à l'environnement
- Approche de gestion des secrets
Organisation du Projet de Test :
- Structure et nommage du projet de test
- Catégories de test et organisation
- Emplacements des données de test et des mocks" : ""}

${(PROJECT_TYPE == "React" || PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect") ? "#### Structure de Projet UI (si détectée)

Organisation des Composants :
- Motifs de structure de dossiers de composants
- Stratégies de groupage (par fonctionnalité, par type, etc.)
- Composants partagés vs. spécifiques aux fonctionnalités
Gestion de l'État :
- Organisation des fichiers liés à l'état
- Structure du store pour l'état global
- Motifs de gestion de l'état local
Organisation du Routage :
- Emplacements de définition des routes
- Organisation des composants page/vue
- Gestion des paramètres de route
Intégration API :
- Organisation du client API
- Structure de la couche service
- Motifs de récupération de données
Gestion des Actifs :
- Organisation des ressources statiques
- Structure des fichiers image/média
- Organisation des polices et icônes
Organisation des Styles :
- Structure des fichiers CSS/SCSS
- Organisation des thèmes
- Motifs de modules de style" : ""}

4. Motifs de Placement de Fichiers

${INCLUDE_FILE_PATTERNS ? "Documentez les motifs qui déterminent où différents types de fichiers doivent être placés :

Fichiers de Configuration :
- Emplacements pour différents types de configuration
- Motifs de configuration spécifiques à l'environnement
Définitions de Modèle/Entité :
- Où les modèles de domaine sont définis
- Emplacements des objets de transfert de données (DTO)
- Emplacements de définition de schéma
Logique Métier :
- Emplacements d'implémentation du service
- Organisation des règles métier
- Placement des fonctions utilitaires et d'assistance
Définitions d'Interface :
- Où les interfaces et abstractions sont définies
- Comment les interfaces sont groupées et organisées
Fichiers de Test :
- Motifs de localisation des tests unitaires
- Placement des tests d'intégration
- Emplacements des utilitaires de test et des mocks
Fichiers de Documentation :
- Placement de la documentation API
- Organisation de la documentation interne
- Distribution des fichiers README" : "Documentez où les principaux types de fichiers sont situés dans le projet."}

5. Conventions de Nommage et Organisation

Documentez les conventions de nommage et d'organisation observées dans tout le projet :

Motifs de Nommage de Fichier :
- Conventions de casse (PascalCase, camelCase, kebab-case)
- Motifs de préfixe et suffixe
- Indicateurs de type dans les noms de fichiers
Motifs de Nommage de Dossier :
- Conventions de nommage pour différents types de dossiers
- Motifs de nommage hiérarchique
- Conventions de groupage et de catégorisation
Motifs d'Espace de Noms/Module :
- Comment les espaces de noms/modules correspondent à la structure de dossiers
- Organisation des déclarations d'import/using
- Séparation API interne vs. publique
Motifs Organisationnels :
- Stratégies de co-localisation du code
- Approches d'encapsulation des fonctionnalités
- Organisation des préoccupations transversales

6. Navigation et Flux de Travail de Développement

Fournissez des conseils pour naviguer dans la structure de la base de code et y travailler :

Points d'Entrée :
- Points d'entrée principaux de l'application
- Points de départ de configuration clés
- Fichiers initiaux pour comprendre le projet
Tâches de Développement Courantes :
- Où ajouter de nouvelles fonctionnalités
- Comment étendre la fonctionnalité existante
- Où placer les nouveaux tests
- Emplacements de modification de configuration
Motifs de Dépendance :
- Comment les dépendances circulent entre les dossiers
- Motifs d'import/référence
- Emplacements d'enregistrement de l'injection de dépendance

${INCLUDE_FILE_COUNTS ? "- Statistiques de Contenu :

Analyse des fichiers par répertoire
Métriques de distribution du code
Zones de concentration de complexité" : ""}

7. Organisation de la Construction et de la Sortie

Documentez le processus de construction et l'organisation de la sortie :

Configuration de Construction :
- Emplacements et objectifs des scripts de construction
- Organisation du pipeline de construction
- Définitions des tâches de construction
Structure de Sortie :
- Emplacements de sortie compilée/construite
- Motifs d'organisation de la sortie
- Structure du package de distribution
Constructions Spécifiques à l'Environnement :
- Différences développement vs. production
- Stratégies de configuration de l'environnement
- Organisation des variantes de construction

8. Organisation Spécifique à la Technologie

${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect") ? "#### Motifs de Structure Spécifique à .NET (si détectés)

Organisation des Fichiers Projet :
- Structure et motifs du fichier projet
- Configuration du framework cible
- Organisation du groupe de propriétés
- Motifs du groupe d'éléments
Organisation de l'Assembly :
- Motifs de nommage d'assembly
- Architecture multi-assembly
- Motifs de référence d'assembly
Organisation des Ressources :
- Motifs de ressources incorporées
- Structure des fichiers de localisation
- Organisation des actifs web statiques
Gestion des Packages :
- Emplacements de configuration NuGet
- Organisation de la référence de package
- Gestion de la version des packages" : ""}

${(PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect") ? "#### Motifs de Structure Spécifique à Java (si détectés)

Hiérarchie de Packages :
- Conventions de nommage et d'imbrication de packages
- Packages domaine vs. technique
- Motifs de visibilité et d'accès
Organisation de l'Outil de Construction :
- Motifs de structure Maven/Gradle
- Organisation des modules
- Motifs de configuration de plugin
Organisation des Ressources :
- Structures de dossiers ressources
- Ressources spécifiques à l'environnement
- Organisation des fichiers de propriétés" : ""}

${(PROJECT_TYPE == "Node.js" || PROJECT_TYPE == "Auto-detect") ? "#### Motifs de Structure Spécifique à Node.js (si détectés)

Organisation des Modules :
- Organisation CommonJS vs. ESM
- Motifs de modules internes
- Gestion des dépendances tierces
Organisation des Scripts :
- Motifs de définition des scripts npm/yarn
- Emplacements des scripts utilitaires
- Scripts des outils de développement
Gestion de la Configuration :
- Emplacements des fichiers de configuration
- Gestion des variables d'environnement
- Approches de gestion des secrets" : ""}

9. Extension et Évolution

Documentez comment la structure du projet est conçue pour être étendue :

Points d'Extension :
- Comment ajouter de nouveaux modules/fonctionnalités tout en maintenant les conventions
- Motifs de dossiers plugin/extension
- Structures de répertoires de personnalisation
Motifs d'Évolutivité :
- Comment la structure s'adapte pour les fonctionnalités plus grandes
- Approche pour décomposer les grands modules
- Stratégies de division du code
Motifs de Refactorisation :
- Approches de refactorisation courantes observées
- Comment les modifications structurelles sont gérées
- Motifs de réorganisation incrémentale

${INCLUDE_TEMPLATES ? "### 10. Modèles de Structure

Fournissez des modèles pour créer de nouveaux composants qui respectent les conventions du projet :

Modèle de Nouvelle Fonctionnalité :
- Structure de dossiers pour ajouter une fonctionnalité complète
- Types de fichiers requis et leurs emplacements
- Motifs de nommage à suivre
Modèle de Nouveau Composant :
- Structure de répertoires pour un composant typique
- Fichiers essentiels à inclure
- Points d'intégration avec la structure existante
Modèle de Nouveau Service :
- Structure pour ajouter un nouveau service
- Placement de l'interface et de l'implémentation
- Motifs de configuration et d'enregistrement
Nouvelle Structure de Test :
- Structure de dossiers pour les projets/fichiers de test
- Modèles d'organisation des fichiers de test
- Organisation des ressources de test" : ""}

${INCLUDE_TEMPLATES ? "11" : "10"}. Application de la Structure

Documentez comment la structure du projet est maintenue et appliquée :

Validation de la Structure :
- Outils/scripts qui appliquent la structure
- Vérifications de construction pour la conformité structurelle
- Règles de linting liées à la structure
Pratiques de Documentation :
- Comment les modifications structurelles sont documentées
- Où les décisions architecturales sont enregistrées
- Historique de l'évolution de la structure

Incluez une section à la fin sur le maintien de ce plan et la date de sa dernière mise à jour. "

folder-structure-blueprint-generator