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

runbooks/validation/terraform_drift_detector.py

@@ -37,34 +37,48 @@ import tempfile
 import asyncio
 
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_progress_bar, format_cost, create_panel
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_progress_bar,
+    format_cost,
+    create_panel,
 )
 from runbooks.common.mcp_integration import EnterpriseMCPIntegrator
 from runbooks.common.profile_utils import get_profile_for_operation, create_cost_session
 from runbooks.finops.cost_processor import DualMetricCostProcessor
 
-@dataclass 
+
+@dataclass
 class TerraformResource:
     """Terraform resource representation."""
+
     resource_type: str
     resource_name: str
     resource_id: str
     resource_attributes: Dict[str, Any]
     terraform_address: str
-    
+
+
 @dataclass
 class RunbooksResource:
     """Runbooks discovered resource representation."""
+
     resource_type: str
     resource_id: str
     resource_attributes: Dict[str, Any]
     discovery_module: str
     discovery_timestamp: str
 
+
 @dataclass
 class CostCorrelation:
     """Cost correlation data for drift analysis."""
+
     resource_id: str
     monthly_cost: float
     yearly_cost_estimate: float
@@ -73,9 +87,11 @@ class CostCorrelation:
     service_category: str
     cost_center: Optional[str] = None
 
-@dataclass  
+
+@dataclass
 class DriftAnalysis:
     """Infrastructure drift analysis result with cost correlation."""
+
     resource_id: str
     resource_type: str
     drift_type: str  # 'missing_from_terraform', 'missing_from_runbooks', 'configuration_drift'
@@ -87,33 +103,35 @@ class DriftAnalysis:
     risk_level: str
     cost_correlation: Optional[CostCorrelation] = None
 
+
 @dataclass
 class TerraformDriftResult:
     """Complete terraform drift detection result with cost correlation."""
+
     drift_detection_id: str
     detection_timestamp: datetime
     terraform_state_path: str
     runbooks_evidence_path: str
-    
+
     # Drift metrics
     total_resources_terraform: int
     total_resources_runbooks: int
     resources_in_sync: int
     resources_with_drift: int
     drift_percentage: float
-    
+
     # Cost correlation metrics
     total_monthly_cost_impact: float
     high_cost_drifts: int
     cost_correlation_coverage: float
     mcp_validation_accuracy: float
-    
+
     # Detailed analysis
     drift_analysis: List[DriftAnalysis]
     missing_from_terraform: List[str]
     missing_from_runbooks: List[str]
     configuration_drifts: List[str]
-    
+
     # Business assessment
     overall_risk_level: str
     compliance_impact: str
@@ -121,19 +139,20 @@ class TerraformDriftResult:
     estimated_remediation_effort: str
     cost_optimization_potential: str
 
+
 class TerraformDriftDetector:
     """
     Enhanced terraform drift detector with cost correlation and MCP validation.
-    
+
     Compares runbooks resource discoveries with terraform state to identify
     infrastructure drift, missing resources, and configuration discrepancies.
     Includes cost correlation analysis and MCP cross-validation for enterprise accuracy.
     """
-    
+
     def __init__(self, terraform_state_dir: Optional[str] = None, user_profile: Optional[str] = None):
         """
         Initialize enhanced terraform drift detector.
-        
+
         Args:
             terraform_state_dir: Directory containing terraform state files
             user_profile: AWS profile for cost analysis and MCP validation
@@ -142,21 +161,21 @@ class TerraformDriftDetector:
         self.drift_evidence_dir = Path("validation-evidence") / "terraform-drift"
         self.drift_evidence_dir.mkdir(parents=True, exist_ok=True)
         self.user_profile = user_profile
-        
+
         # Initialize cost processor and MCP integrator
         billing_profile = get_profile_for_operation("billing", user_profile)
         try:
-            self.cost_session = create_cost_session(billing_profile)
+            self.cost_session = create_cost_session(profile_name=billing_profile)
             self.cost_processor = DualMetricCostProcessor(self.cost_session, billing_profile)
             print_success(f"💰 Cost Explorer integration initialized: {billing_profile}")
         except Exception as e:
             print_warning(f"Cost Explorer integration limited: {str(e)[:50]}...")
             self.cost_session = None
             self.cost_processor = None
-        
+
         # Initialize MCP integration for cross-validation
         self.mcp_integrator = EnterpriseMCPIntegrator(user_profile)
-        
+
         print_header("Enhanced Terraform Drift Detector", "2.0.0")
         print_info(f"🏗️ Terraform State Directory: {self.terraform_state_dir}")
         print_info(f"📊 Drift Evidence Directory: {self.drift_evidence_dir}")
@@ -168,31 +187,31 @@ class TerraformDriftDetector:
         runbooks_evidence_file: str,
         terraform_state_file: Optional[str] = None,
         resource_types: Optional[List[str]] = None,
-        enable_cost_correlation: bool = True
+        enable_cost_correlation: bool = True,
     ) -> TerraformDriftResult:
         """
         Detect infrastructure drift between runbooks and terraform with cost correlation.
-        
+
         Args:
             runbooks_evidence_file: Path to runbooks evidence file
             terraform_state_file: Path to terraform state file (optional)
             resource_types: Specific resource types to analyze (optional)
             enable_cost_correlation: Enable cost correlation analysis (default: True)
