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

runbooks/inventory/mcp_inventory_validator.py

@@ -35,12 +35,13 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import boto3
-from rich.console import Console
-from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn, TimeElapsedColumn
+from rich.progress import BarColumn, SpinnerColumn, TaskProgressColumn, TextColumn, TimeElapsedColumn
+from runbooks.common.rich_utils import Progress
 from rich.table import Table
 
 from ..common.profile_utils import get_profile_for_operation, resolve_profile_for_operation_silent
 from ..common.rich_utils import (
+    Console,
     console as rich_console,
     create_table,
     format_cost,
@@ -58,10 +59,10 @@ class EnhancedMCPValidator:
     Provides enterprise-grade validation using actual MCP servers from .mcp.json configuration,
     with 4-way cross-validation: runbooks inventory + direct AWS APIs + MCP servers + terraform state.
     Ensures ≥99.5% accuracy for enterprise compliance with comprehensive drift detection.
-    
+
     Enhanced Features:
     - Real MCP server integration from .mcp.json configuration
-    - Enterprise AWS profile override priority system (User > Environment > Default) 
+    - Enterprise AWS profile override priority system (User > Environment > Default)
     - Multi-server validation: aws-api, cost-explorer, iam, cloudwatch, terraform-mcp
     - 4-way validation: runbooks + direct APIs + MCP servers + terraform drift
     - Real-time variance detection with configurable tolerance
@@ -70,11 +71,16 @@ class EnhancedMCPValidator:
     - Complete audit trails with evidence-based validation
     """
 
-    def __init__(self, user_profile: Optional[str] = None, console: Optional[Console] = None, 
-                 mcp_config_path: Optional[str] = None, terraform_directory: Optional[str] = None):
+    def __init__(
+        self,
+        user_profile: Optional[str] = None,
+        console: Optional[Console] = None,
+        mcp_config_path: Optional[str] = None,
+        terraform_directory: Optional[str] = None,
+    ):
         """
         Initialize enhanced MCP validator with enterprise profile management and MCP server integration.
-        
+
         Args:
             user_profile: User-specified profile (--profile parameter) - takes priority over environment
             console: Rich console for output (optional)
@@ -87,16 +93,16 @@ class EnhancedMCPValidator:
         self.tolerance_percent = 5.0  # ±5% tolerance for resource count validation
         self.validation_cache = {}  # Cache for performance optimization
         self.cache_ttl = 300  # 5 minutes cache TTL
-        
+
         # MCP Server Integration
         self.mcp_config_path = mcp_config_path or "/Volumes/Working/1xOps/CloudOps-Runbooks/.mcp.json"
         self.mcp_servers = {}
         self.mcp_processes = {}  # Track running MCP server processes
-        
+
         # AWS Profile Management following proven patterns
         self.enterprise_profiles = self._resolve_enterprise_profiles()
         self.aws_sessions = {}
-        
+
         # Terraform integration
         self.terraform_directory = terraform_directory or "/Volumes/Working/1xOps/CloudOps-Runbooks/terraform-aws"
         self.terraform_cache = {}  # Cache terraform state parsing
@@ -104,18 +110,18 @@ class EnhancedMCPValidator:
 
         # Supported AWS services for inventory validation
         self.supported_services = {
-            '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",
         }
 
         # Initialize components
@@ -126,7 +132,7 @@ class EnhancedMCPValidator:
     def _resolve_enterprise_profiles(self) -> Dict[str, str]:
         """
         Resolve enterprise AWS profiles using proven 3-tier priority system.
-        
+
         Returns:
             Dict mapping operation types to resolved profile names
         """
@@ -136,7 +142,7 @@ class EnhancedMCPValidator:
             "operational": resolve_profile_for_operation_silent("operational", self.user_profile),
             "single_account": resolve_profile_for_operation_silent("single_account", self.user_profile),
         }
-    
+
     def _load_mcp_configuration(self) -> None:
         """Load and parse MCP server configuration from .mcp.json."""
         try:
@@ -144,90 +150,88 @@ class EnhancedMCPValidator:
                 print_warning(f"MCP configuration not found: {self.mcp_config_path}")
                 self.mcp_servers = {}
                 return
-                
-            with open(self.mcp_config_path, 'r') as f:
+
+            with open(self.mcp_config_path, "r") as f:
                 config = json.load(f)
-                
+
             self.mcp_servers = config.get("mcpServers", {})
-            
+
             # Log MCP server availability
             available_servers = list(self.mcp_servers.keys())
-            relevant_servers = [s for s in available_servers if s in ['aws-api', 'cost-explorer', 'iam', 'cloudwatch', 'terraform-mcp']]
-            
-            print_info(f"MCP servers available: {len(available_servers)} total, {len(relevant_servers)} validation-relevant")
+            relevant_servers = [
+                s for s in available_servers if s in ["aws-api", "cost-explorer", "iam", "cloudwatch", "terraform-mcp"]
+            ]
+
+            print_info(
+                f"MCP servers available: {len(available_servers)} total, {len(relevant_servers)} validation-relevant"
+            )
             if relevant_servers:
                 self.console.log(f"[dim cyan]Validation servers: {', '.join(relevant_servers)}[/]")
-                
+
         except Exception as e:
             print_warning(f"Failed to load MCP configuration: {str(e)}")
             self.mcp_servers = {}
-    
+
     def _substitute_environment_variables(self, server_config: Dict[str, Any]) -> Dict[str, Any]:
         """
         Substitute environment variables in MCP server configuration with resolved profiles.
-        
+
         Args:
             server_config: MCP server configuration dictionary
-            
+
         Returns:
             Configuration with environment variables resolved
         """
         config = server_config.copy()
-        
+
         if "env" in config:
             env = config["env"].copy()
-            
+
             # Substitute profile environment variables with resolved enterprise profiles
             profile_substitutions = {
                 "${AWS_BILLING_PROFILE}": self.enterprise_profiles["billing"],
                 "${AWS_MANAGEMENT_PROFILE}": self.enterprise_profiles["management"],
                 "${AWS_CENTRALISED_OPS_PROFILE}": self.enterprise_profiles["operational"],
             }
-            
+
             for key, value in env.items():
                 if isinstance(value, str):
                     for placeholder, resolved_profile in profile_substitutions.items():
                         if placeholder in value:
                             env[key] = value.replace(placeholder, resolved_profile)
                             self.console.log(f"[dim]MCP {key}: {placeholder} → {resolved_profile}[/]")
-            
+
             config["env"] = env
-            
+
         return config
-    
+
     async def _start_mcp_server(self, server_name: str, server_config: Dict[str, Any]) -> Optional[subprocess.Popen]:
         """
         Start an MCP server process with resolved environment variables.
-        
+
         Args:
             server_name: Name of the MCP server
             server_config: Server configuration dictionary
-            
+
         Returns:
             Popen process object if successful, None if failed
         """
         try:
             # Substitute environment variables
             resolved_config = self._substitute_environment_variables(server_config)
-            
+
             # Build command
             command = [resolved_config["command"]] + resolved_config.get("args", [])
             env = os.environ.copy()
             env.update(resolved_config.get("env", {}))
-            
+
             # Start process
             self.console.log(f"[dim]Starting MCP server: {server_name}[/]")
-            process = subprocess.Popen(
-                command,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                env=env,
-                text=True
-            )
-            
+            process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, text=True)
+
             # Give process time to start
             await asyncio.sleep(2)
-            
+
             # Check if process is still running
             if process.poll() is None:
                 self.mcp_processes[server_name] = process
@@ -237,11 +241,11 @@ class EnhancedMCPValidator:
                 stdout, stderr = process.communicate()
                 print_warning(f"MCP server '{server_name}' failed to start: {stderr[:100]}")
                 return None
-                
+
         except Exception as e:
             print_warning(f"Failed to start MCP server '{server_name}': {str(e)}")
             return None
-    
+
     def _stop_mcp_servers(self) -> None:
         """Stop all running MCP server processes."""
         for server_name, process in self.mcp_processes.items():
@@ -251,13 +255,13 @@ class EnhancedMCPValidator:
                     self.console.log(f"[dim]Stopped MCP server: {server_name}[/]")
             except Exception as e:
                 self.console.log(f"[yellow]Warning: Could not stop MCP server {server_name}: {str(e)}[/]")
-        
+
         self.mcp_processes.clear()
 
     def _initialize_aws_sessions(self) -> None:
         """Initialize AWS sessions for all enterprise profiles with enhanced error handling."""
         successful_sessions = 0
-        
+
         for operation_type, profile_name in self.enterprise_profiles.items():
             try:
                 # Validate profile exists in AWS config
@@ -265,42 +269,50 @@ class EnhancedMCPValidator:
                 if profile_name not in available_profiles:
                     print_warning(f"Profile '{profile_name}' not found in AWS config for {operation_type}")
                     continue
-                
+
                 session = boto3.Session(profile_name=profile_name)
-                
+
                 # Test session validity with timeout
                 try:
                     sts_client = session.client("sts")
                     identity = sts_client.get_caller_identity()
-                    
+
                     self.aws_sessions[operation_type] = {
                         "session": session,
                         "profile": profile_name,
                         "account_id": identity.get("Account"),
                         "user_id": identity.get("UserId", "Unknown"),
-                        "region": session.region_name or "us-east-1"
+                        "region": session.region_name or "us-east-1",
                     }
-                    
+
                     successful_sessions += 1
-                    print_info(f"✅ MCP session for {operation_type}: {profile_name[:30]}... → Account {identity.get('Account', 'Unknown')}")
-                    
+                    print_info(
+                        f"✅ MCP session for {operation_type}: {profile_name[:30]}... → Account {identity.get('Account', 'Unknown')}"
+                    )
+
                 except Exception as sts_error:
                     if "expired" in str(sts_error).lower() or "token" in str(sts_error).lower():
-                        print_warning(f"AWS SSO token expired for {operation_type}. Run: aws sso login --profile {profile_name}")
+                        print_warning(
+                            f"AWS SSO token expired for {operation_type}. Run: aws sso login --profile {profile_name}"
+                        )
                     else:
                         print_warning(f"STS validation failed for {operation_type}: {str(sts_error)[:40]}")
-                        
+
             except Exception as e:
                 print_warning(f"Session creation failed for {operation_type} ({profile_name[:20]}...): {str(e)[:40]}")
-        
+
         # Log overall session status
         total_profiles = len(self.enterprise_profiles)
