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

runbooks/common/comprehensive_cost_explorer_integration.py

@@ -46,8 +46,17 @@ from botocore.exceptions import ClientError, NoCredentialsError
 
 # Internal imports
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_error, print_warning, print_info,
-    create_table, create_panel, format_cost, create_progress_bar, STATUS_INDICATORS
+    console,
+    print_header,
+    print_success,
+    print_error,
+    print_warning,
+    print_info,
+    create_table,
+    create_panel,
+    format_cost,
+    create_progress_bar,
+    STATUS_INDICATORS,
 )
 
 # Profile and pricing integration
@@ -55,6 +64,7 @@ try:
     from runbooks.common.profile_utils import get_profile_for_operation
     from runbooks.common.aws_pricing import get_aws_pricing_engine, calculate_annual_cost
     from runbooks.common.mcp_cost_explorer_integration import MCPCostExplorerIntegration
+
     INTEGRATIONS_AVAILABLE = True
 except ImportError as e:
     print_warning(f"Integration modules not fully available: {e}")
@@ -63,6 +73,7 @@ except ImportError as e:
 # Terraform drift detection integration
 try:
     from runbooks.validation.terraform_drift_detector import TerraformDriftDetector
+
     TERRAFORM_INTEGRATION_AVAILABLE = True
 except ImportError:
     print_warning("Terraform drift detection not available")
@@ -74,6 +85,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class CostExplorerResult:
     """Comprehensive Cost Explorer API result."""
+
     service_name: str
     account_id: str
     region: str
@@ -90,6 +102,7 @@ class CostExplorerResult:
 @dataclass
 class TerraformCostAlignment:
     """Terraform infrastructure cost alignment."""
+
     terraform_resource_id: str
     terraform_resource_type: str
     cost_explorer_attribution: Decimal
@@ -101,27 +114,28 @@ class TerraformCostAlignment:
 @dataclass
 class ComprehensiveCostAnalysis:
     """Complete cost analysis with infrastructure alignment."""
+
     analysis_id: str
     analysis_timestamp: datetime
-    
+
     # Cost Explorer data
     cost_explorer_results: List[CostExplorerResult]
     total_monthly_cost: Decimal
     total_annual_projection: Decimal
-    
+
     # MCP validation
     mcp_validation_accuracy: float
     mcp_cross_validation_results: Dict[str, Any]
-    
+
     # Terraform alignment
     terraform_cost_alignment: List[TerraformCostAlignment]
     infrastructure_drift_summary: Dict[str, Any]
-    
+
     # Business impact
     optimization_opportunities: List[Dict[str, Any]]
     annual_savings_potential: Decimal
     roi_projection: float
-    
+
     # Compliance and governance
     compliance_status: str
     audit_trail: Dict[str, Any]
@@ -131,21 +145,23 @@ class ComprehensiveCostAnalysis:
 class ComprehensiveCostExplorerIntegration:
     """
     Comprehensive AWS Cost Explorer integration with MCP validation and terraform alignment.
-    
+
     Provides enterprise-grade cost analysis with real-time API integration,
     comprehensive validation, and infrastructure governance alignment.
     """