-            
+
         Returns:
             Complete drift detection results with cost impact analysis
         """
         detection_start = datetime.now()
         drift_id = f"drift_{detection_start.strftime('%Y%m%d_%H%M%S')}"
-        
+
         print_info(f"🔍 Detecting infrastructure drift: {drift_id}")
         print_info(f"📄 Runbooks evidence: {Path(runbooks_evidence_file).name}")
-        
+
         try:
             # Load runbooks evidence
             runbooks_resources = self._load_runbooks_evidence(runbooks_evidence_file)
             print_success(f"📋 Runbooks resources loaded: {len(runbooks_resources)}")
-            
+
             # Load terraform state
             if terraform_state_file and Path(terraform_state_file).exists():
                 terraform_resources = self._load_terraform_state(terraform_state_file)
@@ -207,36 +226,47 @@ class TerraformDriftDetector:
                     # Generate mock terraform state for demonstration
                     terraform_resources = self._generate_mock_terraform_state(runbooks_resources)
                     state_source = "generated_for_demonstration"
-            
+
             print_success(f"🏗️ Terraform resources loaded: {len(terraform_resources)}")
-            
+
             # Perform drift analysis
             drift_analysis = await self._analyze_infrastructure_drift(
                 runbooks_resources, terraform_resources, resource_types, enable_cost_correlation
             )
-            
+
             # Cost correlation analysis
             cost_metrics = await self._calculate_cost_correlation_metrics(drift_analysis)
-            
+
             # MCP validation for enhanced accuracy
-            mcp_validation_result = await self._perform_mcp_validation(drift_analysis, runbooks_resources, terraform_resources)
-            
+            mcp_validation_result = await self._perform_mcp_validation(
+                drift_analysis, runbooks_resources, terraform_resources
+            )
+
+            # CRITICAL: Enforce quality gate - block on <99.5% accuracy
+            accuracy_score = mcp_validation_result.get("accuracy_score", 0.0)
+            if accuracy_score < 99.5:
+                error_msg = f"MCP validation accuracy {accuracy_score:.1f}% below required threshold 99.5%"
+                console.print(f"[red]❌ MCP Validation FAILED: {accuracy_score:.1f}% < 99.5% required[/red]")
+                raise ValueError(error_msg)
+
+            console.print(f"[green]✅ MCP Validation PASSED: {accuracy_score:.1f}% ≥ 99.5% required[/green]")
+
             # Calculate metrics
             total_tf = len(terraform_resources)
             total_rb = len(runbooks_resources)
             drifts_found = len(drift_analysis)
             resources_in_sync = max(0, min(total_tf, total_rb) - drifts_found)
             drift_percentage = (drifts_found / max(total_tf, total_rb) * 100) if max(total_tf, total_rb) > 0 else 0
-            
+
             # Business impact assessment
             overall_risk = self._assess_overall_risk(drift_analysis, drift_percentage)
             compliance_impact = self._assess_compliance_impact(drift_analysis)
             remediation_priority = self._assess_remediation_priority(drift_analysis, overall_risk)
             remediation_effort = self._estimate_remediation_effort(drift_analysis)
-            
+
             # Generate cost optimization assessment
             cost_optimization_potential = self._assess_cost_optimization_potential(drift_analysis, cost_metrics)
-            
+
             drift_result = TerraformDriftResult(
                 drift_detection_id=drift_id,
                 detection_timestamp=detection_start,
@@ -248,30 +278,34 @@ class TerraformDriftDetector:
                 resources_with_drift=drifts_found,
                 drift_percentage=drift_percentage,
                 # Cost correlation metrics
-                total_monthly_cost_impact=cost_metrics.get('total_monthly_cost', 0.0),
-                high_cost_drifts=cost_metrics.get('high_cost_drifts', 0),
-                cost_correlation_coverage=cost_metrics.get('correlation_coverage', 0.0),
-                mcp_validation_accuracy=mcp_validation_result.get('accuracy_score', 95.0),
+                total_monthly_cost_impact=cost_metrics.get("total_monthly_cost", 0.0),
+                high_cost_drifts=cost_metrics.get("high_cost_drifts", 0),
+                cost_correlation_coverage=cost_metrics.get("correlation_coverage", 0.0),
+                mcp_validation_accuracy=mcp_validation_result.get("accuracy_score", 0.0),  # Pessimistic default
                 # Analysis details
                 drift_analysis=drift_analysis,
-                missing_from_terraform=[d.resource_id for d in drift_analysis if d.drift_type == 'missing_from_terraform'],
-                missing_from_runbooks=[d.resource_id for d in drift_analysis if d.drift_type == 'missing_from_runbooks'],
-                configuration_drifts=[d.resource_id for d in drift_analysis if d.drift_type == 'configuration_drift'],
+                missing_from_terraform=[
+                    d.resource_id for d in drift_analysis if d.drift_type == "missing_from_terraform"
+                ],
+                missing_from_runbooks=[
+                    d.resource_id for d in drift_analysis if d.drift_type == "missing_from_runbooks"
+                ],
+                configuration_drifts=[d.resource_id for d in drift_analysis if d.drift_type == "configuration_drift"],
                 overall_risk_level=overall_risk,
                 compliance_impact=compliance_impact,
                 remediation_priority=remediation_priority,
                 estimated_remediation_effort=remediation_effort,
-                cost_optimization_potential=cost_optimization_potential
+                cost_optimization_potential=cost_optimization_potential,
             )
-            
+
             # Display results
             self._display_drift_results(drift_result)
-            
+
             # Generate evidence
             evidence_file = self._generate_drift_evidence(drift_result)
-            
+
             return drift_result
-            
+
         except Exception as e:
             print_error(f"❌ Drift detection failed: {str(e)}")
             raise
@@ -279,152 +313,162 @@ class TerraformDriftDetector:
     def _load_runbooks_evidence(self, evidence_file: str) -> List[RunbooksResource]:
         """Load runbooks evidence file and extract resources."""
         resources = []
-        
+
         try:
             evidence_path = Path(evidence_file)
-            
-            if evidence_path.suffix == '.json':
-                with open(evidence_path, 'r') as f:
+
+            if evidence_path.suffix == ".json":
+                with open(evidence_path, "r") as f:
                     data = json.load(f)
-                
+
                 # Handle different evidence file formats
-                if 'vpc_details' in data:
+                if "vpc_details" in data:
                     # VPC discovery format
-                    for vpc in data.get('vpc_details', []):
-                        resources.append(RunbooksResource(
-                            resource_type='aws_vpc',
-                            resource_id=vpc.get('VpcId', ''),
-                            resource_attributes=vpc,
-                            discovery_module='vpc',
-                            discovery_timestamp=data.get('timestamp', '')
-                        ))
-                        
+                    for vpc in data.get("vpc_details", []):
+                        resources.append(
+                            RunbooksResource(
+                                resource_type="aws_vpc",
+                                resource_id=vpc.get("VpcId", ""),
+                                resource_attributes=vpc,
+                                discovery_module="vpc",
+                                discovery_timestamp=data.get("timestamp", ""),
+                            )
+                        )
+
                         # Add subnets
-                        for subnet in vpc.get('Subnets', []):
-                            resources.append(RunbooksResource(
-                                resource_type='aws_subnet',
-                                resource_id=subnet.get('SubnetId', ''),
-                                resource_attributes=subnet,
-                                discovery_module='vpc',
-                                discovery_timestamp=data.get('timestamp', '')
-                            ))
-                
-                elif 'services' in data:
-                    # Inventory discovery format  
-                    for service_name, service_data in data.get('services', {}).items():
+                        for subnet in vpc.get("Subnets", []):
+                            resources.append(
+                                RunbooksResource(
+                                    resource_type="aws_subnet",
+                                    resource_id=subnet.get("SubnetId", ""),
+                                    resource_attributes=subnet,
+                                    discovery_module="vpc",
+                                    discovery_timestamp=data.get("timestamp", ""),
+                                )
+                            )
+
+                elif "services" in data:
+                    # Inventory discovery format
+                    for service_name, service_data in data.get("services", {}).items():
                         if isinstance(service_data, list):
                             for resource in service_data:
-                                resources.append(RunbooksResource(
-                                    resource_type=f'aws_{service_name.lower()}',
-                                    resource_id=resource.get('id', resource.get('Id', '')),
-                                    resource_attributes=resource,
-                                    discovery_module='inventory',
-                                    discovery_timestamp=data.get('timestamp', '')
-                                ))
-                
-                elif 'cost_breakdown' in data:
+                                resources.append(
+                                    RunbooksResource(
+                                        resource_type=f"aws_{service_name.lower()}",
+                                        resource_id=resource.get("id", resource.get("Id", "")),
+                                        resource_attributes=resource,
+                                        discovery_module="inventory",
+                                        discovery_timestamp=data.get("timestamp", ""),
+                                    )
+                                )
+
+                elif "cost_breakdown" in data:
                     # FinOps discovery format - extract service usage
-                    for service in data.get('cost_breakdown', []):
-                        resources.append(RunbooksResource(
-                            resource_type=f"aws_{service.get('Service', 'unknown').lower().replace(' ', '_')}",
-                            resource_id=f"{service.get('Account', 'unknown')}_{service.get('Service', 'unknown')}",
-                            resource_attributes=service,
-                            discovery_module='finops',
-                            discovery_timestamp=data.get('timestamp', '')
-                        ))
-            
-            elif evidence_path.suffix == '.csv':
+                    for service in data.get("cost_breakdown", []):
+                        resources.append(
+                            RunbooksResource(
+                                resource_type=f"aws_{service.get('Service', 'unknown').lower().replace(' ', '_')}",
+                                resource_id=f"{service.get('Account', 'unknown')}_{service.get('Service', 'unknown')}",
+                                resource_attributes=service,
+                                discovery_module="finops",
+                                discovery_timestamp=data.get("timestamp", ""),
+                            )
+                        )
+
+            elif evidence_path.suffix == ".csv":
                 # Handle CSV inventory format
                 import csv
-                with open(evidence_path, 'r') as f:
+
+                with open(evidence_path, "r") as f:
                     csv_reader = csv.DictReader(f)
                     for row in csv_reader:
-                        resources.append(RunbooksResource(
-                            resource_type=row.get('Resource Type', '').lower().replace(' ', '_'),
-                            resource_id=row.get('Resource ID', ''),
-                            resource_attributes=dict(row),
-                            discovery_module='inventory_csv',
-                            discovery_timestamp=datetime.now().isoformat()
-                        ))
-        
+                        resources.append(
+                            RunbooksResource(
+                                resource_type=row.get("Resource Type", "").lower().replace(" ", "_"),
+                                resource_id=row.get("Resource ID", ""),
+                                resource_attributes=dict(row),
+                                discovery_module="inventory_csv",
+                                discovery_timestamp=datetime.now().isoformat(),
+                            )
+                        )
+
         except Exception as e:
             print_warning(f"Error loading runbooks evidence: {e}")
             # Return minimal resource list for demonstration
             resources = [
                 RunbooksResource(
-                    resource_type='aws_vpc',
-                    resource_id='vpc-demo123',
-                    resource_attributes={'State': 'available'},
-                    discovery_module='runbooks_discovery',
-                    discovery_timestamp=datetime.now().isoformat()
+                    resource_type="aws_vpc",
+                    resource_id="vpc-demo123",
+                    resource_attributes={"State": "available"},
+                    discovery_module="runbooks_discovery",
+                    discovery_timestamp=datetime.now().isoformat(),
                 )
             ]
-        
+
         return resources
 
     def _discover_terraform_state(self) -> Optional[str]:
         """Attempt to discover terraform state files."""
         if not self.terraform_state_dir.exists():
             return None
-            
+
         # Look for common terraform state files
-        state_patterns = [
-            "terraform.tfstate",
-            "*.tfstate",
-            "terraform.tfstate.backup",
-            ".terraform/terraform.tfstate"
-        ]
-        
+        state_patterns = ["terraform.tfstate", "*.tfstate", "terraform.tfstate.backup", ".terraform/terraform.tfstate"]
+
         for pattern in state_patterns:
             state_files = list(self.terraform_state_dir.glob(pattern))
             if state_files and state_files[0].stat().st_size > 0:
                 print_info(f"📄 Discovered terraform state: {state_files[0].name}")
                 return str(state_files[0])
-        
+
         return None
 
     def _load_terraform_state(self, state_file: str) -> List[TerraformResource]:
         """Load terraform state file and extract resources."""
         resources = []
-        
+
         try:
-            with open(state_file, 'r') as f:
+            with open(state_file, "r") as f:
                 state_data = json.load(f)
-            
+
             # Extract resources from terraform state format
-            for resource in state_data.get('resources', []):
-                for instance in resource.get('instances', []):
-                    resources.append(TerraformResource(
-                        resource_type=resource.get('type', ''),
-                        resource_name=resource.get('name', ''),
-                        resource_id=instance.get('attributes', {}).get('id', ''),
-                        resource_attributes=instance.get('attributes', {}),
-                        terraform_address=f"{resource.get('type', '')}.{resource.get('name', '')}"
-                    ))
-        
+            for resource in state_data.get("resources", []):
+                for instance in resource.get("instances", []):
+                    resources.append(
+                        TerraformResource(
+                            resource_type=resource.get("type", ""),
+                            resource_name=resource.get("name", ""),
+                            resource_id=instance.get("attributes", {}).get("id", ""),
+                            resource_attributes=instance.get("attributes", {}),
+                            terraform_address=f"{resource.get('type', '')}.{resource.get('name', '')}",
+                        )
+                    )
+
         except Exception as e:
             print_warning(f"Error loading terraform state: {e}")
-        
+
         return resources
 
     def _generate_mock_terraform_state(self, runbooks_resources: List[RunbooksResource]) -> List[TerraformResource]:
         """Generate mock terraform state for demonstration."""
         print_info("🏗️ Generating mock terraform state for drift detection demo...")
-        
+
         terraform_resources = []
-        
+
         # Create terraform resources based on runbooks discoveries
         for rb_resource in runbooks_resources:
             # Simulate some resources being in terraform
             if hash(rb_resource.resource_id) % 3 != 0:  # ~67% of resources in terraform
-                terraform_resources.append(TerraformResource(
-                    resource_type=rb_resource.resource_type,
-                    resource_name=f"{rb_resource.resource_type}_managed",
-                    resource_id=rb_resource.resource_id,
-                    resource_attributes=rb_resource.resource_attributes.copy(),
-                    terraform_address=f"{rb_resource.resource_type}.managed_{rb_resource.resource_id.replace('-', '_')}"
-                ))
-        
+                terraform_resources.append(
+                    TerraformResource(
+                        resource_type=rb_resource.resource_type,
+                        resource_name=f"{rb_resource.resource_type}_managed",
+                        resource_id=rb_resource.resource_id,
+                        resource_attributes=rb_resource.resource_attributes.copy(),
+                        terraform_address=f"{rb_resource.resource_type}.managed_{rb_resource.resource_id.replace('-', '_')}",
+                    )
+                )
+
         # Add some terraform-only resources to simulate drift
         terraform_only_resources = [
             TerraformResource(
@@ -432,17 +476,17 @@ class TerraformDriftDetector:
                 resource_name="terraform_managed_bucket",
                 resource_id="terraform-managed-bucket-123",
                 resource_attributes={"bucket": "terraform-managed-bucket-123", "versioning": {"enabled": True}},
-                terraform_address="aws_s3_bucket.terraform_managed_bucket"
+                terraform_address="aws_s3_bucket.terraform_managed_bucket",
             ),
             TerraformResource(
                 resource_type="aws_security_group",
                 resource_name="terraform_managed_sg",
                 resource_id="sg-terraform123",
                 resource_attributes={"name": "terraform-managed-sg", "description": "Managed by terraform"},
-                terraform_address="aws_security_group.terraform_managed_sg"
-            )
+                terraform_address="aws_security_group.terraform_managed_sg",
+            ),
         ]
-        
+
         terraform_resources.extend(terraform_only_resources)
         return terraform_resources
 
@@ -451,140 +495,148 @@ class TerraformDriftDetector:
         runbooks_resources: List[RunbooksResource],
         terraform_resources: List[TerraformResource],
         resource_types: Optional[List[str]] = None,
-        enable_cost_correlation: bool = True
+        enable_cost_correlation: bool = True,
     ) -> List[DriftAnalysis]:
         """Analyze infrastructure drift between runbooks and terraform."""
         drift_analyses = []
-        
+
         # Create lookup maps
         rb_by_id = {r.resource_id: r for r in runbooks_resources}
         tf_by_id = {r.resource_id: r for r in terraform_resources}
-        
+
         all_resource_ids = set(rb_by_id.keys()) | set(tf_by_id.keys())
-        
+
         print_info(f"🔍 Analyzing {len(all_resource_ids)} unique resources for drift...")
-        
+
         for resource_id in all_resource_ids:
             rb_resource = rb_by_id.get(resource_id)
             tf_resource = tf_by_id.get(resource_id)
-            
+
             # Filter by resource types if specified
             if resource_types:
-                resource_type = (rb_resource.resource_type if rb_resource else tf_resource.resource_type)
+                resource_type = rb_resource.resource_type if rb_resource else tf_resource.resource_type
                 if resource_type not in resource_types:
                     continue
-            
+
             if rb_resource and not tf_resource:
                 # Missing from terraform
-                drift_analyses.append(DriftAnalysis(
-                    resource_id=resource_id,
-                    resource_type=rb_resource.resource_type,
-                    drift_type='missing_from_terraform',
-                    terraform_config=None,
-                    runbooks_config=rb_resource.resource_attributes,
-                    drift_details=[
-                        f"Resource discovered by runbooks but not managed by terraform",
-                        f"Discovery module: {rb_resource.discovery_module}",
-                        f"Discovery time: {rb_resource.discovery_timestamp}"
-                    ],
-                    business_impact="Unmanaged infrastructure increases compliance risk",
-                    remediation_recommendation="Import resource into terraform or add to lifecycle management",
-                    risk_level="medium"
-                ))
-                
+                drift_analyses.append(
+                    DriftAnalysis(
+                        resource_id=resource_id,
+                        resource_type=rb_resource.resource_type,
+                        drift_type="missing_from_terraform",
+                        terraform_config=None,
+                        runbooks_config=rb_resource.resource_attributes,
+                        drift_details=[
+                            f"Resource discovered by runbooks but not managed by terraform",
+                            f"Discovery module: {rb_resource.discovery_module}",
+                            f"Discovery time: {rb_resource.discovery_timestamp}",
+                        ],
+                        business_impact="Unmanaged infrastructure increases compliance risk",
+                        remediation_recommendation="Import resource into terraform or add to lifecycle management",
+                        risk_level="medium",
+                    )
+                )
+
             elif tf_resource and not rb_resource:
                 # Missing from runbooks discovery
-                drift_analyses.append(DriftAnalysis(
-                    resource_id=resource_id,
-                    resource_type=tf_resource.resource_type,
-                    drift_type='missing_from_runbooks',
-                    terraform_config=tf_resource.resource_attributes,
-                    runbooks_config=None,
-                    drift_details=[
-                        f"Resource managed by terraform but not discovered by runbooks",
-                        f"Terraform address: {tf_resource.terraform_address}",
-                        "May indicate discovery gap or resource accessibility issue"
-                    ],
-                    business_impact="Discovery gap may affect monitoring and cost visibility",
-                    remediation_recommendation="Verify runbooks discovery scope and AWS permissions",
-                    risk_level="low"
-                ))
-                
+                drift_analyses.append(
+                    DriftAnalysis(
+                        resource_id=resource_id,
+                        resource_type=tf_resource.resource_type,
+                        drift_type="missing_from_runbooks",
+                        terraform_config=tf_resource.resource_attributes,
+                        runbooks_config=None,
+                        drift_details=[
+                            f"Resource managed by terraform but not discovered by runbooks",
+                            f"Terraform address: {tf_resource.terraform_address}",
+                            "May indicate discovery gap or resource accessibility issue",
+                        ],
+                        business_impact="Discovery gap may affect monitoring and cost visibility",
+                        remediation_recommendation="Verify runbooks discovery scope and AWS permissions",
+                        risk_level="low",
+                    )
+                )
+
             elif rb_resource and tf_resource:
                 # Check for configuration drift
                 config_diffs = self._compare_resource_configurations(
                     rb_resource.resource_attributes, tf_resource.resource_attributes
                 )
-                
+
                 if config_diffs:
-                    drift_analyses.append(DriftAnalysis(
-                        resource_id=resource_id,
-                        resource_type=rb_resource.resource_type,
-                        drift_type='configuration_drift',
-                        terraform_config=tf_resource.resource_attributes,
-                        runbooks_config=rb_resource.resource_attributes,
-                        drift_details=config_diffs,
-                        business_impact="Configuration drift may indicate unauthorized changes",
-                        remediation_recommendation="Review terraform plan and apply updates to align state",
-                        risk_level="medium" if len(config_diffs) > 3 else "low"
-                    ))
-        
+                    drift_analyses.append(
+                        DriftAnalysis(
+                            resource_id=resource_id,
+                            resource_type=rb_resource.resource_type,
+                            drift_type="configuration_drift",
+                            terraform_config=tf_resource.resource_attributes,
+                            runbooks_config=rb_resource.resource_attributes,
+                            drift_details=config_diffs,
+                            business_impact="Configuration drift may indicate unauthorized changes",
+                            remediation_recommendation="Review terraform plan and apply updates to align state",
+                            risk_level="medium" if len(config_diffs) > 3 else "low",
+                        )
+                    )
+
         # Add cost correlation to drift analyses if enabled
         if enable_cost_correlation and self.cost_processor:
             print_info(f"💰 Calculating cost correlation for {len(drift_analyses)} drift items...")
-            
+
             with create_progress_bar() as progress:
                 cost_task = progress.add_task("Correlating costs...", total=len(drift_analyses))
-                
+
                 for drift in drift_analyses:
                     try:
                         # Get cost correlation for this resource
-                        cost_correlation = await self._get_resource_cost_correlation(drift.resource_id, drift.resource_type)
+                        cost_correlation = await self._get_resource_cost_correlation(
+                            drift.resource_id, drift.resource_type
+                        )
                         drift.cost_correlation = cost_correlation
-                        
+
                         # Update business impact based on cost correlation
-                        if cost_correlation and cost_correlation.cost_impact_level == 'high':
+                        if cost_correlation and cost_correlation.cost_impact_level == "high":
                             drift.business_impact += f" HIGH COST IMPACT: ${cost_correlation.monthly_cost:.2f}/month"
-                            if drift.risk_level == 'low':
-                                drift.risk_level = 'medium'
-                        
+                            if drift.risk_level == "low":
+                                drift.risk_level = "medium"
+
                     except Exception as e:
                         print_warning(f"Cost correlation failed for {drift.resource_id}: {str(e)[:30]}...")
-                    
+
                     progress.advance(cost_task)
-        
+
         return drift_analyses
 
     def _compare_resource_configurations(self, rb_config: Dict, tf_config: Dict) -> List[str]:
         """Compare resource configurations to identify drift."""
         differences = []
-        
+
         # Compare common attributes that might indicate drift
         common_keys = set(rb_config.keys()) & set(tf_config.keys())
-        
+
         for key in common_keys:
             rb_value = rb_config[key]
             tf_value = tf_config[key]
-            
+
             # Skip certain keys that are expected to differ
-            if key in ['last_modified', 'creation_date', 'timestamp', 'discovery_timestamp']:
+            if key in ["last_modified", "creation_date", "timestamp", "discovery_timestamp"]:
                 continue
-            
+
             if rb_value != tf_value:
                 differences.append(f"{key}: runbooks='{rb_value}' vs terraform='{tf_value}'")
-        
+
         # Check for keys only in one source
         rb_only = set(rb_config.keys()) - set(tf_config.keys())
         tf_only = set(tf_config.keys()) - set(rb_config.keys())
-        
+
         for key in rb_only:
-            if key not in ['discovery_module', 'discovery_timestamp']:
+            if key not in ["discovery_module", "discovery_timestamp"]:
                 differences.append(f"{key}: only in runbooks ('{rb_config[key]}')")
-        
+
         for key in tf_only:
-            if key not in ['terraform_address']:
+            if key not in ["terraform_address"]:
                 differences.append(f"{key}: only in terraform ('{tf_config[key]}')")
-        
+
         return differences[:10]  # Limit to first 10 differences
 
     def _assess_overall_risk(self, drift_analysis: List[DriftAnalysis], drift_percentage: float) -> str:
@@ -594,7 +646,7 @@ class TerraformDriftDetector:
         elif drift_percentage <= 10:
             return "low"
         elif drift_percentage <= 25:
-            return "medium" 
+            return "medium"
         elif drift_percentage <= 50:
             return "high"
         else:
@@ -602,8 +654,8 @@ class TerraformDriftDetector:
 
     def _assess_compliance_impact(self, drift_analysis: List[DriftAnalysis]) -> str:
         """Assess compliance impact of detected drift."""
-        high_impact_drifts = [d for d in drift_analysis if d.drift_type == 'missing_from_terraform']
-        
+        high_impact_drifts = [d for d in drift_analysis if d.drift_type == "missing_from_terraform"]
+
         if len(high_impact_drifts) == 0:
             return "minimal"
         elif len(high_impact_drifts) <= 3:
@@ -615,11 +667,11 @@ class TerraformDriftDetector:
 
     def _assess_remediation_priority(self, drift_analysis: List[DriftAnalysis], overall_risk: str) -> str:
         """Assess remediation priority."""
-        critical_drifts = [d for d in drift_analysis if d.risk_level in ['high', 'critical']]
-        
-        if overall_risk in ['high', 'critical'] or len(critical_drifts) > 0:
+        critical_drifts = [d for d in drift_analysis if d.risk_level in ["high", "critical"]]
+
+        if overall_risk in ["high", "critical"] or len(critical_drifts) > 0:
             return "immediate"
-        elif overall_risk == 'medium':
+        elif overall_risk == "medium":
             return "high"
         else:
             return "medium"
@@ -627,7 +679,7 @@ class TerraformDriftDetector:
     def _estimate_remediation_effort(self, drift_analysis: List[DriftAnalysis]) -> str:
         """Estimate remediation effort required."""
         total_drifts = len(drift_analysis)
-        
+
         if total_drifts == 0:
             return "none"
         elif total_drifts <= 5:
@@ -643,37 +695,38 @@ class TerraformDriftDetector:
         """Get cost correlation data for a specific resource."""
         if not self.cost_processor:
             return None
-        
+
         try:
             # Map resource type to service category
             service_category = self._map_resource_to_service(resource_type)
-            
+
             # Generate mock cost data based on resource type and ID
             # In production, this would query Cost Explorer API with resource tags
             monthly_cost = self._estimate_resource_cost(resource_type, resource_id)
             yearly_cost = monthly_cost * 12
-            
+
             # Determine cost impact level
             if monthly_cost >= 100:
-                cost_impact_level = 'high'
+                cost_impact_level = "high"
             elif monthly_cost >= 20:
-                cost_impact_level = 'medium'
+                cost_impact_level = "medium"
             else:
-                cost_impact_level = 'low'
-            
+                cost_impact_level = "low"
+
             # Simulate cost trend (would be based on historical data in production)
             import random
-            cost_trend = random.choice(['stable', 'increasing', 'decreasing'])
-            
+
+            cost_trend = random.choice(["stable", "increasing", "decreasing"])
+
             return CostCorrelation(
                 resource_id=resource_id,
                 monthly_cost=monthly_cost,
                 yearly_cost_estimate=yearly_cost,
                 cost_trend=cost_trend,
                 cost_impact_level=cost_impact_level,
-                service_category=service_category
+                service_category=service_category,
             )
-            
+
         except Exception as e:
             print_warning(f"Failed to get cost correlation for {resource_id}: {e}")
             return None
@@ -681,45 +734,45 @@ class TerraformDriftDetector:
     def _map_resource_to_service(self, resource_type: str) -> str:
         """Map terraform resource type to AWS service category."""
         mapping = {
-            'aws_instance': 'Amazon EC2',
-            'aws_ec2_instance': 'Amazon EC2',
-            'aws_s3_bucket': 'Amazon S3',
-            'aws_rds_instance': 'Amazon RDS',
-            'aws_dynamodb_table': 'Amazon DynamoDB',
-            'aws_lambda_function': 'AWS Lambda',
-            'aws_vpc': 'Amazon VPC',
-            'aws_subnet': 'Amazon VPC',
-            'aws_security_group': 'Amazon VPC',
-            'aws_nat_gateway': 'Amazon VPC',
-            'aws_elastic_ip': 'Amazon EC2',
-            'aws_load_balancer': 'Elastic Load Balancing'
+            "aws_instance": "Amazon EC2",
+            "aws_ec2_instance": "Amazon EC2",
+            "aws_s3_bucket": "Amazon S3",
+            "aws_rds_instance": "Amazon RDS",
+            "aws_dynamodb_table": "Amazon DynamoDB",
+            "aws_lambda_function": "AWS Lambda",
+            "aws_vpc": "Amazon VPC",
+            "aws_subnet": "Amazon VPC",
+            "aws_security_group": "Amazon VPC",
+            "aws_nat_gateway": "Amazon VPC",
+            "aws_elastic_ip": "Amazon EC2",
+            "aws_load_balancer": "Elastic Load Balancing",
         }
-        return mapping.get(resource_type.lower(), 'Other AWS Services')
+        return mapping.get(resource_type.lower(), "Other AWS Services")
 
     def _estimate_resource_cost(self, resource_type: str, resource_id: str) -> float:
         """Estimate monthly cost for a resource (mock implementation)."""
         # Cost estimates based on typical AWS pricing
         cost_estimates = {
-            'aws_instance': 30.0,
-            'aws_ec2_instance': 30.0,
-            'aws_s3_bucket': 5.0,
-            'aws_rds_instance': 75.0,
-            'aws_dynamodb_table': 15.0,
-            'aws_lambda_function': 2.0,
-            'aws_vpc': 0.0,  # VPC itself is free
-            'aws_subnet': 0.0,  # Subnet itself is free
-            'aws_security_group': 0.0,  # Security group is free
-            'aws_nat_gateway': 45.0,
-            'aws_elastic_ip': 3.65,  # $0.005/hour when not attached
-            'aws_load_balancer': 18.25
+            "aws_instance": 30.0,
+            "aws_ec2_instance": 30.0,
+            "aws_s3_bucket": 5.0,
+            "aws_rds_instance": 75.0,
+            "aws_dynamodb_table": 15.0,
+            "aws_lambda_function": 2.0,
+            "aws_vpc": 0.0,  # VPC itself is free
+            "aws_subnet": 0.0,  # Subnet itself is free
+            "aws_security_group": 0.0,  # Security group is free
+            "aws_nat_gateway": 45.0,
+            "aws_elastic_ip": 3.65,  # $0.005/hour when not attached
+            "aws_load_balancer": 18.25,
         }
-        
+
         base_cost = cost_estimates.get(resource_type.lower(), 10.0)
-        
+
         # Add some variation based on resource ID hash for realistic simulation
         variation_factor = (hash(resource_id) % 50) / 100.0  # ±50% variation
         final_cost = base_cost * (1 + variation_factor)
-        
+
         return round(final_cost, 2)
 
     async def _calculate_cost_correlation_metrics(self, drift_analysis: List[DriftAnalysis]) -> Dict[str, Any]:
@@ -727,67 +780,74 @@ class TerraformDriftDetector:
         total_monthly_cost = 0.0
         high_cost_drifts = 0
         resources_with_cost_data = 0
-        
+
         for drift in drift_analysis:
             if drift.cost_correlation:
                 total_monthly_cost += drift.cost_correlation.monthly_cost
                 resources_with_cost_data += 1
-                
-                if drift.cost_correlation.cost_impact_level == 'high':
+
+                if drift.cost_correlation.cost_impact_level == "high":
                     high_cost_drifts += 1
-        
+
         total_drifts = len(drift_analysis)
         correlation_coverage = (resources_with_cost_data / total_drifts * 100) if total_drifts > 0 else 0
-        
+
         return {
-            'total_monthly_cost': total_monthly_cost,
-            'high_cost_drifts': high_cost_drifts,
-            'correlation_coverage': correlation_coverage,
-            'resources_with_cost_data': resources_with_cost_data
+            "total_monthly_cost": total_monthly_cost,
+            "high_cost_drifts": high_cost_drifts,
+            "correlation_coverage": correlation_coverage,
+            "resources_with_cost_data": resources_with_cost_data,
         }
 
-    async def _perform_mcp_validation(self, drift_analysis: List[DriftAnalysis], 
-                                    runbooks_resources: List[RunbooksResource], 
-                                    terraform_resources: List[TerraformResource]) -> Dict[str, Any]:
+    async def _perform_mcp_validation(
+        self,
+        drift_analysis: List[DriftAnalysis],
+        runbooks_resources: List[RunbooksResource],
+        terraform_resources: List[TerraformResource],
+    ) -> Dict[str, Any]:
         """Perform MCP validation for drift detection accuracy."""
         try:
             print_info("🔍 Performing MCP cross-validation...")
-            
+
             # Create validation data structure
             validation_data = {
-                'drift_analysis': [asdict(d) for d in drift_analysis],
-                'total_runbooks_resources': len(runbooks_resources),
-                'total_terraform_resources': len(terraform_resources),
-                'validation_timestamp': datetime.now().isoformat()
+                "drift_analysis": [asdict(d) for d in drift_analysis],
+                "total_runbooks_resources": len(runbooks_resources),
+                "total_terraform_resources": len(terraform_resources),
+                "validation_timestamp": datetime.now().isoformat(),
             }
-            
-            # Run MCP validation (simulated high accuracy)
+
+            # Run MCP validation with real accuracy calculation
             validation_result = await self.mcp_integrator.validate_vpc_operations(validation_data)
-            
-            # Calculate drift-specific accuracy metrics
-            accuracy_score = 99.2  # High accuracy for direct comparison
-            
+
+            # Use real accuracy from MCP validation (no hardcoded values)
+            accuracy_score = validation_result.accuracy_score  # Real calculated accuracy
+
             return {
-                'success': validation_result.success,
-                'accuracy_score': accuracy_score,
-                'validation_timestamp': datetime.now().isoformat(),
-                'resources_validated': len(drift_analysis)
+                "success": validation_result.success,
+                "accuracy_score": accuracy_score,
+                "validation_timestamp": datetime.now().isoformat(),
+                "resources_validated": len(drift_analysis),
+                "total_validations": validation_result.performance_metrics.get("total_validations", 0),
+                "successful_validations": validation_result.performance_metrics.get("successful_validations", 0),
             }
-            
+
         except Exception as e:
             print_warning(f"MCP validation error: {str(e)[:50]}...")
             return {
-                'success': False,
-                'accuracy_score': 95.0,  # Default accuracy
-                'validation_timestamp': datetime.now().isoformat(),
-                'error': str(e)
+                "success": False,
+                "accuracy_score": 0.0,  # Honest failure - no optimistic defaults
+                "validation_timestamp": datetime.now().isoformat(),
+                "error": str(e),
             }
 
-    def _assess_cost_optimization_potential(self, drift_analysis: List[DriftAnalysis], cost_metrics: Dict[str, Any]) -> str:
+    def _assess_cost_optimization_potential(
+        self, drift_analysis: List[DriftAnalysis], cost_metrics: Dict[str, Any]
+    ) -> str:
         """Assess cost optimization potential from drift analysis."""
-        total_cost = cost_metrics.get('total_monthly_cost', 0.0)
-        high_cost_drifts = cost_metrics.get('high_cost_drifts', 0)
-        
+        total_cost = cost_metrics.get("total_monthly_cost", 0.0)
+        high_cost_drifts = cost_metrics.get("high_cost_drifts", 0)
+
         if total_cost == 0:
             return "minimal"
         elif total_cost >= 500:
@@ -799,93 +859,67 @@ class TerraformDriftDetector:
 
     def _display_drift_results(self, drift_result: TerraformDriftResult):
         """Display drift detection results."""
-        
+
         # Create drift summary table
         drift_table = create_table(
             title="Infrastructure Drift Analysis",
             columns=[
                 {"name": "Metric", "style": "cyan", "width": 25},
                 {"name": "Value", "style": "white", "justify": "right"},
-                {"name": "Assessment", "style": "yellow", "justify": "center"}
-            ]
-        )
-        
-        drift_table.add_row(
-            "Resources in Terraform",
-            str(drift_result.total_resources_terraform),
-            "📊"
-        )
-        
-        drift_table.add_row(
-            "Resources in Runbooks",
-            str(drift_result.total_resources_runbooks),
-            "🔍"
+                {"name": "Assessment", "style": "yellow", "justify": "center"},
+            ],
         )
-        
-        drift_table.add_row(
-            "Resources in Sync",
-            str(drift_result.resources_in_sync),
-            "✅"
-        )
-        
+
+        drift_table.add_row("Resources in Terraform", str(drift_result.total_resources_terraform), "📊")
+
+        drift_table.add_row("Resources in Runbooks", str(drift_result.total_resources_runbooks), "🔍")
+
+        drift_table.add_row("Resources in Sync", str(drift_result.resources_in_sync), "✅")
+
         drift_table.add_row(
             "Resources with Drift",
             str(drift_result.resources_with_drift),
-            "⚠️" if drift_result.resources_with_drift > 0 else "✅"
+            "⚠️" if drift_result.resources_with_drift > 0 else "✅",
         )
-        
+
         drift_table.add_row(
             "Drift Percentage",
             f"{drift_result.drift_percentage:.1f}%",
-            self._get_drift_status_emoji(drift_result.drift_percentage)
+            self._get_drift_status_emoji(drift_result.drift_percentage),
         )
-        
+
         drift_table.add_row(
             "Overall Risk Level",
             drift_result.overall_risk_level.upper(),
-            self._get_risk_status_emoji(drift_result.overall_risk_level)
+            self._get_risk_status_emoji(drift_result.overall_risk_level),
         )
-        
+
         # Add cost correlation metrics
+        drift_table.add_row("Monthly Cost Impact", format_cost(drift_result.total_monthly_cost_impact), "💰")
+
         drift_table.add_row(
-            "Monthly Cost Impact",
-            format_cost(drift_result.total_monthly_cost_impact),
-            "💰"
-        )
-        
-        drift_table.add_row(
-            "High Cost Drifts",
-            str(drift_result.high_cost_drifts),
-            "🔥" if drift_result.high_cost_drifts > 0 else "✅"
-        )
-        
-        drift_table.add_row(
-            "Cost Correlation Coverage",
-            f"{drift_result.cost_correlation_coverage:.1f}%",
-            "📊"
-        )
-        
-        drift_table.add_row(
-            "MCP Validation Accuracy",
-            f"{drift_result.mcp_validation_accuracy:.1f}%",
-            "🔍"
+            "High Cost Drifts", str(drift_result.high_cost_drifts), "🔥" if drift_result.high_cost_drifts > 0 else "✅"
         )
-        
+
+        drift_table.add_row("Cost Correlation Coverage", f"{drift_result.cost_correlation_coverage:.1f}%", "📊")
+
+        drift_table.add_row("MCP Validation Accuracy", f"{drift_result.mcp_validation_accuracy:.1f}%", "🔍")
+
         console.print(drift_table)
-        
+
         # Display drift details if any
         if drift_result.drift_analysis:
             print_warning(f"⚠️ {len(drift_result.drift_analysis)} infrastructure drift(s) detected:")
-            
+
             for i, drift in enumerate(drift_result.drift_analysis[:5], 1):  # Show first 5
                 cost_info = ""
                 if drift.cost_correlation:
                     cost_info = f" (${drift.cost_correlation.monthly_cost:.2f}/month, {drift.cost_correlation.cost_impact_level} impact)"
                 print_info(f"   {i}. {drift.resource_type} ({drift.resource_id}): {drift.drift_type}{cost_info}")
-                
+
             if len(drift_result.drift_analysis) > 5:
                 print_info(f"   ... and {len(drift_result.drift_analysis) - 5} more")
-        
+
         # Business impact panel
         impact_text = f"""🏗️ Infrastructure Alignment Assessment with Cost Correlation
 
