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

runbooks/cfat/cloud_foundations_assessment.py

@@ -31,8 +31,14 @@ from botocore.exceptions import ClientError
 
 # Import runbooks enterprise standards
 from runbooks.common.rich_utils import (
-    console, print_header, print_success, print_warning, print_error,
-    create_table, create_progress_bar, create_panel
+    console,
+    print_header,
+    print_success,
+    print_warning,
+    print_error,
+    create_table,
+    create_progress_bar,
+    create_panel,
 )
 from runbooks.common.profile_utils import get_profile_for_operation
 
@@ -44,6 +50,7 @@ class CFATFinding:
     """
     CFAT assessment finding compatible with both Python and JavaScript engines
     """
+
     check_id: str
     category: str
     severity: str  # HIGH, MEDIUM, LOW
@@ -53,28 +60,29 @@ class CFATFinding:
     estimated_effort: str  # HOURS, DAYS, WEEKS
     compliance_frameworks: List[str] = field(default_factory=list)
     resources_affected: List[str] = field(default_factory=list)
-    
+
     @classmethod
-    def from_javascript_result(cls, js_result: Dict[str, Any]) -> 'CFATFinding':
+    def from_javascript_result(cls, js_result: Dict[str, Any]) -> "CFATFinding":
         """Create finding from JavaScript CFAT result"""
         return cls(
-            check_id=js_result.get('checkId', 'unknown'),
-            category=js_result.get('category', 'general'),
-            severity=js_result.get('severity', 'MEDIUM'),
-            title=js_result.get('title', ''),
-            description=js_result.get('description', ''),
-            remediation=js_result.get('remediation', ''),
-            estimated_effort=js_result.get('estimatedEffort', 'UNKNOWN'),
-            compliance_frameworks=js_result.get('complianceFrameworks', []),
-            resources_affected=js_result.get('resourcesAffected', [])
+            check_id=js_result.get("checkId", "unknown"),
+            category=js_result.get("category", "general"),
+            severity=js_result.get("severity", "MEDIUM"),
+            title=js_result.get("title", ""),
+            description=js_result.get("description", ""),
+            remediation=js_result.get("remediation", ""),
+            estimated_effort=js_result.get("estimatedEffort", "UNKNOWN"),
+            compliance_frameworks=js_result.get("complianceFrameworks", []),
+            resources_affected=js_result.get("resourcesAffected", []),
         )
 
 
-@dataclass 
+@dataclass
 class CFATAssessmentResult:
     """
     Comprehensive CFAT assessment result
     """
+
     assessment_id: str
     timestamp: datetime
     assessment_type: str  # 'python', 'javascript', 'dual'
@@ -85,29 +93,29 @@ class CFATAssessmentResult:
     summary_stats: Dict[str, int] = field(default_factory=dict)
     execution_time: float = 0.0
     artifacts_directory: Optional[str] = None
-    
+
     def __post_init__(self):
         """Calculate summary statistics"""
         if self.findings:
             self.summary_stats = {
-                'total_findings': len(self.findings),
-                'high_severity': len([f for f in self.findings if f.severity == 'HIGH']),
-                'medium_severity': len([f for f in self.findings if f.severity == 'MEDIUM']),
-                'low_severity': len([f for f in self.findings if f.severity == 'LOW']),
-                'categories': len(set(f.category for f in self.findings))
+                "total_findings": len(self.findings),
+                "high_severity": len([f for f in self.findings if f.severity == "HIGH"]),
+                "medium_severity": len([f for f in self.findings if f.severity == "MEDIUM"]),
+                "low_severity": len([f for f in self.findings if f.severity == "LOW"]),
+                "categories": len(set(f.category for f in self.findings)),
             }
 
 
 class CloudFoundationsCFATIntegration:
     """
     Cloud Foundations CFAT Integration
-    
+
     Provides dual-engine Cloud Foundation Assessment capability:
     1. JavaScript engine (cloud-foundations-templates/cfat/)
     2. Python engine integration (existing runbooks/cfat/)
     3. Unified reporting and export formats
     4. CloudShell execution compatibility
-    
+
     Key Features:
     - Dual assessment engine execution
     - Project management exports (Jira/Asana CSV)
@@ -115,67 +123,73 @@ class CloudFoundationsCFATIntegration:
     - Enterprise reporting with Rich CLI
     - MCP validation integration
     """