-        self.console.log(f"[dim]AWS sessions: {successful_sessions}/{total_profiles} profiles initialized successfully[/]")
-        
+        self.console.log(
+            f"[dim]AWS sessions: {successful_sessions}/{total_profiles} profiles initialized successfully[/]"
+        )
+
         if successful_sessions == 0:
             print_error("No AWS sessions could be initialized. Check profile configuration and SSO status.")
         elif successful_sessions < total_profiles:
-            print_warning(f"Only {successful_sessions}/{total_profiles} AWS sessions initialized. Some validations may be limited.")
+            print_warning(
+                f"Only {successful_sessions}/{total_profiles} AWS sessions initialized. Some validations may be limited."
+            )
 
     def _discover_terraform_state_files(self) -> None:
         """Discover terraform state files and configurations in the terraform directory."""
@@ -309,22 +321,22 @@ class EnhancedMCPValidator:
             if not terraform_path.exists():
                 print_warning(f"Terraform directory not found: {self.terraform_directory}")
                 return
-                
+
             # Look for terraform configuration files and state references
             config_files = []
             state_references = []
-            
+
             # Search for terraform files recursively
             for tf_file in terraform_path.rglob("*.tf"):
                 config_files.append(str(tf_file))
-                
-            # Search for state configuration files  
+
+            # Search for state configuration files
             for state_file in terraform_path.rglob("state.tf"):
                 state_references.append(str(state_file))
-                
+
             self.terraform_state_files = state_references
             print_info(f"Discovered {len(config_files)} terraform files, {len(state_references)} state configurations")
-            
+
         except Exception as e:
             print_warning(f"Failed to discover terraform files: {str(e)[:50]}")
             self.terraform_state_files = []
@@ -332,17 +344,17 @@ class EnhancedMCPValidator:
     def _parse_terraform_state_config(self, state_file: str) -> Dict[str, Any]:
         """
         Parse terraform state configuration to extract resource declarations.
-        
+
         Args:
             state_file: Path to terraform state.tf file
-            
+
         Returns:
             Dictionary containing parsed terraform configuration
         """
         try:
-            with open(state_file, 'r') as f:
+            with open(state_file, "r") as f:
                 content = f.read()
-                
+
             # Extract account ID from directory structure
             account_id = None
             path_parts = Path(state_file).parts
@@ -352,73 +364,73 @@ class EnhancedMCPValidator:
                     if potential_account.isdigit() and len(potential_account) == 12:
                         account_id = potential_account
                         break
-            
+
             # Extract backend configuration
             backend_bucket = None
             backend_key = None
             dynamodb_table = None
-            
+
             # Simple parsing for S3 backend configuration
-            lines = content.split('\n')
+            lines = content.split("\n")
             in_backend = False
             for line in lines:
                 line = line.strip()
                 if 'backend "s3"' in line:
                     in_backend = True
                     continue
-                if in_backend and line.startswith('bucket'):
-                    backend_bucket = line.split('=')[1].strip().strip('"')
-                elif in_backend and line.startswith('key'):
-                    backend_key = line.split('=')[1].strip().strip('"')
-                elif in_backend and line.startswith('dynamodb_table'):
-                    dynamodb_table = line.split('=')[1].strip().strip('"')
-                elif in_backend and line == '}':
+                if in_backend and line.startswith("bucket"):
+                    backend_bucket = line.split("=")[1].strip().strip('"')
+                elif in_backend and line.startswith("key"):
+                    backend_key = line.split("=")[1].strip().strip('"')
+                elif in_backend and line.startswith("dynamodb_table"):
+                    dynamodb_table = line.split("=")[1].strip().strip('"')
+                elif in_backend and line == "}":
                     in_backend = False
-                    
+
             return {
-                'file_path': state_file,
-                'account_id': account_id,
-                'backend_bucket': backend_bucket,
-                'backend_key': backend_key,
-                'dynamodb_table': dynamodb_table,
-                'directory': str(Path(state_file).parent),
-                'parsed_timestamp': datetime.now().isoformat(),
+                "file_path": state_file,
+                "account_id": account_id,
+                "backend_bucket": backend_bucket,
+                "backend_key": backend_key,
+                "dynamodb_table": dynamodb_table,
+                "directory": str(Path(state_file).parent),
+                "parsed_timestamp": datetime.now().isoformat(),
             }
-            
+
         except Exception as e:
             print_warning(f"Failed to parse terraform state file {state_file}: {str(e)[:50]}")
             return {
-                'file_path': state_file,
-                'error': str(e),
-                'parsed_timestamp': datetime.now().isoformat(),
+                "file_path": state_file,
+                "error": str(e),
+                "parsed_timestamp": datetime.now().isoformat(),
             }
 
     def _get_terraform_declared_resources(self, account_id: Optional[str] = None) -> Dict[str, Any]:
         """
         Extract resource declarations from terraform configuration files.
-        
+
         Args:
             account_id: AWS account ID to filter terraform configurations
-            
+
         Returns:
             Dictionary containing terraform declared resources by type
         """
         try:
             declared_resources = {
-                'ec2': 0,
-                's3': 0,
-                'rds': 0, 
-                'lambda': 0,
-                'vpc': 0,
-                'iam': 0,
-                'cloudformation': 0,
-                'elbv2': 0,
-                'route53': 0,
-                'sns': 0
+                "ec2": 0,
+                "s3": 0,
+                "rds": 0,
+                "lambda": 0,
+                "vpc": 0,
+                "iam": 0,
+                "cloudformation": 0,
+                "elbv2": 0,
+                "route53": 0,
+                "sns": 0,
             }
-            
+
             config_files = []
-            
+
             # If account_id provided, look for account-specific terraform files
             if account_id:
                 account_path = Path(self.terraform_directory) / "account" / account_id
@@ -428,76 +440,76 @@ class EnhancedMCPValidator:
                 # Look in all terraform files
                 terraform_path = Path(self.terraform_directory)
                 config_files.extend(terraform_path.rglob("*.tf"))
-                
+
             resource_patterns = {
-                'ec2': ['aws_instance', 'aws_launch_template'],
-                's3': ['aws_s3_bucket'],
-                'rds': ['aws_db_instance', 'aws_rds_cluster'],
-                'lambda': ['aws_lambda_function'],
-                'vpc': ['aws_vpc'],
-                'iam': ['aws_iam_role', 'aws_iam_user'],
-                'cloudformation': ['aws_cloudformation_stack'],
-                'elbv2': ['aws_lb', 'aws_alb'],
-                'route53': ['aws_route53_zone'],
-                'sns': ['aws_sns_topic']
+                "ec2": ["aws_instance", "aws_launch_template"],
+                "s3": ["aws_s3_bucket"],
+                "rds": ["aws_db_instance", "aws_rds_cluster"],
+                "lambda": ["aws_lambda_function"],
+                "vpc": ["aws_vpc"],
+                "iam": ["aws_iam_role", "aws_iam_user"],
+                "cloudformation": ["aws_cloudformation_stack"],
+                "elbv2": ["aws_lb", "aws_alb"],
+                "route53": ["aws_route53_zone"],
+                "sns": ["aws_sns_topic"],
             }
-            
+
             # Parse terraform files for resource declarations
             for config_file in config_files:
                 try:
-                    with open(config_file, 'r') as f:
+                    with open(config_file, "r") as f:
                         content = f.read()
-                        
+
                     # Count resource declarations
                     for service, patterns in resource_patterns.items():
                         for pattern in patterns:
                             declared_resources[service] += content.count(f'resource "{pattern}"')
-                            
+
                 except Exception as e:
                     continue  # Skip files that can't be read
-                    
+
             return {
-                'account_id': account_id,
-                'declared_resources': declared_resources,
-                'files_parsed': len(config_files),
-                'data_source': 'terraform_configuration_files',
-                'timestamp': datetime.now().isoformat(),
+                "account_id": account_id,
+                "declared_resources": declared_resources,
+                "files_parsed": len(config_files),
+                "data_source": "terraform_configuration_files",
+                "timestamp": datetime.now().isoformat(),
             }
-            
+
         except Exception as e:
             print_warning(f"Failed to extract terraform declared resources: {str(e)[:50]}")
             return {
-                'account_id': account_id,
-                'declared_resources': {service: 0 for service in self.supported_services.keys()},
-                'error': str(e),
-                'data_source': 'terraform_configuration_error',
-                'timestamp': datetime.now().isoformat(),
+                "account_id": account_id,
+                "declared_resources": {service: 0 for service in self.supported_services.keys()},
+                "error": str(e),
+                "data_source": "terraform_configuration_error",
+                "timestamp": datetime.now().isoformat(),
             }
 
     async def validate_with_mcp_servers(self, runbooks_inventory: Dict[str, Any]) -> Dict[str, Any]:
         """
         Enhanced validation using real MCP servers from .mcp.json configuration.
-        
+
         Provides comprehensive 4-way validation:
         1. Runbooks inventory data
-        2. Direct AWS API calls  
+        2. Direct AWS API calls
         3. Real MCP server responses
         4. Terraform state drift detection
-        
+
         Args:
             runbooks_inventory: Inventory data from runbooks collection
-            
+
         Returns:
             Enhanced validation results with MCP server integration
         """
         validation_results = {
             "validation_timestamp": datetime.now().isoformat(),
-            "validation_method": "enhanced_mcp_server_integration", 
+            "validation_method": "enhanced_mcp_server_integration",
             "mcp_integration": {
                 "config_loaded": bool(self.mcp_servers),
                 "servers_available": list(self.mcp_servers.keys()),
                 "servers_started": {},
-                "validation_sources": []
+                "validation_sources": [],
             },
             "enterprise_profiles": self.enterprise_profiles,
             "profiles_validated": 0,
@@ -508,35 +520,32 @@ class EnhancedMCPValidator:
                 "start_time": time.time(),
                 "mcp_server_startup_time": 0,
                 "validation_execution_time": 0,
-                "total_execution_time": 0
-            }
+                "total_execution_time": 0,
+            },
         }
 
         self.console.log(f"[blue]⚡ Starting enhanced MCP server validation[/]")
-        
+
         # Start relevant MCP servers
         await self._start_relevant_mcp_servers(validation_results)
-        
+
         # Execute validation with all available sources
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             BarColumn(),
-            TaskProgressColumn(), 
+            TaskProgressColumn(),
             TimeElapsedColumn(),
             console=self.console,
         ) as progress:
             task = progress.add_task("MCP server validation...", total=len(self.aws_sessions))
