release-kit 0.1.0__py3-none-any.whl

release_kit/__init__.py

@@ -0,0 +1,35 @@
+from .config import AppConfig, PackageConfig, PublishConfig, load_config, select_packages
+from .feeds import Feed, NuGetFeed, NpmFeed, PublishRequest, build_feeds, pep440_dev_version, semver_dev_version
+from .ledger import GitLedger
+from .plan import (
+    PackagePlan,
+    TagLedger,
+    compute_plan,
+    next_version,
+    render_dev_summary,
+    render_summary,
+    resolved_dependency_versions,
+)
+
+__all__ = [
+    "AppConfig",
+    "Feed",
+    "GitLedger",
+    "NpmFeed",
+    "NuGetFeed",
+    "PackageConfig",
+    "PackagePlan",
+    "PublishConfig",
+    "PublishRequest",
+    "TagLedger",
+    "build_feeds",
+    "compute_plan",
+    "load_config",
+    "next_version",
+    "pep440_dev_version",
+    "render_dev_summary",
+    "render_summary",
+    "resolved_dependency_versions",
+    "select_packages",
+    "semver_dev_version",
+]

release_kit/config.py

@@ -0,0 +1,81 @@
+from collections.abc import Sequence
+from pathlib import Path
+
+from pydantic import BaseModel, Field, model_validator
+
+from .feeds import KNOWN_FEEDS
+
+
+class PackageConfig(BaseModel):
+    name: str
+    path: Path
+    feeds: dict[str, str] = Field(default_factory=dict)
+    depends_on: list[str] = Field(default_factory=list)
+    dependency_pins: dict[str, str] = Field(default_factory=dict)
+
+
+class AppConfig(BaseModel):
+    name: str
+    path: Path
+    tag_prefix: str
+    display_name: str
+
+
+class PublishConfig(BaseModel):
+    packages: list[PackageConfig]
+    apps: list[AppConfig] = Field(default_factory=list)
+    compose_files: list[str] = Field(default_factory=list)
+    ci_workflow: str
+    mirror_prefix: str
+    artifact_dir: Path = Path("/tmp/release-artifacts")
+    artifact_skip_prefixes: list[str] = Field(default_factory=lambda: ["env-lock-", "versions"])
+    artifact_skip_suffixes: list[str] = Field(default_factory=lambda: ["-build-report"])
+
+    @model_validator(mode="after")
+    def validate_dependency_graph(self) -> "PublishConfig":
+        seen: set[str] = set()
+        for package in self.packages:
+            for dependency in package.depends_on:
+                if dependency not in seen:
+                    if dependency in {p.name for p in self.packages}:
+                        message = f"package '{package.name}' depends on '{dependency}', which appears later in the list; packages must be ordered dependencies-first"
+                    else:
+                        message = f"package '{package.name}' depends on unknown package '{dependency}'"
+                    raise ValueError(message)
+            seen.add(package.name)
+
+        names = {package.name for package in self.packages}
+        for package in self.packages:
+            for pinned in package.dependency_pins.values():
+                if pinned not in names:
+                    raise ValueError(f"package '{package.name}' pins unknown package '{pinned}'")
+
+        return self
+
+    @model_validator(mode="after")
+    def validate_feed_names(self) -> "PublishConfig":
+        for package in self.packages:
+            unknown_feeds = set(package.feeds) - KNOWN_FEEDS
+            if unknown_feeds:
+                raise ValueError(f"package '{package.name}' declares unknown feeds: {sorted(unknown_feeds)}")
+        return self
+
+
+def load_config(path: Path) -> PublishConfig:
+    return PublishConfig.model_validate_json(path.read_text(encoding="utf-8"))
+
+
+def select_packages(packages: list[PackageConfig], only: Sequence[str], exclude: Sequence[str]) -> list[PackageConfig]:
+    if only and exclude:
+        raise SystemExit("--only and --exclude are mutually exclusive")
+    names = [package.name for package in packages]
+    for requested in [*only, *exclude]:
+        if requested not in names:
+            raise SystemExit(f"Unknown package '{requested}'. Valid: {', '.join(names)}")
+    if only:
+        selected = set(only)
+        return [package for package in packages if package.name in selected]
+    if exclude:
+        deselected = set(exclude)
+        return [package for package in packages if package.name not in deselected]
+    return packages