-    
+
     def __init__(self, profile: Optional[str] = None):
         """Initialize CFAT integration with profile management"""
         self.profile = get_profile_for_operation("management", profile)
         self.session = boto3.Session(profile_name=self.profile)
-        
+
         # JavaScript engine configuration
         self.js_engine_path = Path(__file__).parent / "cloud_foundations_js"
         self.ensure_js_engine_available()
-        
+
         print_success(f"Initialized Cloud Foundations CFAT Integration with profile: {self.profile}")
-        
+
     def ensure_js_engine_available(self):
         """Ensure JavaScript engine is available for execution"""
         # In real implementation, this would extract/setup the JS engine
         # For now, create placeholder structure
         self.js_engine_path.mkdir(exist_ok=True)
-        
-    async def run_comprehensive_assessment(self, 
-                                         cloudshell_mode: bool = False,
-                                         include_python: bool = True,
-                                         include_javascript: bool = True,
-                                         output_directory: Optional[str] = None) -> CFATAssessmentResult:
+
+    async def run_comprehensive_assessment(
+        self,
+        cloudshell_mode: bool = False,
+        include_python: bool = True,
+        include_javascript: bool = True,
+        output_directory: Optional[str] = None,
+    ) -> CFATAssessmentResult:
         """
         Run comprehensive CFAT assessment using available engines
-        
+
         Args:
             cloudshell_mode: Enable CloudShell compatibility optimizations
             include_python: Include Python-based assessment
-            include_javascript: Include JavaScript-based assessment  
+            include_javascript: Include JavaScript-based assessment
             output_directory: Directory for assessment artifacts
-            
+
         Returns:
             Comprehensive assessment result with findings from all engines
         """
         print_header("Cloud Foundations Assessment", __version__)
-        
+
         if not (include_python or include_javascript):
             raise ValueError("At least one assessment engine must be enabled")
-            
+
         # Initialize assessment result
         account_info = self._get_account_info()
         assessment_result = CFATAssessmentResult(
             assessment_id=f"cfat-{datetime.now().strftime('%Y%m%d-%H%M%S')}",
             timestamp=datetime.now(),
-            assessment_type='dual' if (include_python and include_javascript) else 'python' if include_python else 'javascript',
-            account_id=account_info['account_id'],
-            account_name=account_info['account_name'],
-            organization_id=account_info.get('organization_id'),
-            artifacts_directory=output_directory or tempfile.mkdtemp(prefix='cfat-assessment-')
+            assessment_type="dual"
+            if (include_python and include_javascript)
+            else "python"
+            if include_python
+            else "javascript",
+            account_id=account_info["account_id"],
+            account_name=account_info["account_name"],
+            organization_id=account_info.get("organization_id"),
+            artifacts_directory=output_directory or tempfile.mkdtemp(prefix="cfat-assessment-"),
         )
-        
+
         start_time = datetime.now()
-        
+
         try:
             with create_progress_bar() as progress:
                 total_tasks = (1 if include_python else 0) + (1 if include_javascript else 0) + 2
                 assessment_task = progress.add_task("Running comprehensive assessment...", total=total_tasks)
-                
+
                 all_findings = []
-                
+
                 # Run Python assessment if enabled
                 if include_python:
                     try:
@@ -185,7 +199,7 @@ class CloudFoundationsCFATIntegration:
                         progress.advance(assessment_task)
                     except Exception as e:
                         print_warning(f"Python assessment failed: {e}")
-                        
+
                 # Run JavaScript assessment if enabled
                 if include_javascript:
                     try:
@@ -195,82 +209,84 @@ class CloudFoundationsCFATIntegration:
                         progress.advance(assessment_task)
                     except Exception as e:
                         print_warning(f"JavaScript assessment failed: {e}")
-                        
+
                 # Consolidate findings
                 assessment_result.findings = self._consolidate_findings(all_findings)
                 progress.advance(assessment_task)
-                
+
                 # Generate artifacts
                 await self._generate_assessment_artifacts(assessment_result)
                 progress.advance(assessment_task)
