mdan-cli 2.5.0 → 2.5.2

package/app/packs/devops-azure/agents/cicd-architect/agent.py

@@ -0,0 +1,665 @@
+"""
+CI/CD Architect Agent
+
+Specialized agent for CI/CD pipeline design, implementation, and optimization.
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+import asyncio
+
+
+@dataclass
+class CICDRequest:
+    """Request data structure for the CI/CD Architect agent."""
+
+    action: str
+    pipeline_type: Optional[str] = None
+    deployment_strategy: Optional[str] = None
+    tools: Optional[List[str]] = None
+    environment: Optional[str] = None
+
+
+class CICDArchitectAgent:
+    """
+    CI/CD Architect - Expert in CI/CD pipeline design and implementation.
+
+    Specialized in designing, implementing, and optimizing CI/CD pipelines.
+    Expert in GitOps, infrastructure as code, automated testing, and deployment
+    strategies.
+    """
+
+    def __init__(self):
+        """Initialize the CI/CD Architect agent."""
+        self.name = "CI/CD Architect"
+        self.title = "CI/CD Pipeline Design and Implementation Expert"
+        self.icon = "🔄"
+        self.capabilities = [
+            "CI/CD pipeline design and implementation",
+            "GitOps workflows",
+            "Infrastructure as Code integration",
+            "Automated testing strategies",
+            "Deployment strategies (Blue-Green, Canary, Rolling)",
+            "Pipeline security and compliance",
+            "Pipeline monitoring and optimization",
+            "Multi-environment pipeline management",
+        ]
+        self.role = "CI/CD Expert"
+        self.identity = (
+            "Expert CI/CD architect with comprehensive knowledge of pipeline design, "
+            "GitOps practices, and deployment strategies. Specialized in building "
+            "efficient, secure, and reliable CI/CD pipelines."
+        )
+        self.communication_style = (
+            "Technical and practical, focusing on pipeline efficiency, automation, "
+            "and reliability. Provides clear pipeline configurations, YAML examples, "
+            "and best practices."
+        )
+        self.principles = [
+            "Automate everything that can be automated",
+            "Fail fast and fail often",
+            "Keep pipelines fast and efficient",
+            "Implement proper testing at every stage",
+            "Use immutable infrastructure",
+            "Implement feature flags",
+            "Monitor pipeline performance",
+            "Practice continuous improvement",
+        ]
+
+    async def process(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Process the CI/CD request and return a response.
+
+        Args:
+            request: The CI/CD request to process
+
+        Returns:
+            A dictionary containing the CI/CD solution
+        """
+        action = request.action.lower()
+
+        if action == "design":
+            return await self._design_pipeline(request)
+        elif action == "implement":
+            return await self._implement_pipeline(request)
+        elif action == "optimize":
+            return await self._optimize_pipeline(request)
+        elif action == "secure":
+            return await self._secure_pipeline(request)
+        elif action == "monitor":
+            return await self._monitor_pipeline(request)
+        else:
+            return await self._handle_unknown_action(request)
+
+    async def _design_pipeline(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Design CI/CD pipeline.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Pipeline design
+        """
+        pipeline_type = request.pipeline_type or "application_deployment"
+        deployment_strategy = request.deployment_strategy or "blue_green"
+
+        pipeline = {
+            "message": f"CI/CD pipeline design for {pipeline_type}",
+            "agent": self.name,
+            "icon": self.icon,
+            "pipeline_type": pipeline_type,
+            "deployment_strategy": deployment_strategy,
+            "pipeline_stages": [
+                {
+                    "name": "Source",
+                    "description": "Code repository and version control",
+                    "tools": ["GitHub", "Git"],
+                    "triggers": ["push", "pull_request"],
+                    "actions": [
+                        "Validate commit messages",
+                        "Check branch protection rules",
+                        "Run pre-commit hooks",
+                    ],
+                },
+                {
+                    "name": "Build",
+                    "description": "Build application artifacts",
+                    "tools": ["Docker", "Maven/Gradle", "npm"],
+                    "steps": [
+                        "Install dependencies",
+                        "Run unit tests",
+                        "Build application",
+                        "Create Docker image",
+                        "Push to container registry",
+                        "Generate build artifacts",
+                    ],
+                    "duration": "5-10 minutes",
+                },
+                {
+                    "name": "Test",
+                    "description": "Automated testing",
+                    "tools": ["JUnit", "Selenium", "SonarQube", "OWASP ZAP"],
+                    "steps": [
+                        "Run integration tests",
+                        "Run end-to-end tests",
+                        "Security scanning (SAST/DAST)",
+                        "Code quality analysis",
+                        "License compliance check",
+                    ],
+                    "duration": "10-20 minutes",
+                },
+                {
+                    "name": "Deploy",
+                    "description": "Deploy to environments",
+                    "tools": ["Kubernetes", "Helm", "ArgoCD"],
+                    "environments": ["dev", "staging", "production"],
+                    "strategy": deployment_strategy,
+                    "steps": [
+                        "Update deployment configuration",
+                        "Deploy to dev environment",
+                        "Run smoke tests",
+                        "Promote to staging",
+                        "Run full test suite",
+                        "Promote to production",
+                    ],
+                    "duration": "5-15 minutes",
+                },
+                {
+                    "name": "Verify",
+                    "description": "Post-deployment verification",
+                    "tools": ["Prometheus", "Grafana", "Selenium"],
+                    "steps": [
+                        "Health checks",
+                        "Performance monitoring",
+                        "Error tracking",
+                        "User acceptance tests",
+                    ],
+                    "duration": "5-10 minutes",
+                },
+            ],
+            "deployment_strategies": {
+                "blue_green": {
+                    "description": "Deploy new version alongside old, then switch traffic",
+                    "pros": ["Zero downtime", "Instant rollback"],
+                    "cons": ["Double resource cost", "Complex setup"],
+                    "best_for": "Critical applications requiring zero downtime",
+                },
+                "canary": {
+                    "description": "Gradually roll out to subset of users",
+                    "pros": ["Gradual rollout", "Early issue detection"],
+                    "cons": ["Slower rollout", "Complex monitoring"],
+                    "best_for": "High-traffic applications",
+                },
+                "rolling": {
+                    "description": "Gradually replace old instances with new",
+                    "pros": ["Resource efficient", "Simple"],
+                    "cons": ["Potential downtime", "Slower rollback"],
+                    "best_for": "Stateless applications",
+                },
+            },
+            "best_practices": [
+                "Implement automated testing at every stage",
+                "Use immutable infrastructure",
+                "Implement feature flags",
+                "Automate rollback procedures",
+                "Use pipeline as code",
+                "Implement security scanning",
+                "Monitor pipeline performance",
+                "Keep pipelines fast and efficient",
+            ],
+            "dora_metrics": [
+                "Deployment frequency",
+                "Lead time for changes",
+                "Mean time to recovery (MTTR)",
+                "Change failure rate",
+            ],
+        }
+
+        return pipeline
+
+    async def _implement_pipeline(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Implement CI/CD pipeline.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Pipeline implementation
+        """
+        tools = request.tools or ["GitHub Actions", "Docker", "Kubernetes"]
+
+        implementation = {
+            "message": "CI/CD pipeline implementation",
+            "agent": self.name,
+            "icon": self.icon,
+            "tools": tools,
+            "github_actions_workflow": {
+                "name": "CI/CD Pipeline",
+                "on": {
+                    "push": {"branches": ["main", "develop"]},
+                    "pull_request": {"branches": ["main"]},
+                },
+                "jobs": {
+                    "build": {
+                        "runs-on": "ubuntu-latest",
+                        "steps": [
+                            {"uses": "actions/checkout@v3"},
+                            {
+                                "name": "Set up Docker Buildx",
+                                "uses": "docker/setup-buildx-action@v2",
+                            },
+                            {
+                                "name": "Build and push",
+                                "uses": "docker/build-push-action@v4",
+                                "with": {
+                                    "context": ".",
+                                    "push": True,
+                                    "tags": "myapp:${{ github.sha }}",
+                                },
+                            },
+                        ],
+                    },
+                    "test": {
+                        "runs-on": "ubuntu-latest",
+                        "needs": "build",
+                        "steps": [
+                            {"uses": "actions/checkout@v3"},
+                            {"name": "Run tests", "run": "npm test"},
+                            {"name": "Run E2E tests", "run": "npm run test:e2e"},
+                        ],
+                    },
+                    "deploy": {
+                        "runs-on": "ubuntu-latest",
+                        "needs": "test",
+                        "if": "github.ref == 'refs/heads/main'",
+                        "steps": [
+                            {"uses": "actions/checkout@v3"},
+                            {
+                                "name": "Deploy to Kubernetes",
+                                "run": "kubectl apply -f k8s/",
+                            },
+                        ],
+                    },
+                },
+            },
+            "kubernetes_deployment": {
+                "apiVersion": "apps/v1",
+                "kind": "Deployment",
+                "metadata": {"name": "myapp"},
+                "spec": {
+                    "replicas": 3,
+                    "selector": {"matchLabels": {"app": "myapp"}},
+                    "template": {
+                        "metadata": {"labels": {"app": "myapp"}},
+                        "spec": {
+                            "containers": [
+                                {
+                                    "name": "myapp",
+                                    "image": "myapp:${{ github.sha }}",
+                                    "ports": [{"containerPort": 80}],
+                                    "livenessProbe": {
+                                        "httpGet": {"path": "/health", "port": 80},
+                                        "initialDelaySeconds": 30,
+                                        "periodSeconds": 10,
+                                    },
+                                    "readinessProbe": {
+                                        "httpGet": {"path": "/ready", "port": 80},
+                                        "initialDelaySeconds": 5,
+                                        "periodSeconds": 5,
+                                    },
+                                }
+                            ]
+                        },
+                    },
+                },
+            },
+            "helm_chart": {
+                "description": "Helm chart for application deployment",
+                "structure": {
+                    "Chart.yaml": "Chart metadata",
+                    "values.yaml": "Default configuration values",
+                    "templates/": "Kubernetes resource templates",
+                    "templates/deployment.yaml": "Deployment template",
+                    "templates/service.yaml": "Service template",
+                    "templates/ingress.yaml": "Ingress template",
+                },
+            },
+            "gitops_workflow": {
+                "description": "GitOps with ArgoCD",
+                "tools": ["ArgoCD", "GitHub"],
+                "workflow": [
+                    "Developer commits code to application repo",
+                    "CI pipeline builds and tests application",
+                    "CI pipeline updates image tag in deployment repo",
+                    "ArgoCD detects change in deployment repo",
+                    "ArgoCD syncs changes to Kubernetes cluster",
+                ],
+            },
+            "environment_variables": {
+                "CI": "true",
+                "NODE_ENV": "production",
+                "DATABASE_URL": "${{ secrets.DATABASE_URL }}",
+                "API_KEY": "${{ secrets.API_KEY }}",
+            },
+        }
+
+        return implementation
+
+    async def _optimize_pipeline(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Optimize CI/CD pipeline.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Pipeline optimization recommendations
+        """
+        optimization = {
+            "message": "CI/CD pipeline optimization",
+            "agent": self.name,
+            "icon": self.icon,
+            "optimization_areas": [
+                {
+                    "area": "Build Time",
+                    "current": "15 minutes",
+                    "target": "5 minutes",
+                    "recommendations": [
+                        "Use Docker layer caching",
+                        "Parallelize build steps",
+                        "Use build artifacts caching",
+                        "Optimize dependency installation",
+                        "Use faster runners",
+                    ],
+                    "potential_improvement": "60-70%",
+                },
+                {
+                    "area": "Test Time",
+                    "current": "20 minutes",
+                    "target": "10 minutes",
+                    "recommendations": [
+                        "Parallelize test execution",
+                        "Use test selection based on changes",
+                        "Implement test caching",
+                        "Use faster test frameworks",
+                        "Run smoke tests first",
+                    ],
+                    "potential_improvement": "40-50%",
+                },
+                {
+                    "area": "Deployment Time",
+                    "current": "10 minutes",
+                    "target": "3 minutes",
+                    "recommendations": [
+                        "Use blue-green deployment",
+                        "Implement canary releases",
+                        "Optimize Kubernetes rollout",
+                        "Use pre-built images",
+                        "Implement health checks",
+                    ],
+                    "potential_improvement": "60-70%",
+                },
+                {
+                    "area": "Resource Usage",
+                    "current": "High",
+                    "target": "Optimized",
+                    "recommendations": [
+                        "Use self-hosted runners",
+                        "Implement resource limits",
+                        "Use spot instances for runners",
+                        "Optimize runner sizing",
+                        "Clean up resources after pipeline",
+                    ],
+                    "potential_improvement": "30-50%",
+                },
+            ],
+            "best_practices": [
+                "Use caching for dependencies and build artifacts",
+                "Parallelize independent tasks",
+                "Fail fast with early validation",
+                "Use incremental builds",
+                "Optimize Docker images (multi-stage builds)",
+                "Use appropriate runner sizes",
+                "Monitor pipeline performance",
+                "Regularly review and optimize",
+            ],
+            "tools_for_optimization": [
+                "GitHub Actions Cache",
+                "Docker BuildKit",
+                "Parallel test runners",
+                "Build artifacts storage",
+                "Pipeline performance monitoring",
+            ],
+            "metrics_to_track": [
+                "Pipeline duration",
+                "Build time",
+                "Test time",
+                "Deployment time",
+                "Success rate",
+                "Resource usage",
+                "Cost per run",
+            ],
+        }
+
+        return optimization
+
+    async def _secure_pipeline(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Secure CI/CD pipeline.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Pipeline security implementation
+        """
+        security = {
+            "message": "CI/CD pipeline security",
+            "agent": self.name,
+            "icon": self.icon,
+            "security_measures": [
+                {
+                    "area": "Source Code Security",
+                    "measures": [
+                        "Branch protection rules",
+                        "Code review requirements",
+                        "Signed commits",
+                        "Secret scanning",
+                        "Dependency scanning (SCA)",
+                    ],
+                },
+                {
+                    "area": "Build Security",
+                    "measures": [
+                        "SAST (Static Application Security Testing)",
+                        "Container image scanning",
+                        "Vulnerability scanning",
+                        "License compliance check",
+                        "Build provenance (SBOM)",
+                    ],
+                },
+                {
+                    "area": "Pipeline Security",
+                    "measures": [
+                        "Secure secrets management",
+                        "Least privilege access",
+                        "Pipeline as code with version control",
+                        "Audit logging",
+                        "Approval gates for production",
+                    ],
+                },
+                {
+                    "area": "Deployment Security",
+                    "measures": [
+                        "Immutable infrastructure",
+                        "Infrastructure as Code with security checks",
+                        "Network policies",
+                        "Pod security policies",
+                        "Runtime security monitoring",
+                    ],
+                },
+            ],
+            "security_tools": [
+                "GitHub Advanced Security",
+                "SonarQube (SAST)",
+                "Trivy (Container scanning)",
+                "Snyk (Dependency scanning)",
+                "OWASP ZAP (DAST)",
+                "Sigstore (Image signing)",
+            ],
+            "best_practices": [
+                "Implement security scanning at every stage",
+                "Use secrets management (Azure Key Vault, GitHub Secrets)",
+                "Implement least privilege access",
+                "Use signed commits and images",
+                "Regularly update dependencies",
+                "Implement security policies as code",
+                "Monitor for security vulnerabilities",
+                "Conduct regular security audits",
+            ],
+            "compliance": [
+                "SOC 2",
+                "ISO 27001",
+                "PCI DSS",
+                "HIPAA",
+            ],
+        }
+
+        return security
+
+    async def _monitor_pipeline(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Monitor CI/CD pipeline.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Pipeline monitoring setup
+        """
+        monitoring = {
+            "message": "CI/CD pipeline monitoring",
+            "agent": self.name,
+            "icon": self.icon,
+            "metrics_to_track": [
+                {
+                    "category": "Pipeline Performance",
+                    "metrics": [
+                        "Pipeline duration",
+                        "Build time",
+                        "Test time",
+                        "Deployment time",
+                        "Queue time",
+                    ],
+                },
+                {
+                    "category": "Pipeline Quality",
+                    "metrics": [
+                        "Success rate",
+                        "Failure rate",
+                        "Flaky test rate",
+                        "Code coverage",
+                        "Code quality score",
+                    ],
+                },
+                {
+                    "category": "DORA Metrics",
+                    "metrics": [
+                        "Deployment frequency",
+                        "Lead time for changes",
+                        "Mean time to recovery (MTTR)",
+                        "Change failure rate",
+                    ],
+                },
+                {
+                    "category": "Resource Usage",
+                    "metrics": [
+                        "Runner usage",
+                        "CPU usage",
+                        "Memory usage",
+                        "Storage usage",
+                        "Cost per run",
+                    ],
+                },
+            ],
+            "alerting_rules": [
+                {
+                    "name": "Pipeline Failure",
+                    "condition": "pipeline_status == 'failed'",
+                    "severity": "critical",
+                    "notification": ["Slack", "Email"],
+                },
+                {
+                    "name": "High Build Time",
+                    "condition": "build_time > 15 minutes",
+                    "severity": "warning",
+                    "notification": ["Slack"],
+                },
+                {
+                    "name": "Low Success Rate",
+                    "condition": "success_rate < 90% over 24h",
+                    "severity": "warning",
+                    "notification": ["Slack"],
+                },
+            ],
+            "dashboards": [
+                "Pipeline Overview",
+                "Pipeline Performance",
+                "DORA Metrics",
+                "Resource Usage",
+            ],
+            "tools": [
+                "GitHub Actions Insights",
+                "Prometheus",
+                "Grafana",
+                "ELK Stack",
+                "Datadog",
+            ],
+            "best_practices": [
+                "Track DORA metrics",
+                "Monitor pipeline performance",
+                "Set up meaningful alerts",
+                "Create actionable dashboards",
+                "Regularly review metrics",
+                "Use metrics for continuous improvement",
+            ],
+        }
+
+        return monitoring
+
+    async def _handle_unknown_action(self, request: CICDRequest) -> Dict[str, Any]:
+        """
+        Handle unknown actions.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            An error message
+        """
+        return {
+            "message": "Action not recognized",
+            "action": request.action,
+            "agent": self.name,
+            "suggestion": "Use one of: design, implement, optimize, secure, monitor",
+        }
+
+    def get_info(self) -> Dict[str, Any]:
+        """
+        Get agent information.
+
+        Returns:
+            Agent information dictionary
+        """
+        return {
+            "name": self.name,
+            "title": self.title,
+            "icon": self.icon,
+            "capabilities": self.capabilities,
+            "role": self.role,
+            "identity": self.identity,
+            "communication_style": self.communication_style,
+            "principles": self.principles,
+        }