# -*- coding: utf-8 -*- """Score AI Visibility Index runs with the current matcher and roll them up. Monthly runs are collected by ai_visibility_index.py (cron, 1st of the month). Editions are published quarterly from the pooled monthly runs; this script is the one place the published numbers come from. Usage: avi_score.py RUN [RUN ...] score each run, print a summary avi_score.py --pool RUN [RUN ...] also pool the runs into one edition --json OUT write the full result (per-run + pooled) as JSON --csv OUT write one row per (run, market, business, engine) for publication RUN is a month label (2026-09) or a path to an index_*.json file. Engines with no answer for a market are excluded from that market, never counted as a miss. Rates carry 95% Wilson intervals. """ import csv, json, math, os, sys HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) from avi_matcher import mentioned, MATCHER_VERSION INDEX_DIR = os.path.join(HERE, "ai_index") ENGINES = ("chatgpt", "chatgpt_web", "google_ai", "claude") # Stored answer text shorter than the real answer can hide a mention. August 2026 # kept only the first 1,500 characters; every AI Mode answer hit that cap. TRUNC_AT = 1500 def wilson(k, n, z=1.96): if not n: return None p = k / n d = 1 + z * z / n c = (p + z * z / (2 * n)) / d h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / d return [round(100 * (c - h), 1), round(100 * (c + h), 1)] def load(run): path = run if os.path.exists(run) else os.path.join(INDEX_DIR, f"index_{run}_full.json") d = json.load(open(path)) d["_path"] = path return d def records(d): """One record per (market, business, engine) with the v2 verdict.""" out = [] for r in d["rows"]: for eng, a in r["answers"].items(): text = a.get("text") or "" if not text: continue truncated = len(text) >= TRUNC_AT and d.get("methodology", {}).get("answer_text") != "stored in full" for pos, b in enumerate(r["top3"], 1): out.append({ "run": d["run"], "category": r["category"], "city": r["city"], "engine": eng, "maps_position": pos, "business": b["name"], "domain": b.get("domain") or "", "rating": b.get("rating"), "reviews": b.get("reviews"), "mentioned": bool(mentioned(b["name"], text, b.get("domain"))), "answer_truncated": truncated, }) return out def rate(recs): n = len(recs) k = sum(1 for x in recs if x["mentioned"]) if not n: return {"mentioned": 0, "of": 0, "mention_pct": None, "invisible_pct": None, "invisible_ci95": None} lo, hi = wilson(k, n) return {"mentioned": k, "of": n, "mention_pct": round(100 * k / n, 1), "invisible_pct": round(100 - 100 * k / n, 1), "invisible_ci95": [round(100 - hi, 1), round(100 - lo, 1)]} def summarise(recs): s = {} for eng in ENGINES: er = [x for x in recs if x["engine"] == eng] if not er: continue markets = {(x["run"], x["category"], x["city"]) for x in er} trunc_markets = {(x["run"], x["category"], x["city"]) for x in er if x["answer_truncated"]} # A truncated answer can only UNDERCOUNT mentions, so a rate computed # over one is an upper bound on invisibility, not a measurement. Where # every stored answer for an engine-run was truncated there is nothing # defensible to publish, so the block reports the exclusion instead of # a number. This is what the package README has always said; before # 2026-09-20 the summary contradicted it by scoring August AI Mode. usable = [x for x in er if not x["answer_truncated"]] if not usable: s[eng] = { "markets_answered": len(markets), "excluded_from_published_rates": True, "exclusion_reason": ("every stored answer was truncated; a truncated answer can only " "undercount mentions, so no rate is defensible"), "answers_truncated": len(trunc_markets), } continue no1 = [x for x in usable if x["maps_position"] == 1] s[eng] = { "markets_answered": len({(x["run"], x["category"], x["city"]) for x in usable}), "top3": rate(usable), "no1_named": rate(no1), "markets_with_none_of_top3": sum( 1 for m in {(x["run"], x["category"], x["city"]) for x in usable} if not any(x["mentioned"] for x in usable if (x["run"], x["category"], x["city"]) == m)), "answers_truncated": len(trunc_markets), "by_category": {c: rate([x for x in usable if x["category"] == c]) for c in dict.fromkeys(x["category"] for x in usable)}, } return s def main(argv): pool = "--pool" in argv out_json = argv[argv.index("--json") + 1] if "--json" in argv else None out_csv = argv[argv.index("--csv") + 1] if "--csv" in argv else None skip = {out_json, out_csv} runs = [a for a in argv if not a.startswith("--") and a not in skip] result = {"matcher": MATCHER_VERSION, "runs": {}} allrecs = [] for run in runs: d = load(run) recs = records(d) allrecs += recs result["runs"][d["run"]] = {"file": os.path.basename(d["_path"]), "collected": d.get("generated_utc") or d["run"], "summary": summarise(recs)} if pool and len(runs) > 1: result["pooled"] = {"runs": list(result["runs"]), "summary": summarise(allrecs)} for label, block in list(result["runs"].items()) + ([("POOLED", result["pooled"])] if "pooled" in result else []): print(f"\n=== {label} ({MATCHER_VERSION}) ===") for eng, s in block["summary"].items(): if s.get("excluded_from_published_rates"): print(f" {eng:10} markets={s['markets_answered']:3} EXCLUDED: {s['exclusion_reason']} " f"(truncated={s['answers_truncated']})") continue t, n1 = s["top3"], s["no1_named"] print(f" {eng:10} markets={s['markets_answered']:3} top-3 invisible {t['invisible_pct']}% " f"{t['invisible_ci95']} ({t['of'] - t['mentioned']}/{t['of']}) #1 named {n1['mention_pct']}% " f"none-of-top3 markets={s['markets_with_none_of_top3']} truncated={s['answers_truncated']}") for c, r in s["by_category"].items(): print(f" {c:24} visible {r['mention_pct']}% ({r['mentioned']}/{r['of']})") if out_json: json.dump(result, open(out_json, "w"), indent=1) print("\nwrote", out_json) if out_csv: with open(out_csv, "w", newline="") as f: w = csv.DictWriter(f, fieldnames=list(allrecs[0])) w.writeheader() w.writerows(allrecs) print("wrote", out_csv) if __name__ == "__main__": main(sys.argv[1:])