guild-cli 0.26.22__tar.gz → 0.26.23__tar.gz

{guild_cli-0.26.22 → guild_cli-0.26.23}/.claude/skills/version-bump/SKILL.md

@@ -24,8 +24,10 @@ Run from the repo root.
 echo '{"added":["New X"],"changed":["Refactored Y"],"fixed":["Bug in Z"]}' \
   | python3 .claude/skills/version-bump/scripts/bump.py minor
 
-# Without changelog content (inserts empty ### Added/Changed/Fixed stubs):
-python3 .claude/skills/version-bump/scripts/bump.py patch
+# Without changelog content (inserts empty ### Added/Changed/Fixed stubs).
+# From scripts, daemons and agent harnesses, pass --no-stdin so the bump
+# never waits on a stdin it was handed but nobody writes to:
+python3 .claude/skills/version-bump/scripts/bump.py patch --no-stdin
 
 # Check current version without bumping:
 python3 .claude/skills/version-bump/scripts/bump.py show
@@ -44,6 +46,12 @@ python3 .claude/skills/version-bump/scripts/bump.py show
 
 Pass via stdin. All fields are optional — only non-empty sections are rendered.
 
+Stdin is read until it closes, however slowly the JSON arrives. If it stays
+open with no new input for `BUMP_STDIN_IDLE_SECONDS` (default 5), the bump
+stops with an error and changes nothing, instead of hanging or dropping your
+entries. `--no-stdin` (or `BUMP_NO_STDIN=1`) skips stdin and writes the empty
+stub.
+
 ```json
 {
   "added":   ["List of new features"],
@@ -57,7 +65,11 @@ Pass via stdin. All fields are optional — only non-empty sections are rendered
 - `pyproject.toml` — the `version = "x.y.z"` field (single source of truth;
   `steward/__init__.py` reads it via `importlib.metadata`, so there's no
   separate `__version__` literal to keep in sync).
-- `CHANGELOG.md` — inserts a new `## [x.y.z] - YYYY-MM-DD` entry at the top.
+- `CHANGELOG.md` — inserts a new `## [x.y.z] - YYYY-MM-DD` entry above the
+  first `## [` release heading (headings inside fenced code blocks don't
+  count). A leading `## [Unreleased]` section stays on top, untouched; its
+  content is never moved into the release for you. A CHANGELOG with no release
+  heading yet gets the entry after its Unreleased section, or at the end.
 
 The script does the rest. Pick a bump type from the diff (patch for fixes,
 minor for new features, major for breaking changes), summarize the diff into

{guild_cli-0.26.22 → guild_cli-0.26.23}/.claude/skills/version-bump/scripts/bump.py

@@ -11,6 +11,7 @@ Usage:
     bump.py minor    # 0.1.0 -> 0.2.0
     bump.py patch    # 0.1.0 -> 0.1.1
     bump.py show     # print current version
+    bump.py patch --no-stdin   # don't read stdin; insert the empty stub
 
 Changelog entries are passed via stdin as a JSON object:
     {
@@ -19,11 +20,22 @@ Changelog entries are passed via stdin as a JSON object:
       "fixed": ["WHO reply index bug"]
     }
 
