@adgine/geo-cli 1.2.8

package/skills/adgine-geo-citation/scripts/_client.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""Shared HTTP client utilities for geo-skills scripts.
+
+Used by all scripts in this skill. Uses Python stdlib only — no external dependencies.
+
+This file is the canonical source. It must be copied verbatim into every
+adgine-geo-* skill folder's scripts/ directory. The sync linter at
+scripts/sync-skills/sync-skills.sh (in the GEOAgent repo) flags any drift.
+"""
+import os
+import sys
+import json
+import time
+import atexit
+import unicodedata
+import urllib.request as _req
+import urllib.error as _uerr
+import urllib.parse as _up
+
+def _load_dot_env():
+    """Load .env from the repo root (adgine-geo-skills/) into os.environ.
+
+    Resolved relative to this file's location, so it works regardless of the
+    agent's working directory (e.g. Hermes, OpenClaw, or any other runtime).
+    Existing environment variables are never overwritten.
+    """
+    if os.environ.get("GEO_API_KEY"):
+        return
+    # _client.py is at <repo_root>/adgine-geo-<skill>/scripts/_client.py
+    repo_root = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    )
+    env_path = os.path.join(repo_root, ".env")
+    if not os.path.isfile(env_path):
+        return
+    with open(env_path) as _f:
+        for _line in _f:
+            _line = _line.strip()
+            if not _line or _line.startswith("#") or "=" not in _line:
+                continue
+            _k, _, _v = _line.partition("=")
+            _k = _k.strip()
+            _v = _v.strip()
+            if _k and _k not in os.environ:
+                os.environ[_k] = _v
+
+
+_load_dot_env()
+
+_VERSION_UNCHECKED = object()
+_version_state = _VERSION_UNCHECKED
+
+
+def _repo_root():
+    return os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    )
+
+
+def _load_check_version_module():
+    import importlib.util
+    path = os.path.join(_repo_root(), "scripts", "check_version.py")
+    if not os.path.isfile(path):
+        return None
+    spec = importlib.util.spec_from_file_location("geo_check_version", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _load_version_state():
+    global _version_state
+    if _version_state is not _VERSION_UNCHECKED:
+        return _version_state
+    _version_state = None
+    try:
+        mod = _load_check_version_module()
+        if mod is not None:
+            _version_state = mod.get_state()
+    except Exception:
+        pass
+    return _version_state
+
+
+def _print_version_notice():
+    """Emit machine + human hints at import if a newer version exists."""
+    state = _load_version_state()
+    if not state or not state.get("update_available"):
+        return
+    cur, lat = state["current"], state["latest"]
+    try:
+        mod = _load_check_version_module()
+        if mod is not None:
+            inline = mod.format_user_inline(state)
+            if inline:
+                sys.stdout.write(inline + "\n\n")
+                sys.stdout.flush()
+    except Exception:
+        pass
+    if state.get("install_type") == "git":
+        msg = (f"adgine-geo-skills {lat} available (current {cur}). "
+               "Tell me: 请帮我更新 adgine-geo-skills 到最新版本")
+    else:
+        msg = (f"adgine-geo-skills {lat} available (current {cur}). "
+               f"Download: {state.get('release_url', '')}")
+    notice = {"update": {"current": cur, "latest": lat, "message": msg}}
+    try:
+        line = f"_notice: {json.dumps(notice, ensure_ascii=False)}\n\n"
+        sys.stdout.write(line)
+        sys.stdout.flush()
+    except Exception:
+        pass
+
+
+def _print_version_footer():
+    """Emit human-readable footer at process exit (WorkBuddy-compatible)."""
+    state = _load_version_state()
+    if not state or not state.get("update_available"):
+        return
+    try:
+        mod = _load_check_version_module()
+        if mod is None:
+            return
+        footer = mod.format_user_footer(state)
+        if footer:
+            sys.stdout.write("\n" + footer + "\n")
+            sys.stdout.flush()
+    except Exception:
+        pass
+
+
+_print_version_notice()
+atexit.register(_print_version_footer)
+
+
+def get_api_config():
+    """Read GEO_API_KEY and GEO_API_BASE_URL from environment.
+
+    Exits with a helpful message if GEO_API_KEY is not set.
+    Returns (key, base_url).
+    """
+    key = os.environ.get("GEO_API_KEY", "")
+    base = os.environ.get("GEO_API_BASE_URL", "https://platform.adgine.ai").rstrip("/")
+    if not key:
+        repo_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        env_path = os.path.join(repo_root, ".env")
+        example_path = os.path.join(repo_root, ".env.example")
+        setup_path = os.path.join(repo_root, "setup.py")
+        print("ERROR: GEO_API_KEY is not set.")
+        print(f"  Expected location: {env_path}")
+        print()
+        print("  One-shot fix (recommended):")
+        print(f"    python3 {setup_path} <YOUR_KEY>")
+        print()
+        print("  Or set it manually:")
+        if not os.path.isfile(env_path):
+            print(f"    cp {example_path} {env_path}")
+        print(f"    edit {env_path} and set GEO_API_KEY=geo_sk_live_xxx")
+        print()
+        print("  Get your key at: https://platform.adgine.ai")
+        print("  The .env file is gitignored — your key stays local and private.")
+        print()
+        print("  NOTE: adgine-geo-site-audit does NOT require an API key.")
+        print("    Run directly: python3 adgine-geo-site-audit/scripts/geo_collect.py <url>")
+        sys.exit(1)
+    return key, base
+
+
+def get_project_id(arg_value=None):
+    """Resolve project ID from argument or GEO_PROJECT_ID env var.
+
+    Exits with instructions if neither is set.
+    """
+    pid = arg_value or os.environ.get("GEO_PROJECT_ID", "")
+    if not pid:
+        print("ERROR: Project ID is required but not set.")
+        print("  Option 1: export GEO_PROJECT_ID=<project-id>")
+        print("  Option 2: pass --project-id <id> to this script")
+        print("  Run list_projects.py from the adgine-geo-projects skill to see your available projects.")
+        sys.exit(1)
+    return pid
+
+
+def _do_request(method, url, key, body=None, timeout=30):
+    """Execute an HTTP request and return parsed JSON.
+
+    Exits with an error message on HTTP errors or network failures.
+    """
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "User-Agent": "geo-skills/1.0",
+    }
+    request = _req.Request(url, data=data, headers=headers, method=method)
+    try:
+        with _req.urlopen(request, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+            return json.loads(raw) if raw else {}
+    except _uerr.HTTPError as e:
+        raw = e.read().decode("utf-8")[:400]
+        try:
+            err_data = json.loads(raw)
+            msg = err_data.get("message") or err_data.get("detail") or raw
+        except Exception:
+            msg = raw
+        if e.code == 401:
+            print("ERROR: Unauthorized — API key is invalid or revoked.")
+            print("  Generate a new key: https://platform.adgine.ai")
+        elif e.code == 403:
+            print("ERROR: Forbidden — insufficient permissions for this operation.")
+        elif e.code == 404:
+            print(f"ERROR: Not found — {msg}")
+        else:
+            print(f"ERROR: HTTP {e.code} — {msg}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"ERROR: Request failed — {e}")
+        sys.exit(1)
+
+
+def api_get(path, key, base, params=None, timeout=30):
+    url = f"{base}{path}"
+    if params:
+        clean = {k: str(v) for k, v in params.items() if v is not None}
+        if clean:
+            url += "?" + _up.urlencode(clean)
+    return _do_request("GET", url, key, timeout=timeout)
+
+
+def api_post(path, key, base, body=None, timeout=30):
+    return _do_request("POST", f"{base}{path}", key, body, timeout=timeout)
+
+
+def api_patch(path, key, base, body=None, timeout=30):
+    return _do_request("PATCH", f"{base}{path}", key, body, timeout=timeout)
+
+
+def api_put(path, key, base, body=None, timeout=30):
+    return _do_request("PUT", f"{base}{path}", key, body, timeout=timeout)
+
+
+def api_delete(path, key, base, timeout=30):
+    return _do_request("DELETE", f"{base}{path}", key, timeout=timeout)
+
+
+def extract_data(result):
+    """Extract the .data field from a standard geo-api envelope response.
+
+    On success the API returns {"code": 0, "data": <payload>, "message": "ok"}.
+    On non-zero code, this prints the message and exits(1).
+    """
+    if not isinstance(result, dict):
+        return result
+    if "code" in result and result.get("code") not in (0, None):
+        msg = result.get("message") or result.get("detail") or "request failed"
+        print(f"ERROR: API returned code={result.get('code')} — {msg}")
+        sys.exit(1)
+    return result.get("data", result)
+
+
+def poll_job(status_path, key, base, interval=3, max_wait=300,
+             terminal=("completed", "failed", "done", "success", "error")):
+    """Poll a job/task endpoint until it reaches a terminal state.
+
+    Prints an inline spinner with the current phase. Returns the final job dict.
+    """
+    elapsed = 0
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    idx = 0
+    last_job = {}
+    while elapsed < max_wait:
+        result = api_get(status_path, key, base)
+        last_job = extract_data(result) or {}
+        status = (last_job.get("status") or "").lower()
+        phase = last_job.get("current_phase") or last_job.get("phase") or status or "pending"
+        print(f"\r  {frames[idx % len(frames)]} {phase}... ({elapsed}s)", end="", flush=True)
+        idx += 1
+        if status in terminal:
+            print()  # newline after spinner
+            return last_job
+        time.sleep(interval)
+        elapsed += interval
+    print()
+    print(f"WARNING: Job is still running after {max_wait}s. Check status manually.")
+    return last_job
+
+
+def print_json(data):
+    """Print data as formatted JSON (UTF-8 safe)."""
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def fmt_change(value):
+    """Format a numeric change indicator per CONVENTIONS.md §4.
+
+    Returns: '+N' / '-N' / '0' / '--' (None becomes '--').
+    """
+    if value is None:
+        return "--"
+    try:
+        n = float(value)
+    except (TypeError, ValueError):
+        return "--"
+    if n == 0:
+        return "0"
+    sign = "+" if n > 0 else ""
+    if n == int(n):
+        return f"{sign}{int(n):,}"
+    return f"{sign}{n:,.1f}"
+
+
+def truncate(text, n=60, ellipsis="…"):
+    """Truncate text to n characters, adding ellipsis if cut. ASCII-safe for tables."""
+    if text is None:
+        return "--"
+    s = str(text)
+    if len(s) <= n:
+        return s
+    return s[: max(0, n - len(ellipsis))] + ellipsis
+
+def display_width(s):
+    """Return the display width of a string (CJK chars count as 2 columns)."""
+    w = 0
+    for c in str(s):
+        eaw = unicodedata.east_asian_width(c)
+        w += 2 if eaw in ('W', 'F') else 1
+    return w
+
+
+def pad(s, width, align='left'):
+    """Pad string to display width for CJK-aware table alignment.
+    Replaces f'{s:<N}' (align='left') and f'{s:>N}' (align='right').
+    """
+    s = str(s)
+    dw = display_width(s)
+    spaces = max(0, width - dw) * ' '
+    return spaces + s if align == 'right' else s + spaces

package/skills/adgine-geo-citation/scripts/create_tests.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Submit citation tests for one or more GEO prompts.
+
+Sends each prompt to multiple AI platforms (ChatGPT, Perplexity, Google AI
+Overviews, etc.) to check whether your brand is cited in the responses.
+Results are processed asynchronously — check with get_results.py.
+
+Usage:
+  python3 scripts/create_tests.py --prompt-ids <id1,id2,...> [--project-id <id>]
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import get_api_config, get_project_id, api_post, extract_data, print_json
+
+parser = argparse.ArgumentParser(description="Submit GEO citation tests")
+parser.add_argument("--prompt-ids", required=True,
+                    help="Comma-separated prompt IDs to test")
+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 response")
+args = parser.parse_args()
+
+key, base = get_api_config()
+pid = get_project_id(args.project_id)
+
+prompt_ids = [p.strip() for p in args.prompt_ids.split(",") if p.strip()]
+if not prompt_ids:
+    print("ERROR: --prompt-ids must contain at least one ID")
+    sys.exit(1)
+
+print(f"Submitting citation tests for {len(prompt_ids)} prompt(s)...")
+
+body = {"prompt_ids": prompt_ids}
+result = api_post(f"/api/projects/{pid}/citation-tests", key, base, body)
+data = extract_data(result)
+
+if args.json:
+    print_json(data)
+    sys.exit(0)
+
+tests = data if isinstance(data, list) else data.get("tests") or data.get("items") or []
+print(f"\nCreated {len(tests)} citation test(s)")
+print()
+
+# Group by prompt
+by_prompt = {}
+for t in tests:
+    prompt_id = t.get("prompt_id", "unknown")
+    by_prompt.setdefault(prompt_id, []).append(t)
+
+for prompt_id, prompt_tests in by_prompt.items():
+    platforms = [t.get("platform", "?") for t in prompt_tests]
+    print(f"  Prompt [{prompt_id[:36]}]")
+    print(f"    Platforms : {', '.join(platforms)}")
+    print()
+
+print("Results are processed asynchronously (5–15 minutes per platform).")
+print("Check results with:")
+for pid_str in prompt_ids:
+    print(f"  python3 scripts/get_results.py --prompt-id {pid_str}")

package/skills/adgine-geo-citation/scripts/get_aggregate.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Retrieve project-level citation aggregate metrics.
+
+Returns citation count, citation share, and global citation ranking
+for a given time window, with automatic previous-period comparison.
+
+Usage:
+  python3 scripts/get_aggregate.py [--start-date 2025-02-22] [--end-date 2025-03-14]
+  python3 scripts/get_aggregate.py --platform chatgpt,perplexity
+  python3 scripts/get_aggregate.py --json
+"""
+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
+
+parser = argparse.ArgumentParser(description="View project-level citation aggregate metrics")
+parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+parser.add_argument("--start-date", help="Start date (YYYY-MM-DD), default: 7 days ago")
+parser.add_argument("--end-date",   help="End date (YYYY-MM-DD), default: today")
+parser.add_argument("--platform",   help="Comma-separated platform filter (e.g. chatgpt,perplexity)")
+parser.add_argument("--json", action="store_true", help="Output raw JSON")
+args = parser.parse_args()
+
+key, base = get_api_config()
+pid = get_project_id(args.project_id)
+
+# Build query params
+params = {}
+if args.start_date:
+    params["date_from"] = args.start_date
+if args.end_date:
+    params["date_to"] = args.end_date
+if args.platform:
+    params["platform"] = args.platform
+
+result = api_get(
+    f"/api/projects/{pid}/analytics/citation/aggregate",
+    key, base, params=params,
+)
+data = extract_data(result)
+
+if args.json:
+    print_json(data)
+    sys.exit(0)
+
+# Formatted output
+date_range = data.get("date_range") or {}
+print(f"Citation Aggregate Metrics")
+print(f"  Period: {date_range.get('from', '?')} → {date_range.get('to', '?')}")
+if date_range.get("platform"):
+    print(f"  Platforms: {', '.join(date_range['platform'])}")
+print()
+
+# Main metrics
+citation_count = data.get("citation_count") or {}
+citation_share = data.get("citation_share") or {}
+citation_rank  = data.get("citation_rank") or {}
+total_citations = data.get("total_citations") or {}
+
+
+def fmt_change(val):
+    if val is None:
+        return ""
+    if isinstance(val, float):
+        sign = "+" if val > 0 else ""
+        return f" ({sign}{val:.1f})"
+    sign = "+" if val > 0 else ""
+    return f" ({sign}{val})"
+
+
+def fmt_pct(val):
+    if val is None:
+        return "--"
+    return f"{val:.2f}%"
+
+
+print(f"  Citation Count : {citation_count.get('current', 0)}{fmt_change(citation_count.get('change'))}")
+print(f"  Citation Share : {fmt_pct(citation_share.get('current'))}{fmt_change(citation_share.get('change'))}")
+print(f"  Citation Rank  : #{citation_rank.get('current', '--')}{fmt_change(citation_rank.get('change'))}")
+print(f"  Total (all brands): {total_citations.get('current', 0)}{fmt_change(total_citations.get('change'))}")
+print()
+
+# Platform breakdown
+by_platform = data.get("by_platform") or []
+if by_platform:
+    print("  By Platform:")
+    for p in by_platform:
+        plat = p.get("platform", "?")
+        count = p.get("citation_count", 0)
+        share = p.get("citation_share")
+        share_str = f"{share:.1f}%" if share is not None else "--"
+        print(f"    {plat:<16} {count:>5} citations  ({share_str} share)")
+    print()
+
+# Competitor ranking
+competitors = data.get("competitors") or []
+if competitors:
+    print("  Brand Citation Ranking:")
+    for i, c in enumerate(competitors[:10], 1):
+        name = c.get("name", "?")
+        count = c.get("citation_count", 0)
+        share = c.get("citation_share")
+        share_str = f"{share:.1f}%" if share is not None else "--"
+        marker = " ← you" if c.get("is_our_brand") else ""
+        print(f"    #{i:<2} {name:<20} {count:>5} ({share_str}){marker}")