-    
-    def __init__(self,
-                 billing_profile: Optional[str] = None,
-                 management_profile: Optional[str] = None,
-                 single_account_profile: Optional[str] = None,
-                 terraform_state_dir: Optional[str] = None,
-                 validation_tolerance_percent: float = 5.0,
-                 performance_target_seconds: float = 30.0):
+
+    def __init__(
+        self,
+        billing_profile: Optional[str] = None,
+        management_profile: Optional[str] = None,
+        single_account_profile: Optional[str] = None,
+        terraform_state_dir: Optional[str] = None,
+        validation_tolerance_percent: float = 5.0,
+        performance_target_seconds: float = 30.0,
+    ):
         """
         Initialize comprehensive Cost Explorer integration.
-        
+
         Args:
             billing_profile: AWS profile for Cost Explorer access
             management_profile: AWS profile for Organizations access
@@ -160,33 +176,33 @@ class ComprehensiveCostExplorerIntegration:
         self.terraform_state_dir = terraform_state_dir
         self.validation_tolerance = validation_tolerance_percent
         self.performance_target = performance_target_seconds
-        
+
         # Component integrations
         self.mcp_integration = None
         self.terraform_detector = None
         self.pricing_engine = None
-        
+
         # Results and caching
         self.analysis_cache = {}
         self.evidence_dir = Path("validation-evidence") / "comprehensive-cost-analysis"
         self.evidence_dir.mkdir(parents=True, exist_ok=True)
-        
+
         print_header("Comprehensive Cost Explorer Integration", "1.0.0")
         print_info("🏗️ Initializing enterprise cost analysis with infrastructure alignment...")
-        
+
     async def initialize_integrations(self, user_profile_override: Optional[str] = None) -> Dict[str, Any]:
         """Initialize all component integrations."""
-        
+
         initialization_results = {
-            'timestamp': datetime.now().isoformat(),
-            'user_profile_override': user_profile_override,
-            'integrations': {},
-            'overall_status': 'unknown'
+            "timestamp": datetime.now().isoformat(),
+            "user_profile_override": user_profile_override,
+            "integrations": {},
+            "overall_status": "unknown",
         }
-        
+
         with create_progress_bar() as progress:
             task = progress.add_task("Initializing integrations...", total=100)
-            
+
             # Initialize MCP Cost Explorer integration
             progress.update(task, advance=25, description="Initializing MCP integration...")
             if INTEGRATIONS_AVAILABLE:
@@ -196,126 +212,125 @@ class ComprehensiveCostExplorerIntegration:
                         management_profile=self.management_profile,
                         single_account_profile=self.single_account_profile,
                         tolerance_percent=self.validation_tolerance,
-                        performance_target_seconds=self.performance_target
+                        performance_target_seconds=self.performance_target,
                     )
-                    
+
                     # Initialize profiles
                     mcp_results = await self.mcp_integration.initialize_profiles(user_profile_override)
-                    initialization_results['integrations']['mcp'] = {
-                        'status': 'initialized',
-                        'profiles_successful': len(mcp_results.get('profiles_successful', [])),
-                        'validation_capability': 'available'
+                    initialization_results["integrations"]["mcp"] = {
+                        "status": "initialized",
+                        "profiles_successful": len(mcp_results.get("profiles_successful", [])),
+                        "validation_capability": "available",
                     }
-                    
+
                 except Exception as e:
-                    initialization_results['integrations']['mcp'] = {
-                        'status': 'error',
-                        'error': str(e),
-                        'validation_capability': 'limited'
+                    initialization_results["integrations"]["mcp"] = {
+                        "status": "error",
+                        "error": str(e),
+                        "validation_capability": "limited",
                     }
             else:
-                initialization_results['integrations']['mcp'] = {
-                    'status': 'not_available',
-                    'reason': 'Integration modules not installed'
+                initialization_results["integrations"]["mcp"] = {
+                    "status": "not_available",
+                    "reason": "Integration modules not installed",
                 }
-            
+
             # Initialize pricing engine
             progress.update(task, advance=25, description="Initializing pricing engine...")
             if INTEGRATIONS_AVAILABLE:
                 try:
-                    self.pricing_engine = get_aws_pricing_engine(
-                        cache_ttl_hours=24,
-                        enable_fallback=True
-                    )
-                    initialization_results['integrations']['pricing'] = {
-                        'status': 'initialized',
-                        'cache_ttl_hours': 24,
-                        'fallback_enabled': True
+                    self.pricing_engine = get_aws_pricing_engine(cache_ttl_hours=24, enable_fallback=True)
+                    initialization_results["integrations"]["pricing"] = {
+                        "status": "initialized",
+                        "cache_ttl_hours": 24,
+                        "fallback_enabled": True,
                     }
                 except Exception as e:
-                    initialization_results['integrations']['pricing'] = {
-                        'status': 'error',
-                        'error': str(e)
-                    }
-            
+                    initialization_results["integrations"]["pricing"] = {"status": "error", "error": str(e)}
+
             # Initialize terraform drift detector
             progress.update(task, advance=25, description="Initializing terraform detector...")
             if TERRAFORM_INTEGRATION_AVAILABLE:
                 try:
-                    self.terraform_detector = TerraformDriftDetector(
-                        terraform_state_dir=self.terraform_state_dir
-                    )
-                    initialization_results['integrations']['terraform'] = {
-                        'status': 'initialized',
-                        'state_dir': self.terraform_state_dir,
-                        'drift_detection': 'available'
+                    self.terraform_detector = TerraformDriftDetector(terraform_state_dir=self.terraform_state_dir)
+                    initialization_results["integrations"]["terraform"] = {
+                        "status": "initialized",
+                        "state_dir": self.terraform_state_dir,
+                        "drift_detection": "available",
                     }
                 except Exception as e:
-                    initialization_results['integrations']['terraform'] = {
-                        'status': 'error',
-                        'error': str(e),
-                        'drift_detection': 'unavailable'
+                    initialization_results["integrations"]["terraform"] = {
+                        "status": "error",
+                        "error": str(e),
+                        "drift_detection": "unavailable",
                     }
             else:
-                initialization_results['integrations']['terraform'] = {
-                    'status': 'not_available',
-                    'reason': 'Terraform integration module not installed'
+                initialization_results["integrations"]["terraform"] = {
+                    "status": "not_available",
+                    "reason": "Terraform integration module not installed",
                 }
-            
+
             progress.update(task, advance=25, description="Finalizing initialization...")
-            
+
             # Determine overall status
-            successful_integrations = sum(1 for integration in initialization_results['integrations'].values() 
-                                        if integration.get('status') == 'initialized')
-            total_integrations = len(initialization_results['integrations'])
-            
+            successful_integrations = sum(
+                1
+                for integration in initialization_results["integrations"].values()
+                if integration.get("status") == "initialized"
+            )
+            total_integrations = len(initialization_results["integrations"])
+
             if successful_integrations == total_integrations:
-                initialization_results['overall_status'] = 'fully_operational'
+                initialization_results["overall_status"] = "fully_operational"
             elif successful_integrations > 0:
-                initialization_results['overall_status'] = 'partially_operational'
+                initialization_results["overall_status"] = "partially_operational"
             else:
-                initialization_results['overall_status'] = 'initialization_failed'
-            
+                initialization_results["overall_status"] = "initialization_failed"
+
             progress.update(task, completed=100)
-        
+
         # Display initialization results
         self._display_initialization_results(initialization_results)
-        
+
         return initialization_results
-    
-    async def perform_comprehensive_cost_analysis(self,
-                                                 account_filter: Optional[str] = None,
-                                                 analysis_days: int = 90,
-                                                 include_terraform_alignment: bool = True,
-                                                 runbooks_evidence_file: Optional[str] = None) -> ComprehensiveCostAnalysis:
+
+    async def perform_comprehensive_cost_analysis(
+        self,
+        account_filter: Optional[str] = None,
+        analysis_days: int = 90,
+        include_terraform_alignment: bool = True,
+        runbooks_evidence_file: Optional[str] = None,
+    ) -> ComprehensiveCostAnalysis:
         """
         Perform comprehensive cost analysis with all integrations.
-        
+
         Args:
             account_filter: Specific account ID for analysis
             analysis_days: Number of days for cost analysis
             include_terraform_alignment: Include terraform drift detection
             runbooks_evidence_file: Path to runbooks evidence for terraform alignment