-If no stdin is provided, an empty stub is inserted.
+If stdin is a terminal or empty, or --no-stdin (or BUMP_NO_STDIN=1) is given,
+an empty stub is inserted. Stdin is read until it closes; if it stays open
+with no new input for BUMP_STDIN_IDLE_SECONDS (default 5), the bump stops with
+an error and changes nothing, rather than hanging or dropping entries.
+
+The new section goes above the first ``## [`` release heading, ignoring
+headings inside fenced code blocks. A leading ``## [Unreleased]`` section stays
+on top, untouched; a CHANGELOG with no release heading yet gets the section
+after its Unreleased section, or at the end.
 """
 
 import json
+import math
+import os
 import re
+import select
 import sys
 from datetime import date
 from pathlib import Path
@@ -78,17 +90,70 @@ def write_version(path: Path, old: str, new: str) -> None:
     path.write_text(updated)
 
 
-def read_changelog_entries() -> dict:
+STDIN_IDLE_SECONDS_DEFAULT = 5.0
+
+
+def _env_flag(name: str) -> bool:
+    return os.environ.get(name, "").strip().lower() in ("1", "true", "yes")
+
+
+def _stdin_idle_seconds() -> float:
+    raw = os.environ.get("BUMP_STDIN_IDLE_SECONDS")
+    if raw is None:
+        return STDIN_IDLE_SECONDS_DEFAULT
+    try:
+        value = float(raw)
+    except ValueError:
+        value = 0.0
+    if not math.isfinite(value) or value <= 0:
+        print(
+            f"ERROR: BUMP_STDIN_IDLE_SECONDS must be a positive number, got {raw!r}",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    return value
+
+
+def _read_stdin_until_eof(idle: float) -> str | None:
+    """Read stdin to EOF; None if it stays open with no new input for ``idle`` s."""
+    fd = sys.stdin.fileno()
+    chunks = []
+    while True:
+        try:
+            ready, _, _ = select.select([fd], [], [], idle)
+        except (OSError, ValueError):
+            return sys.stdin.read()  # select() can't poll this stdin (e.g. Windows): read as before
+        if not ready:
+            return None
+        chunk = os.read(fd, 65536)
+        if not chunk:
+            return b"".join(chunks).decode()
+        chunks.append(chunk)
+
+
+def read_changelog_entries(no_stdin: bool = False) -> dict:
     """Read changelog entries from stdin as JSON."""
-    if sys.stdin.isatty():
+    if no_stdin or sys.stdin is None or sys.stdin.isatty():
+        return {}
+    idle = _stdin_idle_seconds()
+    raw = _read_stdin_until_eof(idle)
+    if raw is None:
+        print(
+            f"ERROR: stdin stayed open with no input for {idle:g}s and never closed; nothing "
+            "was changed. Pipe the changelog JSON (echo '{...}' | bump.py patch), or pass "
+            "--no-stdin (or set BUMP_NO_STDIN=1) for an empty stub.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    raw = raw.strip()
+    if not raw:
         return {}
     try:
-        raw = sys.stdin.read().strip()
-        if not raw:
-            return {}
         return json.loads(raw)
     except (json.JSONDecodeError, ValueError):
-        print("WARNING: could not parse changelog JSON from stdin, using empty stub", file=sys.stderr)
+        print(
+            "WARNING: could not parse changelog JSON from stdin, using empty stub", file=sys.stderr
+        )
         return {}
 
 
@@ -116,6 +181,32 @@ def format_changelog_section(new: str, entries: dict) -> str:
     return "".join(chunks)
 
 
+def _section_headings(lines: list[str]) -> list[tuple[int, str]]:
+    """``## `` headings outside fenced code blocks, as (line index, line)."""
+    headings, fenced = [], False
+    for i, line in enumerate(lines):
+        if line.lstrip().startswith(("```", "~~~")):
+            fenced = not fenced
+        elif not fenced and line.startswith("## "):
+            headings.append((i, line))
+    return headings
+
+
+def _insertion_index(lines: list[str]) -> int:
+    """Line index for the new section: above the first ``## [`` release heading
+    that isn't Unreleased, so a leading Unreleased section stays on top; after
+    an Unreleased-only section, or at the end of a file with neither."""
+    headings = _section_headings(lines)
+    unreleased = re.compile(r"^## \[Unreleased\]", re.IGNORECASE)
+    releases = [i for i, line in headings if line.startswith("## [") and not unreleased.match(line)]
+    if releases:
+        return releases[0]
+    after = [i for i, line in headings if unreleased.match(line)]
+    if after:
+        return next((i for i, _ in headings if i > after[0]), len(lines))
+    return len(lines)
+
+
 def update_changelog(project_root: Path, new: str, entries: dict) -> None:
     """Insert a new changelog entry into CHANGELOG.md."""
     changelog = project_root / "CHANGELOG.md"
@@ -123,24 +214,25 @@ def update_changelog(project_root: Path, new: str, entries: dict) -> None:
         print("No CHANGELOG.md found — skipping")
         return
 
-    text = changelog.read_text()
+    lines = changelog.read_text().splitlines(keepends=True)
+    idx = _insertion_index(lines)
+    before, after = "".join(lines[:idx]), "".join(lines[idx:])
     new_entry = format_changelog_section(new, entries)
-
-    marker = "## ["
-    idx = text.find(marker)
-    if idx > 0:
-        changelog.write_text(text[:idx] + new_entry + text[idx:])
-        print(f"Updated CHANGELOG.md with [{new}]")
-    else:
-        print("WARNING: could not find insertion point in CHANGELOG.md", file=sys.stderr)
+    if not after:  # appending at the end of the file
+        before = before.rstrip("\n") + "\n\n" if before.strip() else ""
+        new_entry = new_entry.rstrip("\n") + "\n"
+    changelog.write_text(before + new_entry + after)
+    print(f"Updated CHANGELOG.md with [{new}]")
 
 
 def main():
