scriv-release 0.2.2__tar.gz

scriv_release-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuichiro Tachibana (Tsuchiya)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

scriv_release-0.2.2/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: scriv-release
+Version: 0.2.2
+Summary: Changesets-style release automation on top of scriv
+Author: Yuichiro Tachibana (Tsuchiya)
+Author-email: Yuichiro Tachibana (Tsuchiya) <t.yic.yt@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Dist: scriv>=1.7
+Requires-Dist: tomli>=2.0 ; python_full_version < '3.11'
+Requires-Dist: scriv-release[bump-my-version,hatch] ; extra == 'all'
+Requires-Dist: bump-my-version>=0.28 ; extra == 'bump-my-version'
+Requires-Dist: hatch>=1.12 ; extra == 'hatch'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/whitphx/scriv-release
+Project-URL: Issues, https://github.com/whitphx/scriv-release/issues
+Provides-Extra: all
+Provides-Extra: bump-my-version
+Provides-Extra: hatch
+Description-Content-Type: text/markdown
+
+# scriv-release
+
+Changesets-style release automation on top of [`scriv`](https://github.com/nedbat/scriv).
+
+`scriv` already manages per-PR changelog fragments. `scriv-release` adds the missing pieces for fully automated releases:
+
+1. A **policy** for mapping changelog categories to semver bump levels.
+2. **Orchestration** commands (`bump-level`, `next-version`, `collect`, `tag`) that wrap `scriv` and a configurable version provider.
+3. A **GitHub Action** that opens a "Changelog Preview" PR when fragments are pending, and tags a release once that PR is merged — the same flow popularized by [Changesets](https://github.com/changesets/changesets) in the JS ecosystem.
+
+## Quickstart
+
+```bash
+pip install "scriv-release[bump-my-version]"
+```
+
+```toml
+# pyproject.toml
+[tool.scriv-release]
+version_provider = "bump-my-version"
+```
+
+In your repo's `.github/workflows/release.yml`:
+
+```yaml
+on:
+  push:
+    branches: [main]
+
+jobs:
+  release:
+    uses: whitphx/scriv-release/.github/workflows/reusable.yml@v1
+    secrets:
+      app-id: ${{ vars.RELEASE_APP_ID }}
+      app-private-key: ${{ secrets.RELEASE_APP_KEY }}
+```
+
+See [`docs/quickstart.md`](docs/quickstart.md) and [`docs/token-setup.md`](docs/token-setup.md).
+
+## How it works
+
+Two phases, branched on whether changelog fragments are present on `HEAD`:
+
+- **Fragments present** → `scriv collect` into a `scriv-release-preview` branch and open/update a "Changelog Preview" PR.
+- **No fragments on `HEAD`, but fragments on `HEAD~1`** → that means the preview PR was just merged. Determine the bump level from `HEAD~1`'s fragments, tag the release, push the tag.
+
+This is the same file-presence-based detection Changesets uses, so it survives squash, rebase, and merge commits alike.
+
+## Status
+
+Early scaffold. Public API and config keys may shift before `1.0`.
+
+## License
+
+MIT — see [`LICENSE`](LICENSE).

scriv_release-0.2.2/README.md

@@ -0,0 +1,55 @@
+# scriv-release
+
+Changesets-style release automation on top of [`scriv`](https://github.com/nedbat/scriv).
+
+`scriv` already manages per-PR changelog fragments. `scriv-release` adds the missing pieces for fully automated releases:
+
+1. A **policy** for mapping changelog categories to semver bump levels.
+2. **Orchestration** commands (`bump-level`, `next-version`, `collect`, `tag`) that wrap `scriv` and a configurable version provider.
+3. A **GitHub Action** that opens a "Changelog Preview" PR when fragments are pending, and tags a release once that PR is merged — the same flow popularized by [Changesets](https://github.com/changesets/changesets) in the JS ecosystem.
+
+## Quickstart
+
+```bash
+pip install "scriv-release[bump-my-version]"
+```
+
+```toml
+# pyproject.toml
+[tool.scriv-release]
+version_provider = "bump-my-version"
+```
+
+In your repo's `.github/workflows/release.yml`:
+
+```yaml
+on:
+  push:
+    branches: [main]
+
+jobs:
+  release:
+    uses: whitphx/scriv-release/.github/workflows/reusable.yml@v1
+    secrets:
+      app-id: ${{ vars.RELEASE_APP_ID }}
+      app-private-key: ${{ secrets.RELEASE_APP_KEY }}
+```
+
+See [`docs/quickstart.md`](docs/quickstart.md) and [`docs/token-setup.md`](docs/token-setup.md).
+
+## How it works
+
+Two phases, branched on whether changelog fragments are present on `HEAD`:
+
+- **Fragments present** → `scriv collect` into a `scriv-release-preview` branch and open/update a "Changelog Preview" PR.
+- **No fragments on `HEAD`, but fragments on `HEAD~1`** → that means the preview PR was just merged. Determine the bump level from `HEAD~1`'s fragments, tag the release, push the tag.
+
+This is the same file-presence-based detection Changesets uses, so it survives squash, rebase, and merge commits alike.
+
+## Status
+
+Early scaffold. Public API and config keys may shift before `1.0`.
+
+## License
+
+MIT — see [`LICENSE`](LICENSE).

scriv_release-0.2.2/pyproject.toml

@@ -0,0 +1,60 @@
+[project]
+name = "scriv-release"
+version = "0.2.2"
+description = "Changesets-style release automation on top of scriv"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Yuichiro Tachibana (Tsuchiya)", email = "t.yic.yt@gmail.com" }
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Build Tools",
+]
+dependencies = [
+    "scriv>=1.7",
+    "tomli>=2.0; python_version<'3.11'",
+]
+
+[project.optional-dependencies]
+bump-my-version = ["bump-my-version>=0.28"]
+hatch = ["hatch>=1.12"]
+all = ["scriv-release[bump-my-version,hatch]"]
+
+[project.scripts]
+scriv-release = "scriv_release.cli:main"
+
+[project.entry-points."scriv_release.version_providers"]
+bump-my-version = "scriv_release.versioning.bump_my_version:Provider"
+hatch           = "scriv_release.versioning.hatch:Provider"
+uv              = "scriv_release.versioning.uv:Provider"
+shell           = "scriv_release.versioning.shell:Provider"
+
+[project.urls]
+Homepage = "https://github.com/whitphx/scriv-release"
+Issues = "https://github.com/whitphx/scriv-release/issues"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff>=0.6",
+    "mypy>=1.10",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.6,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+extend-select = ["I"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[[tool.mypy.overrides]]
+module = ["scriv.*"]
+follow_untyped_imports = true

scriv_release-0.2.2/src/scriv_release/__init__.py

@@ -0,0 +1,13 @@
+from .config import Config, load_config
+from .orchestrate import collect_for_release, print_changelog, tag_release
+from .policy import BumpLevel, compute_bump_level
+
+__all__ = [
+    "BumpLevel",
+    "Config",
+    "collect_for_release",
+    "compute_bump_level",
+    "load_config",
+    "print_changelog",
+    "tag_release",
+]

scriv_release-0.2.2/src/scriv_release/cli.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .config import load_config
+from .orchestrate import (
+    collect_for_release,
+    detect_release,
+    print_changelog,
+    tag_release,
+)
+from .policy import compute_bump_level
+from .versioning import get_provider
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="scriv-release")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("bump-level", help="Print the bump level (major|minor|patch).")
+    sub.add_parser("next-version", help="Print the next version string.")
+    sub.add_parser(
+        "detect-release",
+        help=(
+            "Print the bump level for an in-progress release based on "
+            "the configured detection mode, or empty if none."
+        ),
+    )
+
+    sub.add_parser("collect", help="Run scriv collect with the auto-computed version.")
+
+    p_print = sub.add_parser("print", help="Print the changelog for a version.")
+    g = p_print.add_mutually_exclusive_group(required=True)
+    g.add_argument("--next", action="store_true", dest="use_next")
+    g.add_argument("--version", default=None)
+
+    p_tag = sub.add_parser("tag", help="Bump and tag a release.")
+    p_tag.add_argument("--push", action="store_true")
+    p_tag.add_argument(
+        "--level",
+        choices=["major", "minor", "patch"],
+        default=None,
+        help="Override the level instead of inferring from current fragments.",
+    )
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    config = load_config()
+
+    if args.cmd == "bump-level":
+        level = compute_bump_level(config=config)
+        if level:
+            print(level)
+        return 0
+
+    if args.cmd == "detect-release":
+        level = detect_release(config=config)
+        if level:
+            print(level)
+        return 0
+
+    if args.cmd == "next-version":
+        level = compute_bump_level(config=config)
+        if level is None:
+            print("No version bump needed.", file=sys.stderr)
+            return 0
+        print(get_provider(config.version_provider).next(level))
+        return 0
+
+    if args.cmd == "collect":
+        next_version = collect_for_release(config=config)
+        if next_version is None:
+            print("No fragments to collect.", file=sys.stderr)
+            return 0
+        print(next_version)
+        return 0
+
+    if args.cmd == "print":
+        if args.use_next:
+            level = compute_bump_level(config=config)
+            if level is None:
+                return 0
+            version = get_provider(config.version_provider).next(level)
+        else:
+            version = args.version
+        sys.stdout.write(print_changelog(version=version))
+        return 0
+
+    if args.cmd == "tag":
+        level = args.level or compute_bump_level(config=config)
+        if level is None:
+            print("No version bump needed.", file=sys.stderr)
+            return 0
+        tag_release(level=level, config=config, push=args.push)
+        return 0
+
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scriv_release-0.2.2/src/scriv_release/config.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+UnknownCategoryPolicy = Literal["warn", "error", "patch"]
+ReleaseDetection = Literal["history", "pr-body-marker", "auto"]
+
+
+_DEFAULT_CATEGORY_MAP: dict[str, str] = {
+    "Added": "minor",
+    "Changed": "minor",
+    "Deprecated": "minor",
+    "Removed": "major",
+    "Fixed": "patch",
+    "Security": "patch",
+    "Chore": "patch",
+}
+
+
+@dataclass(frozen=True)
+class Config:
+    category_semver_map: dict[str, str] = field(
+        default_factory=lambda: dict(_DEFAULT_CATEGORY_MAP)
+    )
+    unknown_category_policy: UnknownCategoryPolicy = "warn"
+    version_provider: str = "bump-my-version"
+    preview_branch: str = "scriv-release-preview"
+    release_detection: ReleaseDetection = "history"
+    pr_body_marker_key: str = "scriv-release-bump"
+
+
+def load_config(pyproject_path: Path | None = None) -> Config:
+    path = pyproject_path or Path("pyproject.toml")
+    if not path.exists():
+        return Config()
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    section = data.get("tool", {}).get("scriv-release", {})
+    return Config(
+        category_semver_map=dict(
+            section.get("category_semver_map", _DEFAULT_CATEGORY_MAP)
+        ),
+        unknown_category_policy=section.get("unknown_category_policy", "warn"),
+        version_provider=section.get("version_provider", "bump-my-version"),
+        preview_branch=section.get("preview_branch", "scriv-release-preview"),
+        release_detection=section.get("release_detection", "history"),
+        pr_body_marker_key=section.get("pr_body_marker_key", "scriv-release-bump"),
+    )

scriv_release-0.2.2/src/scriv_release/orchestrate.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+
+from .config import Config, load_config
+from .policy import BumpLevel, compute_bump_level
+from .versioning import get_provider
+
+
+def collect_for_release(*, config: Config) -> str | None:
+    level = compute_bump_level(config=config)
+    if level is None:
+        return None
+    provider = get_provider(config.version_provider)
+    next_version = provider.next(level)
+    subprocess.run(
+        ["scriv", "collect", "--version", next_version],
+        check=True,
+    )
+    return next_version
+
+
+def print_changelog(*, version: str) -> str:
+    result = subprocess.run(
+        ["scriv", "print", "--version", version],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout
+
+
+def tag_release(*, level: BumpLevel, config: Config, push: bool = False) -> str:
+    provider = get_provider(config.version_provider)
+    return provider.apply(level, tag=True, commit=False, push=push)
+
+
+def parse_marker(body: str, *, key: str) -> BumpLevel | None:
+    pattern = re.compile(
+        rf"^[ \t]*{re.escape(key)}[ \t]*:[ \t]*(major|minor|patch)[ \t]*$",
+        re.MULTILINE | re.IGNORECASE,
+    )
+    match = pattern.search(body)
+    if match is None:
+        return None
+    return match.group(1).lower()  # type: ignore[return-value]
+
+
+def detect_release(*, config: Config) -> BumpLevel | None:
+    mode = config.release_detection
+    if mode in ("pr-body-marker", "auto"):
+        body = _fetch_head_pr_body()
+        if body is not None:
+            level = parse_marker(body, key=config.pr_body_marker_key)
+            if level is not None:
+                return level
+        if mode == "pr-body-marker":
+            return None
+    return _detect_via_fragment_history()
+
+
+def _fetch_head_pr_body() -> str | None:
+    repo = os.environ.get("GITHUB_REPOSITORY")
+    if not repo:
+        return None
+    head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    result = subprocess.run(
+        [
+            "gh",
+            "api",
+            f"/repos/{repo}/commits/{head}/pulls",
+            "--jq",
+            ".[0].body // empty",
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    body = result.stdout.strip()
+    return body or None
+
+
+def _detect_via_fragment_history() -> BumpLevel | None:
+    head = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    subprocess.run(["git", "checkout", "--quiet", "HEAD~1"], check=True)
+    try:
+        return compute_bump_level(config=load_config())
+    finally:
+        subprocess.run(["git", "checkout", "--quiet", head], check=True)

scriv_release-0.2.2/src/scriv_release/policy.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import warnings
+from typing import Literal
+
+from scriv.scriv import Scriv
+
+from .config import Config
+
+BumpLevel = Literal["major", "minor", "patch"]
+
+_PRECEDENCE: tuple[BumpLevel, ...] = ("major", "minor", "patch")
+
+
+def compute_bump_level(*, config: Config) -> BumpLevel | None:
+    scriv = Scriv()
+    fragments = scriv.fragments_to_combine()
+    if not fragments:
+        return None
+
+    entries = scriv.combine_fragments(fragments)
+    levels: set[BumpLevel] = set()
+    for category in entries.keys():
+        mapped = (
+            config.category_semver_map.get(category) if category is not None else None
+        )
+        if mapped is not None:
+            levels.add(mapped)  # type: ignore[arg-type]
+            continue
+        if config.unknown_category_policy == "error":
+            raise ValueError(f"Unknown changelog category: {category!r}")
+        if config.unknown_category_policy == "warn":
+            warnings.warn(
+                f"Unknown changelog category {category!r}; treating as 'patch'.",
+                stacklevel=2,
+            )
+        levels.add("patch")
+
+    for level in _PRECEDENCE:
+        if level in levels:
+            return level
+    return None

scriv_release-0.2.2/src/scriv_release/versioning/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from importlib.metadata import entry_points
+from typing import Protocol, runtime_checkable
+
+from ..policy import BumpLevel
+
+
+@runtime_checkable
+class VersionProvider(Protocol):
+    name: str
+
+    def current(self) -> str: ...
+    def next(self, level: BumpLevel) -> str: ...
+    def apply(
+        self,
+        level: BumpLevel,
+        *,
+        tag: bool = True,
+        commit: bool = False,
+        push: bool = False,
+    ) -> str: ...
+
+
+def get_provider(name: str) -> VersionProvider:
+    matches = entry_points(group="scriv_release.version_providers", name=name)
+    if not matches:
+        raise LookupError(f"No version provider registered as {name!r}")
+    cls = next(iter(matches)).load()
+    return cls()

scriv_release-0.2.2/src/scriv_release/versioning/_git.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import subprocess
+
+
+def finalize(
+    new_version: str,
+    *,
+    tag: bool,
+    commit: bool,
+    push: bool,
+    tag_format: str = "v{version}",
+) -> None:
+    tag_name = tag_format.format(version=new_version)
+    if commit:
+        subprocess.run(["git", "add", "-A"], check=True)
+        subprocess.run(
+            ["git", "commit", "-m", f"Release {tag_name}"],
+            check=True,
+        )
+    if tag:
+        subprocess.run(["git", "tag", tag_name], check=True)
+    if push:
+        subprocess.run(["git", "push", "--follow-tags"], check=True)

scriv_release-0.2.2/src/scriv_release/versioning/_semver.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from packaging.version import Version
+
+from ..policy import BumpLevel
+
+
+def bump_semver(current: str, level: BumpLevel) -> str:
+    v = Version(current)
+    if level == "major":
+        return f"{v.major + 1}.0.0"
+    if level == "minor":
+        return f"{v.major}.{v.minor + 1}.0"
+    return f"{v.major}.{v.minor}.{v.micro + 1}"

scriv_release-0.2.2/src/scriv_release/versioning/bump_my_version.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import subprocess
+
+from ..policy import BumpLevel
+
+
+class Provider:
+    name = "bump-my-version"
+
+    def current(self) -> str:
+        return _run("bump-my-version", "show", "current_version").strip()
+
+    def next(self, level: BumpLevel) -> str:
+        return _run(
+            "bump-my-version", "show", "--increment", level, "new_version"
+        ).strip()
+
+    def apply(
+        self,
+        level: BumpLevel,
+        *,
+        tag: bool = True,
+        commit: bool = False,
+        push: bool = False,
+    ) -> str:
+        args = ["bump-my-version", "bump", level, "--verbose"]
+        if tag:
+            args.append("--tag")
+        if not commit:
+            args.append("--no-commit")
+        _run(*args)
+        new_version = self.current()
+        if push:
+            subprocess.run(["git", "push", "--follow-tags"], check=True)
+        return new_version
+
+
+def _run(*args: str) -> str:
+    result = subprocess.run(args, check=True, capture_output=True, text=True)
+    return result.stdout

scriv_release-0.2.2/src/scriv_release/versioning/hatch.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import subprocess
+
+from ..policy import BumpLevel
+from . import _git
+from ._semver import bump_semver
+
+
+class Provider:
+    name = "hatch"
+
+    def current(self) -> str:
+        return _run("hatch", "version").strip()
+
+    def next(self, level: BumpLevel) -> str:
+        return bump_semver(self.current(), level)
+
+    def apply(
+        self,
+        level: BumpLevel,
+        *,
+        tag: bool = True,
+        commit: bool = False,
+        push: bool = False,
+    ) -> str:
+        new_version = self.next(level)
+        _run("hatch", "version", level)
+        _git.finalize(new_version, tag=tag, commit=commit, push=push)
+        return new_version
+
+
+def _run(*args: str) -> str:
+    result = subprocess.run(args, check=True, capture_output=True, text=True)
+    return result.stdout

scriv_release-0.2.2/src/scriv_release/versioning/shell.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from ..policy import BumpLevel
+from . import _git
+from ._semver import bump_semver
+
+
+class Provider:
+    name = "shell"
+
+    def __init__(self) -> None:
+        self._cmds = _load_commands()
+
+    def current(self) -> str:
+        return _run(self._require("current")).strip()
+
+    def next(self, level: BumpLevel) -> str:
+        cmd = self._cmds.get("next")
+        if cmd:
+            return _run(cmd, env={"LEVEL": level}).strip()
+        return bump_semver(self.current(), level)
+
+    def apply(
+        self,
+        level: BumpLevel,
+        *,
+        tag: bool = True,
+        commit: bool = False,
+        push: bool = False,
+    ) -> str:
+        new_version = self.next(level)
+        _run(
+            self._require("apply"),
+            env={"LEVEL": level, "NEW_VERSION": new_version},
+        )
+        _git.finalize(new_version, tag=tag, commit=commit, push=push)
+        return new_version
+
+    def _require(self, key: str) -> str:
+        cmd = self._cmds.get(key)
+        if not cmd:
+            raise RuntimeError(
+                f"shell provider requires [tool.scriv-release.shell].{key} "
+                "in pyproject.toml"
+            )
+        return cmd
+
+
+def _load_commands(pyproject_path: Path | None = None) -> dict[str, str]:
+    path = pyproject_path or Path("pyproject.toml")
+    if not path.exists():
+        return {}
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    section = data.get("tool", {}).get("scriv-release", {}).get("shell", {})
+    return {k: str(v) for k, v in section.items()}
+
+
+def _run(command: str, *, env: dict[str, str] | None = None) -> str:
+    merged = {**os.environ, **(env or {})}
+    result = subprocess.run(
+        command,
+        shell=True,
+        check=True,
+        capture_output=True,
+        text=True,
+        env=merged,
+    )
+    return result.stdout

scriv_release-0.2.2/src/scriv_release/versioning/uv.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import subprocess
+
+from ..policy import BumpLevel
+from . import _git
+
+
+class Provider:
+    name = "uv"
+
+    def current(self) -> str:
+        return _run("uv", "version", "--short").strip()
+
+    def next(self, level: BumpLevel) -> str:
+        return _run("uv", "version", "--bump", level, "--dry-run", "--short").strip()
+
+    def apply(
+        self,
+        level: BumpLevel,
+        *,
+        tag: bool = True,
+        commit: bool = False,
+        push: bool = False,
+    ) -> str:
+        new_version = _run(
+            "uv", "version", "--bump", level, "--short", "--frozen"
+        ).strip()
+        _git.finalize(new_version, tag=tag, commit=commit, push=push)
+        return new_version
+
+
+def _run(*args: str) -> str:
+    result = subprocess.run(args, check=True, capture_output=True, text=True)
+    return result.stdout