release_kit/create_release.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import shutil
+from datetime import UTC, datetime
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Annotated
+
+import typer
+from bashrun import bash, bash_output
+from pydantic_settings import BaseSettings
+from stack_toolkit.context_sha import compute_service_shas
+from unity_buildkit.ci_step import ci_step
+
+from .config import PublishConfig, load_config
+from .ledger import GitLedger
+from .plan import UNCHANGED_FALLBACK_VERSION
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+class Settings(BaseSettings):
+    github_repository: str
+
+
+def _package_artifacts(config: PublishConfig) -> list[Path]:
+    artifact_dir = config.artifact_dir
+    assets: list[Path] = []
+    if not artifact_dir.is_dir():
+        print("No release artifacts directory found")
+        return assets
+
+    for entry in sorted(artifact_dir.iterdir()):
+        if not entry.is_dir():
+            continue
+        if any(entry.name.startswith(p) for p in config.artifact_skip_prefixes):
+            print(f"  Skipping: {entry.name} (not a release artifact)")
+            continue
+        if any(entry.name.endswith(s) for s in config.artifact_skip_suffixes):
+            print(f"  Skipping: {entry.name} (not a release artifact)")
+            continue
+
+        files = [f for f in entry.rglob("*") if f.is_file()]
+        if not files:
+            print(f"  Skipping: {entry.name} (empty)")
+            continue
+
+        if len(files) == 1:
+            asset = artifact_dir / f"{entry.name}{files[0].suffix}"
+            shutil.copy2(files[0], asset)
+            assets.append(asset)
+            print(f"  Asset: {asset.name}")
+        else:
+            zip_path = artifact_dir / entry.name
+            shutil.make_archive(str(zip_path), "zip", entry)
+            asset = zip_path.parent / f"{zip_path.name}.zip"
+            assets.append(asset)
+            print(f"  Asset: {asset.name} ({len(files)} files)")
+
+    return assets
+
+
+def _nuget_url(identity: str, version: str) -> str:
+    return f"https://www.nuget.org/packages/{identity}/{version}"
+
+
+def _npm_url(identity: str, version: str) -> str:
+    return f"https://www.npmjs.com/package/{identity}/v/{version}"
+
+
+def _pypi_url(identity: str, version: str) -> str:
+    return f"https://pypi.org/project/{identity}/{version}"
+
+
+FEED_URLS = {"nuget": _nuget_url, "npm": _npm_url, "pypi": _pypi_url}
+
+
+def _build_release_notes(config: PublishConfig, service_shas: dict[str, str], ghcr_url: str) -> str:
+    ledger = GitLedger()
+    lines: list[str] = []
+
+    if service_shas:
+        lines.extend([
+            "## Docker images",
+            "",
+            f"Images on [GHCR]({ghcr_url}), per-service tags:",
+            "",
+            "| Env var | Tag |",
+            "|---|---|",
+        ])
+        for var, sha in sorted(service_shas.items()):
+            lines.append(f"| `{var}` | `{sha}` |")
+        lines.append("")
+
+    lines.extend(["## Packages", "", "| Package | Version | Registry |", "|---|---|---|"])
+    for package in config.packages:
+        version = ledger.latest_version(f"{package.name}-v") or UNCHANGED_FALLBACK_VERSION
+        links: list[str] = []
+        for feed_name, identity in package.feeds.items():
+            url_builder = FEED_URLS.get(feed_name)
+            if url_builder is None:
+                links.append(feed_name)
+            elif version != UNCHANGED_FALLBACK_VERSION:
+                links.append(f"[{feed_name}]({url_builder(identity, version)})")
+            else:
+                links.append(feed_name)
+        display = package.name
+        lines.append(f"| {display} | {version} | {', '.join(links)} |")
+
+    for app_config in config.apps:
+        version = ledger.latest_version(f"{app_config.tag_prefix}-v")
+        if version:
+            lines.append(f"| {app_config.display_name} | {version} | — |")
+
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _next_release_tag(repo: str) -> str:
+    today = datetime.now(UTC).strftime("%Y-%m-%d")
+    existing = bash_output(
+        f"gh release list --repo {repo} --json tagName --jq '[.[].tagName] | map(select(startswith(\"{today}\"))) | length'"
+    ).strip()
+    count = int(existing) if existing else 0
+    return f"{today}.{count + 1}" if count > 0 else today
+
+
+@app.command()
+def main(config: Annotated[Path, typer.Option(help="Publish configuration JSON")]) -> None:
+    settings = Settings.model_validate({})
+    publish_config = load_config(config)
+    tag = _next_release_tag(settings.github_repository)
+
+    with ci_step("Compute service SHAs"):
+        service_shas: dict[str, str] = {}
+        for compose_file in publish_config.compose_files:
+            service_shas.update(compute_service_shas(Path.cwd(), Path(compose_file)))
+        for var, sha in sorted(service_shas.items()):
+            print(f"  {var}={sha}")
+
+    with ci_step("Package artifacts"):
+        assets = _package_artifacts(publish_config)
+        if assets:
+            print(f"  {len(assets)} asset(s) ready for upload")
+        else:
+            print("  No build artifacts to attach")
+
+    with ci_step("Create GitHub Release"):
+        owner, repository = settings.github_repository.split("/", maxsplit=1)
+        ghcr_url = f"https://github.com/orgs/{owner}/packages?repo_name={repository}"
+        notes = _build_release_notes(publish_config, service_shas, ghcr_url)
+        print(notes)
+
+        asset_args = " ".join(f'"{a}"' for a in assets)
+        with NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as file:
+            file.write(notes)
+            notes_path = file.name
+        bash(
+            f"gh release create {tag} --title {tag}"
+            f" --notes-file {notes_path}"
+            f" --repo {settings.github_repository}"
+            f" {asset_args}"
+        )
+        Path(notes_path).unlink()
+        print(f"  Release created: {tag}")