-            
+
         Returns:
             Complete comprehensive cost analysis
         """
         analysis_start = datetime.now()
         analysis_id = f"comprehensive_cost_{analysis_start.strftime('%Y%m%d_%H%M%S')}"
-        
+
         print_header("Comprehensive Cost Analysis")
         print_info(f"🎯 Analysis ID: {analysis_id}")
         print_info(f"📊 Account Filter: {account_filter or 'All accounts'}")
         print_info(f"📅 Analysis Period: {analysis_days} days")
-        
+
         # Phase 1: Cost Explorer API integration
         print_info("💰 Phase 1: Cost Explorer API integration...")
         cost_explorer_results = await self._perform_cost_explorer_analysis(account_filter, analysis_days)
-        
+
         # Phase 2: MCP validation
         print_info("🔍 Phase 2: MCP cross-validation...")
-        mcp_validation_results = await self._perform_mcp_validation(cost_explorer_results, account_filter, analysis_days)
-        
+        mcp_validation_results = await self._perform_mcp_validation(
+            cost_explorer_results, account_filter, analysis_days
+        )
+
         # Phase 3: Terraform alignment (if enabled)
         terraform_alignment = []
         infrastructure_drift = {}
@@ -326,13 +341,13 @@ class ComprehensiveCostExplorerIntegration:
             )
         else:
             print_info("⏭️ Phase 3: Skipped - terraform alignment not requested")
-        
+
         # Phase 4: Business impact analysis
         print_info("💼 Phase 4: Business impact analysis...")
         optimization_opportunities, savings_potential, roi_projection = await self._analyze_business_impact(
             cost_explorer_results, terraform_alignment
         )
-        
+
         # Phase 5: Generate comprehensive analysis
         print_info("📋 Phase 5: Generating comprehensive analysis...")
         comprehensive_analysis = ComprehensiveCostAnalysis(
@@ -341,381 +356,401 @@ class ComprehensiveCostExplorerIntegration:
             cost_explorer_results=cost_explorer_results,
             total_monthly_cost=sum(result.monthly_cost for result in cost_explorer_results),
             total_annual_projection=sum(result.annual_projection for result in cost_explorer_results),
-            mcp_validation_accuracy=mcp_validation_results.get('overall_accuracy', 0.0),
+            mcp_validation_accuracy=mcp_validation_results.get("overall_accuracy", 0.0),
             mcp_cross_validation_results=mcp_validation_results,
             terraform_cost_alignment=terraform_alignment,
             infrastructure_drift_summary=infrastructure_drift,
             optimization_opportunities=optimization_opportunities,
             annual_savings_potential=savings_potential,
             roi_projection=roi_projection,
-            compliance_status='compliant' if mcp_validation_results.get('overall_accuracy', 0) >= 99.5 else 'needs_review',
+            compliance_status="compliant"
+            if mcp_validation_results.get("overall_accuracy", 0) >= 99.5
+            else "needs_review",
             audit_trail={
-                'analysis_methodology': 'comprehensive_cost_explorer_with_mcp_terraform_validation',
-                'accuracy_standards': '≥99.5% MCP validation required',
-                'infrastructure_alignment': 'terraform_drift_detection_integrated',
-                'evidence_generation': 'complete_audit_trail'
+                "analysis_methodology": "comprehensive_cost_explorer_with_mcp_terraform_validation",
+                "accuracy_standards": "≥99.5% MCP validation required",
+                "infrastructure_alignment": "terraform_drift_detection_integrated",
+                "evidence_generation": "complete_audit_trail",
             },
-            evidence_files=[]
+            evidence_files=[],
         )
-        
+
         # Generate evidence files
         evidence_files = await self._generate_comprehensive_evidence(comprehensive_analysis)
         comprehensive_analysis.evidence_files = evidence_files
-        
+
         # Display results
         self._display_comprehensive_results(comprehensive_analysis)
-        
+
         return comprehensive_analysis
-    
-    async def _perform_cost_explorer_analysis(self, account_filter: Optional[str], analysis_days: int) -> List[CostExplorerResult]:
+
+    async def _perform_cost_explorer_analysis(
+        self, account_filter: Optional[str], analysis_days: int
+    ) -> List[CostExplorerResult]:
         """Perform Cost Explorer API analysis."""
-        
+
         cost_explorer_results = []
-        
+
         if not self.mcp_integration:
             print_warning("⚠️ MCP integration not available - using fallback pricing")
-            
+
             # Fallback to pricing engine if available
             if self.pricing_engine:
-                services = ['nat_gateway', 'elastic_ip', 'vpc_endpoint', 'ebs_gp3', 's3_standard']
+                services = ["nat_gateway", "elastic_ip", "vpc_endpoint", "ebs_gp3", "s3_standard"]
                 for service in services:
-                    pricing_result = self.pricing_engine.get_service_pricing(service, 'us-east-1')
-                    
-                    cost_explorer_results.append(CostExplorerResult(
-                        service_name=service,
-                        account_id=account_filter or 'fallback',
-                        region='us-east-1',
-                        monthly_cost=Decimal(str(pricing_result.monthly_cost)),
-                        annual_projection=Decimal(str(pricing_result.monthly_cost * 12)),
-                        cost_trend='stable',
-                        optimization_potential=Decimal(str(pricing_result.monthly_cost * 0.3)),
-                        last_updated=pricing_result.last_updated,
-                        data_source=pricing_result.pricing_source,
-                        validation_accuracy=90.0,  # Fallback accuracy
-                        confidence_level=75.0
-                    ))
-            
+                    pricing_result = self.pricing_engine.get_service_pricing(service, "us-east-1")
+
+                    cost_explorer_results.append(
+                        CostExplorerResult(
+                            service_name=service,
+                            account_id=account_filter or "fallback",
+                            region="us-east-1",
+                            monthly_cost=Decimal(str(pricing_result.monthly_cost)),
+                            annual_projection=Decimal(str(pricing_result.monthly_cost * 12)),
+                            cost_trend="stable",
+                            optimization_potential=Decimal(str(pricing_result.monthly_cost * 0.3)),
+                            last_updated=pricing_result.last_updated,
+                            data_source=pricing_result.pricing_source,
+                            validation_accuracy=90.0,  # Fallback accuracy
+                            confidence_level=75.0,
+                        )
+                    )
+
             return cost_explorer_results
-        
+
         try:
             # Use MCP integration for Cost Explorer data
             cost_data = await self.mcp_integration._retrieve_cost_explorer_data(account_filter, analysis_days)
-            
+
             # Process cost data into CostExplorerResult format
-            if cost_data.get('service_breakdown'):
-                for service_name, service_cost in cost_data['service_breakdown'].items():
+            if cost_data.get("service_breakdown"):
+                for service_name, service_cost in cost_data["service_breakdown"].items():
                     annual_cost = Decimal(str(service_cost)) * 12
-                    
-                    cost_explorer_results.append(CostExplorerResult(
-                        service_name=service_name,
-                        account_id=account_filter or 'organization',
-                        region='us-east-1',  # Cost Explorer aggregated
-                        monthly_cost=Decimal(str(service_cost)),
-                        annual_projection=annual_cost,
-                        cost_trend=self._determine_cost_trend(service_cost),
-                        optimization_potential=Decimal(str(service_cost * 0.25)),  # 25% optimization potential
-                        last_updated=datetime.now(),
-                        data_source='cost_explorer_api',
-                        validation_accuracy=95.0,  # High accuracy from API
-                        confidence_level=90.0
-                    ))
-            
-            elif cost_data.get('account_breakdown'):
-                for account_id, account_cost in cost_data['account_breakdown'].items():
+
+                    cost_explorer_results.append(
+                        CostExplorerResult(
+                            service_name=service_name,
+                            account_id=account_filter or "organization",
+                            region="us-east-1",  # Cost Explorer aggregated
+                            monthly_cost=Decimal(str(service_cost)),
+                            annual_projection=annual_cost,
+                            cost_trend=self._determine_cost_trend(service_cost),
+                            optimization_potential=Decimal(str(service_cost * 0.25)),  # 25% optimization potential
+                            last_updated=datetime.now(),
+                            data_source="cost_explorer_api",
+                            validation_accuracy=95.0,  # High accuracy from API
+                            confidence_level=90.0,
+                        )
+                    )
+
+            elif cost_data.get("account_breakdown"):
+                for account_id, account_cost in cost_data["account_breakdown"].items():
                     annual_cost = Decimal(str(account_cost)) * 12
-                    
-                    cost_explorer_results.append(CostExplorerResult(
-                        service_name='account_total',
-                        account_id=account_id,
-                        region='all_regions',
-                        monthly_cost=Decimal(str(account_cost)),
-                        annual_projection=annual_cost,
-                        cost_trend=self._determine_cost_trend(account_cost),
-                        optimization_potential=Decimal(str(account_cost * 0.20)),  # 20% optimization potential
-                        last_updated=datetime.now(),
-                        data_source='cost_explorer_api',
-                        validation_accuracy=95.0,
-                        confidence_level=90.0
-                    ))
-        
+
+                    cost_explorer_results.append(
+                        CostExplorerResult(
+                            service_name="account_total",
+                            account_id=account_id,
+                            region="all_regions",
+                            monthly_cost=Decimal(str(account_cost)),
+                            annual_projection=annual_cost,
+                            cost_trend=self._determine_cost_trend(account_cost),
+                            optimization_potential=Decimal(str(account_cost * 0.20)),  # 20% optimization potential
+                            last_updated=datetime.now(),
+                            data_source="cost_explorer_api",
+                            validation_accuracy=95.0,
+                            confidence_level=90.0,
+                        )
+                    )
+
         except Exception as e:
             print_error(f"Cost Explorer analysis error: {e}")
             logger.error(f"Cost Explorer analysis failed: {e}")
-        
+
         return cost_explorer_results
-    
-    async def _perform_mcp_validation(self, cost_explorer_results: List[CostExplorerResult], 
-                                    account_filter: Optional[str], analysis_days: int) -> Dict[str, Any]:
+
+    async def _perform_mcp_validation(
+        self, cost_explorer_results: List[CostExplorerResult], account_filter: Optional[str], analysis_days: int
+    ) -> Dict[str, Any]:
         """Perform MCP cross-validation."""
-        
+
         mcp_validation_results = {
-            'validation_timestamp': datetime.now().isoformat(),
-            'validation_method': 'comprehensive_mcp_cost_explorer',
-            'overall_accuracy': 0.0,
-            'validations': [],
-            'enterprise_compliance': False
+            "validation_timestamp": datetime.now().isoformat(),
+            "validation_method": "comprehensive_mcp_cost_explorer",
+            "overall_accuracy": 0.0,
+            "validations": [],
+            "enterprise_compliance": False,
         }
-        
+
         if not self.mcp_integration:
-            mcp_validation_results.update({
-                'status': 'mcp_integration_unavailable',
-                'overall_accuracy': 85.0,  # Fallback accuracy
-                'enterprise_compliance': False,
-                'note': 'MCP validation requires full integration availability'
-            })
+            mcp_validation_results.update(
+                {
+                    "status": "mcp_integration_unavailable",
+                    "overall_accuracy": 85.0,  # Fallback accuracy
+                    "enterprise_compliance": False,
+                    "note": "MCP validation requires full integration availability",
+                }
+            )
             return mcp_validation_results
-        
+
         try:
             # Prepare notebook-style results for cross-validation
             notebook_results = {
-                'cost_trends': {
-                    'total_monthly_spend': float(sum(result.monthly_cost for result in cost_explorer_results)),
-                    'analysis_period_days': analysis_days
+                "cost_trends": {
+                    "total_monthly_spend": float(sum(result.monthly_cost for result in cost_explorer_results)),
+                    "analysis_period_days": analysis_days,
                 },
-                'service_breakdown': {
-                    result.service_name: float(result.monthly_cost) 
-                    for result in cost_explorer_results
+                "service_breakdown": {
+                    result.service_name: float(result.monthly_cost) for result in cost_explorer_results
                 },
-                'optimization_potential': float(sum(result.optimization_potential for result in cost_explorer_results))
+                "optimization_potential": float(sum(result.optimization_potential for result in cost_explorer_results)),
             }
-            
+
             # Perform MCP validation
             validation_results = await self.mcp_integration.validate_cost_data_with_cross_validation(
-                notebook_results=notebook_results,
-                account_filter=account_filter,
-                analysis_days=analysis_days
+                notebook_results=notebook_results, account_filter=account_filter, analysis_days=analysis_days
             )
-            
+
             # Extract validation accuracy
-            cross_validation = validation_results.get('cross_validation', {})
-            validations = cross_validation.get('validations', [])
-            
+            cross_validation = validation_results.get("cross_validation", {})
+            validations = cross_validation.get("validations", [])
+
             if validations:
                 # Calculate overall accuracy from validations
-                validated_count = sum(1 for v in validations if v.get('status') == 'validated')
+                validated_count = sum(1 for v in validations if v.get("status") == "validated")
                 total_count = len(validations)
-                
+
                 overall_accuracy = (validated_count / total_count * 100) if total_count > 0 else 0
-                
-                mcp_validation_results.update({
-                    'overall_accuracy': overall_accuracy,
-                    'validations': validations,
-                    'enterprise_compliance': overall_accuracy >= 99.5,
-                    'manager_priorities_assessment': validation_results.get('manager_priorities_assessment', {}),
-                    'performance_metrics': validation_results.get('performance_metrics', {})
-                })
+
+                mcp_validation_results.update(
+                    {
+                        "overall_accuracy": overall_accuracy,
+                        "validations": validations,
+                        "enterprise_compliance": overall_accuracy >= 99.5,
+                        "manager_priorities_assessment": validation_results.get("manager_priorities_assessment", {}),
+                        "performance_metrics": validation_results.get("performance_metrics", {}),
+                    }
+                )
             else:
-                mcp_validation_results.update({
-                    'overall_accuracy': 75.0,  # Default when validation fails
-                    'enterprise_compliance': False,
-                    'status': 'validation_incomplete'
-                })
-        
+                mcp_validation_results.update(
+                    {
+                        "overall_accuracy": 75.0,  # Default when validation fails
+                        "enterprise_compliance": False,
+                        "status": "validation_incomplete",
+                    }
+                )
+
         except Exception as e:
             print_error(f"MCP validation error: {e}")
-            mcp_validation_results.update({
-                'status': 'validation_error',
-                'error': str(e),
-                'overall_accuracy': 70.0,  # Conservative accuracy on error
-                'enterprise_compliance': False
-            })
-        
+            mcp_validation_results.update(
+                {
+                    "status": "validation_error",
+                    "error": str(e),
+                    "overall_accuracy": 70.0,  # Conservative accuracy on error
+                    "enterprise_compliance": False,
+                }
+            )
+
         return mcp_validation_results
-    
-    async def _perform_terraform_alignment(self, cost_explorer_results: List[CostExplorerResult],
-                                         runbooks_evidence_file: str) -> Tuple[List[TerraformCostAlignment], Dict[str, Any]]:
+
+    async def _perform_terraform_alignment(
+        self, cost_explorer_results: List[CostExplorerResult], runbooks_evidence_file: str
+    ) -> Tuple[List[TerraformCostAlignment], Dict[str, Any]]:
         """Perform terraform infrastructure cost alignment."""
-        
+
         terraform_alignments = []
         infrastructure_drift = {}
-        
+
         if not self.terraform_detector:
             print_warning("⚠️ Terraform integration not available")
-            return terraform_alignments, {'status': 'terraform_integration_unavailable'}
-        
+            return terraform_alignments, {"status": "terraform_integration_unavailable"}
+
         try:
             # Perform terraform drift detection
             drift_result = self.terraform_detector.detect_infrastructure_drift(
                 runbooks_evidence_file=runbooks_evidence_file,
-                resource_types=['aws_vpc', 'aws_subnet', 'aws_nat_gateway', 'aws_eip']
+                resource_types=["aws_vpc", "aws_subnet", "aws_nat_gateway", "aws_eip"],
             )
-            
+
             # Process drift results for cost alignment
             for drift_analysis in drift_result.drift_analysis:
                 # Try to correlate with cost data
                 related_cost = self._correlate_cost_with_resource(
-                    drift_analysis.resource_type, 
-                    drift_analysis.resource_id,
-                    cost_explorer_results
+                    drift_analysis.resource_type, drift_analysis.resource_id, cost_explorer_results
                 )
-                
+
                 terraform_alignment = TerraformCostAlignment(
                     terraform_resource_id=drift_analysis.resource_id,
                     terraform_resource_type=drift_analysis.resource_type,
                     cost_explorer_attribution=related_cost,
                     alignment_status=drift_analysis.drift_type,
                     drift_details=drift_analysis.drift_details,
-                    remediation_recommendation=drift_analysis.remediation_recommendation
+                    remediation_recommendation=drift_analysis.remediation_recommendation,
                 )
-                
+
                 terraform_alignments.append(terraform_alignment)
-            
+
             # Summarize infrastructure drift
             infrastructure_drift = {
-                'drift_detection_id': drift_result.drift_detection_id,
-                'total_resources_terraform': drift_result.total_resources_terraform,
-                'total_resources_runbooks': drift_result.total_resources_runbooks,
-                'drift_percentage': drift_result.drift_percentage,
-                'overall_risk_level': drift_result.overall_risk_level,
-                'compliance_impact': drift_result.compliance_impact,
-                'remediation_priority': drift_result.remediation_priority
+                "drift_detection_id": drift_result.drift_detection_id,
+                "total_resources_terraform": drift_result.total_resources_terraform,
+                "total_resources_runbooks": drift_result.total_resources_runbooks,
+                "drift_percentage": drift_result.drift_percentage,
+                "overall_risk_level": drift_result.overall_risk_level,
+                "compliance_impact": drift_result.compliance_impact,
+                "remediation_priority": drift_result.remediation_priority,
             }
-        
+
         except Exception as e:
             print_error(f"Terraform alignment error: {e}")
-            infrastructure_drift = {
-                'status': 'alignment_error',
-                'error': str(e)
-            }
-        
+            infrastructure_drift = {"status": "alignment_error", "error": str(e)}
+
         return terraform_alignments, infrastructure_drift
-    
-    async def _analyze_business_impact(self, cost_explorer_results: List[CostExplorerResult],
-                                     terraform_alignments: List[TerraformCostAlignment]) -> Tuple[List[Dict[str, Any]], Decimal, float]:
+
+    async def _analyze_business_impact(
+        self, cost_explorer_results: List[CostExplorerResult], terraform_alignments: List[TerraformCostAlignment]
+    ) -> Tuple[List[Dict[str, Any]], Decimal, float]:
         """Analyze business impact and optimization opportunities."""
-        
+
         optimization_opportunities = []
-        total_savings_potential = Decimal('0')
-        
+        total_savings_potential = Decimal("0")
+
         # Analyze cost optimization opportunities
         for result in cost_explorer_results:
             if result.optimization_potential > 0:
-                optimization_opportunities.append({
-                    'type': 'cost_optimization',
-                    'service': result.service_name,
-                    'account': result.account_id,
-                    'current_monthly_cost': float(result.monthly_cost),
-                    'potential_monthly_savings': float(result.optimization_potential),
-                    'annual_savings_potential': float(result.optimization_potential * 12),
-                    'confidence_level': result.confidence_level,
-                    'recommendation': f"Optimize {result.service_name} configuration to reduce costs",
-                    'implementation_effort': 'medium',
-                    'risk_level': 'low'
-                })
-                
+                optimization_opportunities.append(
+                    {
+                        "type": "cost_optimization",
+                        "service": result.service_name,
+                        "account": result.account_id,
+                        "current_monthly_cost": float(result.monthly_cost),
+                        "potential_monthly_savings": float(result.optimization_potential),
+                        "annual_savings_potential": float(result.optimization_potential * 12),
+                        "confidence_level": result.confidence_level,
+                        "recommendation": f"Optimize {result.service_name} configuration to reduce costs",
+                        "implementation_effort": "medium",
+                        "risk_level": "low",
+                    }
+                )
+
                 total_savings_potential += result.optimization_potential * 12
-        
+
         # Analyze terraform alignment opportunities
         for alignment in terraform_alignments:
-            if alignment.alignment_status in ['missing_from_terraform', 'configuration_drift']:
-                optimization_opportunities.append({
-                    'type': 'infrastructure_governance',
-                    'resource_type': alignment.terraform_resource_type,
-                    'resource_id': alignment.terraform_resource_id,
-                    'alignment_status': alignment.alignment_status,
-                    'cost_attribution': float(alignment.cost_explorer_attribution),
-                    'recommendation': alignment.remediation_recommendation,
-                    'implementation_effort': 'high' if alignment.alignment_status == 'missing_from_terraform' else 'medium',
-                    'risk_level': 'medium',
-                    'governance_impact': 'high'
-                })
-        
+            if alignment.alignment_status in ["missing_from_terraform", "configuration_drift"]:
+                optimization_opportunities.append(
+                    {
+                        "type": "infrastructure_governance",
+                        "resource_type": alignment.terraform_resource_type,
+                        "resource_id": alignment.terraform_resource_id,
+                        "alignment_status": alignment.alignment_status,
+                        "cost_attribution": float(alignment.cost_explorer_attribution),
+                        "recommendation": alignment.remediation_recommendation,
+                        "implementation_effort": "high"
+                        if alignment.alignment_status == "missing_from_terraform"
+                        else "medium",
+                        "risk_level": "medium",
+                        "governance_impact": "high",
+                    }
+                )
+
         # Calculate ROI projection
         total_current_cost = sum(result.annual_projection for result in cost_explorer_results)
         roi_projection = float((total_savings_potential / total_current_cost) * 100) if total_current_cost > 0 else 0.0
-        
+
         return optimization_opportunities, total_savings_potential, roi_projection
-    
-    def _correlate_cost_with_resource(self, resource_type: str, resource_id: str, 
-                                    cost_results: List[CostExplorerResult]) -> Decimal:
+
+    def _correlate_cost_with_resource(
+        self, resource_type: str, resource_id: str, cost_results: List[CostExplorerResult]
+    ) -> Decimal:
         """Correlate terraform resource with cost data."""
-        
+
         # Simple correlation based on resource type
         service_mapping = {
-            'aws_vpc': 'Amazon Virtual Private Cloud',
-            'aws_nat_gateway': 'Amazon VPC',
-            'aws_subnet': 'Amazon Virtual Private Cloud',
-            'aws_eip': 'Amazon Elastic Compute Cloud - Compute'
+            "aws_vpc": "Amazon Virtual Private Cloud",
+            "aws_nat_gateway": "Amazon VPC",
+            "aws_subnet": "Amazon Virtual Private Cloud",
+            "aws_eip": "Amazon Elastic Compute Cloud - Compute",
         }
-        
-        service_name = service_mapping.get(resource_type, '')
-        
+
+        service_name = service_mapping.get(resource_type, "")
+
         for result in cost_results:
             if service_name in result.service_name or result.service_name in service_name:
                 # Rough attribution - could be enhanced with detailed resource tagging
-                return result.monthly_cost * Decimal('0.1')  # 10% attribution estimate
-        
-        return Decimal('0')
-    
+                return result.monthly_cost * Decimal("0.1")  # 10% attribution estimate
+
+        return Decimal("0")
+
     def _determine_cost_trend(self, current_cost: float) -> str:
         """Determine cost trend (simplified)."""
         # In real implementation, this would compare historical data
         if current_cost > 1000:
-            return 'increasing'
+            return "increasing"
         elif current_cost < 100:
-            return 'decreasing'
+            return "decreasing"
         else:
-            return 'stable'
-    
+            return "stable"
+
     async def _generate_comprehensive_evidence(self, analysis: ComprehensiveCostAnalysis) -> List[str]:
         """Generate comprehensive evidence files."""
-        
+
         evidence_files = []
         timestamp = analysis.analysis_timestamp.strftime("%Y%m%d_%H%M%S")
-        
+
         # Main analysis evidence
         main_evidence_file = self.evidence_dir / f"comprehensive_cost_analysis_{timestamp}.json"
-        
+
         evidence_data = {
-            'comprehensive_cost_analysis': asdict(analysis),
-            'enterprise_metadata': {
-                'framework_version': '1.0.0',
-                'strategic_coordination': 'python-runbooks-engineer → qa-testing-specialist → cloud-architect',
-                'compliance_standards': ['DoD', 'Enterprise', 'FAANG SDLC'],
-                'validation_methodology': 'aws_cost_explorer_api + mcp_cross_validation + terraform_alignment'
+            "comprehensive_cost_analysis": asdict(analysis),
+            "enterprise_metadata": {
+                "framework_version": "1.0.0",
+                "strategic_coordination": "python-runbooks-engineer → qa-testing-specialist → cloud-architect",
+                "compliance_standards": ["DoD", "Enterprise", "FAANG SDLC"],
+                "validation_methodology": "aws_cost_explorer_api + mcp_cross_validation + terraform_alignment",
             },
-            'business_intelligence': {
-                'total_annual_cost_projection': float(analysis.total_annual_projection),
-                'annual_savings_potential': float(analysis.annual_savings_potential),
-                'roi_projection_percent': analysis.roi_projection,
-                'mcp_validation_accuracy': analysis.mcp_validation_accuracy,
-                'enterprise_compliance_status': analysis.compliance_status
+            "business_intelligence": {
+                "total_annual_cost_projection": float(analysis.total_annual_projection),
+                "annual_savings_potential": float(analysis.annual_savings_potential),
+                "roi_projection_percent": analysis.roi_projection,
+                "mcp_validation_accuracy": analysis.mcp_validation_accuracy,
+                "enterprise_compliance_status": analysis.compliance_status,
+            },
+            "executive_summary": self._generate_executive_summary(analysis),
+            "audit_compliance": {
+                "data_source": "real_aws_cost_explorer_api",
+                "validation_methodology": "mcp_cross_validation",
+                "infrastructure_alignment": "terraform_drift_detection",
+                "evidence_integrity": "cryptographic_hash_validation",
+                "audit_trail": "comprehensive",
             },
-            'executive_summary': self._generate_executive_summary(analysis),
-            'audit_compliance': {
-                'data_source': 'real_aws_cost_explorer_api',
-                'validation_methodology': 'mcp_cross_validation',
-                'infrastructure_alignment': 'terraform_drift_detection',
-                'evidence_integrity': 'cryptographic_hash_validation',
-                'audit_trail': 'comprehensive'
-            }
         }
-        
-        with open(main_evidence_file, 'w') as f:
+
+        with open(main_evidence_file, "w") as f:
             json.dump(evidence_data, f, indent=2, default=str)
-        
+
         evidence_files.append(str(main_evidence_file))
-        
+
         # Executive summary file
         exec_summary_file = self.evidence_dir / f"executive_summary_{timestamp}.md"
         exec_summary = self._generate_executive_summary(analysis)
-        
-        with open(exec_summary_file, 'w') as f:
+
+        with open(exec_summary_file, "w") as f:
             f.write(exec_summary)
-        
+
         evidence_files.append(str(exec_summary_file))
-        
+
         print_success(f"📄 Evidence files generated: {len(evidence_files)} files")
-        
+
         return evidence_files
-    
+
     def _generate_executive_summary(self, analysis: ComprehensiveCostAnalysis) -> str:
         """Generate executive summary."""
-        
+
         return f"""# Comprehensive Cost Analysis Executive Summary
 
 **Analysis ID**: {analysis.analysis_id}
