costguard-cli 2.0.16__tar.gz → 2.2.0__tar.gz

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: costguard-cli
-Version: 2.0.16
+Version: 2.2.0
 Summary: CostGuard CI/CD validation CLI — shift-left cost governance for cloud infrastructure
 Author-email: SKYXOPS <engineering@skyxops.com>
 License-Expression: LicenseRef-Proprietary
@@ -24,6 +24,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.28.0
 Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli/__init__.py

@@ -1,3 +1,3 @@
 """CostGuard CLI — shift-left cost governance for CI/CD pipelines."""
 
-__version__ = "2.0.15"
+__version__ = "2.2.0"

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli/formatters/html_report.py

@@ -1271,26 +1271,60 @@ class HtmlFormatter:
 
         decision = (endpoint_data.get("decision") or "ERROR").upper()
 
-        # Cost values — support both flat summary and legacy
+        # Cost values — support both flat summary and legacy. AI-CG-11:
+        # when past/planned/delta are present, the headline becomes the
+        # signed delta so DELETE / DOWNSIZE PRs render the savings instead
+        # of the misleading "$0.00" the legacy field reports.
         summary = results.get("summary") or {}
-        total_monthly = summary.get("total_monthly_cost") or results.get("total_monthly_usd")
         currency = summary.get("currency") or results.get("currency", "USD")
-        total_cost_str = f"${total_monthly:,.2f}" if total_monthly is not None else "N/A"
         resources_raw = results.get("resources") or []
         resource_count = summary.get("total_resources") or len(resources_raw)
 
-        # Prepare resource rows
+        past_total    = results.get("past_monthly_cost")
+        planned_total = results.get("planned_monthly_cost")
+        delta_total   = results.get("delta_monthly_cost")
+        legacy_total  = summary.get("total_monthly_cost") or results.get("total_monthly_usd")
+        # Keep `total_monthly` defined for legacy code paths below (violations
+        # block etc. expects this variable to exist).
+        total_monthly = legacy_total
+
+        if delta_total is not None and (past_total is not None or planned_total is not None):
+            sign = "+" if delta_total >= 0 else "-"
+            kind = "increase" if delta_total > 0 else ("savings" if delta_total < 0 else "no change")
+            total_cost_str = f"{sign}${abs(delta_total):,.2f} ({kind})"
+        else:
+            total_cost_str = f"${legacy_total:,.2f}" if legacy_total is not None else "N/A"
+
+        # Prepare resource rows — for DELETE the customer-visible cost
+        # column reflects the SAVINGS (signed negative), not the legacy
+        # future-state $0.
+        def _fmt_signed(v):
+            return f"{'+' if v >= 0 else '-'}${abs(v):,.2f}"
+
         resources = []
         for r in resources_raw:
             mc = r.get("monthly_cost")
             hc = r.get("hourly_cost")
+            ext = r.get("extensions") or {}
+            action = ext.get("action")
+            delta = ext.get("delta_monthly_cost")
+
+            if delta is not None and action in ("delete", "update", "create"):
+                # New-shape: render signed delta as the headline cost
+                monthly_str = _fmt_signed(delta)
+            else:
+                monthly_str = f"${mc:,.2f}" if mc is not None else "N/A"
+
             resources.append({
                 "resource_name": r.get("resource_name") or r.get("resource_id", "unknown"),
                 "resource_type": r.get("resource_type", "unknown"),
                 "provider": (r.get("provider") or "-").upper(),
                 "region": r.get("region", "-"),
                 "hourly_str": f"${hc:,.4f}" if hc is not None else "-",
-                "monthly_str": f"${mc:,.2f}" if mc is not None else "N/A",
+                "monthly_str": monthly_str,
+                "action": (action or "").capitalize(),
+                "past_str":    f"${ext.get('past_monthly_cost', 0):,.2f}"    if ext.get('past_monthly_cost')    is not None else "—",
+                "planned_str": f"${ext.get('planned_monthly_cost', 0):,.2f}" if ext.get('planned_monthly_cost') is not None else "—",
             })
 
         # Violations

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli/formatters/markdown.py