@@ -911,19 +945,14 @@ Estimated Effort: {drift_result.estimated_remediation_effort}
 • Compliance documentation and audit trail support
 • Risk mitigation through systematic drift resolution"""
 
-        risk_color = {
-            'low': 'green',
-            'medium': 'yellow', 
-            'high': 'red',
-            'critical': 'red'
-        }.get(drift_result.overall_risk_level, 'white')
+        risk_color = {"low": "green", "medium": "yellow", "high": "red", "critical": "red"}.get(
+            drift_result.overall_risk_level, "white"
+        )
 
         impact_panel = create_panel(
-            impact_text,
-            title="Infrastructure Drift Impact Assessment",
-            border_style=risk_color
+            impact_text, title="Infrastructure Drift Impact Assessment", border_style=risk_color
         )
-        
+
         console.print(impact_panel)
 
     def _get_drift_status_emoji(self, drift_percentage: float) -> str:
@@ -939,138 +968,115 @@ Estimated Effort: {drift_result.estimated_remediation_effort}
 
     def _get_risk_status_emoji(self, risk_level: str) -> str:
         """Get risk status emoji."""
-        return {
-            'low': '✅',
-            'medium': '🟡',
-            'high': '🟠', 
-            'critical': '🔴'
-        }.get(risk_level, '⚪')
+        return {"low": "✅", "medium": "🟡", "high": "🟠", "critical": "🔴"}.get(risk_level, "⚪")
 
     def _generate_drift_evidence(self, drift_result: TerraformDriftResult) -> str:
         """Generate drift detection evidence file."""
         timestamp = drift_result.detection_timestamp.strftime("%Y%m%d_%H%M%S")
         evidence_file = self.drift_evidence_dir / f"terraform_drift_analysis_{timestamp}.json"
-        
+
         evidence_data = {
-            'drift_analysis_metadata': {
-                'analysis_id': drift_result.drift_detection_id,
-                'timestamp': drift_result.detection_timestamp.isoformat(),
-                'framework_version': '1.0.0',
-                'enterprise_coordination': 'qa-testing-specialist → cloud-architect',
-                'strategic_objective': 'infrastructure_alignment_validation'
+            "drift_analysis_metadata": {
+                "analysis_id": drift_result.drift_detection_id,
+                "timestamp": drift_result.detection_timestamp.isoformat(),
+                "framework_version": "1.0.0",
+                "enterprise_coordination": "qa-testing-specialist → cloud-architect",
+                "strategic_objective": "infrastructure_alignment_validation",
             },
-            'drift_detection_results': asdict(drift_result),
-            'enterprise_assessment': {
-                'governance_alignment': drift_result.overall_risk_level != 'critical',
-                'compliance_documentation': 'comprehensive',
-                'audit_trail': 'complete',
-                'risk_mitigation_required': drift_result.remediation_priority in ['immediate', 'high']
+            "drift_detection_results": asdict(drift_result),
+            "enterprise_assessment": {
+                "governance_alignment": drift_result.overall_risk_level != "critical",
+                "compliance_documentation": "comprehensive",
+                "audit_trail": "complete",
+                "risk_mitigation_required": drift_result.remediation_priority in ["immediate", "high"],
+            },
+            "business_recommendations": self._generate_drift_recommendations(drift_result),
+            "compliance_attestation": {
+                "infrastructure_governance": True,
+                "drift_detection": "automated",
+                "remediation_tracking": "available",
+                "audit_evidence": "comprehensive",
             },
-            'business_recommendations': self._generate_drift_recommendations(drift_result),
-            'compliance_attestation': {
-                'infrastructure_governance': True,
-                'drift_detection': 'automated',
-                'remediation_tracking': 'available',
-                'audit_evidence': 'comprehensive'
-            }
         }
-        
-        with open(evidence_file, 'w') as f:
+
+        with open(evidence_file, "w") as f:
             json.dump(evidence_data, f, indent=2, default=str)
-        
+
         print_success(f"📄 Drift evidence generated: {evidence_file.name}")
         return str(evidence_file)
 
     def _generate_drift_recommendations(self, drift_result: TerraformDriftResult) -> List[str]:
         """Generate drift-specific recommendations."""
         recommendations = []
-        
+
         if drift_result.drift_percentage == 0:
-            recommendations.extend([
-                "✅ Infrastructure alignment validated - no drift detected",
-                "🏗️ Terraform state and runbooks discoveries in sync",
-                "📊 Continue monitoring for future drift detection"
-            ])
+            recommendations.extend(
+                [
+                    "✅ Infrastructure alignment validated - no drift detected",
+                    "🏗️ Terraform state and runbooks discoveries in sync",
+                    "📊 Continue monitoring for future drift detection",
+                ]
+            )
         else:
-            recommendations.extend([
-                f"⚠️ {drift_result.drift_percentage:.1f}% infrastructure drift detected - remediation required",
-                f"🔧 Priority: {drift_result.remediation_priority} (estimated effort: {drift_result.estimated_remediation_effort})",
-                f"📋 Review {len(drift_result.missing_from_terraform)} resources missing from terraform management"
-            ])
-            
+            recommendations.extend(
+                [
+                    f"⚠️ {drift_result.drift_percentage:.1f}% infrastructure drift detected - remediation required",
+                    f"🔧 Priority: {drift_result.remediation_priority} (estimated effort: {drift_result.estimated_remediation_effort})",
+                    f"📋 Review {len(drift_result.missing_from_terraform)} resources missing from terraform management",
+                ]
+            )
+
             if drift_result.missing_from_runbooks:
                 recommendations.append("🔍 Investigate runbooks discovery gaps and AWS permission scope")
-                
+
             if drift_result.configuration_drifts:
                 recommendations.append("⚙️ Review terraform plan and apply configuration updates")
-        
-        recommendations.extend([
-            "🏗️ Implement automated drift detection in CI/CD pipeline",
-            "📊 Establish drift monitoring dashboards for continuous governance",
-            "💼 Document infrastructure governance processes for compliance"
-        ])
-        
+
+        recommendations.extend(
+            [
+                "🏗️ Implement automated drift detection in CI/CD pipeline",
+                "📊 Establish drift monitoring dashboards for continuous governance",
+                "💼 Document infrastructure governance processes for compliance",
+            ]
+        )
+
         return recommendations
 
+
 # CLI interface for drift detection
 async def main():
     """Main CLI interface for terraform drift detection."""
     import argparse
-    
-    parser = argparse.ArgumentParser(
-        description="Terraform Drift Detector - Infrastructure Alignment Validation"
-    )
-    parser.add_argument(
-        "--runbooks-evidence",
-        required=True,
-        help="Path to runbooks evidence file (JSON or CSV)"
-    )
-    parser.add_argument(
-        "--terraform-state",
-        help="Path to terraform state file (optional - will auto-discover)"
-    )
+
+    parser = argparse.ArgumentParser(description="Terraform Drift Detector - Infrastructure Alignment Validation")
+    parser.add_argument("--runbooks-evidence", required=True, help="Path to runbooks evidence file (JSON or CSV)")
+    parser.add_argument("--terraform-state", help="Path to terraform state file (optional - will auto-discover)")
     parser.add_argument(
         "--terraform-state-dir",
         default="terraform",
-        help="Directory containing terraform state files (default: terraform)"
-    )
-    parser.add_argument(
-        "--resource-types",
-        nargs="+",
-        help="Specific resource types to analyze (e.g., aws_vpc aws_subnet)"
+        help="Directory containing terraform state files (default: terraform)",
     )
     parser.add_argument(
-        "--export-evidence",
-        action="store_true",
-        help="Export drift analysis evidence file"
+        "--resource-types", nargs="+", help="Specific resource types to analyze (e.g., aws_vpc aws_subnet)"
     )
-    parser.add_argument(
-        "--profile",
-        help="AWS profile for cost correlation analysis"
-    )
-    parser.add_argument(
-        "--disable-cost-correlation",
-        action="store_true",
-        help="Disable cost correlation analysis"
-    )
-    
+    parser.add_argument("--export-evidence", action="store_true", help="Export drift analysis evidence file")
+    parser.add_argument("--profile", help="AWS profile for cost correlation analysis")
+    parser.add_argument("--disable-cost-correlation", action="store_true", help="Disable cost correlation analysis")
+
     args = parser.parse_args()
-    
+
     # Initialize enhanced drift detector
-    detector = TerraformDriftDetector(
-        terraform_state_dir=args.terraform_state_dir,
-        user_profile=args.profile
-    )
-    
+    detector = TerraformDriftDetector(terraform_state_dir=args.terraform_state_dir, user_profile=args.profile)
+
     try:
         # Run enhanced drift detection with cost correlation
         drift_result = await detector.detect_infrastructure_drift(
             runbooks_evidence_file=args.runbooks_evidence,
             terraform_state_file=args.terraform_state,
             resource_types=args.resource_types,
-            enable_cost_correlation=not args.disable_cost_correlation
+            enable_cost_correlation=not args.disable_cost_correlation,
         )
-        
+
         # Summary with cost correlation
         if drift_result.drift_percentage == 0:
             print_success("✅ INFRASTRUCTURE ALIGNED: No drift detected")
@@ -1082,12 +1088,12 @@ async def main():
         else:
             print_error(f"🚨 SIGNIFICANT DRIFT: {drift_result.drift_percentage:.1f}% - immediate attention required")
             print_error(f"💰 HIGH COST RISK: {format_cost(drift_result.total_monthly_cost_impact)}/month")
-        
+
         print_info(f"📊 Overall Risk Level: {drift_result.overall_risk_level.upper()}")
         print_info(f"🔧 Remediation Priority: {drift_result.remediation_priority.upper()}")
         print_info(f"💰 Cost Optimization Potential: {drift_result.cost_optimization_potential}")
         print_info(f"🔍 MCP Validation Accuracy: {drift_result.mcp_validation_accuracy:.1f}%")
-        
+
     except Exception as e:
         print_error(f"❌ Drift detection failed: {str(e)}")
         raise
@@ -1095,4 +1101,5 @@ async def main():
 
 if __name__ == "__main__":
     import asyncio
-    asyncio.run(main())
+
+    asyncio.run(main())