mdan-cli 2.5.0 → 2.5.2

package/app/packs/db-optimization/agents/query-optimizer/prompt.yaml

@@ -0,0 +1,74 @@
+name: query-optimizer
+version: 1.0.0
+description: Specialized agent for SQL query optimization, execution plan analysis, and query refactoring
+
+system_prompt: |
+  You are Haytame, a Query Optimizer, a SQL Query Optimization and Execution Plan Expert.
+
+  Your capabilities:
+  - SQL query analysis and optimization
+  - Execution plan interpretation
+  - Query refactoring and rewriting
+  - Index utilization optimization
+  - Join strategy optimization
+  - Subquery optimization
+  - CTE and window function optimization
+  - Query performance prediction
+  - Index design for queries
+  - Query caching strategies
+
+  Your communication style:
+  - Technical and precise, focusing on query mechanics, execution plans, and optimization techniques
+  - Provides concrete query rewrites with explanations of why they perform better
+  - Uses specific examples and before/after comparisons
+  - Explains the underlying database behavior
+
+  Your principles:
+  - Understand the execution plan before optimizing
+  - Optimize for the actual data distribution
+  - Consider the query's place in the overall workload
+  - Balance query complexity with maintainability
+  - Use appropriate join types and orders
+  - Leverage indexes effectively
+  - Avoid unnecessary data processing
+  - Test optimizations with realistic data volumes
+
+  Your role:
+  Expert query optimizer with deep understanding of SQL query execution, database query planners, and optimization techniques. Specialized in transforming inefficient queries into high-performing alternatives across multiple database systems including PostgreSQL, MySQL, SQL Server, and Oracle.
+
+  When analyzing queries:
+  1. Examine the query structure and identify potential issues
+  2. Review the execution plan to understand how the database processes the query
+  3. Identify bottlenecks and expensive operations
+  4. Consider the data distribution and access patterns
+  5. Evaluate index usage and effectiveness
+
+  When optimizing queries:
+  - Provide specific, actionable query rewrites
+  - Explain why the optimization works
+  - Estimate the expected performance improvement
+  - Recommend appropriate indexes
+  - Consider trade-offs (performance vs. maintainability)
+  - Suggest configuration changes if needed
+
+  Common optimization techniques:
+  - Replace SELECT * with specific columns
+  - Use appropriate JOIN types (INNER, LEFT, etc.)
+  - Optimize subqueries (convert to JOINs when appropriate)
+  - Use EXISTS instead of IN for existence checks
+  - Add LIMIT to prevent processing unnecessary rows
+  - Use covering indexes for index-only scans
+  - Consider partial indexes for filtered data
+  - Optimize ORDER BY with proper indexes
+  - Use UNION ALL instead of UNION when duplicates are not a concern
+
+user_prompt_template: |
+  Task: {action}
+
+  Database Type: {db_type}
+  Query: {query}
+  Execution Plan: {execution_plan}
+  Schema Info: {schema_info}
+  Performance Goal: {performance_goal}
+
+  Please provide a comprehensive analysis and optimization recommendations.

package/app/packs/devops-azure/__init__.py

@@ -0,0 +1,13 @@
+"""DevOps/Azure Pack Package."""
+
+from .agents import (
+    DevOpsEngineerAgent,
+    AzureSpecialistAgent,
+    CICDArchitectAgent,
+)
+
+__all__ = [
+    "DevOpsEngineerAgent",
+    "AzureSpecialistAgent",
+    "CICDArchitectAgent",
+]

package/app/packs/devops-azure/agents/__init__.py

@@ -0,0 +1,11 @@
+"""DevOps/Azure Pack Agents Package."""
+
+from .devops_engineer import DevOpsEngineerAgent
+from .azure_specialist import AzureSpecialistAgent
+from .cicd_architect import CICDArchitectAgent
+
+__all__ = [
+    "DevOpsEngineerAgent",
+    "AzureSpecialistAgent",
+    "CICDArchitectAgent",
+]

package/app/packs/devops-azure/agents/azure-specialist/__init__.py

@@ -0,0 +1,5 @@
+"""Azure Specialist Agent Package."""
+
+from .agent import AzureSpecialistAgent
+
+__all__ = ["AzureSpecialistAgent"]

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

@@ -0,0 +1,584 @@
+"""
+Azure Specialist Agent
+
+Specialized agent for Azure cloud services, architecture, and optimization.
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+import asyncio
+
+
+@dataclass
+class AzureRequest:
+    """Request data structure for the Azure Specialist agent."""
+
+    action: str
+    azure_service: Optional[str] = None
+    architecture_type: Optional[str] = None
+    optimization_goal: Optional[str] = None
+    region: Optional[str] = None
+
+
+class AzureSpecialistAgent:
+    """
+    Azure Specialist - Expert in Azure cloud services and architecture.
+
+    Specialized in designing, implementing, and optimizing Azure solutions.
+    Expert in Azure services, best practices, security, and cost optimization.
+    """
+
+    def __init__(self):
+        """Initialize the Azure Specialist agent."""
+        self.name = "Azure Specialist"
+        self.title = "Azure Cloud Services and Architecture Expert"
+        self.icon = "☁️"
+        self.capabilities = [
+            "Azure architecture design",
+            "Azure service selection and configuration",
+            "Azure security and compliance",
+            "Azure cost optimization",
+            "Azure DevOps integration",
+            "Azure monitoring and management",
+            "Azure migration strategies",
+            "Azure serverless and PaaS solutions",
+        ]
+        self.role = "Azure Expert"
+        self.identity = (
+            "Expert Azure specialist with comprehensive knowledge of Azure services, "
+            "architecture patterns, and best practices. Specialized in designing scalable, "
+            "secure, and cost-effective Azure solutions."
+        )
+        self.communication_style = (
+            "Technical and Azure-focused, providing clear guidance on Azure services "
+            "and configurations. Includes specific Azure recommendations, ARM templates, "
+            "and best practices."
+        )
+        self.principles = [
+            "Design for scalability and reliability",
+            "Implement security best practices",
+            "Optimize for cost efficiency",
+            "Use managed services when possible",
+            "Implement proper monitoring and logging",
+            "Follow Azure Well-Architected Framework",
+            "Design for disaster recovery",
+        ]
+
+    async def process(self, request: AzureRequest) -> Dict[str, Any]:
+        """
+        Process the Azure request and return a response.
+
+        Args:
+            request: The Azure request to process
+
+        Returns:
+            A dictionary containing the Azure solution
+        """
+        action = request.action.lower()
+
+        if action == "design":
+            return await self._design_architecture(request)
+        elif action == "configure":
+            return await self._configure_service(request)
+        elif action == "optimize":
+            return await self._optimize_costs(request)
+        elif action == "secure":
+            return await self._implement_security(request)
+        elif action == "migrate":
+            return await self._plan_migration(request)
+        else:
+            return await self._handle_unknown_action(request)
+
+    async def _design_architecture(self, request: AzureRequest) -> Dict[str, Any]:
+        """
+        Design Azure architecture.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Architecture design
+        """
+        architecture_type = request.architecture_type or "web_application"
+        region = request.region or "East US"
+
+        architecture = {
+            "message": f"Azure architecture design for {architecture_type}",
+            "agent": self.name,
+            "icon": self.icon,
+            "architecture_type": architecture_type,
+            "region": region,
+            "components": {
+                "compute": {
+                    "service": "Azure Kubernetes Service (AKS)",
+                    "configuration": {
+                        "node_count": 3,
+                        "vm_size": "Standard_D4s_v3",
+                        "autoscaling": {
+                            "min_nodes": 2,
+                            "max_nodes": 10,
+                            "target_cpu": 70,
+                        },
+                    },
+                },
+                "networking": {
+                    "vnet": {
+                        "address_space": "10.0.0.0/16",
+                        "subnets": {
+                            "aks_subnet": "10.0.1.0/24",
+                            "database_subnet": "10.0.2.0/24",
+                            "gateway_subnet": "10.0.3.0/24",
+                        },
+                    },
+                    "load_balancer": "Azure Load Balancer",
+                    "application_gateway": "Azure Application Gateway (WAF enabled)",
+                },
+                "storage": {
+                    "service": "Azure Storage",
+                    "configuration": {
+                        "type": "Standard_LRS",
+                        "containers": ["app-data", "logs", "backups"],
+                    },
+                },
+                "database": {
+                    "service": "Azure Database for PostgreSQL",
+                    "configuration": {
+                        "tier": "General Purpose",
+                        "vcores": 4,
+                        "storage": 100,
+                        "backup_retention": 7,
+                    },
+                },
+                "caching": {
+                    "service": "Azure Cache for Redis",
+                    "configuration": {
+                        "size": "Standard C1",
+                        "shard_count": 1,
+                    },
+                },
+                "monitoring": {
+                    "service": "Azure Monitor + Application Insights",
+                    "configuration": {
+                        "log_analytics": "Enabled",
+                        "alert_rules": "Configured",
+                    },
+                },
+            },
+            "architecture_patterns": [
+                "Microservices architecture",
+                "High availability with multi-AZ deployment",
+                "Auto-scaling based on demand",
+                "Geo-redundancy for disaster recovery",
+            ],
+            "best_practices": [
+                "Use Azure Well-Architected Framework",
+                "Implement proper network segmentation",
+                "Use managed identities for authentication",
+                "Enable Azure Security Center",
+                "Implement proper backup and disaster recovery",
+                "Use Azure Policy for governance",
+                "Monitor all resources with Azure Monitor",
+            ],
+            "estimated_costs": {
+                "compute": "$300/month",
+                "networking": "$150/month",
+                "storage": "$50/month",
+                "database": "$200/month",
+                "caching": "$80/month",
+                "monitoring": "$100/month",
+                "total": "$880/month",
+            },
+        }
+
+        return architecture
+
+    async def _configure_service(self, request: AzureRequest) -> Dict[str, Any]:
+        """
+        Configure Azure service.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Service configuration
+        """
+        azure_service = request.azure_service or "Azure Kubernetes Service"
+
+        configuration = {
+            "message": f"Configuration for {azure_service}",
+            "agent": self.name,
+            "icon": self.icon,
+            "service": azure_service,
+            "configuration": {
+                "resource_group": "rg-production",
+                "location": "East US",
+                "tags": {
+                    "Environment": "Production",
+                    "Application": "WebApp",
+                    "Owner": "DevOps Team",
+                },
+            },
+            "security": {
+                "managed_identity": "Enabled",
+                "rbac": "Enabled",
+                "network_policies": "Enabled",
+                "encryption": "Enabled (Azure-managed keys)",
+            },
+            "monitoring": {
+                "diagnostic_settings": "Enabled",
+                "log_analytics_workspace": "Enabled",
+                "alert_rules": "Configured",
+            },
+            "backup": {
+                "enabled": True,
+                "retention_period": "30 days",
+                "geo_redundant": True,
+            },
+            "arm_template": {
+                "description": "ARM template for deployment",
+                "parameters": [
+                    {"name": "location", "type": "string", "defaultValue": "East US"},
+                    {
+                        "name": "environment",
+                        "type": "string",
+                        "defaultValue": "production",
+                    },
+                ],
+                "resources": [
+                    {
+                        "type": "Microsoft.ContainerService/managedClusters",
+                        "apiVersion": "2023-01-01",
+                        "name": "[parameters('clusterName')]",
+                        "location": "[parameters('location')]",
+                    },
+                ],
+            },
+            "deployment_commands": [
+                "az group create --name rg-production --location eastus",
+                "az aks create --resource-group rg-production --name aks-cluster --node-count 3 --node-vm-size Standard_D4s_v3",
+                "az aks get-credentials --resource-group rg-production --name aks-cluster",
+            ],
+        }
+
+        return configuration
+
+    async def _optimize_costs(self, request: AzureRequest) -> Dict[str, Any]:
+        """
+        Optimize Azure costs.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Cost optimization recommendations
+        """
+        optimization_goal = request.optimization_goal or "reduce_costs"
+
+        optimization = {
+            "message": f"Azure cost optimization - {optimization_goal}",
+            "agent": self.name,
+            "icon": self.icon,
+            "optimization_goal": optimization_goal,
+            "recommendations": [
+                {
+                    "area": "Compute",
+                    "recommendation": "Use Azure Reserved Instances",
+                    "potential_savings": "30-60%",
+                    "description": "Commit to 1 or 3-year reservations for predictable workloads",
+                    "action": "Purchase reserved instances for production workloads",
+                },
+                {
+                    "area": "Compute",
+                    "recommendation": "Implement auto-scaling",
+                    "potential_savings": "20-40%",
+                    "description": "Scale resources based on demand",
+                    "action": "Configure AKS cluster autoscaler and horizontal pod autoscaler",
+                },
+                {
+                    "area": "Compute",
+                    "recommendation": "Use Azure Spot Instances",
+                    "potential_savings": "60-90%",
+                    "description": "Use spot instances for fault-tolerant workloads",
+                    "action": "Configure spot node pools for batch processing jobs",
+                },
+                {
+                    "area": "Storage",
+                    "recommendation": "Optimize storage tiers",
+                    "potential_savings": "20-50%",
+                    "description": "Use appropriate storage tiers based on access patterns",
+                    "action": "Move infrequently accessed data to Cool or Archive tier",
+                },
+                {
+                    "area": "Database",
+                    "recommendation": "Right-size database resources",
+                    "potential_savings": "15-30%",
+                    "description": "Monitor and adjust database resources based on usage",
+                    "action": "Review database metrics and adjust vcores and storage",
+                },
+                {
+                    "area": "Network",
+                    "recommendation": "Optimize data transfer",
+                    "potential_savings": "10-20%",
+                    "description": "Minimize data transfer costs",
+                    "action": "Use Azure Front Door for CDN, optimize VNet peering",
+                },
+            ],
+            "tools": [
+                "Azure Cost Management + Billing",
+                "Azure Advisor",
+                "Azure Pricing Calculator",
+                "Azure Cost Analysis",
+            ],
+            "best_practices": [
+                "Regularly review Azure Advisor recommendations",
+                "Set up budget alerts",
+                "Use resource tags for cost allocation",
+                "Implement governance policies",
+                "Monitor and optimize continuously",
+                "Use Azure Cost Management APIs for automation",
+            ],
+            "estimated_monthly_savings": "$200-400",
+        }
+
+        return optimization
+
+    async def _implement_security(self, request: AzureRequest) -> Dict[str, Any]:
+        """
+        Implement Azure security.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Security implementation
+        """
+        security = {
+            "message": "Azure security implementation",
+            "agent": self.name,
+            "icon": self.icon,
+            "security_layers": [
+                {
+                    "layer": "Identity and Access Management",
+                    "controls": [
+                        "Azure Active Directory (Entra ID)",
+                        "Multi-Factor Authentication (MFA)",
+                        "Conditional Access Policies",
+                        "Privileged Identity Management (PIM)",
+                        "Managed Identities",
+                    ],
+                },
+                {
+                    "layer": "Network Security",
+                    "controls": [
+                        "Virtual Network (VNet) segmentation",
+                        "Network Security Groups (NSGs)",
+                        "Azure Firewall",
+                        "Application Gateway WAF",
+                        "DDoS Protection",
+                        "Private Endpoints",
+                    ],
+                },
+                {
+                    "layer": "Data Protection",
+                    "controls": [
+                        "Azure Key Vault",
+                        "Azure Disk Encryption",
+                        "Transparent Data Encryption (TDE)",
+                        "Always Encrypted",
+                        "Customer-managed keys",
+                    ],
+                },
+                {
+                    "layer": "Application Security",
+                    "controls": [
+                        "Azure App Service Security",
+                        "Azure Container Registry security",
+                        "Azure Security Center",
+                        "Azure Defender",
+                        "Vulnerability scanning",
+                    ],
+                },
+                {
+                    "layer": "Monitoring and Logging",
+                    "controls": [
+                        "Azure Monitor",
+                        "Azure Sentinel",
+                        "Log Analytics Workspace",
+                        "Activity Logs",
+                        "Diagnostic Settings",
+                    ],
+                },
+            ],
+            "compliance": [
+                "SOC 2",
+                "ISO 27001",
+                "HIPAA",
+                "PCI DSS",
+                "GDPR",
+            ],
+            "best_practices": [
+                "Implement zero-trust security model",
+                "Use least privilege access",
+                "Enable MFA for all users",
+                "Regularly review and update security policies",
+                "Conduct security assessments",
+                "Implement security monitoring and alerting",
+                "Keep all resources updated and patched",
+            ],
+            "security_score": "Target: 80+ (Azure Secure Score)",
+        }
+
+        return security
+
+    async def _plan_migration(self, request: AzureRequest) -> Dict[str, Any]:
+        """
+        Plan Azure migration.
+
+        Args:
+            request: The request to process
+
+        Returns:
+            Migration plan
+        """
+        migration = {
+            "message": "Azure migration plan",
+            "agent": self.name,
+            "icon": self.icon,
+            "migration_phases": [
+                {
+                    "phase": "Assess",
+                    "duration": "2-4 weeks",
+                    "activities": [
+                        "Inventory existing workloads",
+                        "Assess dependencies",
+                        "Estimate costs",
+                        "Identify migration blockers",
+                        "Create migration strategy",
+                    ],
+                    "tools": [
+                        "Azure Migrate",
+                        "Azure Assessment",
+                        "Azure TCO Calculator",
+                    ],
+                },
+                {
+                    "phase": "Migrate",
+                    "duration": "4-8 weeks",
+                    "activities": [
+                        "Set up Azure infrastructure",
+                        "Migrate data",
+                        "Migrate applications",
+                        "Configure networking",
+                        "Implement security",
+                    ],
+                    "tools": [
+                        "Azure Database Migration Service",
+                        "Azure Site Recovery",
+                        "Azure Data Factory",
+                    ],
+                },
+                {
+                    "phase": "Optimize",
+                    "duration": "2-4 weeks",
+                    "activities": [
+                        "Optimize performance",
+                        "Implement auto-scaling",
+                        "Optimize costs",
+                        "Configure monitoring",
+                        "Implement disaster recovery",
+                    ],
+                    "tools": [
+                        "Azure Advisor",
+                        "Azure Monitor",
+                        "Azure Cost Management",
+                    ],
+                },
+                {
+                    "phase": "Manage",
+                    "duration": "Ongoing",
+                    "activities": [
+                        "Monitor performance",
+                        "Manage security",
+                        "Optimize costs",
+                        "Implement updates",
+                        "Handle incidents",
+                    ],
+                    "tools": [
+                        "Azure Monitor",
+                        "Azure Security Center",
+                        "Azure Automation",
+                    ],
+                },
+            ],
+            "migration_strategies": [
+                {
+                    "strategy": "Rehost (Lift and Shift)",
+                    "description": "Move applications to Azure with minimal changes",
+                    "best_for": "Quick migration, legacy applications",
+                    "effort": "Low",
+                },
+                {
+                    "strategy": "Refactor",
+                    "description": "Make minimal changes to optimize for Azure",
+                    "best_for": "Applications needing cloud optimization",
+                    "effort": "Medium",
+                },
+                {
+                    "strategy": "Rearchitect",
+                    "description": "Redesign applications for cloud-native architecture",
+                    "best_for": "Modern applications, microservices",
+                    "effort": "High",
+                },
+                {
+                    "strategy": "Rebuild",
+                    "description": "Build new applications using Azure services",
+                    "best_for": "Applications requiring complete rewrite",
+                    "effort": "Very High",
+                },
+            ],
+            "best_practices": [
+                "Start with a pilot migration",
+                "Use Azure Migrate for assessment",
+                "Implement proper monitoring from day one",
+                "Plan for rollback",
+                "Train team on Azure services",
+                "Document all migration steps",
+            ],
+        }
+
+        return migration
+
+    async def _handle_unknown_action(self, request: AzureRequest) -> 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, configure, optimize, secure, migrate",
+        }
+
+    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,
+        }