@@ -17,6 +17,11 @@ class MarkdownFormatter:
         "low": "🔵",
     }
 
+    # Wrap per-resource table in <details> when row count exceeds this.
+    # Big plans (50-100+ resources) otherwise bury budget/violations/AI
+    # narrative below an unreadable wall of rows.
+    RESOURCE_COLLAPSE_THRESHOLD = 10
+
     def format(self, response: dict, tag: str | None = None, **kwargs) -> str:
         """Format the full CostGuard API response as Markdown."""
         sections: list[str] = []
@@ -84,12 +89,39 @@ class MarkdownFormatter:
         )
 
     def _cost_summary(self, results: dict) -> str:
+        """Render plan-level summary.
+
+        AI-CG-11: when the response carries past/planned/delta (server added
+        these in feature/ai-cg-11-cost-diff), surface the signed delta as
+        the headline so DELETE / DOWNSIZE PRs show their savings instead of
+        the misleading "Estimated Monthly Cost: $0" the legacy field reports.
+        """
         summary = results.get("summary") or {}
-        total = summary.get("total_monthly_cost") or results.get("total_monthly_usd")
         currency = summary.get("currency") or results.get("currency", "USD")
         resource_count = summary.get("total_resources") or len(results.get("resources") or [])
 
-        total_str = f"${total:,.2f}" if total is not None else "N/A"
+        # New cost-diff fields take precedence when present.
+        past    = results.get("past_monthly_cost")
+        planned = results.get("planned_monthly_cost")
+        delta   = results.get("delta_monthly_cost")
+        legacy_total = summary.get("total_monthly_cost") or results.get("total_monthly_usd")
+
+        if delta is not None and (past is not None or planned is not None):
+            sign = "+" if delta >= 0 else "-"
+            kind = "increase" if delta > 0 else ("savings" if delta < 0 else "no change")
+            past_str    = f"${past:,.2f}"    if past    is not None else "$0.00"
+            planned_str = f"${planned:,.2f}" if planned is not None else "$0.00"
+            return (
+                f"### Cost Summary\n\n"
+                f"| Metric | Value |\n"
+                f"|--------|-------|\n"
+                f"| **Monthly cost change** | **{sign}${abs(delta):,.2f} {currency} ({kind})** |\n"
+                f"| Past monthly cost | {past_str} |\n"
+                f"| Planned monthly cost | {planned_str} |\n"
+                f"| Resources Analyzed | {resource_count} |"
+            )
+
+        total_str = f"${legacy_total:,.2f}" if legacy_total is not None else "N/A"
         return (
             f"### Cost Summary\n\n"
             f"| Metric | Value |\n"
@@ -99,24 +131,89 @@ class MarkdownFormatter:
         )
 
     def _resource_table(self, resources: list[dict]) -> str:
-        lines = [
-            "### Per-Resource Costs\n",
-            "| Resource | Type | Region | Monthly Cost |",
-            "|----------|------|--------|-------------:|",
-        ]
+        """Render per-resource table.
+
+        AI-CG-11: adaptive columns based on the actions present in the plan:
+          pure CREATE  → Resource · Type · Region · Cost  (3-col cost area)
+          pure DELETE  → Resource · Type · Region · Savings  (signed negative)
+          UPDATE / MIX → Resource · Type · Region · Action · Past · Planned · Δ
+
+        DELETE rows previously rendered "$0.00" because monthly_cost is the
+        future-state cost. Now they render the signed delta (the saving).
+        """
+        actions = {
+            (r.get("extensions") or {}).get("action")
+            for r in resources
+        }
+        actions.discard(None)
+        # Default to all-columns shape when actions are mixed or absent
+        pure_create = actions == {"create"}
+        pure_delete = actions == {"delete"}
+
+        if pure_create:
+            header = "| Resource | Type | Region | Cost |"
+            divider = "|----------|------|--------|-----:|"
+        elif pure_delete:
+            header = "| Resource | Type | Region | Savings |"
+            divider = "|----------|------|--------|--------:|"
+        else:
+            header = "| Resource | Type | Region | Action | Past | Planned | Δ |"
+            divider = "|----------|------|--------|--------|-----:|--------:|---:|"
+
+        rows = [header, divider]
 
         for r in resources:
             name = r.get("resource_name") or r.get("resource_id", "unknown")
             rtype = r.get("resource_type", "unknown")
             region = r.get("region", "-")