release_kit/ensure_release_pr.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import typer
+from bashrun import bash_output
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+BASE_BRANCH = "main"
+
+
+@app.command()
+def main() -> None:
+    existing = bash_output(
+        f'gh pr list --head dev --base {BASE_BRANCH} --state open --json number --jq ".[0].number"'
+    ).strip()
+    if existing:
+        print(f"Release PR already exists: #{existing}")
+    else:
+        bash_output(
+            f'gh pr create --head dev --base {BASE_BRANCH} --title "Next release"'
+            ' --body "Persistent release gate PR from `dev` → `main`. Merge when ready to cut a release."'
+        )
+        print("Created release PR")

release_kit/feeds.py

@@ -0,0 +1,126 @@
+import json
+import re
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from subprocess import CalledProcessError
+from typing import Protocol
+
+from bashrun import bash, bash_output
+
+NUGET_SOURCE = "https://api.nuget.org/v3/index.json"
+PYPI_SIMPLE_INDEX = "https://pypi.org/simple/"
+PYPROJECT_VERSION_PATTERN = re.compile(r'^version\s*=\s*"[^"]*"')
+NPM_DEV_DIST_TAG = "dev"
+
+
+@dataclass(frozen=True)
+class PublishRequest:
+    path: Path
+    identity: str
+    version: str
+    dependency_versions: dict[str, str]
+    dist_tag: str | None = None
+
+
+class Feed(Protocol):
+    def publish(self, request: PublishRequest) -> None: ...
+
+
+class NuGetFeed:
+    def __init__(self, api_key: str) -> None:
+        self.api_key = api_key
+
+    def publish(self, request: PublishRequest) -> None:
+        bash(f"dotnet pack -c Release -p:Version={request.version} -o ./nupkg", cwd=request.path)
+        bash(
+            f"dotnet nuget push ./nupkg/*.nupkg --api-key {self.api_key} --source {NUGET_SOURCE} --skip-duplicate",
+            cwd=request.path,
+        )
+
+
+class NpmFeed:
+    def publish(self, request: PublishRequest) -> None:
+        command = "npm publish --access public --provenance"
+        if request.dist_tag:
+            command += f" --tag {request.dist_tag}"
+        with ephemeral_manifest_patch(request.path, request.version, request.dependency_versions):
+            try:
+                bash_output(command, cwd=request.path)
+            except CalledProcessError as e:
+                stderr = e.stderr or ""
+                if "EPUBLISHCONFLICT" in stderr or "cannot publish over existing version" in stderr:
+                    print("  Version already published, skipping (idempotent)")
+                else:
+                    raise
+
+
+class PyPIFeed:
+    def publish(self, request: PublishRequest) -> None:
+        if request.dependency_versions:
+            raise ValueError("pypi dependency pins are not supported")
+        with ephemeral_pyproject_patch(request.path, request.version):
+            bash("uv build --out-dir dist", cwd=request.path)
+        bash(f"uv publish --check-url {PYPI_SIMPLE_INDEX}", cwd=request.path)
+
+
+@contextmanager
+def ephemeral_manifest_patch(package_path: Path, version: str, dependency_versions: dict[str, str]) -> Generator[None]:
+    manifest_path = package_path / "package.json"
+    original = manifest_path.read_text(encoding="utf-8")
+    try:
+        manifest = json.loads(original)
+        manifest["version"] = version
+        for dependency_name, dependency_version in dependency_versions.items():
+            manifest["dependencies"][dependency_name] = dependency_version
+        manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+        yield
+    finally:
+        manifest_path.write_text(original, encoding="utf-8")
+
+
+@contextmanager
+def ephemeral_pyproject_patch(package_path: Path, version: str) -> Generator[None]:
+    manifest_path = package_path / "pyproject.toml"
+    original = manifest_path.read_text(encoding="utf-8")
+    try:
+        manifest_path.write_text(patch_project_version(original, version), encoding="utf-8")
+        yield
+    finally:
+        manifest_path.write_text(original, encoding="utf-8")
+
+
+def patch_project_version(original: str, version: str) -> str:
+    lines = original.splitlines(keepends=True)
+    in_project_table = False
+    for index, line in enumerate(lines):
+        if line.startswith("["):
+            in_project_table = line.strip() == "[project]"
+            continue
+        if in_project_table and PYPROJECT_VERSION_PATTERN.match(line):
+            lines[index] = f'version = "{version}"\n'
+            return "".join(lines)
+    raise ValueError("pyproject.toml carries no [project] version to patch")
+
+
+KNOWN_FEEDS = frozenset({"nuget", "npm", "pypi"})
+
+
+def semver_dev_version(base_version: str, run_id: str) -> str:
+    return f"{base_version}-dev.{run_id}"
+
+
+def pep440_dev_version(base_version: str, run_id: str) -> str:
+    return f"{base_version}.dev{run_id}"
+
+
+DEV_VERSION_FORMATS: dict[str, Callable[[str, str], str]] = {
+    "nuget": semver_dev_version,
+    "npm": semver_dev_version,
+    "pypi": pep440_dev_version,
+}
+
+
+def build_feeds(nuget_api_key: str) -> dict[str, Feed]:
+    return {"nuget": NuGetFeed(nuget_api_key), "npm": NpmFeed(), "pypi": PyPIFeed()}

