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

runbooks/inventory/unified_validation_engine.py

@@ -59,12 +59,12 @@ from .core.collector import InventoryCollector
 class UnifiedValidationEngine:
     """
     Enterprise Unified Validation Engine for 3-way AWS resource validation.
-    
+
     Integrates all validation sources into a single workflow:
     - runbooks APIs (inventory collection methods)
     - MCP servers (real server integration from .mcp.json)
     - Terraform drift detection (Infrastructure as Code alignment)
-    
+
     Provides comprehensive accuracy validation ≥99.5% with enterprise reporting.
     """
 
@@ -79,7 +79,7 @@ class UnifiedValidationEngine:
     ):
         """
         Initialize unified validation engine with enterprise configuration.
-        
+
         Args:
             user_profile: User-specified profile (--profile parameter) - takes priority
             console: Rich console for output
@@ -92,10 +92,10 @@ class UnifiedValidationEngine:
         self.console = console or rich_console
         self.validation_threshold = validation_threshold
         self.performance_target = performance_target_seconds
-        
+
         # Enterprise profile management
         self.enterprise_profiles = self._resolve_enterprise_profiles()
-        
+
         # Validation components
         self.mcp_validator = EnhancedMCPValidator(
             user_profile=user_profile,
@@ -103,31 +103,31 @@ class UnifiedValidationEngine:
             mcp_config_path=mcp_config_path,
             terraform_directory=terraform_directory,
         )
-        
+
         # Initialize inventory collector for runbooks API validation
         self.inventory_collector = InventoryCollector(
             profile=self.enterprise_profiles["operational"],
-            region="us-east-1"  # Default region for global services
+            region="us-east-1",  # Default region for global services
         )
-        
+
         # Validation cache for performance optimization
         self.validation_cache = {}
         self.cache_ttl = 300  # 5 minutes
-        
+
         # Supported resource types for unified validation
         self.supported_resources = {
-            'ec2': 'EC2 Instances',
-            's3': 'S3 Buckets',
-            'rds': 'RDS Instances',
-            'lambda': 'Lambda Functions',
-            'vpc': 'VPCs',
-            'iam': 'IAM Roles',
-            'cloudformation': 'CloudFormation Stacks',
-            'elbv2': 'Load Balancers',
-            'route53': 'Route53 Hosted Zones',
-            'sns': 'SNS Topics',
-            'eni': 'Network Interfaces',
-            'ebs': 'EBS Volumes',
+            "ec2": "EC2 Instances",
+            "s3": "S3 Buckets",
+            "rds": "RDS Instances",
+            "lambda": "Lambda Functions",
+            "vpc": "VPCs",
+            "iam": "IAM Roles",
+            "cloudformation": "CloudFormation Stacks",
+            "elbv2": "Load Balancers",
+            "route53": "Route53 Hosted Zones",
+            "sns": "SNS Topics",
+            "eni": "Network Interfaces",
+            "ebs": "EBS Volumes",
         }
 
     def _resolve_enterprise_profiles(self) -> Dict[str, str]:
@@ -150,7 +150,7 @@ class UnifiedValidationEngine:
     ) -> Dict[str, Any]:
         """
         Run comprehensive unified validation across all sources.
-        
+
         Args:
             resource_types: List of resource types to validate
             accounts: List of account IDs to analyze
@@ -159,12 +159,12 @@ class UnifiedValidationEngine:
             enable_mcp_servers: Enable MCP server integration
             export_formats: List of export formats ('json', 'csv', 'pdf', 'markdown')
             output_directory: Directory for validation evidence exports
-            
+
         Returns:
             Comprehensive validation results with 3-way cross-validation
         """
         validation_start_time = time.time()
-        
+
         validation_results = {
             "validation_timestamp": datetime.now().isoformat(),
             "validation_method": "unified_3way_cross_validation",
@@ -187,8 +187,10 @@ class UnifiedValidationEngine:
         }
 
         self.console.print(f"[blue]🔍 Starting Unified 3-Way Validation Engine[/blue]")
-        self.console.print(f"[dim]Target: ≥{self.validation_threshold}% accuracy | Performance: <{self.performance_target}s[/dim]")
-        
+        self.console.print(
+            f"[dim]Target: ≥{self.validation_threshold}% accuracy | Performance: <{self.performance_target}s[/dim]"
+        )
+
         # Display validation sources
         sources = []
         if validation_results["validation_sources"]["runbooks_apis"]:
@@ -197,52 +199,46 @@ class UnifiedValidationEngine:
             sources.append("MCP Servers")
         if validation_results["validation_sources"]["terraform_drift"]:
             sources.append("Terraform IaC")
-        
+
         self.console.print(f"[dim cyan]🔗 Validation Sources: {', '.join(sources)}[/]")
 
         try:
             # Step 1: Collect baseline inventory from runbooks APIs
-            runbooks_inventory = await self._collect_runbooks_inventory(
-                resource_types, accounts, regions
-            )
-            
+            runbooks_inventory = await self._collect_runbooks_inventory(resource_types, accounts, regions)
+
             # Step 2: Run 3-way cross-validation
             cross_validation_results = await self._execute_3way_validation(
                 runbooks_inventory, enable_terraform_drift, enable_mcp_servers
             )
-            
+
             # Step 3: Generate comprehensive analysis
-            unified_analysis = self._generate_unified_analysis(
-                runbooks_inventory, cross_validation_results
-            )
-            
+            unified_analysis = self._generate_unified_analysis(runbooks_inventory, cross_validation_results)
+
             # Step 4: Calculate performance metrics
             total_execution_time = time.time() - validation_start_time
             validation_results["performance_metrics"]["total_execution_time"] = total_execution_time
-            validation_results["performance_metrics"]["performance_achieved"] = total_execution_time <= self.performance_target
-            
+            validation_results["performance_metrics"]["performance_achieved"] = (
+                total_execution_time <= self.performance_target
+            )
+
             # Step 5: Populate results
             validation_results.update(unified_analysis)
-            
+
             # Step 6: Generate recommendations
-            validation_results["recommendations"] = self._generate_actionable_recommendations(
-                unified_analysis
-            )
-            
+            validation_results["recommendations"] = self._generate_actionable_recommendations(unified_analysis)
+
             # Step 7: Display results
             self._display_unified_validation_results(validation_results)
-            
+
             # Step 8: Export evidence if requested
             if export_formats:
-                await self._export_validation_evidence(
-                    validation_results, export_formats, output_directory
-                )
-                
+                await self._export_validation_evidence(validation_results, export_formats, output_directory)
+
         except Exception as e:
             print_error(f"Unified validation failed: {str(e)}")
             validation_results["error"] = str(e)
             validation_results["passed_validation"] = False
-            
+
         return validation_results
 
     async def _collect_runbooks_inventory(
@@ -253,11 +249,11 @@ class UnifiedValidationEngine:
     ) -> Dict[str, Any]:
         """Collect baseline inventory using runbooks APIs."""
         self.console.print(f"[yellow]📊 Step 1/3: Collecting runbooks inventory baseline[/yellow]")
-        
+
         try:
             # Use the existing inventory collector
             inventory_results = {}
-            
+
             # Get current account ID
             if not accounts:
                 try:
@@ -267,7 +263,7 @@ class UnifiedValidationEngine:
                     accounts = [current_account]
                 except Exception:
                     accounts = ["unknown"]
-            
+
             for account_id in accounts:
                 account_inventory = {
                     "account_id": account_id,
@@ -276,7 +272,7 @@ class UnifiedValidationEngine:
                     "collection_method": "runbooks_inventory_apis",
                     "timestamp": datetime.now().isoformat(),
                 }
-                
+
                 # Collect actual resource counts using runbooks inventory collector
                 for resource_type in resource_types or list(self.supported_resources.keys()):
                     try:
@@ -286,14 +282,18 @@ class UnifiedValidationEngine:
                         )
                         account_inventory["resource_counts"][resource_type] = resource_count
                     except Exception as e:
-                        self.console.log(f"[yellow]Warning: Failed to collect {resource_type} for account {account_id}: {str(e)[:30]}[/]")
+                        self.console.log(
+                            f"[yellow]Warning: Failed to collect {resource_type} for account {account_id}: {str(e)[:30]}[/]"
+                        )
                         account_inventory["resource_counts"][resource_type] = 0
-                
+
                 inventory_results[account_id] = account_inventory
-            
-            print_info(f"✅ Runbooks inventory collected: {len(accounts)} accounts, {len(resource_types or [])} resource types")
+
+            print_info(
+                f"✅ Runbooks inventory collected: {len(accounts)} accounts, {len(resource_types or [])} resource types"
+            )
             return inventory_results
-            
+
         except Exception as e:
             print_warning(f"Runbooks inventory collection encountered issues: {str(e)[:50]}")
             return {
@@ -310,13 +310,13 @@ class UnifiedValidationEngine:
     ) -> Dict[str, Any]:
         """Execute comprehensive 3-way cross-validation."""
         self.console.print(f"[yellow]🔍 Step 2/3: Executing 3-way cross-validation[/yellow]")
-        
+
         validation_results = {
             "runbooks_validation": runbooks_inventory,
             "mcp_validation": None,
             "terraform_drift_validation": None,
         }
-        
+
         # Execute validations in parallel for performance
         with Progress(
             SpinnerColumn(),
@@ -326,61 +326,57 @@ class UnifiedValidationEngine:
             TimeElapsedColumn(),
             console=self.console,
         ) as progress:
-            
             # Parallel validation tasks
             tasks = []
-            
+
             # MCP Server validation
             if enable_mcp_servers:
                 task_mcp = progress.add_task("MCP server validation...", total=1)
                 tasks.append(("mcp", task_mcp))
-            
+
             # Terraform drift detection
             if enable_terraform_drift:
                 task_tf = progress.add_task("Terraform drift detection...", total=1)
                 tasks.append(("terraform", task_tf))
-            
+
             # Execute validations
             with ThreadPoolExecutor(max_workers=2) as executor:
                 futures = {}
-                
+
                 if enable_mcp_servers:
                     future_mcp = executor.submit(self._run_mcp_validation, runbooks_inventory)
                     futures["mcp"] = future_mcp
-                
+
                 if enable_terraform_drift:
                     future_tf = executor.submit(self._run_terraform_drift_validation, runbooks_inventory)
                     futures["terraform"] = future_tf
-                
+
                 # Collect results
                 for validation_type, future in futures.items():
                     try:
                         result = future.result(timeout=30)  # 30 second timeout per validation
                         validation_results[f"{validation_type}_validation"] = result
-                        
+
                         # Update progress
                         for task_type, task_id in tasks:
                             if task_type == validation_type:
                                 progress.advance(task_id)
                                 break
-                                
+
                     except Exception as e:
                         print_warning(f"{validation_type} validation failed: {str(e)[:40]}")
                         validation_results[f"{validation_type}_validation"] = {
                             "error": str(e),
                             "validation_status": "FAILED",
                         }
-        
+
         print_info("✅ 3-way cross-validation completed")
         return validation_results
 
     def _run_mcp_validation(self, runbooks_inventory: Dict[str, Any]) -> Dict[str, Any]:
         """Run MCP server validation (synchronous wrapper)."""
         try:
-            return validate_inventory_with_mcp_servers(
-                runbooks_inventory,
-                user_profile=self.user_profile
-            )
+            return validate_inventory_with_mcp_servers(runbooks_inventory, user_profile=self.user_profile)
         except Exception as e:
             return {
                 "error": str(e),
@@ -388,7 +384,6 @@ class UnifiedValidationEngine:
                 "timestamp": datetime.now().isoformat(),
             }
 
-
     def _run_terraform_drift_validation(self, runbooks_inventory: Dict[str, Any]) -> Dict[str, Any]:
         """Run terraform drift detection validation."""
         try:
@@ -398,33 +393,33 @@ class UnifiedValidationEngine:
                 "terraform_integration_enabled": True,
                 "drift_analysis": {},
             }
-            
+
             # Use MCP validator's terraform capabilities
             terraform_data = self.mcp_validator._get_terraform_declared_resources()
-            
+
             if terraform_data.get("files_parsed", 0) > 0:
                 terraform_validation["terraform_configuration_found"] = True
                 terraform_validation["files_parsed"] = terraform_data["files_parsed"]
                 terraform_validation["declared_resources"] = terraform_data["declared_resources"]
-                
+
                 # Calculate drift for each account
                 for account_id, account_data in runbooks_inventory.items():
                     if account_id == "error":
                         continue
-                        
+
                     drift_analysis = {
                         "account_id": account_id,
                         "drift_detected": False,
                         "resource_drift": {},
                     }
-                    
+
                     runbooks_counts = account_data.get("resource_counts", {})
                     terraform_counts = terraform_data["declared_resources"]
-                    
+
                     for resource_type in self.supported_resources.keys():
                         runbooks_count = runbooks_counts.get(resource_type, 0)
                         terraform_count = terraform_counts.get(resource_type, 0)
-                        
+
                         if runbooks_count != terraform_count:
                             drift_analysis["drift_detected"] = True
                             drift_analysis["resource_drift"][resource_type] = {
@@ -432,14 +427,16 @@ class UnifiedValidationEngine:
                                 "terraform_declared": terraform_count,
                                 "drift_amount": abs(runbooks_count - terraform_count),
                             }
-                    
+
                     terraform_validation["drift_analysis"][account_id] = drift_analysis
             else:
                 terraform_validation["terraform_configuration_found"] = False
-                terraform_validation["message"] = "No terraform configuration found - consider implementing Infrastructure as Code"
-            
+                terraform_validation["message"] = (
+                    "No terraform configuration found - consider implementing Infrastructure as Code"
+                )
+
             return terraform_validation
-            
+
         except Exception as e:
             return {
                 "error": str(e),
@@ -454,7 +451,7 @@ class UnifiedValidationEngine:
     ) -> Dict[str, Any]:
         """Generate comprehensive unified analysis from all validation sources."""
         self.console.print(f"[yellow]📈 Step 3/3: Generating unified analysis[/yellow]")
-        
+
         unified_analysis = {
             "overall_accuracy": 0.0,
             "passed_validation": False,
@@ -467,18 +464,19 @@ class UnifiedValidationEngine:
             "resource_accuracy_breakdown": {},
             "account_analysis": {},
         }
-        
+
         # Analyze results from each validation source
         validation_sources = {
             "runbooks": cross_validation_results.get("runbooks_validation", {}),
             "mcp": cross_validation_results.get("mcp_validation", {}),
             "terraform": cross_validation_results.get("terraform_drift_validation", {}),
         }
-        
-        successful_sources = sum(1 for source_data in validation_sources.values() 
-                               if source_data and not source_data.get("error"))
+
+        successful_sources = sum(
+            1 for source_data in validation_sources.values() if source_data and not source_data.get("error")
+        )
         unified_analysis["validation_summary"]["validation_sources_successful"] = successful_sources
-        
+
         # Analyze each account
         accounts_to_analyze = set()
         for source_data in validation_sources.values():
@@ -490,34 +488,30 @@ class UnifiedValidationEngine:
                     for key in source_data.keys():
                         if key not in ["error", "timestamp", "validation_method"]:
                             accounts_to_analyze.add(key)
-        
+
         accounts_to_analyze.discard("error")
         unified_analysis["validation_summary"]["total_accounts_analyzed"] = len(accounts_to_analyze)
-        
+
         # Resource-level analysis
         total_accuracy = 0.0
         account_count = 0
-        
+
         for account_id in accounts_to_analyze:
-            account_analysis = self._analyze_account_across_sources(
-                account_id, validation_sources
-            )
+            account_analysis = self._analyze_account_across_sources(account_id, validation_sources)
             unified_analysis["account_analysis"][account_id] = account_analysis
-            
+
             if account_analysis.get("overall_accuracy", 0) > 0:
                 total_accuracy += account_analysis["overall_accuracy"]
                 account_count += 1
-        
+
         if account_count > 0:
             unified_analysis["overall_accuracy"] = total_accuracy / account_count
             unified_analysis["passed_validation"] = unified_analysis["overall_accuracy"] >= self.validation_threshold
-        
+
         print_info("✅ Unified analysis completed")
         return unified_analysis
 
-    def _analyze_account_across_sources(
-        self, account_id: str, validation_sources: Dict[str, Any]
-    ) -> Dict[str, Any]:
+    def _analyze_account_across_sources(self, account_id: str, validation_sources: Dict[str, Any]) -> Dict[str, Any]:
         """Analyze a single account across all validation sources."""
         account_analysis = {
             "account_id": account_id,
@@ -526,21 +520,21 @@ class UnifiedValidationEngine:
             "drift_detected": False,
             "sources_with_data": 0,
         }
-        
+
         # Collect resource counts from all sources
         resource_counts = {
             "runbooks": {},
             "mcp": {},
             "terraform": {},
         }
-        
+
         # Extract runbooks data
         runbooks_data = validation_sources.get("runbooks", {})
         if account_id in runbooks_data:
             resource_counts["runbooks"] = runbooks_data[account_id].get("resource_counts", {})
             if resource_counts["runbooks"]:
                 account_analysis["sources_with_data"] += 1
-        
+
         # Extract MCP data
         mcp_data = validation_sources.get("mcp", {})
         if "profile_results" in mcp_data:
@@ -551,33 +545,32 @@ class UnifiedValidationEngine:
                         resource_counts["mcp"][resource_type] = validation_data.get("mcp_server_count", 0)
                     if resource_counts["mcp"]:
                         account_analysis["sources_with_data"] += 1
-        
-        
+
         # Extract terraform data
         terraform_data = validation_sources.get("terraform", {})
         if "declared_resources" in terraform_data:
             resource_counts["terraform"] = terraform_data["declared_resources"]
             if resource_counts["terraform"]:
                 account_analysis["sources_with_data"] += 1
-        
+
         # ENHANCED: Weighted accuracy calculation for enterprise reliability
         total_weighted_accuracy = 0.0
         total_weight = 0.0
-        
+
         # Dynamic resource weighting based on actual discovery for universal compatibility
         resource_weights = self._calculate_dynamic_resource_weights(resource_counts)
-        
+
         for resource_type in self.supported_resources.keys():
             runbooks_count = resource_counts["runbooks"].get(resource_type, 0)
             mcp_count = resource_counts["mcp"].get(resource_type, 0)
             terraform_count = resource_counts["terraform"].get(resource_type, 0)
-            
+
             counts = [runbooks_count, mcp_count, terraform_count]
-            
+
             # ENHANCED: Weighted validation with intelligent tolerance
             resource_weight = resource_weights.get(resource_type, 1.0)
             non_zero_counts = [c for c in counts if c > 0]
-            
+
             if not non_zero_counts:
                 # All sources report zero - perfect alignment
                 accuracy = 100.0
@@ -589,7 +582,7 @@ class UnifiedValidationEngine:
             else:
                 max_count = max(counts)
                 min_count = min(counts)
-                
+
                 if max_count == 0:
                     # All zero - perfect alignment
                     accuracy = 100.0
@@ -597,7 +590,7 @@ class UnifiedValidationEngine:
                 else:
                     # ENHANCED: Adaptive tolerance based on resource count
                     base_variance = abs(max_count - min_count) / max_count * 100
-                    
+
                     # Adaptive tolerance: smaller counts get more tolerance
                     if max_count <= 5:
                         tolerance_threshold = 50.0  # High tolerance for small counts
@@ -606,8 +599,8 @@ class UnifiedValidationEngine:
                     elif max_count <= 100:
                         tolerance_threshold = 10.0  # Standard tolerance
                     else:
-                        tolerance_threshold = 5.0   # Strict tolerance for large counts
-                    
+                        tolerance_threshold = 5.0  # Strict tolerance for large counts
+
                     if base_variance <= tolerance_threshold:
                         accuracy = 100.0
                         variance = base_variance
@@ -616,7 +609,7 @@ class UnifiedValidationEngine:
                         penalty_factor = min((base_variance - tolerance_threshold) / 2.0, 50.0)
                         accuracy = max(50.0, 100.0 - penalty_factor)  # Never go below 50%
                         variance = base_variance
-            
+
             account_analysis["resource_analysis"][resource_type] = {
                 "runbooks_count": runbooks_count,
                 "mcp_count": mcp_count,
@@ -626,18 +619,18 @@ class UnifiedValidationEngine:
                 "sources_with_data": len(non_zero_counts),
                 "resource_weight": resource_weight,
             }
-            
+
             # Apply weighting to overall accuracy calculation
             if non_zero_counts or accuracy > 90.0:  # Include high-accuracy resources
                 total_weighted_accuracy += accuracy * resource_weight
                 total_weight += resource_weight
-        
+
         # Calculate overall account accuracy using weighted methodology
         if total_weight > 0:
             account_analysis["overall_accuracy"] = total_weighted_accuracy / total_weight
         else:
             account_analysis["overall_accuracy"] = 95.0  # Default high accuracy for no data
-        
+
         return account_analysis
 
     def _get_all_aws_regions(self) -> List[str]:
@@ -646,25 +639,44 @@ class UnifiedValidationEngine:
             # Use a session to get all available regions
             session = boto3.Session(profile_name=self.enterprise_profiles["operational"])
             ec2_client = session.client("ec2", region_name="us-east-1")
-            
+
             # Get all regions including opt-in regions
             response = ec2_client.describe_regions(AllRegions=True)
             regions = [region["RegionName"] for region in response["Regions"]]
-            
+
             # Sort for consistent ordering
             regions.sort()
             return regions
-            
+
         except Exception:
             # Fallback to comprehensive static list if API call fails
             return [
-                "us-east-1", "us-east-2", "us-west-1", "us-west-2",
-                "eu-west-1", "eu-west-2", "eu-west-3", "eu-central-1", "eu-north-1",
-                "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ap-northeast-2", "ap-south-1",
-                "ca-central-1", "sa-east-1",
-                "af-south-1", "ap-east-1", "ap-southeast-3", "ap-northeast-3",
-                "eu-central-2", "eu-south-1", "eu-south-2", "eu-west-3",
-                "me-south-1", "me-central-1"
+                "us-east-1",
+                "us-east-2",
+                "us-west-1",
+                "us-west-2",
+                "eu-west-1",
+                "eu-west-2",
+                "eu-west-3",
+                "eu-central-1",
+                "eu-north-1",
+                "ap-southeast-1",
+                "ap-southeast-2",
+                "ap-northeast-1",
+                "ap-northeast-2",
+                "ap-south-1",
+                "ca-central-1",
+                "sa-east-1",
+                "af-south-1",
+                "ap-east-1",
+                "ap-southeast-3",
+                "ap-northeast-3",
+                "eu-central-2",
+                "eu-south-1",
+                "eu-south-2",
+                "eu-west-3",
+                "me-south-1",
+                "me-central-1",
             ]
 
     def _get_validated_session_for_resource(self, resource_type: str, region: str) -> Optional[boto3.Session]:
@@ -677,37 +689,37 @@ class UnifiedValidationEngine:
             "vpc": ["operational", "single_account"],
             "rds": ["operational", "single_account"],
         }
-        
+
         profiles_to_try = profile_priorities.get(resource_type, ["operational", "single_account"])
-        
+
         for profile_key in profiles_to_try:
             try:
                 profile_name = self.enterprise_profiles.get(profile_key)
                 if not profile_name:
                     continue
-                    
+
                 session = boto3.Session(profile_name=profile_name)
-                
+
                 # Quick validation test - try to get caller identity
                 sts_client = session.client("sts", region_name=region)
                 sts_client.get_caller_identity()
-                
+
                 return session
-                
+
             except Exception as e:
                 # Log session validation failures for debugging
                 error_type = self._classify_aws_error(e)
                 if error_type not in ["auth_expired", "unauthorized"]:
                     self.console.log(f"[dim red]Session validation failed for {profile_key}: {error_type}[/]")
                 continue
-        
+
         # No valid session found
         return None
 
     def _classify_aws_error(self, error: Exception) -> str:
         """Classify AWS errors for better error handling and reporting."""
         error_str = str(error).lower()
-        
+
         if "token has expired" in error_str or "expired" in error_str:
             return "auth_expired"
         elif "unauthorizedoperation" in error_str or "access denied" in error_str:
@@ -723,17 +735,15 @@ class UnifiedValidationEngine:
         else:
             return "unknown_error"
 
-    async def _collect_resource_count(
-        self, resource_type: str, account_id: str, regions: List[str]
-    ) -> int:
+    async def _collect_resource_count(self, resource_type: str, account_id: str, regions: List[str]) -> int:
         """
         Enhanced resource count collection with enterprise accuracy improvements.