package/skills/adgine-geo-citation/scripts/get_results.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Retrieve citation test results for a GEO prompt.
+
+Usage:
+  # Results for a single prompt (all platforms):
+  python3 scripts/get_results.py --prompt-id <id> [--project-id <id>] [--json]
+
+  # Aggregated cited URLs across multiple prompts:
+  python3 scripts/get_results.py --aggregate --prompt-ids <id1,id2,...> [--project-id <id>]
+"""
+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
+
+parser = argparse.ArgumentParser(description="View GEO citation test results")
+parser.add_argument("--project-id", help="Project ID (or set GEO_PROJECT_ID env var)")
+parser.add_argument("--prompt-id",  help="Prompt ID to retrieve results for")
+parser.add_argument("--prompt-ids", help="Comma-separated prompt IDs (used with --aggregate)")
+parser.add_argument("--test-id",    help="Citation test ID for a single-test detail lookup")
+parser.add_argument("--aggregate",  action="store_true",
+                    help="Aggregate cited URLs across multiple prompts")
+parser.add_argument("--start-date", help="Filter by start date (YYYY-MM-DD), uses analytics endpoint")
+parser.add_argument("--end-date",   help="Filter by end date (YYYY-MM-DD), uses analytics endpoint")
+parser.add_argument("--show-response", action="store_true",
+                    help="Print the full AI response text for each test")
+parser.add_argument("--json", action="store_true", help="Output raw JSON")
+args = parser.parse_args()
+
+key, base = get_api_config()
+pid = get_project_id(args.project_id)
+
+STATUS_ICONS = {
+    "completed": "✓",
+    "running":   "⏳",
+    "pending":   "◌",
+    "failed":    "✗",
+}
+
+# ── AGGREGATE MODE ────────────────────────────────────────────────────────────
+if args.aggregate:
+    if not args.prompt_ids:
+        print("ERROR: --prompt-ids is required with --aggregate")
+        sys.exit(1)
+    prompt_ids = [p.strip() for p in args.prompt_ids.split(",") if p.strip()]
+    body = {"prompt_ids": prompt_ids}
+    result = api_post(f"/api/projects/{pid}/citation-tests/urls", key, base, body)
+    data = extract_data(result)
+
+    if args.json:
+        print_json(data)
+        sys.exit(0)
+
+    urls   = data.get("urls") or []
+    total  = data.get("total", len(urls))
+    print(f"Cited URLs ({total} found across {len(prompt_ids)} prompts):")
+    print()
+    for url in urls:
+        print(f"  {url}")
+    sys.exit(0)
+
+# ── SINGLE TEST DETAIL MODE ──────────────────────────────────────────────────
+if args.test_id:
+    result = api_get(
+        f"/api/projects/{pid}/citation-tests/{args.test_id}",
+        key, base,
+    )
+    test = extract_data(result) or {}
+    if args.json:
+        print_json(test)
+        sys.exit(0)
+    platform = test.get("platform", "Unknown")
+    status   = test.get("status", "pending")
+    cited    = test.get("is_cited") or test.get("cited", False)
+    print(f"Citation test {args.test_id}")
+    print(f"  Platform    : {platform}")
+    print(f"  Status      : {STATUS_ICONS.get(status, '?')} {status}")
+    print(f"  Brand cited : {'Yes' if cited else 'No'}")
+    citations = test.get("citations") or []
+    if citations:
+        print(f"  Cited URLs  : {len(citations)}")
+        for url in citations[:10]:
+            print(f"    - {url}")
+    sys.exit(0)
+
+# ── SINGLE PROMPT MODE ────────────────────────────────────────────────────────
+if not args.prompt_id:
+    print("ERROR: One of --prompt-id, --test-id or (--aggregate + --prompt-ids) is required")
+    sys.exit(1)
+
+# If date filters provided, use the analytics execution endpoint (supports date range)
+if args.start_date or args.end_date:
+    params = {}
+    if args.start_date:
+        params["date_from"] = args.start_date
+    if args.end_date:
+        params["date_to"] = args.end_date
+    result = api_get(
+        f"/api/projects/{pid}/analytics/prompts/{args.prompt_id}/executions",
+        key, base, params=params,
+    )
+    data = extract_data(result)
+
+    if args.json:
+        print_json(data)
+        sys.exit(0)
+
+    items = data if isinstance(data, list) else (data or {}).get("items", [])
+    print(f"Citation executions for prompt {args.prompt_id}")
+    if args.start_date or args.end_date:
+        print(f"  Date range: {args.start_date or '...'} → {args.end_date or '...'}")
+    print(f"  Found: {len(items)} execution(s)")
+    print()
+    for e in items:
+        plat = e.get("platform", "?")
+        dt = (e.get("analyzed_at") or e.get("date") or "--")[:10]
+        mentioned = e.get("our_brand_mentioned", False)
+        rank = e.get("our_brand_rank")
+        print(f"  [{plat}] {dt}  Brand: {'Yes' if mentioned else 'No'}"
+              f"{f'  Rank: #{rank}' if rank else ''}")
+    sys.exit(0)
+
+result = api_get(
+    f"/api/projects/{pid}/citation-tests/prompts/{args.prompt_id}",
+    key, base,
+)
+data = extract_data(result)
+
+if args.json:
+    print_json(data)
+    sys.exit(0)
+
+tests = data if isinstance(data, list) else data.get("tests") or data.get("items") or [data]
+
+# Handle case where a single test object is returned
+if isinstance(data, dict) and "platform" in data:
+    tests = [data]
+
+print(f"Citation results for prompt: {args.prompt_id}")
+print()
+
+for test in tests:
+    platform    = test.get("platform", "Unknown")
+    status      = test.get("status", "pending")
+    icon        = STATUS_ICONS.get(status, "?")
+    cited       = test.get("is_cited") or test.get("cited", False)
+    response    = test.get("response_text") or ""
+    citations   = test.get("citations") or []
+
+    print(f"  [{platform}]  {icon} {status}")
+    print(f"    Brand cited : {'Yes ✓' if cited else 'No'}")
+
+    if citations:
+        print(f"    Cited URLs  : {len(citations)}")
+        for url in citations[:5]:
+            print(f"      - {url}")
+        if len(citations) > 5:
+            print(f"      ... and {len(citations) - 5} more")
+
+    if args.show_response and response:
+        print(f"    AI Response :")
+        # Indent response for readability
+        for line in response[:800].splitlines():
+            print(f"      {line}")
+        if len(response) > 800:
+            print(f"      [... truncated, {len(response)} chars total ...]")
+
+    print()
+
+# Summary
+completed = [t for t in tests if t.get("status") == "completed"]
+cited_tests = [t for t in completed if t.get("is_cited") or t.get("cited")]
+print(f"Summary: {len(cited_tests)}/{len(completed)} completed tests cited your brand", end="")
+pending_count = len([t for t in tests if t.get("status") in ("pending", "running")])
+if pending_count:
+    print(f"  ({pending_count} still running)", end="")
+print()