Prompt file imported from paz-dev-com/GPO.Tool.SpecKit (.github/prompts/speckit.plan.prompt.md). Copyright stays with the author.

Agent de Planification - SpecKit GPO Tool

Contexte Technique

Stack Technologique

• Backend : .NET 8, ASP.NET Core
• Frontend : Blazor (Server ou WebAssembly selon exigences)
• Base de données : SQL Server
• UI Framework : Bootstrap 5
• JavaScript/TypeScript : ESLint pour la qualité du code
• ORM : Entity Framework Core 8
• Authentification : ASP.NET Core Identity + Active Directory

Architecture Cible

• Architecture Clean (Onion/Hexagonal)
• Principes SOLID
• Pattern CQRS (si complexité justifiée)
• Repository Pattern
• Dependency Injection native ASP.NET Core
• Séparation des responsabilités stricte

Principes de Planification

1. Décomposition en Couches

Toute planification doit respecter cette structure de projet :

GPO.Tool.VibeCode/
??? src/
?   ??? VibeCode.Web/                  # Blazor Application
?   ?   ??? Pages/                      # Blazor Pages/Components
?   ?   ??? Components/                 # Composants réutilisables
?   ?   ??? Layouts/                    # Layouts Blazor
?   ?   ??? wwwroot/                    # Static files, CSS, JS
?   ?   ??? Program.cs
?   ?
?   ??? VibeCode.Application/           # Couche Application (Use Cases)
?   ?   ??? Common/                     # Interfaces, DTOs
?   ?   ??? Users/                      # Use cases utilisateurs
?   ?   ??? GPO/                        # Use cases GPO
?   ?   ??? Scripts/                    # Use cases scripts
?   ?   ??? Audit/                      # Use cases audit
?   ?   ??? Services/                   # Services métier
?   ?
?   ??? VibeCode.Domain/                # Couche Domaine (Entités, Logique métier)
?   ?   ??? Entities/                   # Entités métier
?   ?   ??? Enums/                      # Énumérations
?   ?   ??? Exceptions/                 # Exceptions métier
?   ?   ??? Interfaces/                 # Interfaces domaine
?   ?   ??? ValueObjects/               # Value Objects
?   ?
?   ??? VibeCode.Infrastructure/        # Couche Infrastructure
?   ?   ??? Data/                       # EF Core DbContext, Migrations
?   ?   ??? Repositories/               # Implémentation repositories
?   ?   ??? Services/                   # Services infrastructure (Email, Scripts)
?   ?   ??? ActiveDirectory/            # Intégration AD/GPMC
?   ?   ??? Security/                   # Authentification, Autorisation
?   ?
?   ??? VibeCode.Shared/                # Couche partagée
?       ??? DTOs/                       # Data Transfer Objects
?       ??? Constants/                  # Constantes
?       ??? Helpers/                    # Helpers utilitaires
?
??? tests/
    ??? VibeCode.UnitTests/             # Tests unitaires
    ??? VibeCode.IntegrationTests/      # Tests d'intégration
    ??? VibeCode.E2ETests/              # Tests end-to-end (si applicable)

2. Priorisation des Tâches

Phase 1 : Fondations (Sprint 1-2)

1. Setup infrastructure projet

   • Création de la solution multi-projets
   • Configuration Entity Framework Core
   • Mise en place CI/CD basique
   • Configuration ESLint, StyleCop

2. Authentification et autorisation

   • Modèle utilisateur (User entity)
   • ASP.NET Core Identity setup
   • Gestion des rôles (Admin, Auditeur, Standard)
   • Intégration Active Directory (optionnel phase 1)
   • Login/Logout

3. Audit logging foundation

   • Entité AuditLog
   • Service de logging
   • Middleware d'audit

Phase 2 : Gestion Utilisateurs (Sprint 3-4)

1. CRUD Utilisateurs (Admin)

   • US-USER-001 à US-USER-004
   • Pages Blazor : Liste, Création, Édition
   • Validation côté client et serveur
   • Tests unitaires et d'intégration

2. Gestion des permissions

   • Authorization handlers
   • Policies par rôle
   • Tests de sécurité

Phase 3 : Gestion GPO (Sprint 5-6)

1. Intégration GPMC

   • Service d'accès aux GPO (GroupPolicyService)
   • Cache des données GPO
   • US-GPO-001 à US-GPO-002

2. Gestion avancée GPO

   • US-GPO-003 : Modification (Admin)
   • US-GPO-004 : Export/Import
   • Tests d'intégration avec AD

