nat-engine 1__py3-none-any.whl

mannf/core/reporting/unified_report.py

@@ -0,0 +1,664 @@
+# Copyright (C) 2026 Brad Guider
+# This file is part of NAT (Neural Agent Testing Framework).
+# Licensed under the AGPL-3.0. See LICENSE for details.
+# Commercial licensing available — see COMMERCIAL_LICENSE.md.
+
+"""UnifiedReportGenerator – aggregates all testing dimensions into a single report.
+
+Consumes the raw dict returned by
+:meth:`~mannf.core.functional_orchestrator.FunctionalTestOrchestrator.report`
+and produces:
+
+* :meth:`generate_json` — a fully JSON-serializable dict with summary
+  statistics across all four testing dimensions.
+* :meth:`generate_html` — a self-contained HTML dashboard (no external
+  dependencies) with embedded CSS.
+* :meth:`save_report` — writes HTML and/or JSON files to a given directory.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from typing import Any
+
+
+class UnifiedReportGenerator:
+    """Aggregates functional, visual, accessibility, and performance results.
+
+    All public methods are stateless and accept the raw report dict directly.
+    """
+
+    # ------------------------------------------------------------------
+    # JSON report
+    # ------------------------------------------------------------------
+
+    def generate_json(self, report_dict: dict[str, Any]) -> dict[str, Any]:
+        """Build a structured, JSON-serializable summary of *report_dict*.
+
+        Parameters
+        ----------
+        report_dict:
+            The dict returned by
+            :meth:`~mannf.core.functional_orchestrator.FunctionalTestOrchestrator.report`.
+
+        Returns
+        -------
+        dict
+            Unified summary with keys ``generated_at``, ``elapsed_seconds``,
+            ``agent_count``, ``overall_verdict``, ``functional``, and
+            optionally ``visual_regression``, ``accessibility``,
+            ``performance``.
+        """
+        overall_verdict = self._compute_overall_verdict(report_dict)
+
+        result: dict[str, Any] = {
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "elapsed_seconds": report_dict.get("elapsed_seconds", 0.0),
+            "agent_count": report_dict.get("agent_count", 0),
+            "overall_verdict": overall_verdict,
+            "functional": self._functional_summary(report_dict),
+        }
+
+        if "visual_regression" in report_dict:
+            result["visual_regression"] = self._visual_summary(report_dict["visual_regression"])
+
+        if "accessibility" in report_dict:
+            result["accessibility"] = self._accessibility_summary(report_dict["accessibility"])
+
+        if "performance" in report_dict:
+            result["performance"] = self._performance_summary(report_dict["performance"])
+
+        if "root_cause_analysis" in report_dict:
+            result["root_cause_analysis"] = report_dict["root_cause_analysis"]
+
+        return result
+
+    # ------------------------------------------------------------------
+    # HTML report
+    # ------------------------------------------------------------------
+
+    def generate_html(self, report_dict: dict[str, Any]) -> str:
+        """Build a self-contained HTML dashboard from *report_dict*.
+
+        Parameters
+        ----------
+        report_dict:
+            The dict returned by
+            :meth:`~mannf.core.functional_orchestrator.FunctionalTestOrchestrator.report`.
+
+        Returns
+        -------
+        str
+            A complete HTML document with embedded CSS and no external
+            dependencies.
+        """
+        json_data = self.generate_json(report_dict)
+        verdict = json_data["overall_verdict"]
+        generated_at = json_data["generated_at"]
+        elapsed = json_data["elapsed_seconds"]
+        agent_count = json_data["agent_count"]
+
+        verdict_class = "badge-pass" if verdict == "pass" else "badge-fail"
+        verdict_label = "PASS" if verdict == "pass" else "FAIL"
+
+        sections = []
+        sections.append(self._html_functional_section(json_data["functional"], report_dict))
+
+        if "visual_regression" in json_data:
+            sections.append(self._html_visual_section(json_data["visual_regression"], report_dict.get("visual_regression", {})))
+
+        if "accessibility" in json_data:
+            sections.append(self._html_accessibility_section(json_data["accessibility"], report_dict.get("accessibility", {})))
+
+        if "performance" in json_data:
+            sections.append(self._html_performance_section(json_data["performance"], report_dict.get("performance", {})))
+
+        if "root_cause_analysis" in json_data:
+            sections.append(self._html_root_cause_section(json_data["root_cause_analysis"]))
+
+        sections_html = "\n".join(sections)
+
+        return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>NAT Unified Test Report</title>
+<style>
+{self._css()}
+</style>
+</head>
+<body>
+<div class="container">
+  <header>
+    <div class="header-content">
+      <h1>NAT Unified Test Report</h1>
+      <span class="badge {verdict_class}">{verdict_label}</span>
+    </div>
+    <div class="header-meta">
+      <span>Run timestamp: {generated_at}</span>
+      <span>Elapsed: {elapsed}s</span>
+      <span>Agents: {agent_count}</span>
+    </div>
+  </header>
+  {sections_html}
+  <footer>
+    <p>Generated by NAT Framework &mdash; Neural Agent Testing &mdash; {generated_at}</p>
+  </footer>
+</div>
+</body>
+</html>"""
+
+    # ------------------------------------------------------------------
+    # Save report
+    # ------------------------------------------------------------------
+
+    def save_report(
+        self,
+        report_dict: dict[str, Any],
+        output_dir: str,
+        formats: list[str] | None = None,
+    ) -> list[str]:
+        """Write report files to *output_dir*.
+
+        Parameters
+        ----------
+        report_dict:
+            The dict returned by
+            :meth:`~mannf.core.functional_orchestrator.FunctionalTestOrchestrator.report`.
+        output_dir:
+            Directory to write files into.  Created if it does not exist.
+        formats:
+            List of ``"html"`` and/or ``"json"``.  Defaults to
+            ``["html", "json"]``.
+
+        Returns
+        -------
+        list[str]
+            Absolute paths of all files written.
+        """
+        if formats is None:
+            formats = ["html", "json"]
+
+        os.makedirs(output_dir, exist_ok=True)
+
+        written: list[str] = []
+
+        if "html" in formats:
+            html_path = os.path.join(output_dir, "nat_report.html")
+            with open(html_path, "w", encoding="utf-8") as fh:
+                fh.write(self.generate_html(report_dict))
+            written.append(html_path)
+
+        if "json" in formats:
+            json_path = os.path.join(output_dir, "nat_report.json")
+            with open(json_path, "w", encoding="utf-8") as fh:
+                json.dump(self.generate_json(report_dict), fh, indent=2)
+            written.append(json_path)
+
+        return written
+
+    # ------------------------------------------------------------------
+    # Overall verdict
+    # ------------------------------------------------------------------
+
+    def _compute_overall_verdict(self, report_dict: dict[str, Any]) -> str:
+        """Return ``"pass"`` only when all enabled dimensions pass."""
+        # Functional: any failures → fail
+        if report_dict.get("failed", 0) > 0:
+            return "fail"
+
+        # Visual regression: any diffs detected → fail
+        vr = report_dict.get("visual_regression")
+        if vr is not None and vr.get("failed", 0) > 0:
+            return "fail"
+
+        # Accessibility: any failed scans → fail
+        acc = report_dict.get("accessibility")
+        if acc is not None and acc.get("failed", 0) > 0:
+            return "fail"
+
+        # Performance: any failed evaluations → fail
+        perf = report_dict.get("performance")
+        if perf is not None and perf.get("failed", 0) > 0:
+            return "fail"
+
+        return "pass"
+
+    # ------------------------------------------------------------------
+    # Summary builders
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _functional_summary(report_dict: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "total": report_dict.get("total", 0),
+            "passed": report_dict.get("passed", 0),
+            "failed": report_dict.get("failed", 0),
+        }
+
+    @staticmethod
+    def _visual_summary(vr: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "total_comparisons": vr.get("total_comparisons", 0),
+            "matched": vr.get("passed", 0),
+            "diffs_detected": vr.get("failed", 0),
+            "baselines_saved": vr.get("baselines_created", 0),
+        }
+
+    @staticmethod
+    def _accessibility_summary(acc: dict[str, Any]) -> dict[str, Any]:
+        results = acc.get("results", [])
+        total_violations = sum(r.get("violation_count", 0) for r in results)
+        # Aggregate violations by impact level
+        violation_counts: dict[str, int] = {
+            "critical": 0, "serious": 0, "moderate": 0, "minor": 0
+        }
+        for r in results:
+            for v in r.get("violations", []):
+                impact = v.get("impact", "moderate")
+                if impact in violation_counts:
+                    violation_counts[impact] += 1
+
+        return {
+            "total_pages_scanned": acc.get("total_scans", 0),
+            "total_violations": total_violations,
+            "avg_compliance_score": acc.get("avg_compliance_score", 100.0),
+            "violation_counts_by_impact": violation_counts,
+        }
+
+    @staticmethod
+    def _performance_summary(perf: dict[str, Any]) -> dict[str, Any]:
+        results = perf.get("results", [])
+
+        # Per Core Web Vital aggregation
+        cwv_metrics: dict[str, list[float]] = {}
+        for r in results:
+            for m in r.get("metrics", []):
+                name = m["name"]
+                cwv_metrics.setdefault(name, []).append(m["value"])
+
+        cwv_stats: dict[str, dict[str, float]] = {}
+        for name, values in cwv_metrics.items():
+            cwv_stats[name] = {
+                "avg": round(sum(values) / len(values), 2),
+                "min": round(min(values), 2),
+                "max": round(max(values), 2),
+            }
+
+        # Overall grade: based on avg performance score
+        avg_score = perf.get("avg_performance_score", 100.0)
+        if avg_score >= 90:
+            grade = "good"
+        elif avg_score >= 50:
+            grade = "needs-improvement"
+        else:
+            grade = "poor"
+
+        return {
+            "total_pages_measured": perf.get("total_evaluations", 0),
+            "avg_performance_score": avg_score,
+            "overall_grade": grade,
+            "cwv_stats": cwv_stats,
+            "threshold_violations": len(perf.get("threshold_violations", [])),
+        }
+
+    # ------------------------------------------------------------------
+    # HTML section builders
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _badge(passed: bool) -> str:
+        if passed:
+            return '<span class="badge badge-pass">PASS</span>'
+        return '<span class="badge badge-fail">FAIL</span>'
+
+    def _html_functional_section(
+        self,
+        summary: dict[str, Any],
+        report_dict: dict[str, Any],
+    ) -> str:
+        total = summary["total"]
+        passed = summary["passed"]
+        failed = summary["failed"]
+        verdict = self._badge(failed == 0)
+
+        tasks = report_dict.get("tasks", [])
+        rows = ""
+        for t in tasks:
+            task_passed = t.get("passed", not t.get("error"))
+            row_class = "row-pass" if task_passed else "row-fail"
+            status_badge = self._badge(task_passed)
+            url = t.get("url", "")
+            error = t.get("error", "") or ""
+            rows += (
+                f'<tr class="{row_class}">'
+                f"<td>{url}</td>"
+                f"<td>{status_badge}</td>"
+                f"<td>{error}</td>"
+                f"</tr>\n"
+            )
+
+        table = ""
+        if rows:
+            table = f"""
+<table>
+  <thead><tr><th>URL</th><th>Status</th><th>Error</th></tr></thead>
+  <tbody>{rows}</tbody>
+</table>"""
+
+        return f"""
+<section class="report-section" id="functional-testing">
+  <h2>Functional Testing {verdict}</h2>
+  <div class="stats-row">
+    <div class="stat-card"><div class="stat-value">{total}</div><div class="stat-label">Total</div></div>
+    <div class="stat-card stat-pass"><div class="stat-value">{passed}</div><div class="stat-label">Passed</div></div>
+    <div class="stat-card stat-fail"><div class="stat-value">{failed}</div><div class="stat-label">Failed</div></div>
+  </div>
+  {table}
+</section>"""
+
+    def _html_visual_section(
+        self,
+        summary: dict[str, Any],
+        vr_raw: dict[str, Any],
+    ) -> str:
+        total = summary["total_comparisons"]
+        matched = summary["matched"]
+        diffs = summary["diffs_detected"]
+        baselines = summary["baselines_saved"]
+        verdict = self._badge(diffs == 0)
+
+        rows = ""
+        for r in vr_raw.get("results", []):
+            matched_val = r.get("matched", False)
+            diff_pct = r.get("diff_percentage", 0.0)
+            row_class = "row-pass" if matched_val else "row-fail"
+            rows += (
+                f'<tr class="{row_class}">'
+                f'<td>{r.get("url", "")}</td>'
+                f"<td>{self._badge(matched_val)}</td>"
+                f"<td>{diff_pct:.2f}%</td>"
+                f"</tr>\n"
+            )
+
+        table = ""
+        if rows:
+            table = f"""
+<table>
+  <thead><tr><th>URL</th><th>Status</th><th>Diff %</th></tr></thead>
+  <tbody>{rows}</tbody>
+</table>"""
+
+        return f"""
+<section class="report-section" id="visual-regression">
+  <h2>Visual Regression {verdict}</h2>
+  <div class="stats-row">
+    <div class="stat-card"><div class="stat-value">{total}</div><div class="stat-label">Total</div></div>
+    <div class="stat-card stat-pass"><div class="stat-value">{matched}</div><div class="stat-label">Matched</div></div>
+    <div class="stat-card stat-fail"><div class="stat-value">{diffs}</div><div class="stat-label">Diffs</div></div>
+    <div class="stat-card"><div class="stat-value">{baselines}</div><div class="stat-label">Baselines Saved</div></div>
+  </div>
+  {table}
+</section>"""
+
+    def _html_accessibility_section(
+        self,
+        summary: dict[str, Any],
+        acc_raw: dict[str, Any],
+    ) -> str:
+        pages = summary["total_pages_scanned"]
+        avg_score = summary["avg_compliance_score"]
+        total_violations = summary["total_violations"]
+        v_counts = summary["violation_counts_by_impact"]
+        verdict = self._badge(total_violations == 0)
+
+        score_class = "stat-pass" if avg_score >= 80 else "stat-fail"
+
+        rows = ""
+        for r in acc_raw.get("results", []):
+            score = r.get("compliance_score", 100.0)
+            passed = r.get("passed", True)
+            row_class = "row-pass" if passed else "row-fail"
+            rows += (
+                f'<tr class="{row_class}">'
+                f'<td>{r.get("url", "")}</td>'
+                f"<td>{self._badge(passed)}</td>"
+                f"<td>{score:.1f}%</td>"
+                f'<td>{r.get("violation_count", 0)}</td>'
+                f"</tr>\n"
+            )
+
+        table = ""
+        if rows:
+            table = f"""
+<table>
+  <thead><tr><th>URL</th><th>Status</th><th>Compliance Score</th><th>Violations</th></tr></thead>
+  <tbody>{rows}</tbody>
+</table>"""
+
+        return f"""
+<section class="report-section" id="accessibility">
+  <h2>Accessibility {verdict}</h2>
+  <div class="stats-row">
+    <div class="stat-card"><div class="stat-value">{pages}</div><div class="stat-label">Pages Scanned</div></div>
+    <div class="stat-card {score_class}"><div class="stat-value">{avg_score:.1f}%</div><div class="stat-label">Avg Compliance</div></div>
+    <div class="stat-card stat-fail"><div class="stat-value">{total_violations}</div><div class="stat-label">Total Violations</div></div>
+    <div class="stat-card"><div class="stat-value">{v_counts.get('critical', 0)}</div><div class="stat-label">Critical</div></div>
+    <div class="stat-card"><div class="stat-value">{v_counts.get('serious', 0)}</div><div class="stat-label">Serious</div></div>
+    <div class="stat-card"><div class="stat-value">{v_counts.get('moderate', 0)}</div><div class="stat-label">Moderate</div></div>
+    <div class="stat-card"><div class="stat-value">{v_counts.get('minor', 0)}</div><div class="stat-label">Minor</div></div>
+  </div>
+  {table}
+</section>"""
+
+    def _html_performance_section(
+        self,
+        summary: dict[str, Any],
+        perf_raw: dict[str, Any],
+    ) -> str:
+        pages = summary["total_pages_measured"]
+        avg_score = summary["avg_performance_score"]
+        grade = summary["overall_grade"]
+        cwv_stats = summary["cwv_stats"]
+        violations = summary["threshold_violations"]
+        verdict = self._badge(violations == 0)
+
+        grade_class = {
+            "good": "stat-pass",
+            "needs-improvement": "stat-warn",
+            "poor": "stat-fail",
+        }.get(grade, "stat-warn")
+
+        # CWV cards
+        cwv_order = ["LCP", "FID", "FCP", "CLS", "TTFB", "TTI", "TBT", "page_load_time"]
+        cwv_cards = ""
+        for metric_name in cwv_order:
+            if metric_name not in cwv_stats:
+                continue
+            stats = cwv_stats[metric_name]
+            cwv_cards += (
+                f'<div class="cwv-card">'
+                f"<div class=\"cwv-name\">{metric_name}</div>"
+                f"<div class=\"cwv-avg\">avg: {stats['avg']}</div>"
+                f"<div class=\"cwv-range\">min: {stats['min']} / max: {stats['max']}</div>"
+                f"</div>\n"
+            )
+
+        rows = ""
+        for r in perf_raw.get("results", []):
+            passed = r.get("passed", True)
+            row_class = "row-pass" if passed else "row-fail"
+            rows += (
+                f'<tr class="{row_class}">'
+                f'<td>{r.get("url", "")}</td>'
+                f"<td>{self._badge(passed)}</td>"
+                f'<td>{r.get("performance_score", 0):.1f}</td>'
+                f'<td>{r.get("page_load_time_ms", 0):.0f} ms</td>'
+                f'<td>{r.get("good_count", 0)} good / {r.get("poor_count", 0)} poor</td>'
+                f"</tr>\n"
+            )
+
+        table = ""
+        if rows:
+            table = f"""
+<table>
+  <thead><tr><th>URL</th><th>Status</th><th>Score</th><th>Load Time</th><th>Metrics</th></tr></thead>
+  <tbody>{rows}</tbody>
+</table>"""
+
+        return f"""
+<section class="report-section" id="performance">
+  <h2>Performance {verdict}</h2>
+  <div class="stats-row">
+    <div class="stat-card"><div class="stat-value">{pages}</div><div class="stat-label">Pages Measured</div></div>
+    <div class="stat-card {grade_class}"><div class="stat-value">{avg_score:.1f}</div><div class="stat-label">Avg Score</div></div>
+    <div class="stat-card {grade_class}"><div class="stat-value">{grade}</div><div class="stat-label">Grade</div></div>
+    <div class="stat-card stat-fail"><div class="stat-value">{violations}</div><div class="stat-label">Threshold Violations</div></div>
+  </div>
+  <div class="cwv-grid">
+    {cwv_cards}
+  </div>
+  {table}
+</section>"""
+
+    @staticmethod
+    def _html_root_cause_section(suggestions: list[dict[str, Any]]) -> str:
+        """Render the Root Cause Analysis section for the HTML report."""
+        if not suggestions:
+            return """
+<section class="report-section" id="root-cause-analysis">
+  <h2>🧠 Root Cause Analysis</h2>
+  <p style="color:#666;font-size:.9rem;">No failures were analyzed.</p>
+</section>"""
+
+        analyzed = [s for s in suggestions if not s.get("quota_limited")]
+        limited = [s for s in suggestions if s.get("quota_limited")]
+
+        cards_html = ""
+        for s in analyzed:
+            confidence_pct = int(s.get("confidence", 0.0) * 100)
+            severity = s.get("severity", "")
+            sev_class = {
+                "critical": "sev-critical",
+                "high": "sev-high",
+                "medium": "sev-medium",
+                "low": "sev-low",
+            }.get(severity, "")
+            files = s.get("files_to_check", [])
+            files_html = (
+                "<ul>" + "".join(f"<li><code>{f}</code></li>" for f in files) + "</ul>"
+                if files
+                else "<em>None identified</em>"
+            )
+            cards_html += f"""
+<div class="rca-card">
+  <div class="rca-header">
+    <span class="rca-url">{s.get("url", "")}</span>
+    {f'<span class="rca-sev {sev_class}">{severity.upper()}</span>' if severity else ""}
+    <span class="rca-confidence">Confidence: {confidence_pct}%</span>
+  </div>
+  <div class="rca-body">
+    <div class="rca-field"><strong>Likely Cause:</strong> {s.get("likely_cause", "")}</div>
+    <div class="rca-field"><strong>Suggested Fix:</strong> {s.get("suggested_fix", "")}</div>
+    <div class="rca-field"><strong>Files to Check:</strong> {files_html}</div>
+  </div>
+</div>"""
+
+        limited_html = ""
+        if limited:
+            limited_html = f"""
+<div class="rca-quota-notice">
+  🔒 {len(limited)} finding(s) not analyzed — upgrade your plan to analyze all findings.
+</div>"""
+
+        return f"""
+<section class="report-section" id="root-cause-analysis">
+  <h2>🧠 Root Cause Analysis</h2>
+  <div class="stats-row">
+    <div class="stat-card"><div class="stat-value">{len(analyzed)}</div><div class="stat-label">Analyzed</div></div>
+    <div class="stat-card"><div class="stat-value">{len(limited)}</div><div class="stat-label">Quota Limited</div></div>
+  </div>
+  {cards_html}
+  {limited_html}
+</section>"""
+
+    # ------------------------------------------------------------------
+    # Embedded CSS
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _css() -> str:
+        return """
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+       background: #f0f2f5; color: #1a1a2e; line-height: 1.5; }
+.container { max-width: 1100px; margin: 0 auto; padding: 24px; }
+
+header { background: #fff; border-radius: 8px; padding: 24px;
+         box-shadow: 0 2px 8px rgba(0,0,0,.08); margin-bottom: 24px; }
+.header-content { display: flex; align-items: center; gap: 16px; margin-bottom: 8px; }
+.header-content h1 { font-size: 1.6rem; color: #1a1a2e; }
+.header-meta { display: flex; gap: 24px; font-size: .85rem; color: #666; }
+
+.badge { display: inline-block; padding: 4px 12px; border-radius: 12px;
+         font-weight: 700; font-size: .85rem; text-transform: uppercase; }
+.badge-pass { background: #d4edda; color: #155724; }
+.badge-fail { background: #f8d7da; color: #721c24; }
+
+.report-section { background: #fff; border-radius: 8px; padding: 24px;
+                  box-shadow: 0 2px 8px rgba(0,0,0,.08); margin-bottom: 24px; }
+.report-section h2 { font-size: 1.2rem; margin-bottom: 16px; display: flex;
+                     align-items: center; gap: 10px; }
+
+.stats-row { display: flex; flex-wrap: wrap; gap: 12px; margin-bottom: 16px; }
+.stat-card { background: #f8f9fa; border-radius: 6px; padding: 12px 16px;
+             min-width: 90px; text-align: center; border: 1px solid #e9ecef; }
+.stat-value { font-size: 1.4rem; font-weight: 700; }
+.stat-label { font-size: .75rem; color: #666; margin-top: 2px; }
+.stat-pass { background: #d4edda; border-color: #c3e6cb; }
+.stat-pass .stat-value { color: #155724; }
+.stat-fail { background: #f8d7da; border-color: #f5c6cb; }
+.stat-fail .stat-value { color: #721c24; }
+.stat-warn { background: #fff3cd; border-color: #ffc107; }
+.stat-warn .stat-value { color: #856404; }
+
+table { width: 100%; border-collapse: collapse; font-size: .9rem; margin-top: 8px; }
+thead { background: #f8f9fa; }
+th { padding: 10px 12px; text-align: left; font-weight: 600;
+     border-bottom: 2px solid #dee2e6; }
+td { padding: 8px 12px; border-bottom: 1px solid #dee2e6; }
+.row-pass td { background: #f9fff9; }
+.row-fail td { background: #fff9f9; }
+
+.cwv-grid { display: flex; flex-wrap: wrap; gap: 12px; margin-bottom: 16px; }
+.cwv-card { background: #f8f9fa; border-radius: 6px; padding: 12px;
+            min-width: 130px; border: 1px solid #e9ecef; }
+.cwv-name { font-weight: 700; font-size: .95rem; margin-bottom: 4px; }
+.cwv-avg { font-size: .85rem; color: #333; }
+.cwv-range { font-size: .75rem; color: #888; margin-top: 2px; }
+
+/* Root Cause Analysis */
+.rca-card { border: 1px solid #e9ecef; border-radius: 6px; margin-bottom: 12px;
+            overflow: hidden; }
+.rca-header { background: #f8f9fa; padding: 10px 14px; display: flex;
+              align-items: center; gap: 10px; flex-wrap: wrap; }
+.rca-url { font-weight: 600; font-size: .9rem; flex: 1; }
+.rca-confidence { font-size: .8rem; color: #666; margin-left: auto; }
+.rca-body { padding: 12px 14px; }
+.rca-field { margin-bottom: 8px; font-size: .9rem; }
+.rca-field ul { margin: 4px 0 0 16px; }
+.rca-field code { background: #f8f9fa; padding: 1px 5px; border-radius: 3px;
+                  font-size: .85em; }
+.rca-quota-notice { background: #fff3cd; border: 1px solid #ffc107; border-radius: 6px;
+                    padding: 10px 14px; font-size: .85rem; color: #856404; margin-top: 8px; }
+.rca-sev { padding: 2px 8px; border-radius: 10px; font-size: .75rem; font-weight: 700; }
+.sev-critical { background: #f8d7da; color: #721c24; }
+.sev-high { background: #fde8d2; color: #8a3a00; }
+.sev-medium { background: #fff3cd; color: #856404; }
+.sev-low { background: #d4edda; color: #155724; }
+
+footer { text-align: center; color: #aaa; font-size: .8rem; padding: 16px 0; }
+"""

mannf/core/testing/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (C) 2026 Brad Guider
+# This file is part of NAT (Neural Agent Testing Framework).
+# Licensed under the AGPL-3.0. See LICENSE for details.
+# Commercial licensing available — see COMMERCIAL_LICENSE.md.
+
+"""Testing sub-package for the Multi-Agent Neural Network Framework."""
+
+from mannf.core.testing.models import TestCase, TestResult, TestSuite, TestStatus
+from mannf.core.testing.adaptive_controller import AdaptiveController
+
+__all__ = [
+    "TestCase",
+    "TestResult",
+    "TestSuite",
+    "TestStatus",
+    "AdaptiveController",
+]