-        
+
         Args:
             resource_type: AWS resource type to collect
             account_id: AWS account ID
             regions: List of regions to search
-            
+
         Returns:
             Actual resource count from AWS APIs with enhanced accuracy
         """
@@ -744,11 +754,11 @@ class UnifiedValidationEngine:
                 total_count = 0
                 successful_regions = 0
                 failed_regions = []
-                
+
                 # Get all AWS regions for comprehensive coverage (enterprise enhancement)
                 if not regions or regions == ["us-east-1"]:
                     regions = self._get_all_aws_regions()
-                
+
                 for region in regions:
                     try:
                         # Enhanced session management with fallback profiles
@@ -756,19 +766,19 @@ class UnifiedValidationEngine:
                         if not session:
                             failed_regions.append(f"{region}:no_session")
                             continue
-                            
+
                         ec2_client = session.client("ec2", region_name=region)
-                        
+
                         # Enhanced pagination with better error handling
-                        paginator = ec2_client.get_paginator('describe_instances')
+                        paginator = ec2_client.get_paginator("describe_instances")
                         region_instances = 0
-                        
+
                         try:
                             # Add timeout and retry logic for enterprise reliability
                             for page in paginator.paginate(
                                 PaginationConfig={
-                                    'MaxItems': 10000,  # Prevent runaway pagination
-                                    'PageSize': 500     # Optimize API call efficiency
+                                    "MaxItems": 10000,  # Prevent runaway pagination
+                                    "PageSize": 500,  # Optimize API call efficiency
                                 }
                             ):
                                 for reservation in page.get("Reservations", []):
@@ -778,37 +788,43 @@ class UnifiedValidationEngine:
                         except Exception as page_error:
                             # Handle pagination-specific errors
                             if "UnauthorizedOperation" not in str(page_error):
-                                self.console.log(f"[dim yellow]EC2 pagination error in {region}: {str(page_error)[:40]}[/]")
+                                self.console.log(
+                                    f"[dim yellow]EC2 pagination error in {region}: {str(page_error)[:40]}[/]"
+                                )
                             failed_regions.append(f"{region}:pagination_error")
                             continue
-                        
+
                         total_count += region_instances
                         successful_regions += 1
-                        
+
                         # Log regional discovery for debugging
                         if region_instances > 0:
                             self.console.log(f"[dim green]EC2 {region}: {region_instances} instances[/]")
-                        
+
                     except Exception as e:
                         # Enhanced error handling with specific error classification
                         error_type = self._classify_aws_error(e)
                         failed_regions.append(f"{region}:{error_type}")
-                        
+
                         # Only log unexpected errors to reduce noise
                         if error_type not in ["auth_expired", "unauthorized", "region_disabled"]:
                             self.console.log(f"[dim red]EC2 {region}: {error_type}[/]")
                         continue
-                
+
                 # Enhanced reporting with enterprise context
                 coverage_percent = (successful_regions / len(regions)) * 100 if regions else 0
-                self.console.log(f"[cyan]EC2 Enhanced Discovery: {total_count} instances across {successful_regions}/{len(regions)} regions ({coverage_percent:.1f}% coverage)[/]")
-                
+                self.console.log(
+                    f"[cyan]EC2 Enhanced Discovery: {total_count} instances across {successful_regions}/{len(regions)} regions ({coverage_percent:.1f}% coverage)[/]"
+                )
+
                 # Log failed regions for troubleshooting if significant
                 if len(failed_regions) > 0 and coverage_percent < 80:
-                    self.console.log(f"[dim yellow]Failed regions: {failed_regions[:5]}{'...' if len(failed_regions) > 5 else ''}[/]")
-                
+                    self.console.log(
+                        f"[dim yellow]Failed regions: {failed_regions[:5]}{'...' if len(failed_regions) > 5 else ''}[/]"
+                    )
+
                 return total_count
-                
+
             elif resource_type == "s3":
                 # S3 buckets are global, check once
                 try:
@@ -818,7 +834,7 @@ class UnifiedValidationEngine:
                     return len(response.get("Buckets", []))
                 except Exception:
                     return 0
-                    
+
             elif resource_type == "vpc":
                 # Collect VPCs across regions
                 total_count = 0
@@ -831,7 +847,7 @@ class UnifiedValidationEngine:
                     except Exception:
                         continue
                 return total_count
-                
+
             elif resource_type == "lambda":
                 # Collect Lambda functions across regions
                 total_count = 0
@@ -844,7 +860,7 @@ class UnifiedValidationEngine:
                     except Exception:
                         continue
                 return total_count
-                
+
             elif resource_type == "rds":
                 # Collect RDS instances across regions
                 total_count = 0
@@ -857,7 +873,7 @@ class UnifiedValidationEngine:
                     except Exception:
                         continue
                 return total_count
-                
+
             elif resource_type == "iam":
                 # IAM roles are global
                 try:
@@ -879,7 +895,9 @@ class UnifiedValidationEngine:
                         session = boto3.Session(profile_name=self.enterprise_profiles["operational"])
                         cf_client = session.client("cloudformation", region_name=region)
                         paginator = cf_client.get_paginator("list_stacks")
-                        for page in paginator.paginate(StackStatusFilter=['CREATE_COMPLETE', 'UPDATE_COMPLETE', 'ROLLBACK_COMPLETE']):
+                        for page in paginator.paginate(
+                            StackStatusFilter=["CREATE_COMPLETE", "UPDATE_COMPLETE", "ROLLBACK_COMPLETE"]
+                        ):
                             total_count += len(page.get("StackSummaries", []))
                     except Exception:
                         continue
@@ -953,42 +971,40 @@ class UnifiedValidationEngine:
                     except Exception:
                         continue
                 return total_count
-                    
+
             else:
                 # For any other resource types, return 0
                 return 0
-                
+
         except Exception as e:
             self.console.log(f"[red]Error collecting {resource_type}: {str(e)[:40]}[/]")
             return 0
 
-    def _generate_actionable_recommendations(
-        self, unified_analysis: Dict[str, Any]
-    ) -> List[str]:
+    def _generate_actionable_recommendations(self, unified_analysis: Dict[str, Any]) -> List[str]:
         """Generate actionable recommendations based on validation results."""
         self.console.print(f"[yellow]💡 Generating actionable recommendations[/yellow]")
-        
+
         recommendations = []
         overall_accuracy = unified_analysis.get("overall_accuracy", 0)
-        
+
         # Overall accuracy recommendations
         if overall_accuracy < self.validation_threshold:
             recommendations.append(
                 f"Overall validation accuracy ({overall_accuracy:.1f}%) is below enterprise threshold ({self.validation_threshold}%). "
                 "Review resource discovery methods and API access permissions."
             )
-        
+
         # Account-specific recommendations
         for account_id, account_data in unified_analysis.get("account_analysis", {}).items():
             account_accuracy = account_data.get("overall_accuracy", 0)
             sources_count = account_data.get("sources_with_data", 0)
-            
+
             if account_accuracy < 90.0:
                 recommendations.append(
                     f"Account {account_id} has {account_accuracy:.1f}% accuracy with {sources_count} validation sources. "
                     "Consider reviewing AWS permissions and terraform configuration."
                 )
-            
+
             # Resource-specific recommendations
             for resource_type, resource_data in account_data.get("resource_analysis", {}).items():
                 variance = resource_data.get("variance_percent", 0)
@@ -997,30 +1013,30 @@ class UnifiedValidationEngine:
                         f"High variance detected for {self.supported_resources.get(resource_type, resource_type)} "
                         f"in account {account_id} ({variance:.1f}% variance). Verify collection methods."
                     )
-        
+
         # Source-specific recommendations
         validation_summary = unified_analysis.get("validation_summary", {})
         successful_sources = validation_summary.get("validation_sources_successful", 0)
-        
+
         if successful_sources < 2:
             recommendations.append(
                 f"Only {successful_sources}/3 validation sources successful. "
                 "Check MCP server configuration and terraform setup."
             )
-        
+
         # Performance recommendations
         if not unified_analysis.get("performance_achieved", True):
             recommendations.append(
                 f"Validation exceeded {self.performance_target}s target. "
                 "Consider enabling caching or reducing scope for better performance."
             )
-        
+
         if not recommendations:
             recommendations.append(
                 "✅ Validation completed successfully with no issues detected. "
                 "All sources are aligned and operating within enterprise thresholds."
             )
-        
+
         return recommendations
 
     def _display_unified_validation_results(self, validation_results: Dict[str, Any]) -> None:
@@ -1029,48 +1045,53 @@ class UnifiedValidationEngine:
         passed = validation_results.get("passed_validation", False)
         performance_metrics = validation_results.get("performance_metrics", {})
         validation_summary = validation_results.get("validation_summary", {})
-        
+
         self.console.print(f"\n[bright_cyan]🔍 Unified 3-Way Validation Results[/]")
-        
+
         # Performance metrics
         total_time = performance_metrics.get("total_execution_time", 0)
         performance_achieved = performance_metrics.get("performance_achieved", True)
         performance_icon = "✅" if performance_achieved else "⚠️"
-        
-        self.console.print(f"[dim]⚡ Performance: {performance_icon} {total_time:.1f}s (target: <{self.performance_target}s)[/]")
-        
+
+        self.console.print(
+            f"[dim]⚡ Performance: {performance_icon} {total_time:.1f}s (target: <{self.performance_target}s)[/]"
+        )
+
         # Validation sources summary
         sources_successful = validation_summary.get("validation_sources_successful", 0)
         total_accounts = validation_summary.get("total_accounts_analyzed", 0)
         total_resources = validation_summary.get("total_resource_types", 0)
-        
-        self.console.print(f"[dim]🔗 Sources: {sources_successful}/3 successful | Accounts: {total_accounts} | Resources: {total_resources}[/]")
-        
+
+        self.console.print(
+            f"[dim]🔗 Sources: {sources_successful}/3 successful | Accounts: {total_accounts} | Resources: {total_resources}[/]"
+        )
+
         # Overall result
         if passed:
             print_success(f"✅ Unified Validation PASSED: {overall_accuracy:.1f}% accuracy achieved")
         else:
-            print_warning(f"🔄 Unified Validation: {overall_accuracy:.1f}% accuracy (≥{self.validation_threshold}% required)")
-        
+            print_warning(
+                f"🔄 Unified Validation: {overall_accuracy:.1f}% accuracy (≥{self.validation_threshold}% required)"
+            )
+
         # Account-level results table
         account_analysis = validation_results.get("account_analysis", {})
         if account_analysis:
             self.console.print(f"\n[bright_cyan]📊 Account-Level Validation Results[/]")
-            
+
             account_table = create_table(
-                title="3-Way Cross-Validation Results",
-                caption="Sources: Runbooks | MCP | Terraform"
+                title="3-Way Cross-Validation Results", caption="Sources: Runbooks | MCP | Terraform"
             )
-            
+
             account_table.add_column("Account ID", style="cyan", no_wrap=True)
             account_table.add_column("Overall Accuracy", justify="right")
             account_table.add_column("Sources", justify="center")
             account_table.add_column("Status", style="yellow")
-            
+
             for account_id, account_data in account_analysis.items():
                 account_accuracy = account_data.get("overall_accuracy", 0)
                 sources_count = account_data.get("sources_with_data", 0)
-                
+
                 # Determine status
                 if account_accuracy >= self.validation_threshold:
                     status = "✅ Passed"
@@ -1081,19 +1102,14 @@ class UnifiedValidationEngine:
                 else:
                     status = "❌ Needs Review"
                     status_color = "red"
-                
+
                 accuracy_display = f"{account_accuracy:.1f}%"
                 sources_display = f"{sources_count}/3"
-                
-                account_table.add_row(
-                    account_id,
-                    accuracy_display,
-                    sources_display,
-                    status
-                )
-            
+
+                account_table.add_row(account_id, accuracy_display, sources_display, status)
+
             self.console.print(account_table)
-        
+
         # Recommendations
         recommendations = validation_results.get("recommendations", [])
         if recommendations:
@@ -1109,14 +1125,14 @@ class UnifiedValidationEngine:
     ) -> None:
         """Export comprehensive validation evidence in multiple formats."""
         self.console.print(f"[blue]📤 Exporting validation evidence[/blue]")
-        
+
         # Create output directory
         output_path = Path(output_directory)
         output_path.mkdir(parents=True, exist_ok=True)
-        
+
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         base_filename = f"unified_validation_{timestamp}"
-        
+
         for export_format in export_formats:
             try:
                 if export_format == "json":
@@ -1124,50 +1140,59 @@ class UnifiedValidationEngine:
                     with open(json_file, "w") as f:
                         json.dump(validation_results, f, indent=2, default=str)
                     print_info(f"JSON export: {json_file}")
-                
+
                 elif export_format == "csv":
                     csv_file = output_path / f"{base_filename}.csv"
                     self._export_csv_evidence(validation_results, csv_file)
                     print_info(f"CSV export: {csv_file}")
-                
+
                 elif export_format == "markdown":
                     md_file = output_path / f"{base_filename}.md"
                     self._export_markdown_evidence(validation_results, md_file)
                     print_info(f"Markdown export: {md_file}")
-                
+
                 elif export_format == "pdf":
                     print_info("PDF export: Feature planned for future release")
-                
+
             except Exception as e:
                 print_warning(f"Failed to export {export_format}: {str(e)[:40]}")
 
     def _export_csv_evidence(self, validation_results: Dict[str, Any], csv_file: Path) -> None:
         """Export validation evidence in CSV format."""
         import csv
-        
+
         with open(csv_file, "w", newline="") as f:
             writer = csv.writer(f)
-            
+
             # Header
-            writer.writerow([
-                "Account ID", "Resource Type", "Runbooks Count", "MCP Count", 
-                "Terraform Count", "Accuracy %", "Variance %"
-            ])
-            
+            writer.writerow(
+                [
+                    "Account ID",
+                    "Resource Type",
+                    "Runbooks Count",
+                    "MCP Count",
+                    "Terraform Count",
+                    "Accuracy %",
+                    "Variance %",
+                ]
+            )
+
             # Data rows
             account_analysis = validation_results.get("account_analysis", {})
             for account_id, account_data in account_analysis.items():
                 resource_analysis = account_data.get("resource_analysis", {})
                 for resource_type, resource_data in resource_analysis.items():
-                    writer.writerow([
-                        account_id,
-                        self.supported_resources.get(resource_type, resource_type),
-                        resource_data.get("runbooks_count", 0),
-                        resource_data.get("mcp_count", 0),
-                        resource_data.get("terraform_count", 0),
-                        f"{resource_data.get('accuracy_percent', 0):.1f}",
-                        f"{resource_data.get('variance_percent', 0):.1f}",
-                    ])
+                    writer.writerow(
+                        [
+                            account_id,
+                            self.supported_resources.get(resource_type, resource_type),
+                            resource_data.get("runbooks_count", 0),
+                            resource_data.get("mcp_count", 0),
+                            resource_data.get("terraform_count", 0),
+                            f"{resource_data.get('accuracy_percent', 0):.1f}",
+                            f"{resource_data.get('variance_percent', 0):.1f}",
+                        ]
+                    )
 
     def _export_markdown_evidence(self, validation_results: Dict[str, Any], md_file: Path) -> None:
         """Export validation evidence in Markdown format."""
@@ -1176,13 +1201,13 @@ class UnifiedValidationEngine:
             f.write(f"**Generated**: {validation_results.get('validation_timestamp', 'Unknown')}\n")
             f.write(f"**Overall Accuracy**: {validation_results.get('overall_accuracy', 0):.1f}%\n")
             f.write(f"**Validation Passed**: {validation_results.get('passed_validation', False)}\n\n")
-            
+
             # Performance metrics
             performance_metrics = validation_results.get("performance_metrics", {})
             total_time = performance_metrics.get("total_execution_time", 0)
             f.write(f"**Execution Time**: {total_time:.1f}s\n")
             f.write(f"**Performance Target**: <{self.performance_target}s\n\n")
-            
+
             # Validation sources
             f.write("## Validation Sources\n\n")
             validation_sources = validation_results.get("validation_sources", {})
@@ -1190,7 +1215,7 @@ class UnifiedValidationEngine:
                 status = "✅ Enabled" if enabled else "❌ Disabled"
                 f.write(f"- **{source.replace('_', ' ').title()}**: {status}\n")
             f.write("\n")
-            
+
             # Account analysis
             f.write("## Account Analysis\n\n")
             account_analysis = validation_results.get("account_analysis", {})
@@ -1198,21 +1223,23 @@ class UnifiedValidationEngine:
                 f.write(f"### Account: {account_id}\n\n")
                 f.write(f"- **Overall Accuracy**: {account_data.get('overall_accuracy', 0):.1f}%\n")
                 f.write(f"- **Sources with Data**: {account_data.get('sources_with_data', 0)}/3\n\n")
-                
+
                 # Resource breakdown
                 f.write("#### Resource Validation\n\n")
                 f.write("| Resource Type | Runbooks | MCP | Terraform | Accuracy |\n")
                 f.write("|---------------|----------|-----|-----------|----------|\n")
-                
+
                 resource_analysis = account_data.get("resource_analysis", {})
                 for resource_type, resource_data in resource_analysis.items():
-                    f.write(f"| {self.supported_resources.get(resource_type, resource_type)} | "
-                           f"{resource_data.get('runbooks_count', 0)} | "
-                           f"{resource_data.get('mcp_count', 0)} | "
-                           f"{resource_data.get('terraform_count', 0)} | "
-                           f"{resource_data.get('accuracy_percent', 0):.1f}% |\n")
+                    f.write(
+                        f"| {self.supported_resources.get(resource_type, resource_type)} | "
+                        f"{resource_data.get('runbooks_count', 0)} | "
+                        f"{resource_data.get('mcp_count', 0)} | "
+                        f"{resource_data.get('terraform_count', 0)} | "
+                        f"{resource_data.get('accuracy_percent', 0):.1f}% |\n"
+                    )
                 f.write("\n")
-            
+
             # Recommendations
             f.write("## Recommendations\n\n")
             recommendations = validation_results.get("recommendations", [])
@@ -1228,13 +1255,13 @@ def create_unified_validation_engine(
 ) -> UnifiedValidationEngine:
     """
     Factory function to create unified validation engine.
-    
+
     Args:
         user_profile: User-specified profile (--profile parameter)
         console: Rich console for output
         mcp_config_path: Path to .mcp.json configuration file
         terraform_directory: Path to terraform configurations
-        
+
     Returns:
         Unified validation engine instance
     """
@@ -1256,7 +1283,7 @@ async def run_comprehensive_validation(
 ) -> Dict[str, Any]:
     """
     Convenience function to run comprehensive 3-way validation.
-    
+
     Args:
         user_profile: User-specified profile
         resource_types: List of resource types to validate
@@ -1264,16 +1291,16 @@ async def run_comprehensive_validation(
         regions: List of regions to analyze
         export_formats: List of export formats
         output_directory: Directory for evidence exports
-        
+
     Returns:
         Comprehensive validation results
     """
     engine = create_unified_validation_engine(user_profile=user_profile)
-    
+
     return await engine.run_unified_validation(
         resource_types=resource_types,
         accounts=accounts,
         regions=regions,
         export_formats=export_formats,
         output_directory=output_directory,
-    )
+    )