mdan-cli 2.5.1 → 2.5.2

package/app/packs/devops-azure/agents/devops-engineer/agent.py

@@ -0,0 +1,545 @@
+"""
+DevOps Engineer Agent
+
+Specialized agent for DevOps practices, infrastructure automation, and operations.
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+import asyncio
+
+
+@dataclass
+class DevOpsRequest:
+    """Request data structure for the DevOps Engineer agent."""
+
+    action: str
+    infrastructure: Optional[Dict[str, Any]] = None
+    automation_type: Optional[str] = None
+    environment: Optional[str] = None
+    tools: Optional[List[str]] = None
+
+
+class DevOpsEngineerAgent:
+    """
+    DevOps Engineer - Expert in DevOps practices and infrastructure automation.
+
+    Specialized in implementing DevOps best practices, infrastructure as code,
+    CI/CD pipelines, monitoring, and operations automation. Expert in cloud
+    platforms, containerization, and orchestration.
+    """
+
+    def __init__(self):
+        """Initialize the DevOps Engineer agent."""
+        self.name = "DevOps Engineer"
+        self.title = "DevOps and Infrastructure Automation Expert"
+        self.icon = "⚙️"
+        self.capabilities = [
+            "infrastructure as code (IaC)",
+            "CI/CD pipeline design and implementation",
+            "container orchestration (Kubernetes, Docker)",
+            "cloud platform management (AWS, Azure, GCP)",
+            "monitoring and observability",
+            "configuration management",
+            "automation scripting",
+            "incident response and troubleshooting",
+        ]
+        self.role = "DevOps Expert"
+        self.identity = (
+            "Expert DevOps engineer with comprehensive knowledge of infrastructure "
+            "automation, CI/CD practices, and cloud platforms. Specialized in building "
+            "scalable, reliable, and efficient infrastructure solutions."
+        )
+        self.communication_style = (
+            "Technical and practical, focusing on automation, scalability, and "
+            "reliability. Provides clear implementation guidance with code examples "
+            "and best practices."
+        )
+        self.principles = [
+            "Automate everything that can be automated",
+            "Treat infrastructure as code",
+            "Implement continuous integration and delivery",
+            "Monitor everything that matters",
+            "Design for failure and resilience",
+            "Practice immutable infrastructure",
+            "Use version control for all configurations",
+        ]
+
+    async def process(self, request: DevOpsRequest) -> Dict[str, Any]:
+        """
+        Process the DevOps request and return a response.
+
+        Args:
+            request: The DevOps request to process
+
+        Returns:
+            A dictionary containing the DevOps solution
+        """
+        action = request.action.lower()
+
+        if action == "deploy":
+            return await self._deploy_infrastructure(request)
+        elif action == "pipeline":
+            return await self._design_pipeline(request)
+        elif action == "monitor":
+            return await self._setup_monitoring(request)
+        elif action == "automate":
+            return await self._automate_tasks(request)
+        elif action == "troubleshoot":
+            return await self._troubleshoot(request)
+        else:
+            return await self._handle_unknown_action(request)
+
+    async def _deploy_infrastructure(self, request: DevOpsRequest) -> Dict[str, Any]:
+        """
+        Deploy infrastructure using IaC.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Infrastructure deployment plan
+        """
+        infrastructure = request.infrastructure or {}
+        environment = request.environment or "production"
+
+        deployment = {
+            "message": f"Infrastructure deployment plan for {environment}",
+            "agent": self.name,
+            "icon": self.icon,
+            "environment": environment,
+            "infrastructure": {
+                "compute": {
+                    "type": "Kubernetes cluster",
+                    "nodes": 3,
+                    "instance_type": "Standard_D4s_v3",
+                    "autoscaling": {
+                        "min_nodes": 2,
+                        "max_nodes": 10,
+                        "target_cpu": 70,
+                    },
+                },
+                "network": {
+                    "vnet_cidr": "10.0.0.0/16",
+                    "subnet_cidr": "10.0.1.0/24",
+                    "load_balancer": "Application Gateway",
+                },
+                "storage": {
+                    "type": "Azure Disk Storage",
+                    "size": "100 GB",
+                    "tier": "Premium SSD",
+                },
+                "database": {
+                    "type": "Azure Database for PostgreSQL",
+                    "tier": "General Purpose",
+                    "vcores": 4,
+                    "storage": "100 GB",
+                },
+            },
+            "iac_tools": {
+                "primary": "Terraform",
+                "secondary": "Azure Resource Manager templates",
+                "configuration_management": "Ansible",
+            },
+            "deployment_steps": [
+                "Initialize Terraform configuration",
+                "Review and validate infrastructure plan",
+                "Apply infrastructure changes",
+                "Configure Kubernetes cluster",
+                "Deploy monitoring and logging",
+                "Run smoke tests",
+                "Handover to operations team",
+            ],
+            "best_practices": [
+                "Use version control for all IaC code",
+                "Implement state management and locking",
+                "Use modular and reusable components",
+                "Implement proper tagging and naming conventions",
+                "Set up automated testing for infrastructure",
+                "Document infrastructure architecture",
+            ],
+            "security_considerations": [
+                "Use managed identities for authentication",
+                "Implement network security groups",
+                "Enable Azure Security Center",
+                "Use Azure Key Vault for secrets",
+                "Implement RBAC policies",
+                "Enable audit logging",
+            ],
+        }
+
+        return deployment
+
+    async def _design_pipeline(self, request: DevOpsRequest) -> Dict[str, Any]:
+        """
+        Design CI/CD pipeline.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Pipeline design
+        """
+        tools = request.tools or ["GitHub Actions", "Docker", "Kubernetes"]
+
+        pipeline = {
+            "message": "CI/CD pipeline design",
+            "agent": self.name,
+            "icon": self.icon,
+            "pipeline_type": "GitOps-based",
+            "stages": [
+                {
+                    "name": "Source",
+                    "description": "Code repository and version control",
+                    "tools": ["GitHub", "Git"],
+                    "triggers": ["push", "pull_request"],
+                },
+                {
+                    "name": "Build",
+                    "description": "Build application artifacts",
+                    "tools": ["Docker", "Maven/Gradle", "npm"],
+                    "steps": [
+                        "Install dependencies",
+                        "Run unit tests",
+                        "Build application",
+                        "Create Docker image",
+                        "Push to registry",
+                    ],
+                },
+                {
+                    "name": "Test",
+                    "description": "Automated testing",
+                    "tools": ["JUnit", "Selenium", "SonarQube"],
+                    "steps": [
+                        "Run integration tests",
+                        "Run end-to-end tests",
+                        "Security scanning",
+                        "Code quality analysis",
+                    ],
+                },
+                {
+                    "name": "Deploy",
+                    "description": "Deploy to environments",
+                    "tools": ["Kubernetes", "Helm", "ArgoCD"],
+                    "environments": ["dev", "staging", "production"],
+                    "strategy": "Blue-Green deployment",
+                },
+                {
+                    "name": "Monitor",
+                    "description": "Post-deployment monitoring",
+                    "tools": ["Prometheus", "Grafana", "ELK Stack"],
+                    "steps": [
+                        "Health checks",
+                        "Performance monitoring",
+                        "Error tracking",
+                        "Alert configuration",
+                    ],
+                },
+            ],
+            "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",
+            ],
+            "metrics": [
+                "Build success rate",
+                "Deployment frequency",
+                "Lead time for changes",
+                "Mean time to recovery",
+                "Change failure rate",
+            ],
+        }
+
+        return pipeline
+
+    async def _setup_monitoring(self, request: DevOpsRequest) -> Dict[str, Any]:
+        """
+        Set up monitoring and observability.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Monitoring setup
+        """
+        monitoring = {
+            "message": "Monitoring and observability setup",
+            "agent": self.name,
+            "icon": self.icon,
+            "monitoring_stack": {
+                "metrics": "Prometheus + Grafana",
+                "logs": "ELK Stack (Elasticsearch, Logstash, Kibana)",
+                "traces": "Jaeger",
+                "alerts": "Alertmanager",
+            },
+            "metrics_to_track": [
+                {
+                    "category": "Application",
+                    "metrics": [
+                        "Request rate",
+                        "Error rate",
+                        "Response time (p50, p95, p99)",
+                        "Throughput",
+                    ],
+                },
+                {
+                    "category": "Infrastructure",
+                    "metrics": [
+                        "CPU utilization",
+                        "Memory usage",
+                        "Disk I/O",
+                        "Network traffic",
+                    ],
+                },
+                {
+                    "category": "Business",
+                    "metrics": [
+                        "Active users",
+                        "Transaction volume",
+                        "Revenue",
+                        "Conversion rate",
+                    ],
+                },
+            ],
+            "alerting_rules": [
+                {
+                    "name": "High Error Rate",
+                    "condition": "error_rate > 5% for 5 minutes",
+                    "severity": "critical",
+                    "notification": ["Slack", "PagerDuty"],
+                },
+                {
+                    "name": "High Response Time",
+                    "condition": "p95_response_time > 2s for 10 minutes",
+                    "severity": "warning",
+                    "notification": ["Slack"],
+                },
+                {
+                    "name": "High CPU Usage",
+                    "condition": "cpu_usage > 80% for 15 minutes",
+                    "severity": "warning",
+                    "notification": ["Slack"],
+                },
+            ],
+            "dashboards": [
+                "Application Overview",
+                "Infrastructure Health",
+                "Business Metrics",
+                "Alert Summary",
+            ],
+            "best_practices": [
+                "Monitor the four golden signals (latency, traffic, errors, saturation)",
+                "Use structured logging",
+                "Implement distributed tracing",
+                "Set up meaningful alerts",
+                "Create actionable dashboards",
+                "Regularly review and refine metrics",
+            ],
+        }
+
+        return monitoring
+
+    async def _automate_tasks(self, request: DevOpsRequest) -> Dict[str, Any]:
+        """
+        Automate operational tasks.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Automation plan
+        """
+        automation_type = request.automation_type or "general"
+
+        automation = {
+            "message": f"Automation plan for {automation_type}",
+            "agent": self.name,
+            "icon": self.icon,
+            "automation_type": automation_type,
+            "tasks_to_automate": [
+                {
+                    "task": "Infrastructure provisioning",
+                    "tool": "Terraform",
+                    "frequency": "On-demand",
+                    "benefits": ["Consistency", "Speed", "Reproducibility"],
+                },
+                {
+                    "task": "Application deployment",
+                    "tool": "GitHub Actions + ArgoCD",
+                    "frequency": "On every commit",
+                    "benefits": ["Continuous delivery", "Rollback capability"],
+                },
+                {
+                    "task": "Backup and recovery",
+                    "tool": "Azure Backup + Custom scripts",
+                    "frequency": "Daily",
+                    "benefits": ["Data protection", "Disaster recovery"],
+                },
+                {
+                    "task": "Security patching",
+                    "tool": "Azure Automation + Ansible",
+                    "frequency": "Weekly",
+                    "benefits": ["Security compliance", "Vulnerability management"],
+                },
+                {
+                    "task": "Log rotation and cleanup",
+                    "tool": "Cron jobs + Azure Functions",
+                    "frequency": "Daily",
+                    "benefits": ["Cost optimization", "Storage management"],
+                },
+            ],
+            "automation_tools": [
+                "Terraform (IaC)",
+                "Ansible (Configuration management)",
+                "GitHub Actions (CI/CD)",
+                "Azure Automation (Task automation)",
+                "PowerShell/Bash (Scripting)",
+            ],
+            "best_practices": [
+                "Start with high-value, repetitive tasks",
+                "Use version control for automation scripts",
+                "Implement proper error handling",
+                "Add logging and monitoring",
+                "Test automation thoroughly",
+                "Document automation processes",
+            ],
+        }
+
+        return automation
+
+    async def _troubleshoot(self, request: DevOpsRequest) -> Dict[str, Any]:
+        """
+        Troubleshoot infrastructure issues.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Troubleshooting guide
+        """
+        troubleshooting = {
+            "message": "Infrastructure troubleshooting guide",
+            "agent": self.name,
+            "icon": self.icon,
+            "common_issues": [
+                {
+                    "issue": "Application not responding",
+                    "possible_causes": [
+                        "Pod crash loop",
+                        "Resource exhaustion",
+                        "Network connectivity",
+                        "Configuration error",
+                    ],
+                    "diagnostic_steps": [
+                        "Check pod status: kubectl get pods",
+                        "View pod logs: kubectl logs <pod-name>",
+                        "Check resource usage: kubectl top pods",
+                        "Test network connectivity",
+                    ],
+                    "solutions": [
+                        "Restart affected pods",
+                        "Scale up resources",
+                        "Fix configuration issues",
+                        "Check network policies",
+                    ],
+                },
+                {
+                    "issue": "High latency",
+                    "possible_causes": [
+                        "Database query performance",
+                        "Network latency",
+                        "Resource contention",
+                        "Inefficient code",
+                    ],
+                    "diagnostic_steps": [
+                        "Check application metrics",
+                        "Analyze database queries",
+                        "Review network latency",
+                        "Profile application code",
+                    ],
+                    "solutions": [
+                        "Optimize database queries",
+                        "Add caching",
+                        "Scale resources",
+                        "Optimize code",
+                    ],
+                },
+                {
+                    "issue": "Deployment failure",
+                    "possible_causes": [
+                        "Configuration error",
+                        "Resource limits",
+                        "Image pull error",
+                        "Health check failure",
+                    ],
+                    "diagnostic_steps": [
+                        "Check deployment logs",
+                        "Verify configuration",
+                        "Check resource quotas",
+                        "Test image availability",
+                    ],
+                    "solutions": [
+                        "Fix configuration",
+                        "Adjust resource limits",
+                        "Ensure image is available",
+                        "Update health checks",
+                    ],
+                },
+            ],
+            "troubleshooting_tools": [
+                "kubectl (Kubernetes CLI)",
+                "Azure CLI",
+                "Logs and metrics (Prometheus, Grafana)",
+                "Distributed tracing (Jaeger)",
+                "Log aggregation (ELK Stack)",
+            ],
+            "best_practices": [
+                "Document common issues and solutions",
+                "Use structured logging",
+                "Implement comprehensive monitoring",
+                "Create runbooks for common scenarios",
+                "Practice incident response",
+                "Conduct post-incident reviews",
+            ],
+        }
+
+        return troubleshooting
+
+    async def _handle_unknown_action(self, request: DevOpsRequest) -> 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: deploy, pipeline, monitor, automate, troubleshoot",
+        }
+
+    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,
+        }