-            
+
             # Parallel execution for <20s target
             with ThreadPoolExecutor(max_workers=min(3, len(self.aws_sessions))) as executor:
                 future_to_operation = {}
                 for operation_type, session_info in self.aws_sessions.items():
                     future = executor.submit(
-                        self._validate_operation_with_mcp_servers, 
-                        operation_type, 
-                        session_info, 
-                        runbooks_inventory
+                        self._validate_operation_with_mcp_servers, operation_type, session_info, runbooks_inventory
                     )
                     future_to_operation[future] = operation_type
 
@@ -555,17 +564,17 @@ class EnhancedMCPValidator:
         # Finalize results and cleanup
         self._finalize_mcp_validation_results(validation_results)
         self._stop_mcp_servers()
-        
+
         return validation_results
-    
+
     async def _start_relevant_mcp_servers(self, validation_results: Dict[str, Any]) -> None:
         """Start MCP servers relevant to validation operations."""
         startup_start = time.time()
-        
+
         # Priority servers for validation
-        relevant_servers = ['aws-api', 'cost-explorer', 'iam', 'cloudwatch']
+        relevant_servers = ["aws-api", "cost-explorer", "iam", "cloudwatch"]
         started_servers = []
-        
+
         for server_name in relevant_servers:
             if server_name in self.mcp_servers:
                 server_config = self.mcp_servers[server_name]
@@ -575,30 +584,30 @@ class EnhancedMCPValidator:
                     validation_results["mcp_integration"]["servers_started"][server_name] = {
                         "status": "started",
                         "pid": process.pid,
-                        "profile_used": self._get_server_profile(server_config)
+                        "profile_used": self._get_server_profile(server_config),
                     }
                 else:
                     validation_results["mcp_integration"]["servers_started"][server_name] = {
                         "status": "failed",
-                        "error": "Failed to start process"
+                        "error": "Failed to start process",
                     }
-        
+
         validation_results["mcp_integration"]["validation_sources"] = [
             "runbooks_inventory",
-            "direct_aws_apis", 
-            f"mcp_servers_{len(started_servers)}"
+            "direct_aws_apis",
+            f"mcp_servers_{len(started_servers)}",
         ]
-        
+
         if self.terraform_state_files:
             validation_results["mcp_integration"]["validation_sources"].append("terraform_state")
-            
+
         validation_results["performance_metrics"]["mcp_server_startup_time"] = time.time() - startup_start
-        
+
         if started_servers:
             print_success(f"✅ MCP servers started: {', '.join(started_servers)}")
         else:
             print_warning("⚠️ No MCP servers started - using direct API validation only")
-    
+
     def _get_server_profile(self, server_config: Dict[str, Any]) -> Optional[str]:
         """Extract the profile name used by an MCP server configuration."""
         env = server_config.get("env", {})
@@ -606,29 +615,35 @@ class EnhancedMCPValidator:
             if "PROFILE" in key and isinstance(value, str) and not value.startswith("${"):
                 return value
         return None
-    
-    def _validate_operation_with_mcp_servers(self, operation_type: str, session_info: Dict[str, Any], 
-                                          runbooks_inventory: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+
+    def _validate_operation_with_mcp_servers(
+        self, operation_type: str, session_info: Dict[str, Any], runbooks_inventory: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
         """Validate a single operation using all available validation sources."""
         try:
             session = session_info["session"]
             profile_name = session_info["profile"]
             account_id = session_info["account_id"]
-            
+
             # Get validation data from all sources
             runbooks_data = self._extract_runbooks_inventory_data(runbooks_inventory, operation_type, account_id)
             direct_aws_data = asyncio.run(self._get_independent_inventory_data(session, profile_name))
             mcp_server_data = self._get_mcp_server_data(operation_type, account_id)
             terraform_data = self._get_terraform_declared_resources(account_id)
-            
+
             # Calculate comprehensive validation accuracy
             validation_result = self._calculate_comprehensive_accuracy(
-                runbooks_data, direct_aws_data, mcp_server_data, terraform_data,
-                operation_type, profile_name, account_id
+                runbooks_data,
+                direct_aws_data,
+                mcp_server_data,
+                terraform_data,
+                operation_type,
+                profile_name,
+                account_id,
             )
-            
+
             return validation_result
-            
+
         except Exception as e:
             return {
                 "operation_type": operation_type,
@@ -637,17 +652,17 @@ class EnhancedMCPValidator:
                 "overall_accuracy_percent": 0.0,
                 "passed_validation": False,
                 "error": str(e),
-                "validation_status": "ERROR"
+                "validation_status": "ERROR",
             }
-    
+
     def _get_mcp_server_data(self, operation_type: str, account_id: Optional[str]) -> Dict[str, Any]:
         """
         Get validation data from MCP servers (placeholder for actual MCP client implementation).
-        
+
         Args:
             operation_type: Type of operation (billing, management, operational)
             account_id: AWS account ID for context
-            
+
         Returns:
             MCP server validation data
         """
@@ -659,28 +674,34 @@ class EnhancedMCPValidator:
             "account_id": account_id,
             "resource_counts": {},
             "servers_queried": [],
-            "validation_timestamp": datetime.now().isoformat()
+            "validation_timestamp": datetime.now().isoformat(),
         }
-        
+
         # Check which servers are running and could provide data
         for server_name, process in self.mcp_processes.items():
             if process and process.poll() is None:  # Server is running
                 mcp_data["servers_queried"].append(server_name)
-                
+
         # For demonstration, populate with placeholder data structure
         # Real implementation would use MCP client to query running servers
         for service in self.supported_services.keys():
             mcp_data["resource_counts"][service] = 0  # Placeholder
-        
+
         return mcp_data
 
-    def _calculate_comprehensive_accuracy(self, runbooks_data: Dict, direct_aws_data: Dict, 
-                                        mcp_server_data: Dict, terraform_data: Dict,
-                                        operation_type: str, profile_name: str, 
-                                        account_id: Optional[str]) -> Dict[str, Any]:
+    def _calculate_comprehensive_accuracy(
+        self,
+        runbooks_data: Dict,
+        direct_aws_data: Dict,
+        mcp_server_data: Dict,
+        terraform_data: Dict,
+        operation_type: str,
+        profile_name: str,
+        account_id: Optional[str],
+    ) -> Dict[str, Any]:
         """
         Calculate comprehensive accuracy across all validation sources.
-        
+
         Args:
             runbooks_data: Data from runbooks inventory
             direct_aws_data: Data from direct AWS API calls
@@ -689,7 +710,7 @@ class EnhancedMCPValidator:
             operation_type: Operation type being validated
             profile_name: AWS profile name
             account_id: AWS account ID
-            
+
         Returns:
             Comprehensive validation result
         """
@@ -702,7 +723,7 @@ class EnhancedMCPValidator:
             resource_validations = {}
             total_variance = 0.0
             valid_comparisons = 0
-            
+
             # Comprehensive validation for each resource type
             for resource_type in self.supported_services.keys():
                 runbooks_count = runbooks_counts.get(resource_type, 0)
@@ -713,7 +734,7 @@ class EnhancedMCPValidator:
                 # Calculate variance across all sources
                 all_counts = [runbooks_count, direct_aws_count, mcp_server_count, terraform_count]
                 active_counts = [c for c in all_counts if c > 0]
-                
+
                 if not active_counts:
                     # All sources report zero - perfect alignment
                     accuracy_percent = 100.0
@@ -742,7 +763,7 @@ class EnhancedMCPValidator:
                     "variance_percent": variance,
                     "validation_status": validation_status,
                     "passed_validation": accuracy_percent >= self.validation_threshold,
-                    "sources_with_data": len(active_counts)
+                    "sources_with_data": len(active_counts),
                 }
 
                 # Include in total variance calculation
@@ -767,9 +788,9 @@ class EnhancedMCPValidator:
                     "runbooks_inventory": bool(runbooks_counts),
                     "direct_aws_apis": bool(direct_aws_counts),
                     "mcp_servers": len(mcp_server_data.get("servers_queried", [])),
-                    "terraform_state": bool(terraform_counts)
+                    "terraform_state": bool(terraform_counts),
                 },
-                "accuracy_category": self._categorize_inventory_accuracy(overall_accuracy)
+                "accuracy_category": self._categorize_inventory_accuracy(overall_accuracy),
             }
 
         except Exception as e:
@@ -780,19 +801,19 @@ class EnhancedMCPValidator:
                 "overall_accuracy_percent": 0.0,
                 "passed_validation": False,
                 "error": str(e),
-                "validation_status": "ERROR"
+                "validation_status": "ERROR",
             }
-    
+
     def _finalize_mcp_validation_results(self, validation_results: Dict[str, Any]) -> None:
         """Finalize MCP validation results with comprehensive metrics."""
         profile_results = validation_results["profile_results"]
-        
+
         # Calculate performance metrics
         start_time = validation_results["performance_metrics"]["start_time"]
         validation_results["performance_metrics"]["total_execution_time"] = time.time() - start_time
         validation_results["performance_metrics"]["validation_execution_time"] = (
-            validation_results["performance_metrics"]["total_execution_time"] - 
-            validation_results["performance_metrics"]["mcp_server_startup_time"]
+            validation_results["performance_metrics"]["total_execution_time"]
+            - validation_results["performance_metrics"]["mcp_server_startup_time"]
         )
 
         if not profile_results:
@@ -811,7 +832,7 @@ class EnhancedMCPValidator:
 
         # Display enhanced results
         self._display_mcp_validation_results(validation_results)
-        
+
     def _display_mcp_validation_results(self, results: Dict[str, Any]) -> None:
         """Display enhanced MCP validation results with server integration details."""
         overall_accuracy = results.get("total_accuracy", 0)
@@ -820,36 +841,38 @@ class EnhancedMCPValidator:
         performance_metrics = results.get("performance_metrics", {})
 
         self.console.print(f"\n[bright_cyan]🔍 Enhanced MCP Server Validation Results[/]")
-        
+
         # Display MCP integration summary
         servers_started = mcp_integration.get("servers_started", {})
         if servers_started:
             successful_servers = [name for name, info in servers_started.items() if info.get("status") == "started"]
             failed_servers = [name for name, info in servers_started.items() if info.get("status") == "failed"]
-            
+
             if successful_servers:
                 self.console.print(f"[dim green]✅ MCP Servers: {', '.join(successful_servers)}[/]")
             if failed_servers:
                 self.console.print(f"[dim red]❌ Failed Servers: {', '.join(failed_servers)}[/]")
-        
+
         # Display validation sources
         validation_sources = mcp_integration.get("validation_sources", [])
         self.console.print(f"[dim cyan]🔗 Validation Sources: {', '.join(validation_sources)}[/]")
-        
+
         # Display performance metrics
         total_time = performance_metrics.get("total_execution_time", 0)
         startup_time = performance_metrics.get("mcp_server_startup_time", 0)
         validation_time = performance_metrics.get("validation_execution_time", 0)
-        
-        self.console.print(f"[dim]⚡ Performance: {total_time:.1f}s total ({startup_time:.1f}s startup, {validation_time:.1f}s validation)[/]")
-        
+
+        self.console.print(
+            f"[dim]⚡ Performance: {total_time:.1f}s total ({startup_time:.1f}s startup, {validation_time:.1f}s validation)[/]"
+        )
+
         # Display per-operation results
         for result in results.get("profile_results", []):
             operation_type = result.get("operation_type", "Unknown")
             accuracy = result.get("overall_accuracy_percent", 0)
             status = result.get("validation_status", "UNKNOWN")
             account_id = result.get("account_id", "Unknown")
-            
+
             # Determine display formatting
             if status == "PASSED" and accuracy >= 99.5:
                 icon = "✅"
@@ -863,27 +886,32 @@ class EnhancedMCPValidator:
             else:
                 icon = "❌"
                 color = "red"
-            
-            self.console.print(f"[dim]  {operation_type:12s} ({account_id}): {icon} [{color}]{accuracy:.1f}% accuracy[/]")
-            
+
+            self.console.print(
+                f"[dim]  {operation_type:12s} ({account_id}): {icon} [{color}]{accuracy:.1f}% accuracy[/]"
+            )
+
             # Show resource-level details for significant variances
             resource_validations = result.get("resource_validations", {})
             for resource_type, resource_data in resource_validations.items():
                 if resource_data.get("variance_percent", 0) > 10:  # Show resources with >10% variance
                     variance = resource_data["variance_percent"]
                     sources_count = resource_data["sources_with_data"]
-                    self.console.print(f"[dim]    {self.supported_services.get(resource_type, resource_type):15s}: ⚠️ {variance:.1f}% variance ({sources_count} sources)[/]")
+                    self.console.print(
+                        f"[dim]    {self.supported_services.get(resource_type, resource_type):15s}: ⚠️ {variance:.1f}% variance ({sources_count} sources)[/]"
+                    )
 
         # Overall validation summary
         if passed:
             print_success(f"✅ Enhanced MCP Validation PASSED: {overall_accuracy:.1f}% accuracy achieved")
         else:
             print_warning(f"⚠️ Enhanced MCP Validation: {overall_accuracy:.1f}% accuracy (≥99.5% required)")
-            
+
         print_info(f"Enterprise compliance: {results.get('profiles_validated', 0)} operations validated")
 
-    def _extract_runbooks_inventory_data(self, runbooks_inventory: Dict[str, Any], 
-                                       operation_type: str, account_id: Optional[str] = None) -> Dict[str, Any]:
+    def _extract_runbooks_inventory_data(
+        self, runbooks_inventory: Dict[str, Any], operation_type: str, account_id: Optional[str] = None
+    ) -> Dict[str, Any]:
         """
         Extract inventory data from runbooks results for comprehensive validation.
         Enhanced to work with operation types instead of profile names.
@@ -892,7 +920,7 @@ class EnhancedMCPValidator:
             # Handle various runbooks inventory data structures
             resource_counts = {}
             regions_discovered = []
-            
+
             # Try operation_type key first
             if operation_type in runbooks_inventory:
                 operation_data = runbooks_inventory[operation_type]
@@ -907,14 +935,16 @@ class EnhancedMCPValidator:
             else:
                 resource_counts = runbooks_inventory.get("resource_counts", {})
                 regions_discovered = runbooks_inventory.get("regions", [])
-            
+
             return {
                 "operation_type": operation_type,
                 "account_id": account_id,
                 "resource_counts": resource_counts,
                 "regions_discovered": regions_discovered,
                 "data_source": "runbooks_inventory_collection",
-                "extraction_method": f"operation_type_{operation_type}" if operation_type in runbooks_inventory else "fallback"
+                "extraction_method": f"operation_type_{operation_type}"
+                if operation_type in runbooks_inventory
+                else "fallback",
             }
         except Exception as e:
             self.console.log(f"[yellow]Warning: Error extracting runbooks inventory data: {str(e)}[/]")
@@ -924,13 +954,13 @@ class EnhancedMCPValidator:
                 "resource_counts": {},
                 "regions_discovered": [],
                 "data_source": "runbooks_inventory_collection_error",
-                "error": str(e)
+                "error": str(e),
             }
 
     async def validate_inventory_data_async(self, runbooks_inventory: Dict[str, Any]) -> Dict[str, Any]:
         """
         Enhanced 3-way validation: runbooks inventory vs AWS API vs terraform state.
-        
+
         Provides comprehensive drift detection between declared infrastructure
         and actual deployed resources with enterprise accuracy requirements.
 
@@ -951,18 +981,20 @@ class EnhancedMCPValidator:
             "terraform_integration": {
                 "enabled": len(self.terraform_state_files) > 0,
                 "state_files_discovered": len(self.terraform_state_files),
-                "drift_analysis": {}
+                "drift_analysis": {},
             },
         }
 
         # Enhanced parallel processing with terraform integration for <20s performance target
-        self.console.log(f"[blue]⚡ Starting enhanced 3-way validation with {min(5, len(self.aws_sessions))} workers[/]")
-        
+        self.console.log(
+            f"[blue]⚡ Starting enhanced 3-way validation with {min(5, len(self.aws_sessions))} workers[/]"
+        )
+
         with Progress(
             SpinnerColumn(),
             TextColumn("[progress.description]{task.description}"),
             BarColumn(),
-            TaskProgressColumn(), 
+            TaskProgressColumn(),
             TimeElapsedColumn(),
             console=self.console,
         ) as progress:
@@ -972,8 +1004,11 @@ class EnhancedMCPValidator:
             with ThreadPoolExecutor(max_workers=min(5, len(self.aws_sessions))) as executor:
                 # Submit all validation tasks
                 future_to_profile = {}
-                for profile, session in self.aws_sessions.items():
-                    future = executor.submit(self._validate_profile_with_drift_detection, profile, session, runbooks_inventory)
+                for profile, session_info in self.aws_sessions.items():
+                    session = session_info["session"]  # Extract boto3.Session from dict
+                    future = executor.submit(
+                        self._validate_profile_with_drift_detection, profile, session, runbooks_inventory
+                    )
                     future_to_profile[future] = profile
 
                 # Collect results as they complete (maintain progress visibility)
@@ -992,7 +1027,9 @@ class EnhancedMCPValidator:
         self._finalize_enhanced_validation_results(validation_results)
         return validation_results
 
-    def _validate_profile_with_drift_detection(self, profile: str, session: boto3.Session, runbooks_inventory: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    def _validate_profile_with_drift_detection(
+        self, profile: str, session: boto3.Session, runbooks_inventory: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
         """Enhanced validation with 3-way drift detection: runbooks vs API vs terraform."""
         try:
             # Get AWS account ID for terraform state correlation
@@ -1014,11 +1051,7 @@ class EnhancedMCPValidator:
 
             # Calculate 3-way accuracy and drift detection
             drift_result = self._calculate_drift_analysis(
-                runbooks_inventory_data, 
-                aws_inventory_data, 
-                terraform_data, 
-                profile,
-                account_id
+                runbooks_inventory_data, aws_inventory_data, terraform_data, profile, account_id
             )
             return drift_result
 
@@ -1031,10 +1064,12 @@ class EnhancedMCPValidator:
                 "error": str(e),
                 "validation_status": "ERROR",
                 "account_id": None,
-                "drift_analysis": {}
+                "drift_analysis": {},
             }
 
-    def _validate_profile_inventory_sync(self, profile: str, session: boto3.Session, runbooks_inventory: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    def _validate_profile_inventory_sync(
+        self, profile: str, session: boto3.Session, runbooks_inventory: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
         """Synchronous wrapper for profile inventory validation (for parallel execution)."""
         try:
             # Get independent resource counts from AWS API
@@ -1051,17 +1086,19 @@ class EnhancedMCPValidator:
             # Return None for failed validations (handled in calling function)
             return None
 
-    def _calculate_drift_analysis(self, runbooks_data: Dict, aws_data: Dict, terraform_data: Dict, profile: str, account_id: Optional[str]) -> Dict[str, Any]:
+    def _calculate_drift_analysis(
+        self, runbooks_data: Dict, aws_data: Dict, terraform_data: Dict, profile: str, account_id: Optional[str]
+    ) -> Dict[str, Any]:
         """
         Calculate comprehensive drift analysis between runbooks, AWS API, and terraform.
-        
+
         Args:
             runbooks_data: Inventory data from runbooks
             aws_data: Inventory data from AWS API
             terraform_data: Declared resources from terraform
             profile: Profile name for validation
             account_id: AWS account ID
-            
+
         Returns:
             Comprehensive drift analysis with accuracy metrics
         """
@@ -1073,7 +1110,7 @@ class EnhancedMCPValidator:
             resource_drift_analysis = {}
             total_variance = 0.0
             valid_comparisons = 0
-            
+
             # Analyze each resource type across all 3 sources
             for resource_type in self.supported_services.keys():
                 runbooks_count = runbooks_counts.get(resource_type, 0)
@@ -1084,10 +1121,10 @@ class EnhancedMCPValidator:
                 api_drift = abs(runbooks_count - aws_count) if runbooks_count > 0 or aws_count > 0 else 0
                 iac_drift = abs(aws_count - terraform_count) if aws_count > 0 or terraform_count > 0 else 0
                 total_drift = abs(runbooks_count - terraform_count) if runbooks_count > 0 or terraform_count > 0 else 0
-                
+
                 # Determine max count for percentage calculations
                 max_count = max(runbooks_count, aws_count, terraform_count)
-                
+
                 # Calculate accuracy percentages
                 if max_count == 0:
                     # All sources report zero - perfect alignment
@@ -1112,10 +1149,14 @@ class EnhancedMCPValidator:
                 recommendations = []
                 if iac_drift > 0:
                     if aws_count > terraform_count:
-                        recommendations.append(f"Consider updating terraform to declare {aws_count - terraform_count} additional {resource_type} resources")
+                        recommendations.append(
+                            f"Consider updating terraform to declare {aws_count - terraform_count} additional {resource_type} resources"
+                        )
                     elif terraform_count > aws_count:
-                        recommendations.append(f"Investigate {terraform_count - aws_count} terraform-declared {resource_type} resources not found in AWS")
-                
+                        recommendations.append(
+                            f"Investigate {terraform_count - aws_count} terraform-declared {resource_type} resources not found in AWS"
+                        )
+
                 if api_drift > 0:
                     recommendations.append(f"Review inventory collection accuracy for {resource_type} resources")
 
@@ -1131,12 +1172,12 @@ class EnhancedMCPValidator:
                     "overall_accuracy_percent": overall_accuracy,
                     "drift_status": drift_status,
                     "passed_validation": overall_accuracy >= self.validation_threshold,
-                    "recommendations": recommendations
+                    "recommendations": recommendations,
                 }
 
                 # Include in total variance calculation if any resources exist
                 if max_count > 0:
-                    total_variance += (100.0 - overall_accuracy)
+                    total_variance += 100.0 - overall_accuracy
                     valid_comparisons += 1
 
             # Calculate overall metrics
@@ -1146,15 +1187,20 @@ class EnhancedMCPValidator:
             # Generate account-level recommendations
             account_recommendations = []
             high_drift_resources = [
-                resource for resource, data in resource_drift_analysis.items()
+                resource
+                for resource, data in resource_drift_analysis.items()
                 if data["drift_status"] != "NO_DRIFT" and data["total_drift"] > 0
             ]
-            
+
             if high_drift_resources:
-                account_recommendations.append(f"Review terraform configuration for {len(high_drift_resources)} resource types with detected drift")
-            
+                account_recommendations.append(
+                    f"Review terraform configuration for {len(high_drift_resources)} resource types with detected drift"
+                )
+
             if terraform_data.get("files_parsed", 0) == 0:
-                account_recommendations.append("No terraform configuration found for this account - consider implementing Infrastructure as Code")
+                account_recommendations.append(
+                    "No terraform configuration found for this account - consider implementing Infrastructure as Code"
+                )
 
             return {
                 "profile": profile,
@@ -1171,9 +1217,12 @@ class EnhancedMCPValidator:
                     "total_resource_types": len(resource_drift_analysis),
                     "drift_detected": len(high_drift_resources),
                     "no_drift": len(resource_drift_analysis) - len(high_drift_resources),
-                    "highest_drift_resource": max(resource_drift_analysis.keys(), 
-                                                key=lambda x: resource_drift_analysis[x]["total_drift"]) if resource_drift_analysis else None
-                }
+                    "highest_drift_resource": max(
+                        resource_drift_analysis.keys(), key=lambda x: resource_drift_analysis[x]["total_drift"]
+                    )
+                    if resource_drift_analysis
+                    else None,
+                },
             }
 
         except Exception as e:
@@ -1184,7 +1233,7 @@ class EnhancedMCPValidator:
                 "passed_validation": False,
                 "error": str(e),
                 "validation_status": "ERROR",
-                "drift_analysis": {}
+                "drift_analysis": {},
             }
 
     async def _get_independent_inventory_data(self, session: boto3.Session, profile: str) -> Dict[str, Any]:
@@ -1204,10 +1253,10 @@ class EnhancedMCPValidator:
                 if session is None:
                     print_warning(f"Session not initialized for {profile}, using default profile")
                     session = boto3.Session(profile_name=profile)
-                
+
                 ec2_client = session.client("ec2", region_name="us-east-1")
                 regions_response = ec2_client.describe_regions()
-                regions = [region['RegionName'] for region in regions_response['Regions']]
+                regions = [region["RegionName"] for region in regions_response["Regions"]]
                 inventory_data["regions_discovered"] = regions
             except Exception as e:
                 print_warning(f"Could not discover regions for {profile}: {str(e)[:50]}")
@@ -1216,57 +1265,59 @@ class EnhancedMCPValidator:
 
             # Validate resource counts for each supported service
             resource_counts = {}
-            
+
             # EC2 Instances - Enhanced comprehensive discovery
             try:
                 total_ec2_instances = 0
                 successful_regions = 0
                 failed_regions = 0
-                
+
                 # Use all available regions for comprehensive coverage
                 for region in regions:
                     try:
                         ec2_client = session.client("ec2", region_name=region)
-                        
+
                         # Get all instances using pagination for large accounts
-                        paginator = ec2_client.get_paginator('describe_instances')
+                        paginator = ec2_client.get_paginator("describe_instances")
                         region_instances = 0
-                        
+
                         for page in paginator.paginate():
-                            for reservation in page.get('Reservations', []):
+                            for reservation in page.get("Reservations", []):
                                 # Count all instances regardless of state for accurate inventory
-                                instances = reservation.get('Instances', [])
+                                instances = reservation.get("Instances", [])
                                 region_instances += len(instances)
-                        
+
                         total_ec2_instances += region_instances
                         successful_regions += 1
-                        
+
                         # Log progress for debugging
                         if region_instances > 0:
                             self.console.log(f"[dim]  EC2 {region}: {region_instances} instances[/]")
-                        
+
                     except Exception as e:
                         failed_regions += 1
                         # Log specific errors for troubleshooting
                         if "UnauthorizedOperation" not in str(e):
                             self.console.log(f"[dim yellow]  EC2 {region}: Access denied or unavailable[/]")
-                
-                resource_counts['ec2'] = total_ec2_instances
-                
+
+                resource_counts["ec2"] = total_ec2_instances
+
                 # Track validation quality metrics
-                self.console.log(f"[dim]EC2 validation: {successful_regions} regions accessible, {failed_regions} failed[/]")
-                
+                self.console.log(
+                    f"[dim]EC2 validation: {successful_regions} regions accessible, {failed_regions} failed[/]"
+                )
+
             except Exception as e:
                 self.console.log(f"[red]EC2 validation failed: {str(e)[:50]}[/]")
-                resource_counts['ec2'] = 0
+                resource_counts["ec2"] = 0
 
             # S3 Buckets (global service)
             try:
                 s3_client = session.client("s3", region_name="us-east-1")
                 buckets_response = s3_client.list_buckets()
-                resource_counts['s3'] = len(buckets_response.get('Buckets', []))
+                resource_counts["s3"] = len(buckets_response.get("Buckets", []))
             except Exception:
-                resource_counts['s3'] = 0
+                resource_counts["s3"] = 0
 
             # RDS Instances - Enhanced comprehensive discovery
             try:
@@ -1274,23 +1325,23 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         rds_client = session.client("rds", region_name=region)
-                        
+
                         # Use pagination for large RDS deployments
-                        paginator = rds_client.get_paginator('describe_db_instances')
+                        paginator = rds_client.get_paginator("describe_db_instances")
                         region_instances = 0
-                        
+
                         for page in paginator.paginate():
-                            region_instances += len(page.get('DBInstances', []))
-                            
+                            region_instances += len(page.get("DBInstances", []))
+
                         total_rds_instances += region_instances
-                        
+
                         if region_instances > 0:
                             self.console.log(f"[dim]  RDS {region}: {region_instances} instances[/]")
                     except Exception:
                         continue
-                resource_counts['rds'] = total_rds_instances
+                resource_counts["rds"] = total_rds_instances
             except Exception:
-                resource_counts['rds'] = 0
+                resource_counts["rds"] = 0
 
             # Lambda Functions - Enhanced comprehensive discovery
             try:
@@ -1298,23 +1349,23 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         lambda_client = session.client("lambda", region_name=region)
-                        
+
                         # Use pagination for large Lambda deployments
-                        paginator = lambda_client.get_paginator('list_functions')
+                        paginator = lambda_client.get_paginator("list_functions")
                         region_functions = 0
-                        
+
                         for page in paginator.paginate():
-                            region_functions += len(page.get('Functions', []))
-                            
+                            region_functions += len(page.get("Functions", []))
+
                         total_lambda_functions += region_functions
-                        
+
                         if region_functions > 0:
                             self.console.log(f"[dim]  Lambda {region}: {region_functions} functions[/]")
                     except Exception:
                         continue
-                resource_counts['lambda'] = total_lambda_functions
+                resource_counts["lambda"] = total_lambda_functions
             except Exception:
-                resource_counts['lambda'] = 0
+                resource_counts["lambda"] = 0
 
             # VPCs - Enhanced comprehensive discovery
             try:
@@ -1322,43 +1373,43 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         ec2_client = session.client("ec2", region_name=region)
-                        
+
                         # Use pagination for VPC discovery
-                        paginator = ec2_client.get_paginator('describe_vpcs')
+                        paginator = ec2_client.get_paginator("describe_vpcs")
                         region_vpcs = 0
-                        
+
                         for page in paginator.paginate():
-                            region_vpcs += len(page.get('Vpcs', []))
-                            
+                            region_vpcs += len(page.get("Vpcs", []))
+
                         total_vpcs += region_vpcs
-                        
+
                         if region_vpcs > 0:
                             self.console.log(f"[dim]  VPC {region}: {region_vpcs} VPCs[/]")
                     except Exception:
                         continue
-                resource_counts['vpc'] = total_vpcs
+                resource_counts["vpc"] = total_vpcs
             except Exception:
-                resource_counts['vpc'] = 0
+                resource_counts["vpc"] = 0
 
             # IAM Roles (global service) - Enhanced discovery with pagination
             try:
                 iam_client = session.client("iam", region_name="us-east-1")
-                
+
                 # Use pagination for large IAM role deployments
-                paginator = iam_client.get_paginator('list_roles')
+                paginator = iam_client.get_paginator("list_roles")
                 total_roles = 0
-                
+
                 for page in paginator.paginate():
-                    total_roles += len(page.get('Roles', []))
-                
-                resource_counts['iam'] = total_roles
-                
+                    total_roles += len(page.get("Roles", []))
+
+                resource_counts["iam"] = total_roles
+
                 if total_roles > 0:
                     self.console.log(f"[dim]  IAM: {total_roles} roles discovered[/]")
-                    
+
             except Exception as e:
                 self.console.log(f"[yellow]IAM roles discovery failed: {str(e)[:40]}[/]")
-                resource_counts['iam'] = 0
+                resource_counts["iam"] = 0
 
             # CloudFormation Stacks - Enhanced comprehensive discovery
             try:
@@ -1366,67 +1417,69 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         cf_client = session.client("cloudformation", region_name=region)
-                        
+
                         # Use pagination for large CloudFormation deployments
-                        paginator = cf_client.get_paginator('list_stacks')
+                        paginator = cf_client.get_paginator("list_stacks")
                         region_stacks = 0
-                        
-                        for page in paginator.paginate(StackStatusFilter=['CREATE_COMPLETE', 'UPDATE_COMPLETE', 'ROLLBACK_COMPLETE']):
-                            region_stacks += len(page.get('StackSummaries', []))
-                            
+
+                        for page in paginator.paginate(
+                            StackStatusFilter=["CREATE_COMPLETE", "UPDATE_COMPLETE", "ROLLBACK_COMPLETE"]
+                        ):
+                            region_stacks += len(page.get("StackSummaries", []))
+
                         total_stacks += region_stacks
-                        
+
                         if region_stacks > 0:
                             self.console.log(f"[dim]  CloudFormation {region}: {region_stacks} stacks[/]")
                     except Exception:
                         continue
-                resource_counts['cloudformation'] = total_stacks
+                resource_counts["cloudformation"] = total_stacks
             except Exception:
-                resource_counts['cloudformation'] = 0
+                resource_counts["cloudformation"] = 0
 
-            # Load Balancers (ELBv2) - Enhanced comprehensive discovery  
+            # Load Balancers (ELBv2) - Enhanced comprehensive discovery
             try:
                 total_load_balancers = 0
                 for region in regions:
                     try:
                         elbv2_client = session.client("elbv2", region_name=region)
-                        
+
                         # Use pagination for large load balancer deployments
-                        paginator = elbv2_client.get_paginator('describe_load_balancers')
+                        paginator = elbv2_client.get_paginator("describe_load_balancers")
                         region_lbs = 0
-                        
+
                         for page in paginator.paginate():
-                            region_lbs += len(page.get('LoadBalancers', []))
-                            
+                            region_lbs += len(page.get("LoadBalancers", []))
+
                         total_load_balancers += region_lbs
-                        
+
                         if region_lbs > 0:
                             self.console.log(f"[dim]  ELBv2 {region}: {region_lbs} load balancers[/]")
                     except Exception:
                         continue
-                resource_counts['elbv2'] = total_load_balancers
+                resource_counts["elbv2"] = total_load_balancers
             except Exception:
-                resource_counts['elbv2'] = 0
+                resource_counts["elbv2"] = 0
 
             # Route53 Hosted Zones (global service) - Enhanced discovery
             try:
                 route53_client = session.client("route53", region_name="us-east-1")
-                
+
                 # Use pagination for large Route53 deployments
-                paginator = route53_client.get_paginator('list_hosted_zones')
+                paginator = route53_client.get_paginator("list_hosted_zones")
                 total_hosted_zones = 0
-                
+
                 for page in paginator.paginate():
-                    total_hosted_zones += len(page.get('HostedZones', []))
-                
-                resource_counts['route53'] = total_hosted_zones
-                
+                    total_hosted_zones += len(page.get("HostedZones", []))
+
+                resource_counts["route53"] = total_hosted_zones
+
                 if total_hosted_zones > 0:
                     self.console.log(f"[dim]  Route53: {total_hosted_zones} hosted zones[/]")
-                    
+
             except Exception as e:
                 self.console.log(f"[yellow]Route53 discovery failed: {str(e)[:40]}[/]")
-                resource_counts['route53'] = 0
+                resource_counts["route53"] = 0
 
             # SNS Topics - Enhanced comprehensive discovery
             try:
@@ -1434,23 +1487,23 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         sns_client = session.client("sns", region_name=region)
-                        
+
                         # Use pagination for large SNS deployments
-                        paginator = sns_client.get_paginator('list_topics')
+                        paginator = sns_client.get_paginator("list_topics")
                         region_topics = 0
-                        
+
                         for page in paginator.paginate():
-                            region_topics += len(page.get('Topics', []))
-                            
+                            region_topics += len(page.get("Topics", []))
+
                         total_topics += region_topics
-                        
+
                         if region_topics > 0:
                             self.console.log(f"[dim]  SNS {region}: {region_topics} topics[/]")
                     except Exception:
                         continue
-                resource_counts['sns'] = total_topics
+                resource_counts["sns"] = total_topics
             except Exception:
-                resource_counts['sns'] = 0
+                resource_counts["sns"] = 0
 
             # Network Interfaces (ENI) - Enhanced comprehensive discovery
             try:
@@ -1458,23 +1511,23 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         ec2_client = session.client("ec2", region_name=region)
-                        
+
                         # Use pagination for large ENI deployments
-                        paginator = ec2_client.get_paginator('describe_network_interfaces')
+                        paginator = ec2_client.get_paginator("describe_network_interfaces")
                         region_enis = 0
-                        
+
                         for page in paginator.paginate():
-                            region_enis += len(page.get('NetworkInterfaces', []))
-                            
+                            region_enis += len(page.get("NetworkInterfaces", []))
+
                         total_enis += region_enis
-                        
+
                         if region_enis > 0:
                             self.console.log(f"[dim]  ENI {region}: {region_enis} network interfaces[/]")
                     except Exception:
                         continue
-                resource_counts['eni'] = total_enis
+                resource_counts["eni"] = total_enis
             except Exception:
-                resource_counts['eni'] = 0
+                resource_counts["eni"] = 0
 
             # EBS Volumes - Enhanced comprehensive discovery
             try:
@@ -1482,23 +1535,23 @@ class EnhancedMCPValidator:
                 for region in regions:
                     try:
                         ec2_client = session.client("ec2", region_name=region)
-                        
+
                         # Use pagination for large EBS deployments
-                        paginator = ec2_client.get_paginator('describe_volumes')
+                        paginator = ec2_client.get_paginator("describe_volumes")
                         region_volumes = 0
-                        
+
                         for page in paginator.paginate():
-                            region_volumes += len(page.get('Volumes', []))
-                            
+                            region_volumes += len(page.get("Volumes", []))
+
                         total_volumes += region_volumes
-                        
+
                         if region_volumes > 0:
                             self.console.log(f"[dim]  EBS {region}: {region_volumes} volumes[/]")
                     except Exception:
                         continue
-                resource_counts['ebs'] = total_volumes
+                resource_counts["ebs"] = total_volumes
             except Exception:
-                resource_counts['ebs'] = 0
+                resource_counts["ebs"] = 0
 
             inventory_data["resource_counts"] = resource_counts
 
@@ -1516,11 +1569,11 @@ class EnhancedMCPValidator:
     def _extract_runbooks_inventory_data(self, runbooks_inventory: Dict[str, Any], profile: str) -> Dict[str, Any]:
         """
         Extract inventory data from runbooks results for comparison.
-        
+
         Args:
             runbooks_inventory: Inventory results from runbooks collection
             profile: Profile name for data extraction
-            
+
         Returns:
             Extracted inventory data in standardized format
         """
@@ -1534,13 +1587,13 @@ class EnhancedMCPValidator:
                 # Fallback: Look for direct resource keys (legacy format)
                 resource_counts = runbooks_inventory.get("resource_counts", {})
                 regions_discovered = runbooks_inventory.get("regions", [])
-            
+
             return {
                 "profile": profile,
                 "resource_counts": resource_counts,
                 "regions_discovered": regions_discovered,
                 "data_source": "runbooks_inventory_collection",
-                "extraction_method": "profile_nested" if profile in runbooks_inventory else "direct_keys"
+                "extraction_method": "profile_nested" if profile in runbooks_inventory else "direct_keys",
             }
         except Exception as e:
             self.console.log(f"[yellow]Warning: Error extracting runbooks inventory data for {profile}: {str(e)}[/]")
@@ -1549,18 +1602,18 @@ class EnhancedMCPValidator:
                 "resource_counts": {},
                 "regions_discovered": [],
                 "data_source": "runbooks_inventory_collection_error",
-                "error": str(e)
+                "error": str(e),
             }
 
     def _calculate_inventory_accuracy(self, runbooks_data: Dict, aws_data: Dict, profile: str) -> Dict[str, Any]:
         """
         Calculate accuracy between runbooks and AWS API inventory data.
-        
+
         Args:
             runbooks_data: Inventory data from runbooks
             aws_data: Inventory data from AWS API
             profile: Profile name for validation
-            
+
         Returns:
             Accuracy metrics with resource-level breakdown
         """
@@ -1583,11 +1636,15 @@ class EnhancedMCPValidator:
                 elif runbooks_count == 0 and aws_count > 0:
                     # Runbooks missing resources - accuracy issue
                     accuracy_percent = 0.0
-                    self.console.log(f"[red]⚠️  Profile {profile} {resource_type}: Runbooks shows 0 but MCP shows {aws_count}[/]")
+                    self.console.log(
+                        f"[red]⚠️  Profile {profile} {resource_type}: Runbooks shows 0 but MCP shows {aws_count}[/]"
+                    )
                 elif aws_count == 0 and runbooks_count > 0:
-                    # MCP missing data - moderate accuracy issue  
+                    # MCP missing data - moderate accuracy issue
                     accuracy_percent = 50.0  # Give partial credit as MCP may have different access
-                    self.console.log(f"[yellow]⚠️  Profile {profile} {resource_type}: MCP shows 0 but Runbooks shows {runbooks_count}[/]")
+                    self.console.log(
+                        f"[yellow]⚠️  Profile {profile} {resource_type}: MCP shows 0 but Runbooks shows {runbooks_count}[/]"
+                    )
                 else:
                     # Both have values - calculate variance-based accuracy
                     max_count = max(runbooks_count, aws_count)
@@ -1600,7 +1657,7 @@ class EnhancedMCPValidator:
                     "accuracy_percent": accuracy_percent,
                     "variance_count": abs(runbooks_count - aws_count),
                     "variance_percent": abs(runbooks_count - aws_count) / max(max(runbooks_count, aws_count), 1) * 100,
-                    "passed_validation": accuracy_percent >= self.validation_threshold
+                    "passed_validation": accuracy_percent >= self.validation_threshold,
                 }
 
                 if runbooks_count > 0 or aws_count > 0:  # Only count non-zero comparisons
@@ -1666,14 +1723,14 @@ class EnhancedMCPValidator:
                 "total_accounts": len(valid_results),
                 "accounts_with_drift": 0,
                 "resource_types_with_drift": set(),
