nextog-cli 1.0.0__py3-none-any.whl

nextog/reports/__init__.py

@@ -0,0 +1,1359 @@
+"""
+Industrial Excel Report Generator for nextOG CLI
+Auto-generates professional Excel reports after ANY test run.
+All reports are built automatically after testing completes.
+"""
+
+import os
+import json
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+from datetime import datetime
+from rich.console import Console
+
+console = Console()
+
+
+class IndustrialReportGenerator:
+    """
+    Generates industrial-grade Excel reports after testing.
+    Supports: Web, Mobile, API, Embedded, System tests.
+    All data stays local - privacy first.
+    """
+    
+    def __init__(self, db, settings, privacy):
+        self.db = db
+        self.settings = settings
+        self.privacy = privacy
+        self.output_dir = Path.home() / ".nextog" / "reports"
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def generate_after_test(self, test_results: Dict, test_type: str = "auto") -> str:
+        """
+        Auto-generate Excel report after any test run.
+        Called automatically by all test engines.
+        
+        Args:
+            test_results: Results from any test engine
+            test_type: Type of test (web, mobile, api, embedded, system, auto)
+        
+        Returns:
+            Path to generated Excel file
+        """
+        try:
+            import openpyxl
+            from openpyxl.styles import (
+                Font, PatternFill, Alignment, Border, Side, 
+                numbers, NamedStyle
+            )
+            from openpyxl.chart import BarChart, PieChart, Reference, LineChart
+            from openpyxl.chart.label import DataLabelList
+            from openpyxl.chart.series import DataPoint
+            from openpyxl.utils import get_column_letter
+            from openpyxl.formatting.rule import CellIsRule, DataBarRule
+            from openpyxl.worksheet.table import Table, TableStyleInfo
+        except ImportError:
+            console.print("[yellow]⚠ Installing openpyxl for Excel reports...[/yellow]")
+            os.system("pip install openpyxl")
+            import openpyxl
+            from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+            from openpyxl.chart import BarChart, PieChart, Reference
+            from openpyxl.chart.label import DataLabelList
+            from openpyxl.utils import get_column_letter
+        
+        # Create workbook
+        wb = openpyxl.Workbook()
+        
+        # Detect test type if auto
+        if test_type == "auto":
+            test_type = self._detect_test_type(test_results)
+        
+        # Generate timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # ─── SHEET 1: Executive Summary ───────────────────────────
+        ws_summary = wb.active
+        ws_summary.title = "Executive Summary"
+        self._create_executive_summary(ws_summary, test_results, test_type, timestamp)
+        
+        # ─── SHEET 2: Test Details ────────────────────────────────
+        ws_details = wb.create_sheet("Test Details")
+        self._create_test_details(ws_details, test_results, test_type)
+        
+        # ─── SHEET 3: Coverage Analysis ───────────────────────────
+        ws_coverage = wb.create_sheet("Coverage Analysis")
+        self._create_coverage_analysis(ws_coverage, test_results, test_type)
+        
+        # ─── SHEET 4: Element Report ──────────────────────────────
+        ws_elements = wb.create_sheet("Elements & Components")
+        self._create_element_report(ws_elements, test_results, test_type)
+        
+        # ─── SHEET 5: Defect Log ──────────────────────────────────
+        ws_defects = wb.create_sheet("Defect Log")
+        self._create_defect_log(ws_defects, test_results, test_type)
+        
+        # ─── SHEET 6: Performance Metrics ─────────────────────────
+        ws_perf = wb.create_sheet("Performance Metrics")
+        self._create_performance_metrics(ws_perf, test_results, test_type)
+        
+        # ─── SHEET 7: Charts & Graphs ─────────────────────────────
+        ws_charts = wb.create_sheet("Charts & Graphs")
+        self._create_charts(ws_charts, test_results, test_type)
+        
+        # ─── SHEET 8: Recommendations ─────────────────────────────
+        ws_rec = wb.create_sheet("Recommendations")
+        self._create_recommendations(ws_rec, test_results, test_type)
+        
+        # ─── SHEET 9: Test Environment ────────────────────────────
+        ws_env = wb.create_sheet("Test Environment")
+        self._create_test_environment(ws_env, test_type)
+        
+        # ─── SHEET 10: Sign-off Sheet ─────────────────────────────
+        ws_sign = wb.create_sheet("Sign-Off")
+        self._create_signoff_sheet(ws_sign, test_results, test_type, timestamp)
+        
+        # Auto-fit columns for all sheets
+        for ws in wb.worksheets:
+            self._auto_fit_columns(ws)
+        
+        # Save workbook
+        filename = f"nextOG_{test_type}_Report_{timestamp}.xlsx"
+        filepath = self.output_dir / filename
+        wb.save(str(filepath))
+        
+        # Record in privacy engine (local only)
+        self.privacy.record_activity("report_generated", {
+            "file": str(filepath),
+            "type": test_type,
+            "timestamp": timestamp,
+        })
+        
+        # Save to DB
+        self.db.save_metadata(f"last_report_{test_type}", str(filepath))
+        
+        return str(filepath)
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 1: Executive Summary
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_executive_summary(self, ws, results: Dict, test_type: str, timestamp: str):
+        """Create executive summary sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        from openpyxl.utils import get_column_letter
+        
+        # Styles
+        title_font = Font(name="Calibri", size=20, bold=True, color="FFFFFF")
+        title_fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        header_font = Font(name="Calibri", size=12, bold=True, color="FFFFFF")
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        label_font = Font(name="Calibri", size=11, bold=True)
+        value_font = Font(name="Calibri", size=11)
+        green_fill = PatternFill(start_color="27AE60", end_color="27AE60", fill_type="solid")
+        red_fill = PatternFill(start_color="E74C3C", end_color="E74C3C", fill_type="solid")
+        yellow_fill = PatternFill(start_color="F39C12", end_color="F39C12", fill_type="solid")
+        white_font = Font(name="Calibri", size=14, bold=True, color="FFFFFF")
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        # Title Row
+        ws.merge_cells("A1:H1")
+        ws["A1"] = f"🚀 nextOG CLI — {test_type.upper()} Test Report"
+        ws["A1"].font = title_font
+        ws["A1"].fill = title_fill
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 40
+        
+        # Subtitle
+        ws.merge_cells("A2:H2")
+        ws["A2"] = f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} | Privacy: LOCAL ONLY | Tool: nextOG CLI v1.0"
+        ws["A2"].font = Font(name="Calibri", size=9, italic=True, color="666666")
+        ws["A2"].alignment = Alignment(horizontal="center")
+        ws.row_dimensions[2].height = 20
+        
+        # ─── Key Metrics Box ─────────────────────────────────────
+        ws.merge_cells("A4:B4")
+        ws["A4"] = "KEY METRICS"
+        ws["A4"].font = header_font
+        ws["A4"].fill = header_fill
+        ws["B4"].fill = header_fill
+        
+        total = results.get("total", 0)
+        passed = results.get("passed", 0)
+        failed = results.get("failed", 0)
+        skipped = results.get("skipped", 0)
+        coverage = results.get("coverage", 0)
+        duration = results.get("duration", 0)
+        
+        metrics = [
+            ("Total Tests", total),
+            ("Passed ✅", passed),
+            ("Failed ❌", failed),
+            ("Skipped ⚠️", skipped),
+            ("Coverage", f"{coverage}%"),
+            ("Duration", f"{duration:.1f}s" if duration else "N/A"),
+            ("Pass Rate", f"{(passed/total*100):.1f}%" if total > 0 else "0%"),
+            ("Test Type", test_type.upper()),
+        ]
+        
+        for i, (label, value) in enumerate(metrics, start=5):
+            ws[f"A{i}"] = label
+            ws[f"A{i}"].font = label_font
+            ws[f"A{i}"].border = thin_border
+            
+            ws[f"B{i}"] = value
+            ws[f"B{i}"].font = value_font
+            ws[f"B{i}"].border = thin_border
+            ws[f"B{i}"].alignment = Alignment(horizontal="center")
+            
+            # Color coding
+            if "Passed" in label:
+                ws[f"B{i}"].fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+            elif "Failed" in label:
+                ws[f"B{i}"].fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+            elif "Coverage" in label:
+                if coverage >= 80:
+                    ws[f"B{i}"].fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+                elif coverage >= 60:
+                    ws[f"B{i}"].fill = PatternFill(start_color="FEF9E7", end_color="FEF9E7", fill_type="solid")
+                else:
+                    ws[f"B{i}"].fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+        
+        # ─── Status Summary ──────────────────────────────────────
+        ws.merge_cells("D4:E4")
+        ws["D4"] = "OVERALL STATUS"
+        ws["D4"].font = header_font
+        ws["D4"].fill = header_fill
+        ws["E4"].fill = header_fill
+        
+        if coverage >= 80 and failed == 0:
+            status = "✅ PASS — Release Ready"
+            status_fill = green_fill
+        elif coverage >= 60:
+            status = "⚠️ CONDITIONAL — Review Required"
+            status_fill = yellow_fill
+        else:
+            status = "❌ FAIL — Critical Issues Found"
+            status_fill = red_fill
+        
+        ws.merge_cells("D5:E5")
+        ws["D5"] = status
+        ws["D5"].font = white_font
+        ws["D5"].fill = status_fill
+        ws["D5"].alignment = Alignment(horizontal="center", vertical="center")
+        ws["E5"].fill = status_fill
+        ws.row_dimensions[5].height = 35
+        
+        # Risk Level
+        ws["D6"] = "Risk Level:"
+        ws["D6"].font = label_font
+        if failed > 5:
+            risk = "🔴 HIGH"
+        elif failed > 0:
+            risk = "🟡 MEDIUM"
+        else:
+            risk = "🟢 LOW"
+        ws["E6"] = risk
+        ws["E6"].font = value_font
+        
+        # Recommendation
+        ws["D7"] = "Recommendation:"
+        ws["D7"].font = label_font
+        if coverage >= 80 and failed == 0:
+            rec = "Approve for production release"
+        elif coverage >= 60:
+            rec = "Fix critical defects before release"
+        else:
+            rec = "Major rework required - do not release"
+        ws.merge_cells("E7:F7")
+        ws["E7"] = rec
+        ws["E7"].font = value_font
+        
+        # ─── Test Breakdown by Category ──────────────────────────
+        ws.merge_cells("A14:H14")
+        ws["A14"] = "TEST BREAKDOWN BY CATEGORY"
+        ws["A14"].font = header_font
+        ws["A14"].fill = header_fill
+        for col in range(1, 9):
+            ws.cell(row=14, column=col).fill = header_fill
+        
+        headers = ["Category", "Total", "Passed", "Failed", "Skipped", "Pass Rate", "Coverage", "Status"]
+        for col, header in enumerate(headers, 1):
+            cell = ws.cell(row=15, column=col)
+            cell.value = header
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = PatternFill(start_color="34495E", end_color="34495E", fill_type="solid")
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        categories = results.get("categories", {})
+        row = 16
+        for cat_name, cat_data in categories.items():
+            if isinstance(cat_data, dict):
+                cat_total = cat_data.get("total", 0)
+                cat_passed = cat_data.get("passed", 0)
+                cat_failed = cat_data.get("failed", 0)
+                cat_skipped = cat_data.get("skipped", 0)
+                cat_pass_rate = f"{(cat_passed/cat_total*100):.1f}%" if cat_total > 0 else "0%"
+                cat_coverage = f"{cat_data.get('coverage', 0)}%"
+                
+                ws.cell(row=row, column=1, value=cat_name.replace("_", " ").title()).border = thin_border
+                ws.cell(row=row, column=2, value=cat_total).border = thin_border
+                ws.cell(row=row, column=2).alignment = Alignment(horizontal="center")
+                ws.cell(row=row, column=3, value=cat_passed).border = thin_border
+                ws.cell(row=row, column=3).fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+                ws.cell(row=row, column=3).alignment = Alignment(horizontal="center")
+                ws.cell(row=row, column=4, value=cat_failed).border = thin_border
+                if cat_failed > 0:
+                    ws.cell(row=row, column=4).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+                ws.cell(row=row, column=4).alignment = Alignment(horizontal="center")
+                ws.cell(row=row, column=5, value=cat_skipped).border = thin_border
+                ws.cell(row=row, column=5).alignment = Alignment(horizontal="center")
+                ws.cell(row=row, column=6, value=cat_pass_rate).border = thin_border
+                ws.cell(row=row, column=6).alignment = Alignment(horizontal="center")
+                ws.cell(row=row, column=7, value=cat_coverage).border = thin_border
+                ws.cell(row=row, column=7).alignment = Alignment(horizontal="center")
+                
+                status = "✅ Pass" if cat_failed == 0 else "❌ Fail"
+                ws.cell(row=row, column=8, value=status).border = thin_border
+                ws.cell(row=row, column=8).alignment = Alignment(horizontal="center")
+                
+                row += 1
+        
+        # ─── Target vs Actual ────────────────────────────────────
+        row += 2
+        ws.merge_cells(f"A{row}:H{row}")
+        ws[f"A{row}"] = "COVERAGE TARGET vs ACTUAL"
+        ws[f"A{row}"].font = header_font
+        ws[f"A{row}"].fill = header_fill
+        for col in range(1, 9):
+            ws.cell(row=row, column=col).fill = header_fill
+        
+        row += 1
+        target_headers = ["Phase", "Target Min", "Target Max", "Actual", "Status", "Gap"]
+        for col, h in enumerate(target_headers, 1):
+            cell = ws.cell(row=row, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = PatternFill(start_color="34495E", end_color="34495E", fill_type="solid")
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        phases = [
+            ("Smoke Tests", 0, 20),
+            ("Functional Tests", 20, 40),
+            ("Integration Tests", 40, 60),
+            ("Performance & Security", 60, 80),
+            ("Advanced & Regression", 80, 90),
+        ]
+        
+        row += 1
+        phase_keys = ["smoke", "functional", "integration", "performance", "advanced"]
+        for i, (phase_name, target_min, target_max) in enumerate(phases):
+            phase_data = categories.get(phase_keys[i], {}) if i < len(phase_keys) else {}
+            actual = phase_data.get("coverage", 0) if isinstance(phase_data, dict) else 0
+            
+            ws.cell(row=row, column=1, value=phase_name).border = thin_border
+            ws.cell(row=row, column=2, value=f"{target_min}%").border = thin_border
+            ws.cell(row=row, column=2).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=3, value=f"{target_max}%").border = thin_border
+            ws.cell(row=row, column=3).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=4, value=f"{actual}%").border = thin_border
+            ws.cell(row=row, column=4).alignment = Alignment(horizontal="center")
+            
+            if actual >= target_max:
+                status = "✅ Achieved"
+                gap = "—"
+            elif actual >= target_min:
+                status = "🔄 In Progress"
+                gap = f"+{target_max - actual}% needed"
+            else:
+                status = "⬜ Pending"
+                gap = f"+{target_min - actual}% needed"
+            
+            ws.cell(row=row, column=5, value=status).border = thin_border
+            ws.cell(row=row, column=5).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=6, value=gap).border = thin_border
+            ws.cell(row=row, column=6).alignment = Alignment(horizontal="center")
+            
+            row += 1
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 2: Test Details
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_test_details(self, ws, results: Dict, test_type: str):
+        """Create detailed test results sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        header_font = Font(name="Calibri", size=11, bold=True, color="FFFFFF")
+        
+        # Title
+        ws.merge_cells("A1:J1")
+        ws["A1"] = f"DETAILED TEST RESULTS — {test_type.upper()}"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        # Headers
+        headers = [
+            "#", "Test ID", "Test Name", "Category", "Type", 
+            "Element/Endpoint", "Status", "Duration (ms)", 
+            "Expected", "Actual", "Notes"
+        ]
+        
+        for col, header in enumerate(headers, 1):
+            cell = ws.cell(row=3, column=col)
+            cell.value = header
+            cell.font = header_font
+            cell.fill = header_fill
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center", wrap_text=True)
+        
+        # Data rows
+        details = results.get("details", [])
+        categories = results.get("categories", {})
+        
+        row = 4
+        test_num = 1
+        
+        # If we have detailed test cases
+        if details:
+            for detail in details:
+                if isinstance(detail, dict):
+                    ws.cell(row=row, column=1, value=test_num).border = thin_border
+                    ws.cell(row=row, column=1).alignment = Alignment(horizontal="center")
+                    ws.cell(row=row, column=2, value=detail.get("id", f"TC-{test_num:04d}")).border = thin_border
+                    ws.cell(row=row, column=3, value=detail.get("name", "Unnamed Test")).border = thin_border
+                    ws.cell(row=row, column=4, value=detail.get("category", test_type)).border = thin_border
+                    ws.cell(row=row, column=5, value=detail.get("type", "functional")).border = thin_border
+                    ws.cell(row=row, column=6, value=detail.get("element", detail.get("endpoint", "N/A"))).border = thin_border
+                    
+                    status = detail.get("status", "unknown")
+                    ws.cell(row=row, column=7, value=status.upper()).border = thin_border
+                    ws.cell(row=row, column=7).alignment = Alignment(horizontal="center")
+                    
+                    if status == "passed":
+                        ws.cell(row=row, column=7).fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+                    elif status == "failed":
+                        ws.cell(row=row, column=7).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+                    elif status == "skipped":
+                        ws.cell(row=row, column=7).fill = PatternFill(start_color="FEF9E7", end_color="FEF9E7", fill_type="solid")
+                    
+                    ws.cell(row=row, column=8, value=detail.get("duration", 0)).border = thin_border
+                    ws.cell(row=row, column=9, value=detail.get("expected", "")).border = thin_border
+                    ws.cell(row=row, column=10, value=detail.get("actual", detail.get("error", ""))).border = thin_border
+                    ws.cell(row=row, column=11, value=detail.get("notes", "")).border = thin_border
+                    
+                    test_num += 1
+                    row += 1
+        else:
+            # Generate from category data
+            for cat_name, cat_data in categories.items():
+                if isinstance(cat_data, dict):
+                    for i in range(cat_data.get("passed", 0)):
+                        ws.cell(row=row, column=1, value=test_num).border = thin_border
+                        ws.cell(row=row, column=2, value=f"TC-{test_num:04d}").border = thin_border
+                        ws.cell(row=row, column=3, value=f"{cat_name} test {i+1}").border = thin_border
+                        ws.cell(row=row, column=4, value=cat_name).border = thin_border
+                        ws.cell(row=row, column=7, value="PASSED").border = thin_border
+                        ws.cell(row=row, column=7).fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+                        ws.cell(row=row, column=7).alignment = Alignment(horizontal="center")
+                        test_num += 1
+                        row += 1
+                    
+                    for i in range(cat_data.get("failed", 0)):
+                        ws.cell(row=row, column=1, value=test_num).border = thin_border
+                        ws.cell(row=row, column=2, value=f"TC-{test_num:04d}").border = thin_border
+                        ws.cell(row=row, column=3, value=f"{cat_name} test (failed) {i+1}").border = thin_border
+                        ws.cell(row=row, column=4, value=cat_name).border = thin_border
+                        ws.cell(row=row, column=7, value="FAILED").border = thin_border
+                        ws.cell(row=row, column=7).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+                        ws.cell(row=row, column=7).alignment = Alignment(horizontal="center")
+                        test_num += 1
+                        row += 1
+        
+        # Summary at bottom
+        row += 2
+        ws.merge_cells(f"A{row}:C{row}")
+        ws[f"A{row}"] = "SUMMARY"
+        ws[f"A{row}"].font = Font(bold=True, size=12)
+        row += 1
+        ws[f"A{row}"] = "Total Test Cases:"
+        ws[f"B{row}"] = results.get("total", 0)
+        ws[f"B{row}"].font = Font(bold=True)
+        row += 1
+        ws[f"A{row}"] = "Pass Rate:"
+        total = results.get("total", 1)
+        ws[f"B{row}"] = f"{(results.get('passed', 0) / total * 100):.1f}%"
+        row += 1
+        ws[f"A{row}"] = "Overall Coverage:"
+        ws[f"B{row}"] = f"{results.get('coverage', 0)}%"
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 3: Coverage Analysis
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_coverage_analysis(self, ws, results: Dict, test_type: str):
+        """Create coverage analysis sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        header_font = Font(name="Calibri", size=11, bold=True, color="FFFFFF")
+        
+        # Title
+        ws.merge_cells("A1:G1")
+        ws["A1"] = "COVERAGE ANALYSIS — 0% → 90% PROGRESS TRACKER"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        # Overall Coverage
+        ws.merge_cells("A3:B3")
+        ws["A3"] = "Overall Coverage:"
+        ws["A3"].font = Font(bold=True, size=14)
+        coverage = results.get("coverage", 0)
+        ws["C3"] = f"{coverage}%"
+        ws["C3"].font = Font(bold=True, size=14, 
+                             color="27AE60" if coverage >= 80 else "F39C12" if coverage >= 60 else "E74C3C")
+        
+        # Phase coverage table
+        ws.merge_cells("A5:G5")
+        ws["A5"] = "PHASE-WISE COVERAGE BREAKDOWN"
+        ws["A5"].font = header_font
+        ws["A5"].fill = header_fill
+        for col in range(1, 8):
+            ws.cell(row=5, column=col).fill = header_fill
+        
+        headers = ["Phase", "Target Range", "Actual Coverage", "Status", "Tests Run", "Tests Passed", "Gap to Next"]
+        for col, h in enumerate(headers, 1):
+            cell = ws.cell(row=6, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = PatternFill(start_color="34495E", end_color="34495E", fill_type="solid")
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        phases_data = [
+            ("Phase 1: Smoke Tests", "0% - 20%", "smoke"),
+            ("Phase 2: Functional Tests", "20% - 40%", "functional"),
+            ("Phase 3: Integration Tests", "40% - 60%", "integration"),
+            ("Phase 4: Performance & Security", "60% - 80%", "performance"),
+            ("Phase 5: Advanced & Regression", "80% - 90%", "advanced"),
+        ]
+        
+        categories = results.get("categories", {})
+        row = 7
+        
+        for phase_name, target_range, phase_key in phases_data:
+            cat_data = categories.get(phase_key, {})
+            actual = cat_data.get("coverage", 0) if isinstance(cat_data, dict) else 0
+            total = cat_data.get("total", 0) if isinstance(cat_data, dict) else 0
+            passed = cat_data.get("passed", 0) if isinstance(cat_data, dict) else 0
+            
+            ws.cell(row=row, column=1, value=phase_name).border = thin_border
+            ws.cell(row=row, column=2, value=target_range).border = thin_border
+            ws.cell(row=row, column=2).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=3, value=f"{actual}%").border = thin_border
+            ws.cell(row=row, column=3).alignment = Alignment(horizontal="center")
+            
+            # Color code actual coverage
+            if actual >= 80:
+                ws.cell(row=row, column=3).fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+            elif actual >= 40:
+                ws.cell(row=row, column=3).fill = PatternFill(start_color="FEF9E7", end_color="FEF9E7", fill_type="solid")
+            elif actual > 0:
+                ws.cell(row=row, column=3).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+            
+            # Status
+            if actual >= 80:
+                status = "✅ Complete"
+            elif actual > 0:
+                status = "🔄 In Progress"
+            else:
+                status = "⬜ Not Started"
+            ws.cell(row=row, column=4, value=status).border = thin_border
+            ws.cell(row=row, column=4).alignment = Alignment(horizontal="center")
+            
+            ws.cell(row=row, column=5, value=total).border = thin_border
+            ws.cell(row=row, column=5).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=6, value=passed).border = thin_border
+            ws.cell(row=row, column=6).alignment = Alignment(horizontal="center")
+            
+            gap = max(0, 20 - actual) if actual < 20 else max(0, 40 - actual) if actual < 40 else max(0, 60 - actual) if actual < 60 else max(0, 80 - actual) if actual < 80 else max(0, 90 - actual)
+            ws.cell(row=row, column=7, value=f"+{gap}%" if gap > 0 else "✅").border = thin_border
+            ws.cell(row=row, column=7).alignment = Alignment(horizontal="center")
+            
+            row += 1
+        
+        # Coverage by Element Type
+        row += 2
+        ws.merge_cells(f"A{row}:G{row}")
+        ws[f"A{row}"] = "COVERAGE BY ELEMENT TYPE"
+        ws[f"A{row}"].font = header_font
+        ws[f"A{row}"].fill = header_fill
+        for col in range(1, 8):
+            ws.cell(row=row, column=col).fill = header_fill
+        
+        row += 1
+        elem_headers = ["Element Type", "Total Found", "Tested", "Coverage %", "Priority", "Status", "Notes"]
+        for col, h in enumerate(elem_headers, 1):
+            cell = ws.cell(row=row, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = PatternFill(start_color="34495E", end_color="34495E", fill_type="solid")
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        row += 1
+        element_types = [
+            ("Buttons/CTAs", "critical"), ("Input Fields", "critical"),
+            ("Forms", "critical"), ("Navigation Links", "high"),
+            ("Images/Media", "medium"), ("Tables/Data", "medium"),
+            ("Modals/Dialogs", "high"), ("Search Components", "high"),
+            ("Footer Elements", "low"), ("Third-party Widgets", "medium"),
+        ]
+        
+        for elem_name, priority in element_types:
+            ws.cell(row=row, column=1, value=elem_name).border = thin_border
+            ws.cell(row=row, column=5, value=priority).border = thin_border
+            ws.cell(row=row, column=5).alignment = Alignment(horizontal="center")
+            
+            if priority == "critical":
+                ws.cell(row=row, column=5).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+            elif priority == "high":
+                ws.cell(row=row, column=5).fill = PatternFill(start_color="FEF9E7", end_color="FEF9E7", fill_type="solid")
+            
+            row += 1
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 4: Element Report
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_element_report(self, ws, results: Dict, test_type: str):
+        """Create element/component report"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        ws.merge_cells("A1:I1")
+        ws["A1"] = "ELEMENTS & COMPONENTS DETECTION REPORT"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        ws.merge_cells("A2:I2")
+        ws["A2"] = "All system elements detected with their purpose and test coverage status"
+        ws["A2"].font = Font(italic=True, color="666666")
+        ws["A2"].alignment = Alignment(horizontal="center")
+        
+        headers = [
+            "#", "Element Name", "Type", "Selector/ID", 
+            "Description/Purpose", "Test Priority", 
+            "Tests Applied", "Result", "Recommendation"
+        ]
+        
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        for col, h in enumerate(headers, 1):
+            cell = ws.cell(row=4, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = header_fill
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center", wrap_text=True)
+        
+        # Element data based on test type
+        elements = results.get("elements", [])
+        
+        if not elements:
+            # Generate standard elements based on test type
+            elements = self._get_standard_elements(test_type)
+        
+        row = 5
+        for i, elem in enumerate(elements, 1):
+            ws.cell(row=row, column=1, value=i).border = thin_border
+            ws.cell(row=row, column=2, value=elem.get("name", "")).border = thin_border
+            ws.cell(row=row, column=3, value=elem.get("type", "")).border = thin_border
+            ws.cell(row=row, column=4, value=elem.get("selector", elem.get("id", ""))).border = thin_border
+            ws.cell(row=row, column=5, value=elem.get("description", "")).border = thin_border
+            ws.cell(row=row, column=6, value=elem.get("priority", "medium")).border = thin_border
+            ws.cell(row=row, column=7, value=elem.get("tests_applied", "")).border = thin_border
+            ws.cell(row=row, column=8, value=elem.get("result", "pending")).border = thin_border
+            ws.cell(row=row, column=9, value=elem.get("recommendation", "")).border = thin_border
+            
+            # Wrap text for description
+            ws.cell(row=row, column=5).alignment = Alignment(wrap_text=True)
+            ws.cell(row=row, column=9).alignment = Alignment(wrap_text=True)
+            
+            row += 1
+    
+    def _get_standard_elements(self, test_type: str) -> List[Dict]:
+        """Get standard elements based on test type"""
+        web_elements = [
+            {"name": "Header/Logo", "type": "header", "selector": "header > .logo", "description": "Company branding and navigation home link", "priority": "high", "tests_applied": "Load, Click, Responsive", "result": "pending", "recommendation": "Verify logo links to homepage"},
+            {"name": "Navigation Menu", "type": "nav", "selector": "nav, .navbar", "description": "Main navigation links for site sections", "priority": "critical", "tests_applied": "Links, Hover, Mobile menu", "result": "pending", "recommendation": "Test all nav links, mobile hamburger menu"},
+            {"name": "Hero Section", "type": "section", "selector": ".hero, #hero", "description": "Primary landing content with CTA", "priority": "high", "tests_applied": "Visibility, CTA click, Responsive", "result": "pending", "recommendation": "Verify CTA button functionality"},
+            {"name": "Login Form", "type": "form", "selector": "form[action*='login']", "description": "User authentication form", "priority": "critical", "tests_applied": "Input validation, Submit, Error states", "result": "pending", "recommendation": "Test empty fields, invalid credentials, CSRF"},
+            {"name": "Search Bar", "type": "input", "selector": "input[type='search']", "description": "Site search functionality", "priority": "high", "tests_applied": "Input, Submit, Results, Empty state", "result": "pending", "recommendation": "Test autocomplete, no results, special chars"},
+            {"name": "Footer Links", "type": "footer", "selector": "footer a", "description": "Footer navigation and legal links", "priority": "medium", "tests_applied": "Link validation", "result": "pending", "recommendation": "Verify all footer links resolve correctly"},
+            {"name": "Contact Form", "type": "form", "selector": "form[action*='contact']", "description": "Contact/submission form", "priority": "critical", "tests_applied": "Validation, Submission, Confirmation", "result": "pending", "recommendation": "Test all field validations and submission"},
+            {"name": "Images", "type": "image", "selector": "img", "description": "All page images with alt text", "priority": "medium", "tests_applied": "Load, Alt text, Responsive, Lazy load", "result": "pending", "recommendation": "Verify alt text for accessibility"},
+        ]
+        
+        mobile_elements = [
+            {"name": "App Launcher", "type": "activity", "selector": "MainActivity", "description": "App main activity/launch point", "priority": "critical", "tests_applied": "Launch time, Crash check", "result": "pending", "recommendation": "Verify cold start under 3 seconds"},
+            {"name": "Login Screen", "type": "screen", "selector": "LoginActivity", "description": "User authentication screen", "priority": "critical", "tests_applied": "Input, Submit, Error handling", "result": "pending", "recommendation": "Test all error states and keyboard types"},
+            {"name": "Navigation Drawer", "type": "component", "selector": "NavigationView", "description": "Side navigation menu", "priority": "high", "tests_applied": "Open/Close, Item click, Back", "result": "pending", "recommendation": "Test swipe gesture and keyboard nav"},
+            {"name": "List/RecyclerView", "type": "component", "selector": "RecyclerView", "description": "Scrollable data list", "priority": "high", "tests_applied": "Scroll, Click item, Pull-to-refresh", "result": "pending", "recommendation": "Test with empty, loading, and error states"},
+            {"name": "Bottom Navigation", "type": "component", "selector": "BottomNavigationView", "description": "Bottom tab navigation bar", "priority": "critical", "tests_applied": "Tab switch, Badge, Active state", "result": "pending", "recommendation": "Verify all tabs switch correctly"},
+            {"name": "Floating Action Button", "type": "button", "selector": "FloatingActionButton", "description": "Primary action button", "priority": "high", "tests_applied": "Click, Animation, Accessibility", "result": "pending", "recommendation": "Verify content description for a11y"},
+        ]
+        
+        api_elements = [
+            {"name": "Health Endpoint", "type": "GET", "selector": "/api/health", "description": "API health check endpoint", "priority": "critical", "tests_applied": "Status 200, Response time, Format", "result": "pending", "recommendation": "Must return 200 with version info"},
+            {"name": "Auth Endpoint", "type": "POST", "selector": "/api/auth/login", "description": "Authentication endpoint", "priority": "critical", "tests_applied": "Valid/invalid creds, Token generation", "result": "pending", "recommendation": "Test brute force protection, token expiry"},
+            {"name": "CRUD Endpoints", "type": "ALL", "selector": "/api/resources/*", "description": "Create, Read, Update, Delete operations", "priority": "critical", "tests_applied": "All HTTP methods, Schema validation", "result": "pending", "recommendation": "Test all CRUD operations with edge cases"},
+            {"name": "Pagination", "type": "GET", "selector": "/api/resources?page=", "description": "Paginated list endpoints", "priority": "high", "tests_applied": "Page navigation, Limits, Sorting", "result": "pending", "recommendation": "Test boundary pages and empty results"},
+            {"name": "File Upload", "type": "POST", "selector": "/api/upload", "description": "File upload endpoint", "priority": "high", "tests_applied": "Size limits, Type validation, Storage", "result": "pending", "recommendation": "Test max file size and invalid types"},
+            {"name": "WebSocket", "type": "WS", "selector": "ws://api/ws", "description": "Real-time WebSocket connection", "priority": "medium", "tests_applied": "Connect, Send/Receive, Reconnect", "result": "pending", "recommendation": "Test connection timeout and message format"},
+        ]
+        
+        embedded_elements = [
+            {"name": "MQTT Broker", "type": "protocol", "selector": "mqtt://target:1883", "description": "Message broker connection", "priority": "critical", "tests_applied": "Connect, Subscribe, Publish, QoS", "result": "pending", "recommendation": "Verify QoS levels and retain flag"},
+            {"name": "Sensor Data", "type": "telemetry", "selector": "topic/sensors/*", "description": "Sensor data topics", "priority": "critical", "tests_applied": "Data format, Range, Frequency", "result": "pending", "recommendation": "Verify data within expected ranges"},
+            {"name": "Command Interface", "type": "control", "selector": "topic/commands/*", "description": "Device command topics", "priority": "high", "tests_applied": "Send/Receive, Ack, Timeout", "result": "pending", "recommendation": "Test command acknowledgment and retries"},
+            {"name": "OTA Updates", "type": "firmware", "selector": "topic/ota/*", "description": "Over-the-air firmware updates", "priority": "high", "tests_applied": "Version check, Download, Verify, Install", "result": "pending", "recommendation": "Test update rollback on failure"},
+            {"name": "Watchdog Timer", "type": "system", "selector": "device/watchdog", "description": "Device health monitoring", "priority": "critical", "tests_applied": "Heartbeat, Timeout, Recovery", "result": "pending", "recommendation": "Verify automatic recovery after timeout"},
+        ]
+        
+        type_map = {
+            "web": web_elements,
+            "mobile": mobile_elements,
+            "api": api_elements,
+            "embedded": embedded_elements,
+        }
+        
+        return type_map.get(test_type, web_elements)
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 5: Defect Log
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_defect_log(self, ws, results: Dict, test_type: str):
+        """Create defect/bug tracking sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        ws.merge_cells("A1:K1")
+        ws["A1"] = "DEFECT LOG — Issues Found During Testing"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="C0392B", end_color="C0392B", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        headers = [
+            "Defect ID", "Severity", "Priority", "Category",
+            "Title", "Description", "Steps to Reproduce",
+            "Expected Result", "Actual Result", "Environment",
+            "Status"
+        ]
+        
+        header_fill = PatternFill(start_color="E74C3C", end_color="E74C3C", fill_type="solid")
+        for col, h in enumerate(headers, 1):
+            cell = ws.cell(row=3, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = header_fill
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center", wrap_text=True)
+        
+        # Generate defects from failed tests
+        details = results.get("details", [])
+        defects = [d for d in details if isinstance(d, dict) and d.get("status") == "failed"]
+        
+        row = 4
+        for i, defect in enumerate(defects, 1):
+            ws.cell(row=row, column=1, value=f"DEF-{i:04d}").border = thin_border
+            ws.cell(row=row, column=2, value="High").border = thin_border
+            ws.cell(row=row, column=3, value="P1").border = thin_border
+            ws.cell(row=row, column=4, value=defect.get("category", test_type)).border = thin_border
+            ws.cell(row=row, column=5, value=defect.get("name", "Test Failure")).border = thin_border
+            ws.cell(row=row, column=6, value=defect.get("error", defect.get("actual", "Test failed"))).border = thin_border
+            ws.cell(row=row, column=7, value=defect.get("steps", "Run automated test suite")).border = thin_border
+            ws.cell(row=row, column=8, value=defect.get("expected", "Test should pass")).border = thin_border
+            ws.cell(row=row, column=9, value=defect.get("actual", "Test failed")).border = thin_border
+            ws.cell(row=row, column=10, value=test_type).border = thin_border
+            ws.cell(row=row, column=11, value="Open").border = thin_border
+            
+            # Color severity
+            ws.cell(row=row, column=2).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+            ws.cell(row=row, column=11).fill = PatternFill(start_color="FEF9E7", end_color="FEF9E7", fill_type="solid")
+            
+            row += 1
+        
+        if not defects:
+            ws.merge_cells(f"A4:K4")
+            ws["A4"] = "✅ No defects found — All tests passed!"
+            ws["A4"].font = Font(size=14, bold=True, color="27AE60")
+            ws["A4"].alignment = Alignment(horizontal="center")
+            ws.row_dimensions[4].height = 30
+        
+        # Summary
+        row += 2
+        ws[f"A{row}"] = "Defect Summary:"
+        ws[f"A{row}"].font = Font(bold=True, size=12)
+        row += 1
+        ws[f"A{row}"] = "Total Defects:"
+        ws[f"B{row}"] = len(defects)
+        row += 1
+        ws[f"A{row}"] = "Critical:"
+        ws[f"B{row}"] = sum(1 for d in defects if isinstance(d, dict) and d.get("severity") == "critical")
+        row += 1
+        ws[f"A{row}"] = "High:"
+        ws[f"B{row}"] = len(defects)  # All assumed high for now
+        row += 1
+        ws[f"A{row}"] = "Open:"
+        ws[f"B{row}"] = len(defects)
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 6: Performance Metrics
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_performance_metrics(self, ws, results: Dict, test_type: str):
+        """Create performance metrics sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        ws.merge_cells("A1:F1")
+        ws["A1"] = "PERFORMANCE METRICS"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        # Metrics table
+        headers = ["Metric", "Value", "Benchmark", "Status", "Trend", "Notes"]
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        
+        for col, h in enumerate(headers, 1):
+            cell = ws.cell(row=3, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = header_fill
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        metrics = self._get_performance_metrics(results, test_type)
+        row = 4
+        for metric in metrics:
+            ws.cell(row=row, column=1, value=metric["name"]).border = thin_border
+            ws.cell(row=row, column=2, value=metric["value"]).border = thin_border
+            ws.cell(row=row, column=2).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=3, value=metric["benchmark"]).border = thin_border
+            ws.cell(row=row, column=3).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=4, value=metric["status"]).border = thin_border
+            ws.cell(row=row, column=4).alignment = Alignment(horizontal="center")
+            
+            if metric["status"] == "✅ Pass":
+                ws.cell(row=row, column=4).fill = PatternFill(start_color="D5F5E3", end_color="D5F5E3", fill_type="solid")
+            elif metric["status"] == "❌ Fail":
+                ws.cell(row=row, column=4).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+            
+            ws.cell(row=row, column=5, value=metric.get("trend", "—")).border = thin_border
+            ws.cell(row=row, column=5).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=6, value=metric.get("notes", "")).border = thin_border
+            
+            row += 1
+    
+    def _get_performance_metrics(self, results: Dict, test_type: str) -> List[Dict]:
+        """Get performance metrics based on test type"""
+        duration = results.get("duration", 0)
+        
+        base_metrics = [
+            {"name": "Total Test Duration", "value": f"{duration:.1f}s", "benchmark": "< 300s", 
+             "status": "✅ Pass" if duration < 300 else "❌ Fail", "notes": "End-to-end test time"},
+            {"name": "Tests Per Second", "value": f"{results.get('total', 0) / max(duration, 1):.1f}",
+             "benchmark": "> 1 tps", "status": "✅ Pass", "notes": "Test execution throughput"},
+            {"name": "Pass Rate", "value": f"{(results.get('passed', 0) / max(results.get('total', 1), 1) * 100):.1f}%",
+             "benchmark": "> 95%", "status": "✅ Pass" if results.get("passed", 0) / max(results.get("total", 1), 1) > 0.95 else "❌ Fail",
+             "notes": "Percentage of tests passing"},
+            {"name": "Defect Density", "value": f"{results.get('failed', 0)} defects",
+             "benchmark": "< 5 defects", "status": "✅ Pass" if results.get("failed", 0) < 5 else "❌ Fail",
+             "notes": "Number of defects found"},
+            {"name": "Coverage Efficiency", "value": f"{results.get('coverage', 0)}%",
+             "benchmark": "> 80%", "status": "✅ Pass" if results.get("coverage", 0) >= 80 else "⚠️ Warning",
+             "notes": "Test coverage vs target"},
+        ]
+        
+        if test_type == "web":
+            base_metrics.extend([
+                {"name": "Page Load Time", "value": "—", "benchmark": "< 3s", "status": "Pending", "notes": "Run with --performance flag"},
+                {"name": "Lighthouse Score", "value": "—", "benchmark": "> 90", "status": "Pending", "notes": "Run with --performance flag"},
+            ])
+        elif test_type == "api":
+            base_metrics.extend([
+                {"name": "Avg Response Time", "value": "—", "benchmark": "< 500ms", "status": "Pending", "notes": "API response time"},
+                {"name": "Throughput", "value": "—", "benchmark": "> 100 req/s", "status": "Pending", "notes": "Requests per second"},
+            ])
+        
+        return base_metrics
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 7: Charts & Graphs
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_charts(self, ws, results: Dict, test_type: str):
+        """Create charts and graphs sheet"""
+        from openpyxl.chart import BarChart, PieChart, Reference
+        from openpyxl.chart.label import DataLabelList
+        from openpyxl.chart.series import DataPoint
+        from openpyxl.styles import Font, PatternFill, Alignment
+        
+        ws["A1"] = "CHARTS & VISUAL ANALYTICS"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        
+        # ─── Pie Chart: Pass/Fail Distribution ───────────────────
+        ws["A3"] = "Status"
+        ws["B3"] = "Count"
+        ws["A4"] = "Passed"
+        ws["B4"] = results.get("passed", 0)
+        ws["A5"] = "Failed"
+        ws["B5"] = results.get("failed", 0)
+        ws["A6"] = "Skipped"
+        ws["B6"] = results.get("skipped", 0)
+        
+        pie = PieChart()
+        pie.title = "Test Results Distribution"
+        pie.style = 10
+        data = Reference(ws, min_col=2, min_row=3, max_row=6)
+        cats = Reference(ws, min_col=1, min_row=4, max_row=6)
+        pie.add_data(data, titles_from_data=True)
+        pie.set_categories(cats)
+        pie.width = 15
+        pie.height = 10
+        
+        # Color the slices
+        from openpyxl.chart.series import DataPoint
+        from openpyxl.drawing.fill import PatternFillProperties, ColorChoice
+        passed_pt = DataPoint(idx=0)
+        passed_pt.graphicalProperties.solidFill = "27AE60"
+        failed_pt = DataPoint(idx=1)
+        failed_pt.graphicalProperties.solidFill = "E74C3C"
+        skip_pt = DataPoint(idx=2)
+        skip_pt.graphicalProperties.solidFill = "F39C12"
+        pie.series[0].data_points = [passed_pt, failed_pt, skip_pt]
+        
+        ws.add_chart(pie, "D3")
+        
+        # ─── Bar Chart: Coverage by Phase ────────────────────────
+        ws["A9"] = "Phase"
+        ws["B9"] = "Coverage %"
+        categories = results.get("categories", {})
+        phase_names = ["Smoke", "Functional", "Integration", "Performance", "Advanced"]
+        phase_keys = ["smoke", "functional", "integration", "performance", "advanced"]
+        
+        row = 10
+        for i, (name, key) in enumerate(zip(phase_names, phase_keys)):
+            ws.cell(row=row, column=1, value=name)
+            cat_data = categories.get(key, {})
+            coverage = cat_data.get("coverage", 0) if isinstance(cat_data, dict) else 0
+            ws.cell(row=row, column=2, value=coverage)
+            row += 1
+        
+        bar = BarChart()
+        bar.type = "col"
+        bar.title = "Coverage by Phase (Target: 90%)"
+        bar.style = 10
+        bar.y_axis.title = "Coverage %"
+        bar.x_axis.title = "Test Phase"
+        
+        data = Reference(ws, min_col=2, min_row=9, max_row=14)
+        cats = Reference(ws, min_col=1, min_row=10, max_row=14)
+        bar.add_data(data, titles_from_data=True)
+        bar.set_categories(cats)
+        bar.width = 15
+        bar.height = 10
+        
+        ws.add_chart(bar, "D19")
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 8: Recommendations
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_recommendations(self, ws, results: Dict, test_type: str):
+        """Create recommendations sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        ws.merge_cells("A1:F1")
+        ws["A1"] = "RECOMMENDATIONS & ACTION ITEMS"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        headers = ["#", "Category", "Recommendation", "Priority", "Effort", "Impact"]
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        
+        for col, h in enumerate(headers, 1):
+            cell = ws.cell(row=3, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = header_fill
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        # Generate recommendations based on results
+        recommendations = self._generate_recommendations(results, test_type)
+        
+        row = 4
+        for i, rec in enumerate(recommendations, 1):
+            ws.cell(row=row, column=1, value=i).border = thin_border
+            ws.cell(row=row, column=2, value=rec["category"]).border = thin_border
+            ws.cell(row=row, column=3, value=rec["recommendation"]).border = thin_border
+            ws.cell(row=row, column=3).alignment = Alignment(wrap_text=True)
+            ws.cell(row=row, column=4, value=rec["priority"]).border = thin_border
+            ws.cell(row=row, column=4).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=5, value=rec["effort"]).border = thin_border
+            ws.cell(row=row, column=5).alignment = Alignment(horizontal="center")
+            ws.cell(row=row, column=6, value=rec["impact"]).border = thin_border
+            ws.cell(row=row, column=6).alignment = Alignment(horizontal="center")
+            
+            # Color code priority
+            if rec["priority"] == "Critical":
+                ws.cell(row=row, column=4).fill = PatternFill(start_color="FADBD8", end_color="FADBD8", fill_type="solid")
+            elif rec["priority"] == "High":
+                ws.cell(row=row, column=4).fill = PatternFill(start_color="FEF9E7", end_color="FEF9E7", fill_type="solid")
+            
+            row += 1
+    
+    def _generate_recommendations(self, results: Dict, test_type: str) -> List[Dict]:
+        """Generate recommendations based on test results"""
+        recs = []
+        coverage = results.get("coverage", 0)
+        failed = results.get("failed", 0)
+        total = results.get("total", 1)
+        
+        if coverage < 60:
+            recs.append({
+                "category": "Coverage",
+                "recommendation": f"Coverage is at {coverage}%. Add more test cases to reach at least 80% coverage before release.",
+                "priority": "Critical",
+                "effort": "High",
+                "impact": "High",
+            })
+        
+        if failed > 0:
+            recs.append({
+                "category": "Defects",
+                "recommendation": f"Fix {failed} failing test(s) before release. Prioritize critical and high severity defects.",
+                "priority": "Critical",
+                "effort": "Medium",
+                "impact": "High",
+            })
+        
+        if test_type == "web":
+            recs.append({
+                "category": "Accessibility",
+                "recommendation": "Run WCAG 2.1 AA compliance audit. Ensure all interactive elements have ARIA labels.",
+                "priority": "High",
+                "effort": "Medium",
+                "impact": "High",
+            })
+            recs.append({
+                "category": "Performance",
+                "recommendation": "Run Lighthouse audit for Core Web Vitals. Target LCP < 2.5s, FID < 100ms, CLS < 0.1.",
+                "priority": "Medium",
+                "effort": "Low",
+                "impact": "Medium",
+            })
+        
+        if test_type == "api":
+            recs.append({
+                "category": "Security",
+                "recommendation": "Implement rate limiting on all API endpoints. Add request validation middleware.",
+                "priority": "High",
+                "effort": "Medium",
+                "impact": "High",
+            })
+            recs.append({
+                "category": "Documentation",
+                "recommendation": "Ensure OpenAPI spec is up-to-date. All endpoints should have request/response examples.",
+                "priority": "Medium",
+                "effort": "Low",
+                "impact": "Medium",
+            })
+        
+        if test_type == "mobile":
+            recs.append({
+                "category": "UX",
+                "recommendation": "Test on physical devices (not just emulators). Verify on low-end devices with limited RAM.",
+                "priority": "High",
+                "effort": "High",
+                "impact": "High",
+            })
+            recs.append({
+                "category": "Performance",
+                "recommendation": "Monitor memory leaks during extended usage. Check battery consumption impact.",
+                "priority": "Medium",
+                "effort": "Medium",
+                "impact": "Medium",
+            })
+        
+        if test_type == "embedded":
+            recs.append({
+                "category": "Reliability",
+                "recommendation": "Run 72-hour soak test. Verify watchdog timer recovery and power cycling.",
+                "priority": "Critical",
+                "effort": "High",
+                "impact": "Critical",
+            })
+            recs.append({
+                "category": "Security",
+                "recommendation": "Verify firmware encryption and secure boot. Test OTA update rollback mechanism.",
+                "priority": "High",
+                "effort": "High",
+                "impact": "Critical",
+            })
+        
+        # Always add general recommendations
+        recs.append({
+            "category": "CI/CD",
+            "recommendation": "Integrate nextOG tests into CI/CD pipeline. Set coverage gate at 80% minimum.",
+            "priority": "High",
+            "effort": "Medium",
+            "impact": "High",
+        })
+        recs.append({
+            "category": "Regression",
+            "recommendation": "Add failed tests to regression suite. Schedule weekly full regression runs.",
+            "priority": "Medium",
+            "effort": "Low",
+            "impact": "Medium",
+        })
+        recs.append({
+            "category": "Monitoring",
+            "recommendation": "Set up production monitoring with alerts matching test coverage areas.",
+            "priority": "Medium",
+            "effort": "Medium",
+            "impact": "Medium",
+        })
+        
+        return recs
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 9: Test Environment
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_test_environment(self, ws, test_type: str):
+        """Create test environment documentation sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        import platform as plat
+        
+        try:
+            import psutil
+        except ImportError:
+            psutil = None
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        ws.merge_cells("A1:D1")
+        ws["A1"] = "TEST ENVIRONMENT DETAILS"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        headers = ["Property", "Value", "Category", "Notes"]
+        header_fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        
+        for col, h in enumerate(headers, 1):
+            cell = ws.cell(row=3, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = header_fill
+            cell.border = thin_border
+        
+        env_data = [
+            ("Tool", "nextOG CLI v1.0.0", "Software", "QA Automation Tool"),
+            ("Python Version", plat.python_version(), "Runtime", "Test execution engine"),
+            ("OS", f"{plat.system()} {plat.release()}", "Platform", "Test host OS"),
+            ("Machine", plat.machine(), "Hardware", "CPU architecture"),
+            ("Processor", plat.processor() or "N/A", "Hardware", "CPU details"),
+            ("Total RAM", f"{psutil.virtual_memory().total / (1024**3):.1f} GB" if psutil else "N/A", "Hardware", "System memory"),
+            ("Available RAM", f"{psutil.virtual_memory().available / (1024**3):.1f} GB" if psutil else "N/A", "Hardware", "Free memory"),
+            ("CPU Cores", str(psutil.cpu_count()) if psutil else str(os.cpu_count() or "N/A"), "Hardware", "Logical processors"),
+            ("Test Type", test_type.upper(), "Configuration", "Test suite type"),
+            ("Test Date", datetime.now().strftime("%Y-%m-%d"), "Schedule", "Execution date"),
+            ("Test Time", datetime.now().strftime("%H:%M:%S"), "Schedule", "Execution time"),
+            ("Timezone", datetime.now().astimezone().tzname(), "Schedule", "Local timezone"),
+            ("Privacy Mode", "LOCAL ONLY - No External Data Transfer", "Security", "All data stays on device"),
+            ("Data Encryption", "AES-256 (Fernet)", "Security", "Local data encryption"),
+            ("Report Location", f"~/.nextog/reports/", "Storage", "Local report storage"),
+        ]
+        
+        row = 4
+        for prop, value, category, notes in env_data:
+            ws.cell(row=row, column=1, value=prop).border = thin_border
+            ws.cell(row=row, column=2, value=value).border = thin_border
+            ws.cell(row=row, column=3, value=category).border = thin_border
+            ws.cell(row=row, column=4, value=notes).border = thin_border
+            row += 1
+    
+    # ═══════════════════════════════════════════════════════════════
+    # SHEET 10: Sign-Off Sheet
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _create_signoff_sheet(self, ws, results: Dict, test_type: str, timestamp: str):
+        """Create sign-off/approval sheet"""
+        from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
+        
+        thin_border = Border(
+            left=Side(style='thin'), right=Side(style='thin'),
+            top=Side(style='thin'), bottom=Side(style='thin')
+        )
+        
+        ws.merge_cells("A1:F1")
+        ws["A1"] = "TEST SIGN-OFF & APPROVAL"
+        ws["A1"].font = Font(name="Calibri", size=16, bold=True, color="FFFFFF")
+        ws["A1"].fill = PatternFill(start_color="1B4F72", end_color="1B4F72", fill_type="solid")
+        ws["A1"].alignment = Alignment(horizontal="center", vertical="center")
+        ws.row_dimensions[1].height = 35
+        
+        # Report info
+        ws["A3"] = "Report ID:"
+        ws["A3"].font = Font(bold=True)
+        ws["B3"] = f"nextOG-{test_type.upper()}-{timestamp}"
+        
+        ws["A4"] = "Generated By:"
+        ws["A4"].font = Font(bold=True)
+        ws["B4"] = "nextOG CLI v1.0.0 (Automated)"
+        
+        ws["A5"] = "Test Type:"
+        ws["A5"].font = Font(bold=True)
+        ws["B5"] = test_type.upper()
+        
+        ws["A6"] = "Coverage:"
+        ws["A6"].font = Font(bold=True)
+        ws["B6"] = f"{results.get('coverage', 0)}%"
+        
+        ws["A7"] = "Status:"
+        ws["A7"].font = Font(bold=True)
+        coverage = results.get("coverage", 0)
+        failed = results.get("failed", 0)
+        if coverage >= 80 and failed == 0:
+            ws["B7"] = "✅ PASS — Recommended for Release"
+        elif coverage >= 60:
+            ws["B7"] = "⚠️ CONDITIONAL — Requires Review"
+        else:
+            ws["B7"] = "❌ FAIL — Not Recommended for Release"
+        
+        # Approval section
+        ws.merge_cells("A9:F9")
+        ws["A9"] = "APPROVAL SIGNATURES"
+        ws["A9"].font = Font(size=14, bold=True, color="FFFFFF")
+        ws["A9"].fill = PatternFill(start_color="2E86C1", end_color="2E86C1", fill_type="solid")
+        ws["A9"].alignment = Alignment(horizontal="center")
+        
+        sign_headers = ["Role", "Name", "Signature", "Date", "Comments", "Approved"]
+        for col, h in enumerate(sign_headers, 1):
+            cell = ws.cell(row=10, column=col)
+            cell.value = h
+            cell.font = Font(bold=True, color="FFFFFF")
+            cell.fill = PatternFill(start_color="34495E", end_color="34495E", fill_type="solid")
+            cell.border = thin_border
+            cell.alignment = Alignment(horizontal="center")
+        
+        roles = ["QA Lead", "Dev Lead", "Product Manager", "Release Manager"]
+        row = 11
+        for role in roles:
+            ws.cell(row=row, column=1, value=role).border = thin_border
+            ws.cell(row=row, column=2).border = thin_border
+            ws.cell(row=row, column=3).border = thin_border
+            ws.cell(row=row, column=4).border = thin_border
+            ws.cell(row=row, column=5).border = thin_border
+            ws.cell(row=row, column=6).border = thin_border
+            ws.row_dimensions[row].height = 30
+            row += 1
+        
+        # Footer
+        row += 2
+        ws.merge_cells(f"A{row}:F{row}")
+        ws[f"A{row}"] = "This report was generated automatically by nextOG CLI. All data is stored locally with AES-256 encryption. No external data transfer occurred."
+        ws[f"A{row}"].font = Font(italic=True, size=9, color="666666")
+        ws[f"A{row}"].alignment = Alignment(horizontal="center", wrap_text=True)
+    
+    # ═══════════════════════════════════════════════════════════════
+    # UTILITY METHODS
+    # ═══════════════════════════════════════════════════════════════
+    
+    def _detect_test_type(self, results: Dict) -> str:
+        """Auto-detect test type from results"""
+        engine = results.get("engine", "")
+        if engine:
+            return engine
+        
+        # Try to detect from structure
+        if "url" in results:
+            return "web"
+        elif "app" in results or "platform" in results:
+            return "mobile"
+        elif "base_url" in results or "spec" in results:
+            return "api"
+        elif "target" in results or "protocol" in results:
+            return "embedded"
+        
+        return "full"
+    
+    def _auto_fit_columns(self, ws):
+        """Auto-fit column widths"""
+        from openpyxl.utils import get_column_letter
+        
+        for column in ws.columns:
+            max_length = 0
+            column_letter = get_column_letter(column[0].column)
+            
+            for cell in column:
+                try:
+                    if cell.value:
+                        cell_len = len(str(cell.value))
+                        if cell_len > max_length:
+                            max_length = cell_len
+                except Exception:
+                    pass
+            
+            adjusted_width = min(max_length + 4, 50)
+            ws.column_dimensions[column_letter].width = max(adjusted_width, 12)