-    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help"):
+    args = [a for a in sys.argv[1:] if a != "--no-stdin"]
+    no_stdin = len(args) < len(sys.argv) - 1 or _env_flag("BUMP_NO_STDIN")
+    if not args or args[0] in ("-h", "--help"):
         print(__doc__.strip())
         sys.exit(0)
 
-    part = sys.argv[1].lower()
+    part = args[0].lower()
     path = find_pyproject()
     current = read_version(path)
 
@@ -149,7 +241,7 @@ def main():
         sys.exit(0)
 
     # Read changelog entries before bumping
-    entries = read_changelog_entries()
+    entries = read_changelog_entries(no_stdin)
 
     new = bump(current, part)
     write_version(path, current, new)
@@ -162,10 +254,12 @@ def main():
         if init.exists():
             init_text = init.read_text()
             if f'__version__ = "{current}"' in init_text:
-                init.write_text(init_text.replace(
-                    f'__version__ = "{current}"',
-                    f'__version__ = "{new}"',
-                ))
+                init.write_text(
+                    init_text.replace(
+                        f'__version__ = "{current}"',
+                        f'__version__ = "{new}"',
+                    )
+                )
                 print(f"Updated {init.relative_to(path.parent)}")
 
     # Update changelog

{guild_cli-0.26.22 → guild_cli-0.26.23}/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/). This project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.26.23] - 2026-10-30
+
+### Added
+
+- `version-bump`: `--no-stdin` (or `BUMP_NO_STDIN=1`) skips reading stdin and writes the empty changelog stub, for scripts, daemons and agent harnesses that hand the script a stdin nobody writes to. `BUMP_STDIN_IDLE_SECONDS` (default 5) sets how long stdin may stay silent before the bump gives up.
+
+### Fixed
+
+- `version-bump`: `bump.py` no longer hangs on a stdin that stays open, whether it sends nothing or only part of the JSON. Stdin is read until it closes, however slowly the JSON arrives; if it goes silent for `BUMP_STDIN_IDLE_SECONDS` first, the bump stops with an error and changes nothing, instead of hanging or silently dropping the entries. Piped JSON (`echo … | bump.py patch`) works as before.
+- `version-bump`: the new `CHANGELOG.md` section goes above the first `## [` release heading, ignoring headings inside fenced code blocks. A leading `## [Unreleased]` section now stays on top, untouched; before, the release was inserted above it. A file whose first line is a `## [` heading is updated instead of refused (culture's vendored copy already did this), and a CHANGELOG with no release heading gets the section appended instead of a warning.
+
 ## [0.26.22] - 2026-10-24
 
 ### Added

{guild_cli-0.26.22 → guild_cli-0.26.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: guild-cli
-Version: 0.26.22
+Version: 0.26.23
 Summary: guildmaster — an agent and CLI that manages skills for the AgentCulture mesh.
 Project-URL: Homepage, https://github.com/agentculture/guildmaster
 Project-URL: Issues, https://github.com/agentculture/guildmaster/issues

{guild_cli-0.26.22 → guild_cli-0.26.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "guild-cli"
-version = "0.26.22"
+version = "0.26.23"
 description = "guildmaster — an agent and CLI that manages skills for the AgentCulture mesh."
 readme = "README.md"
 license = "Apache-2.0"

guild_cli-0.26.23/tests/test_version_bump_script.py

@@ -0,0 +1,224 @@
+"""Behavioural tests for the vendored ``version-bump`` skill's ``bump.py``.
+
+``bump.py`` is broadcast to every sibling, so these run the *actual* script in
+a throwaway repo (a ``pyproject.toml`` + ``CHANGELOG.md``) as a subprocess.
+The contract that matters:
+
+- changelog JSON piped on stdin lands in the new section, however slowly it
+  arrives, as long as the producer keeps writing and then closes stdin;
+- a stdin held open without input (a daemon or harness pipe) never hangs the
+  bump and never silently drops entries: it stops with an error and changes
+  nothing, unless ``--no-stdin`` / ``BUMP_NO_STDIN=1`` says no input is coming;
+- the new section goes above the first ``## [`` release heading: a leading
+  ``## [Unreleased]`` stays on top untouched, and ``## [`` lines in code
+  fences or a stray mid-file Unreleased heading are not insertion points.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import time
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+BUMP = REPO_ROOT / ".claude" / "skills" / "version-bump" / "scripts" / "bump.py"
+TODAY = date.today().isoformat()
+FAST_IDLE = {"BUMP_STDIN_IDLE_SECONDS": "0.2"}
+
+
+def _repo(tmp_path: Path, changelog: str = "# Changelog\n\n## [0.1.0] - 2026-01-01\n") -> Path:
+    (tmp_path / "pyproject.toml").write_text('[project]\nname = "x"\nversion = "0.1.0"\n')
+    (tmp_path / "CHANGELOG.md").write_text(changelog)
+    return tmp_path
+
+
+def _env(**extra: str) -> dict:
+    env = {k: v for k, v in os.environ.items() if not k.startswith("BUMP_")}
+    env.update(extra)
+    return env
+
+
+def _bump(repo: Path, stdin: str = "", *args: str, **env: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, str(BUMP), "patch", *args],
+        cwd=repo,
+        input=stdin,
+        capture_output=True,
+        text=True,
+        timeout=30,
+        env=_env(**env),
+    )
+
+
+def _bump_with_open_stdin(repo: Path, *args: str, first: str = "", **env: str):
+    """Run a bump whose stdin stays open (optionally after writing ``first``)."""
+    proc = subprocess.Popen(
+        [sys.executable, str(BUMP), "patch", *args],
+        cwd=repo,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=_env(**env),
+    )
+    try:
+        if first:
+            proc.stdin.write(first)
+            proc.stdin.flush()
+        proc.wait(timeout=30)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        raise
+    finally:
+        proc.stdin.close()
+        out, err = proc.stdout.read(), proc.stderr.read()
+        proc.stdout.close()
+        proc.stderr.close()
+    return proc.returncode, out, err
+
+
+def _unchanged(repo: Path, changelog: str = "# Changelog\n\n## [0.1.0] - 2026-01-01\n") -> bool:
+    return (
+        'version = "0.1.0"' in (repo / "pyproject.toml").read_text()
+        and (repo / "CHANGELOG.md").read_text() == changelog
+    )
+
+
+# ---- stdin -------------------------------------------------------------------
+
+
+def test_piped_entries_land_in_the_new_section(tmp_path):
+    repo = _repo(tmp_path)
+    result = _bump(repo, '{"fixed": ["The bug"]}')
+    assert result.returncode == 0, result.stderr
+    assert "0.1.0 -> 0.1.1" in result.stdout
+    assert 'version = "0.1.1"' in (repo / "pyproject.toml").read_text()
+    text = (repo / "CHANGELOG.md").read_text()
+    assert text == (
+        f"# Changelog\n\n## [0.1.1] - {TODAY}\n\n### Fixed\n\n- The bug\n\n"
+        "## [0.1.0] - 2026-01-01\n"
+    )
+
+
+def test_slow_producer_that_keeps_writing_is_read_in_full(tmp_path):
+    # Review of #149: a fixed wait dropped JSON from a producer slower than it.
+    repo = _repo(tmp_path)
+    proc = subprocess.Popen(
+        [sys.executable, str(BUMP), "patch"],
+        cwd=repo,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=_env(BUMP_STDIN_IDLE_SECONDS="1"),
+    )
+    for part in ('{"fixed": ', '["Slow"]', "}"):
+        time.sleep(0.4)  # total 1.2 s: longer than the idle wait, but never idle that long
+        proc.stdin.write(part)
+        proc.stdin.flush()
+    out, err = proc.communicate(timeout=30)
+    assert proc.returncode == 0, err
+    assert "- Slow" in (repo / "CHANGELOG.md").read_text()
+
+
+def test_idle_open_stdin_stops_with_an_error_and_changes_nothing(tmp_path):
+    repo = _repo(tmp_path)
+    code, _, err = _bump_with_open_stdin(repo, **FAST_IDLE)
+    assert code != 0
+    assert "--no-stdin" in err
+    assert _unchanged(repo)
+
+
+def test_partial_input_then_held_open_stops_instead_of_hanging(tmp_path):
+    repo = _repo(tmp_path)
+    code, _, err = _bump_with_open_stdin(repo, first='{"fixed": ["x"', **FAST_IDLE)
+    assert code != 0
+    assert "never closed" in err
+    assert _unchanged(repo)
+
+
+@pytest.mark.parametrize("how", ["flag", "env"])
+def test_no_stdin_skips_reading_and_writes_the_stub(tmp_path, how):
+    repo = _repo(tmp_path)
+    args, env = (("--no-stdin",), {}) if how == "flag" else ((), {"BUMP_NO_STDIN": "1"})
+    start = time.monotonic()
+    code, out, err = _bump_with_open_stdin(repo, *args, BUMP_STDIN_IDLE_SECONDS="60", **env)
+    assert code == 0, err
+    assert time.monotonic() - start < 20  # never waited on the open pipe
+    assert "0.1.0 -> 0.1.1" in out
+    assert "### Added\n\n### Changed\n\n### Fixed\n" in (repo / "CHANGELOG.md").read_text()
+
+
+@pytest.mark.parametrize("value", ["soon", "0", "-1", "nan", "inf"])
+def test_invalid_idle_seconds_is_rejected(tmp_path, value):
+    repo = _repo(tmp_path)
+    result = _bump(repo, "", BUMP_STDIN_IDLE_SECONDS=value)
+    assert result.returncode != 0
+    assert "BUMP_STDIN_IDLE_SECONDS" in result.stderr
+    assert _unchanged(repo)
+
+
+# ---- CHANGELOG insertion -----------------------------------------------------
+
+
+def test_changelog_starting_with_a_section_is_still_updated(tmp_path):
+    repo = _repo(tmp_path, changelog="## [0.1.0] - 2026-01-01\n")
+    assert _bump(repo).returncode == 0
+    assert (repo / "CHANGELOG.md").read_text().startswith(f"## [0.1.1] - {TODAY}\n")
+
+
+def test_leading_unreleased_stays_on_top_untouched(tmp_path):
+    # Unreleased content in consumer repos is often stale or a placeholder, so
+    # it is never moved into a release automatically.
+    unreleased = "## [Unreleased]\n\nNote.\n\n### Fixed\n\n- Pending\n\n"
+    repo = _repo(tmp_path, changelog=f"# Changelog\n\n{unreleased}## [0.1.0] - 2026-01-01\n")
+    result = _bump(repo, '{"fixed": ["From stdin"]}')
+    assert result.returncode == 0, result.stderr
+    assert (repo / "CHANGELOG.md").read_text() == (
+        f"# Changelog\n\n{unreleased}## [0.1.1] - {TODAY}\n\n### Fixed\n\n- From stdin\n\n"
+        "## [0.1.0] - 2026-01-01\n"
+    )
+
+
+def test_unreleased_only_changelog_gets_the_section_after_it(tmp_path):
+    repo = _repo(tmp_path, changelog="# Changelog\n\n## [Unreleased]\n\n- Pending\n")
+    assert _bump(repo, '{"fixed": ["Bug"]}').returncode == 0
+    assert (repo / "CHANGELOG.md").read_text() == (
+        f"# Changelog\n\n## [Unreleased]\n\n- Pending\n\n## [0.1.1] - {TODAY}\n\n"
+        "### Fixed\n\n- Bug\n"
+    )
+
+
+def test_empty_leading_unreleased_stays_on_top(tmp_path):
+    repo = _repo(tmp_path, changelog="# Changelog\n\n## [Unreleased]\n\n## [0.1.0] - 2026-01-01\n")
+    assert _bump(repo, '{"fixed": ["Bug"]}').returncode == 0
+    assert (repo / "CHANGELOG.md").read_text() == (
+        f"# Changelog\n\n## [Unreleased]\n\n## [0.1.1] - {TODAY}\n\n### Fixed\n\n- Bug\n\n"
+        "## [0.1.0] - 2026-01-01\n"
+    )
+
+
+def test_stray_mid_file_unreleased_and_fenced_headings_are_not_insertion_points(tmp_path):
+    changelog = (
+        "# Changelog\n\nEntries look like:\n\n```markdown\n## [1.2.3] - 2026-01-01\n```\n\n"
+        "## [0.1.0] - 2026-01-01\n\n## [Unreleased]\n\n## [0.0.1] - 2025-01-01\n"
+    )
+    repo = _repo(tmp_path, changelog=changelog)
+    assert _bump(repo, '{"fixed": ["Bug"]}').returncode == 0
+    text = (repo / "CHANGELOG.md").read_text()
+    assert text.index("```\n\n## [0.1.1]") < text.index("## [0.1.0]")
+    assert text.count("## [Unreleased]") == 1
+    assert text.endswith("## [0.1.0] - 2026-01-01\n\n## [Unreleased]\n\n## [0.0.1] - 2025-01-01\n")
+
+
+def test_changelog_without_a_version_heading_gets_the_section_appended(tmp_path):
+    repo = _repo(tmp_path, changelog="# Changelog\n\nAll notable changes.\n")
+    assert _bump(repo, '{"fixed": ["Bug"]}').returncode == 0
+    assert (repo / "CHANGELOG.md").read_text() == (
+        f"# Changelog\n\nAll notable changes.\n\n## [0.1.1] - {TODAY}\n\n### Fixed\n\n- Bug\n"
+    )

{guild_cli-0.26.22 → guild_cli-0.26.23}/uv.lock

@@ -179,7 +179,7 @@ wheels = [
 
 [[package]]
 name = "guild-cli"
-version = "0.26.22"
+version = "0.26.23"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },