|
| 1 | +"""The release-sweep summary: findings, fixes, people's queue and cost. |
| 2 | +
|
| 3 | +Every settled sweep writes ``<state_dir>/reports/sweep-<repo>-<tag>.md``. |
| 4 | +For a repository in auto_merge with a public upstream, the same summary is |
| 5 | +also published as one issue in the knowledge repository through the outbox |
| 6 | +(``open_issue``); the publisher creates it once, keyed by its title. Shadow |
| 7 | +and private repositories publish nothing. |
| 8 | +""" |
| 9 | + |
| 10 | +from __future__ import annotations |
| 11 | + |
| 12 | +import json |
| 13 | +from collections import Counter |
| 14 | + |
| 15 | +MARKER = "<!-- kb-sweep-report:v1 -->" |
| 16 | +PENDING = "pending_sweep_reports" |
| 17 | + |
| 18 | + |
| 19 | +def queue_report(ledger, repo: str, report: dict) -> None: |
| 20 | + pending = json.loads(ledger.get_cursor(repo, PENDING) or "[]") |
| 21 | + if not any(item.get("run_id") == report.get("run_id") for item in pending): |
| 22 | + pending.append(report) |
| 23 | + ledger.set_cursor(repo, PENDING, json.dumps(pending, sort_keys=True, default=str)) |
| 24 | + |
| 25 | + |
| 26 | +def flush_reports(rt, lifecycle) -> list[str]: |
| 27 | + """Publish every queued report; a failure keeps it (and the rest) queued.""" |
| 28 | + pending = json.loads(rt.ledger.get_cursor(lifecycle.repo, PENDING) or "[]") |
| 29 | + done: list[str] = [] |
| 30 | + while pending: |
| 31 | + publish_summary(rt, lifecycle, pending[0]) |
| 32 | + done.append(str(pending[0].get("run_id"))) |
| 33 | + pending = pending[1:] |
| 34 | + rt.ledger.set_cursor(lifecycle.repo, PENDING, json.dumps(pending, sort_keys=True, default=str)) |
| 35 | + return done |
| 36 | + |
| 37 | + |
| 38 | +def report_id(rt, report: dict) -> str: |
| 39 | + """Stable for one sweep (across its resumed attempts), distinct across |
| 40 | + sweeps: a release sweep is its tag; a periodic fallback sweep re-checks the |
| 41 | + same tag, so it also carries its start date.""" |
| 42 | + import datetime as dt |
| 43 | + |
| 44 | + sweep = report["sweep"] |
| 45 | + tag = sweep.get("tag") or "untagged" |
| 46 | + if sweep.get("reason") == "release": |
| 47 | + return tag |
| 48 | + started = float(report.get("started_at") or rt.clock()) |
| 49 | + return f"{tag}-{sweep.get('reason') or 'sweep'}-" \ |
| 50 | + f"{dt.datetime.fromtimestamp(started, dt.timezone.utc).strftime('%Y%m%d')}" |
| 51 | + |
| 52 | + |
| 53 | +def summary(rt, lifecycle, report: dict) -> tuple[str, str]: |
| 54 | + sweep = report["sweep"] |
| 55 | + tag = report_id(rt, report) |
| 56 | + t1 = report.get("t1") or {} |
| 57 | + statuses: Counter = Counter() |
| 58 | + ops: Counter = Counter() |
| 59 | + for changeset_id in report.get("changesets") or []: |
| 60 | + changeset = rt.ledger.changeset(changeset_id) |
| 61 | + statuses[changeset["status"]] += 1 |
| 62 | + for op in changeset["detail"].get("operations") or []: |
| 63 | + ops[op["kind"]] += 1 |
| 64 | + tokens = {"input": 0, "output": 0} |
| 65 | + seconds = 0.0 |
| 66 | + calls = 0 |
| 67 | + if getattr(rt, "traces", None) is not None and report.get("run_id"): |
| 68 | + run_id = report["run_id"] # this sweep instance only (a fallback reuses the tag) |
| 69 | + for record in rt.traces.query(kind="model_call", run_id=run_id, limit=100000): |
| 70 | + calls += 1 |
| 71 | + tokens["input"] += int((record.get("usage") or {}).get("input_tokens") or 0) |
| 72 | + tokens["output"] += int((record.get("usage") or {}).get("output_tokens") or 0) |
| 73 | + seconds += float(record.get("seconds") or 0) |
| 74 | + title = f"Knowledge sweep report: {lifecycle.repo} {tag}" |
| 75 | + lines = [ |
| 76 | + MARKER, |
| 77 | + f"Release sweep of `{lifecycle.repo}` for **{tag}** " |
| 78 | + f"(`{str(sweep.get('from_sha') or '')[:12]}..{str(sweep.get('to_sha') or '')[:12]}`, " |
| 79 | + f"trigger: {sweep.get('reason', '')}).", |
| 80 | + "", |
| 81 | + "| | |", "|---|---|", |
| 82 | + f"| structural issues (T1) | {len(t1.get('issues') or [])} |", |
| 83 | + f"| duplicate rule IDs | {len(t1.get('duplicates') or {})} |", |
| 84 | + f"| pages over capacity | {len(t1.get('over_capacity') or {})} |", |
| 85 | + f"| pages missing from an index (fixed) | {len(t1.get('unlisted') or [])} |", |
| 86 | + f"| pages kept as they are | {len(report.get('kept_pages', report.get('skipped_pages')) or [])} |", |
| 87 | + f"| pages that failed an evaluation | {len(report.get('failed_attempts') or set(report.get('failed_pages') or []))} " |
| 88 | + f"({sum((report.get('failed_attempts') or {}).values())} failed attempts) |", |
| 89 | + f"| change sets | {sum(statuses.values())} " |
| 90 | + f"({', '.join(f'{k}: {v}' for k, v in sorted(statuses.items())) or 'none'}) |", |
| 91 | + f"| operations | {', '.join(f'{k}: {v}' for k, v in sorted(ops.items())) or 'none'} |", |
| 92 | + f"| waiting for people | {len(rt.ledger.human_queue(lifecycle.repo))} |", |
| 93 | + f"| model calls | {calls} ({tokens['input']} in / {tokens['output']} out tokens, {seconds:.0f}s) |", |
| 94 | + ] |
| 95 | + if report.get("breaker"): |
| 96 | + lines += ["", f"**Circuit breaker:** {report['breaker']}; every change set went to people."] |
| 97 | + lines += ["", "Generated by the Copilot knowledge service."] |
| 98 | + return title, "\n".join(lines) + "\n" |
| 99 | + |
| 100 | + |
| 101 | +def publish_summary(rt, lifecycle, report: dict) -> str: |
| 102 | + """Write the summary locally; open the issue only where publication is allowed.""" |
| 103 | + title, body = summary(rt, lifecycle, report) |
| 104 | + path = rt.state_dir / "reports" / f"sweep-{lifecycle.repo}-{report_id(rt, report)}.md" |
| 105 | + path.parent.mkdir(parents=True, exist_ok=True) |
| 106 | + path.write_text(f"# {title}\n\n{body}", encoding="utf-8") |
| 107 | + if rt.outbox is None or not lifecycle.auto_merge or not lifecycle.publishes: |
| 108 | + return "recorded" |
| 109 | + rt.outbox.issue(lifecycle.repo, "open_issue", {"title": title, "body": body, "labels": ["kb:sweep-report"]}) |
| 110 | + return "issued" |
0 commit comments