flurdy/agent-skills / skills/ready-to-merge
ready-to-merge
VerifiedPre-merge gate — verify a PR is green, approved, in sync, and free of obvious risk, then (on explicit approval) squash-merge it. Composes /pr-status, /contract-check, and /review-pr rather than reimplementing them.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 23.1 KB |
| references/default-sync.md | markdown | 6.9 KB |
| scripts/default-sync.py | script | 11.8 KB |
| scripts/gh-branch-delete.pyexecutable | script | 417 B |
| scripts/gh-branch-view.pyexecutable | script | 280 B |
| scripts/git-unpushed.shexecutable | script | 204 B |
| scripts/github_branch.py | script | 2.0 KB |
| scripts/merge-timing.pyexecutable | script | 9.1 KB |
| tests/test-skill-contract.shexecutable | script | 2.8 KB |
| tests/test_branch_wrappers.py | script | 7.6 KB |
| tests/test_default_sync.py | script | 11.5 KB |
| tests/test_merge_timing.py | script | 11.0 KB |
tests/test_merge_timing.py
View on GitHub"""Evaluate merge-timing policies offline with fixed clocks and temporary repositories."""
import json
import os
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest
SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "merge-timing.py"
BUSINESS = """
timezone = "Europe/London"
[[rule]]
name = "business-hours"
enforcement = "required"
days = ["mon", "tue", "wed", "thu", "fri"]
start = "09:00"
end = "17:30"
"""
AFTERNOON = """
[[rule]]
name = "late-afternoon"
enforcement = "advisory"
end = "16:00"
end_by_day = { fri = "12:00" }
"""
class MergeTimingTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory(prefix="merge timing ")
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name).resolve()
self.repo = self.root / "client" / "repo"
self.repo.mkdir(parents=True)
self.git("init", "-q", "-b", "main")
self.git("-c", "user.name=t", "-c", "user.email=t@example.invalid",
"commit", "-q", "--allow-empty", "-m", "init")
def git(self, *args, cwd=None):
subprocess.run(["git", *args], cwd=cwd or self.repo, check=True, capture_output=True)
def policy(self, text, where=None):
path = (where or self.root / "client") / "merge-timing.toml"
path.write_text(text)
return path
def run_helper(self, now, repo=None, tz="UTC"):
env = {**os.environ, "TZ": tz}
result = subprocess.run(
[sys.executable, "-I", str(SCRIPT), "--repo", str(repo or self.repo), "--now", now],
env=env, text=True, capture_output=True, timeout=30,
)
return result.returncode, json.loads(result.stdout) if result.stdout else None, result.stderr
def evaluate(self, now, **kwargs):
code, data, stderr = self.run_helper(now, **kwargs)
self.assertIn(code, (0, 3), stderr)
return data
def test_absent_policy_is_none(self):
self.assertEqual(self.evaluate("2026-10-16T17:00:00+01:00"), {"status": "none"})
def test_business_hours_inside_and_outside(self):
self.policy(BUSINESS)
inside = self.evaluate("2026-10-14T10:00:00+01:00")
self.assertEqual(inside["status"], "clear")
self.assertEqual(inside["violations"], [])
self.assertIsNone(inside["next_allowed"])
outside = self.evaluate("2026-10-14T18:00:00+01:00")
self.assertEqual(outside["status"], "required")
self.assertEqual(outside["local_time"], "2026-10-14T18:00+01:00")
self.assertEqual(outside["weekday"], "wed")
self.assertEqual(outside["violations"][0]["rule"], "business-hours")
self.assertIn("17:30", outside["violations"][0]["reason"])
self.assertEqual(outside["next_allowed"], "2026-10-15T09:00+01:00")
def test_precise_window_boundaries(self):
self.policy(BUSINESS)
for local, status in (("08:59", "required"), ("09:00", "clear"),
("17:29", "clear"), ("17:30", "required")):
with self.subTest(local=local):
self.assertEqual(self.evaluate(f"2026-10-14T{local}:00+01:00")["status"], status)
def test_ordinary_and_friday_cutoffs_are_advisory(self):
self.policy('timezone = "Europe/London"\n' + AFTERNOON)
for now, status in (("2026-10-15T15:59:00+01:00", "clear"),
("2026-10-15T16:00:00+01:00", "advisory"),
("2026-10-16T11:59:00+01:00", "clear"),
("2026-10-16T12:00:00+01:00", "advisory")):
with self.subTest(now=now):
self.assertEqual(self.evaluate(now)["status"], status)
friday = self.evaluate("2026-10-16T12:00:00+01:00")
self.assertIn("12:00", friday["violations"][0]["reason"])
self.assertIn("Fri", friday["violations"][0]["reason"])
def test_required_beats_advisory_and_rolls_over_the_weekend(self):
self.policy(BUSINESS + AFTERNOON)
data = self.evaluate("2026-10-16T17:45:00+01:00")
self.assertEqual(data["status"], "required")
self.assertEqual([v["rule"] for v in data["violations"]], ["business-hours", "late-afternoon"])
self.assertEqual(data["next_allowed"], "2026-10-19T09:00+01:00")
def test_all_friday_restriction(self):
self.policy('timezone = "Europe/London"\n[[rule]]\nname = "no-friday"\n'
'enforcement = "required"\ndays = ["mon", "tue", "wed", "thu"]\n')
data = self.evaluate("2026-10-16T10:00:00+01:00")
self.assertEqual(data["status"], "required")
self.assertIn("Fri is not an allowed merge day", data["violations"][0]["reason"])
self.assertEqual(data["next_allowed"], "2026-10-19T00:00+01:00")
def test_machine_timezone_does_not_change_the_result(self):
self.policy(BUSINESS)
now = "2026-10-14T16:30:00+00:00" # 17:30 in London
results = {tz: self.evaluate(now, tz=tz) for tz in ("UTC", "Pacific/Auckland", "America/Los_Angeles")}
self.assertEqual(len({json.dumps(r, sort_keys=True) for r in results.values()}), 1, results)
self.assertEqual(results["UTC"]["status"], "required")
def test_daylight_saving_transitions(self):
self.policy('timezone = "Europe/London"\n[[rule]]\nenforcement = "required"\n'
'start = "09:00"\nend = "17:30"\n')
for now, status, local in (("2026-03-28T08:30:00+00:00", "required", "2026-03-28T08:30+00:00"),
("2026-03-29T08:30:00+00:00", "clear", "2026-03-29T09:30+01:00"),
("2026-10-24T08:30:00+00:00", "clear", "2026-10-24T09:30+01:00"),
("2026-10-25T08:30:00+00:00", "required", "2026-10-25T08:30+00:00")):
with self.subTest(now=now):
data = self.evaluate(now)
self.assertEqual((data["status"], data["local_time"]), (status, local))
self.assertEqual(self.evaluate("2026-03-28T18:00:00+00:00")["next_allowed"], "2026-03-29T09:00+01:00")
self.assertEqual(self.evaluate("2026-10-24T17:00:00+00:00")["next_allowed"], "2026-10-25T09:00+00:00")
def test_time_crossing_a_cutoff_between_report_and_execution(self):
self.policy('timezone = "Europe/London"\n[[rule]]\nenforcement = "required"\n'
'end_by_day = { fri = "12:00" }\n')
self.assertEqual(self.evaluate("2026-10-16T11:59:59+01:00")["status"], "clear")
self.assertEqual(self.evaluate("2026-10-16T12:00:00+01:00")["status"], "required")
def test_malformed_policy_is_unknown(self):
cases = {
"toml": "timezone = \n",
"unknown top key": 'timezone = "UTC"\nenforcment = "required"\n[[rule]]\nenforcement = "advisory"\nend = "16:00"\n',
"unknown rule key": 'timezone = "UTC"\n[[rule]]\nenforcement = "advisory"\nends = "16:00"\n',
"missing timezone": '[[rule]]\nenforcement = "advisory"\nend = "16:00"\n',
"bad timezone": 'timezone = "Mars/Olympus"\n[[rule]]\nenforcement = "advisory"\nend = "16:00"\n',
"missing enforcement": 'timezone = "UTC"\n[[rule]]\nend = "16:00"\n',
"bad enforcement": 'timezone = "UTC"\n[[rule]]\nenforcement = "strict"\nend = "16:00"\n',
"no rules": 'timezone = "UTC"\n',
"empty rule": 'timezone = "UTC"\n[[rule]]\nenforcement = "required"\n',
"bad time": 'timezone = "UTC"\n[[rule]]\nenforcement = "required"\nend = "4pm"\n',
"start after end": 'timezone = "UTC"\n[[rule]]\nenforcement = "required"\nstart = "17:00"\nend = "09:00"\n',
"empty days": 'timezone = "UTC"\n[[rule]]\nenforcement = "required"\ndays = []\n',
"bad day": 'timezone = "UTC"\n[[rule]]\nenforcement = "required"\ndays = ["friday"]\n',
"cutoff on disallowed day": 'timezone = "UTC"\n[[rule]]\nenforcement = "required"\n'
'days = ["mon"]\nend_by_day = { fri = "12:00" }\n',
"duplicate names": 'timezone = "UTC"\n[[rule]]\nname = "a"\nenforcement = "required"\nend = "16:00"\n'
'[[rule]]\nname = "a"\nenforcement = "advisory"\nend = "15:00"\n',
}
for label, text in cases.items():
with self.subTest(label=label):
self.policy(text)
code, data, _ = self.run_helper("2026-10-14T10:00:00+01:00")
self.assertEqual(code, 3)
self.assertEqual(data["status"], "unknown")
self.assertTrue(data["error"])
def test_unavailable_policy_is_unknown(self):
(self.root / "client" / "merge-timing.toml").mkdir()
code, data, _ = self.run_helper("2026-10-14T10:00:00+01:00")
self.assertEqual((code, data["status"]), (3, "unknown"))
@unittest.skipIf(os.geteuid() == 0, "root can read any file")
def test_unreadable_policy_is_unknown(self):
path = self.policy(BUSINESS)
path.chmod(0)
self.addCleanup(path.chmod, 0o600)
code, data, _ = self.run_helper("2026-10-14T10:00:00+01:00")
self.assertEqual((code, data["status"]), (3, "unknown"))
def test_in_repository_policy_cannot_relax_trusted_policy(self):
self.policy(BUSINESS)
self.policy('timezone = "UTC"\n[[rule]]\nenforcement = "advisory"\nend = "24:00"\n', where=self.repo)
data = self.evaluate("2026-10-14T18:00:00+01:00")
self.assertEqual(data["status"], "required")
self.assertEqual(data["policy"], str(self.root / "client" / "merge-timing.toml"))
self.assertEqual(data["ignored"], [str(self.repo / "merge-timing.toml")])
def test_in_repository_policy_alone_is_reported_but_not_applied(self):
self.policy(BUSINESS, where=self.repo)
self.assertEqual(self.evaluate("2026-10-14T18:00:00+01:00"),
{"status": "none", "ignored": [str(self.repo / "merge-timing.toml")]})
def test_policy_inside_another_checkout_of_the_same_repository_is_unknown(self):
worktree = self.repo / ".worktrees" / "topic"
self.git("worktree", "add", "-q", "-b", "topic", str(worktree))
self.policy(BUSINESS, where=self.repo)
code, data, _ = self.run_helper("2026-10-14T10:00:00+01:00", repo=worktree)
self.assertEqual((code, data["status"]), (3, "unknown"))
self.assertIn("same repository", data["error"])
def test_nearest_trusted_policy_wins(self):
self.policy('timezone = "UTC"\n[[rule]]\nenforcement = "required"\nend = "01:00"\n', where=self.root)
self.policy(BUSINESS)
self.assertEqual(self.evaluate("2026-10-14T10:00:00+01:00")["status"], "clear")
def test_outside_a_repository_is_unknown(self):
outside = self.root / "plain"
outside.mkdir()
code, data, _ = self.run_helper("2026-10-14T10:00:00+01:00", repo=outside)
self.assertEqual((code, data["status"]), (3, "unknown"))
def test_naive_now_is_rejected(self):
code, _, stderr = self.run_helper("2026-10-14T10:00:00")
self.assertEqual(code, 2)
self.assertIn("offset", stderr)
if __name__ == "__main__":
unittest.main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |