technology-stack-blueprint-generator

Par github · awesome-copilot

Générateur de blueprints complets pour stacks technologiques, qui analyse les codebases afin de produire une documentation architecturale détaillée. Détecte automatiquement les stacks technologiques, les langages de programmation et les patterns d'implémentation sur plusieurs plateformes (.NET, Java, JavaScript, React, Python). Génère des blueprints configurables incluant les informations de version, les détails de licence, les patterns d'utilisation, les conventions de codage et les diagrammes visuels. Fournit des templates prêts à l'emploi et garantit la cohérence architecturale pour un développement guidé.

npx skills add https://github.com/github/awesome-copilot --skill technology-stack-blueprint-generator

Générateur de plan directeur complet de la pile technologique

Variables de configuration

${PROJECT_TYPE="Auto-detect|.NET|Java|JavaScript|React.js|React Native|Angular|Python|Other"} <!-- Technologie principale --> ${DEPTH_LEVEL="Basic|Standard|Comprehensive|Implementation-Ready"} <!-- Profondeur d'analyse --> ${INCLUDE_VERSIONS=true|false} <!-- Inclure les informations de version --> ${INCLUDE_LICENSES=true|false} <!-- Inclure les informations de licence --> ${INCLUDE_DIAGRAMS=true|false} <!-- Générer des diagrammes d'architecture --> ${INCLUDE_USAGE_PATTERNS=true|false} <!-- Inclure les motifs d'utilisation du code --> ${INCLUDE_CONVENTIONS=true|false} <!-- Documenter les conventions de codage --> ${OUTPUT_FORMAT="Markdown|JSON|YAML|HTML"} <!-- Sélectionner le format de sortie --> ${CATEGORIZATION="Technology Type|Layer|Purpose"} <!-- Méthode d'organisation -->

Prompt généré

"Analysez la base de code et générez un plan directeur de pile technologique de niveau ${DEPTH_LEVEL} qui documente complètement les technologies et les motifs d'implémentation pour faciliter la génération cohérente de code. Utilisez l'approche suivante :

1. Phase d'identification des technologies

  • ${PROJECT_TYPE == "Auto-detect" ? "Analysez la base de code pour repérer les fichiers de projet, fichiers de configuration et dépendances afin de déterminer toutes les piles technologiques en usage" : "Concentrez-vous sur les technologies ${PROJECT_TYPE}"}
  • Identifiez tous les langages de programmation en examinant les extensions de fichier et le contenu
  • Analysez les fichiers de configuration (package.json, .csproj, pom.xml, etc.) pour extraire les dépendances
  • Examinez les scripts de build et les définitions de pipeline pour les informations de tooling
  • ${INCLUDE_VERSIONS ? "Extrayez les informations de version précises à partir des fichiers de packages et de configuration" : "Omettez les détails de version"}
  • ${INCLUDE_LICENSES ? "Documentez les informations de licence pour toutes les dépendances" : ""}

2. Analyse des technologies principales

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

  • Frameworks cibles et versions de langage (détecter à partir des fichiers de projet)
  • Toutes les références de package NuGet avec versions et commentaires de but
  • Structure et motifs d'organisation du projet
  • Approche de configuration (appsettings.json, IOptions, etc.)
  • Mécanismes d'authentification (Identity, JWT, etc.)
  • Motifs de conception d'API (REST, GraphQL, minimal APIs, etc.)
  • Approches d'accès aux données (EF Core, Dapper, etc.)
  • Motifs d'injection de dépendances
  • Composants de pipeline middleware" : ""}