release_kit/fetch_ci_artifacts.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+from shutil import rmtree
+from typing import Annotated
+
+import typer
+from bashrun import bash, bash_output
+from pydantic_settings import BaseSettings
+from unity_buildkit.ci_step import ci_step
+
+from .config import load_config
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+class Settings(BaseSettings):
+    github_sha: str
+    github_repository: str
+    github_output: str | None = None
+
+
+@app.command()
+def main(
+    config: Annotated[Path, typer.Option(help="Publish configuration JSON")],
+    ci_run_id: Annotated[str | None, typer.Option(help="Override CI run lookup with a known run ID")] = None,
+) -> None:
+    settings = Settings.model_validate({})
+    publish_config = load_config(config)
+    repo = settings.github_repository
+
+    if ci_run_id:
+        run_id = ci_run_id
+        print(f"  Using override CI run: {run_id}")
+    else:
+        sha = bash_output(f'gh api "/repos/{repo}/git/commits/{settings.github_sha}" --jq ".parents[1].sha"').strip()
+
+        with ci_step("Find successful CI run"):
+            run_id = bash_output(
+                f'gh api "/repos/{repo}/actions/workflows/{publish_config.ci_workflow}/runs'
+                f'?head_sha={sha}&status=success" --jq ".workflow_runs[0].id // empty"'
+            ).strip()
+
+            if not run_id:
+                print(f"::error::No successful CI run found for SHA {sha}. Cannot release untested code.")
+                raise typer.Exit(code=1)
+
+            print(f"  CI run: {run_id}")
+
+    if settings.github_output:
+        with Path(settings.github_output).open("a", encoding="utf-8") as file:
+            file.write(f"run_id={run_id}\n")
+
+    artifact_dir = publish_config.artifact_dir
+    with ci_step("Download artifacts"):
+        bash(f"gh run download {run_id} --repo {repo} --dir {artifact_dir}")
+
+        if not artifact_dir.is_dir():
+            print("  No artifacts downloaded")
+            return
+
+        downloaded = 0
+        for entry in sorted(artifact_dir.iterdir()):
+            if not entry.is_dir():
+                continue
+            if any(entry.name.startswith(p) for p in publish_config.artifact_skip_prefixes) or any(
+                entry.name.endswith(s) for s in publish_config.artifact_skip_suffixes
+            ):
+                print(f"  Removed: {entry.name}")
+                rmtree(entry)
+                continue
+            downloaded += 1
+            print(f"  Kept: {entry.name}")
+
+        print(f"  {downloaded} artifact(s) ready in {artifact_dir}")