-            mc = r.get("monthly_cost")
-            cost_str = f"${mc:,.2f}" if mc is not None else "N/A"
+            ext = r.get("extensions") or {}
+            action = ext.get("action")
+            past    = ext.get("past_monthly_cost")
+            planned = ext.get("planned_monthly_cost")
+            delta   = ext.get("delta_monthly_cost")
+            mc      = r.get("monthly_cost")
             success = r.get("success", True)
             status = "" if success else " (failed)"
 
-            lines.append(f"| `{name}` | {rtype} | {region} | {cost_str}{status} |")
-
-        return "\n".join(lines)
+            def fmt(v):
+                return f"${v:,.2f}" if v is not None else "—"
+            def fmt_signed(v):
+                if v is None:
+                    return "—"
+                return f"{'+' if v >= 0 else '-'}${abs(v):,.2f}"
+
+            if pure_create:
+                cost_str = fmt(planned if planned is not None else mc)
+                rows.append(f"| `{name}` | {rtype} | {region} | {cost_str}{status} |")
+            elif pure_delete:
+                savings_str = fmt_signed(delta) if delta is not None else fmt_signed(-(past or 0))
+                rows.append(f"| `{name}` | {rtype} | {region} | {savings_str}{status} |")
+            else:
+                action_str = (action or "-").capitalize() if action else "-"
+                past_str    = "—" if action == "create" else fmt(past)
+                planned_str = "—" if action == "delete" else fmt(planned)
+                delta_str   = fmt_signed(delta) if delta is not None else fmt(mc)
+                rows.append(
+                    f"| `{name}` | {rtype} | {region} | {action_str} | "
+                    f"{past_str} | {planned_str} | {delta_str}{status} |"
+                )
+
+        table = "\n".join(rows)
+        count = len(resources)
+
+        # Long resource lists make PR/MR comments huge and dominate the review
+        # surface. Wrap the table in <details> when it crosses the threshold so
+        # reviewers see the summary by default and can expand on demand.
+        # GitLab and GitHub both render <details>/<summary> as native folds.
+        if count > self.RESOURCE_COLLAPSE_THRESHOLD:
+            return (
+                "### Per-Resource Costs\n\n"
+                f"<details>\n"
+                f"<summary>Show {count} resources</summary>\n\n"
+                f"{table}\n\n"
+                f"</details>"
+            )
+        return f"### Per-Resource Costs\n\n{table}"
 
     def _budget_section(self, budget: dict) -> str:
         budget_name = budget.get("budget_name", "Unknown")

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli/validate.py

@@ -185,8 +185,37 @@ def build_parser() -> argparse.ArgumentParser:
 # ---------------------------------------------------------------------------
 # Plan file reading
 # ---------------------------------------------------------------------------
