| """Cross-task sameness lint (R2, SPEC 7.6 item 3), run over a build after its tasks are built. |
| |
| Every piece of prose a task carries is filed under the text it came from: a card's ticket, thread, postmortem or |
| runbook under the card (`H04`, `R06`, `survey:H08`, ...), README, ADRs, service runbooks and the handover under |
| `house`, the split paragraph under `split`. Names, alerts, keys, numbers and times are masked (the way |
| `review-v02/scratch-realism/rep.py` does it). Two checks: |
| |
| - no masked sentence appears in more than a third (rounded up) of the tasks that carry its text; |
| - word 6-grams of instruction plus incident prose: the largest pairwise Jaccard over the tasks (SPEC: <= 0.10 over |
| the public 12; reported here for the whole build). |
| |
| `render(family, seed)` builds a task's text without promtool, so tests and the CLI can lint a block quickly. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import itertools |
| import math |
| import random |
| import re |
| from collections import defaultdict |
|
|
| STRUCT = re.compile(r"^\s*(#|\|[-: |]+\|\s*$|---\s*$|```|alerts: \[|<!--)") |
| HANDLE_LINE = re.compile(r"^\S*\d\d:\d\d\s+[\w.@-]+:\s*") |
|
|
|
|
| def render(family: str, seed: int, master: int = 20260930) -> dict: |
| """The workspace text, instruction and tickets of a task, without calibration or promtool.""" |
| from . import families |
| from .build import materialize, static_files |
| from .items_triage import Kept |
| w, items = families.build(family, seed, master, f"afx-{family.lower()}-s{seed:02d}") |
| trng = random.Random(w.tseed ^ 0x7E47) |
| kept = [] |
| if family == "E5" and trng.random() < 0.7: |
| k = Kept(w, trng) |
| if k.ok: |
| kept.append(k) |
| w.notes["then"] = materialize(w, items, set()) |
| tickets = {} |
| for it in items: |
| t = it.ticket(w, trng) |
| t.kind, t.symptom, t.code = it.kind, it.ticket_like, it.code |
| tickets[it.rid] = t |
| for it in items: |
| if it.code == "R01" and getattr(it, "tier", "") == "slow": |
| fast = next((o for o in items if o.code == "R01" and getattr(o, "tier", "") == "fast" |
| and o.p.get("svc") == it.p.get("svc")), None) |
| tickets[it.rid].pair_of = tickets[fast.rid] if fast is not None else None |
| st = static_files(w, items, tickets, kept, trng, "00000000-0000-0000-0000-000000000000") |
| return {"task_id": w.task_id, "world": w, "items": items, "tickets": tickets, "static": st["workspace"], |
| "instruction": st["instruction"], "kept": kept} |
|
|
|
|
| def _names(w) -> list[str]: |
| out = {w.company.name, w.domain, w.namespace, w.company.key} |
| out |= {s.name for s in w.services} | set(w.teams) | set(w.shared_teams) |
| for p in w.people: |
| out |= {p.first, p.last, p.full, p.handle} |
| for f in w.files.values(): |
| out.add(f.stem) |
| return sorted((x for x in out if x and len(x) > 1), key=len, reverse=True) |
|
|
|
|
| def normalise(text: str, names: list[str]) -> str: |
| for n in names: |
| text = text.replace(n, "<X>") |
| text = re.sub(r"[A-Z][a-z]+[A-Z][A-Za-z]+", "<Alert>", text) |
| text = re.sub(r"\b[A-Z]+-\d+\b", "<KEY>", text) |
| text = re.sub(r"\d+(\.\d+)?", "<N>", text) |
| text = re.sub(r"\b(Mon|Tues|Wednes|Thurs|Fri|Satur|Sun)day\b|\b(Mon|Tue|Wed|Thu|Fri|Sat|Sun)\b", "<DAY>", text) |
| text = re.sub(r"\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\b", "<MON>", text) |
| return " ".join(text.split()) |
|
|
|
|
| def sentences(text: str, names: list[str]) -> set[str]: |
| out, in_code = set(), False |
| for line in text.splitlines(): |
| if line.strip().startswith("```"): |
| in_code = not in_code |
| continue |
| if in_code or STRUCT.match(line): |
| continue |
| line = HANDLE_LINE.sub("", line) |
| for part in re.split(r"(?<=[.!?])\s+", line): |
| n = normalise(part, names) |
| if len(n) >= 25 and len(n.split()) >= 5: |
| out.add(n) |
| return out |
|
|
|
|
| def units(m: dict) -> list[tuple[str, str]]: |
| """(text key, text) for every piece of prose in a built (or rendered) task.""" |
| from .variety import item_keys |
| w, ws = m["world"], m["static"] |
| instr = m.get("instruction") or "" |
| out: list[tuple[str, str]] = [] |
| by_packet, by_ticket = {}, {} |
| for it in m["items"]: |
| t = m["tickets"][it.rid] |
| key = sorted(item_keys(w, it), key=lambda k: (not k.startswith("survey:"), k))[0] |
| by_ticket[t.key] = key |
| for path in t.files: |
| by_packet[path.split("/")[1]] = it.code |
| |
| parts = re.split(r"(?m)^### ", instr) |
| out.append(("house", parts[0])) |
| for p in parts[1:]: |
| key = p.split(":", 1)[0] |
| body, _, tail = p.partition("\n\n") |
| lines = p.split("\n") |
| main = "\n".join(x for x in lines if not x.startswith(("_Reported", "Reporter:", "`", ">"))) |
| out.append((by_ticket.get(key, "house"), main)) |
| out.append(("house", "\n".join(x for x in lines if x.startswith(("_Reported", "Reporter:", "`", ">"))))) |
| if w.trigger and w.trigger.get("moved"): |
| tt = next((x for x in instr.split("\n\n") if w.trigger["date"] in x and w.trigger["new"] in x), "") |
| out.append(("split", tt)) |
| rb_card = {f"runbooks/{rb['file']}": f"{rb['card']}:runbook" for rb in w.runbooks.values() if rb.get("card")} |
| answers = {} |
| for it in m["items"]: |
| keys = item_keys(w, it) |
| survey = next((k for k in keys if k.startswith("survey:")), None) |
| if survey: |
| answers[m["tickets"][it.rid].body.strip()] = survey |
| for k in m.get("kept", []): |
| answers.update({t.body.strip(): "kept" for t in m.get("kept_tickets", [])}) |
| for path, text in ws.items(): |
| if not path.endswith(".md"): |
| continue |
| if path.startswith("incidents/"): |
| out.append((by_packet.get(path.split("/")[1], "house"), text)) |
| elif path.startswith("runbooks/"): |
| out.append((rb_card.get(path, "house"), text)) |
| elif path.startswith("docs/slo/"): |
| out.append(("H11", text)) |
| elif path.startswith("docs/oncall-survey"): |
| head, _, rest = text.partition("**1.**") |
| out.append(("survey", head)) |
| for ans in re.split(r"(?m)^\*\*\d+\.\*\*", "**1.**" + rest)[1:]: |
| body = re.sub(r"^ \([\w-]+\)", "", ans).strip() |
| key = answers.get(body) |
| if key is None: |
| key = "kept" if "woke" in body or "Woken" in body or "laptop" in body else "survey-aside" |
| out.append((key, body)) |
| else: |
| out.append(("house", text)) |
| return out |
|
|
|
|
| def check(tasks: list[dict], frac: float = 1 / 3) -> tuple[list[str], dict]: |
| """Violations of the per-key sentence rule, and stats (max pairwise 6-gram Jaccard).""" |
| seen: dict[str, dict[str, set[str]]] = defaultdict(lambda: defaultdict(set)) |
| carriers: dict[str, set[str]] = defaultdict(set) |
| grams = {} |
| for m in tasks: |
| names = _names(m["world"]) |
| tid = m["task_id"] |
| g = set() |
| for key, text in units(m): |
| carriers[key].add(tid) |
| for snt in sentences(text, names): |
| seen[key][snt].add(tid) |
| prose = (m.get("instruction") or "") + "\n".join(v for k, v in m["static"].items() if k.endswith(".md") and ( |
| k.startswith("incidents/") or k.startswith("docs/oncall-survey"))) |
| words = normalise(prose, names).split() |
| g = {tuple(words[i:i + 6]) for i in range(len(words) - 5)} |
| grams[tid] = g |
| bad = [] |
| for key, sents in seen.items(): |
| n = len(carriers[key]) |
| cap = max(1, math.ceil(n * frac - 1e-9)) |
| for snt, who in sents.items(): |
| if len(who) > cap: |
| bad.append(f"[{key}] {len(who)}/{n} tasks (cap {cap}): {snt[:140]}") |
| worst = (0.0, None) |
| for a, b in itertools.combinations(sorted(grams), 2): |
| u = len(grams[a] | grams[b]) |
| j = len(grams[a] & grams[b]) / u if u else 0.0 |
| if j > worst[0]: |
| worst = (round(j, 3), (a, b)) |
| return sorted(bad), {"max_jaccard_6gram": worst[0], "pair": worst[1], "keys": {k: len(v) for k, v in carriers.items()}} |
|
|
|
|
| def main(argv=None) -> int: |
| import argparse |
| import json |
| ap = argparse.ArgumentParser(description="cross-task sameness lint over a block of rendered tasks") |
| ap.add_argument("--master", type=int, default=20260930) |
| ap.add_argument("--seeds", default="1-9") |
| ap.add_argument("--families", default="E1,E2,E3,E4,E5") |
| a = ap.parse_args(argv) |
| lo, hi = (int(x) for x in a.seeds.split("-")) |
| tasks = [render(f, s, a.master) for f in a.families.split(",") for s in range(lo, hi + 1)] |
| bad, stats = check(tasks) |
| print(json.dumps(stats, default=str)) |
| for b in bad: |
| print(b) |
| print(f"{len(bad)} sentences over the cap") |
| return 1 if bad else 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
