argus-cloud-optimizer 0.2.0__py3-none-any.whl

core/reports/generator.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from core.models.finding import ResourceFinding
+
+# Maximum findings shown as individual rows in the Slack digest
+SLACK_DIGEST_LIMIT = 5
+
+
+def build_report(
+    findings: list[ResourceFinding],
+    cloud: str,
+    executive_summary: str,
+    accounts_scanned: list[str] | None = None,
+    agent_input_tokens: int = 0,
+    agent_output_tokens: int = 0,
+    scan_diff: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """
+    Convert a list of ResourceFinding objects into the canonical JSON report.
+    Findings are sorted by estimated_monthly_cost descending before serialising.
+    """
+    sorted_findings = sorted(
+        findings, key=lambda f: f.estimated_monthly_cost, reverse=True
+    )
+    total_waste = sum(f.estimated_monthly_cost for f in sorted_findings)
+
+    return {
+        "schema_version": "1.0",
+        "scan_id": str(uuid.uuid4()),
+        "generated_at": datetime.now(tz=timezone.utc).isoformat(),
+        "cloud": cloud,
+        "accounts_scanned": accounts_scanned or [],
+        "total_estimated_waste_usd": round(total_waste, 2),
+        "findings_count": len(sorted_findings),
+        "findings": [f.to_dict() for f in sorted_findings],
+        "executive_summary": executive_summary,
+        "agent_input_tokens": agent_input_tokens,
+        "agent_output_tokens": agent_output_tokens,
+        "estimated_agent_cost_usd": _estimate_cost(
+            agent_input_tokens, agent_output_tokens
+        ),
+        "scan_diff": scan_diff,
+    }
+
+
+def _estimate_cost(input_tokens: int, output_tokens: int) -> float:
+    input_cost_per_m = 3.0
+    output_cost_per_m = 15.0
+    cost = (input_tokens / 1_000_000 * input_cost_per_m) + (
+        output_tokens / 1_000_000 * output_cost_per_m
+    )
+    return round(cost, 4)
+
+
+def build_slack_payload(
+    report: dict[str, Any],
+    report_url: str | None = None,
+) -> dict[str, Any]:
+    """
+    Build a compact Slack Block Kit digest.
+
+    Shows stats + AI summary + top findings as a one-line-per-finding table.
+    Full AI reasoning lives in the HTML report linked via report_url.
+    """
+    cloud = report["cloud"].upper()
+    total = report["total_estimated_waste_usd"]
+    count = report["findings_count"]
+    generated_at = report["generated_at"][:10]  # YYYY-MM-DD
+    accounts = len(report.get("accounts_scanned", []))
+
+    _PRIORITY_EMOJI = {
+        "HIGH": ":red_circle:",
+        "MEDIUM": ":large_yellow_circle:",
+        "LOW": ":large_green_circle:",
+    }
+
+    blocks: list[dict[str, Any]] = [
+        {
+            "type": "header",
+            "text": {
+                "type": "plain_text",
+                "text": f"Argus — {cloud} Waste Report ({generated_at})",
+            },
+        },
+        {
+            "type": "section",
+            "fields": [
+                {
+                    "type": "mrkdwn",
+                    "text": f":money_with_wings: *${total:,.2f}/month* estimated waste",
+                },
+                {
+                    "type": "mrkdwn",
+                    "text": (
+                        f":bar_chart: *{count}* idle "
+                        f"resource{'s' if count != 1 else ''} across "
+                        f"*{accounts}* account{'s' if accounts != 1 else ''}"
+                    ),
+                },
+            ],
+        },
+        {
+            "type": "section",
+            "text": {
+                "type": "mrkdwn",
+                "text": f"_{report['executive_summary']}_",
+            },
+        },
+        {"type": "divider"},
+    ]
+
+    top = report["findings"][:SLACK_DIGEST_LIMIT]
+    if top:
+        lines = ["*Top findings*"]
+        for finding in top:
+            cost = finding["estimated_monthly_cost"]
+            priority = (finding.get("priority") or "low").upper()
+            emoji = _PRIORITY_EMOJI.get(priority, ":white_circle:")
+            label = finding.get("name") or finding["resource_id"]
+            rtype = finding["resource_type"]
+            lines.append(f"{emoji} `{label}` · {rtype} · *${cost:,.2f}/mo*")
+
+        remaining = count - SLACK_DIGEST_LIMIT
+        if remaining > 0:
+            lines.append(
+                f":white_circle: _+{remaining} more "
+                f"finding{'s' if remaining != 1 else ''} in the full report_"
+            )
+
+        blocks.append(
+            {"type": "section", "text": {"type": "mrkdwn", "text": "\n".join(lines)}}
+        )
+        blocks.append({"type": "divider"})
+
+    actions: list[dict[str, Any]] = []
+    if report_url:
+        actions.append(
+            {
+                "type": "button",
+                "text": {
+                    "type": "plain_text",
+                    "text": ":page_facing_up: Full report (HTML)",
+                },
+                "url": report_url,
+                "style": "primary",
+            }
+        )
+    actions.append(
+        {
+            "type": "button",
+            "text": {"type": "plain_text", "text": "vamshisiddarth/argus"},
+            "url": "https://github.com/vamshisiddarth/argus",
+        }
+    )
+    blocks.append({"type": "actions", "elements": actions})
+
+    blocks.append(
+        {
+            "type": "context",
+            "elements": [{"type": "mrkdwn", "text": f"Scan ID: `{report['scan_id']}`"}],
+        }
+    )
+
+    return {"blocks": blocks}

core/reports/html.py

@@ -0,0 +1,286 @@
+"""
+Self-contained HTML report generator for Argus.
+
+Produces a single HTML file with:
+- Summary stats header
+- AI executive summary
+- Filterable/sortable findings table
+- Expandable rows with AI reasoning and recommendation
+
+The output is intentionally self-contained (no external CDN) so it works
+offline and is safe to serve from a pre-signed S3 URL.
+"""
+
+from __future__ import annotations
+
+import html
+from datetime import datetime, timezone
+from typing import Any
+
+
+def build_html_report(report: dict[str, Any]) -> str:
+    cloud = report["cloud"].upper()
+    total = report["total_estimated_waste_usd"]
+    count = report["findings_count"]
+    generated_at = report["generated_at"][:10]
+    scan_id = report["scan_id"]
+    accounts = ", ".join(report.get("accounts_scanned", [])) or "—"
+    summary = html.escape(report.get("executive_summary", ""))
+    findings = report["findings"]
+
+    rows_html = _build_rows(findings)
+
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Argus — {cloud} Waste Report ({generated_at})</title>
+<style>
+*,*::before,*::after{{box-sizing:border-box;margin:0;padding:0}}
+body{{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;font-size:14px;line-height:1.5;color:#111;background:#f5f5f4}}
+a{{color:#185fa5;text-decoration:none}}
+a:hover{{text-decoration:underline}}
+.wrap{{max-width:1100px;margin:0 auto;padding:24px 16px}}
+.header{{background:#fff;border:1px solid #e5e5e5;border-radius:10px;padding:20px 24px;margin-bottom:16px}}
+.header-top{{display:flex;align-items:center;gap:10px;margin-bottom:12px}}
+.logo{{width:22px;height:22px}}
+.title{{font-size:17px;font-weight:600}}
+.meta{{font-size:12px;color:#888;margin-left:auto}}
+.stats{{display:flex;gap:12px;flex-wrap:wrap;margin-bottom:14px}}
+.stat{{background:#f5f5f4;border-radius:8px;padding:10px 16px;min-width:120px}}
+.stat-val{{font-size:22px;font-weight:600}}
+.stat-val.red{{color:#a32d2d}}
+.stat-lbl{{font-size:11px;color:#666;margin-top:2px}}
+.summary{{font-size:13px;color:#444;line-height:1.7;border-left:3px solid #e5e5e5;padding-left:12px}}
+.filters{{display:flex;gap:8px;flex-wrap:wrap;margin-bottom:12px;align-items:center}}
+.filters select,.filters input{{background:#fff;border:1px solid #d4d4d4;border-radius:6px;padding:6px 10px;font-size:13px;color:#111;outline:none}}
+.filters select:focus,.filters input:focus{{border-color:#378add}}
+.count-label{{margin-left:auto;font-size:12px;color:#888}}
+.card{{background:#fff;border:1px solid #e5e5e5;border-radius:10px;overflow:hidden}}
+table{{width:100%;border-collapse:collapse}}
+thead th{{font-size:11px;font-weight:600;color:#888;text-transform:uppercase;letter-spacing:.04em;padding:9px 12px;border-bottom:1px solid #e5e5e5;background:#fafaf9;text-align:left;white-space:nowrap}}
+thead th.sort{{cursor:pointer;user-select:none}}
+thead th.sort:hover{{color:#111}}
+tbody tr{{transition:background .1s}}
+tbody tr:hover{{background:#fafaf9}}
+tbody td{{padding:10px 12px;border-bottom:1px solid #f0f0f0;vertical-align:middle}}
+tbody tr:last-child td{{border-bottom:none}}
+.expand-btn{{background:none;border:none;cursor:pointer;color:#888;font-size:16px;line-height:1;padding:2px 4px;border-radius:4px}}
+.expand-btn:hover{{background:#f0f0f0;color:#111}}
+.pill{{display:inline-block;padding:2px 8px;border-radius:4px;font-size:11px;font-weight:600}}
+.pill-high{{background:#fcebeb;color:#a32d2d}}
+.pill-medium{{background:#faeeda;color:#854f0b}}
+.pill-low{{background:#eaf3de;color:#3b6d11}}
+.mono{{font-family:'SFMono-Regular',Consolas,'Liberation Mono',Menlo,monospace;font-size:12px}}
+.muted{{color:#888}}
+.cost-high{{font-weight:600;color:#a32d2d}}
+.cost-medium{{font-weight:600;color:#854f0b}}
+.cost-low{{font-weight:600;color:#3b6d11}}
+.detail-row td{{padding:0}}
+.detail-inner{{display:none;background:#fafaf9;border-top:1px solid #f0f0f0;padding:12px 16px;font-size:12px;line-height:1.7;color:#444}}
+.detail-inner.open{{display:block}}
+.detail-label{{font-weight:600;color:#111;margin-right:4px}}
+.footer{{display:flex;align-items:center;justify-content:space-between;padding:10px 16px;border-top:1px solid #f0f0f0;font-size:11px;color:#aaa}}
+@media(max-width:640px){{.stats{{flex-direction:column}}.meta{{display:none}}}}
+</style>
+</head>
+<body>
+<div class="wrap">
+  <div class="header">
+    <div class="header-top">
+      <svg class="logo" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+        <path d="M12 4L4 8l8 4 8-4-8-4z" fill="#E24B4A"/>
+        <path d="M4 12l8 4 8-4M4 16l8 4 8-4" stroke="#E24B4A" stroke-width="1.5" stroke-linecap="round"/>
+      </svg>
+      <span class="title">Argus — {cloud} Waste Report</span>
+      <span class="meta">{generated_at} &nbsp;·&nbsp; Scan {scan_id[:8]} &nbsp;·&nbsp; Accounts: {html.escape(accounts)}</span>
+    </div>
+    <div class="stats">
+      <div class="stat"><div class="stat-val red">${total:,.2f}</div><div class="stat-lbl">estimated waste / month</div></div>
+      <div class="stat"><div class="stat-val">{count}</div><div class="stat-lbl">findings</div></div>
+      <div class="stat"><div class="stat-val">{len(report.get("accounts_scanned", []))}</div><div class="stat-lbl">accounts scanned</div></div>
+    </div>
+    <p class="summary">{summary}</p>
+  </div>
+
+  <div class="filters">
+    <select id="f-priority" onchange="applyFilters()">
+      <option value="">All priorities</option>
+      <option>high</option><option>medium</option><option>low</option>
+    </select>
+    <select id="f-type" onchange="applyFilters()">
+      <option value="">All types</option>
+      {_build_type_options(findings)}
+    </select>
+    <input id="f-search" placeholder="Search resource ID, name, or region…" oninput="applyFilters()" style="min-width:220px">
+    <span class="count-label" id="count-label">Showing {count} of {count} findings</span>
+  </div>
+
+  <div class="card">
+    <table id="findings-table">
+      <thead>
+        <tr>
+          <th style="width:32px"></th>
+          <th class="sort" onclick="sortBy('priority')">Priority</th>
+          <th class="sort" onclick="sortBy('name')">Resource</th>
+          <th>Type</th>
+          <th>Region</th>
+          <th class="sort" onclick="sortBy('cost')">Cost / mo</th>
+          <th>Last activity</th>
+        </tr>
+      </thead>
+      <tbody id="tbody">
+        {rows_html}
+      </tbody>
+    </table>
+    <div class="footer">
+      <span>Generated by <a href="https://github.com/vamshisiddarth/argus">Argus</a> &nbsp;·&nbsp; Self-contained HTML, works offline</span>
+      <a href="#" onclick="downloadJson(event)">&#8595; Download JSON</a>
+    </div>
+  </div>
+</div>
+
+<script>
+var RAW_JSON = {_json_data(report)};
+
+function toggle(btn) {{
+  var row = btn.closest('tr');
+  var detail = row.nextElementSibling;
+  var inner = detail.querySelector('.detail-inner');
+  var open = inner.classList.contains('open');
+  inner.classList.toggle('open', !open);
+  btn.textContent = open ? '›' : '⌄';
+}}
+
+var sortState = {{col: 'cost', asc: false}};
+
+function sortBy(col) {{
+  if (sortState.col === col) sortState.asc = !sortState.asc;
+  else {{ sortState.col = col; sortState.asc = col !== 'cost'; }}
+  applyFilters();
+}}
+
+var PRIORITY_ORDER = {{high: 0, medium: 1, low: 2}};
+
+function applyFilters() {{
+  var p = document.getElementById('f-priority').value.toLowerCase();
+  var t = document.getElementById('f-type').value.toLowerCase();
+  var s = document.getElementById('f-search').value.toLowerCase();
+  var tbody = document.getElementById('tbody');
+  var rows = Array.from(tbody.querySelectorAll('tr[data-priority]'));
+
+  rows.forEach(function(row) {{
+    var dp = row.dataset.priority || '';
+    var dt = (row.dataset.rtype || '').toLowerCase();
+    var txt = row.textContent.toLowerCase();
+    var match = (!p || dp === p) && (!t || dt.includes(t)) && (!s || txt.includes(s));
+    row.style.display = match ? '' : 'none';
+    var detail = row.nextElementSibling;
+    if (detail && detail.classList.contains('detail-row')) {{
+      detail.style.display = match ? '' : 'none';
+      if (!match) detail.querySelector('.detail-inner').classList.remove('open');
+    }}
+  }});
+
+  var visible = rows.filter(function(r) {{ return r.style.display !== 'none'; }});
+
+  visible.sort(function(a, b) {{
+    var col = sortState.col;
+    var av, bv;
+    if (col === 'cost') {{
+      av = parseFloat(a.dataset.cost || 0);
+      bv = parseFloat(b.dataset.cost || 0);
+    }} else if (col === 'priority') {{
+      av = PRIORITY_ORDER[a.dataset.priority] || 99;
+      bv = PRIORITY_ORDER[b.dataset.priority] || 99;
+    }} else {{
+      av = (a.dataset.name || '').toLowerCase();
+      bv = (b.dataset.name || '').toLowerCase();
+    }}
+    if (av < bv) return sortState.asc ? -1 : 1;
+    if (av > bv) return sortState.asc ? 1 : -1;
+    return 0;
+  }});
+
+  visible.forEach(function(row) {{
+    var detail = row.nextElementSibling;
+    tbody.appendChild(row);
+    if (detail && detail.classList.contains('detail-row')) tbody.appendChild(detail);
+  }});
+
+  document.getElementById('count-label').textContent =
+    'Showing ' + visible.length + ' of ' + rows.length + ' findings';
+}}
+
+function downloadJson(e) {{
+  e.preventDefault();
+  var blob = new Blob([JSON.stringify(RAW_JSON, null, 2)], {{type: 'application/json'}});
+  var a = document.createElement('a');
+  a.href = URL.createObjectURL(blob);
+  a.download = 'argus-report-' + RAW_JSON.scan_id.slice(0, 8) + '.json';
+  a.click();
+}}
+</script>
+</body>
+</html>"""
+
+
+def _build_rows(findings: list[dict[str, Any]]) -> str:
+    parts: list[str] = []
+    for f in findings:
+        priority = (f.get("priority") or "low").lower()
+        resource_id = html.escape(f.get("resource_id") or "")
+        name = html.escape(f.get("name") or "")
+        rtype = html.escape(f.get("resource_type") or "")
+        region = html.escape(f.get("region") or "")
+        cost = f.get("estimated_monthly_cost") or 0.0
+        waste_reason = html.escape(f.get("waste_reason") or "")
+        recommendation = html.escape(f.get("recommendation") or "")
+        last_activity = f.get("last_activity")
+        if last_activity:
+            try:
+                dt = datetime.fromisoformat(str(last_activity).replace("Z", "+00:00"))
+                delta = datetime.now(tz=timezone.utc) - dt
+                days = delta.days
+                last_activity_str = f"{days}d ago" if days >= 0 else "—"
+            except (ValueError, TypeError):
+                last_activity_str = html.escape(str(last_activity))
+        else:
+            last_activity_str = "—"
+
+        display_name = name or resource_id
+        cost_class = f"cost-{priority}"
+        pill_class = f"pill-{priority}"
+
+        parts.append(
+            f"""<tr data-priority="{priority}" data-rtype="{rtype}" data-cost="{cost}" data-name="{display_name}">
+  <td><button class="expand-btn" onclick="toggle(this)" aria-label="expand">›</button></td>
+  <td><span class="pill {pill_class}">{priority.upper()}</span></td>
+  <td><span class="mono">{display_name}</span>{"<br><span class='mono muted'>" + resource_id + "</span>" if name else ""}</td>
+  <td class="muted">{rtype}</td>
+  <td class="muted">{region}</td>
+  <td class="{cost_class}">${cost:,.2f}</td>
+  <td class="muted">{last_activity_str}</td>
+</tr>
+<tr class="detail-row">
+  <td colspan="7"><div class="detail-inner">
+    <span class="detail-label">Why idle:</span>{waste_reason}<br>
+    <span class="detail-label">Recommendation:</span>{recommendation}
+  </div></td>
+</tr>"""
+        )
+    return "\n".join(parts)
+
+
+def _build_type_options(findings: list[dict[str, Any]]) -> str:
+    types = sorted(
+        {f.get("resource_type") or "" for f in findings if f.get("resource_type")}
+    )
+    return "\n".join(f"<option>{html.escape(t)}</option>" for t in types)
+
+
+def _json_data(report: dict[str, Any]) -> str:
+    import json
+
+    return json.dumps(report, default=str)

core/reports/multi_cloud.py

@@ -0,0 +1,162 @@
+"""
+Multi-cloud report aggregation and unified resource taxonomy.
+
+Merges individual per-cloud reports into a single combined report with
+normalized resource type names for cross-cloud comparison.
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+RESOURCE_TAXONOMY: dict[str, str] = {
+    # Compute
+    "AWS::EC2::Instance": "Compute Instance",
+    "AWS::EC2::NatGateway": "NAT Gateway",
+    "AWS::Lambda::Function": "Serverless Function",
+    "GCE": "Compute Instance",
+    "CloudFunction": "Serverless Function",
+    "VirtualMachine": "Compute Instance",
+    "AzureFunction": "Serverless Function",
+    # Database
+    "AWS::RDS::DBInstance": "Relational Database",
+    "AWS::RDS::DBCluster": "Database Cluster",
+    "CloudSQL": "Relational Database",
+    "AlloyDB": "Database Cluster",
+    "AzureSQL": "Relational Database",
+    "CosmosDB": "NoSQL Database",
+    # Cache
+    "AWS::ElastiCache::CacheCluster": "Cache Cluster",
+    "AWS::ElastiCache::ReplicationGroup": "Cache Cluster",
+    "Memorystore": "Cache Cluster",
+    "AzureCache": "Cache Cluster",
+    # Data warehouse
+    "AWS::Redshift::Cluster": "Data Warehouse",
+    "BigQuery": "Data Warehouse",
+    "Synapse": "Data Warehouse",
+    # Search
+    "AWS::Elasticsearch::Domain": "Search Service",
+    # Storage
+    "AWS::EC2::Volume": "Block Storage",
+    "PersistentDisk": "Block Storage",
+    "ManagedDisk": "Block Storage",
+    # Load balancer
+    "AWS::ElasticLoadBalancingV2::LoadBalancer": "Load Balancer",
+    "LoadBalancer": "Load Balancer",
+    "AzureLB": "Load Balancer",
+    # Replication
+    "AWS::DMS::ReplicationInstance": "Replication Instance",
+}
+
+
+def normalize_resource_type(resource_type: str) -> str:
+    return RESOURCE_TAXONOMY.get(resource_type, resource_type)
+
+
+def merge_reports(reports: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Merge multiple per-cloud reports into one combined multi-cloud report.
+
+    Each input report is a standard Argus report dict (from build_report()).
+    The merged report has:
+      - All findings from all clouds, sorted by cost descending
+      - Each finding gets a `normalized_type` field
+      - Combined totals and executive summary
+      - Per-cloud breakdown in `cloud_breakdown`
+    """
+    if not reports:
+        return _empty_merged_report()
+
+    if len(reports) == 1:
+        return _enrich_single(reports[0])
+
+    all_findings: list[dict[str, Any]] = []
+    clouds: list[str] = []
+    accounts: list[str] = []
+    total_input_tokens = 0
+    total_output_tokens = 0
+    summaries: list[str] = []
+    cloud_breakdown: list[dict[str, Any]] = []
+
+    for report in reports:
+        cloud = report["cloud"]
+        clouds.append(cloud)
+        accounts.extend(report.get("accounts_scanned", []))
+        total_input_tokens += report.get("agent_input_tokens", 0)
+        total_output_tokens += report.get("agent_output_tokens", 0)
+
+        if report.get("executive_summary"):
+            summaries.append(f"[{cloud.upper()}] {report['executive_summary']}")
+
+        cloud_breakdown.append(
+            {
+                "cloud": cloud,
+                "findings_count": report["findings_count"],
+                "total_estimated_waste_usd": report["total_estimated_waste_usd"],
+                "scan_id": report["scan_id"],
+            }
+        )
+
+        for finding in report.get("findings", []):
+            enriched = {**finding}
+            enriched["normalized_type"] = normalize_resource_type(
+                finding["resource_type"]
+            )
+            all_findings.append(enriched)
+
+    all_findings.sort(key=lambda f: f["estimated_monthly_cost"], reverse=True)
+    total_waste = sum(f["estimated_monthly_cost"] for f in all_findings)
+
+    return {
+        "schema_version": "1.0",
+        "scan_id": str(uuid.uuid4()),
+        "generated_at": datetime.now(tz=timezone.utc).isoformat(),
+        "cloud": "multi",
+        "clouds": sorted(set(clouds)),
+        "accounts_scanned": accounts,
+        "total_estimated_waste_usd": round(total_waste, 2),
+        "findings_count": len(all_findings),
+        "findings": all_findings,
+        "executive_summary": " ".join(summaries),
+        "agent_input_tokens": total_input_tokens,
+        "agent_output_tokens": total_output_tokens,
+        "cloud_breakdown": cloud_breakdown,
+    }
+
+
+def _empty_merged_report() -> dict[str, Any]:
+    return {
+        "schema_version": "1.0",
+        "scan_id": str(uuid.uuid4()),
+        "generated_at": datetime.now(tz=timezone.utc).isoformat(),
+        "cloud": "multi",
+        "clouds": [],
+        "accounts_scanned": [],
+        "total_estimated_waste_usd": 0.0,
+        "findings_count": 0,
+        "findings": [],
+        "executive_summary": "",
+        "agent_input_tokens": 0,
+        "agent_output_tokens": 0,
+        "cloud_breakdown": [],
+    }
+
+
+def _enrich_single(report: dict[str, Any]) -> dict[str, Any]:
+    enriched = {**report}
+    enriched["clouds"] = [report["cloud"]]
+    enriched["cloud_breakdown"] = [
+        {
+            "cloud": report["cloud"],
+            "findings_count": report["findings_count"],
+            "total_estimated_waste_usd": report["total_estimated_waste_usd"],
+            "scan_id": report["scan_id"],
+        }
+    ]
+    for finding in enriched.get("findings", []):
+        finding["normalized_type"] = normalize_resource_type(
+            finding["resource_type"]
+        )
+    return enriched