+def _parse_plan_text(raw: str, source: str) -> dict:
+    """Parse plan text as JSON, falling back to YAML for CloudFormation
+    templates which are commonly authored in YAML. `source` is used only
+    for error messages ('stdin' or a file path)."""
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as json_exc:
+        try:
+            import yaml  # PyYAML is a runtime dep — see pyproject.toml
+        except ImportError as imp_exc:
+            raise ValueError(
+                f"Invalid JSON in {source} ({json_exc}); install PyYAML to also "
+                "accept CloudFormation YAML templates."
+            ) from imp_exc
+        try:
+            loaded = yaml.safe_load(raw)
+        except yaml.YAMLError as yaml_exc:
+            raise ValueError(
+                f"{source} is neither valid JSON ({json_exc}) nor valid YAML ({yaml_exc})."
+            ) from yaml_exc
+        if not isinstance(loaded, dict):
+            raise ValueError(
+                f"{source} parsed as YAML to {type(loaded).__name__}, expected a dict "
+                "(top-level mapping like a CloudFormation template)."
+            )
+        return loaded
+
+
 def read_plan_file(plan_path: str) -> dict:
-    """Read and parse the IaC plan JSON file, or stdin when plan_path is '-'."""
+    """Read and parse the IaC plan JSON (or CloudFormation YAML) file, or
+    stdin when plan_path is '-'."""
     if plan_path == "-":
         try:
             raw = sys.stdin.read()
@@ -194,10 +223,7 @@ def read_plan_file(plan_path: str) -> dict:
             raise ValueError("Stdin read interrupted")
         if not raw.strip():
             raise ValueError("No data received on stdin (empty pipe)")
-        try:
-            return json.loads(raw)
-        except json.JSONDecodeError as exc:
-            raise ValueError(f"Invalid JSON on stdin: {exc}") from exc
+        return _parse_plan_text(raw, source="stdin")
 
     path = Path(plan_path)
     if not path.exists():
@@ -205,11 +231,9 @@ def read_plan_file(plan_path: str) -> dict:
     if not path.is_file():
         raise ValueError(f"Plan path is not a file: {plan_path}")
 
-    try:
-        with open(path, "r", encoding="utf-8") as fh:
-            return json.load(fh)
-    except json.JSONDecodeError as exc:
-        raise ValueError(f"Invalid JSON in plan file: {exc}") from exc
+    with open(path, "r", encoding="utf-8") as fh:
+        raw = fh.read()
+    return _parse_plan_text(raw, source=str(path))
 
 
 # ---------------------------------------------------------------------------
@@ -235,6 +259,69 @@ def detect_iac_type(plan_content: dict) -> str:
     return "terraform"
 
 