release_kit/ledger.py

@@ -0,0 +1,33 @@
+import re
+from pathlib import Path
+
+from bashrun import bash, bash_check, bash_output
+
+# Prerelease-suffixed tags (e.g. 1.0.6-preview) are not stable-ledger versions: the stable flow
+# must never compute a next version from one. Dev-channel versions never enter the tag space.
+STABLE_VERSION_PATTERN = re.compile(r"^\d+\.\d+\.\d+$")
+
+
+def is_stable_version(version: str) -> bool:
+    return STABLE_VERSION_PATTERN.fullmatch(version) is not None
+
+
+class GitLedger:
+    def latest_version(self, prefix: str) -> str | None:
+        output = bash_output(f'git tag --list "{prefix}*" --sort=-v:refname').strip()
+        if not output:
+            return None
+        for tag in output.splitlines():
+            version = tag[len(prefix) :]
+            if is_stable_version(version):
+                return version
+        return None
+
+    def has_changes_since(self, tag: str | None, path: Path) -> bool:
+        if tag is None:
+            return True
+        return not bash_check(f"git diff --quiet {tag} HEAD -- {path}")
+
+    def create_and_push_tag(self, tag: str) -> None:
+        bash(f"git tag {tag}")
+        bash(f"git push origin {tag}")

release_kit/mirror_images.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from bashrun import bash
+from stack_toolkit.image_refs import collect_repo_references
+from unity_buildkit.ci_step import ci_step
+
+from .config import load_config
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+CRANE_VERSION = "v0.22.1"
+
+
+@app.command()
+def main(config: Annotated[Path, typer.Option(help="Publish configuration JSON")]) -> None:
+    publish_config = load_config(config)
+    mirror_prefix = publish_config.mirror_prefix
+    targets = {
+        occurrence.reference: occurrence.reference[len(mirror_prefix) + 1 :]
+        for occurrence in collect_repo_references(Path.cwd(), dockerfile_glob=None)
+        if occurrence.reference.startswith(f"{mirror_prefix}/")
+    }
+    with ci_step("Install crane"):
+        sudo = "sudo " if os.geteuid() != 0 else ""
+        archive = "go-containerregistry_Linux_x86_64.tar.gz"
+        bash(f"curl -fsSLO https://github.com/google/go-containerregistry/releases/download/{CRANE_VERSION}/{archive}")
+        bash(f"{sudo}tar -xzf {archive} -C /usr/local/bin crane")
+        Path(archive).unlink()
+    for mirrored, upstream in sorted(targets.items()):
+        with ci_step(f"Mirror {upstream} -> {mirrored}"):
+            bash(f"crane copy {upstream} {mirrored}")
+    print(f"Mirrored images: {len(targets)}")

release_kit/plan.py