${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect" ? "#### Analyse de la pile Java (si détectée)

  • Version JDK et frameworks principaux
  • Toutes les dépendances Maven/Gradle avec versions et but
  • Organisation de la structure de packages
  • Utilisation et configurations Spring Boot
  • Motifs d'annotations
  • Approche d'injection de dépendances
  • Technologies d'accès aux données (JPA, JDBC, etc.)
  • Conception d'API (Spring MVC, JAX-RS, etc.)" : ""}

${PROJECT_TYPE == "JavaScript" || PROJECT_TYPE == "Auto-detect" ? "#### Analyse JavaScript (si détectée)

  • Version ECMAScript et paramètres de transpileur
  • Toutes les dépendances npm catégorisées par but
  • Système de modules (ESM, CommonJS)
  • Tooling de build (webpack, Vite, etc.) avec configuration
  • Utilisation et configuration TypeScript
  • Frameworks et motifs de test" : ""}

${PROJECT_TYPE == "React.js" || PROJECT_TYPE == "Auto-detect" ? "#### Analyse React (si détectée)

  • Version React et motifs clés (hooks vs composants en classe)
  • Approche de gestion d'état (Context, Redux, Zustand, etc.)
  • Utilisation de bibliothèque de composants (Material-UI, Chakra, etc.)
  • Implémentation du routing
  • Stratégies de gestion des formulaires
  • Motifs d'intégration d'API
  • Approche de test pour les composants" : ""}

${PROJECT_TYPE == "Python" || PROJECT_TYPE == "Auto-detect" ? "#### Analyse Python (si détectée)

  • Version Python et fonctionnalités clés du langage utilisées
  • Dépendances de packages et configuration d'environnement virtuel
  • Détails du framework web (Django, Flask, FastAPI)
  • Motifs d'utilisation d'ORM
  • Organisation de la structure du projet
  • Motifs de conception d'API" : ""}

3. Motifs et conventions d'implémentation

${INCLUDE_CONVENTIONS ? "Documentez les conventions de codage et les motifs pour chaque zone technologique :

Conventions de nommage

  • Motifs de nommage de classe/type
  • Motifs de nommage de méthode/fonction
  • Conventions de nommage de variable
  • Conventions de nommage de fichier et d'organisation
  • Motifs d'interface/classe abstraite

Organisation du code

  • Structure et organisation des fichiers
  • Motifs de hiérarchie de dossiers
  • Limites de composant/module
  • Motifs de séparation du code et de responsabilité

Motifs courants

  • Approches de gestion d'erreur
  • Motifs de logging
  • Accès à la configuration
  • Implémentation de l'authentification/autorisation
  • Stratégies de validation
  • Motifs de test" : ""}

4. Exemples d'utilisation

${INCLUDE_USAGE_PATTERNS ? "Extrayez des exemples de code représentatifs montrant les motifs d'implémentation standard :

Exemples d'implémentation d'API

  • Implémentation standard de contrôleur/endpoint
  • Motif de DTO de requête
  • Formatage de réponse
  • Approche de validation
  • Gestion d'erreur

Exemples d'accès aux données

  • Implémentation du motif Repository
  • Définitions d'entité/modèle
  • Motifs de requête
  • Gestion des transactions

Exemples de couche Service

  • Implémentation de classe Service
  • Organisation de la logique métier
  • Intégration des préoccupations transversales
  • Utilisation d'injection de dépendances

Exemples de composant UI (le cas échéant)

  • Structure de composant
  • Motif de gestion d'état
  • Gestion d'événements
  • Motif d'intégration d'API" : ""}

5. Carte de la pile technologique

${DEPTH_LEVEL == "Comprehensive" || DEPTH_LEVEL == "Implementation-Ready" ? "Créez une carte technologique complète incluant :

Utilisation du framework principal

  • Frameworks principaux et leur usage spécifique dans le projet
  • Configurations et personnalisations spécifiques au framework
  • Points d'extension et personnalisations

Points d'intégration

  • Comment les différents composants technologiques s'intègrent
  • Flux d'authentification entre les composants
  • Flux de données entre frontend et backend
  • Motifs d'intégration de service tiers

Tooling de développement

  • Paramètres IDE et conventions
  • Outils d'analyse de code
  • Linters et formatters avec configuration
  • Pipeline de build et de déploiement
  • Frameworks de test et approches

Infrastructure

  • Détails de l'environnement de déploiement
  • Technologies de conteneurisation
  • Services cloud utilisés
  • Infrastructure de monitoring et logging" : ""}

6. Détails d'implémentation spécifiques aux technologies

${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? "#### Détails d'implémentation .NET (si détectés)

  • Motif d'injection de dépendances :

    • Approche d'enregistrement de service (motifs Scoped/Singleton/Transient)
    • Motifs de liaison de configuration

  • Motifs de contrôleur :

    • Utilisation du contrôleur de base
    • Types et motifs de résultats d'action
    • Conventions d'attribut de route
    • Utilisation de filtre (autorisation, validation, etc.)

  • Motifs d'accès aux données :

    • Configuration et utilisation d'ORM
    • Approche de configuration d'entité
    • Définitions de relations
    • Motifs de requête et approches d'optimisation

  • Motifs de conception d'API (si utilisés) :

    • Organisation des endpoints
    • Approches de liaison de paramètres
    • Gestion du type de réponse

  • Fonctionnalités du langage utilisées :

    • Détecter les fonctionnalités spécifiques du langage à partir du code
    • Identifier les motifs et idiomes courants
    • Noter les fonctionnalités dépendantes de version spécifiques" : ""}

${PROJECT_TYPE == "React.js" || PROJECT_TYPE == "Auto-detect" ? "#### Détails d'implémentation React (si détectés)

  • Structure de composant :

    • Composants fonction vs composants en classe
    • Définitions d'interface Props
    • Motifs de composition de composants

  • Motifs d'utilisation de hooks :

    • Style d'implémentation de custom hook
    • Motifs useState
    • Approches de nettoyage useEffect
    • Motifs d'utilisation de Context

  • Gestion d'état :

    • Décisions d'état local vs global
    • Motifs de bibliothèque de gestion d'état
    • Configuration du store
    • Motifs de sélecteur

  • Approche de stylisation :

    • Méthodologie CSS (modules CSS, styled-components, etc.)
    • Implémentation de thème
    • Motifs de design réactif" : ""}

7. Plan directeur pour l'implémentation de nouveau code

${DEPTH_LEVEL == "Implementation-Ready" ? "Sur la base de l'analyse, fournissez un plan directeur détaillé pour l'implémentation de nouvelles fonctionnalités :

  • Modèles de fichier/classe : Structure standard pour les types de composants courants
  • Extraits de code : Motifs de code prêts à l'emploi pour les opérations courantes
  • Liste de vérification d'implémentation : Étapes standard pour implémenter les fonctionnalités de bout en bout
  • Points d'intégration : Comment connecter le nouveau code avec les systèmes existants
  • Exigences de test : Motifs de test standard pour différents types de composants
  • Exigences de documentation : Motifs de doc standard pour les nouvelles fonctionnalités" : ""}

${INCLUDE_DIAGRAMS ? "### 8. Diagrammes de relation technologique

  • Diagramme de pile : Représentation visuelle de la pile technologique complète
  • Flux de dépendances : Comment les différentes technologies interagissent
  • Relations de composants : Comment les composants majeurs dépendent les uns des autres
  • Flux de données : Comment les données circulent dans la pile technologique" : ""}

${INCLUDE_DIAGRAMS ? "9" : "8"}. Contexte de décision technologique

  • Documentez les raisons apparentes des choix technologiques
  • Notez les technologies héritées ou dépréciées marquées pour remplacement
  • Identifiez les contraintes et limites technologiques
  • Documentez les chemins de mise à niveau technologique et les considérations de compatibilité

Formatez la sortie en ${OUTPUT_FORMAT} et catégorisez les technologies par ${CATEGORIZATION}.

Enregistrez la sortie en tant que 'Technology_Stack_Blueprint.${OUTPUT_FORMAT == "Markdown" ? "md" : OUTPUT_FORMAT.toLowerCase()}' "

Skills similaires

quality-playbook
github / awesome-copilot

Générer un système qualité complet et personnalisé pour tout projet logiciel.

33 044
aiconfig-migrate
launchdarkly / agent-skills

Migrer une application d'invites LLM codées en dur vers LaunchDarkly AI Configs en cinq étapes.

10
skill-creator
anthropics / skills

Créer, tester et affiner des skills pour agents IA de façon itérative.

134 761
shopify-hydrogen
shopify / agent-skills

Implémenter des fonctionnalités Hydrogen Shopify via des recettes de cookbook prêtes à l'emploi.

32
wiki
factory-ai / factory-plugins

Générer une wiki interconnectée à partir d'un dépôt de code analysé en profondeur.

72