Phase 4 : Exécution Scripts (Sprint 7-8)

1. Catalogue et exécution

   • US-SCRIPT-001 à US-SCRIPT-003
   • Service d'exécution PowerShell sécurisé
   • Gestion timeout et annulation
   • Streaming des résultats

2. Historique et monitoring

   • Sauvegarde des résultats
   • Pages de consultation historique
   • Notifications temps réel (SignalR)

Phase 5 : Audit et Dashboard (Sprint 9-10)

1. Module d'audit

   • US-AUDIT-001 à US-AUDIT-002
   • Export multi-formats (CSV, Excel, PDF)
   • Génération de rapports

2. Dashboard

   • US-DASH-001
   • Graphiques et statistiques
   • Widgets par rôle

Phase 6 : Finalisation (Sprint 11-12)

1. Performance et optimisation

   • Profiling et optimisation requêtes
   • Cache stratégique
   • Lazy loading

2. Tests et documentation

   • Tests de charge
   • Documentation utilisateur
   • Documentation technique
   • Guides de déploiement

3. Dépendances Techniques

NuGet Packages Requis

Backend Core

• Microsoft.AspNetCore.Blazor (version 8.0+)
• Microsoft.EntityFrameworkCore.SqlServer (8.0+)
• Microsoft.EntityFrameworkCore.Tools (8.0+)
• Microsoft.AspNetCore.Identity.EntityFrameworkCore (8.0+)

Authentification & Sécurité

• Microsoft.AspNetCore.Authentication.Negotiate (AD integration)
• Microsoft.AspNetCore.Authentication.JwtBearer (si API)
• System.DirectoryServices.AccountManagement (AD queries)

Audit & Logging

• Serilog.AspNetCore (logging structuré)
• Serilog.Sinks.File
• Serilog.Sinks.MSSqlServer

Export de données

• ClosedXML (Excel export)
• iTextSharp ou QuestPDF (PDF generation)
• CsvHelper (CSV export)

Scripts & PowerShell

• System.Management.Automation (PowerShell execution)

UI & Composants

• Blazorise.Bootstrap5 (composants Bootstrap pour Blazor)
• BlazorStrap (alternative)
• Radzen.Blazor (composants riches, optionnel)

Tests

• xUnit ou NUnit
• Moq (mocking)
• FluentAssertions
• Microsoft.AspNetCore.Mvc.Testing (tests d'intégration)
• Bogus (génération de données test)

Code Quality

• StyleCop.Analyzers (code style C#)
• Microsoft.CodeAnalysis.NetAnalyzers

Frontend Tools

• Bootstrap 5 (déjà inclus)
• ESLint pour JavaScript/TypeScript
  • Configuration : .eslintrc.json
  • Règles : Airbnb ou Standard
• Prettier (formatage code)

4. Stratégie de Migration Base de Données

Migrations Entity Framework Core

# Création migration initiale
dotnet ef migrations add InitialCreate --project GPO.Tool.SpecKit.Infrastructure --startup-project GPO.Tool.SpecKit.Web

# Application migration
dotnet ef database update --project GPO.Tool.SpecKit.Infrastructure --startup-project GPO.Tool.SpecKit.Web

Ordre de création des tables

1. Users (entité principale)
2. Roles (si non géré par Identity)
3. AuditLogs (dépend de Users)
4. Scripts (indépendant)
5. ScriptExecutions (dépend de Users et Scripts)
6. GPOCache (indépendant)

5. Structure d'une User Story Planifiée

Pour chaque User Story, la planification doit inclure :

Exemple : US-USER-001 (Créer un utilisateur)

1. Tâches Backend

• Créer entité User dans Domain/Entities
• Créer DTO CreateUserDto dans Shared/DTOs
• Créer interface IUserRepository dans Domain/Interfaces
• Implémenter UserRepository dans Infrastructure/Repositories
• Créer CreateUserCommand dans Application/Users/Commands
• Créer CreateUserCommandHandler avec validation
• Créer IUserService dans Application/Common/Interfaces
• Implémenter UserService dans Application/Services
• Ajouter validation avec FluentValidation
• Créer tests unitaires pour UserService
• Créer tests d'intégration pour UserRepository

2. Tâches Frontend (Blazor)

• Créer composant UserCreateForm.razor
• Créer page Users/Create.razor
• Ajouter validation côté client (DataAnnotations)
• Gérer état du formulaire (loading, errors)
• Afficher messages de succès/erreur
• Ajouter navigation après création
• Créer tests de composant (bUnit)

3. Tâches Sécurité

• Ajouter [Authorize(Policy = "AdminOnly")] sur endpoints
• Créer policy AdminOnly dans Program.cs
• Tester accès avec différents rôles
• Ajouter audit log après création

4. Tâches Documentation

• Documenter API endpoint (Swagger comments)
• Ajouter commentaires XML sur méthodes publiques
• Mettre à jour diagramme de séquence

Estimation : 5-8 points (Story Points) Priorité : High (fondation) Dépendances : Setup infrastructure, Entity User, ASP.NET Identity

6. Patterns et Pratiques Recommandés

6.1 CQRS (Command Query Responsibility Segregation)

// Command (Write)
public record CreateUserCommand(string Username, string Email, UserRole Role) : IRequest<Result<Guid>>;

public class CreateUserCommandHandler : IRequestHandler<CreateUserCommand, Result<Guid>>
{
    // Implementation
}

// Query (Read)
public record GetUserByIdQuery(Guid Id) : IRequest<Result<UserDto>>;

public class GetUserByIdQueryHandler : IRequestHandler<GetUserByIdQuery, Result<UserDto>>
{
    // Implementation
}

6.2 Result Pattern (au lieu d'exceptions)

public class Result<T>
{
    public bool IsSuccess { get; }
    public T Value { get; }
    public Error Error { get; }
    
    // Static factory methods
    public static Result<T> Success(T value) => new(true, value, Error.None);
    public static Result<T> Failure(Error error) => new(false, default, error);
}

6.3 Repository Pattern

public interface IRepository<T> where T : class
{
    Task<T?> GetByIdAsync(Guid id, CancellationToken cancellationToken = default);
    Task<IEnumerable<T>> GetAllAsync(CancellationToken cancellationToken = default);
    Task<T> AddAsync(T entity, CancellationToken cancellationToken = default);
    Task UpdateAsync(T entity, CancellationToken cancellationToken = default);
    Task DeleteAsync(T entity, CancellationToken cancellationToken = default);
}

6.4 Service Pattern

public interface IUserService
{
    Task<Result<UserDto>> CreateUserAsync(CreateUserDto dto, CancellationToken cancellationToken = default);
    Task<Result<UserDto>> GetUserByIdAsync(Guid id, CancellationToken cancellationToken = default);
    Task<Result<IEnumerable<UserDto>>> GetAllUsersAsync(CancellationToken cancellationToken = default);
    Task<Result> UpdateUserAsync(Guid id, UpdateUserDto dto, CancellationToken cancellationToken = default);
    Task<Result> DeleteUserAsync(Guid id, CancellationToken cancellationToken = default);
}

7. Standards de Qualité

7.1 Code C#

• StyleCop : règles de style activées
• Code Analysis : niveau latest-all
• Warnings as Errors en production
• Nullable Reference Types activé
• XML Documentation pour API publiques

7.2 JavaScript/TypeScript

// .eslintrc.json
{
  "extends": ["airbnb-base", "prettier"],
  "env": {
    "browser": true,
    "es2021": true
  },
  "parserOptions": {
    "ecmaVersion": 12,
    "sourceType": "module"
  },
  "rules": {
    "no-console": "warn",
    "no-unused-vars": "error",
    "prefer-const": "error"
  }
}

7.3 Tests

• Couverture minimale : 80% globale
• Tests unitaires : logique métier isolée
• Tests d'intégration : base de données, repositories
• Tests E2E : parcours utilisateur critiques (Playwright/Selenium)

8. CI/CD Pipeline

8.1 Pipeline de Build

# .github/workflows/build.yml
name: Build and Test

on: [push, pull_request]

jobs:
  build:
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup .NET 8
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: 8.0.x
      - name: Restore dependencies
        run: dotnet restore
      - name: Build
        run: dotnet build --no-restore --configuration Release
      - name: Test
        run: dotnet test --no-build --configuration Release --verbosity normal
      - name: Code Coverage
        run: dotnet test --collect:"XPlat Code Coverage"

8.2 Quality Gates

• ? Build réussit
• ? Tous les tests passent
• ? Couverture de code > 80%
• ? Pas de warnings critiques
• ? ESLint pas d'erreurs
• ? Revue de code approuvée

9. Stratégie de Tests

9.1 Tests Unitaires

public class UserServiceTests
{
    private readonly Mock<IUserRepository> _userRepositoryMock;
    private readonly Mock<IAuditService> _auditServiceMock;
    private readonly UserService _sut;

    public UserServiceTests()
    {
        _userRepositoryMock = new Mock<IUserRepository>();
        _auditServiceMock = new Mock<IAuditService>();
        _sut = new UserService(_userRepositoryMock.Object, _auditServiceMock.Object);
    }

    [Fact]
    public async Task CreateUserAsync_WithValidData_ReturnsSuccess()
    {
        // Arrange
        var dto = new CreateUserDto("john.doe", "john@example.com", UserRole.Standard);
        
        // Act
        var result = await _sut.CreateUserAsync(dto);
        
        // Assert
        result.IsSuccess.Should().BeTrue();
        _userRepositoryMock.Verify(r => r.AddAsync(It.IsAny<User>(), default), Times.Once);
        _auditServiceMock.Verify(a => a.LogAsync(It.IsAny<AuditLog>(), default), Times.Once);
    }
}

9.2 Tests d'Intégration

public class UserRepositoryIntegrationTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;

    public UserRepositoryIntegrationTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }

    [Fact]
    public async Task AddAsync_ShouldPersistUser()
    {
        // Arrange
        using var scope = _factory.Services.CreateScope();
        var repository = scope.ServiceProvider.GetRequiredService<IUserRepository>();
        var user = new User { Username = "test.user", Email = "test@example.com" };

        // Act
        var result = await repository.AddAsync(user);

        // Assert
        result.Should().NotBeNull();
        result.Id.Should().NotBe(Guid.Empty);
    }
}

10. Checklist de Planification

Avant de valider un plan de développement, vérifier :

• Architecture : respect de Clean Architecture
• Couches : séparation claire (Domain, Application, Infrastructure, Web)
• Dépendances : packages NuGet identifiés et versionnés
• Sécurité : authentification, autorisation, audit prévus
• Tests : stratégie de test définie (unitaire, intégration, E2E)
• Performance : critères de performance identifiés
• Base de données : migrations EF Core planifiées
• UI/UX : composants Blazor identifiés, Bootstrap utilisé
• Code Quality : ESLint, StyleCop configurés
• CI/CD : pipeline de build défini
• Documentation : plan de documentation (code, API, utilisateur)
• Priorisation : tâches ordonnées par dépendances et valeur métier
• Estimation : story points ou temps estimés
• Risques : risques techniques identifiés

11. Gestion des Risques Techniques

Risques Identifiés

12. Livrables par Sprint

Chaque sprint doit produire :

• ? Code fonctionnel mergé sur main
• ? Tests passants (couverture > 80%)
• ? Migrations base de données appliquées
• ? Documentation technique à jour
• ? Démo fonctionnelle (si applicable)
• ? Changelog mis à jour

13. Conventions de Nommage

C# / .NET

• Namespaces : VibeCode.{Couche}.{Module}
• Classes : PascalCase (UserService, CreateUserCommand)
• Interfaces : PascalCase avec préfixe I (IUserRepository)
• Méthodes : PascalCase (GetUserByIdAsync)
• Variables locales : camelCase (userId, userName)
• Constantes : PascalCase (MaxUsersPerPage)
• Fichiers : même nom que la classe principale

Blazor

• Composants : PascalCase (UserCreateForm.razor)
• Pages : PascalCase dans dossier (Users/Create.razor)
• Paramètres : PascalCase avec [Parameter]

Base de Données

• Tables : PascalCase pluriel (Users, AuditLogs)
• Colonnes : PascalCase (FirstName, CreatedAt)
• Clés étrangères : {Table}Id (UserId, ScriptId)
• Index : IX_{Table}_{Column(s)}

14. Documentation Requise

Pour chaque fonctionnalité majeure :

• Architecture Decision Records (ADR) pour choix techniques importants
• Sequence Diagrams pour flux complexes
• API Documentation (Swagger/OpenAPI)
• README par projet avec instructions de setup
• CHANGELOG.md maintenu à jour
• Guide de contribution (CONTRIBUTING.md)

Conclusion

L'agent de planification doit produire des plans détaillés, réalistes et alignés avec :

• La constitution du projet (qualité, tests, performance, sécurité)
• Les spécifications fonctionnelles détaillées
• L'architecture technique moderne (.NET 8, Blazor, Clean Architecture)
• Les contraintes de l'environnement bancaire cloisonné

Chaque plan doit être actionnable, testable et mesurable.