-                
+
             assessment_result.execution_time = (datetime.now() - start_time).total_seconds()
-            print_success(f"Assessment completed in {assessment_result.execution_time:.1f}s with {len(assessment_result.findings)} findings")
-            
+            print_success(
+                f"Assessment completed in {assessment_result.execution_time:.1f}s with {len(assessment_result.findings)} findings"
+            )
+
             return assessment_result
-            
+
         except Exception as e:
             print_error(f"Assessment execution failed: {e}")
             raise
-            
+
     async def _run_python_assessment(self, cloudshell_mode: bool) -> List[CFATFinding]:
         """
         Run Python-based CFAT assessment
         Integration with existing runbooks CFAT module
         """
         findings = []
-        
+
         try:
             # Import existing CFAT functionality
             from runbooks.cfat.cfat_runner import CFATRunner
-            
+
             cfat_runner = CFATRunner(profile=self.profile)
             python_results = await cfat_runner.run_assessment()
-            
+
             # Convert Python results to standardized findings
-            for result in python_results.get('findings', []):
+            for result in python_results.get("findings", []):
                 finding = CFATFinding(
-                    check_id=result.get('check_id', 'python-check'),
-                    category=result.get('category', 'governance'),
-                    severity=result.get('severity', 'MEDIUM'),
-                    title=result.get('title', ''),
-                    description=result.get('description', ''),
-                    remediation=result.get('remediation', ''),
-                    estimated_effort=result.get('effort', 'UNKNOWN')
+                    check_id=result.get("check_id", "python-check"),
+                    category=result.get("category", "governance"),
+                    severity=result.get("severity", "MEDIUM"),
+                    title=result.get("title", ""),
+                    description=result.get("description", ""),
+                    remediation=result.get("remediation", ""),
+                    estimated_effort=result.get("effort", "UNKNOWN"),
                 )
                 findings.append(finding)
-                
+
         except ImportError:
             print_warning("Existing Python CFAT module not available, skipping Python assessment")
         except Exception as e:
             print_error(f"Python assessment execution failed: {e}")
-            
+
         return findings
-        
+
     async def _run_javascript_assessment(self, cloudshell_mode: bool) -> List[CFATFinding]:
         """
         Run JavaScript-based CFAT assessment
         Based on cloud-foundations-templates/cfat/ engine
         """
         findings = []
-        
+
         try:
             # Prepare JavaScript execution environment
             js_command = self._prepare_javascript_command(cloudshell_mode)
-            
+
             # Execute JavaScript assessment
             result = subprocess.run(
                 js_command,
                 capture_output=True,
                 text=True,
                 timeout=300,  # 5 minute timeout
-                cwd=self.js_engine_path
+                cwd=self.js_engine_path,
             )
-            
+
             if result.returncode == 0:
                 # Parse JavaScript assessment output
                 js_results = self._parse_javascript_output(result.stdout)
-                
+
                 # Convert to standardized findings
                 for js_result in js_results:
                     finding = CFATFinding.from_javascript_result(js_result)
@@ -278,14 +294,14 @@ class CloudFoundationsCFATIntegration:
             else:
                 print_warning(f"JavaScript assessment returned non-zero exit code: {result.returncode}")
                 print_warning(f"stderr: {result.stderr}")
-                
+
         except subprocess.TimeoutExpired:
             print_error("JavaScript assessment timed out after 5 minutes")
         except Exception as e:
             print_error(f"JavaScript assessment execution failed: {e}")
-            
+
         return findings
-        
+
     def _prepare_javascript_command(self, cloudshell_mode: bool) -> List[str]:
         """
         Prepare JavaScript execution command
@@ -293,32 +309,27 @@ class CloudFoundationsCFATIntegration:
         """
         if cloudshell_mode:
             # CloudShell optimized execution
-            return [
-                'bash', '-c',
-                f'cd {self.js_engine_path} && AWS_PROFILE={self.profile} node app.js'
-            ]
+            return ["bash", "-c", f"cd {self.js_engine_path} && AWS_PROFILE={self.profile} node app.js"]
         else:
             # Local execution
