HTML Report Generation

@app.get("/results/{job_id}.html", response_class=HTMLResponse)
async def get_job_report(
    job_id: str,
    *,
    refresh: bool = Query(
        default=False, description="Force regeneration of the HTML report"
    ),
) -> HTMLResponse:
    """Serve an HTML report, generating it on-demand if needed.

    Reports are generated lazily from stored results and cached to disk.
    Pass ``?refresh=1`` to force regeneration (e.g. after a code update).
    """
    # Try disk cache first (skip when refresh requested)
    if not refresh:
        html_content = await get_html_report(job_id)
        if html_content:
            return HTMLResponse(html_content)

    # Check if the job exists
    result = await get_result(job_id)
    if not result:
        raise HTTPException(
            status_code=404,
            detail=f"Job '{job_id}' not found.",
        )

    status = result.get("status", "unknown")
    if status in ("pending", "running"):
        return HTMLResponse(
            format_status_page(job_id, status, result),
            headers={"Refresh": "10"},
        )

    # Generate HTML on-demand from stored result data
    result_data = result.get("result")
    if result_data and status == "completed":
        analysis_result = _build_analysis_result(job_id, result_data)
        html_content = format_result_as_html(analysis_result)
        try:
            await save_html_report(job_id, html_content)
        except OSError:
            logger.warning(
                "Failed to cache HTML report for job_id: %s", job_id, exc_info=True
            )
        logger.info(f"HTML report generated on-demand for job_id: {job_id}")
        return HTMLResponse(html_content)

def format_status_page(job_id: str, status: str, result: dict) -> str:
    """Generate a status page for a job that is still processing.

    Uses the same dark theme as the full report, with auto-refresh
    and a simple status indicator.
    """

:root {
    --bg-primary: #0d1117;
    --bg-secondary: #161b22;
    --bg-tertiary: #21262d;
    --bg-hover: #292e36;
    --border: #30363d;
    --text-primary: #e6edf3;
    --text-secondary: #8b949e;
    --text-muted: #6e7681;
    --accent-red: #f85149;
    --accent-red-bg: rgba(248, 81, 73, 0.12);
    --accent-green: #3fb950;
    --accent-blue: #58a6ff;
    --accent-blue-bg: rgba(88, 166, 255, 0.08);
    --accent-yellow: #d29922;
    --accent-orange: #f0883e;
    --accent-orange-bg: rgba(240, 136, 62, 0.12);
    --accent-purple: #bc8cff;
    --font-mono: 'SF Mono', 'Cascadia Code', 'Fira Code', 'JetBrains Mono', Consolas, monospace;
    --font-sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
    --radius: 8px;
}

def _grouping_key(detail: AnalysisDetail) -> str:
    """Compute a grouping key for root cause aggregation.

    Groups by classification + first 4 words of the bug title
    (for product bugs) or classification + file path (for code issues).
    Falls back to full JSON match when neither is available.

    The first 4 words of the title capture the essence of the bug
    while tolerating minor phrasing variations from different AI calls.
    """
    cls = (detail.classification or "").strip().upper()

    # For product bugs, group by classification + first 4 words of title
    if (
        isinstance(detail.product_bug_report, ProductBugReport)
        and detail.product_bug_report.title
    ):
        title = detail.product_bug_report.title.strip().lower()
        words = title.split()[:4]
        normalized_title = " ".join(words)
        return f"{cls}|title:{normalized_title}"

    # For code issues, group by classification + file path
    if isinstance(detail.code_fix, CodeFix) and detail.code_fix.file:
        return f"{cls}|file:{detail.code_fix.file.strip()}"

    # Fallback: full JSON match
    return detail.model_dump_json()

# Second pass: merge singletons into the dominant group
total = len(failures)
if total > 2 and len(groups_map) > 1:
    # Find the largest group
    dominant_key = max(groups_map, key=lambda k: len(groups_map[k]))
    dominant_size = len(groups_map[dominant_key])

    if dominant_size > total * 0.5:
        # Get the classification of the dominant group
        dominant_cls = (
            groups_map[dominant_key][0].analysis.classification.strip().upper()
        )
        # Merge singletons with the same classification
        keys_to_remove: list[str] = []
        for key in order:
            if key == dominant_key:
                continue
            if len(groups_map[key]) == 1:
                singleton_cls = (
                    groups_map[key][0].analysis.classification.strip().upper()
                )
                if singleton_cls == dominant_cls:
                    groups_map[dominant_key].extend(groups_map[key])
                    keys_to_remove.append(key)

        for key in keys_to_remove:
            del groups_map[key]
            order.remove(key)