-**Date**: {analysis.analysis_timestamp.strftime('%Y-%m-%d %H:%M:%S')}
+**Date**: {analysis.analysis_timestamp.strftime("%Y-%m-%d %H:%M:%S")}
 
 ## Financial Overview
 
@@ -727,19 +762,19 @@ class ComprehensiveCostExplorerIntegration:
 
 - **MCP Validation Accuracy**: {analysis.mcp_validation_accuracy:.1f}%
 - **Enterprise Compliance**: {analysis.compliance_status.upper()}
-- **Infrastructure Alignment**: {'Validated' if analysis.terraform_cost_alignment else 'Not Assessed'}
+- **Infrastructure Alignment**: {"Validated" if analysis.terraform_cost_alignment else "Not Assessed"}
 
 ## Key Findings
 
 - **Cost Explorer Results**: {len(analysis.cost_explorer_results)} services analyzed
 - **Optimization Opportunities**: {len(analysis.optimization_opportunities)} identified
-- **Infrastructure Drift**: {'Detected' if analysis.infrastructure_drift_summary.get('drift_percentage', 0) > 0 else 'None detected'}
+- **Infrastructure Drift**: {"Detected" if analysis.infrastructure_drift_summary.get("drift_percentage", 0) > 0 else "None detected"}
 
 ## Recommendations
 
 1. **Cost Optimization**: Implement identified optimization opportunities for ${analysis.annual_savings_potential:,.2f} annual savings
