souleyez 2.43.29__py3-none-any.whl → 3.0.0__py3-none-any.whl

souleyez/reporting/generator.py

@@ -34,12 +34,19 @@ class ReportGenerator:
         """Lazy load AI report service."""
         if self._ai_service is None:
             from souleyez.ai.report_service import AIReportService
+
             self._ai_service = AIReportService()
         return self._ai_service
 
-    def generate_report(self, engagement_id: int, format: str = 'markdown',
-                       output_path: Optional[str] = None, report_type: str = 'technical',
-                       ai_enhanced: bool = False, compare_to: Optional[int] = None) -> str:
+    def generate_report(
+        self,
+        engagement_id: int,
+        format: str = "markdown",
+        output_path: Optional[str] = None,
+        report_type: str = "technical",
+        ai_enhanced: bool = False,
+        compare_to: Optional[int] = None,
+    ) -> str:
         """
         Generate comprehensive pentest report.
 
@@ -59,46 +66,48 @@ class ReportGenerator:
             self._check_ai_permission()
 
         # Validate report type
-        valid_types = ['executive', 'technical', 'summary', 'detection']
+        valid_types = ["executive", "technical", "summary", "detection"]
         if report_type not in valid_types:
-            raise ValueError(f"Invalid report_type '{report_type}'. Must be one of: {', '.join(valid_types)}")
+            raise ValueError(
+                f"Invalid report_type '{report_type}'. Must be one of: {', '.join(valid_types)}"
+            )
 
         # Detection reports use a different generation path
-        if report_type == 'detection':
-            return self._generate_detection_report(
-                engagement_id, format, output_path
-            )
+        if report_type == "detection":
+            return self._generate_detection_report(engagement_id, format, output_path)
 
         # Gather all data
         data = self._gather_report_data(engagement_id)
-        data['report_type'] = report_type
-        data['ai_enhanced'] = ai_enhanced
+        data["report_type"] = report_type
+        data["ai_enhanced"] = ai_enhanced
 
         # Gather comparison data if requested
         if compare_to:
-            data['comparison'] = self._gather_comparison_data(compare_to)
+            data["comparison"] = self._gather_comparison_data(compare_to)
         else:
-            data['comparison'] = None
+            data["comparison"] = None
 
         # Generate AI content if enabled
         if ai_enhanced:
             if self.ai_service.is_available():
                 logger.info("AI enhancement enabled - generating AI content")
-                data['ai_content'] = self._generate_ai_content(engagement_id, data)
+                data["ai_content"] = self._generate_ai_content(engagement_id, data)
             else:
-                logger.warning("AI enhancement requested but provider not available - falling back to standard report")
-                data['ai_content'] = None
+                logger.warning(
+                    "AI enhancement requested but provider not available - falling back to standard report"
+                )
+                data["ai_content"] = None
         else:
-            data['ai_content'] = None
+            data["ai_content"] = None
 
         # Generate report based on format
-        if format == 'markdown':
+        if format == "markdown":
             report_content = self._generate_markdown(data)
-            ext = '.md'
-        elif format == 'html':
+            ext = ".md"
+        elif format == "html":
             report_content = self._generate_html(data)
-            ext = '.html'
-        elif format == 'pdf':
+            ext = ".html"
+        elif format == "pdf":
             # Generate HTML first, then convert to PDF
             html_content = self._generate_html(data)
             return self._convert_to_pdf(html_content, data, output_path)
@@ -107,10 +116,10 @@ class ReportGenerator:
 
         # Write report to file
         if not output_path:
-            output_path = self._default_output_path(data['engagement']['name'], ext)
+            output_path = self._default_output_path(data["engagement"]["name"], ext)
 
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        with open(output_path, 'w', encoding='utf-8') as f:
+        with open(output_path, "w", encoding="utf-8") as f:
             f.write(report_content)
 
         return output_path
@@ -125,58 +134,66 @@ class ReportGenerator:
 
         # Organize findings by severity
         findings_by_severity = {
-            'critical': [],
-            'high': [],
-            'medium': [],
-            'low': [],
-            'info': []
+            "critical": [],
+            "high": [],
+            "medium": [],
+            "low": [],
+            "info": [],
         }
         for finding in findings:
-            severity = finding.get('severity', 'info')
+            severity = finding.get("severity", "info")
             findings_by_severity[severity].append(finding)
 
         # Evidence counts
         evidence_counts = {
-            'reconnaissance': len(evidence.get('reconnaissance', [])),
-            'enumeration': len(evidence.get('enumeration', [])),
-            'exploitation': len(evidence.get('exploitation', [])),
-            'post_exploitation': len(evidence.get('post_exploitation', []))
+            "reconnaissance": len(evidence.get("reconnaissance", [])),
+            "enumeration": len(evidence.get("enumeration", [])),
+            "exploitation": len(evidence.get("exploitation", [])),
+            "post_exploitation": len(evidence.get("post_exploitation", [])),
         }
-        
+
         # Collect unique tools used from findings and evidence
         tools_used = set()
-        
+
         # Tools from findings
         for finding in findings:
-            tool = finding.get('tool')
-            if tool and tool.strip() and tool.lower() not in ['unknown', 'none', 'n/a']:
+            tool = finding.get("tool")
+            if tool and tool.strip() and tool.lower() not in ["unknown", "none", "n/a"]:
                 tools_used.add(tool)
-        
+
         # Tools from evidence (all phases)
         for phase_evidence in evidence.values():
             if isinstance(phase_evidence, list):
                 for item in phase_evidence:
                     if isinstance(item, dict):
-                        tool = item.get('tool')
-                        if tool and tool.strip() and tool.lower() not in ['unknown', 'none', 'n/a']:
+                        tool = item.get("tool")
+                        if (
+                            tool
+                            and tool.strip()
+                            and tool.lower() not in ["unknown", "none", "n/a"]
+                        ):
                             tools_used.add(tool)
-        
+
         # Tools from credentials
         for cred in credentials:
-            source = cred.get('source')
-            if source and source.strip() and source.lower() not in ['unknown', 'none', 'n/a']:
+            source = cred.get("source")
+            if (
+                source
+                and source.strip()
+                and source.lower() not in ["unknown", "none", "n/a"]
+            ):
                 tools_used.add(source)
 
         return {
-            'engagement': engagement,
-            'attack_surface': attack_surface,
-            'findings': findings,
-            'findings_by_severity': findings_by_severity,
-            'credentials': credentials,
-            'evidence': evidence,
-            'evidence_counts': evidence_counts,
-            'tools_used': sorted(list(tools_used)),  # Sorted list of unique tools
-            'generated_at': datetime.now()
+            "engagement": engagement,
+            "attack_surface": attack_surface,
+            "findings": findings,
+            "findings_by_severity": findings_by_severity,
+            "credentials": credentials,
+            "evidence": evidence,
+            "evidence_counts": evidence_counts,
+            "tools_used": sorted(list(tools_used)),  # Sorted list of unique tools
+            "generated_at": datetime.now(),
         }
 
     def _gather_comparison_data(self, previous_engagement_id: int) -> Optional[Dict]:
@@ -193,7 +210,9 @@ class ReportGenerator:
         try:
             previous_engagement = self.em.get_by_id(previous_engagement_id)
             if not previous_engagement:
-                logger.warning(f"Previous engagement {previous_engagement_id} not found")
+                logger.warning(
+                    f"Previous engagement {previous_engagement_id} not found"
+                )
                 return None
 
             # Gather previous engagement data
@@ -204,10 +223,10 @@ class ReportGenerator:
             previous_metrics = metrics_calc.get_dashboard_metrics(previous_data)
 
             return {
-                'engagement': previous_engagement,
-                'metrics': previous_metrics,
-                'findings_by_severity': previous_data['findings_by_severity'],
-                'data': previous_data
+                "engagement": previous_engagement,
+                "metrics": previous_metrics,
+                "findings_by_severity": previous_data["findings_by_severity"],
+                "data": previous_data,
             }
         except Exception as e:
             logger.warning(f"Failed to gather comparison data: {e}")
@@ -221,66 +240,80 @@ class ReportGenerator:
         sections = []
 
         # Title page
-        sections.append(formatter.title_page(data['engagement'], data['generated_at']))
+        sections.append(formatter.title_page(data["engagement"], data["generated_at"]))
 
         # Table of contents
         sections.append(formatter.table_of_contents())
 
         # Get report type and AI content
-        report_type = data.get('report_type', 'technical')
-        ai_content = data.get('ai_content')
+        report_type = data.get("report_type", "technical")
+        ai_content = data.get("ai_content")
 
         # Executive Summary (AI-enhanced if available)
-        if ai_content and ai_content.get('executive_summary'):
-            sections.append(formatter.ai_executive_summary(
-                ai_content['executive_summary'],
-                ai_content.get('provider', 'AI')
-            ))
+        if ai_content and ai_content.get("executive_summary"):
+            sections.append(
+                formatter.ai_executive_summary(
+                    ai_content["executive_summary"], ai_content.get("provider", "AI")
+                )
+            )
         else:
-            sections.append(formatter.executive_summary(
-                data['engagement'],
-                data['findings_by_severity'],
-                data['attack_surface']['overview'],
-                report_type
-            ))
+            sections.append(
+                formatter.executive_summary(
+                    data["engagement"],
+                    data["findings_by_severity"],
+                    data["attack_surface"]["overview"],
+                    report_type,
+                )
+            )
 
         # Engagement Overview
-        sections.append(formatter.engagement_overview(data['engagement'], data['tools_used'], report_type))
+        sections.append(
+            formatter.engagement_overview(
+                data["engagement"], data["tools_used"], report_type
+            )
+        )
 
         # Note: Attack Surface section removed - now covered by Intelligence Hub
 
         # Findings Summary
-        sections.append(formatter.findings_summary(data['findings_by_severity']))
-        
+        sections.append(formatter.findings_summary(data["findings_by_severity"]))
+
         # Key Findings Summary (Top Critical/High) - for quick scanning
-        sections.append(formatter.key_findings_summary(data['findings_by_severity']))
+        sections.append(formatter.key_findings_summary(data["findings_by_severity"]))
 
         # Detailed Findings
-        sections.append(formatter.detailed_findings(data['findings_by_severity'], report_type))
+        sections.append(
+            formatter.detailed_findings(data["findings_by_severity"], report_type)
+        )
 
         # Note: Evidence section removed - evidence is now displayed with each finding card
 
         # Recommendations (AI-enhanced if available)
-        if ai_content and ai_content.get('remediation_plan'):
-            sections.append(formatter.ai_remediation_plan(
-                ai_content['remediation_plan'],
-                ai_content.get('provider', 'AI')
-            ))
+        if ai_content and ai_content.get("remediation_plan"):
+            sections.append(
+                formatter.ai_remediation_plan(
+                    ai_content["remediation_plan"], ai_content.get("provider", "AI")
+                )
+            )
         else:
-            sections.append(formatter.recommendations(
-                data['findings_by_severity'],
-                data['attack_surface']['recommendations']
-            ))
+            sections.append(
+                formatter.recommendations(
+                    data["findings_by_severity"],
+                    data["attack_surface"]["recommendations"],
+                )
+            )
 
         # Appendix with Methodology (moved here for cleaner report flow)
-        sections.append(formatter.appendix(
-            data['attack_surface']['hosts'],
-            data['credentials'],
-            include_methodology=True
-        ))
+        sections.append(
+            formatter.appendix(
+                data["attack_surface"]["hosts"],
+                data["credentials"],
+                include_methodology=True,
+            )
+        )
 
         # Footer
-        sections.append(formatter.footer(data['generated_at']))
+        sections.append(formatter.footer(data["generated_at"]))
 
         return "\n\n".join(sections)
 
@@ -301,100 +334,105 @@ class ReportGenerator:
         chain_analyzer = AttackChainAnalyzer()
 
         # Get report type
-        report_type = data.get('report_type', 'technical')
+        report_type = data.get("report_type", "technical")
 
         # Calculate metrics, charts, and compliance
         metrics = metrics_calc.get_dashboard_metrics(data)
         charts = chart_gen.generate_all_charts(data)
-        
+
         # Get all findings as flat list for compliance mapping
         all_findings = []
-        for severity_findings in data['findings_by_severity'].values():
+        for severity_findings in data["findings_by_severity"].values():
             all_findings.extend(severity_findings)
         compliance_data = compliance_mapper.get_compliance_coverage(all_findings)
-        
+
         # Build attack chain (legacy)
         attack_chain = chain_analyzer.build_attack_chain(
-            data.get('evidence', {}),
-            all_findings,
-            data.get('credentials', [])
+            data.get("evidence", {}), all_findings, data.get("credentials", [])
         )
         attack_summary = chain_analyzer.get_attack_summary(attack_chain)
 
         # Build host-centric attack chain (new visualization)
         host_centric_chain = chain_analyzer.build_host_centric_chain(
-            data.get('evidence', {}),
+            data.get("evidence", {}),
             all_findings,
-            data.get('credentials', []),
-            data.get('attack_surface')
+            data.get("credentials", []),
+            data.get("attack_surface"),
         )
 
         sections = []
-        ai_content = data.get('ai_content')
+        ai_content = data.get("ai_content")
 
         # Title page (all types)
-        sections.append(md_formatter.title_page(data['engagement'], data['generated_at']))
+        sections.append(
+            md_formatter.title_page(data["engagement"], data["generated_at"])
+        )
 
         # Executive One-Pager (first page summary - all report types)
-        sections.append(formatter.executive_one_pager(
-            metrics,
-            data['findings_by_severity'],
-            data['engagement']
-        ))
+        sections.append(
+            formatter.executive_one_pager(
+                metrics, data["findings_by_severity"], data["engagement"]
+            )
+        )
 
         # Compare to Previous (if comparison data provided)
-        comparison = data.get('comparison')
+        comparison = data.get("comparison")
         if comparison:
-            sections.append(formatter.compare_to_previous(
-                metrics,
-                comparison['metrics'],
-                data['engagement'],
-                comparison['engagement']
-            ))
+            sections.append(
+                formatter.compare_to_previous(
+                    metrics,
+                    comparison["metrics"],
+                    data["engagement"],
+                    comparison["engagement"],
+                )
+            )
 
         # Table of contents (technical only)
-        if report_type in ['technical', 'executive']:
+        if report_type in ["technical", "executive"]:
             sections.append(md_formatter.table_of_contents())
 
         # Executive Summary (AI-enhanced if available)
-        if ai_content and ai_content.get('executive_summary'):
-            sections.append(formatter.ai_executive_summary(
-                ai_content['executive_summary'],
-                ai_content.get('provider', 'AI')
-            ))
+        if ai_content and ai_content.get("executive_summary"):
+            sections.append(
+                formatter.ai_executive_summary(
+                    ai_content["executive_summary"], ai_content.get("provider", "AI")
+                )
+            )
         else:
-            sections.append(md_formatter.executive_summary(
-                data['engagement'],
-                data['findings_by_severity'],
-                data['attack_surface']['overview'],
-                report_type
-            ))
+            sections.append(
+                md_formatter.executive_summary(
+                    data["engagement"],
+                    data["findings_by_severity"],
+                    data["attack_surface"]["overview"],
+                    report_type,
+                )
+            )
 
         # Intelligence Hub (all report types - near the top for visibility)
-        sections.append(formatter.intelligence_hub_section(data['attack_surface']))
+        sections.append(formatter.intelligence_hub_section(data["attack_surface"]))
 
         # Risk Quadrant (visual risk matrix - all report types)
-        sections.append(formatter.risk_quadrant(data['findings_by_severity']))
+        sections.append(formatter.risk_quadrant(data["findings_by_severity"]))
 
         # Remediation Timeline (visual timeline - all report types)
         sections.append(formatter.remediation_timeline(metrics))
 
         # Executive Dashboard (executive and summary)
-        if report_type in ['executive', 'summary']:
+        if report_type in ["executive", "summary"]:
             sections.append(formatter.executive_dashboard(metrics))
 
         # Charts Section
-        if report_type == 'executive':
+        if report_type == "executive":
             # Executive: Key charts only (severity, exploitation rate)
             exec_charts = {
-                'severity_distribution': charts.get('severity_distribution'),
-                'exploitation_progress': charts.get('exploitation_progress')
+                "severity_distribution": charts.get("severity_distribution"),
+                "exploitation_progress": charts.get("exploitation_progress"),
             }
             sections.append(formatter.charts_section(exec_charts))
-        elif report_type == 'summary':
+        elif report_type == "summary":
             # Summary: Basic chart only
             summary_charts = {
-                'severity_distribution': charts.get('severity_distribution')
+                "severity_distribution": charts.get("severity_distribution")
             }
             sections.append(formatter.charts_section(summary_charts))
         else:
@@ -402,95 +440,115 @@ class ReportGenerator:
             sections.append(formatter.charts_section(charts))
 
         # Engagement Overview (technical only)
-        if report_type == 'technical':
-            sections.append(md_formatter.engagement_overview(data['engagement'], data['tools_used'], report_type))
+        if report_type == "technical":
+            sections.append(
+                md_formatter.engagement_overview(
+                    data["engagement"], data["tools_used"], report_type
+                )
+            )
             # Note: Attack Surface section removed - now covered by Intelligence Hub
-        
+
         # Findings Summary (all types)
-        sections.append(md_formatter.findings_summary(data['findings_by_severity']))
-        
+        sections.append(md_formatter.findings_summary(data["findings_by_severity"]))
+
         # Key Findings Summary (Top Critical/High) - for quick scanning
-        sections.append(md_formatter.key_findings_summary(data['findings_by_severity']))
-        
+        sections.append(md_formatter.key_findings_summary(data["findings_by_severity"]))
+
         # Compliance Mapping (executive and technical)
-        if report_type in ['executive', 'technical']:
-            sections.append(formatter.compliance_section(all_findings, compliance_data, report_type))
+        if report_type in ["executive", "technical"]:
+            sections.append(
+                formatter.compliance_section(all_findings, compliance_data, report_type)
+            )
 
         # Detailed Findings
-        if report_type == 'executive':
+        if report_type == "executive":
             # Executive: Top 5 critical/high only
-            top_findings = self._filter_top_findings(data['findings_by_severity'], limit=5)
+            top_findings = self._filter_top_findings(
+                data["findings_by_severity"], limit=5
+            )
             sections.append(formatter.detailed_findings_collapsible(top_findings))
-        elif report_type == 'summary':
+        elif report_type == "summary":
             # Summary: Top 3 critical/high only
-            top_findings = self._filter_top_findings(data['findings_by_severity'], limit=3)
+            top_findings = self._filter_top_findings(
+                data["findings_by_severity"], limit=3
+            )
             sections.append(formatter.detailed_findings_collapsible(top_findings))
         else:
             # Technical: All findings
-            sections.append(formatter.detailed_findings_collapsible(data['findings_by_severity']))
-        
+            sections.append(
+                formatter.detailed_findings_collapsible(data["findings_by_severity"])
+            )
+
         # Attack Chain Visualization (technical only)
-        if report_type == 'technical':
-            sections.append(md_formatter.attack_chain_section(
-                attack_chain, attack_summary, host_centric_chain
-            ))
+        if report_type == "technical":
+            sections.append(
+                md_formatter.attack_chain_section(
+                    attack_chain, attack_summary, host_centric_chain
+                )
+            )
 
         # Note: Evidence section removed - evidence is now displayed with each finding card
 
         # Recommendations (AI-enhanced if available)
-        if ai_content and ai_content.get('remediation_plan'):
-            sections.append(formatter.ai_remediation_plan(
-                ai_content['remediation_plan'],
-                ai_content.get('provider', 'AI')
-            ))
-        elif report_type == 'executive':
+        if ai_content and ai_content.get("remediation_plan"):
+            sections.append(
+                formatter.ai_remediation_plan(
+                    ai_content["remediation_plan"], ai_content.get("provider", "AI")
+                )
+            )
+        elif report_type == "executive":
             # Executive: Business-focused recommendations
-            sections.append(self._generate_executive_recommendations(
-                data['findings_by_severity'],
-                metrics
-            ))
+            sections.append(
+                self._generate_executive_recommendations(
+                    data["findings_by_severity"], metrics
+                )
+            )
         else:
             # Technical/Summary: Standard recommendations
-            sections.append(md_formatter.recommendations(
-                data['findings_by_severity'],
-                data['attack_surface']['recommendations']
-            ))
-        
+            sections.append(
+                md_formatter.recommendations(
+                    data["findings_by_severity"],
+                    data["attack_surface"]["recommendations"],
+                )
+            )
+
         # Appendix with Methodology (technical only)
         # Note: Methodology moved to appendix for cleaner report flow
-        if report_type == 'technical':
-            sections.append(md_formatter.appendix(
-                data['attack_surface']['hosts'],
-                data['credentials'],
-                include_methodology=True
-            ))
-        
+        if report_type == "technical":
+            sections.append(
+                md_formatter.appendix(
+                    data["attack_surface"]["hosts"],
+                    data["credentials"],
+                    include_methodology=True,
+                )
+            )
+
         # Footer (all types)
-        sections.append(md_formatter.footer(data['generated_at']))
+        sections.append(md_formatter.footer(data["generated_at"]))
 
         # Join all sections
         markdown_content = "\n\n".join(sections)
 
         # Convert markdown to HTML with extensions
         html_content = markdown.markdown(
-            markdown_content,
-            extensions=['tables', 'nl2br', 'sane_lists']
+            markdown_content, extensions=["tables", "nl2br", "sane_lists"]
         )
 
         # Wrap in HTML structure
         html_parts = [
-            formatter.html_header(data['engagement']['name']),
+            formatter.html_header(data["engagement"]["name"]),
             html_content,
-            formatter.html_footer()
+            formatter.html_footer(),
         ]
 
         return "\n".join(html_parts)
 
-    def _convert_to_pdf(self, html_content: str, data: Dict,
-                       output_path: Optional[str] = None) -> str:
+    def _convert_to_pdf(
+        self, html_content: str, data: Dict, output_path: Optional[str] = None
+    ) -> str:
         """Convert HTML to PDF using WeasyPrint (primary) or wkhtmltopdf (fallback)."""
         if not output_path:
-            output_path = self._default_output_path(data['engagement']['name'], '.pdf')
+            output_path = self._default_output_path(data["engagement"]["name"], ".pdf")
 
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
 
@@ -502,7 +560,8 @@ class ReportGenerator:
             font_config = FontConfiguration()
 
             # Additional CSS for PDF rendering
-            pdf_css = CSS(string='''
+            pdf_css = CSS(
+                string="""
                 @page {
                     size: Letter;
                     margin: 20mm 15mm;
@@ -514,10 +573,14 @@ class ReportGenerator:
                 .chart-container, .finding-card, details {
                     page-break-inside: avoid;
                 }
-            ''', font_config=font_config)
+            """,
+                font_config=font_config,
+            )
 
             html_doc = HTML(string=html_content)
-            html_doc.write_pdf(output_path, stylesheets=[pdf_css], font_config=font_config)
+            html_doc.write_pdf(
+                output_path, stylesheets=[pdf_css], font_config=font_config
+            )
 
             logger.info(f"PDF generated with WeasyPrint: {output_path}")
             return output_path
@@ -531,23 +594,36 @@ class ReportGenerator:
 
         # Fallback to wkhtmltopdf
         import tempfile
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.html', delete=False, encoding='utf-8') as f:
+
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".html", delete=False, encoding="utf-8"
+        ) as f:
             f.write(html_content)
             html_path = f.name
 
         try:
             import subprocess
-            result = subprocess.run([
-                'wkhtmltopdf',
-                '--enable-local-file-access',
-                '--page-size', 'Letter',
-                '--margin-top', '20mm',
-                '--margin-bottom', '20mm',
-                '--margin-left', '15mm',
-                '--margin-right', '15mm',
-                html_path,
-                output_path
-            ], check=True, capture_output=True)
+
+            result = subprocess.run(
+                [
+                    "wkhtmltopdf",
+                    "--enable-local-file-access",
+                    "--page-size",
+                    "Letter",
+                    "--margin-top",
+                    "20mm",
+                    "--margin-bottom",
+                    "20mm",
+                    "--margin-left",
+                    "15mm",
+                    "--margin-right",
+                    "15mm",
+                    html_path,
+                    output_path,
+                ],
+                check=True,
+                capture_output=True,
+            )
 
             return output_path
 
@@ -583,8 +659,8 @@ class ReportGenerator:
         project_root = os.getcwd()
 
         # Check if we're in souleyez directory structure
-        if 'souleyez' in project_root and os.path.exists(
-            os.path.join(project_root, 'setup.py')
+        if "souleyez" in project_root and os.path.exists(
+            os.path.join(project_root, "setup.py")
         ):
             output_dir = os.path.join(project_root, "reports")
         else:
@@ -594,36 +670,30 @@ class ReportGenerator:
         os.makedirs(output_dir, exist_ok=True)
 
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_name = engagement_name.replace(' ', '_').replace('/', '_')
+        safe_name = engagement_name.replace(" ", "_").replace("/", "_")
         filename = f"{safe_name}{suffix}_report_{timestamp}{ext}"
 
         return os.path.join(output_dir, filename)
-    
+
     def _filter_top_findings(self, findings: Dict, limit: int = 5) -> Dict:
         """Filter to top N critical/high findings for executive/summary reports."""
-        filtered = {
-            'critical': [],
-            'high': [],
-            'medium': [],
-            'low': [],
-            'info': []
-        }
-        
+        filtered = {"critical": [], "high": [], "medium": [], "low": [], "info": []}
+
         # Get critical and high findings
-        critical = findings.get('critical', [])
-        high = findings.get('high', [])
-        
+        critical = findings.get("critical", [])
+        high = findings.get("high", [])
+
         # Combine and take top N
         top_findings = (critical + high)[:limit]
-        
+
         # Split back into severity categories
         for finding in top_findings:
-            severity = finding.get('severity', 'info').lower()
+            severity = finding.get("severity", "info").lower()
             if severity in filtered:
                 filtered[severity].append(finding)
-        
+
         return filtered
-    
+
     def _generate_executive_recommendations(self, findings: Dict, metrics: Dict) -> str:
         """Generate business-focused recommendations for executive report."""
         section = """## EXECUTIVE RECOMMENDATIONS
@@ -632,37 +702,39 @@ class ReportGenerator:
 
 """
         # Critical findings
-        critical_count = len(findings.get('critical', []))
+        critical_count = len(findings.get("critical", []))
         if critical_count > 0:
             section += f"**{critical_count} Critical vulnerabilities require immediate remediation:**\n\n"
-            for idx, finding in enumerate(findings['critical'][:3], 1):
+            for idx, finding in enumerate(findings["critical"][:3], 1):
                 section += f"{idx}. {finding['title']}\n"
                 section += f"   - **Business Impact:** High risk of data breach or system compromise\n"
                 section += f"   - **Recommended Action:** Emergency patch or system isolation\n\n"
         else:
             section += "✓ No critical vulnerabilities identified.\n\n"
-        
+
         section += """### Short-Term (1-2 Weeks)
 
 **Remediation Timeline:**
 """
-        timeline = metrics.get('remediation_timeline', {})
+        timeline = metrics.get("remediation_timeline", {})
         section += f"- Estimated effort: {timeline.get('total_days', 0)} business days ({timeline.get('weeks', 0)} weeks)\n"
         section += f"- Critical issues: {timeline.get('critical', 0)} days\n"
         section += f"- High priority: {timeline.get('high', 0)} days\n\n"
-        
+
         section += """### Compliance & Risk Posture
 
 """
         section += f"**Overall Risk Score:** {metrics.get('risk_score', 0)}/100 ({metrics.get('risk_level', 'UNKNOWN')})\n\n"
-        
-        if metrics.get('risk_score', 0) >= 75:
+
+        if metrics.get("risk_score", 0) >= 75:
             section += "⚠️ **Action Required:** Critical risk level requires board notification and immediate action plan.\n\n"
-        elif metrics.get('risk_score', 0) >= 50:
+        elif metrics.get("risk_score", 0) >= 50:
             section += "⚠️ **Action Required:** High risk level requires executive review and remediation plan.\n\n"
         else:
-            section += "✓ Risk level is manageable with standard remediation timeline.\n\n"
-        
+            section += (
+                "✓ Risk level is manageable with standard remediation timeline.\n\n"
+            )
+
         section += """### Budget Considerations
 
 **Estimated Costs:**
@@ -714,58 +786,66 @@ class ReportGenerator:
         """Generate all AI content for report."""
 
         ai_content = {
-            'executive_summary': None,
-            'remediation_plan': None,
-            'risk_rating': None,
-            'enhanced_findings': {},
-            'provider': None,
-            'errors': []
+            "executive_summary": None,
+            "remediation_plan": None,
+            "risk_rating": None,
+            "enhanced_findings": {},
+            "provider": None,
+            "errors": [],
         }
 
         try:
-            ai_content['provider'] = self.ai_service.provider.provider_type.value
+            ai_content["provider"] = self.ai_service.provider.provider_type.value
         except Exception:
             pass
 
         # Generate executive summary
         try:
-            ai_content['executive_summary'] = self.ai_service.generate_executive_summary(engagement_id)
-            if ai_content['executive_summary']:
+            ai_content["executive_summary"] = (
+                self.ai_service.generate_executive_summary(engagement_id)
+            )
+            if ai_content["executive_summary"]:
                 logger.info("AI executive summary generated")
         except Exception as e:
-            ai_content['errors'].append(f'Executive summary: {e}')
+            ai_content["errors"].append(f"Executive summary: {e}")
             logger.warning(f"AI executive summary failed: {e}")
 
         # Generate remediation plan
         try:
-            ai_content['remediation_plan'] = self.ai_service.generate_remediation_plan(engagement_id)
-            if ai_content['remediation_plan']:
+            ai_content["remediation_plan"] = self.ai_service.generate_remediation_plan(
+                engagement_id
+            )
+            if ai_content["remediation_plan"]:
                 logger.info("AI remediation plan generated")
         except Exception as e:
-            ai_content['errors'].append(f'Remediation plan: {e}')
+            ai_content["errors"].append(f"Remediation plan: {e}")
             logger.warning(f"AI remediation plan failed: {e}")
 
         # Generate risk rating
         try:
-            ai_content['risk_rating'] = self.ai_service.generate_risk_rating(engagement_id)
+            ai_content["risk_rating"] = self.ai_service.generate_risk_rating(
+                engagement_id
+            )
         except Exception as e:
-            ai_content['errors'].append(f'Risk rating: {e}')
+            ai_content["errors"].append(f"Risk rating: {e}")
 
         # Enhance top critical/high findings (limit to 10 for cost control)
         try:
             priority_findings = (
-                data['findings_by_severity'].get('critical', [])[:5] +
-                data['findings_by_severity'].get('high', [])[:5]
+                data["findings_by_severity"].get("critical", [])[:5]
+                + data["findings_by_severity"].get("high", [])[:5]
             )
             for finding in priority_findings:
                 try:
                     enhanced = self.ai_service.enhance_finding(finding)
                     if enhanced:
-                        ai_content['enhanced_findings'][finding['id']] = enhanced
+                        ai_content["enhanced_findings"][finding["id"]] = enhanced
                 except Exception as e:
-                    logger.warning(f"Failed to enhance finding {finding.get('id')}: {e}")
+                    logger.warning(
+                        f"Failed to enhance finding {finding.get('id')}: {e}"
+                    )
         except Exception as e:
-            ai_content['errors'].append(f'Finding enhancement: {e}')
+            ai_content["errors"].append(f"Finding enhancement: {e}")
 
         return ai_content
 
@@ -774,10 +854,7 @@ class ReportGenerator:
     # =========================================================================
 
     def _generate_detection_report(
-        self,
-        engagement_id: int,
-        format: str,
-        output_path: Optional[str] = None
+        self, engagement_id: int, format: str, output_path: Optional[str] = None
     ) -> str:
         """
         Generate detection coverage report.
@@ -800,7 +877,7 @@ class ReportGenerator:
 
         # Check if Wazuh is configured
         config = WazuhConfig.get_config(engagement_id)
-        if not config or not config.get('enabled'):
+        if not config or not config.get("enabled"):
             raise ValueError(
                 "Detection reports require Wazuh integration. "
                 "Configure with 'souleyez wazuh config' first."
@@ -815,28 +892,26 @@ class ReportGenerator:
         charts = chart_gen.generate_detection_charts(data)
 
         # Generate report based on format
-        if format == 'html':
+        if format == "html":
             report_content = self._generate_detection_html(data, charts)
-            ext = '.html'
-        elif format == 'pdf':
+            ext = ".html"
+        elif format == "pdf":
             html_content = self._generate_detection_html(data, charts)
             return self._convert_detection_to_pdf(html_content, data, output_path)
-        elif format == 'markdown':
+        elif format == "markdown":
             report_content = self._generate_detection_markdown(data)
-            ext = '.md'
+            ext = ".md"
         else:
             raise ValueError(f"Unsupported format for detection report: {format}")
 
         # Write report to file
         if not output_path:
             output_path = self._default_output_path(
-                data.engagement.get('name', 'detection'),
-                ext,
-                suffix='_detection'
+                data.engagement.get("name", "detection"), ext, suffix="_detection"
             )
 
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        with open(output_path, 'w', encoding='utf-8') as f:
+        with open(output_path, "w", encoding="utf-8") as f:
             f.write(report_content)
 
         logger.info(f"Detection report generated: {output_path}")
@@ -850,9 +925,9 @@ class ReportGenerator:
         sections = []
 
         # Title page
-        sections.append(formatter.detection_title_page(
-            data.engagement, data.generated_at
-        ))
+        sections.append(
+            formatter.detection_title_page(data.engagement, data.generated_at)
+        )
 
         # Executive summary
         sections.append(formatter.detection_executive_summary(data))
@@ -888,12 +963,14 @@ class ReportGenerator:
         sections.append(formatter.per_host_detection_section(data))
 
         # Footer
-        sections.append(f"""
+        sections.append(
+            f"""
 ---
 
 *Detection Coverage Report generated by SoulEyez*
 *{data.generated_at.strftime('%B %d, %Y at %H:%M:%S')}*
-""")
+"""
+        )
 
         return "\n\n".join(sections)
 
@@ -904,15 +981,17 @@ class ReportGenerator:
 
         # Helper to convert markdown with table support
         def md_to_html(md_text: str) -> str:
-            return markdown.markdown(md_text, extensions=['tables', 'fenced_code'])
+            return markdown.markdown(md_text, extensions=["tables", "fenced_code"])
 
         formatter = HTMLFormatter()
         sections = []
 
         # HTML header with detection-specific styles
-        sections.append(formatter.detection_report_header(
-            f"Detection Coverage - {data.engagement.get('name', 'Report')}"
-        ))
+        sections.append(
+            formatter.detection_report_header(
+                f"Detection Coverage - {data.engagement.get('name', 'Report')}"
+            )
+        )
         sections.append('<div class="container">')
 
         # Title
@@ -926,7 +1005,8 @@ class ReportGenerator:
 
         # Stats cards
         summary = data.summary
-        sections.append(f"""
+        sections.append(
+            f"""
 <div class="detection-stat-grid">
     <div class="detection-stat-card coverage">
         <div class="detection-stat-value">{summary.coverage_percent}%</div>
@@ -945,32 +1025,37 @@ class ReportGenerator:
         <div class="detection-stat-label">Not Detected</div>
     </div>
 </div>
-""")
+"""
+        )
 
         # Coverage overview
         overview_md = formatter.detection_coverage_overview(data)
         sections.append(md_to_html(overview_md))
 
         # Charts
-        if charts.get('detection_coverage'):
-            sections.append(f"""
+        if charts.get("detection_coverage"):
+            sections.append(
+                f"""
 <div class="chart-container" style="max-width: 400px; margin: 20px auto;">
     <canvas id="detectionCoverageChart"></canvas>
 </div>
 <script>
 new Chart(document.getElementById('detectionCoverageChart'), {charts['detection_coverage']});
 </script>
-""")
+"""
+            )
 
-        if charts.get('detection_by_tactic'):
-            sections.append(f"""
+        if charts.get("detection_by_tactic"):
+            sections.append(
+                f"""
 <div class="chart-container" style="max-width: 800px; margin: 20px auto;">
     <canvas id="detectionTacticChart"></canvas>
 </div>
 <script>
 new Chart(document.getElementById('detectionTacticChart'), {charts['detection_by_tactic']});
 </script>
-""")
+"""
+            )
 
         # MITRE ATT&CK Heatmap (HTML version)
         sections.append(formatter.mitre_heatmap_html(data))
@@ -993,12 +1078,14 @@ new Chart(document.getElementById('detectionTacticChart'), {charts['detection_by
 
         # Detection gaps (with warning styling)
         if data.gaps:
-            sections.append("""
+            sections.append(
+                """
 <div class="gap-warning">
     <h4>Detection Gaps Identified</h4>
     <p>The following attacks were NOT detected by the SIEM. These represent potential blindspots that should be addressed.</p>
 </div>
-""")
+"""
+            )
         gaps_md = formatter.detection_gaps_section(data)
         sections.append(md_to_html(gaps_md))
 
@@ -1015,34 +1102,33 @@ new Chart(document.getElementById('detectionTacticChart'), {charts['detection_by
         sections.append(md_to_html(host_md))
 
         # Footer
-        sections.append(f"""
+        sections.append(
+            f"""
 <hr>
 <p style="text-align: center; color: #6c757d;">
     <em>Detection Coverage Report generated by SoulEyez</em><br>
     {data.generated_at.strftime('%B %d, %Y at %H:%M:%S')}
 </p>
-""")
+"""
+        )
 
         # HTML footer with Chart.js
-        sections.append("""
+        sections.append(
+            """
 <script src="https://cdn.jsdelivr.net/npm/chart.js@3.9.1/dist/chart.min.js"></script>
-""")
+"""
+        )
         sections.append(formatter.html_footer())
 
         return "\n".join(sections)
 
     def _convert_detection_to_pdf(
-        self,
-        html_content: str,
-        data,
-        output_path: Optional[str] = None
+        self, html_content: str, data, output_path: Optional[str] = None
     ) -> str:
         """Convert detection HTML report to PDF."""
         if not output_path:
             output_path = self._default_output_path(
-                data.engagement.get('name', 'detection'),
-                '.pdf',
-                suffix='_detection'
+                data.engagement.get("name", "detection"), ".pdf", suffix="_detection"
             )
 
         os.makedirs(os.path.dirname(output_path), exist_ok=True)
@@ -1053,12 +1139,12 @@ new Chart(document.getElementById('detectionTacticChart'), {charts['detection_by
 
             # Inline all external resources for PDF
             html_content = html_content.replace(
-                'https://cdn.jsdelivr.net/npm/chart.js@3.9.1/dist/chart.min.js',
-                ''
+                "https://cdn.jsdelivr.net/npm/chart.js@3.9.1/dist/chart.min.js", ""
             )
 
             html = HTML(string=html_content)
-            css = CSS(string="""
+            css = CSS(
+                string="""
                 @page {
                     size: letter;
                     margin: 20mm 15mm;
@@ -1075,7 +1161,8 @@ new Chart(document.getElementById('detectionTacticChart'), {charts['detection_by
                 .mitre-heatmap {
                     page-break-inside: avoid;
                 }
-            """)
+            """
+            )
             html.write_pdf(output_path, stylesheets=[css])
             logger.info(f"PDF generated with WeasyPrint: {output_path}")
             return output_path
@@ -1087,16 +1174,13 @@ new Chart(document.getElementById('detectionTacticChart'), {charts['detection_by
         import subprocess
         import tempfile
 
-        with tempfile.NamedTemporaryFile(
-            mode='w', suffix='.html', delete=False
-        ) as tmp:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".html", delete=False) as tmp:
             tmp.write(html_content)
             tmp_path = tmp.name
 
         try:
             subprocess.run(
-                ['wkhtmltopdf', '--quiet', tmp_path, output_path],
-                check=True
+                ["wkhtmltopdf", "--quiet", tmp_path, output_path], check=True
             )
             logger.info(f"PDF generated with wkhtmltopdf: {output_path}")
             return output_path