insightfactory-cli 1.1.1__tar.gz → 1.1.2.dev28__tar.gz

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/CHANGELOG.md

@@ -7,8 +7,21 @@ project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 The release job reads the section whose heading matches the version in
 `pyproject.toml` and makes it the body of the GitHub Release. CI holds both ends of
-that: a PR into `develop` or `main` must raise the version and add its section here,
-and a tag whose version has no section fails rather than releasing an empty page.
+that: every PR into `develop` must add an entry here, and a tag whose version has no
+section fails rather than releasing an empty page. The version only moves when the
+last one has been released, so a cycle's PRs share a section.
+
+## 1.1.2
+
+### Changed
+
+- `release-guard` asks every PR into `develop` for a `CHANGELOG.md` entry, and asks
+  for a version bump only when `develop` is still on the version `main` is on. One
+  bump opens a release cycle and the PRs after it add to the section it opened,
+  rather than each minting a version that is never tagged.
+- The guard now measures a version against `main` as well as the base branch. A bump
+  has to land above the released version, not merely above the base, and a PR into an
+  open cycle has to add a line rather than reword one.
 
 ## 1.1.1
 

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/CLAUDE.md

@@ -34,9 +34,13 @@ uv run ty check
   match `pyproject.toml`. Pushing `develop` publishes a `.dev{run_number}`
   pre-release. Creating the release tag is a deliberate human act — do not create
   or push one unless asked to cut a release.
-- **Every PR into `develop` or `main` raises `version` in `pyproject.toml` and
-  documents that version in `CHANGELOG.md`.** The `release-guard` job runs
-  `tools/check_release.py` and fails the PR otherwise. Put user-visible changes in
-  the Added/Changed/Fixed group that fits; for internal-only work (tests, CI, a
-  refactor nothing observes) a one-line entry saying so is enough. The section
-  becomes the body of that version's GitHub Release.
+- **Every PR into `develop` adds a `CHANGELOG.md` entry**, in the Added/Changed/Fixed
+  group that fits. For internal-only work (tests, CI, a refactor nothing observes) a
+  one-line entry saying so is enough. The section becomes the body of that version's
+  GitHub Release.
+- **Raise `version` in `pyproject.toml` only when `develop` is on the same version as
+  `main`.** That version is released, so a new entry under it would describe a change
+  it does not contain: bump, and open a section for the new version. While `develop`
+  is ahead of `main` the cycle is open and PRs add to the section already there. A PR
+  into `main` always raises the version. The `release-guard` job runs
+  `tools/check_release.py` and fails the PR otherwise.

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: insightfactory-cli
-Version: 1.1.1
+Version: 1.1.2.dev28
 Summary: Profile-based authentication CLI for the InsightFactory Interfaces API
 Project-URL: Homepage, https://insightfactory.ai
 Author-email: "insightfactory.ai Support" <support@insightfactory.ai>
@@ -354,20 +354,32 @@ artifact, so its notes belong on that Release. A checkout with no tags falls bac
 to the tagged version's section alone.
 
 `develop` therefore carries the version the next release will use, and the
-`release-guard` job holds it there. A PR into `develop` must raise `version` in
-`pyproject.toml` above what `develop` already has, and must add that version's
-`CHANGELOG.md` section. `tools/check_release.py` runs both checks and is what
-fails the PR:
+`release-guard` job holds it there. `tools/check_release.py` runs the checks and
+is what fails the PR:
 
 ```bash
-BASE=origin/develop python3 tools/check_release.py
+BASE=origin/develop RELEASED=origin/main python3 tools/check_release.py
 ```
 