-2. **Infrastructure Governance**: {'Address infrastructure drift detected' if analysis.infrastructure_drift_summary.get('drift_percentage', 0) > 0 else 'Maintain current infrastructure alignment'}
-3. **Validation Framework**: {'Continue MCP validation excellence' if analysis.mcp_validation_accuracy >= 99.5 else 'Enhance MCP validation accuracy'}
+2. **Infrastructure Governance**: {"Address infrastructure drift detected" if analysis.infrastructure_drift_summary.get("drift_percentage", 0) > 0 else "Maintain current infrastructure alignment"}
+3. **Validation Framework**: {"Continue MCP validation excellence" if analysis.mcp_validation_accuracy >= 99.5 else "Enhance MCP validation accuracy"}
 
 ## Strategic Alignment
 
@@ -752,106 +787,91 @@ class ComprehensiveCostExplorerIntegration:
 *Generated by Comprehensive Cost Explorer Integration latest version*
 *Strategic Coordination: Enterprise Agile Team with systematic delegation*
 """
-    
+
     def _display_initialization_results(self, results: Dict[str, Any]) -> None:
         """Display initialization results."""
-        
+
         init_table = create_table(
             title="Integration Initialization Results",
             columns=[
                 {"name": "Integration", "style": "bold cyan"},
                 {"name": "Status", "style": "white"},
                 {"name": "Capability", "style": "yellow"},
-                {"name": "Notes", "style": "dim"}
-            ]
+                {"name": "Notes", "style": "dim"},
+            ],
         )
-        
-        for integration_name, integration_data in results['integrations'].items():
-            status = integration_data.get('status', 'unknown')
+
+        for integration_name, integration_data in results["integrations"].items():
+            status = integration_data.get("status", "unknown")
             status_display = {
-                'initialized': '✅ Operational',
-                'error': '❌ Error',
-                'not_available': '⚠️ Unavailable'
+                "initialized": "✅ Operational",
+                "error": "❌ Error",
+                "not_available": "⚠️ Unavailable",
             }.get(status, status)
-            
-            capability = 'Available' if status == 'initialized' else 'Limited'
-            notes = integration_data.get('error', integration_data.get('reason', 'Ready'))[:50]
-            
-            init_table.add_row(
-                integration_name.upper(),
-                status_display,
-                capability,
-                notes
-            )
-        
+
+            capability = "Available" if status == "initialized" else "Limited"
+            notes = integration_data.get("error", integration_data.get("reason", "Ready"))[:50]
+
+            init_table.add_row(integration_name.upper(), status_display, capability, notes)
+
         console.print(init_table)
-        
-        overall_status = results['overall_status']
+
+        overall_status = results["overall_status"]
         status_panel = create_panel(
-            f"""🏗️ Comprehensive Integration Status: {overall_status.upper().replace('_', ' ')}
+            f"""🏗️ Comprehensive Integration Status: {overall_status.upper().replace("_", " ")}
             
 Integration Readiness:
-• Real-time Cost Explorer API: {'✅ Ready' if 'mcp' in results['integrations'] and results['integrations']['mcp'].get('status') == 'initialized' else '⚠️ Limited'}
-• MCP Validation (≥99.5%): {'✅ Ready' if 'mcp' in results['integrations'] and results['integrations']['mcp'].get('status') == 'initialized' else '⚠️ Limited'}
-• Terraform Drift Detection: {'✅ Ready' if 'terraform' in results['integrations'] and results['integrations']['terraform'].get('status') == 'initialized' else '⚠️ Limited'}
-• Dynamic Pricing Engine: {'✅ Ready' if 'pricing' in results['integrations'] and results['integrations']['pricing'].get('status') == 'initialized' else '⚠️ Limited'}
+• Real-time Cost Explorer API: {"✅ Ready" if "mcp" in results["integrations"] and results["integrations"]["mcp"].get("status") == "initialized" else "⚠️ Limited"}
+• MCP Validation (≥99.5%): {"✅ Ready" if "mcp" in results["integrations"] and results["integrations"]["mcp"].get("status") == "initialized" else "⚠️ Limited"}
+• Terraform Drift Detection: {"✅ Ready" if "terraform" in results["integrations"] and results["integrations"]["terraform"].get("status") == "initialized" else "⚠️ Limited"}
+• Dynamic Pricing Engine: {"✅ Ready" if "pricing" in results["integrations"] and results["integrations"]["pricing"].get("status") == "initialized" else "⚠️ Limited"}
 
-Enterprise Compliance: {'✅ All systems operational' if overall_status == 'fully_operational' else '⚠️ Partial capability - some features may be limited'}""",
+Enterprise Compliance: {"✅ All systems operational" if overall_status == "fully_operational" else "⚠️ Partial capability - some features may be limited"}""",
             title="Enterprise Integration Status",
-            border_style="green" if overall_status == 'fully_operational' else "yellow"
+            border_style="green" if overall_status == "fully_operational" else "yellow",
         )
-        
+
         console.print(status_panel)
-    
+
     def _display_comprehensive_results(self, analysis: ComprehensiveCostAnalysis) -> None:
         """Display comprehensive analysis results."""
-        
+
         print_header("Comprehensive Cost Analysis Results")
-        
+
         # Financial summary
         financial_table = create_table(
             title="💰 Financial Analysis Summary",
             columns=[
                 {"name": "Metric", "style": "bold cyan"},
                 {"name": "Value", "style": "bright_green", "justify": "right"},
-                {"name": "Assessment", "style": "yellow", "justify": "center"}
-            ]
-        )
-        
-        financial_table.add_row(
-            "Current Annual Cost",
-            f"${analysis.total_annual_projection:,.2f}",
-            "📊"
-        )
-        
-        financial_table.add_row(
-            "Annual Savings Potential",
-            f"${analysis.annual_savings_potential:,.2f}",
-            "💰"
+                {"name": "Assessment", "style": "yellow", "justify": "center"},
+            ],
         )
-        
+
+        financial_table.add_row("Current Annual Cost", f"${analysis.total_annual_projection:,.2f}", "📊")
+
+        financial_table.add_row("Annual Savings Potential", f"${analysis.annual_savings_potential:,.2f}", "💰")
+
         financial_table.add_row(
-            "ROI Projection",
-            f"{analysis.roi_projection:.1f}%",
-            "📈" if analysis.roi_projection > 10 else "📊"
+            "ROI Projection", f"{analysis.roi_projection:.1f}%", "📈" if analysis.roi_projection > 10 else "📊"
         )
-        
+
         financial_table.add_row(
             "MCP Validation Accuracy",
             f"{analysis.mcp_validation_accuracy:.1f}%",
-            "✅" if analysis.mcp_validation_accuracy >= 99.5 else "⚠️"
+            "✅" if analysis.mcp_validation_accuracy >= 99.5 else "⚠️",
         )
-        
+
         console.print(financial_table)
-        
+
         # Compliance status panel
-        compliance_color = "green" if analysis.compliance_status == 'compliant' else "yellow"
+        compliance_color = "green" if analysis.compliance_status == "compliant" else "yellow"
         compliance_text = f"""🏛️ Enterprise Compliance Assessment
         
 Compliance Status: {analysis.compliance_status.upper()}