-                "terraform_coverage": 0
+                "terraform_coverage": 0,
             }
-            
+
             for result in valid_results:
                 # Check if account has terraform coverage
                 if result.get("terraform_files_parsed", 0) > 0:
                     drift_summary["terraform_coverage"] += 1
-                    
+
                 # Collect drift analysis
                 has_drift = False
                 resource_drift = result.get("resource_drift_analysis", {})
@@ -1681,7 +1738,7 @@ class EnhancedMCPValidator:
                     if drift_data.get("drift_status", "NO_DRIFT") != "NO_DRIFT":
                         has_drift = True
                         drift_summary["resource_types_with_drift"].add(resource_type)
-                        
+
                     # Aggregate resource summary
                     if resource_type not in resource_summary:
                         resource_summary[resource_type] = {
@@ -1689,17 +1746,19 @@ class EnhancedMCPValidator:
                             "total_aws": 0,
                             "total_terraform": 0,
                             "accuracy_scores": [],
-                            "drift_incidents": 0
+                            "drift_incidents": 0,
                         }
-                    
+
                     resource_summary[resource_type]["total_runbooks"] += drift_data.get("runbooks_count", 0)
                     resource_summary[resource_type]["total_aws"] += drift_data.get("aws_api_count", 0)
                     resource_summary[resource_type]["total_terraform"] += drift_data.get("terraform_count", 0)
-                    resource_summary[resource_type]["accuracy_scores"].append(drift_data.get("overall_accuracy_percent", 0))
-                    
+                    resource_summary[resource_type]["accuracy_scores"].append(
+                        drift_data.get("overall_accuracy_percent", 0)
+                    )
+
                     if drift_data.get("drift_status", "NO_DRIFT") != "NO_DRIFT":
                         resource_summary[resource_type]["drift_incidents"] += 1
-                
+
                 if has_drift:
                     drift_summary["accounts_with_drift"] += 1
 
@@ -1714,10 +1773,16 @@ class EnhancedMCPValidator:
             validation_results["terraform_integration"]["drift_analysis"] = {
                 "total_accounts": drift_summary["total_accounts"],
                 "accounts_with_drift": drift_summary["accounts_with_drift"],
-                "drift_percentage": (drift_summary["accounts_with_drift"] / drift_summary["total_accounts"] * 100) if drift_summary["total_accounts"] > 0 else 0,
+                "drift_percentage": (drift_summary["accounts_with_drift"] / drift_summary["total_accounts"] * 100)
+                if drift_summary["total_accounts"] > 0
+                else 0,
                 "resource_types_with_drift": len(drift_summary["resource_types_with_drift"]),
                 "terraform_coverage_accounts": drift_summary["terraform_coverage"],
-                "terraform_coverage_percentage": (drift_summary["terraform_coverage"] / drift_summary["total_accounts"] * 100) if drift_summary["total_accounts"] > 0 else 0
+                "terraform_coverage_percentage": (
+                    drift_summary["terraform_coverage"] / drift_summary["total_accounts"] * 100
+                )
+                if drift_summary["total_accounts"] > 0
+                else 0,
             }
 
         # Display enhanced results with drift analysis
@@ -1745,11 +1810,7 @@ class EnhancedMCPValidator:
             for result in valid_results:
                 for resource_type, resource_data in result.get("resource_accuracies", {}).items():
                     if resource_type not in resource_summary:
-                        resource_summary[resource_type] = {
-                            "total_runbooks": 0,
-                            "total_aws": 0,
-                            "accuracy_scores": []
-                        }
+                        resource_summary[resource_type] = {"total_runbooks": 0, "total_aws": 0, "accuracy_scores": []}
                     resource_summary[resource_type]["total_runbooks"] += resource_data["runbooks_count"]
                     resource_summary[resource_type]["total_aws"] += resource_data["aws_api_count"]
                     resource_summary[resource_type]["accuracy_scores"].append(resource_data["accuracy_percent"])
@@ -1795,7 +1856,9 @@ class EnhancedMCPValidator:
                 color = "red"
 
             # Profile summary
-            self.console.print(f"[dim]  {profile[:30]}: {icon} [{color}]{accuracy:.1f}% accuracy[/] [dim]({category})[/][/dim]")
+            self.console.print(
+                f"[dim]  {profile[:30]}: {icon} [{color}]{accuracy:.1f}% accuracy[/] [dim]({category})[/][/dim]"
+            )
 
             # Resource-level breakdown
             resource_accuracies = profile_result.get("resource_accuracies", {})
@@ -1824,7 +1887,7 @@ class EnhancedMCPValidator:
                 avg_accuracy = summary.get("average_accuracy", 0)
                 total_runbooks = summary.get("total_runbooks", 0)
                 total_aws = summary.get("total_aws", 0)
