@adgine/geo-cli 1.2.8

package/skills/adgine-geo-aiagent/scripts/page_analytics.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""Site-wide AI traffic analytics — overall KPI, page rankings, Sankey, raw logs.
+
+Subcommands:
+  overview-kpi                     — site overall KPIs (5 cards + trends):
+                                     citation / index / training / agent / referral
+  pages       [--page 1] [--limit 20]   — top pages by AI references
+  pages-detail [--limit 20]        — 5-metric table per page (citation/index/training/
+                                     agent/referral) with previous-period delta
+  pages-export [--format csv|json] — download pages-detail as CSV/JSON
+  platform-flow                    — Sankey: AI platform → page path
+  logs [--limit 50]                — raw AI event logs (bot + human, paginated)
+
+Common opts: --start --end [--platform]
+
+Usage:
+  python3 scripts/page_analytics.py overview-kpi
+  python3 scripts/page_analytics.py pages-detail --start 2025-11-01
+  python3 scripts/page_analytics.py pages-export --format csv > pages.csv
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import (
+    get_api_config, get_project_id,
+    api_get,
+    extract_data, print_json, truncate,
+    pad,
+)
+
+
+def _fmt_num(n):
+    if n is None:
+        return "--"
+    try:
+        f = float(n)
+        if f == int(f):
+            return f"{int(f):,}"
+        return f"{f:,.1f}"
+    except (TypeError, ValueError):
+        return str(n)
+
+
+def _fmt_change(c):
+    if c is None:
+        return "--"
+    try:
+        f = float(c)
+        sign = "+" if f >= 0 else ""
+        return f"{sign}{f:.1f}%"
+    except (TypeError, ValueError):
+        return str(c)
+
+
+def _date_params(args):
+    p = {}
+    if args.start:
+        p["start_date"] = args.start
+    if args.end:
+        p["end_date"] = args.end
+    if getattr(args, "platform", None):
+        p["platform"] = args.platform
+    return p or None
+
+
+def cmd_overview_kpi(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/ai-agent/overview-kpi",
+                     key, base, params=_date_params(args))
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    # This endpoint returns a flat dict:
+    # {ai_citations, ai_index, ai_training, ai_agent, human_referrals, ai_human_ratio, ...}
+    # Each value is a {current, prev, delta, delta_pct, ...} dict.
+
+    def _get_kpi(d, k):
+        v = d.get(k)
+        if isinstance(v, dict):
+            cur = v.get("current")
+            delta_pct = v.get("delta_pct")
+            if delta_pct is not None:
+                ch_str = f"+{delta_pct:.1f}%" if delta_pct >= 0 else f"{delta_pct:.1f}%"
+            else:
+                ch_str = "--"
+        else:
+            cur, ch_str = v, "--"
+        return cur, ch_str
+
+    print("Site AI Overview — 5 KPI cards")
+    print()
+    print("```")
+    print("┌────────────────────┬──────────────┬──────────────┐")
+    print("│ KPI                │      Current │       Change │")
+    print("├────────────────────┼──────────────┼──────────────┤")
+    for k, label in [
+        ("ai_citations",   "AI Citation"),
+        ("ai_index",       "AI Index"),
+        ("ai_training",    "AI Training"),
+        ("ai_agent",       "AI Agent"),
+        ("human_referrals","AI Referral"),
+        ("ai_human_ratio", "AI Referral %"),
+    ]:
+        cur, ch_str = _get_kpi(data, k)
+        print(f"│ {pad(label, 18)} │ {_fmt_num(cur):>12} │ {ch_str:>12} │")
+    print("└────────────────────┴──────────────┴──────────────┘")
+    print("```")
+
+
+def cmd_pages(args, key, base, pid):
+    params = _date_params(args) or {}
+    params["page"] = args.page
+    params["limit"] = args.limit
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages",
+                     key, base, params=params)
+    data = extract_data(result)
+    # API returns {items, total, ...} not a bare list or {"pages": [...]}
+    if isinstance(data, list):
+        items = data
+    elif isinstance(data, dict):
+        items = data.get("items") or data.get("pages", [])
+    else:
+        items = []
+    total = data.get("total", len(items)) if isinstance(data, dict) else len(items)
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print("No page data.")
+        return
+    print(f"Top AI-referenced pages ({total} total, showing {len(items)})")
+    print()
+    print("```")
+    print("┌────────────────────────────────────────────┬──────────┬────────┬──────────┐")
+    print("│ Page                                       │ Bot Hits │  Human │ Total AI │")
+    print("├────────────────────────────────────────────┼──────────┼────────┼──────────┤")
+    for p in items:
+        path = truncate(p.get("path") or p.get("url"), 42)
+        bot = _fmt_num(p.get("bot_requests") or p.get("ai_hits") or p.get("count"))
+        human = _fmt_num(p.get("human_referral_requests"))
+        total_ai = _fmt_num(p.get("total_ai_requests") or p.get("references"))
+        print(f"│ {pad(path, 42)} │ {bot:>8} │ {human:>6} │ {total_ai:>8} │")
+    print("└────────────────────────────────────────────┴──────────┴────────┴──────────┘")
+    print("```")
+
+
+def cmd_pages_detail(args, key, base, pid):
+    params = _date_params(args) or {}
+    params["page"] = args.page
+    params["limit"] = args.limit
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages-detail",
+                     key, base, params=params)
+    data = extract_data(result)
+    # API returns {items, total, ...} not a bare list or {"pages": [...]}
+    if isinstance(data, list):
+        items = data
+    elif isinstance(data, dict):
+        items = data.get("items") or data.get("pages", [])
+    else:
+        items = []
+    total = data.get("total", len(items)) if isinstance(data, dict) else len(items)
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print("No page detail data.")
+        return
+    print(f"Pages — 5-metric detail ({total} total, showing {len(items)})")
+    print()
+    print("```")
+    print("┌────────────────────────────────┬──────┬──────┬──────┬──────┬──────┐")
+    print("│ Page                           │ Cite │ Indx │ Trn  │ Agnt │ Ref  │")
+    print("├────────────────────────────────┼──────┼──────┼──────┼──────┼──────┤")
+    for p in items:
+        path = truncate(p.get("path") or p.get("url"), 30)
+        c = _fmt_num(p.get("ai_citation"))
+        i = _fmt_num(p.get("ai_search") or p.get("ai_index"))
+        t = _fmt_num(p.get("ai_training"))
+        a = _fmt_num(p.get("ai_agent"))
+        r = _fmt_num(p.get("ai_referral") or p.get("ai_referral_visits"))
+        print(f"│ {pad(path, 30)} │ {c:>4} │ {i:>4} │ {t:>4} │ {a:>4} │ {r:>4} │")
+    print("└────────────────────────────────┴──────┴──────┴──────┴──────┴──────┘")
+    print("```")
+
+
+def cmd_pages_export(args, key, base, pid):
+    params = _date_params(args) or {}
+    params["format"] = args.format
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages-detail/export",
+                     key, base, params=params)
+    # Export returns raw CSV or JSON — pass through.
+    if isinstance(result, (dict, list)):
+        if args.format == "json":
+            print_json(result)
+        else:
+            print(result)
+    else:
+        print(result)
+
+
+def cmd_platform_flow(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages-platform-flow",
+                     key, base, params=_date_params(args))
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    nodes = data.get("nodes", [])
+    links = data.get("links", [])
+    print(f"Sankey AI platform → page: {len(nodes)} nodes, {len(links)} links")
+    print()
+    sorted_links = sorted(links, key=lambda l: l.get("value", 0), reverse=True)[:15]
+    for ln in sorted_links:
+        s = ln.get("source")
+        t = ln.get("target")
+        v = _fmt_num(ln.get("value"))
+        print(f"  {s} → {t}  ({v})")
+
+
+def cmd_logs(args, key, base, pid):
+    params = _date_params(args) or {}
+    params["page"] = args.page
+    params["limit"] = args.limit
+    if args.traffic_type:
+        params["traffic_type"] = args.traffic_type
+    result = api_get(f"/api/projects/{pid}/ai-agent/logs",
+                     key, base, params=params)
+    data = extract_data(result)
+    # API returns {items, total, page, limit, pages}
+    if isinstance(data, list):
+        items = data
+        total = len(data)
+    elif isinstance(data, dict):
+        items = data.get("items") or data.get("logs") or data.get("events", [])
+        total = data.get("total", len(items))
+    else:
+        items = []
+        total = 0
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print("No log events.")
+        return
+    print(f"Raw AI event logs (total {total}, showing {len(items)})")
+    print()
+    print("```")
+    print("┌────────────────────┬────────────────────┬────────────┬──────────────────────────┐")
+    print("│ Time (UTC)         │ Type               │ Platform   │ Path                     │")
+    print("├────────────────────┼────────────────────┼────────────┼──────────────────────────┤")
+    for e in items:
+        t = truncate(
+            (e.get("occurred_at") or e.get("timestamp") or e.get("created_at") or "")[:19].replace("T", " "),
+            18)
+        ttype = truncate(
+            e.get("traffic_type_label") or e.get("bot_name") or e.get("traffic_type") or "(human)",
+            18)
+        plat = truncate(e.get("platform_name") or e.get("platform") or "--", 10)
+        path = truncate(e.get("path") or e.get("url"), 24)
+        print(f"│ {pad(t, 18)} │ {pad(ttype, 18)} │ {pad(plat, 10)} │ {pad(path, 24)} │")
+    print("└────────────────────┴────────────────────┴────────────┴──────────────────────────┘")
+    print("```")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Site-wide AI traffic analytics")
+    parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    for name in ("overview-kpi", "platform-flow"):
+        p = sub.add_parser(name)
+        p.add_argument("--start")
+        p.add_argument("--end")
+        p.add_argument("--platform")
+
+    for name in ("pages", "pages-detail"):
+        p = sub.add_parser(name)
+        p.add_argument("--start")
+        p.add_argument("--end")
+        p.add_argument("--platform")
+        p.add_argument("--page", type=int, default=1)
+        p.add_argument("--limit", type=int, default=20)
+
+    p_ex = sub.add_parser("pages-export")
+    p_ex.add_argument("--start")
+    p_ex.add_argument("--end")
+    p_ex.add_argument("--platform")
+    p_ex.add_argument("--format", choices=["csv", "json"], default="csv")
+
+    p_lg = sub.add_parser("logs")
+    p_lg.add_argument("--start")
+    p_lg.add_argument("--end")
+    p_lg.add_argument("--platform")
+    p_lg.add_argument("--page", type=int, default=1)
+    p_lg.add_argument("--limit", type=int, default=50)
+    p_lg.add_argument("--traffic-type", choices=["bot", "human"])
+
+    args = parser.parse_args()
+    key, base = get_api_config()
+    pid = get_project_id(args.project_id)
+
+    handlers = {
+        "overview-kpi": cmd_overview_kpi,
+        "pages": cmd_pages,
+        "pages-detail": cmd_pages_detail,
+        "pages-export": cmd_pages_export,
+        "platform-flow": cmd_platform_flow,
+        "logs": cmd_logs,
+    }
+    handlers[args.command](args, key, base, pid)
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-aiagent/scripts/page_detail.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Deep-dive analytics for a specific page path.
+
+All subcommands require --path (URL path on the project's website).
+
+Subcommands:
+  kpi --path <p>          — 5 KPI cards for this page (citation/index/training/
+                            agent/total bots) with delta + daily trend
+  logs --path <p>         — recent AI access events on this exact path
+        [--limit 50] [--traffic-type bot|human]
+  platforms --path <p>    — per-platform 4-AI + human-referral + share table
+  related --path <p>      — sibling pages under the same parent path, with
+                            5-metric comparison
+  health --path <p>       — PageSpeed Insights report (cached). Returns
+                            report=null if never analyzed.
+  health-refresh --path <p>  — synchronously refresh PSI report (15–60s blocking)
+
+Common opts: --start --end
+
+Usage:
+  python3 scripts/page_detail.py kpi --path /blog/my-article
+  python3 scripts/page_detail.py logs --path /blog/my-article --limit 20
+  python3 scripts/page_detail.py health --path /blog/my-article
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import (
+    get_api_config, get_project_id,
+    api_get, api_post,
+    extract_data, print_json, truncate,
+    pad,
+)
+
+
+def _fmt_num(n):
+    if n is None:
+        return "--"
+    try:
+        f = float(n)
+        if f == int(f):
+            return f"{int(f):,}"
+        return f"{f:,.1f}"
+    except (TypeError, ValueError):
+        return str(n)
+
+
+def _fmt_change(c):
+    if c is None:
+        return "--"
+    try:
+        f = float(c)
+        sign = "+" if f >= 0 else ""
+        return f"{sign}{f:.1f}%"
+    except (TypeError, ValueError):
+        return str(c)
+
+
+def _base_params(args):
+    p = {"path": args.path}
+    if args.start:
+        p["start_date"] = args.start
+    if args.end:
+        p["end_date"] = args.end
+    return p
+
+
+def cmd_kpi(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages/by-path/kpi",
+                     key, base, params=_base_params(args))
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    kpis = data.get("kpis") or data
+    print(f"Page KPIs — {args.path}")
+    print()
+    print("```")
+    print("┌────────────────────┬──────────────┬──────────────┐")
+    print("│ KPI                │      Current │       Change │")
+    print("├────────────────────┼──────────────┼──────────────┤")
+    for k, label in [
+        ("ai_citation", "AI Citation"),
+        ("ai_index", "AI Index"),
+        ("ai_training", "AI Training"),
+        ("ai_agent", "AI Agent"),
+        ("total_bots", "All bots"),
+    ]:
+        v = kpis.get(k) if isinstance(kpis, dict) else None
+        if isinstance(v, dict):
+            cur, ch = v.get("current"), v.get("change")
+        else:
+            cur, ch = v, None
+        print(f"│ {pad(label, 18)} │ {_fmt_num(cur):>12} │ {_fmt_change(ch):>12} │")
+    print("└────────────────────┴──────────────┴──────────────┘")
+    print("```")
+
+
+def cmd_logs(args, key, base, pid):
+    params = _base_params(args)
+    params["limit"] = args.limit
+    if args.traffic_type:
+        params["traffic_type"] = args.traffic_type
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages/by-path/logs",
+                     key, base, params=params)
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("logs") or (data or {}).get("events", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print(f"No log events for {args.path}.")
+        return
+    print(f"Logs for {args.path} ({len(items)})")
+    print()
+    print("```")
+    print("┌────────────────────┬────────────────────┬────────────┐")
+    print("│ Time               │ Bot / UA           │ Platform   │")
+    print("├────────────────────┼────────────────────┼────────────┤")
+    for e in items:
+        t = truncate((e.get("timestamp") or e.get("created_at") or "")[:19], 18)
+        bot = truncate(e.get("bot_name") or e.get("user_agent") or "(human)", 18)
+        plat = truncate(e.get("platform") or "--", 10)
+        print(f"│ {pad(t, 18)} │ {pad(bot, 18)} │ {pad(plat, 10)} │")
+    print("└────────────────────┴────────────────────┴────────────┘")
+    print("```")
+
+
+def cmd_platforms(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages/by-path/platforms",
+                     key, base, params=_base_params(args))
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("platforms", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print(f"No platform breakdown for {args.path}.")
+        return
+    print(f"Per-platform metrics for {args.path} ({len(items)})")
+    print()
+    print("```")
+    print("┌────────────────────┬──────┬──────┬──────┬──────┬────────┬────────┐")
+    print("│ Platform           │ Cite │ Indx │ Trn  │ Agnt │ Human  │   %    │")
+    print("├────────────────────┼──────┼──────┼──────┼──────┼────────┼────────┤")
+    for p in items:
+        name = truncate(p.get("name") or p.get("platform"), 18)
+        c = _fmt_num(p.get("ai_citation"))
+        i = _fmt_num(p.get("ai_index"))
+        t = _fmt_num(p.get("ai_training"))
+        a = _fmt_num(p.get("ai_agent"))
+        h = _fmt_num(p.get("human_referral") or p.get("human"))
+        pct = p.get("share") or p.get("percentage")
+        pct_s = (f"{float(pct):.1f}%" if pct is not None else "--")
+        print(f"│ {pad(name, 18)} │ {c:>4} │ {i:>4} │ {t:>4} │ {a:>4} │ {h:>6} │ {pct_s:>6} │")
+    print("└────────────────────┴──────┴──────┴──────┴──────┴────────┴────────┘")
+    print("```")
+
+
+def cmd_related(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages/by-path/related",
+                     key, base, params=_base_params(args))
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("pages", [])
+    if args.json:
+        print_json(items)
+        return
+    if not items:
+        print(f"No sibling pages under parent of {args.path}.")
+        return
+    print(f"Sibling pages of {args.path} ({len(items)})")
+    print()
+    print("```")
+    print("┌────────────────────────────────┬──────┬──────┬──────┬──────┬──────┐")
+    print("│ Page                           │ Cite │ Indx │ Trn  │ Agnt │ Cit% │")
+    print("├────────────────────────────────┼──────┼──────┼──────┼──────┼──────┤")
+    for p in items:
+        path = truncate(p.get("path") or p.get("url"), 30)
+        c = _fmt_num(p.get("ai_citation"))
+        i = _fmt_num(p.get("ai_index"))
+        t = _fmt_num(p.get("ai_training"))
+        a = _fmt_num(p.get("ai_agent"))
+        cp = p.get("ai_citation_pct")
+        cp_s = (f"{float(cp):.1f}" if cp is not None else "--")
+        print(f"│ {pad(path, 30)} │ {c:>4} │ {i:>4} │ {t:>4} │ {a:>4} │ {cp_s:>4} │")
+    print("└────────────────────────────────┴──────┴──────┴──────┴──────┴──────┘")
+    print("```")
+
+
+def cmd_health(args, key, base, pid):
+    result = api_get(f"/api/projects/{pid}/ai-agent/pages/by-path/health",
+                     key, base, params={"path": args.path})
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    report = data.get("report") or data
+    if not report or report == {}:
+        print(f"No PageSpeed report cached for {args.path}.")
+        print("Run `python3 scripts/page_detail.py health-refresh --path ...` to generate one.")
+        return
+    print(f"PageSpeed Insights — {args.path}")
+    print()
+    perf = report.get("performance_score") or report.get("performance")
+    print(f"  Performance score: {perf}")
+    cwv = report.get("core_web_vitals") or report.get("cwv") or {}
+    if cwv:
+        print("  Core Web Vitals:")
+        for k, v in cwv.items():
+            print(f"    {k}: {v}")
+    fetched = report.get("fetched_at") or report.get("updated_at")
+    if fetched:
+        print(f"  Fetched at: {fetched}")
+
+
+def cmd_health_refresh(args, key, base, pid):
+    print(f"Refreshing PageSpeed report for {args.path} (15–60s blocking)...")
+    result = api_post(f"/api/projects/{pid}/ai-agent/pages/by-path/health/refresh",
+                      key, base, body={"path": args.path})
+    data = extract_data(result) or {}
+    if args.json:
+        print_json(data)
+        return
+    print("Refresh completed.")
+    perf = data.get("performance_score") or data.get("performance")
+    if perf is not None:
+        print(f"  Performance score: {perf}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Page-level deep-dive AI analytics")
+    parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    for name in ("kpi", "platforms", "related"):
+        p = sub.add_parser(name)
+        p.add_argument("--path", required=True)
+        p.add_argument("--start")
+        p.add_argument("--end")
+
+    p_lg = sub.add_parser("logs")
+    p_lg.add_argument("--path", required=True)
+    p_lg.add_argument("--start")
+    p_lg.add_argument("--end")
+    p_lg.add_argument("--limit", type=int, default=50)
+    p_lg.add_argument("--traffic-type", choices=["bot", "human"])
+
+    p_h = sub.add_parser("health")
+    p_h.add_argument("--path", required=True)
+
+    p_hr = sub.add_parser("health-refresh")
+    p_hr.add_argument("--path", required=True)
+
+    args = parser.parse_args()
+    key, base = get_api_config()
+    pid = get_project_id(args.project_id)
+
+    handlers = {
+        "kpi": cmd_kpi,
+        "logs": cmd_logs,
+        "platforms": cmd_platforms,
+        "related": cmd_related,
+        "health": cmd_health,
+        "health-refresh": cmd_health_refresh,
+    }
+    handlers[args.command](args, key, base, pid)
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-analytics/API.md

@@ -0,0 +1,89 @@
+# GEO Analytics API Reference
+
+## Endpoint
+
+```
+GET /api/public/projects/{project_id}/dashboard/overview
+```
+
+### Query parameters
+
+| Param | Values | Default | Description |
+|---|---|---|---|
+| `period` | `7d` `14d` `30d` `90d` | `30d` | Analysis time window |
+
+### Response envelope
+
+```json
+{
+  "code": 0,
+  "message": "success",
+  "data": {
+    "period": "30d",
+    "date_range":    { "start": "2026-03-19", "end": "2026-04-18" },
+    "compare_range": { "start": "2026-02-17", "end": "2026-03-18" },
+    "integrations":  { "gsc": true, "ga4": true, "cloudflare": false },
+    "search":        { ... },
+    "traffic":       { ... },
+    "ai_impact":     { ... },
+    "infrastructure":{ ... }
+  }
+}
+```
+
+Sections that are `null` → integration not connected.
+
+---
+
+## Section: `search` (Google Search Console)
+
+| Field | Type | Description |
+|---|---|---|
+| `clicks` | int | Total organic clicks |
+| `impressions` | int | Total impressions |
+| `avg_ctr` | float | Average click-through rate |
+| `avg_position` | float | Average ranking position |
+| `clicks_trend` | array | Daily clicks `[{ date, clicks }]` |
+| `top_queries` | array | Top 5 search queries `[{ query, clicks, impressions, ctr, position }]` |
+| `prev_clicks` | int | Previous period clicks (for comparison) |
+| `prev_impressions` | int | Previous period impressions |
+
+---
+
+## Section: `traffic` (Google Analytics 4)
+
+| Field | Type | Description |
+|---|---|---|
+| `sessions` | int | Total sessions |
+| `active_users` | int | Active users |
+| `sessions_trend` | array | Daily sessions |
+| `top_sources` | array | Top traffic sources |
+| `prev_sessions` | int | Previous period sessions |
+| `prev_active_users` | int | Previous period active users |
+
+---
+
+## Section: `ai_impact`
+
+| Field | Type | Description |
+|---|---|---|
+| `ai_referral_sessions` | int | Sessions from AI platforms (ChatGPT, Perplexity, etc.) |
+| `ai_crawler_requests` | int | Requests from AI crawlers via Cloudflare |
+| `ai_referral_trend` | array | Daily AI referral sessions |
+| `ai_crawler_trend` | array | Daily AI crawler requests |
+| `top_ai_sources` | array | Top AI referral sources |
+| `top_ai_bots` | array | Top AI crawlers |
+
+**Tracked AI sources**: chat.openai.com, chatgpt.com, perplexity.ai, claude.ai,
+copilot.microsoft.com, gemini.google.com, you.com, phind.com, poe.com
+
+---
+
+## Section: `infrastructure` (Cloudflare)
+
+| Field | Type | Description |
+|---|---|---|
+| `total_requests` | int | Total HTTP requests |
+| `bandwidth_bytes` | int | Bandwidth consumed |
+| `threats_blocked` | int | Blocked threats |
+| `requests_trend` | array | Daily request counts |