-MCP Validation: {analysis.mcp_validation_accuracy:.1f}% ({'✅ EXCEEDS' if analysis.mcp_validation_accuracy >= 99.5 else '⚠️ BELOW'} 99.5% requirement)
-Infrastructure Alignment: {'✅ Terraform validated' if analysis.terraform_cost_alignment else '📊 Assessment available'}
-Audit Trail: {'✅ Complete' if analysis.evidence_files else '⚠️ Generating'}
+MCP Validation: {analysis.mcp_validation_accuracy:.1f}% ({"✅ EXCEEDS" if analysis.mcp_validation_accuracy >= 99.5 else "⚠️ BELOW"} 99.5% requirement)
+Infrastructure Alignment: {"✅ Terraform validated" if analysis.terraform_cost_alignment else "📊 Assessment available"}
+Audit Trail: {"✅ Complete" if analysis.evidence_files else "⚠️ Generating"}
 
 🎯 Strategic Objectives:
 • runbooks package: ✅ Enhanced with real-time Cost Explorer API
@@ -865,19 +885,17 @@ Audit Trail: {'✅ Complete' if analysis.evidence_files else '⚠️ Generating'
 • Executive-ready reporting with quantified ROI"""
 
         compliance_panel = create_panel(
-            compliance_text,
-            title="Enterprise Compliance & Strategic Alignment",
-            border_style=compliance_color
+            compliance_text, title="Enterprise Compliance & Strategic Alignment", border_style=compliance_color
         )
-        
+
         console.print(compliance_panel)
-        
+
         # Optimization opportunities summary
         if analysis.optimization_opportunities:
             print_info(f"🔧 {len(analysis.optimization_opportunities)} optimization opportunities identified")
             print_info(f"💰 Total annual savings potential: ${analysis.annual_savings_potential:,.2f}")
             print_info(f"📈 ROI projection: {analysis.roi_projection:.1f}%")
-        
+
         # Evidence files
         if analysis.evidence_files:
             print_success(f"📄 Evidence files generated: {len(analysis.evidence_files)} files")
@@ -889,91 +907,65 @@ Audit Trail: {'✅ Complete' if analysis.evidence_files else '⚠️ Generating'
 async def main():
     """Main CLI interface for comprehensive cost analysis."""
     import argparse
-    
+
     parser = argparse.ArgumentParser(
         description="Comprehensive AWS Cost Explorer Integration with MCP Validation and Terraform Alignment"
     )
+    parser.add_argument("--account-filter", help="Specific AWS account ID to analyze")
+    parser.add_argument("--analysis-days", type=int, default=90, help="Number of days for cost analysis (default: 90)")
+    parser.add_argument("--billing-profile", help="AWS profile for Cost Explorer access")
+    parser.add_argument("--management-profile", help="AWS profile for Organizations access")
+    parser.add_argument("--single-account-profile", help="AWS profile for single account operations")
+    parser.add_argument("--terraform-state-dir", help="Directory containing terraform state files")
+    parser.add_argument("--runbooks-evidence", help="Path to runbooks evidence file for terraform alignment")
+    parser.add_argument("--skip-terraform", action="store_true", help="Skip terraform alignment validation")
     parser.add_argument(
-        "--account-filter",
-        help="Specific AWS account ID to analyze"
+        "--validation-tolerance", type=float, default=5.0, help="MCP validation tolerance percentage (default: 5.0)"
     )
-    parser.add_argument(
-        "--analysis-days",
-        type=int,
-        default=90,
-        help="Number of days for cost analysis (default: 90)"
-    )
-    parser.add_argument(
-        "--billing-profile",
-        help="AWS profile for Cost Explorer access"
-    )
-    parser.add_argument(
-        "--management-profile",
-        help="AWS profile for Organizations access"
-    )
-    parser.add_argument(
-        "--single-account-profile",
-        help="AWS profile for single account operations"
-    )
-    parser.add_argument(
-        "--terraform-state-dir",
-        help="Directory containing terraform state files"
-    )
-    parser.add_argument(
-        "--runbooks-evidence",
-        help="Path to runbooks evidence file for terraform alignment"
-    )
-    parser.add_argument(
-        "--skip-terraform",
-        action="store_true",
-        help="Skip terraform alignment validation"
-    )
-    parser.add_argument(
-        "--validation-tolerance",
-        type=float,
-        default=5.0,
-        help="MCP validation tolerance percentage (default: 5.0)"
-    )
-    
+
     args = parser.parse_args()
-    
+
     # Initialize comprehensive integration
     integration = ComprehensiveCostExplorerIntegration(
         billing_profile=args.billing_profile,
         management_profile=args.management_profile,
         single_account_profile=args.single_account_profile,
         terraform_state_dir=args.terraform_state_dir,
-        validation_tolerance_percent=args.validation_tolerance
+        validation_tolerance_percent=args.validation_tolerance,
     )
-    
+
     try:
         # Initialize all integrations
         init_results = await integration.initialize_integrations()
-        
-        if init_results['overall_status'] == 'initialization_failed':
+
+        if init_results["overall_status"] == "initialization_failed":
             print_error("❌ Integration initialization failed - limited functionality available")
-        
+
         # Perform comprehensive cost analysis
         analysis = await integration.perform_comprehensive_cost_analysis(
             account_filter=args.account_filter,
             analysis_days=args.analysis_days,
             include_terraform_alignment=not args.skip_terraform and bool(args.runbooks_evidence),
-            runbooks_evidence_file=args.runbooks_evidence
+            runbooks_evidence_file=args.runbooks_evidence,
         )
-        
+
         # Final summary
-        if analysis.compliance_status == 'compliant':
-            print_success("✅ ENTERPRISE COMPLIANCE ACHIEVED: ≥99.5% MCP validation with complete infrastructure alignment")
+        if analysis.compliance_status == "compliant":
+            print_success(
+                "✅ ENTERPRISE COMPLIANCE ACHIEVED: ≥99.5% MCP validation with complete infrastructure alignment"
+            )
         else:
             print_warning("⚠️ COMPLIANCE REVIEW REQUIRED: Enhance MCP validation accuracy to meet enterprise standards")
-        
-        print_info(f"💰 Annual savings potential: ${analysis.annual_savings_potential:,.2f} ({analysis.roi_projection:.1f}% ROI)")
+
+        print_info(
+            f"💰 Annual savings potential: ${analysis.annual_savings_potential:,.2f} ({analysis.roi_projection:.1f}% ROI)"
+        )
         print_info(f"📊 Analysis evidence: {len(analysis.evidence_files)} files generated")
-        
+
     except Exception as e:
         print_error(f"❌ Comprehensive cost analysis failed: {str(e)}")
         raise
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())