runbooks 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

runbooks/security/cloudops_automation_security_validator.py

@@ -48,7 +48,7 @@ from runbooks.common.rich_utils import (
 
 class CloudOpsSecurityLevel(Enum):
     """Security validation levels for CloudOps-Automation components."""
-    
+
     BATTLE_TESTED = "BATTLE_TESTED"  # 217 proven components
     ENTERPRISE_READY = "ENTERPRISE_READY"  # Multi-account validated
     REAL_TIME_VALIDATED = "REAL_TIME_VALIDATED"  # Live AWS API validated
@@ -57,9 +57,9 @@ class CloudOpsSecurityLevel(Enum):
 
 class ValidationCategory(Enum):
     """CloudOps-Automation security validation categories."""
-    
+
     IAM_SECURITY = "IAM_SECURITY"
-    ENCRYPTION_COMPLIANCE = "ENCRYPTION_COMPLIANCE" 
+    ENCRYPTION_COMPLIANCE = "ENCRYPTION_COMPLIANCE"
     NETWORK_SECURITY = "NETWORK_SECURITY"
     DATA_PROTECTION = "DATA_PROTECTION"
     ACCESS_CONTROL = "ACCESS_CONTROL"
@@ -70,7 +70,7 @@ class ValidationCategory(Enum):
 @dataclass
 class CloudOpsSecurityComponent:
     """Represents a CloudOps-Automation security component for validation."""
-    
+
     component_name: str
     component_path: str
     validation_category: ValidationCategory
@@ -88,7 +88,7 @@ class CloudOpsSecurityComponent:
 @dataclass
 class MultiAccountSecurityValidation:
     """Multi-account security validation results."""
-    
+
     validation_id: str
     timestamp: datetime
     accounts_validated: int
@@ -107,10 +107,10 @@ class CloudOpsAutomationSecurityValidator:
     """
     CloudOps-Automation Security Validation Framework
     =================================================
-    
+
     Validates and integrates 217 battle-tested CloudOps-Automation components
     with enterprise security-as-code patterns and real-time AWS validation.
-    
+
     Key Capabilities:
     - Security assessment of CloudOps-Automation treasure trove
     - Real-time AWS security state validation via MCP integration
@@ -123,24 +123,26 @@ class CloudOpsAutomationSecurityValidator:
         self.profile = profile
         self.output_dir = Path(output_dir)
         self.output_dir.mkdir(parents=True, exist_ok=True)
-        
+
         # Initialize secure session
         self.session = self._create_secure_session()
-        
+
         # CloudOps-Automation component inventory
-        self.automation_components_path = Path("/Volumes/Working/1xOps/CloudOps-Runbooks/README/CloudOps-Automation/AWS/legos")
+        self.automation_components_path = Path(
+            "/Volumes/Working/1xOps/CloudOps-Runbooks/README/CloudOps-Automation/AWS/legos"
+        )
         self.security_components = self._discover_security_components()
-        
+
         # Real-time validation engine
         self.real_time_validator = RealTimeSecurityValidator(self.session)
         self.mcp_integration_engine = MCPSecurityIntegration()
-        
+
         # Multi-account security controls
         self.multi_account_controller = MultiAccountSecurityController(self.session)
-        
+
         # Compliance framework engine
         self.compliance_engine = ComplianceFrameworkEngine()
-        
+
         print_header("CloudOps-Automation Security Validator", "1.0.0")
         print_success(f"Discovered {len(self.security_components)} security components")
         print_info(f"Profile: {profile}")
@@ -149,64 +151,64 @@ class CloudOpsAutomationSecurityValidator:
     def _create_secure_session(self) -> boto3.Session:
         """Create secure AWS session for security validation."""
         try:
-            session = create_management_session(profile=self.profile)
-            
+            session = create_management_session(profile_name=self.profile)
+
             # Validate session credentials
             sts_client = session.client("sts")
             identity = sts_client.get_caller_identity()
-            
+
             print_info(f"Secure session established for: {identity.get('Arn', 'Unknown')}")
             return session
-            
+
         except (ClientError, NoCredentialsError) as e:
             print_error(f"Failed to establish secure session: {str(e)}")
             raise
 
     def _discover_security_components(self) -> List[CloudOpsSecurityComponent]:
         """Discover and categorize CloudOps-Automation security components."""
-        
+
         print_info("Discovering CloudOps-Automation security components...")
-        
+
         security_components = []
-        
+
         if not self.automation_components_path.exists():
             print_warning(f"CloudOps-Automation path not found: {self.automation_components_path}")
             return security_components
-        
+
         # Security-related component patterns
         security_patterns = {
             "iam": {
                 "patterns": ["iam", "policy", "role", "user", "access"],
                 "category": ValidationCategory.IAM_SECURITY,
-                "frameworks": ["SOC2", "AWS Well-Architected", "CIS Benchmarks"]
+                "frameworks": ["SOC2", "AWS Well-Architected", "CIS Benchmarks"],
             },
             "encryption": {
                 "patterns": ["encrypt", "kms", "ssl", "tls"],
                 "category": ValidationCategory.ENCRYPTION_COMPLIANCE,
-                "frameworks": ["SOC2", "PCI-DSS", "HIPAA"]
+                "frameworks": ["SOC2", "PCI-DSS", "HIPAA"],
             },
             "security_group": {
                 "patterns": ["security_group", "firewall", "network"],
                 "category": ValidationCategory.NETWORK_SECURITY,
-                "frameworks": ["AWS Well-Architected", "CIS Benchmarks"]
+                "frameworks": ["AWS Well-Architected", "CIS Benchmarks"],
             },
             "s3_security": {
                 "patterns": ["s3", "bucket", "public"],
                 "category": ValidationCategory.DATA_PROTECTION,
-                "frameworks": ["SOC2", "PCI-DSS", "HIPAA", "AWS Well-Architected"]
-            }
+                "frameworks": ["SOC2", "PCI-DSS", "HIPAA", "AWS Well-Architected"],
+            },
         }
-        
+
         # Discover components
         component_count = 0
         for component_dir in self.automation_components_path.iterdir():
             if component_dir.is_dir():
                 component_count += 1
-                
+
                 # Analyze component for security relevance
                 component_name = component_dir.name
                 security_match = self._classify_security_component(component_name, security_patterns)
-                
+
                 if security_match:
                     component = CloudOpsSecurityComponent(
                         component_name=component_name,
@@ -216,33 +218,35 @@ class CloudOpsAutomationSecurityValidator:
                         aws_services=self._extract_aws_services(component_name),
                         compliance_frameworks=security_match["frameworks"],
                         risk_assessment=self._assess_component_risk(component_name),
-                        integration_priority=self._calculate_integration_priority(component_name, security_match)
+                        integration_priority=self._calculate_integration_priority(component_name, security_match),
                     )
                     security_components.append(component)
-        
+
         print_success(f"Total CloudOps-Automation components discovered: {component_count}")
         print_success(f"Security-relevant components identified: {len(security_components)}")
-        
+
         # Sort by integration priority
         security_components.sort(key=lambda x: x.integration_priority, reverse=True)
-        
+
         return security_components
 
-    def _classify_security_component(self, component_name: str, security_patterns: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    def _classify_security_component(
+        self, component_name: str, security_patterns: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
         """Classify component as security-relevant based on naming patterns."""
-        
+
         component_lower = component_name.lower()
-        
+
         for pattern_type, pattern_config in security_patterns.items():
             for pattern in pattern_config["patterns"]:
                 if pattern in component_lower:
                     return pattern_config
-        
+
         return None
 
     def _extract_aws_services(self, component_name: str) -> List[str]:
         """Extract AWS services from component name."""
-        
+
         services = []
         service_patterns = {
             "s3": ["s3", "bucket"],
@@ -254,24 +258,24 @@ class CloudOpsAutomationSecurityValidator:
             "vpc": ["vpc", "network"],
             "lambda": ["lambda", "function"],
             "sns": ["sns", "topic"],
-            "sqs": ["sqs", "queue"]
+            "sqs": ["sqs", "queue"],
         }
-        
+
         component_lower = component_name.lower()
         for service, patterns in service_patterns.items():
             if any(pattern in component_lower for pattern in patterns):
                 services.append(service)
-        
+
         return services if services else ["unknown"]
 
     def _assess_component_risk(self, component_name: str) -> str:
         """Assess security risk level of component."""
-        
+
         high_risk_patterns = ["terminate", "delete", "destroy", "public", "open"]
         medium_risk_patterns = ["modify", "update", "change", "attach", "detach"]
-        
+
         component_lower = component_name.lower()
-        
+
         if any(pattern in component_lower for pattern in high_risk_patterns):
             return "HIGH"
         elif any(pattern in component_lower for pattern in medium_risk_patterns):
@@ -281,37 +285,35 @@ class CloudOpsAutomationSecurityValidator:
 
     def _calculate_integration_priority(self, component_name: str, security_match: Dict[str, Any]) -> int:
         """Calculate integration priority (1-10) for runbooks integration."""
-        
+
         priority = 5  # Base priority
-        
+
         # High-value security operations get higher priority
         high_value_patterns = ["iam_policy", "encrypt", "security_group", "access_control"]
         if any(pattern in component_name.lower() for pattern in high_value_patterns):
             priority += 3
-        
+
         # Critical compliance frameworks increase priority
         if "SOC2" in security_match["frameworks"] or "PCI-DSS" in security_match["frameworks"]:
             priority += 2
-        
+
         # Multi-service components get higher priority
         if "aws_" in component_name.lower() and len(self._extract_aws_services(component_name)) > 1:
             priority += 1
-        
+
         return min(10, priority)  # Cap at 10
 
     async def comprehensive_security_validation(
-        self, 
-        target_accounts: Optional[List[str]] = None,
-        include_real_time_validation: bool = True
+        self, target_accounts: Optional[List[str]] = None, include_real_time_validation: bool = True
     ) -> MultiAccountSecurityValidation:
         """
         Execute comprehensive security validation of CloudOps-Automation components
         with real-time AWS security monitoring.
         """
-        
+
         validation_id = f"cloudops-security-{int(time.time())}"
         start_time = datetime.utcnow()
-        
+
         console.print(
             create_panel(
                 f"[bold cyan]CloudOps-Automation Security Validation[/bold cyan]\n\n"
@@ -322,287 +324,277 @@ class CloudOpsAutomationSecurityValidator:
                 border_style="cyan",
             )
         )
-        
+
         # Discover target accounts if not provided
         if not target_accounts:
             target_accounts = await self._discover_organization_accounts()
-        
+
         # Initialize validation results
         validation_results = {
-            'battle_tested_validated': 0,
-            'enterprise_ready_validated': 0,
-            'real_time_validated': 0,
-            'compliance_validated': 0,
-            'critical_findings': [],
-            'integration_candidates': []
+            "battle_tested_validated": 0,
+            "enterprise_ready_validated": 0,
+            "real_time_validated": 0,
+            "compliance_validated": 0,
+            "critical_findings": [],
+            "integration_candidates": [],
         }
-        
+
         # Validate security components
         with create_progress_bar(description="Security Validation") as progress:
-            
             # Task 1: Validate CloudOps-Automation components
             component_task = progress.add_task(
-                "[cyan]Validating CloudOps components...", 
-                total=len(self.security_components)
+                "[cyan]Validating CloudOps components...", total=len(self.security_components)
             )
-            
+
             for component in self.security_components:
                 component_result = await self._validate_security_component(component)
-                
-                if component_result['valid']:
-                    validation_results['battle_tested_validated'] += 1
-                    
-                    if component_result.get('enterprise_ready'):
-                        validation_results['enterprise_ready_validated'] += 1
-                        validation_results['integration_candidates'].append(component)
-                
+
+                if component_result["valid"]:
+                    validation_results["battle_tested_validated"] += 1
+
+                    if component_result.get("enterprise_ready"):
+                        validation_results["enterprise_ready_validated"] += 1
+                        validation_results["integration_candidates"].append(component)
+
                 progress.update(component_task, advance=1)
-            
+
             # Task 2: Real-time AWS security validation
             if include_real_time_validation:
-                aws_task = progress.add_task(
-                    "[green]Real-time AWS validation...", 
-                    total=len(target_accounts)
-                )
-                
+                aws_task = progress.add_task("[green]Real-time AWS validation...", total=len(target_accounts))
+
                 for account_id in target_accounts:
                     account_validation = await self._validate_account_real_time_security(account_id)
-                    
-                    if account_validation['success']:
-                        validation_results['real_time_validated'] += 1
-                    
-                    validation_results['critical_findings'].extend(
-                        account_validation.get('critical_findings', [])
-                    )
-                    
+
+                    if account_validation["success"]:
+                        validation_results["real_time_validated"] += 1
+
+                    validation_results["critical_findings"].extend(account_validation.get("critical_findings", []))
+
                     progress.update(aws_task, advance=1)
-        
+
         # Calculate scores
         total_components = len(self.security_components)
-        compliance_score = (validation_results['battle_tested_validated'] / total_components * 100) if total_components > 0 else 0
-        
-        security_posture_score = self._calculate_security_posture_score(
-            validation_results, target_accounts
+        compliance_score = (
+            (validation_results["battle_tested_validated"] / total_components * 100) if total_components > 0 else 0
         )
-        
+
+        security_posture_score = self._calculate_security_posture_score(validation_results, target_accounts)
+
         # Generate integration roadmap
-        integration_roadmap = self._generate_integration_roadmap(
-            validation_results['integration_candidates']
-        )
-        
+        integration_roadmap = self._generate_integration_roadmap(validation_results["integration_candidates"])
+
         # Generate recommendations
-        recommendations = self._generate_security_recommendations(
-            validation_results, target_accounts
-        )
-        
+        recommendations = self._generate_security_recommendations(validation_results, target_accounts)
+
         # Create comprehensive validation result
         validation_result = MultiAccountSecurityValidation(
             validation_id=validation_id,
             timestamp=start_time,
             accounts_validated=len(target_accounts),
             components_assessed=len(self.security_components),
-            battle_tested_components=validation_results['battle_tested_validated'],
-            enterprise_ready_components=validation_results['enterprise_ready_validated'],
-            real_time_validations=validation_results['real_time_validated'],
+            battle_tested_components=validation_results["battle_tested_validated"],
+            enterprise_ready_components=validation_results["enterprise_ready_validated"],
+            real_time_validations=validation_results["real_time_validated"],
             compliance_score=compliance_score,
             security_posture_score=security_posture_score,
-            critical_findings=validation_results['critical_findings'],
+            critical_findings=validation_results["critical_findings"],
             recommendations=recommendations,
-            integration_roadmap=integration_roadmap
+            integration_roadmap=integration_roadmap,
         )
-        
+
         # Export validation results
         await self._export_validation_results(validation_result)
-        
+
         # Display comprehensive summary
         self._display_validation_summary(validation_result)
-        
+
         return validation_result
 
     async def _validate_security_component(self, component: CloudOpsSecurityComponent) -> Dict[str, Any]:
         """Validate individual CloudOps-Automation security component."""
-        
+
         validation_result = {
-            'component_name': component.component_name,
-            'valid': False,
-            'enterprise_ready': False,
-            'issues': [],
-            'recommendations': []
+            "component_name": component.component_name,
+            "valid": False,
+            "enterprise_ready": False,
+            "issues": [],
+            "recommendations": [],
         }
-        
+
         try:
             component_path = Path(component.component_path)
-            
+
             # Check if component files exist
             if not component_path.exists():
-                validation_result['issues'].append("Component path not found")
+                validation_result["issues"].append("Component path not found")
                 return validation_result
-            
+
             # Look for Python implementation file
             py_files = list(component_path.glob("*.py"))
             if not py_files:
-                validation_result['issues'].append("No Python implementation found")
+                validation_result["issues"].append("No Python implementation found")
                 return validation_result
-            
+
             # Basic validation - component has implementation
-            validation_result['valid'] = True
-            
+            validation_result["valid"] = True
+
             # Check for enterprise readiness indicators
             main_py_file = py_files[0]
             if main_py_file.exists():
-                with open(main_py_file, 'r', encoding='utf-8', errors='ignore') as f:
+                with open(main_py_file, "r", encoding="utf-8", errors="ignore") as f:
                     content = f.read()
-                    
+
                     # Enterprise readiness checks
                     enterprise_indicators = [
-                        'BaseModel',  # Pydantic validation
-                        'ClientError',  # AWS error handling
-                        'def ',  # Function definitions
-                        'try:',  # Error handling
+                        "BaseModel",  # Pydantic validation
+                        "ClientError",  # AWS error handling
+                        "def ",  # Function definitions
+                        "try:",  # Error handling
                     ]
-                    
+
                     indicators_found = sum(1 for indicator in enterprise_indicators if indicator in content)
-                    
+
                     if indicators_found >= 3:  # Most enterprise indicators present
-                        validation_result['enterprise_ready'] = True
+                        validation_result["enterprise_ready"] = True
                         component.security_level = CloudOpsSecurityLevel.ENTERPRISE_READY
-                    
+
                     # Check for security best practices
-                    if 'ClientError' in content and 'try:' in content:
-                        validation_result['recommendations'].append(
+                    if "ClientError" in content and "try:" in content:
+                        validation_result["recommendations"].append(
                             "Component has good error handling - suitable for runbooks integration"
                         )
-                    
-                    if 'BaseModel' in content:
-                        validation_result['recommendations'].append(
+
+                    if "BaseModel" in content:
+                        validation_result["recommendations"].append(
                             "Component uses Pydantic validation - aligns with runbooks v2 patterns"
                         )
-            
+
             component.validation_status = "validated"
             component.validation_results = validation_result
-            
+
         except Exception as e:
-            validation_result['issues'].append(f"Validation error: {str(e)}")
-        
+            validation_result["issues"].append(f"Validation error: {str(e)}")
+
         return validation_result
 
     async def _validate_account_real_time_security(self, account_id: str) -> Dict[str, Any]:
         """Validate real-time security state for account via MCP integration."""
-        
+
         print_info(f"Real-time security validation for account: {account_id}")
-        
+
         validation_result = {
-            'account_id': account_id,
-            'success': False,
-            'critical_findings': [],
-            'security_checks': [],
-            'mcp_integration_status': 'pending'
+            "account_id": account_id,
+            "success": False,
+            "critical_findings": [],
+            "security_checks": [],
+            "mcp_integration_status": "pending",
         }
-        
+
         try:
             # Use real-time validator
             security_state = await self.real_time_validator.validate_account_security(account_id)
-            
+
             if security_state:
-                validation_result['success'] = True
-                validation_result['security_checks'] = security_state.get('checks', [])
-                validation_result['critical_findings'] = security_state.get('critical_findings', [])
-                validation_result['mcp_integration_status'] = 'success'
-            
+                validation_result["success"] = True
+                validation_result["security_checks"] = security_state.get("checks", [])
+                validation_result["critical_findings"] = security_state.get("critical_findings", [])
+                validation_result["mcp_integration_status"] = "success"
+
         except Exception as e:
-            validation_result['critical_findings'].append({
-                'finding_type': 'validation_error',
-                'severity': 'HIGH',
-                'message': f"Real-time validation failed: {str(e)}",
-                'account_id': account_id
-            })
-        
+            validation_result["critical_findings"].append(
+                {
+                    "finding_type": "validation_error",
+                    "severity": "HIGH",
+                    "message": f"Real-time validation failed: {str(e)}",
+                    "account_id": account_id,
+                }
+            )
+
         return validation_result
 
     async def _discover_organization_accounts(self) -> List[str]:
         """Discover AWS Organization accounts for multi-account validation."""
-        
+
         accounts = []
-        
+
         try:
-            organizations = self.session.client('organizations')
-            
+            organizations = self.session.client("organizations")
+
             # List organization accounts
-            paginator = organizations.get_paginator('list_accounts')
-            
+            paginator = organizations.get_paginator("list_accounts")
+
             for page in paginator.paginate():
-                for account in page.get('Accounts', []):
-                    if account['Status'] == 'ACTIVE':
-                        accounts.append(account['Id'])
-            
+                for account in page.get("Accounts", []):
+                    if account["Status"] == "ACTIVE":
+                        accounts.append(account["Id"])
+
             print_success(f"Discovered {len(accounts)} active organization accounts")
-            
+
         except ClientError as e:
             print_warning(f"Could not discover organization accounts: {str(e)}")
             # Fallback to current account
-            sts = self.session.client('sts')
-            current_account = sts.get_caller_identity()['Account']
+            sts = self.session.client("sts")
+            current_account = sts.get_caller_identity()["Account"]
             accounts = [current_account]
             print_info(f"Using current account for validation: {current_account}")
-        
+
         return accounts
 
     def _calculate_security_posture_score(
-        self, 
-        validation_results: Dict[str, Any], 
-        target_accounts: List[str]
+        self, validation_results: Dict[str, Any], target_accounts: List[str]
     ) -> float:
         """Calculate overall security posture score."""
-        
+
         # Base score from component validation
         component_score = 0.0
         if len(self.security_components) > 0:
-            component_score = (validation_results['battle_tested_validated'] / len(self.security_components)) * 50
-        
+            component_score = (validation_results["battle_tested_validated"] / len(self.security_components)) * 50
+
         # Real-time validation score
         real_time_score = 0.0
         if len(target_accounts) > 0:
-            real_time_score = (validation_results['real_time_validated'] / len(target_accounts)) * 30
-        
+            real_time_score = (validation_results["real_time_validated"] / len(target_accounts)) * 30
+
         # Enterprise readiness score
         enterprise_score = 0.0
-        if validation_results['battle_tested_validated'] > 0:
-            enterprise_score = (validation_results['enterprise_ready_validated'] / validation_results['battle_tested_validated']) * 20
-        
+        if validation_results["battle_tested_validated"] > 0:
+            enterprise_score = (
+                validation_results["enterprise_ready_validated"] / validation_results["battle_tested_validated"]
+            ) * 20
+
         total_score = component_score + real_time_score + enterprise_score
-        
+
         return min(100.0, total_score)
 
     def _generate_integration_roadmap(
-        self, 
-        integration_candidates: List[CloudOpsSecurityComponent]
+        self, integration_candidates: List[CloudOpsSecurityComponent]
     ) -> List[Dict[str, Any]]:
         """Generate integration roadmap for high-priority components."""
-        
+
         roadmap = []
-        
+
         # Sort by integration priority
         sorted_candidates = sorted(integration_candidates, key=lambda x: x.integration_priority, reverse=True)
-        
+
         for i, component in enumerate(sorted_candidates[:10]):  # Top 10 candidates
             roadmap_item = {
-                'phase': f"Phase {(i // 3) + 1}",  # Group into phases
-                'priority': component.integration_priority,
-                'component_name': component.component_name,
-                'category': component.validation_category.value,
-                'aws_services': component.aws_services,
-                'compliance_frameworks': component.compliance_frameworks,
-                'integration_effort': self._estimate_integration_effort(component),
-                'business_value': self._estimate_business_value(component),
-                'recommended_timeline': f"{(i // 3) * 2 + 2}-{(i // 3) * 2 + 4} weeks"
+                "phase": f"Phase {(i // 3) + 1}",  # Group into phases
+                "priority": component.integration_priority,
+                "component_name": component.component_name,
+                "category": component.validation_category.value,
+                "aws_services": component.aws_services,
+                "compliance_frameworks": component.compliance_frameworks,
+                "integration_effort": self._estimate_integration_effort(component),
+                "business_value": self._estimate_business_value(component),
+                "recommended_timeline": f"{(i // 3) * 2 + 2}-{(i // 3) * 2 + 4} weeks",
             }
             roadmap.append(roadmap_item)
-        
+
         return roadmap
 
     def _estimate_integration_effort(self, component: CloudOpsSecurityComponent) -> str:
         """Estimate integration effort for component."""
-        
+
         if component.integration_priority >= 8:
             return "LOW"  # High priority usually means straightforward integration
         elif component.integration_priority >= 6:
@@ -612,100 +604,95 @@ class CloudOpsAutomationSecurityValidator:
 
     def _estimate_business_value(self, component: CloudOpsSecurityComponent) -> str:
         """Estimate business value of component integration."""
-        
-        high_value_categories = [
-            ValidationCategory.IAM_SECURITY,
-            ValidationCategory.ENCRYPTION_COMPLIANCE
-        ]
-        
+
+        high_value_categories = [ValidationCategory.IAM_SECURITY, ValidationCategory.ENCRYPTION_COMPLIANCE]
+
         if component.validation_category in high_value_categories:
             return "HIGH"
         elif len(component.compliance_frameworks) >= 3:
-            return "HIGH" 
+            return "HIGH"
         else:
             return "MEDIUM"
 
     def _generate_security_recommendations(
-        self, 
-        validation_results: Dict[str, Any], 
-        target_accounts: List[str]
+        self, validation_results: Dict[str, Any], target_accounts: List[str]
     ) -> List[str]:
         """Generate security recommendations based on validation results."""
-        
+
         recommendations = []
-        
+
         # Component integration recommendations
-        if validation_results['enterprise_ready_validated'] > 0:
+        if validation_results["enterprise_ready_validated"] > 0:
             recommendations.append(
                 f"Integrate {validation_results['enterprise_ready_validated']} enterprise-ready "
                 "CloudOps-Automation components into runbooks security module"
             )
-        
+
         # Real-time validation recommendations
-        if validation_results['real_time_validated'] < len(target_accounts):
-            recommendations.append(
-                "Implement MCP-based real-time security monitoring for all organization accounts"
-            )
-        
+        if validation_results["real_time_validated"] < len(target_accounts):
+            recommendations.append("Implement MCP-based real-time security monitoring for all organization accounts")
+
         # Critical findings recommendations
-        if validation_results['critical_findings']:
+        if validation_results["critical_findings"]:
             recommendations.append(
                 f"Address {len(validation_results['critical_findings'])} critical security findings "
                 "identified during validation"
             )
-        
+
         # Compliance recommendations
-        recommendations.extend([
-            "Establish continuous security validation pipeline using CloudOps-Automation patterns",
-            "Implement automated security remediation workflows with approval gates",
-            "Deploy security-as-code patterns across all organization accounts",
-            "Integrate security validation with existing DORA metrics and FAANG SDLC processes"
-        ])
-        
+        recommendations.extend(
+            [
+                "Establish continuous security validation pipeline using CloudOps-Automation patterns",
+                "Implement automated security remediation workflows with approval gates",
+                "Deploy security-as-code patterns across all organization accounts",
+                "Integrate security validation with existing DORA metrics and FAANG SDLC processes",
+            ]
+        )
+
         return recommendations
 
     async def _export_validation_results(self, validation_result: MultiAccountSecurityValidation):
         """Export comprehensive validation results."""
-        
+
         # Export JSON report
         json_report_path = self.output_dir / f"security_validation_{validation_result.validation_id}.json"
-        
+
         report_data = {
-            'validation_id': validation_result.validation_id,
-            'timestamp': validation_result.timestamp.isoformat(),
-            'summary': {
-                'accounts_validated': validation_result.accounts_validated,
-                'components_assessed': validation_result.components_assessed,
-                'battle_tested_components': validation_result.battle_tested_components,
-                'enterprise_ready_components': validation_result.enterprise_ready_components,
-                'compliance_score': validation_result.compliance_score,
-                'security_posture_score': validation_result.security_posture_score
+            "validation_id": validation_result.validation_id,
+            "timestamp": validation_result.timestamp.isoformat(),
+            "summary": {
+                "accounts_validated": validation_result.accounts_validated,
+                "components_assessed": validation_result.components_assessed,
+                "battle_tested_components": validation_result.battle_tested_components,
+                "enterprise_ready_components": validation_result.enterprise_ready_components,
+                "compliance_score": validation_result.compliance_score,
+                "security_posture_score": validation_result.security_posture_score,
             },
-            'critical_findings': validation_result.critical_findings,
-            'recommendations': validation_result.recommendations,
-            'integration_roadmap': validation_result.integration_roadmap,
-            'component_details': [
+            "critical_findings": validation_result.critical_findings,
+            "recommendations": validation_result.recommendations,
+            "integration_roadmap": validation_result.integration_roadmap,
+            "component_details": [
                 {
-                    'name': comp.component_name,
-                    'category': comp.validation_category.value,
-                    'security_level': comp.security_level.value,
-                    'priority': comp.integration_priority,
-                    'aws_services': comp.aws_services,
-                    'compliance_frameworks': comp.compliance_frameworks,
-                    'validation_status': comp.validation_status
+                    "name": comp.component_name,
+                    "category": comp.validation_category.value,
+                    "security_level": comp.security_level.value,
+                    "priority": comp.integration_priority,
+                    "aws_services": comp.aws_services,
+                    "compliance_frameworks": comp.compliance_frameworks,
+                    "validation_status": comp.validation_status,
                 }
                 for comp in self.security_components
-            ]
+            ],
         }
-        
-        with open(json_report_path, 'w') as f:
+
+        with open(json_report_path, "w") as f:
             json.dump(report_data, f, indent=2)
-        
+
         print_success(f"Validation results exported to: {json_report_path}")
 
     def _display_validation_summary(self, validation_result: MultiAccountSecurityValidation):
         """Display comprehensive validation summary with Rich formatting."""
-        
+
         # Summary panel
         summary_content = (
             f"[bold green]Validation ID:[/bold green] {validation_result.validation_id}\n"
@@ -716,13 +703,13 @@ class CloudOpsAutomationSecurityValidator:
             f"[bold cyan]Compliance Score:[/bold cyan] {validation_result.compliance_score:.1f}%\n"
             f"[bold magenta]Security Posture Score:[/bold magenta] {validation_result.security_posture_score:.1f}%"
         )
-        
-        console.print(create_panel(
-            summary_content,
-            title="🔒 CloudOps-Automation Security Validation Summary",
-            border_style="green"
-        ))
-        
+
+        console.print(
+            create_panel(
+                summary_content, title="🔒 CloudOps-Automation Security Validation Summary", border_style="green"
+            )
+        )
+
         # Critical findings table
         if validation_result.critical_findings:
             findings_table = create_table(
@@ -731,20 +718,22 @@ class CloudOpsAutomationSecurityValidator:
                     {"name": "Account", "style": "red"},
                     {"name": "Finding Type", "style": "yellow"},
                     {"name": "Severity", "style": "red"},
-                    {"name": "Message", "style": "white"}
-                ]
+                    {"name": "Message", "style": "white"},
+                ],
             )
-            
+
             for finding in validation_result.critical_findings[:10]:  # Show top 10
                 findings_table.add_row(
-                    finding.get('account_id', 'Unknown'),
-                    finding.get('finding_type', 'Unknown'),
-                    finding.get('severity', 'Unknown'),
-                    finding.get('message', 'Unknown')[:80] + "..." if len(finding.get('message', '')) > 80 else finding.get('message', '')
+                    finding.get("account_id", "Unknown"),
+                    finding.get("finding_type", "Unknown"),
+                    finding.get("severity", "Unknown"),
+                    finding.get("message", "Unknown")[:80] + "..."
+                    if len(finding.get("message", "")) > 80
+                    else finding.get("message", ""),
                 )
-            
+
             console.print(findings_table)
-        
+
         # Integration roadmap table
         if validation_result.integration_roadmap:
             roadmap_table = create_table(
@@ -755,22 +744,22 @@ class CloudOpsAutomationSecurityValidator:
                     {"name": "Category", "style": "yellow"},
                     {"name": "Priority", "style": "red"},
                     {"name": "Business Value", "style": "magenta"},
-                    {"name": "Timeline", "style": "blue"}
-                ]
+                    {"name": "Timeline", "style": "blue"},
+                ],
             )
-            
+
             for item in validation_result.integration_roadmap:
                 roadmap_table.add_row(
-                    item['phase'],
-                    item['component_name'][:30] + "..." if len(item['component_name']) > 30 else item['component_name'],
-                    item['category'],
-                    str(item['priority']),
-                    item['business_value'],
-                    item['recommended_timeline']
+                    item["phase"],
+                    item["component_name"][:30] + "..." if len(item["component_name"]) > 30 else item["component_name"],
+                    item["category"],
+                    str(item["priority"]),
+                    item["business_value"],
+                    item["recommended_timeline"],
                 )
-            
+
             console.print(roadmap_table)
-        
+
         # Recommendations
         if validation_result.recommendations:
             print_header("Security Recommendations", "")
@@ -780,385 +769,370 @@ class CloudOpsAutomationSecurityValidator:
 
 class RealTimeSecurityValidator:
     """Real-time AWS security state validation via MCP integration."""
-    
+
     def __init__(self, session: boto3.Session):
         self.session = session
-        
+
     async def validate_account_security(self, account_id: str) -> Dict[str, Any]:
         """Validate real-time security state for account."""
-        
+
         security_checks = []
         critical_findings = []
-        
+
         try:
             # Assume cross-account role if needed
-            if account_id != self.session.client('sts').get_caller_identity()['Account']:
+            if account_id != self.session.client("sts").get_caller_identity()["Account"]:
                 # For now, use current session - cross-account role assumption would be implemented here
                 pass
-            
+
             # Real-time security validations
-            
+
             # 1. IAM security validation
             iam_results = await self._validate_iam_security()
-            security_checks.extend(iam_results['checks'])
-            critical_findings.extend(iam_results['critical_findings'])
-            
+            security_checks.extend(iam_results["checks"])
+            critical_findings.extend(iam_results["critical_findings"])
+
             # 2. S3 encryption validation
             s3_results = await self._validate_s3_encryption()
-            security_checks.extend(s3_results['checks'])
-            critical_findings.extend(s3_results['critical_findings'])
-            
+            security_checks.extend(s3_results["checks"])
+            critical_findings.extend(s3_results["critical_findings"])
+
             # 3. Network security validation
             network_results = await self._validate_network_security()
-            security_checks.extend(network_results['checks'])
-            critical_findings.extend(network_results['critical_findings'])
-            
+            security_checks.extend(network_results["checks"])
+            critical_findings.extend(network_results["critical_findings"])
+
         except Exception as e:
-            critical_findings.append({
-                'finding_type': 'real_time_validation_error',
-                'severity': 'HIGH',
-                'message': f"Real-time validation failed: {str(e)}",
-                'account_id': account_id
-            })
-        
+            critical_findings.append(
+                {
+                    "finding_type": "real_time_validation_error",
+                    "severity": "HIGH",
+                    "message": f"Real-time validation failed: {str(e)}",
+                    "account_id": account_id,
+                }
+            )
+
         return {
-            'account_id': account_id,
-            'checks': security_checks,
-            'critical_findings': critical_findings,
-            'validation_timestamp': datetime.utcnow().isoformat()
+            "account_id": account_id,
+            "checks": security_checks,
+            "critical_findings": critical_findings,
+            "validation_timestamp": datetime.utcnow().isoformat(),
         }
-    
+
     async def _validate_iam_security(self) -> Dict[str, Any]:
         """Validate IAM security configuration."""
-        
+
         checks = []
         critical_findings = []
-        
+
         try:
-            iam = self.session.client('iam')
-            
+            iam = self.session.client("iam")
+
             # Check for root access keys
             try:
-                account_summary = iam.get_account_summary()['SummaryMap']
-                if account_summary.get('AccountAccessKeysPresent', 0) > 0:
-                    critical_findings.append({
-                        'finding_type': 'root_access_keys',
-                        'severity': 'CRITICAL',
-                        'message': 'Root account has active access keys',
-                        'remediation': 'Delete root access keys and enable MFA'
-                    })
-                
-                checks.append({
-                    'check_type': 'root_access_keys',
-                    'status': 'fail' if account_summary.get('AccountAccessKeysPresent', 0) > 0 else 'pass'
-                })
-                
+                account_summary = iam.get_account_summary()["SummaryMap"]
+                if account_summary.get("AccountAccessKeysPresent", 0) > 0:
+                    critical_findings.append(
+                        {
+                            "finding_type": "root_access_keys",
+                            "severity": "CRITICAL",
+                            "message": "Root account has active access keys",
+                            "remediation": "Delete root access keys and enable MFA",
+                        }
+                    )
+
+                checks.append(
+                    {
+                        "check_type": "root_access_keys",
+                        "status": "fail" if account_summary.get("AccountAccessKeysPresent", 0) > 0 else "pass",
+                    }
+                )
+
             except ClientError:
                 pass  # May not have permissions
-        
+
         except ClientError as e:
-            critical_findings.append({
-                'finding_type': 'iam_validation_error',
-                'severity': 'HIGH',
-                'message': f"IAM validation failed: {str(e)}"
-            })
-        
-        return {'checks': checks, 'critical_findings': critical_findings}
-    
+            critical_findings.append(
+                {
+                    "finding_type": "iam_validation_error",
+                    "severity": "HIGH",
+                    "message": f"IAM validation failed: {str(e)}",
+                }
+            )
+
+        return {"checks": checks, "critical_findings": critical_findings}
+
     async def _validate_s3_encryption(self) -> Dict[str, Any]:
         """Validate S3 encryption compliance."""
-        
+
         checks = []
         critical_findings = []
-        
+
         try:
-            s3 = self.session.client('s3')
-            
+            s3 = self.session.client("s3")
+
             # List buckets and check encryption
             response = s3.list_buckets()
-            
-            for bucket in response.get('Buckets', []):
-                bucket_name = bucket['Name']
-                
+
+            for bucket in response.get("Buckets", []):
+                bucket_name = bucket["Name"]
+
                 try:
                     # Check bucket encryption
                     s3.get_bucket_encryption(Bucket=bucket_name)
-                    
-                    checks.append({
-                        'check_type': 's3_encryption',
-                        'resource': bucket_name,
-                        'status': 'pass'
-                    })
-                    
+
+                    checks.append({"check_type": "s3_encryption", "resource": bucket_name, "status": "pass"})
+
                 except ClientError as e:
-                    if e.response['Error']['Code'] == 'ServerSideEncryptionConfigurationNotFoundError':
-                        critical_findings.append({
-                            'finding_type': 's3_unencrypted',
-                            'severity': 'HIGH',
-                            'message': f'S3 bucket {bucket_name} is not encrypted',
-                            'resource': bucket_name,
-                            'remediation': f'Enable encryption on bucket {bucket_name}'
-                        })
-                        
-                        checks.append({
-                            'check_type': 's3_encryption',
-                            'resource': bucket_name,
-                            'status': 'fail'
-                        })
-        
+                    if e.response["Error"]["Code"] == "ServerSideEncryptionConfigurationNotFoundError":
+                        critical_findings.append(
+                            {
+                                "finding_type": "s3_unencrypted",
+                                "severity": "HIGH",
+                                "message": f"S3 bucket {bucket_name} is not encrypted",
+                                "resource": bucket_name,
+                                "remediation": f"Enable encryption on bucket {bucket_name}",
+                            }
+                        )
+
+                        checks.append({"check_type": "s3_encryption", "resource": bucket_name, "status": "fail"})
+
         except ClientError as e:
-            critical_findings.append({
-                'finding_type': 's3_validation_error',
-                'severity': 'HIGH',
-                'message': f"S3 validation failed: {str(e)}"
-            })
-        
-        return {'checks': checks, 'critical_findings': critical_findings}
-    
+            critical_findings.append(
+                {
+                    "finding_type": "s3_validation_error",
+                    "severity": "HIGH",
+                    "message": f"S3 validation failed: {str(e)}",
+                }
+            )
+
+        return {"checks": checks, "critical_findings": critical_findings}
+
     async def _validate_network_security(self) -> Dict[str, Any]:
         """Validate network security configuration."""
-        
+
         checks = []
         critical_findings = []
-        
+
         try:
-            ec2 = self.session.client('ec2')
-            
+            ec2 = self.session.client("ec2")
+
             # Check security groups for open access
-            security_groups = ec2.describe_security_groups()['SecurityGroups']
-            
+            security_groups = ec2.describe_security_groups()["SecurityGroups"]
+
             for sg in security_groups:
-                sg_id = sg['GroupId']
-                
+                sg_id = sg["GroupId"]
+
                 # Check for overly permissive rules
-                for rule in sg.get('IpPermissions', []):
-                    for ip_range in rule.get('IpRanges', []):
-                        if ip_range.get('CidrIp') == '0.0.0.0/0':
-                            
+                for rule in sg.get("IpPermissions", []):
+                    for ip_range in rule.get("IpRanges", []):
+                        if ip_range.get("CidrIp") == "0.0.0.0/0":
                             # Determine severity based on port
-                            port = rule.get('FromPort', 'unknown')
-                            severity = 'CRITICAL' if port in [22, 3389, 80, 443] else 'HIGH'
-                            
-                            critical_findings.append({
-                                'finding_type': 'open_security_group',
-                                'severity': severity,
-                                'message': f'Security group {sg_id} allows unrestricted access on port {port}',
-                                'resource': sg_id,
-                                'remediation': f'Restrict access in security group {sg_id}'
-                            })
-                            
-                            checks.append({
-                                'check_type': 'security_group_rules',
-                                'resource': sg_id,
-                                'status': 'fail'
-                            })
+                            port = rule.get("FromPort", "unknown")
+                            severity = "CRITICAL" if port in [22, 3389, 80, 443] else "HIGH"
+
+                            critical_findings.append(
+                                {
+                                    "finding_type": "open_security_group",
+                                    "severity": severity,
+                                    "message": f"Security group {sg_id} allows unrestricted access on port {port}",
+                                    "resource": sg_id,
+                                    "remediation": f"Restrict access in security group {sg_id}",
+                                }
+                            )
+
+                            checks.append({"check_type": "security_group_rules", "resource": sg_id, "status": "fail"})
                             break
                 else:
-                    checks.append({
-                        'check_type': 'security_group_rules',
-                        'resource': sg_id,
-                        'status': 'pass'
-                    })
-        
+                    checks.append({"check_type": "security_group_rules", "resource": sg_id, "status": "pass"})
+
         except ClientError as e:
-            critical_findings.append({
-                'finding_type': 'network_validation_error',
-                'severity': 'HIGH',
-                'message': f"Network validation failed: {str(e)}"
-            })
-        
-        return {'checks': checks, 'critical_findings': critical_findings}
+            critical_findings.append(
+                {
+                    "finding_type": "network_validation_error",
+                    "severity": "HIGH",
+                    "message": f"Network validation failed: {str(e)}",
+                }
+            )
+
+        return {"checks": checks, "critical_findings": critical_findings}
 
 
 class MCPSecurityIntegration:
     """MCP integration for real-time security monitoring."""
-    
+
     def __init__(self):
         self.mcp_endpoints = self._initialize_mcp_endpoints()
-    
+
     def _initialize_mcp_endpoints(self) -> Dict[str, str]:
         """Initialize MCP endpoints for security monitoring."""
-        
+
         return {
-            'cost_explorer': 'mcp://aws/cost-explorer',
-            'organizations': 'mcp://aws/organizations',
-            'security_hub': 'mcp://aws/security-hub',
-            'config': 'mcp://aws/config',
-            'cloudtrail': 'mcp://aws/cloudtrail'
+            "cost_explorer": "mcp://aws/cost-explorer",
+            "organizations": "mcp://aws/organizations",
+            "security_hub": "mcp://aws/security-hub",
+            "config": "mcp://aws/config",
+            "cloudtrail": "mcp://aws/cloudtrail",
         }
-    
+
     async def validate_security_via_mcp(self, account_id: str) -> Dict[str, Any]:
         """Validate security state via MCP integration."""
-        
+
         # Placeholder for MCP integration
         # This would integrate with actual MCP servers for real-time data
-        
+
         return {
-            'account_id': account_id,
-            'mcp_status': 'available',
-            'security_score': 85.0,
-            'last_updated': datetime.utcnow().isoformat()
+            "account_id": account_id,
+            "mcp_status": "available",
+            "security_score": 85.0,
+            "last_updated": datetime.utcnow().isoformat(),
         }
 
 
 class MultiAccountSecurityController:
     """Multi-account security controls for 61-account operations."""
-    
+
     def __init__(self, session: boto3.Session):
         self.session = session
-        
+
     async def apply_security_controls(self, account_ids: List[str]) -> Dict[str, Any]:
         """Apply security controls across multiple accounts."""
-        
-        results = {
-            'accounts_processed': 0,
-            'controls_applied': 0,
-            'failures': []
-        }
-        
+
+        results = {"accounts_processed": 0, "controls_applied": 0, "failures": []}
+
         for account_id in account_ids:
             try:
                 # Apply security controls to account
                 account_result = await self._apply_account_security_controls(account_id)
-                
-                if account_result['success']:
-                    results['accounts_processed'] += 1
-                    results['controls_applied'] += account_result['controls_applied']
+
+                if account_result["success"]:
+                    results["accounts_processed"] += 1
+                    results["controls_applied"] += account_result["controls_applied"]
                 else:
-                    results['failures'].append({
-                        'account_id': account_id,
-                        'error': account_result['error']
-                    })
-                    
+                    results["failures"].append({"account_id": account_id, "error": account_result["error"]})
+
             except Exception as e:
-                results['failures'].append({
-                    'account_id': account_id,
-                    'error': str(e)
-                })
-        
+                results["failures"].append({"account_id": account_id, "error": str(e)})
+
         return results
-    
+
     async def _apply_account_security_controls(self, account_id: str) -> Dict[str, Any]:
         """Apply security controls to individual account."""
-        
+
         # Placeholder for multi-account security control implementation
         # This would implement cross-account role assumption and security policy enforcement
-        
+
         return {
-            'account_id': account_id,
-            'success': True,
-            'controls_applied': 5,  # Example: 5 security controls applied
-            'error': None
+            "account_id": account_id,
+            "success": True,
+            "controls_applied": 5,  # Example: 5 security controls applied
+            "error": None,
         }
 
 
 class ComplianceFrameworkEngine:
     """Compliance framework validation engine."""
-    
+
     def __init__(self):
         self.frameworks = {
-            'SOC2': self._soc2_requirements,
-            'PCI-DSS': self._pci_dss_requirements,
-            'HIPAA': self._hipaa_requirements,
-            'AWS_Well_Architected': self._aws_wa_requirements,
-            'CIS_Benchmarks': self._cis_requirements
+            "SOC2": self._soc2_requirements,
+            "PCI-DSS": self._pci_dss_requirements,
+            "HIPAA": self._hipaa_requirements,
+            "AWS_Well_Architected": self._aws_wa_requirements,
+            "CIS_Benchmarks": self._cis_requirements,
         }
-    
+
     def _soc2_requirements(self) -> List[str]:
         """SOC2 compliance requirements."""
         return [
-            'Encryption at rest for sensitive data',
-            'Access controls and authentication',
-            'Audit logging and monitoring',
-            'Incident response procedures',
-            'Change management controls'
+            "Encryption at rest for sensitive data",
+            "Access controls and authentication",
+            "Audit logging and monitoring",
+            "Incident response procedures",
+            "Change management controls",
         ]
-    
+
     def _pci_dss_requirements(self) -> List[str]:
         """PCI-DSS compliance requirements."""
         return [
-            'Cardholder data encryption',
-            'Network security controls',
-            'Strong authentication mechanisms',
-            'Regular security testing',
-            'Information security policy'
+            "Cardholder data encryption",
+            "Network security controls",
+            "Strong authentication mechanisms",
+            "Regular security testing",
+            "Information security policy",
         ]
-    
+
     def _hipaa_requirements(self) -> List[str]:
         """HIPAA compliance requirements."""
         return [
-            'PHI encryption and access controls',
-            'Audit trails for PHI access',
-            'Risk assessment and management',
-            'Security incident response',
-            'Business associate agreements'
+            "PHI encryption and access controls",
+            "Audit trails for PHI access",
+            "Risk assessment and management",
+            "Security incident response",
+            "Business associate agreements",
         ]
-    
+
     def _aws_wa_requirements(self) -> List[str]:
         """AWS Well-Architected security pillar requirements."""
         return [
-            'Identity and access management',
-            'Detective controls',
-            'Infrastructure protection',
-            'Data protection',
-            'Incident response capability'
+            "Identity and access management",
+            "Detective controls",
+            "Infrastructure protection",
+            "Data protection",
+            "Incident response capability",
         ]
-    
+
     def _cis_requirements(self) -> List[str]:
         """CIS Benchmarks requirements."""
         return [
-            'Account security configuration',
-            'Network security controls',
-            'Identity and access management',
-            'Data protection controls',
-            'Monitoring and logging'
+            "Account security configuration",
+            "Network security controls",
+            "Identity and access management",
+            "Data protection controls",
+            "Monitoring and logging",
         ]
-    
+
     def validate_compliance(self, framework: str, validation_results: Dict[str, Any]) -> Dict[str, Any]:
         """Validate compliance against specific framework."""
-        
+
         if framework not in self.frameworks:
-            return {'error': f'Framework {framework} not supported'}
-        
+            return {"error": f"Framework {framework} not supported"}
+
         requirements = self.frameworks[framework]()
-        
-        compliance_score = len(validation_results.get('passed_checks', [])) / len(requirements) * 100
-        
+
+        compliance_score = len(validation_results.get("passed_checks", [])) / len(requirements) * 100
+
         return {
-            'framework': framework,
-            'compliance_score': compliance_score,
-            'requirements': requirements,
-            'passed_checks': validation_results.get('passed_checks', []),
-            'failed_checks': validation_results.get('failed_checks', [])
+            "framework": framework,
+            "compliance_score": compliance_score,
+            "requirements": requirements,
+            "passed_checks": validation_results.get("passed_checks", []),
+            "failed_checks": validation_results.get("failed_checks", []),
         }
 
 
 # CLI integration for enterprise security validation
 if __name__ == "__main__":
     import argparse
-    
-    parser = argparse.ArgumentParser(description='CloudOps-Automation Security Validator')
-    parser.add_argument('--profile', default='default', help='AWS profile to use')
-    parser.add_argument('--accounts', nargs='+', help='Target account IDs (optional)')
-    parser.add_argument('--real-time', action='store_true', help='Include real-time validation')
-    parser.add_argument('--output-dir', default='./artifacts/cloudops-security', help='Output directory')
-    
+
+    parser = argparse.ArgumentParser(description="CloudOps-Automation Security Validator")
+    parser.add_argument("--profile", default="default", help="AWS profile to use")
+    parser.add_argument("--accounts", nargs="+", help="Target account IDs (optional)")
+    parser.add_argument("--real-time", action="store_true", help="Include real-time validation")
+    parser.add_argument("--output-dir", default="./artifacts/cloudops-security", help="Output directory")
+
     args = parser.parse_args()
-    
+
     async def main():
-        validator = CloudOpsAutomationSecurityValidator(
-            profile=args.profile,
-            output_dir=args.output_dir
-        )
-        
+        validator = CloudOpsAutomationSecurityValidator(profile=args.profile, output_dir=args.output_dir)
+
         result = await validator.comprehensive_security_validation(
-            target_accounts=args.accounts,
-            include_real_time_validation=args.real_time
+            target_accounts=args.accounts, include_real_time_validation=args.real_time
         )
-        
+
         print_success(f"Security validation completed: {result.validation_id}")
         print_info(f"Compliance score: {result.compliance_score:.1f}%")
         print_info(f"Security posture score: {result.security_posture_score:.1f}%")
-    
+
     # Run the async main function
-    asyncio.run(main())
+    asyncio.run(main())