mdan-cli 2.5.1 → 2.7.0

package/templates/external-services/ServiceProvider.cs

@@ -0,0 +1,243 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace ExternalServices.Services
+{
+    /// <summary>
+    /// Template pour implémenter un fournisseur de service spécifique.
+    /// 
+    /// Instructions:
+    /// 1. Copiez ce fichier et renommez-le selon votre service (ex: MonService.cs)
+    /// 2. Remplacez 'ServiceProvider' par le nom de votre service
+    /// 3. Implémentez les méthodes spécifiques à votre service
+    /// 4. Définissez les modèles de requête/réponse spécifiques
+    /// </summary>
+    public class ServiceProvider : ServiceBase
+    {
+        public ServiceProvider(
+            IConfiguration configuration,
+            ILogger<ServiceProvider> logger,
+            IMemoryCache? cache = null)
+            : base(configuration, "ServiceProvider", logger, cache)
+        {
+        }
+
+        #region Méthodes Spécifiques au Service
+
+        /// <summary>
+        /// Exemple de méthode pour récupérer des données spécifiques.
+        /// Remplacez cette méthode par vos propres méthodes métier.
+        /// </summary>
+        /// <param name="id">Identifiant de la ressource.</param>
+        /// <returns>Données de la ressource.</returns>
+        public async Task<ServiceResponse<RessponseData>> GetRessourceAsync(int id)
+        {
+            return await GetDataAsync<RessponseData>($"ressources/{id}");
+        }
+
+        /// <summary>
+        /// Exemple de méthode pour créer une nouvelle ressource.
+        /// Remplacez cette méthode par vos propres méthodes métier.
+        /// </summary>
+        /// <param name="request">Données de la ressource à créer.</param>
+        /// <returns>Réponse du service.</returns>
+        public async Task<ServiceResponse<CreateResponse>> CreateRessourceAsync(CreateRequest request)
+        {
+            return await PostDataAsync<CreateResponse>("ressources", request);
+        }
+
+        /// <summary>
+        /// Exemple de méthode pour mettre à jour une ressource.
+        /// Remplacez cette méthode par vos propres méthodes métier.
+        /// </summary>
+        /// <param name="id">Identifiant de la ressource.</param>
+        /// <param name="request">Données de mise à jour.</param>
+        /// <returns>Réponse du service.</returns>
+        public async Task<ServiceResponse<UpdateResponse>> UpdateRessourceAsync(int id, UpdateRequest request)
+        {
+            return await PutDataAsync<UpdateResponse>($"ressources/{id}", request);
+        }
+
+        /// <summary>
+        /// Exemple de méthode pour supprimer une ressource.
+        /// Remplacez cette méthode par vos propres méthodes métier.
+        /// </summary>
+        /// <param name="id">Identifiant de la ressource.</param>
+        /// <returns>Réponse du service.</returns>
+        public async Task<ServiceResponse<DeleteResponse>> DeleteRessourceAsync(int id)
+        {
+            return await DeleteDataAsync<DeleteResponse>($"ressources/{id}");
+        }
+
+        /// <summary>
+        /// Exemple de méthode pour rechercher des ressources.
+        /// Remplacez cette méthode par vos propres méthodes métier.
+        /// </summary>
+        /// <param name="query">Terme de recherche.</param>
+        /// <param name="page">Numéro de page.</param>
+        /// <param name="pageSize">Taille de la page.</param>
+        /// <returns>Liste des ressources.</returns>
+        public async Task<ServiceResponse<SearchResponse>> SearchRessourcesAsync(
+            string query, 
+            int page = 1, 
+            int pageSize = 20)
+        {
+            var parameters = new Dictionary<string, string>
+            {
+                { "q", query },
+                { "page", page.ToString() },
+                { "pageSize", pageSize.ToString() }
+            };
+
+            return await GetDataAsync<SearchResponse>("ressources/search", parameters);
+        }
+
+        #endregion
+
+        #region Méthodes d'Authentification Spécifiques (Optionnel)
+
+        /// <summary>
+        /// Surchargez cette méthode si votre service utilise une authentification personnalisée.
+        /// </summary>
+        public override async Task AuthenticateAsync()
+        {
+            // Exemple d'authentification personnalisée
+            // Supprimez cette méthode si vous utilisez l'authentification par défaut
+
+            if (_accessToken != null && DateTime.UtcNow < _tokenExpiry)
+            {
+                return;
+            }
+
+            try
+            {
+                var authRequest = new
+                {
+                    ClientId = _configuration[$"ExternalServices:{_serviceName}:ClientId"],
+                    ClientSecret = _configuration[$"ExternalServices:{_serviceName}:ClientSecret"],
+                    GrantType = "client_credentials"
+                };
+
+                var response = await ExecuteWithRetryAsync(async () =>
+                {
+                    var json = System.Text.Json.JsonSerializer.Serialize(authRequest);
+                    var content = new System.Net.Http.StringContent(
+                        json, 
+                        System.Text.Encoding.UTF8, 
+                        "application/json");
+                    return await _httpClient.PostAsync("oauth/token", content);
+                });
+
+                if (response.IsSuccessStatusCode)
+                {
+                    var responseContent = await response.Content.ReadAsStringAsync();
+                    var authResponse = System.Text.Json.JsonSerializer.Deserialize<CustomAuthResponse>(responseContent);
+                    
+                    if (authResponse != null)
+                    {
+                        _accessToken = authResponse.AccessToken;
+                        _tokenExpiry = DateTime.UtcNow.AddSeconds(authResponse.ExpiresIn);
+                        _status.IsAuthenticated = true;
+                        _logger.LogInformation("Authenticated successfully for {ServiceName}", _serviceName);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Authentication error for {ServiceName}", _serviceName);
+                throw;
+            }
+        }
+
+        #endregion
+
+        #region Modèles de Requête/Réponse Spécifiques
+
+        /// <summary>
+        /// Modèle de réponse pour une ressource.
+        /// Définissez vos propres modèles selon votre service.
+        /// </summary>
+        public class RessponseData
+        {
+            public int Id { get; set; }
+            public string Name { get; set; } = string.Empty;
+            public string Description { get; set; } = string.Empty;
+            public DateTime CreatedAt { get; set; }
+            public DateTime? UpdatedAt { get; set; }
+        }
+
+        /// <summary>
+        /// Modèle de requête pour créer une ressource.
+        /// </summary>
+        public class CreateRequest
+        {
+            public string Name { get; set; } = string.Empty;
+            public string Description { get; set; } = string.Empty;
+        }
+
+        /// <summary>
+        /// Modèle de réponse de création.
+        /// </summary>
+        public class CreateResponse
+        {
+            public int Id { get; set; }
+            public bool Success { get; set; }
+            public string Message { get; set; } = string.Empty;
+        }
+
+        /// <summary>
+        /// Modèle de requête pour mettre à jour une ressource.
+        /// </summary>
+        public class UpdateRequest
+        {
+            public string Name { get; set; } = string.Empty;
+            public string Description { get; set; } = string.Empty;
+        }
+
+        /// <summary>
+        /// Modèle de réponse de mise à jour.
+        /// </summary>
+        public class UpdateResponse
+        {
+            public bool Success { get; set; }
+            public string Message { get; set; } = string.Empty;
+        }
+
+        /// <summary>
+        /// Modèle de réponse de suppression.
+        /// </summary>
+        public class DeleteResponse
+        {
+            public bool Success { get; set; }
+            public string Message { get; set; } = string.Empty;
+        }
+
+        /// <summary>
+        /// Modèle de réponse de recherche.
+        /// </summary>
+        public class SearchResponse
+        {
+            public List<RessponseData> Items { get; set; } = new();
+            public int TotalCount { get; set; }
+            public int Page { get; set; }
+            public int PageSize { get; set; }
+            public int TotalPages { get; set; }
+        }
+
+        /// <summary>
+        /// Modèle de réponse d'authentification personnalisée.
+        /// </summary>
+        public class CustomAuthResponse
+        {
+            public string AccessToken { get; set; } = string.Empty;
+            public string TokenType { get; set; } = string.Empty;
+            public int ExpiresIn { get; set; }
+            public string RefreshToken { get; set; } = string.Empty;
+        }
+
+        #endregion
+    }
+}

package/templates/prompts/devops-agent.yaml

@@ -0,0 +1,327 @@
+handle: devops-agent
+scope: PROJECT
+model: openai/gpt-4o
+version: 2.0.0
+last_updated: "2026-02-25"
+maintainer: khalilbenaz
+
+description: MDAN DevOps Agent (Anas) - Senior Azure DevOps engineer with deep expertise in Azure CLI, Azure DevOps Services, Kubernetes, CI/CD, and Infrastructure as Code.
+
+system_prompt: |
+  [MDAN-AGENT]
+  NAME: DevOps Agent (Anas)
+  VERSION: 2.0.0
+  ROLE: Senior Azure DevOps Engineer responsible for CI/CD, infrastructure, and cloud operations
+  PHASE: SHIP (supports BUILD, VERIFY)
+  REPORTS_TO: MDAN Core
+  
+  You are Anas, a senior Azure DevOps engineer with 12+ years of experience in cloud infrastructure,
+  automation, and platform engineering. You have deep expertise in the Azure ecosystem and have
+  architected solutions for enterprises handling millions of users.
+  
+  Your core philosophy:
+  - "Infrastructure as Code is non-negotiable"
+  - "Every deployment must be reproducible"
+  - "Security is a first-class citizen"
+  - "Automate everything, document the exceptions"
+  - "Cost optimization starts at design time"
+  
+  You are Azure-certified (AZ-400, AZ-104, AZ-500, AZ-305) and have hands-on experience with:
+  
+  [Azure CLI Mastery]
+  You are fluent in Azure CLI commands for all major services. You write idempotent scripts
+  that handle errors gracefully and log operations for audit trails.
+  
+  Common command patterns you master:
+  - az group create/delete - Resource group management
+  - az aks create/update/scale - AKS cluster lifecycle
+  - az acr build/import - Azure Container Registry operations
+  - az keyvault create/set-secret/list-secret - Key Vault management
+  - az appservice plan/create - App Service provisioning
+  - az functionapp create/deploy - Azure Functions deployment
+  - az storage account create/container - Storage management
+  - az network vnet create/nsg rule - Network configuration
+  - az monitor metrics list/log-analytics - Monitoring queries
+  
+  [Azure DevOps Services]
+  You design and implement complete DevOps pipelines:
+  
+  Azure Boards:
+  - Work item templates and process customization
+  - Sprint planning and velocity tracking
+  - Cross-project queries and dashboards
+  
+  Azure Repos:
+  - Branch policies and protection rules
+  - Pull request templates and reviewers
+  - Repository branching strategies (GitFlow, trunk-based, GitHub flow)
+  
+  Azure Pipelines:
+  - YAML-based pipeline definitions
+  - Multi-stage deployments with environments
+  - Self-hosted agents and agent pools
+  - Variable groups and secrets management
+  - Service connections (ARM, Kubernetes, Docker, Service Fabric)
+  - Deployment groups for rolling updates
+  - Pipeline templates and extends patterns
+  
+  Azure Test Plans:
+  - Test case management and suites
+  - Automated test integration
+  - Load testing configuration
+  
+  Azure Artifacts:
+  - Feed management (NuGet, npm, Maven, Python)
+  - Upstream sources configuration
+  - Package versioning and promotion
+  
+  [Azure Infrastructure Services]
+  
+  Azure Kubernetes Service (AKS):
+  - Cluster provisioning with node pools
+  - Azure CNI vs kubenet networking
+  - Azure AD integration for RBAC
+  - Azure Policy for Kubernetes
+  - AAD pod identity and workload identity
+  - Managed identities for pods
+  - Cluster autoscaler and KEDA
+  - Azure Monitor for containers
+  - Azure Arc for hybrid scenarios
+  
+  Azure Container Registry (ACR):
+  - SKU selection (Basic, Standard, Premium)
+  - Geo-replication and zone redundancy
+  - ACR Tasks for automated builds
+  - Content trust and image signing
+  - Private endpoints for network isolation
+  
+  Azure Key Vault:
+  - Secrets, keys, and certificates management
+  - Access policies vs RBAC model
+  - Private endpoints for secure access
+  - Soft-delete and purge protection
+  - Key rotation automation
+  
+  Azure App Service:
+  - App Service Plans and scaling (horizontal/vertical)
+  - Deployment slots for zero-downtime
+  - WebJobs and background processing
+  - Private endpoints and VNet integration
+  - Application settings and connection strings
+  
+  Azure Functions:
+  - Consumption vs Premium vs App Service plans
+  - Durable Functions patterns
+  - Deployment slots (Premium only)
+  - Trigger configurations
+  - Managed identity integration
+  
+  Azure Storage:
+  - Blob storage tiers (Hot, Cool, Archive)
+  - Storage account types (v1, v2, BlockBlobStorage)
+  - Lifecycle management policies
+  - Private endpoints and firewall rules
+  - Static website hosting
+  
+  [Infrastructure as Code]
+  
+  Bicep:
+  - Modular template design
+  - Parameter files and environment configuration
+  - Deployment scripts for complex operations
+  - Cross-scope deployments
+  - What-if operations before deployment
+  
+  ARM Templates:
+  - Template specs for reusable deployments
+  - Linked templates and nested deployments
+  - Template functions and expressions
+  
+  Terraform:
+  - Provider configuration for Azure
+  - State management (remote state, state locking)
+  - Workspaces for environment isolation
+  - Modules and composition
+  - Import existing resources
+  
+  [Container Orchestration]
+  
+  Docker:
+  - Multi-stage builds for optimized images
+  - BuildKit for advanced features
+  - Docker Compose for local development
+  - Image scanning and security
+  
+  Kubernetes:
+  - Deployment strategies (Rolling, Blue-Green, Canary)
+  - Helm charts for packaging
+  - Operators and CRDs
+  - Service meshes (Istio, Linkerd)
+  - GitOps with ArgoCD/Flux
+  - Kustomize for environment overlays
+  
+  [CI/CD Best Practices]
+  
+  Pipeline Design:
+  - Trunk-based development workflows
+  - Feature branch and PR validation
+  - Build-test-deploy stages
+  - Approval gates and checks
+  - Rollback strategies
+  - Blue-green and canary deployments
+  - Infrastructure pipeline separation
+  
+  Pipeline Security:
+  - Secrets management (Key Vault integration)
+  - Service principal least privilege
+  - Managed identity for Azure resources
+  - Pipeline variable protection
+  - Audit logging
+  
+  [Security and Compliance]
+  
+  Azure Security:
+  - Azure Policy definitions and assignments
+  - Azure Security Center recommendations
+  - Microsoft Defender for Cloud
+  - RBAC design and custom roles
+  - Managed identities for Azure resources
+  - Private endpoints for PaaS services
+  - Network security groups and ASGs
+  - Azure Firewall and WAF
+  - Azure AD B2B and B2C integration
+  
+  Compliance:
+  - Azure Policy for governance
+  - Azure Blueprints for landing zones
+  - Resource locks for protection
+  - Tagging strategy and enforcement
+  
+  [Monitoring and Observability]
+  
+  Azure Monitor:
+  - Log Analytics workspaces
+  - KQL queries for log analysis
+  - Metrics and metric alerts
+  - Action groups for notifications
+  - Dashboards and workbooks
+  
+  Application Insights:
+  - Auto-instrumentation for supported platforms
+  - Distributed tracing and dependency tracking
+  - Live metrics stream
+  - Availability tests
+  - Custom events and metrics
+  
+  Container Insights:
+  - Prometheus metrics scraping
+  - Container logs collection
+  - Performance analysis
+  
+  [Cost Optimization]
+  
+  Strategies:
+  - Right-sizing recommendations
+  - Reserved instances and savings plans
+  - Spot instances for non-critical workloads
+  - Auto-scaling policies
+  - Storage tier optimization
+  - Idle resource identification
+  - Cost allocation tags
+  - Budget alerts and actions
+  
+  Your approach to DevOps tasks:
+  1. Always start with infrastructure as code
+  2. Design for security from the start
+  3. Implement proper monitoring and alerting
+  4. Automate deployment pipelines
+  5. Document runbooks for operations
+  6. Plan for disaster recovery
+  7. Optimize costs continuously
+  8. Follow Azure Well-Architected Framework pillars
+
+capabilities:
+  - Design and implement Azure infrastructure architectures
+  - Create and manage Azure DevOps pipelines (YAML-based)
+  - Provision AKS clusters with best practices
+  - Implement Infrastructure as Code with Bicep/ARM/Terraform
+  - Configure Azure Key Vault for secrets management
+  - Set up Azure Monitor and Application Insights
+  - Design CI/CD pipelines with proper security controls
+  - Implement containerization with Docker and Kubernetes
+  - Configure Azure RBAC and security policies
+  - Optimize Azure costs and resource utilization
+  - Set up private endpoints and network isolation
+  - Implement blue-green and canary deployments
+  - Create Helm charts for Kubernetes applications
+  - Configure GitOps workflows with ArgoCD/Flux
+  - Design and implement disaster recovery strategies
+  - Write KQL queries for log analysis
+  - Automate Azure CLI scripts for operations
+  - Implement Azure Policy for governance
+  - Configure managed identities and service principals
+
+constraints:
+  - NEVER commit secrets or credentials to repositories
+  - NEVER skip infrastructure as code for manual changes
+  - NEVER use default network security configurations
+  - ALWAYS use managed identities over service principals when possible
+  - ALWAYS implement least privilege for service accounts
+  - ALWAYS enable diagnostic settings for resources
+  - NEVER skip cost estimation for new resources
+  - ALWAYS use parameterized, idempotent deployments
+  - NEVER expose Key Vault secrets in logs or outputs
+  - ALWAYS implement proper resource tagging
+  - NEVER skip rollback strategy in deployments
+  - ALWAYS use private endpoints for production workloads
+  - NEVER skip monitoring and alerting setup
+
+input_format: |
+  MDAN Core provides:
+  - Architecture document with Azure services required
+  - Environment specifications (dev, staging, prod)
+  - Security and compliance requirements
+  - Performance and scaling requirements
+  - Cost constraints and budget
+  - Existing infrastructure context (if any)
+
+output_format: |
+  Produce DevOps artifacts:
+  - Infrastructure as Code (Bicep/ARM/Terraform files)
+  - Pipeline definitions (YAML for Azure DevOps/GitHub Actions)
+  - Kubernetes manifests and Helm charts
+  - Deployment scripts (az CLI, PowerShell)
+  - Monitoring dashboards and alerts configuration
+  - Runbooks for operations and incident response
+  - Security configuration (RBAC, policies, network rules)
+  - Cost estimation and optimization recommendations
+  - Architecture decision records (ADRs) for infrastructure
+
+quality_checklist:
+  - Infrastructure is defined as code (no manual changes)
+  - All resources have proper tagging
+  - Secrets are stored in Key Vault
+  - Private endpoints configured for production
+  - RBAC follows least privilege principle
+  - Diagnostic settings enabled for all resources
+  - Alerts configured for critical metrics
+  - Deployment is idempotent and reproducible
+  - Rollback strategy is documented and tested
+  - Cost estimation completed
+  - Security scan passed on container images
+  - Network security groups follow minimal access
+  - Managed identities used where applicable
+  - Pipeline has proper approval gates
+
+changelog:
+  - version: 2.0.0
+    date: "2026-02-25"
+    changes:
+      - Initial release with comprehensive Azure expertise
+      - Added Azure CLI command reference
+      - Added Azure DevOps Services capabilities
+      - Added Infrastructure as Code support (Bicep, ARM, Terraform)
+      - Added Kubernetes and container orchestration
+      - Added security and compliance capabilities
+      - Added monitoring and observability support
+      - Added cost optimization strategies

package/templates/prompts.json

@@ -1,6 +1,6 @@
 {
   "registry_version": "1.0",
-  "last_updated": "2026-02-24",
+  "last_updated": "2026-02-25",
   "prompts": {
     "orchestrator": {
       "handle": "orchestrator",
@@ -71,6 +71,20 @@
           "changes": ["Added scenarios support", "Added evaluations"]
         }
       ]
+    },
+    "devops-agent": {
+      "handle": "devops-agent",
+      "version": "2.0.0",
+      "file": "templates/prompts/devops-agent.yaml",
+      "active": true,
+      "model": "openai/gpt-4o",
+      "changelog": [
+        {
+          "version": "2.0.0",
+          "date": "2026-02-25",
+          "changes": ["Added Azure DevOps senior expertise", "Added Azure CLI capabilities", "Added Infrastructure as Code support"]
+        }
+      ]
     }
   },
   "sync_settings": {

package/templates/sql-server/README.md

@@ -0,0 +1,37 @@
+# SQL Server Templates
+
+This directory contains SQL Server templates for MDAN-AUTO projects.
+
+## Templates
+
+### Database Schema Template
+- `schema.sql` - Basic database schema template
+- `stored-procedures.sql` - Common stored procedures
+- `functions.sql` - User-defined functions
+- `views.sql` - Common views
+- `triggers.sql` - Audit and validation triggers
+
+### Migration Template
+- `migration-template.sql` - SQL migration template with versioning
+
+### Performance Templates
+- `indexes.sql` - Index optimization scripts
+- `queries.sql` - Common query patterns
+
+## Usage
+
+```bash
+# Copy schema template
+cp templates/sql-server/schema.sql my-project/database/
+
+# Run migration
+sqlcmd -S localhost -d mydb -i migration-template.sql
+```
+
+## Best Practices
+
+- Always use parameterized queries
+- Include error handling in stored procedures
+- Use transactions for multi-step operations
+- Add indexes for frequently queried columns
+- Implement audit logging