@@ -0,0 +1,83 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+from .config import PackageConfig
+from .feeds import DEV_VERSION_FORMATS
+
+FIRST_VERSION = "0.1.0"
+UNCHANGED_FALLBACK_VERSION = "0.0.0"
+
+
+class TagLedger(Protocol):
+    def latest_version(self, prefix: str) -> str | None: ...
+
+    def has_changes_since(self, tag: str | None, path: Path) -> bool: ...
+
+
+@dataclass(frozen=True)
+class PackagePlan:
+    name: str
+    publish: bool
+    version: str
+    last_version: str | None
+
+
+def next_version(last_version: str | None) -> str:
+    if last_version is None:
+        return FIRST_VERSION
+    major, minor, patch = last_version.split(".")
+    return f"{major}.{minor}.{int(patch) + 1}"
+
+
+def compute_plan(packages: list[PackageConfig], ledger: TagLedger) -> dict[str, PackagePlan]:
+    plans: dict[str, PackagePlan] = {}
+    for package in packages:
+        last_version = ledger.latest_version(f"{package.name}-v")
+        changed = ledger.has_changes_since(f"{package.name}-v{last_version}" if last_version else None, package.path)
+        if any(plans[dependency].publish for dependency in package.depends_on):
+            changed = True
+        plans[package.name] = PackagePlan(
+            name=package.name,
+            publish=changed,
+            version=next_version(last_version) if changed else (last_version or UNCHANGED_FALLBACK_VERSION),
+            last_version=last_version,
+        )
+    return plans
+
+
+def resolved_dependency_versions(package: PackageConfig, plans: dict[str, PackagePlan]) -> dict[str, str]:
+    return {
+        dependency_name: plans[pinned_package].version
+        for dependency_name, pinned_package in package.dependency_pins.items()
+        if plans[pinned_package].publish
+    }
+
+
+def render_summary(plans: dict[str, PackagePlan]) -> str:
+    lines = [
+        "### Publish Plan",
+        "| Package | Publish | Version |",
+        "|---|---|---|",
+    ]
+    lines.extend(f"| {plan.name} | {plan.publish} | {plan.version} |" for plan in plans.values())
+    return "\n".join(lines)
+
+
+def render_dev_summary(packages: list[PackageConfig], plans: dict[str, PackagePlan], run_id: str) -> str:
+    lines = [
+        "### Dev Publish Plan",
+        "| Package | Publish | Versions |",
+        "|---|---|---|",
+    ]
+    for package in packages:
+        plan = plans[package.name]
+        if not plan.publish:
+            lines.append(f"| {plan.name} | False | - |")
+            continue
+        versions = ", ".join(
+            f"{feed_name}: {identity} @ {DEV_VERSION_FORMATS[feed_name](plan.version, run_id)}"
+            for feed_name, identity in package.feeds.items()
+        )
+        lines.append(f"| {plan.name} | True | {versions} |")
+    return "\n".join(lines)

release_kit/publish_dev.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic_settings import BaseSettings
+from unity_buildkit.ci_step import ci_step
+from unity_buildkit.setup import configure_git, free_disk_space, install_dotnet, install_node
+
+from .config import load_config, select_packages
+from .feeds import DEV_VERSION_FORMATS, NPM_DEV_DIST_TAG, PublishRequest, build_feeds
+from .ledger import GitLedger
+from .plan import compute_plan, render_dev_summary, resolved_dependency_versions
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+DEFAULT_CONFIG_PATH = Path("build/publish-config.json")
+
+
+class Settings(BaseSettings):
+    github_workspace: str = ""
+    github_step_summary: str | None = None
+    github_run_id: str = ""
+    nuget_api_key: str = ""
+
+
+def _write_summary(path: str | None, text: str) -> None:
+    if path:
+        with Path(path).open("a", encoding="utf-8") as file:
+            file.write(text + "\n")
+
+
+@app.command()
+def main(
+    config: Annotated[Path, typer.Option(help="Publish configuration JSON")] = DEFAULT_CONFIG_PATH,
+    dry_run: Annotated[bool, typer.Option(help="Plan publishes without executing them")] = False,
+    run_id: Annotated[
+        str, typer.Option(help="CI run id baked into every dev version (defaults to GITHUB_RUN_ID)")
+    ] = "",
+    only: Annotated[list[str] | None, typer.Option(help="Restrict to named packages (repeatable).")] = None,
+    exclude: Annotated[list[str] | None, typer.Option(help="Skip named packages (repeatable).")] = None,
+) -> None:
+    settings = Settings.model_validate({})
+    resolved_run_id = run_id or settings.github_run_id
+    if not resolved_run_id.isdigit():
+        raise SystemExit("dev run id must be all digits: pass --run-id or set GITHUB_RUN_ID")
+
+    publish_config = load_config(config)
+    packages = select_packages(publish_config.packages, only or [], exclude or [])
+    ledger = GitLedger()
+
+    with ci_step("Compute dev publish plan"):
+        plans = compute_plan(publish_config.packages, ledger)
+
+        summary = render_dev_summary(packages, plans, resolved_run_id)
+        print(summary)
+        _write_summary(settings.github_step_summary, summary)
+
+        if not any(plan.publish for plan in plans.values()):
+            print("Nothing to publish")
+            return
+
+        if dry_run:
+            print("Dry run — skipping publish")
+            return
+
+    with ci_step("Setup"):
+        configure_git(settings.github_workspace)
+        free_disk_space()
+        install_dotnet("8.0")
+        install_node("24", "https://registry.npmjs.org")
+
+    feeds = build_feeds(settings.nuget_api_key)
+    published: list[tuple[str, str, str]] = []
+    for package in packages:
+        plan = plans[package.name]
+        if not plan.publish:
+            continue
+        dependency_versions = resolved_dependency_versions(package, plans)
+        for feed_name, identity in package.feeds.items():
+            dev_version = DEV_VERSION_FORMATS[feed_name](plan.version, resolved_run_id)
+            with ci_step(f"Publish {feed_name} ({package.name}) {dev_version}"):
+                feeds[feed_name].publish(
+                    PublishRequest(
+                        path=package.path,
+                        identity=identity,
+                        version=dev_version,
+                        dependency_versions={
+                            dependency_name: DEV_VERSION_FORMATS[feed_name](version, resolved_run_id)
+                            for dependency_name, version in dependency_versions.items()
+                        },
+                        dist_tag=NPM_DEV_DIST_TAG if feed_name == "npm" else None,
+                    )
+                )
+            published.append((feed_name, identity, dev_version))
+
+    recap = "\n".join([
+        "### Published dev versions",
+        *(f"{feed_name}: {identity} @ {version}" for feed_name, identity, version in published),
+    ])
+    print(recap)
+    print("Consume these by exact version pin - there is no discovery tooling by design")
+    _write_summary(settings.github_step_summary, recap)

