Files
solidcraft/scripts/ci/main_merge.py
T
jyvikoandClaude Opus 5.5 6b4026fd19 CI: carry through consecutive merges of main
A change that merged main twice in a row ran the full set on every other push: the change before
the second merge was itself a carried run, its shards skipped, so it had no passing shards to
carry. The script now walks down the first parents through consecutive merges of main that kept
the change's patch (each equal to the next), at most 10, to the run where the shards ran.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT
2026-10-19 16:42:11 -04:00

110 lines
4.5 KiB
Python

#!/usr/bin/env python3
"""Is this pull request push only a merge of main into a change that already passed CI?
python3 -I scripts/ci/main_merge.py --base BASE_SHA --head HEAD_SHA --repo OWNER/NAME
Prints `carried=<url of the passing run>` when all of these hold, else `carried=`:
- HEAD is a merge commit whose second parent is on main (an ancestor of BASE): "Merge branch
'main'", or GitHub's Update branch button;
- the pull request's own change is the same before and after the merge (equal `git patch-id`),
so the merge resolved no conflict and brought nothing into the change itself;
- a ci.yml run of the change before the merge passed with the test shards. When that change was
itself only a merge of main (a run that carried, its shards skipped), the walk goes on down
the first parents, through at most MAX_CHAIN merges, to the run where the shards ran.
Then the run needs only the repository checks: the change was tested, and main tests the merged
result after it lands. Any doubt (an error, an API failure, an unexpected shape) prints
`carried=` and the full checks run. Reads GH_TOKEN from the environment for the API.
"""
import argparse
import json
import os
import subprocess
import sys
import urllib.request
API = "https://api.github.com"
SHARD_PREFIX = "Native Linux tests"
# Consecutive merges of main followed back to a run whose shards ran.
MAX_CHAIN = 10
def git(*args):
return subprocess.run(["git", *args], capture_output=True, text=True, check=True).stdout
def patch_id(a, b):
"""The stable patch id of `git diff a b` ("" for an empty diff)."""
diff = subprocess.run(["git", "diff", "--no-renames", a, b], capture_output=True, check=True).stdout
if not diff.strip():
return ""
out = subprocess.run(["git", "patch-id", "--stable"], input=diff, capture_output=True, check=True).stdout
return out.split()[0].decode() if out.split() else ""
def merge_of_main(base, head):
"""The first parent of HEAD when HEAD only merges main into an unchanged change, else None."""
parents = git("rev-list", "--parents", "-n", "1", head).split()[1:]
if len(parents) != 2:
return None
change, merged = parents
if subprocess.run(["git", "merge-base", "--is-ancestor", merged, base]).returncode != 0:
return None
fork_point = git("merge-base", change, merged).strip()
before, after = patch_id(fork_point, change), patch_id(merged, head)
return change if before and before == after else None
def merge_chain(base, head):
"""The changes HEAD carries from, nearest first: the first parent of each consecutive merge of
main that left the change's own patch as it was (each one equals the next, so all equal HEAD's)."""
chain, cur = [], head
for _ in range(MAX_CHAIN):
change = merge_of_main(base, cur)
if change is None:
break
chain.append(change)
cur = change
return chain
def get(url, token):
req = urllib.request.Request(url, headers={"Accept": "application/vnd.github+json", "Authorization": f"Bearer {token}"})
with urllib.request.urlopen(req, timeout=20) as r:
return json.load(r)
def passing_run(repo, sha, token):
"""URL of a successful pull request ci.yml run of `sha` whose test shards all passed."""
runs = get(f"{API}/repos/{repo}/actions/workflows/ci.yml/runs?head_sha={sha}&event=pull_request&status=success&per_page=10", token)
for run in runs.get("workflow_runs", []):
jobs = get(f"{API}/repos/{repo}/actions/runs/{run['id']}/jobs?per_page=100", token).get("jobs", [])
shards = [j for j in jobs if j.get("name", "").startswith(SHARD_PREFIX)]
if shards and all(j.get("conclusion") == "success" for j in shards):
return run.get("html_url", "")
return ""
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base", required=True)
ap.add_argument("--head", required=True)
ap.add_argument("--repo", required=True)
a = ap.parse_args()
carried = ""
try:
token = os.environ.get("GH_TOKEN", "")
for change in merge_chain(a.base, a.head) if token else []:
carried = passing_run(a.repo, change, token)
if carried:
print(f"{a.head} merges main into {change}, which passed: {carried}", file=sys.stderr)
break
except (subprocess.CalledProcessError, OSError, ValueError, KeyError) as e:
print(f"not carried ({e})", file=sys.stderr)
carried = ""
print(f"carried={carried}")
if __name__ == "__main__":
main()