-                
+
                 summary_icon = "✅" if avg_accuracy >= 99.5 else "⚠️" if avg_accuracy >= 90.0 else "❌"
                 self.console.print(
                     f"[dim]  {self.supported_services.get(resource_type, resource_type):20s}: {summary_icon} "
@@ -1838,21 +1901,23 @@ class EnhancedMCPValidator:
         terraform_integration = results.get("terraform_integration", {})
 
         self.console.print(f"\n[bright_cyan]🔍 Enhanced Inventory Validation with Drift Detection[/]")
-        
+
         # Display terraform integration status
         if terraform_integration.get("enabled", False):
             tf_files = terraform_integration.get("state_files_discovered", 0)
             drift_analysis = terraform_integration.get("drift_analysis", {})
-            
+
             self.console.print(f"[dim]🏗️  Terraform Integration: {tf_files} state files discovered[/]")
-            
+
             if drift_analysis:
                 total_accounts = drift_analysis.get("total_accounts", 0)
                 accounts_with_drift = drift_analysis.get("accounts_with_drift", 0)
                 drift_percentage = drift_analysis.get("drift_percentage", 0)
                 tf_coverage = drift_analysis.get("terraform_coverage_percentage", 0)
-                
-                self.console.print(f"[dim]📊 Drift Analysis: {accounts_with_drift}/{total_accounts} accounts ({drift_percentage:.1f}%) with detected drift[/]")
+
+                self.console.print(
+                    f"[dim]📊 Drift Analysis: {accounts_with_drift}/{total_accounts} accounts ({drift_percentage:.1f}%) with detected drift[/]"
+                )
                 self.console.print(f"[dim]🎯 IaC Coverage: {tf_coverage:.1f}% accounts have terraform configuration[/]")
 
         # Display per-profile results with enhanced drift breakdown
@@ -1877,7 +1942,7 @@ class EnhancedMCPValidator:
             # Profile summary with drift information
             drift_count = drift_summary.get("drift_detected", 0)
             total_resources = drift_summary.get("total_resource_types", 0)
-            
+
             self.console.print(f"[dim]  {profile[:30]} ({account_id}): {icon} [{color}]{accuracy:.1f}% accuracy[/]")
             if drift_count > 0:
                 self.console.print(f"[dim]    🔄 Drift detected in {drift_count}/{total_resources} resource types[/]")
@@ -1885,21 +1950,25 @@ class EnhancedMCPValidator:
             # Enhanced resource-level breakdown with 3-way comparison
             drift_analysis = profile_result.get("resource_drift_analysis", {})
             for resource_type, drift_data in drift_analysis.items():
-                if drift_data.get("runbooks_count", 0) > 0 or drift_data.get("aws_api_count", 0) > 0 or drift_data.get("terraform_count", 0) > 0:
+                if (
+                    drift_data.get("runbooks_count", 0) > 0
+                    or drift_data.get("aws_api_count", 0) > 0
+                    or drift_data.get("terraform_count", 0) > 0
+                ):
                     drift_status = drift_data.get("drift_status", "NO_DRIFT")
                     resource_icon = "✅" if drift_status == "NO_DRIFT" else "🔄" if "DRIFT" in drift_status else "⚠️"
-                    
+
                     runbooks_count = drift_data.get("runbooks_count", 0)
                     aws_count = drift_data.get("aws_api_count", 0)
                     terraform_count = drift_data.get("terraform_count", 0)
                     overall_acc = drift_data.get("overall_accuracy_percent", 0)
-                    
+
                     self.console.print(
                         f"[dim]    {self.supported_services.get(resource_type, resource_type):20s}: {resource_icon} "
                         f"Runbooks: {runbooks_count:3d} | AWS: {aws_count:3d} | Terraform: {terraform_count:3d} | "
                         f"Accuracy: {overall_acc:5.1f}%[/dim]"
                     )
-                    
+
                     # Show recommendations for drift
                     recommendations = drift_data.get("recommendations", [])
                     for rec in recommendations[:1]:  # Show first recommendation only
@@ -1915,34 +1984,33 @@ class EnhancedMCPValidator:
             print_success(f"✅ Enhanced Validation PASSED: {overall_accuracy:.1f}% accuracy achieved")
         else:
             print_warning(f"🔄 Enhanced Validation: {overall_accuracy:.1f}% accuracy with drift detected")
-            
+
         print_info(f"Enterprise compliance: {results.get('profiles_validated', 0)} profiles validated")
 
         # Enhanced resource validation summary with terraform comparison
         resource_summary = results.get("resource_validation_summary", {})
         if resource_summary:
             self.console.print(f"\n[bright_cyan]📊 Enhanced Resource Validation Summary[/]")
-            
+
             # Create drift analysis table
             drift_table = create_table(
-                title="Infrastructure Drift Analysis",
-                caption="3-way comparison: Runbooks | AWS API | Terraform IaC"
+                title="Infrastructure Drift Analysis", caption="3-way comparison: Runbooks | AWS API | Terraform IaC"
             )
-            
+
             drift_table.add_column("Resource Type", style="cyan", no_wrap=True)
             drift_table.add_column("Runbooks", style="green", justify="right")
             drift_table.add_column("AWS API", style="blue", justify="right")
             drift_table.add_column("Terraform", style="magenta", justify="right")
             drift_table.add_column("Accuracy", justify="right")
             drift_table.add_column("Drift Status", style="yellow")
-            
+
             for resource_type, summary in resource_summary.items():
                 avg_accuracy = summary.get("average_accuracy", 0)
                 total_runbooks = summary.get("total_runbooks", 0)
                 total_aws = summary.get("total_aws", 0)
                 total_terraform = summary.get("total_terraform", 0)
                 drift_incidents = summary.get("drift_incidents", 0)
-                
+
                 # Determine status
                 if drift_incidents > 0:
                     status = f"🔄 {drift_incidents} drift(s)"
@@ -1950,18 +2018,18 @@ class EnhancedMCPValidator:
                 else:
                     status = "✅ Aligned"
                     status_style = "green"
-                
+
                 accuracy_icon = "✅" if avg_accuracy >= 99.5 else "⚠️" if avg_accuracy >= 90.0 else "❌"
-                
+
                 drift_table.add_row(
                     self.supported_services.get(resource_type, resource_type),
                     str(total_runbooks),
                     str(total_aws),
                     str(total_terraform),
                     f"{accuracy_icon} {avg_accuracy:5.1f}%",
-                    status
+                    status,
                 )
-            
+
             self.console.print(drift_table)
 
     def validate_inventory_data(self, runbooks_inventory: Dict[str, Any]) -> Dict[str, Any]:
@@ -1974,74 +2042,76 @@ class EnhancedMCPValidator:
 
         return loop.run_until_complete(self.validate_inventory_data_async(runbooks_inventory))
 
-    def validate_resource_counts(self, resource_counts: Dict[str, int], profile: Optional[str] = None) -> Dict[str, Any]:
+    def validate_resource_counts(
+        self, resource_counts: Dict[str, int], profile: Optional[str] = None
+    ) -> Dict[str, Any]:
         """
         Cross-validate individual resource counts with AWS API.
-        
+
         Args:
             resource_counts: Dictionary of resource types to counts (e.g., {'ec2': 45, 's3': 12})
             profile: Profile to use for validation (uses first available if None)
-            
+
         Returns:
             Resource-level validation results
         """
         profile = profile or (self.profiles[0] if self.profiles else None)
         if not profile or profile not in self.aws_sessions:
-            return {'error': 'No valid profile for resource count validation'}
-        
+            return {"error": "No valid profile for resource count validation"}
+
         session_info = self.aws_sessions[profile]
         session = session_info["session"]  # Extract actual boto3.Session object
         validations = {}
-        
+
         # Get MCP resource counts
         try:
             mcp_data = asyncio.run(self._get_independent_inventory_data(session, profile))
-            mcp_counts = mcp_data.get('resource_counts', {})
-            
+            mcp_counts = mcp_data.get("resource_counts", {})
+
             # Validate each resource type
             for resource_type, runbooks_count in resource_counts.items():
                 if resource_type in self.supported_services:
                     mcp_count = mcp_counts.get(resource_type, 0)
-                    
+
                     variance = 0.0
                     if runbooks_count > 0:
                         variance = abs(runbooks_count - mcp_count) / runbooks_count * 100
-                    
+
                     validations[resource_type] = {
-                        'runbooks_count': runbooks_count,
-                        'mcp_count': mcp_count,
-                        'variance_percent': variance,
-                        'passed': variance <= self.tolerance_percent,
-                        'status': 'PASSED' if variance <= self.tolerance_percent else 'VARIANCE'
+                        "runbooks_count": runbooks_count,
+                        "mcp_count": mcp_count,
+                        "variance_percent": variance,
+                        "passed": variance <= self.tolerance_percent,
+                        "status": "PASSED" if variance <= self.tolerance_percent else "VARIANCE",
                     }
-            
+
             # Display resource validation results
             self._display_resource_count_validation(validations)
-            
+
         except Exception as e:
             print_error(f"Resource count validation failed: {str(e)[:50]}")
-            return {'error': str(e)}
-        
+            return {"error": str(e)}
+
         return {
-            'resources': validations,
-            'validated_count': len(validations),
-            'passed_count': sum(1 for v in validations.values() if v['passed']),
-            'timestamp': datetime.now().isoformat()
+            "resources": validations,
+            "validated_count": len(validations),
+            "passed_count": sum(1 for v in validations.values() if v["passed"]),
+            "timestamp": datetime.now().isoformat(),
         }
-    
+
     def _display_resource_count_validation(self, validations: Dict[str, Dict]) -> None:
         """Display resource count validation results."""
         if validations:
             self.console.print("\n[bright_cyan]Resource Count MCP Validation:[/bright_cyan]")
-            
+
             for resource_type, validation in validations.items():
-                if validation['passed']:
+                if validation["passed"]:
                     icon = "✅"
                     color = "green"
                 else:
                     icon = "⚠️"
                     color = "yellow"
-                
+
                 resource_name = self.supported_services.get(resource_type, resource_type)
                 self.console.print(
                     f"[dim]  {resource_name:20s}: {icon} [{color}]"
@@ -2050,30 +2120,38 @@ class EnhancedMCPValidator:
                 )
 
 
-def create_enhanced_mcp_validator(user_profile: Optional[str] = None, console: Optional[Console] = None, 
-                                 mcp_config_path: Optional[str] = None, terraform_directory: Optional[str] = None) -> EnhancedMCPValidator:
+def create_enhanced_mcp_validator(
+    user_profile: Optional[str] = None,
+    console: Optional[Console] = None,
+    mcp_config_path: Optional[str] = None,
+    terraform_directory: Optional[str] = None,
+) -> EnhancedMCPValidator:
     """
     Factory function to create enhanced MCP validator with real server integration.
-    
+
     Args:
         user_profile: User-specified profile (--profile parameter) - takes priority
         console: Rich console for output
         mcp_config_path: Path to .mcp.json configuration file
         terraform_directory: Path to terraform configurations
-        
+
     Returns:
         Enhanced MCP validator instance
     """
     return EnhancedMCPValidator(
-        user_profile=user_profile, 
-        console=console, 
+        user_profile=user_profile,
+        console=console,
         mcp_config_path=mcp_config_path,
-        terraform_directory=terraform_directory
+        terraform_directory=terraform_directory,
     )
 
 
-def validate_inventory_with_mcp_servers(runbooks_inventory: Dict[str, Any], user_profile: Optional[str] = None,
-                                      mcp_config_path: Optional[str] = None, terraform_directory: Optional[str] = None) -> Dict[str, Any]:
+def validate_inventory_with_mcp_servers(
+    runbooks_inventory: Dict[str, Any],
+    user_profile: Optional[str] = None,
+    mcp_config_path: Optional[str] = None,
+    terraform_directory: Optional[str] = None,
+) -> Dict[str, Any]:
     """
     Enhanced convenience function to validate inventory results using real MCP servers.
 
@@ -2087,42 +2165,50 @@ def validate_inventory_with_mcp_servers(runbooks_inventory: Dict[str, Any], user
         Enhanced validation results with MCP server integration and drift detection
     """
     validator = create_enhanced_mcp_validator(
-        user_profile=user_profile,
-        mcp_config_path=mcp_config_path, 
-        terraform_directory=terraform_directory
+        user_profile=user_profile, mcp_config_path=mcp_config_path, terraform_directory=terraform_directory
     )
     return asyncio.run(validator.validate_with_mcp_servers(runbooks_inventory))
 
 
 # Legacy compatibility - maintain backward compatibility with existing code
-def create_inventory_mcp_validator(profiles: List[str], console: Optional[Console] = None, terraform_directory: Optional[str] = None) -> EnhancedMCPValidator:
+def create_inventory_mcp_validator(
+    profiles: List[str], console: Optional[Console] = None, terraform_directory: Optional[str] = None
+) -> EnhancedMCPValidator:
     """Legacy compatibility function for existing code."""
     # Convert profile list to single user profile (use first profile)
     user_profile = profiles[0] if profiles else None
-    return create_enhanced_mcp_validator(user_profile=user_profile, console=console, terraform_directory=terraform_directory)
+    return create_enhanced_mcp_validator(
+        user_profile=user_profile, console=console, terraform_directory=terraform_directory
+    )
 
 
-def validate_inventory_results_with_mcp(profiles: List[str], runbooks_inventory: Dict[str, Any], terraform_directory: Optional[str] = None) -> Dict[str, Any]:
+def validate_inventory_results_with_mcp(
+    profiles: List[str], runbooks_inventory: Dict[str, Any], terraform_directory: Optional[str] = None
+) -> Dict[str, Any]:
     """Legacy compatibility function for existing code."""
     user_profile = profiles[0] if profiles else None
-    return validate_inventory_with_mcp_servers(runbooks_inventory, user_profile=user_profile, terraform_directory=terraform_directory)
+    return validate_inventory_with_mcp_servers(
+        runbooks_inventory, user_profile=user_profile, terraform_directory=terraform_directory
+    )
 
 
-def generate_drift_report(profiles: List[str], runbooks_inventory: Dict[str, Any], terraform_directory: Optional[str] = None) -> Dict[str, Any]:
+def generate_drift_report(
+    profiles: List[str], runbooks_inventory: Dict[str, Any], terraform_directory: Optional[str] = None
+) -> Dict[str, Any]:
     """
     Generate comprehensive infrastructure drift report.
-    
+
     Args:
         profiles: List of AWS profiles to analyze
         runbooks_inventory: Inventory results from runbooks collection
         terraform_directory: Path to terraform configurations
-        
+
     Returns:
         Comprehensive drift analysis report with recommendations
     """
     validator = create_inventory_mcp_validator(profiles, terraform_directory=terraform_directory)
     validation_results = validator.validate_inventory_data(runbooks_inventory)
-    
+
     # Extract drift-specific information for reporting
     drift_report = {
         "report_type": "infrastructure_drift_analysis",
@@ -2131,9 +2217,9 @@ def generate_drift_report(profiles: List[str], runbooks_inventory: Dict[str, Any
         "accounts_analyzed": validation_results.get("profiles_validated", 0),
         "overall_accuracy": validation_results.get("total_accuracy", 0),
         "drift_detected": not validation_results.get("passed_validation", False),
-        "detailed_analysis": []
+        "detailed_analysis": [],
     }
-    
+
     # Add detailed per-account drift analysis
     for profile_result in validation_results.get("profile_results", []):
         account_drift = {
@@ -2143,8 +2229,8 @@ def generate_drift_report(profiles: List[str], runbooks_inventory: Dict[str, Any
             "drift_summary": profile_result.get("drift_summary", {}),
             "terraform_coverage": profile_result.get("terraform_files_parsed", 0) > 0,
             "recommendations": profile_result.get("account_recommendations", []),
-            "resource_drift_details": profile_result.get("resource_drift_analysis", {})
+            "resource_drift_details": profile_result.get("resource_drift_analysis", {}),
         }
         drift_report["detailed_analysis"].append(account_drift)
-    
-    return drift_report
+
+    return drift_report