+def _changeset_missing_properties(plan_content: dict) -> bool:
+    """Detect CloudFormation describe-change-set output that lacks resource
+    Properties — AWS strips Properties unless `describe-change-set` was
+    invoked with `--include-property-values`. CostGuard's CFN parser cannot
+    price these and would return 'Invalid CloudFormation format' or zero
+    monthly cost. Catching it locally saves an API round-trip and gives a
+    clearer error message.
+
+    Returns True only when:
+      - the plan looks like a changeset (has Changes[])
+      - at least one Add/Modify change is present
+      - NONE of those changes carry property values (AfterContext.Properties
+        or BeforeContext.Properties or Details[].Target.Name)
+    """
+    changes = plan_content.get("Changes")
+    if not isinstance(changes, list) or not changes:
+        return False  # Not a changeset shape, let the API/parser handle it.
+
+    saw_priceable_change = False
+    for change in changes:
+        if not isinstance(change, dict):
+            continue
+        rc = change.get("ResourceChange") or {}
+        action = (rc.get("Action") or "").lower()
+        if action in ("remove", "delete"):
+            continue  # Deletes have no cost impact, no Properties expected.
+        saw_priceable_change = True
+
+        # Properties may be present in any of these shapes.
+        for ctx_key in ("AfterContext", "BeforeContext"):
+            ctx = rc.get(ctx_key)
+            if isinstance(ctx, str):
+                # AWS sometimes serializes as a JSON-encoded string.
+                try:
+                    ctx = json.loads(ctx)
+                except (json.JSONDecodeError, TypeError):
+                    ctx = None
+            if isinstance(ctx, dict) and ctx.get("Properties"):
+                return False
+        details = rc.get("Details") or []
+        if any(
+            isinstance(d, dict) and (d.get("Target") or {}).get("Name")
+            for d in details
+        ):
+            return False
+
+    return saw_priceable_change
+
+
+def _normalize_api_url(api_url: str) -> str:
+    """Accept either a base URL ('https://host') or a full endpoint URL
+    ('https://host/v1/costguard/analyze') so users can store whichever they
+    like in COSTGUARD_API_URL without thinking about which one this CLI
+    expects. Strips the well-known analyze suffix if present so the caller
+    can safely re-append it.
+    """
+    base = api_url.rstrip("/")
+    suffix = "/v1/costguard/analyze"
+    if base.endswith(suffix):
+        base = base[: -len(suffix)]
+    return base
+
+
 def call_costguard_api(
     api_url: str,
     api_key: str,
@@ -249,7 +336,7 @@ def call_costguard_api(
     errors (429, 502, 503, 504, timeouts, connection resets).
     Client errors (400, 401, 403, 404) fail immediately.
     """
-    url = f"{api_url.rstrip('/')}/v1/costguard/analyze"
+    url = f"{_normalize_api_url(api_url)}/v1/costguard/analyze"
 
     headers = {
         "x-api-key": api_key,
@@ -424,6 +511,23 @@ def main() -> None:
         # Determine IaC type
         iac_type = args.iac_type or detect_iac_type(plan_content)
 
+        # Pre-flight: CloudFormation changesets must include resource
+        # property values; otherwise the API has nothing to price against
+        # and would return "Invalid CloudFormation format". Catching this
+        # locally avoids a wasted API call and points the user at the AWS
+        # CLI flag they actually need.
+        if iac_type == "cloudformation" and _changeset_missing_properties(plan_content):
+            print(
+                "[CostGuard] ERROR: CloudFormation changeset contains no resource "
+                "Properties.\n"
+                "[CostGuard] Hint: regenerate the changeset with --include-property-values:\n"
+                "[CostGuard]   aws cloudformation describe-change-set \\\n"
+                "[CostGuard]     --stack-name <stack> --change-set-name <name> \\\n"
+                "[CostGuard]     --include-property-values > changeset.json",
+                file=sys.stderr,
+            )
+            sys.exit(EXIT_ERROR)
+
         # Warn if no budget code and no skip — API will reject
         if not budget_code and not args.skip_budget:
             print(

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: costguard-cli
-Version: 2.0.16
+Version: 2.2.0
 Summary: CostGuard CI/CD validation CLI — shift-left cost governance for cloud infrastructure
 Author-email: SKYXOPS <engineering@skyxops.com>
 License-Expression: LicenseRef-Proprietary
@@ -24,6 +24,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.28.0
 Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli.egg-info/SOURCES.txt

@@ -16,4 +16,6 @@ costguard_cli/formatters/__init__.py
 costguard_cli/formatters/html_report.py
 costguard_cli/formatters/json_report.py
 costguard_cli/formatters/markdown.py
-costguard_cli/formatters/terminal.py
+costguard_cli/formatters/terminal.py
+tests/test_formatters_cost_diff.py
+tests/test_resource_table_collapse.py

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/costguard_cli.egg-info/requires.txt

@@ -1,5 +1,6 @@
 requests>=2.28.0
 jinja2>=3.1.0
+pyyaml>=6.0
 
 [dev]
 pytest>=7.0

{costguard_cli-2.0.16 → costguard_cli-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "costguard-cli"
-version = "2.0.16"
+version = "2.2.0"
 description = "CostGuard CI/CD validation CLI — shift-left cost governance for cloud infrastructure"
 requires-python = ">=3.9"
 license = "LicenseRef-Proprietary"
@@ -36,6 +36,7 @@ classifiers = [
 dependencies = [
     "requests>=2.28.0",
     "jinja2>=3.1.0",
+    "pyyaml>=6.0",
 ]
 
 [project.scripts]

costguard_cli-2.2.0/tests/test_formatters_cost_diff.py

@@ -0,0 +1,157 @@
+# =============================================================================
+# Copyright (c) 2026 SKYXOPS Corp. All rights reserved.
+# =============================================================================
+"""AI-CG-11 follow-up: markdown + HTML formatters render signed cost-diff
+when the costguard API response carries past/planned/delta fields.
+
+Regression-guard for the original bug: DELETE resources render as "$0.00"
+in the legacy `monthly_cost` field, hiding the savings from the reviewer.
+"""
+
+import pytest
+
+from costguard_cli.formatters.markdown import MarkdownFormatter
+from costguard_cli.formatters.html_report import HtmlFormatter
+
+
+@pytest.fixture
+def markdown():
+    return MarkdownFormatter()
+
+
+@pytest.fixture
+def html():
+    return HtmlFormatter()
+
+
+def _mixed_response():
+    """Minimal response shape with all 4 actions exercised. Mirrors the
+    real costguard API: top-level `endpoint_data` (decision/violations/budget)
+    + top-level `results` (cost numbers + resources)."""
+    return {
+        "request_id": "01J5K8R7-TEST",
+        "endpoint_data": {"decision": "ALLOW"},
+        "results": {
+            "narrative": "Test narrative.",
+            "currency": "USD",
+            "past_monthly_cost":    270.60,
+            "planned_monthly_cost": 247.90,
+            "delta_monthly_cost":   -22.70,
+            "total_monthly_usd":    247.90,
+            "resources": [
+                {
+                    "resource_name": "aws_instance.d1",
+                    "resource_type": "aws_instance",
+                    "provider": "aws",
+                    "region": "us-east-1",
+                    "monthly_cost": 0.0,
+                    "extensions": {
+                        "action": "delete",
+                        "past_monthly_cost":    140.00,
+                        "planned_monthly_cost":   0.00,
+                        "delta_monthly_cost":  -140.00,
+                    },
+                },
+                {
+                    "resource_name": "aws_instance.u1",
+                    "resource_type": "aws_instance",
+                    "provider": "aws",
+                    "region": "us-east-1",
+                    "monthly_cost": 3.80,
+                    "extensions": {
+                        "action": "update",
+                        "past_monthly_cost":   30.30,
+                        "planned_monthly_cost": 3.80,
+                        "delta_monthly_cost": -26.50,
+                    },
+                },
+                {
+                    "resource_name": "aws_instance.c1",
+                    "resource_type": "aws_instance",
+                    "provider": "aws",
+                    "region": "us-east-1",
+                    "monthly_cost": 70.00,
+                    "extensions": {
+                        "action": "create",
+                        "past_monthly_cost":    0.00,
+                        "planned_monthly_cost": 70.00,
+                        "delta_monthly_cost":  +70.00,
+                    },
+                },
+            ],
+        },
+    }
+
+
+def _pure_delete_response():
+    return {
+        "request_id": "01J5K8R7-DEL",
+        "endpoint_data": {"decision": "ALLOW"},
+        "results": {
+            "narrative": "Decommission.",
+            "currency": "USD",
+            "past_monthly_cost":    430.50,
+            "planned_monthly_cost":   0.00,
+            "delta_monthly_cost":  -430.50,
+            "total_monthly_usd":      0.00,
+            "resources": [
+                {
+                    "resource_name": "aws_db_instance.legacy",
+                    "resource_type": "aws_db_instance",
+                    "provider": "aws", "region": "us-east-1",
+                    "monthly_cost": 0.0,
+                    "extensions": {
+                        "action": "delete",
+                        "past_monthly_cost":   290.20,
+                        "planned_monthly_cost":  0.00,
+                        "delta_monthly_cost":  -290.20,
+                    },
+                },
+            ],
+        },
+    }
+
+
+# ----- Markdown -----
+
+def test_markdown_mixed_shows_signed_delta_headline(markdown):
+    out = markdown.format(_mixed_response())
+    assert "Monthly cost change" in out
+    assert "-$22.70" in out
+    assert "(savings)" in out
+
+
+def test_markdown_delete_row_shows_negative_savings_not_zero(markdown):
+    out = markdown.format(_mixed_response())
+    # The DELETE row's Δ column must show -$140.00, NOT $0.00
+    assert "-$140.00" in out
+    # Sanity: the DELETE row's Δ column contains the signed savings
+    # (note: aws_instance.d1 also appears in the hourly-cost collapsible,
+    # so just verify the resource is rendered at all).
+    assert "aws_instance.d1" in out
+
+
+def test_markdown_pure_delete_uses_savings_column(markdown):
+    out = markdown.format(_pure_delete_response())
+    assert "Savings" in out
+    assert "-$290.20" in out
+
+
+# ----- HTML -----
+
+def test_html_mixed_shows_signed_delta_headline(html):
+    out = html.format(_mixed_response())
+    assert "-$22.70" in out
+    assert "(savings)" in out
+
+
+def test_html_delete_row_shows_signed_savings(html):
+    out = html.format(_mixed_response())
+    assert "-$140.00" in out
+    assert "aws_instance.d1" in out
+
+
+def test_html_pure_delete_headline_shows_signed_delta(html):
+    out = html.format(_pure_delete_response())
+    assert "-$430.50" in out
+    assert "aws_db_instance.legacy" in out

costguard_cli-2.2.0/tests/test_resource_table_collapse.py

@@ -0,0 +1,54 @@
+"""AI-XMOD-202: collapse per-resource cost table when > RESOURCE_COLLAPSE_THRESHOLD."""
+
+from costguard_cli.formatters.markdown import MarkdownFormatter
+
+
+def _response(n_resources: int) -> dict:
+    return {
+        "endpoint_data": {"decision": "ALLOW", "budget": {}, "violations": []},
+        "results": {
+            "total_monthly_usd": n_resources * 10,
+            "resources": [
+                {
+                    "resource_name": f"aws_instance.r{i}",
+                    "resource_type": "aws_instance",
+                    "region": "us-east-1",
+                    "monthly_cost": 10.0,
+                    "extensions": {"action": "create", "planned_monthly_cost": 10.0},
+                }
+                for i in range(n_resources)
+            ],
+        },
+        "request_id": "test",
+        "timestamp": "2026-05-24T00:00:00",
+        "processing_time_ms": 1,
+    }
+
+
+def test_short_table_renders_flat():
+    out = MarkdownFormatter().format(_response(5))
+    assert "### Per-Resource Costs" in out
+    assert "<summary>Show 5 resources" not in out
+    assert "aws_instance.r0" in out
+    assert "aws_instance.r4" in out
+
+
+def test_long_table_wrapped_in_details():
+    out = MarkdownFormatter().format(_response(15))
+    assert "### Per-Resource Costs" in out
+    assert "<details>" in out
+    assert "<summary>Show 15 resources</summary>" in out
+    assert "</details>" in out
+    assert "aws_instance.r0" in out
+    assert "aws_instance.r14" in out
+
+
+def test_threshold_boundary_exact_match_not_collapsed():
+    # At exactly the threshold, stay flat (strictly greater than collapses).
+    out = MarkdownFormatter().format(_response(MarkdownFormatter.RESOURCE_COLLAPSE_THRESHOLD))
+    assert "<summary>Show" not in out
+
+
+def test_threshold_boundary_one_over_collapses():
+    out = MarkdownFormatter().format(_response(MarkdownFormatter.RESOURCE_COLLAPSE_THRESHOLD + 1))
+    assert "<summary>Show" in out