release_kit/publish_packages.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic_settings import BaseSettings
+from unity_buildkit.ci_step import ci_step
+from unity_buildkit.setup import configure_git, free_disk_space, install_dotnet, install_node
+
+from .config import load_config, select_packages
+from .feeds import PublishRequest, build_feeds
+from .ledger import GitLedger
+from .plan import compute_plan, next_version, render_summary, resolved_dependency_versions
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+DEFAULT_CONFIG_PATH = Path("build/publish-config.json")
+
+
+class Settings(BaseSettings):
+    github_workspace: str = ""
+    github_step_summary: str | None = None
+    github_output: str | None = None
+    nuget_api_key: str = ""
+
+
+def _append_output(path: str | None, line: str) -> None:
+    if path:
+        with Path(path).open("a", encoding="utf-8") as file:
+            file.write(line + "\n")
+
+
+@app.command()
+def main(
+    config: Annotated[Path, typer.Option(help="Publish configuration JSON")] = DEFAULT_CONFIG_PATH,
+    dry_run: Annotated[bool, typer.Option(help="Plan publishes without executing them")] = False,
+    only: Annotated[list[str] | None, typer.Option(help="Restrict to named packages (repeatable).")] = None,
+    exclude: Annotated[list[str] | None, typer.Option(help="Skip named packages (repeatable).")] = None,
+    with_apps: Annotated[bool, typer.Option(help="Handle app version bumps and tags in a filtered run.")] = False,
+) -> None:
+    settings = Settings.model_validate({})
+    publish_config = load_config(config)
+    packages = select_packages(publish_config.packages, only or [], exclude or [])
+    ledger = GitLedger()
+
+    with ci_step("Compute publish plan"):
+        plans = compute_plan(publish_config.packages, ledger)
+
+        summary = render_summary(plans)
+        print(summary)
+        _append_output(settings.github_step_summary, summary)
+
+        if not any(plan.publish for plan in plans.values()):
+            print("Nothing to publish")
+            return
+
+        if dry_run:
+            print("Dry run — skipping publish")
+            return
+
+    with ci_step("Setup"):
+        configure_git(settings.github_workspace)
+        free_disk_space()
+        install_dotnet("8.0")
+        install_node("24", "https://registry.npmjs.org")
+
+    feeds = build_feeds(settings.nuget_api_key)
+    for package in packages:
+        plan = plans[package.name]
+        if not plan.publish:
+            continue
+        dependency_versions = resolved_dependency_versions(package, plans)
+        for feed_name, identity in package.feeds.items():
+            with ci_step(f"Publish {feed_name} ({package.name})"):
+                feeds[feed_name].publish(
+                    PublishRequest(
+                        path=package.path,
+                        identity=identity,
+                        version=plan.version,
+                        dependency_versions=dependency_versions,
+                    )
+                )
+
+    handle_apps = (not only and not exclude) or with_apps
+    any_package_published = any(plans[package.name].publish for package in packages)
+    app_versions: dict[str, str] = {}
+    with ci_step("Compute app versions"):
+        for app_config in publish_config.apps:
+            last_version = ledger.latest_version(f"{app_config.tag_prefix}-v")
+            changed = ledger.has_changes_since(
+                f"{app_config.tag_prefix}-v{last_version}" if last_version else None, app_config.path
+            )
+            # Apps depend on packages — bump if any package changed
+            if any_package_published:
+                changed = True
+            if changed:
+                new_version = next_version(last_version)
+                app_versions[app_config.name] = new_version
+                print(f"  {app_config.name}: {last_version or '(none)'} -> {new_version}")
+            else:
+                print(f"  {app_config.name}: {last_version or '0.0.0'} (unchanged)")
+
+    with ci_step("Create version tags"):
+        for package in packages:
+            plan = plans[package.name]
+            if plan.publish:
+                tag = f"{package.name}-v{plan.version}"
+                ledger.create_and_push_tag(tag)
+                print(f"  Tagged: {tag}")
+
+        if handle_apps:
+            for app_config in publish_config.apps:
+                if app_config.name in app_versions:
+                    tag = f"{app_config.tag_prefix}-v{app_versions[app_config.name]}"
+                    ledger.create_and_push_tag(tag)
+                    print(f"  Tagged: {tag}")
+
+        _append_output(settings.github_output, "published=true")

release_kit-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: release-kit
+Version: 0.1.0
+Summary: Publication machinery: per-package tag ledger, path-diff change detection, ephemeral version patching, and per-registry feed adapters (nuget, npm/UPM) driven by a declarative consumer-owned config
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.13
+Requires-Dist: bashrun>=0.1.0
+Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: stack-toolkit>=0.1.0
+Requires-Dist: typer>=0.17.4
+Requires-Dist: unity-buildkit>=0.1.0

release_kit-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+release_kit/__init__.py,sha256=CDbeGa-o3YqUEqygWePVp3WZYK53FmAsLshF6gs3PT4,831
+release_kit/config.py,sha256=ZLP1A2iIrM6sfRpyIxst93LIJljL577fAiD-jjPRzK0,3167
+release_kit/create_release.py,sha256=fAJyJGxz7zkaAejCOjWwZCfRtVPc9KkDl5aPdnzjd-E,5912
+release_kit/ensure_release_pr.py,sha256=Pqs06fHsA26Rji-IZxfFA-2JqQrAetFRR2tgKkTvBxI,703
+release_kit/feeds.py,sha256=O41agvb3M-19TfMvoGATJPQJ58S2Nd1jD6UTtWBZXCs,4405
+release_kit/fetch_ci_artifacts.py,sha256=_5fkK1jEfhM1NWgt--0ZpcVAj0aQkmOUn2riAwxWAgg,2569
+release_kit/ledger.py,sha256=wnmBgLOUVHN1T0kxAeCpCruJSr_Kr2QaqOOMtDcS8YU,1144
+release_kit/mirror_images.py,sha256=NXNL9y9lgAIAD7X16WmQu0HuA65UtbAwCl7vCl851XA,1405
+release_kit/plan.py,sha256=N6x3w2hnDJrNUoBiTIbVktpjXj9H2EenQVyxv5lepj4,2743
+release_kit/publish_dev.py,sha256=5Ok1vRvzke2_Qpm9-2hFdTpDCz4Bj7UtVD2ZRNNU4vc,4132
+release_kit/publish_packages.py,sha256=BRfqezhksaqNyEbgAm4PuYqb0yLXhoJBmim9TMc4YHo,4699
+release_kit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+release_kit-0.1.0.dist-info/METADATA,sha256=biZyPUbTqmHjwbe4Ys0wShHMC44yqzjHUdUqoJ8w6KY,532
+release_kit-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+release_kit-0.1.0.dist-info/entry_points.txt,sha256=LSXNcSGT1G-q92fefhezjG3zSa0ufUOGQy4oRys5Ajk,316
+release_kit-0.1.0.dist-info/licenses/LICENSE,sha256=RFhQPdSOiMTguUX7JSoIuTxA7HVzCbj_p8WU36HjUQQ,10947
+release_kit-0.1.0.dist-info/licenses/NOTICE,sha256=jvglZza3GCdN7v4_TLuXUqX9C_uABlwAKUkcIeKwk_8,26
+release_kit-0.1.0.dist-info/RECORD,,

release_kit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

release_kit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+create-release = release_kit.create_release:app
+ensure-release-pr = release_kit.ensure_release_pr:app
+fetch-ci-artifacts = release_kit.fetch_ci_artifacts:app
+mirror-images = release_kit.mirror_images:app
+publish-dev = release_kit.publish_dev:app
+publish-packages = release_kit.publish_packages:app

release_kit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

release_kit-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1 @@
+Copyright 2026 Tyler Hatch