-One version per PR, then. The instinct is to let a second change join the
-section the first one opened, and the guard refuses that: the version would be
-tagged with notes that do not describe everything in it, and nothing stops the
-tag going out between the two merges. Bump the patch number again, or fold the
-second change into the first PR.
+**Every PR into `develop` adds a `CHANGELOG.md` entry.** That is the whole point
+of the file, and a change with no entry reaches users with no line anywhere
+saying it happened.
+
+**The version moves once per release cycle, not once per PR.** The first PR after
+a release raises `version` in `pyproject.toml` and opens that version's section;
+the rest of the cycle adds to the section it opened. The guard asks for the bump
+only while `develop` is still on the version `main` is on, because that version
+is released and its notes describe something your change is not in.
+
+The comparison is against `main` rather than against the tag, which matters in
+the window where the release PR has merged but the tag is not pushed yet. What a
+version contains is fixed when it reaches `main`, so a change landing after that
+belongs to the next version, whatever the tags say.
+
+A PR into `main` always needs the bump. It carries no new entries, only the
+version they were written under, and `main` exists to be tagged: leaving it on
+`main`'s own version makes it un-taggable, since that version is on PyPI and any
+other tag matches no file.
 
 Verify and build live in the reusable workflow
 [`if_s_insightfactory_cli.yml`](https://github.com/insightfactory-ai/if_sre_github_actions/blob/main/.github/workflows/if_s_insightfactory_cli.yml)

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/README.md

@@ -330,20 +330,32 @@ artifact, so its notes belong on that Release. A checkout with no tags falls bac
 to the tagged version's section alone.
 
 `develop` therefore carries the version the next release will use, and the
-`release-guard` job holds it there. A PR into `develop` must raise `version` in
-`pyproject.toml` above what `develop` already has, and must add that version's
-`CHANGELOG.md` section. `tools/check_release.py` runs both checks and is what
-fails the PR:
+`release-guard` job holds it there. `tools/check_release.py` runs the checks and
+is what fails the PR:
 
 ```bash
-BASE=origin/develop python3 tools/check_release.py
+BASE=origin/develop RELEASED=origin/main python3 tools/check_release.py
 ```
 
-One version per PR, then. The instinct is to let a second change join the
-section the first one opened, and the guard refuses that: the version would be
-tagged with notes that do not describe everything in it, and nothing stops the
-tag going out between the two merges. Bump the patch number again, or fold the
-second change into the first PR.
+**Every PR into `develop` adds a `CHANGELOG.md` entry.** That is the whole point
+of the file, and a change with no entry reaches users with no line anywhere
+saying it happened.
+
+**The version moves once per release cycle, not once per PR.** The first PR after
+a release raises `version` in `pyproject.toml` and opens that version's section;
+the rest of the cycle adds to the section it opened. The guard asks for the bump
+only while `develop` is still on the version `main` is on, because that version
+is released and its notes describe something your change is not in.
+
+The comparison is against `main` rather than against the tag, which matters in
+the window where the release PR has merged but the tag is not pushed yet. What a
+version contains is fixed when it reaches `main`, so a change landing after that
+belongs to the next version, whatever the tags say.
+
+A PR into `main` always needs the bump. It carries no new entries, only the
+version they were written under, and `main` exists to be tagged: leaving it on
+`main`'s own version makes it un-taggable, since that version is on PyPI and any
+other tag matches no file.
 
 Verify and build live in the reusable workflow
 [`if_s_insightfactory_cli.yml`](https://github.com/insightfactory-ai/if_sre_github_actions/blob/main/.github/workflows/if_s_insightfactory_cli.yml)

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "insightfactory-cli"
-version = "1.1.1"
+version = "1.1.2.dev28"
 description = "Profile-based authentication CLI for the InsightFactory Interfaces API"
 readme = "README.md"
 requires-python = ">=3.10"

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/tests/test_release_tools.py

@@ -296,31 +296,38 @@ def test_main_still_requires_the_changelog_on_the_opt_out(changelog, monkeypatch
         check_release.main()
 
 
-@pytest.mark.parametrize(("base", "expected_pass"), [("9.9.8", True), ("9.9.9", False), ("10.0.0", False)])
-def test_main_compares_against_the_base_branch(changelog, monkeypatch, base, expected_pass):
+@pytest.mark.parametrize(
+    ("base", "error"),
+    [("9.9.8", None), ("9.9.9", "has to raise the version"), ("10.0.0", "below origin/main's")],
+)
+def test_main_requires_a_bump_without_released(changelog, monkeypatch, base, error):
+    """No RELEASED is a PR into the release branch: the version must always move."""
     changelog("# Changelog\n\n## 9.9.9\n\n- a thing\n")
-    monkeypatch.setenv("BASE", "origin/develop")
+    monkeypatch.setenv("BASE", "origin/main")
+    monkeypatch.delenv("RELEASED", raising=False)
     monkeypatch.setattr(check_release, "base_version", lambda _: base)
-    if expected_pass:
+    if error is None:
         assert check_release.main() == 0
     else:
-        with pytest.raises(SystemExit, match="under notes written for other work"):
+        with pytest.raises(SystemExit, match=error):
             check_release.main()
 
 
 def test_main_treats_a_short_base_version_as_padded(changelog, monkeypatch):
     """9.9 and 9.9.0 are the same release, so 9.9.9 is still a bump over 9.9."""
     changelog("# Changelog\n\n## 9.9.9\n\n- a thing\n")
-    monkeypatch.setenv("BASE", "origin/develop")
+    monkeypatch.setenv("BASE", "origin/main")
+    monkeypatch.delenv("RELEASED", raising=False)
     monkeypatch.setattr(check_release, "base_version", lambda _: "9.9")
     assert check_release.main() == 0
 
 
 def test_main_refuses_an_equal_short_base_version(changelog, monkeypatch):
     changelog("# Changelog\n\n## 9.9\n\n- a thing\n", version="9.9")
-    monkeypatch.setenv("BASE", "origin/develop")
+    monkeypatch.setenv("BASE", "origin/main")
+    monkeypatch.delenv("RELEASED", raising=False)
     monkeypatch.setattr(check_release, "base_version", lambda _: "9.9.0")
-    with pytest.raises(SystemExit, match="under notes written for other work"):
+    with pytest.raises(SystemExit, match="has to raise the version"):
         check_release.main()
 
 
@@ -488,3 +495,124 @@ def test_versions_in_changelog_also_refuses_an_unclosed_fence():
     """Strictness is a property of the module, not of which entry point you call."""
     with pytest.raises(SystemExit, match="never closed"):
         release_notes.versions_in_changelog("# Changelog\n\n## 2.0.0\n\n```bash\nx\n")
+
+
+# ── a bump once a cycle, an entry every PR ────────────────────────────────────
+
+
+@pytest.fixture
+def refs(monkeypatch):
+    """Stand in for the two branches the guard reads, as a PR into develop."""
+
+    def setup(develop_version: str, main_version: str, develop_changelog: str) -> None:
+        monkeypatch.setenv("BASE", "origin/develop")
+        monkeypatch.setenv("RELEASED", "origin/main")
+        monkeypatch.setattr(
+            check_release,
+            "base_version",
+            lambda ref: develop_version if ref == "origin/develop" else main_version,
+        )
+        monkeypatch.setattr(
+            check_release,
+            "file_at",
+            lambda ref, path: develop_changelog,
+        )
+
+    return setup
+
+
+def test_open_cycle_accepts_a_new_entry_without_a_bump(changelog, refs):
+    """develop is ahead of main, so 9.9.9's section is still open to add to."""
+    changelog("# Changelog\n\n## 9.9.9\n\n- an earlier entry\n- what this PR did\n")
+    refs("9.9.9", "9.9.8", "# Changelog\n\n## 9.9.9\n\n- an earlier entry\n")
+    assert check_release.main() == 0
+
+
+def test_open_cycle_refuses_an_unchanged_section(changelog, refs):
+    """The bump is not required, so the entry is what this PR owes instead."""
+    changelog("# Changelog\n\n## 9.9.9\n\n- an earlier entry\n")
+    refs("9.9.9", "9.9.8", "# Changelog\n\n## 9.9.9\n\n- an earlier entry\n")
+    with pytest.raises(SystemExit, match="adds nothing to origin/develop's"):
+        check_release.main()
+
+
+def test_released_version_still_requires_a_bump(changelog, refs):
+    """develop is on what main is on, so 9.9.9 is released and its notes are fixed."""
+    changelog("# Changelog\n\n## 9.9.9\n\n- an earlier entry\n- what this PR did\n")
+    refs("9.9.9", "9.9.9", "# Changelog\n\n## 9.9.9\n\n- an earlier entry\n")
+    with pytest.raises(SystemExit, match="origin/main is on 9.9.9: that version is released"):
+        check_release.main()
+
+
+def test_a_bump_satisfies_the_guard_whatever_the_cycle(changelog, refs):
+    """Deliberately jumping the version mid-cycle stays allowed."""
+    changelog("# Changelog\n\n## 9.9.9\n\n- a thing\n")
+    refs("9.9.8", "9.9.7", "# Changelog\n\n## 9.9.8\n\n- older\n")
+    assert check_release.main() == 0
+
+
+def test_a_bump_off_the_released_version_is_the_cycle_opening(changelog, refs):
+    changelog("# Changelog\n\n## 9.9.9\n\n- opens the cycle\n")
+    refs("9.9.8", "9.9.8", "# Changelog\n\n## 9.9.8\n\n- released\n")
+    assert check_release.main() == 0
+
+
+def test_a_lowered_version_is_refused(changelog, refs):
+    changelog("# Changelog\n\n## 9.9.7\n\n- a thing\n", version="9.9.7")
+    refs("9.9.9", "9.9.8", "# Changelog\n\n## 9.9.9\n\n- newer\n")
+    with pytest.raises(SystemExit, match="below origin/develop's"):
+        check_release.main()
+
+
+def test_a_version_at_or_below_the_released_one_is_refused(changelog, refs):
+    """A bump has to clear main, not just develop: 9.9.9's notes are already published."""
+    changelog("# Changelog\n\n## 9.9.9\n\n- a thing\n")
+    refs("9.9.8", "9.9.9", "# Changelog\n\n## 9.9.8\n\n- older\n")
+    with pytest.raises(SystemExit, match="not above origin/main's 9.9.9"):
+        check_release.main()
+
+
+def test_the_released_comparison_pads_to_the_wider_version(changelog, refs):
+    """9.9 and 9.9.0 are the same release, so this is not a bump off it."""
+    changelog("# Changelog\n\n## 9.9\n\n- a thing\n", version="9.9")
+    refs("9.8", "9.9.0", "# Changelog\n\n## 9.8\n\n- older\n")
+    with pytest.raises(SystemExit, match="not above origin/main's 9.9.0"):
+        check_release.main()
+
+
+def test_a_reformatted_section_adds_nothing(changelog, refs):
+    """Re-indenting an entry is not writing one."""
+    changelog("# Changelog\n\n## 9.9.9\n\n-   an earlier entry\n")
+    refs("9.9.9", "9.9.8", "# Changelog\n\n## 9.9.9\n\n- an earlier entry\n")
+    with pytest.raises(SystemExit, match="adds nothing to origin/develop's"):
+        check_release.main()
+
+
+def test_deleting_an_entry_is_not_adding_one(changelog, refs):
+    changelog("# Changelog\n\n## 9.9.9\n\n- an earlier entry\n")
+    refs("9.9.9", "9.9.8", "# Changelog\n\n## 9.9.9\n\n- an earlier entry\n- a second entry\n")
+    with pytest.raises(SystemExit, match="adds nothing to origin/develop's"):
+        check_release.main()
+
+
+def test_section_at_reports_an_unreadable_ref(monkeypatch):
+    """A git failure is not the same as a missing section, and must not be swallowed."""
+
+    def boom(ref, path):
+        raise SystemExit(f"error: cannot read {path} at {ref}")
+
+    monkeypatch.setattr(check_release, "file_at", boom)
+    with pytest.raises(SystemExit, match="cannot read CHANGELOG.md"):
+        check_release.section_at("origin/develop", "9.9.9")
+
+
+def test_section_at_returns_none_when_the_base_has_no_section(monkeypatch):
+    monkeypatch.setattr(check_release, "file_at", lambda ref, path: "# Changelog\n\n## 1.0.0\n\n- old\n")
+    assert check_release.section_at("origin/develop", "9.9.9") is None
+
+
+def test_a_first_entry_for_a_version_the_base_lacks_counts_as_changed(changelog, refs):
+    """The section is new on this branch, so it cannot match the base's."""
+    changelog("# Changelog\n\n## 9.9.9\n\n- the first entry\n")
+    refs("9.9.9", "9.9.8", "# Changelog\n\n## 1.0.0\n\n- unrelated\n")
+    assert check_release.main() == 0

insightfactory_cli-1.1.2.dev28/tools/check_release.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Refuse a change that nobody would be able to find in the release notes.
+
+Run by the `release-guard` CI job. Every PR must say what it did; only some have
+to move the version to say it.
+
+  * The version in pyproject.toml always has a CHANGELOG.md section.
+  * A PR whose base is still on the released version has to raise the version and
+    open a section of its own. Any version it moves to is above the released one.
+  * Any other PR into an open cycle has to add a line to the section already there.
+
+A cycle is open while the base branch is ahead of RELEASED, the branch releases are
+tagged from. Anchoring on that branch rather than on the tag matters in the window
+where a release PR has merged but the tag is not pushed yet: the contents of that
+version are fixed at the merge, so a later change belongs to the next one, and
+appending to it would ship a Release describing something it does not contain.
+
+BASE names the ref to compare against (`origin/develop`). A push has no base to
+diff, so it passes `BASE=none` and gets the CHANGELOG check alone. BASE unset is an
+error rather than that same skip: these are the checks a human cannot replicate by
+reading the diff, and a renamed or mis-indented `env:` key should fail the job
+rather than quietly turn it into a no-op.
+
+RELEASED names the release branch (`origin/main`), and is what makes the bump
+conditional. Left unset, every PR must bump, which is what a PR into the release
+branch itself wants: it carries no new entries, only the version they were written
+under.
+
+Stdlib only: this runs on the CI runner's system python3, outside the project venv.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).resolve().parent))
+
+import release_notes  # noqa: E402
+from release_notes import changelog_section, current_version, parse_version, release_parts, version_key  # noqa: E402
+
+NO_BASE = "none"
+
+
+def file_at(ref: str, path: str) -> str:
+    result = subprocess.run(
+        ["git", "show", f"{ref}:{path}"],
+        cwd=release_notes.ROOT,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise SystemExit(
+            f"error: cannot read {path} at {ref}: {result.stderr.strip()}\n"
+            f"If this is CI, the checkout needs fetch-depth: 0 for {ref} to exist locally."
+        )
+    return result.stdout
+
+
+def base_version(base: str) -> str:
+    return parse_version(file_at(base, "pyproject.toml"), where=f"pyproject.toml at {base}")
+
+
+def section_at(ref: str, version: str) -> str | None:
+    """That version's CHANGELOG section on `ref`, or None if it has none yet."""
+    text = file_at(ref, "CHANGELOG.md")
+    try:
+        return release_notes.changelog_section(version, text)
+    except SystemExit:
+        return None
+
+
+def entry_lines(section: str | None) -> set[str]:
+    """The section's entries, as comparable lines.
+
+    Whitespace is collapsed and headings dropped, so re-indenting or re-wrapping an
+    entry does not read as writing one.
+    """
+    if section is None:
+        return set()
+    lines = (" ".join(line.split()) for line in section.splitlines())
+    return {line for line in lines if line and not line.startswith("#")}
+
+
+def main() -> int:
+    version = current_version()
+
+    # Raises if the section is missing or empty, with the message to act on.
+    section = changelog_section(version)
+    print(f"CHANGELOG.md documents {version}")
+
+    base = os.environ.get("BASE", "").strip()
+    if not base:
+        raise SystemExit(
+            f"error: BASE is unset. Pass the ref to compare against, "
+            f"or BASE={NO_BASE} for a run that genuinely has no base branch."
+        )
+    if base == NO_BASE:
+        print(f"BASE={NO_BASE}, skipping the version-bump check")
+        return 0
+
+    previous = base_version(base)
+    released_ref = os.environ.get("RELEASED", "").strip()
+    released = base_version(released_ref) if released_ref else None
+
+    widths = [len(release_parts(version)), len(release_parts(previous))]
+    if released is not None:
+        widths.append(len(release_parts(released)))
+    width = max(widths)
+
+    def key(value: str) -> tuple[int, ...]:
+        return version_key(value, width)
+
+    if key(version) < key(previous):
+        raise SystemExit(
+            f"error: pyproject.toml is at {version}, below {base}'s {previous}. "
+            f"Rebase on {base} rather than lowering the version."
+        )
+
+    if released is not None and key(version) <= key(released):
+        # Every version this repo can still write notes for is above the released one,
+        # whichever way the base branch got to where it is.
+        if key(version) == key(previous):
+            raise SystemExit(
+                f"error: pyproject.toml is at {version}, the same as {base}'s, and {released_ref} is "
+                f"on {released}: that version is released. Raise the version and open a CHANGELOG.md "
+                f"section for it."
+            )
+        raise SystemExit(
+            f"error: pyproject.toml is at {version}, which is not above {released_ref}'s {released}. "
+            f"{released} is released, so its notes are fixed. Raise the version past it."
+        )
+
+    if key(version) > key(previous):
+        # A bump always satisfies the guard. The section check above already made
+        # sure the version it opens is documented and not empty.
+        print(f"version {version} is above {base}'s {previous}")
+        return 0
+
+    if released is None:
+        raise SystemExit(
+            f"error: pyproject.toml is at {version}, the same as {base}'s. "
+            f"A PR into {base} has to raise the version to the one its entries were written under."
+        )
+
+    # The cycle is open, so no bump. The entry is what this PR owes instead. The
+    # checkout is the merge ref, so the working tree section holds the base's entries
+    # as well as this PR's: anything not on the base tip is what this PR added.
+    if not entry_lines(section) - entry_lines(section_at(base, version)):
+        raise SystemExit(
+            f"error: the CHANGELOG.md section for {version} adds nothing to {base}'s. "
+            f"{version} is unreleased, so no version bump is needed, but this change still has to "
+            f"say what it did. Add an entry under `## {version}`."
+        )
+
+    print(f"{version} is unreleased ({released_ref} is on {released}) and this PR adds to its section")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{insightfactory_cli-1.1.1 → insightfactory_cli-1.1.2.dev28}/uv.lock

@@ -305,7 +305,7 @@ wheels = [
 
 [[package]]
 name = "insightfactory-cli"
-version = "1.1.1"
+version = "1.1.2"
 source = { editable = "." }
 
 [package.optional-dependencies]

insightfactory_cli-1.1.1/tools/check_release.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""Refuse a change that would land under a version someone has already written up.
-
-Two checks, run by the `release-guard` CI job:
-
-  * the version in pyproject.toml has a CHANGELOG.md section, and
-  * on a PR, that version is above the one on the base branch.
-
-BASE names the git ref to compare against (`origin/develop`). A push has no base
-to diff, so it passes `BASE=none` and gets the CHANGELOG check alone. BASE unset
-is an error rather than that same skip: the bump check is the half a human cannot
-replicate by reading the diff, and a renamed or mis-indented `env:` key should
-fail the job rather than quietly turn it into a no-op.
-
-Stdlib only: this runs on the CI runner's system python3, outside the project venv.
-"""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-sys.path.append(str(Path(__file__).resolve().parent))
-
-import release_notes  # noqa: E402
-from release_notes import changelog_section, current_version, parse_version, release_parts, version_key  # noqa: E402
-
-NO_BASE = "none"
-
-
-def base_version(base: str) -> str:
-    result = subprocess.run(
-        ["git", "show", f"{base}:pyproject.toml"],
-        cwd=release_notes.ROOT,
-        capture_output=True,
-        text=True,
-    )
-    if result.returncode != 0:
-        raise SystemExit(
-            f"error: cannot read pyproject.toml at {base}: {result.stderr.strip()}\n"
-            f"If this is CI, the checkout needs fetch-depth: 0 for {base} to exist locally."
-        )
-    return parse_version(result.stdout, where=f"pyproject.toml at {base}")
-
-
-def main() -> int:
-    version = current_version()
-
-    # Raises if the section is missing or empty, with the message to act on.
-    changelog_section(version)
-    print(f"CHANGELOG.md documents {version}")
-
-    base = os.environ.get("BASE", "").strip()
-    if not base:
-        raise SystemExit(
-            f"error: BASE is unset. Pass the ref to compare against, "
-            f"or BASE={NO_BASE} for a run that genuinely has no base branch."
-        )
-    if base == NO_BASE:
-        print(f"BASE={NO_BASE}, skipping the version-bump check")
-        return 0
-
-    previous = base_version(base)
-    width = max(len(release_parts(version)), len(release_parts(previous)))
-    if version_key(version, width) <= version_key(previous, width):
-        raise SystemExit(
-            f"error: pyproject.toml is at {version}, and {base} is at {previous}. "
-            f"{base} already has a {previous} section in CHANGELOG.md, so this change would land "
-            f"under notes written for other work, and could be tagged before anyone lists it. "
-            f"Raise the version and open its own section."
-        )
-    print(f"version {version} is above {base}'s {previous}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())