-            return [
-                'node', 'app.js'
-            ]
-            
+            return ["node", "app.js"]
+
     def _parse_javascript_output(self, stdout: str) -> List[Dict[str, Any]]:
         """Parse JavaScript assessment output to structured findings"""
         # In real implementation, this would parse the actual JS CFAT output format
         # For demonstration, return mock structure
         return [
             {
-                'checkId': 'js-org-001',
-                'category': 'organization',
-                'severity': 'HIGH',
-                'title': 'Organization Structure Assessment',
-                'description': 'Organization structure needs improvement',
-                'remediation': 'Implement proper OU structure',
-                'estimatedEffort': 'DAYS'
+                "checkId": "js-org-001",
+                "category": "organization",
+                "severity": "HIGH",
+                "title": "Organization Structure Assessment",
+                "description": "Organization structure needs improvement",
+                "remediation": "Implement proper OU structure",
+                "estimatedEffort": "DAYS",
             }
         ]
-        
+
     def _consolidate_findings(self, all_findings: List[CFATFinding]) -> List[CFATFinding]:
         """
         Consolidate findings from multiple engines, removing duplicates
@@ -327,14 +338,14 @@ class CloudFoundationsCFATIntegration:
         # In real implementation, would use more sophisticated matching
         seen_checks = set()
         consolidated = []
-        
+
         for finding in all_findings:
             if finding.check_id not in seen_checks:
                 seen_checks.add(finding.check_id)
                 consolidated.append(finding)
-                
+
         return consolidated
-        
+
     async def _generate_assessment_artifacts(self, assessment: CFATAssessmentResult):
         """
         Generate comprehensive assessment artifacts
@@ -342,46 +353,46 @@ class CloudFoundationsCFATIntegration:
         """
         artifacts_path = Path(assessment.artifacts_directory)
         artifacts_path.mkdir(exist_ok=True)
-        
+
         # Generate detailed report
         await self._generate_detailed_report(assessment, artifacts_path)
-        
+
         # Generate CSV exports
         await self._generate_csv_exports(assessment, artifacts_path)
-        
+
         # Generate project management imports
         await self._generate_project_management_exports(assessment, artifacts_path)
-        
+
         # Create assessment archive
         await self._create_assessment_archive(assessment, artifacts_path)
-        
+
     async def _generate_detailed_report(self, assessment: CFATAssessmentResult, artifacts_path: Path):
         """Generate detailed text report"""
         report_file = artifacts_path / "cfat-detailed-report.txt"
-        
-        with open(report_file, 'w') as f:
-            f.write("="*80 + "\n")
+
+        with open(report_file, "w") as f:
+            f.write("=" * 80 + "\n")
             f.write("CLOUD FOUNDATIONS ASSESSMENT REPORT\n")
-            f.write("="*80 + "\n")
+            f.write("=" * 80 + "\n")
             f.write(f"Assessment ID: {assessment.assessment_id}\n")
             f.write(f"Timestamp: {assessment.timestamp}\n")
             f.write(f"Account: {assessment.account_name} ({assessment.account_id})\n")
             f.write(f"Assessment Type: {assessment.assessment_type}\n")
             f.write(f"Execution Time: {assessment.execution_time:.1f}s\n")
             f.write("\n")
-            
+
             f.write("EXECUTIVE SUMMARY\n")
-            f.write("-"*40 + "\n")
+            f.write("-" * 40 + "\n")
             f.write(f"Total Findings: {assessment.summary_stats.get('total_findings', 0)}\n")
             f.write(f"High Severity: {assessment.summary_stats.get('high_severity', 0)}\n")
             f.write(f"Medium Severity: {assessment.summary_stats.get('medium_severity', 0)}\n")
             f.write(f"Low Severity: {assessment.summary_stats.get('low_severity', 0)}\n")
             f.write(f"Categories: {assessment.summary_stats.get('categories', 0)}\n")
             f.write("\n")
-            
+
             f.write("DETAILED FINDINGS\n")
-            f.write("-"*40 + "\n")
-            
+            f.write("-" * 40 + "\n")
+
             for finding in assessment.findings:
                 f.write(f"Finding: {finding.title}\n")
                 f.write(f"Category: {finding.category}\n")
@@ -389,28 +400,30 @@ class CloudFoundationsCFATIntegration:
                 f.write(f"Description: {finding.description}\n")
                 f.write(f"Remediation: {finding.remediation}\n")
                 f.write(f"Estimated Effort: {finding.estimated_effort}\n")
-                f.write("-"*40 + "\n")
-                
+                f.write("-" * 40 + "\n")
+
     async def _generate_csv_exports(self, assessment: CFATAssessmentResult, artifacts_path: Path):
         """Generate CSV exports for analysis"""
         csv_file = artifacts_path / "cfat-findings.csv"
-        
-        with open(csv_file, 'w', newline='') as csvfile:
-            fieldnames = ['check_id', 'category', 'severity', 'title', 'description', 'remediation', 'estimated_effort']
+
+        with open(csv_file, "w", newline="") as csvfile:
+            fieldnames = ["check_id", "category", "severity", "title", "description", "remediation", "estimated_effort"]
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-            
+
             writer.writeheader()
             for finding in assessment.findings:
-                writer.writerow({
-                    'check_id': finding.check_id,
-                    'category': finding.category,
-                    'severity': finding.severity,
-                    'title': finding.title,
-                    'description': finding.description,
-                    'remediation': finding.remediation,
-                    'estimated_effort': finding.estimated_effort
-                })
-                
+                writer.writerow(
+                    {
+                        "check_id": finding.check_id,
+                        "category": finding.category,
+                        "severity": finding.severity,
+                        "title": finding.title,
+                        "description": finding.description,
+                        "remediation": finding.remediation,
+                        "estimated_effort": finding.estimated_effort,
+                    }
+                )
+
     async def _generate_project_management_exports(self, assessment: CFATAssessmentResult, artifacts_path: Path):
         """
         Generate project management import files
@@ -418,155 +431,135 @@ class CloudFoundationsCFATIntegration:
         """
         # Jira import
         jira_file = artifacts_path / "jira-import.csv"
-        with open(jira_file, 'w', newline='') as csvfile:
-            fieldnames = ['Summary', 'Issue Type', 'Priority', 'Description', 'Labels', 'Epic Link']
+        with open(jira_file, "w", newline="") as csvfile:
+            fieldnames = ["Summary", "Issue Type", "Priority", "Description", "Labels", "Epic Link"]
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-            
+
             writer.writeheader()
             for finding in assessment.findings:
-                writer.writerow({
-                    'Summary': finding.title,
-                    'Issue Type': 'Task',
-                    'Priority': self._map_severity_to_jira_priority(finding.severity),
-                    'Description': f"{finding.description}\n\nRemediation: {finding.remediation}",
-                    'Labels': f"cfat,{finding.category},{finding.severity.lower()}",
-                    'Epic Link': 'Cloud Foundations Assessment'
-                })
-                
+                writer.writerow(
+                    {
+                        "Summary": finding.title,
+                        "Issue Type": "Task",
+                        "Priority": self._map_severity_to_jira_priority(finding.severity),
+                        "Description": f"{finding.description}\n\nRemediation: {finding.remediation}",
+                        "Labels": f"cfat,{finding.category},{finding.severity.lower()}",
+                        "Epic Link": "Cloud Foundations Assessment",
+                    }
+                )
+
         # Asana import
         asana_file = artifacts_path / "asana-import.csv"
-        with open(asana_file, 'w', newline='') as csvfile:
-            fieldnames = ['Name', 'Notes', 'Priority', 'Tags', 'Projects']
+        with open(asana_file, "w", newline="") as csvfile:
+            fieldnames = ["Name", "Notes", "Priority", "Tags", "Projects"]
             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-            
+
             writer.writeheader()
             for finding in assessment.findings:
-                writer.writerow({
-                    'Name': finding.title,
-                    'Notes': f"{finding.description}\n\nRemediation: {finding.remediation}",
-                    'Priority': self._map_severity_to_asana_priority(finding.severity),
-                    'Tags': f"cfat,{finding.category}",
-                    'Projects': 'Cloud Foundations Assessment'
-                })
-                
+                writer.writerow(
+                    {
+                        "Name": finding.title,
+                        "Notes": f"{finding.description}\n\nRemediation: {finding.remediation}",
+                        "Priority": self._map_severity_to_asana_priority(finding.severity),
+                        "Tags": f"cfat,{finding.category}",
+                        "Projects": "Cloud Foundations Assessment",
+                    }
+                )
+
     def _map_severity_to_jira_priority(self, severity: str) -> str:
         """Map CFAT severity to Jira priority"""
-        mapping = {
-            'HIGH': 'High',
-            'MEDIUM': 'Medium', 
-            'LOW': 'Low'
-        }
-        return mapping.get(severity, 'Medium')
-        
+        mapping = {"HIGH": "High", "MEDIUM": "Medium", "LOW": "Low"}
+        return mapping.get(severity, "Medium")
+
     def _map_severity_to_asana_priority(self, severity: str) -> str:
         """Map CFAT severity to Asana priority"""
-        mapping = {
-            'HIGH': 'High',
-            'MEDIUM': 'Medium',
-            'LOW': 'Low'
-        }
-        return mapping.get(severity, 'Medium')
-        
+        mapping = {"HIGH": "High", "MEDIUM": "Medium", "LOW": "Low"}
+        return mapping.get(severity, "Medium")
+
     async def _create_assessment_archive(self, assessment: CFATAssessmentResult, artifacts_path: Path):
         """Create zip archive of all assessment artifacts"""
         archive_file = artifacts_path / "assessment.zip"
-        
-        with zipfile.ZipFile(archive_file, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            for file_path in artifacts_path.glob('*'):
-                if file_path.name != 'assessment.zip':  # Don't include the zip itself
+
+        with zipfile.ZipFile(archive_file, "w", zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in artifacts_path.glob("*"):
+                if file_path.name != "assessment.zip":  # Don't include the zip itself
                     zipf.write(file_path, file_path.name)
-                    
+
         print_success(f"Assessment archive created: {archive_file}")
-        
+
     def _get_account_info(self) -> Dict[str, str]:
         """Get current account information"""
         try:
-            sts = self.session.client('sts')
+            sts = self.session.client("sts")
             identity = sts.get_caller_identity()
-            
-            account_id = identity['Account']
-            
+
+            account_id = identity["Account"]
+
             # Try to get account name from organizations
             account_name = account_id  # Default to account ID
             org_id = None
-            
+
             try:
-                orgs = self.session.client('organizations')
+                orgs = self.session.client("organizations")
                 account = orgs.describe_account(AccountId=account_id)
-                account_name = account['Account']['Name']
-                
+                account_name = account["Account"]["Name"]
+
                 org_info = orgs.describe_organization()
-                org_id = org_info['Organization']['Id']
+                org_id = org_info["Organization"]["Id"]
             except ClientError:
                 pass  # Not in organization or no permission
-                
-            return {
-                'account_id': account_id,
-                'account_name': account_name,
-                'organization_id': org_id
-            }
-            
+
+            return {"account_id": account_id, "account_name": account_name, "organization_id": org_id}
+
         except ClientError as e:
             print_error(f"Failed to get account information: {e}")
             raise
-            
+
     def display_assessment_summary(self, assessment: CFATAssessmentResult):
         """
         Display assessment summary with Rich CLI formatting
         """
         print_header("Assessment Results Summary", __version__)
-        
+
         # Executive summary table
-        summary_table = create_table(
-            title="Executive Summary",
-            caption=f"Assessment ID: {assessment.assessment_id}"
-        )
-        
+        summary_table = create_table(title="Executive Summary", caption=f"Assessment ID: {assessment.assessment_id}")
+
         summary_table.add_column("Metric", style="cyan")
         summary_table.add_column("Value", justify="right", style="green")
         summary_table.add_column("Impact", style="yellow")
-        
+
         impact_levels = {
-            'total_findings': 'Requires attention',
-            'high_severity': 'Immediate action',
-            'medium_severity': 'Plan remediation',
-            'low_severity': 'Schedule improvement'
+            "total_findings": "Requires attention",
+            "high_severity": "Immediate action",
+            "medium_severity": "Plan remediation",
+            "low_severity": "Schedule improvement",
         }
-        
+
         for metric, value in assessment.summary_stats.items():
-            impact = impact_levels.get(metric, 'Review needed')
-            summary_table.add_row(
-                metric.replace('_', ' ').title(),
-                str(value),
-                impact
-            )
-            
+            impact = impact_levels.get(metric, "Review needed")
+            summary_table.add_row(metric.replace("_", " ").title(), str(value), impact)
+
         console.print(summary_table)
-        
+
         # Findings by category
         if assessment.findings:
             category_stats = {}
             for finding in assessment.findings:
                 if finding.category not in category_stats:
-                    category_stats[finding.category] = {'high': 0, 'medium': 0, 'low': 0}
+                    category_stats[finding.category] = {"high": 0, "medium": 0, "low": 0}
                 category_stats[finding.category][finding.severity.lower()] += 1
-                
+
             category_table = create_table(title="Findings by Category")
             category_table.add_column("Category", style="cyan")
             category_table.add_column("High", justify="right", style="red")
             category_table.add_column("Medium", justify="right", style="yellow")
             category_table.add_column("Low", justify="right", style="green")
-            
+
             for category, stats in category_stats.items():
-                category_table.add_row(
-                    category.title(),
-                    str(stats['high']),
-                    str(stats['medium']),
-                    str(stats['low'])
-                )
-                
+                category_table.add_row(category.title(), str(stats["high"]), str(stats["medium"]), str(stats["low"]))
+
             console.print(category_table)
-            
+
         # Assessment details panel
         details_text = f"""
 Assessment Type: {assessment.assessment_type}
@@ -574,12 +567,8 @@ Account: {assessment.account_name} ({assessment.account_id})
 Execution Time: {assessment.execution_time:.1f} seconds
 Artifacts: {assessment.artifacts_directory}
         """
-        
-        details_panel = create_panel(
-            details_text,
-            title="Assessment Details",
-            style="blue"
-        )
+
+        details_panel = create_panel(details_text, title="Assessment Details", style="blue")
         console.print(details_panel)
 
 
@@ -588,34 +577,32 @@ async def main():
     Demonstration of CFAT Cloud Foundations integration
     """
     import argparse
-    
-    parser = argparse.ArgumentParser(
-        description="CFAT Cloud Foundations Integration - Dual Engine Assessment"
-    )
-    parser.add_argument('--profile', help='AWS profile to use')
-    parser.add_argument('--cloudshell', action='store_true', help='Enable CloudShell compatibility mode')
-    parser.add_argument('--python-only', action='store_true', help='Run Python assessment only')
-    parser.add_argument('--javascript-only', action='store_true', help='Run JavaScript assessment only')
-    parser.add_argument('--output-dir', help='Output directory for artifacts')
-    
+
+    parser = argparse.ArgumentParser(description="CFAT Cloud Foundations Integration - Dual Engine Assessment")
+    parser.add_argument("--profile", help="AWS profile to use")
+    parser.add_argument("--cloudshell", action="store_true", help="Enable CloudShell compatibility mode")
+    parser.add_argument("--python-only", action="store_true", help="Run Python assessment only")
+    parser.add_argument("--javascript-only", action="store_true", help="Run JavaScript assessment only")
+    parser.add_argument("--output-dir", help="Output directory for artifacts")
+
     args = parser.parse_args()
-    
+
     try:
         cfat_integration = CloudFoundationsCFATIntegration(profile=args.profile)
-        
+
         # Run comprehensive assessment
         result = await cfat_integration.run_comprehensive_assessment(
             cloudshell_mode=args.cloudshell,
             include_python=not args.javascript_only,
             include_javascript=not args.python_only,
-            output_directory=args.output_dir
+            output_directory=args.output_dir,
         )
-        
+
         # Display results
         cfat_integration.display_assessment_summary(result)
-        
+
         print_success("CFAT Cloud Foundations integration demonstration completed")
-        
+
     except Exception as e:
         print_error(f"CFAT integration demonstration failed: {e}")
         raise
@@ -623,4 +610,5 @@ async def main():
 
 if __name__ == "__main__":
     import asyncio
-    asyncio.run(main())
+
+    asyncio.run(main())