feat: initial release of hf-release v0.1.0

.env.example

@@ -0,0 +1,3 @@
+# Copy to .env and fill in your tokens (never commit .env)
+HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+GITHUB_TOKEN=github_pat_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

.gitignore

@@ -0,0 +1,21 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.env
+
+# Test / coverage
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Mypy
+.mypy_cache/
+
+# OS
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,98 @@
+# hf-release
+
+> Push model weights to **Hugging Face Hub** and create a **GitHub Release** in one atomic command.
+
+## The Problem
+
+Today, releasing an ML model requires four separate manual steps:
+
+1. `push_to_hub()` — upload weights to HF Hub
+2. `git tag` — version the commit
+3. GitHub UI — create a release
+4. Edit README — update the model card
+
+No existing tool treats this as a single operation. `hf-release` does.
+
+## Installation
+
+```bash
+pip install hf-release
+```
+
+## Quick Start
+
+```bash
+export HF_TOKEN=hf_...
+export GITHUB_TOKEN=ghp_...
+
+hf-release release \
+  --model ./my-model \
+  --version v1.2.0 \
+  --hf-repo username/my-model \
+  --gh-repo username/my-model-repo
+```
+
+This single command will:
+
+- Upload all model files to HF Hub on the `main` branch
+- Create a git tag `v1.2.0` on HF Hub
+- Sync the local `README.md` to the HF model card (with version tag injected)
+- Create an annotated git tag on GitHub
+- Create a GitHub Release with auto-generated release notes (grouped by PR labels)
+- Append an "ML Artifacts" table to the release notes linking both platforms
+
+## All Options
+
+```
+--model         PATH    Local model directory                    [required]
+--version       TEXT    Version tag, e.g. v1.2.0                [required]
+--hf-repo       TEXT    HF Hub repo ID (owner/name)             [required unless --skip-hf]
+--gh-repo       TEXT    GitHub repo ID (owner/name)             [required unless --skip-gh]
+
+--hf-token      TEXT    HF write token         [env: HF_TOKEN]
+--gh-token      TEXT    GitHub PAT             [env: GITHUB_TOKEN]
+
+--branch        TEXT    HF Hub target branch                    [default: main]
+--commit-msg    TEXT    Custom HF commit message
+--ignore        TEXT    Glob pattern to exclude from upload      [repeatable]
+--create-repo         Create HF repo if it does not exist
+
+--release-name  TEXT    GitHub release display name
+--previous-tag  TEXT    Starting tag for release note diff
+--draft               Create GitHub release as draft
+--prerelease          Mark as pre-release
+--notes-file    PATH    Use a local Markdown file as release notes
+
+--skip-card-sync      Do not sync model card README
+--tags          TEXT    Extra tags to inject into card metadata  [repeatable]
+
+--skip-hf             Skip HF Hub push entirely
+--skip-gh             Skip GitHub release entirely
+--skip-tag            Skip tag creation on both platforms
+--dry-run             Show plan, make no API calls
+--yes / -y            Skip confirmation prompt
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `HF_TOKEN` | Hugging Face write token |
+| `GITHUB_TOKEN` | GitHub personal access token (needs `repo` scope) |
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 2 | Authentication error |
+| 3 | Repo not found |
+| 4 | Tag conflict |
+| 5 | Model card sync failure |
+| 6 | Upload failure |
+| 7 | GitHub release creation failure |
+| 8 | Input validation error |
+
+## License
+
+MIT

pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hf-release"
+version = "0.1.0"
+description = "Push model weights to HF Hub and create GitHub Releases atomically"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["huggingface", "github", "mlops", "model-release", "cli"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "typer[all]>=0.12",
+    "huggingface_hub>=0.23",
+    "PyGithub>=2.3",
+    "rich>=13.7",
+    "pydantic>=2.0",
+    "pydantic-settings>=2.0",
+    "semver>=3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-mock>=3.14",
+    "ruff>=0.4",
+    "mypy>=1.10",
+]
+
+[project.scripts]
+hf-release = "hf_release.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/username/hf-release"
+Repository = "https://github.com/username/hf-release"
+Issues = "https://github.com/username/hf-release/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hf_release"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true

src/hf_release/__init__.py

@@ -0,0 +1,3 @@
+"""hf-release: Dual-publish ML models to Hugging Face Hub and GitHub."""
+
+__version__ = "0.1.0"

src/hf_release/__main__.py

@@ -0,0 +1,6 @@
+"""Allow `python -m hf_release` invocation."""
+
+from .cli import app
+
+if __name__ == "__main__":
+    app()

src/hf_release/cli.py

@@ -0,0 +1,47 @@
+"""Root Typer application for hf-release."""
+
+from __future__ import annotations
+
+import typer
+from rich.traceback import install as install_rich_tb
+
+from . import __version__
+from .commands.release import app as release_app
+from .utils.display import console, print_error
+from .utils.exceptions import HFReleaseError
+
+# Never leak tokens in tracebacks
+install_rich_tb(show_locals=False)
+
+app = typer.Typer(
+    name="hf-release",
+    rich_markup_mode="rich",
+    pretty_exceptions_show_locals=False,
+    add_completion=True,
+    help=(
+        "[bold]hf-release[/bold] — publish model weights to [cyan]Hugging Face Hub[/cyan] "
+        "and create a [green]GitHub Release[/green] in one atomic command."
+    ),
+)
+
+app.add_typer(release_app, name="release")
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"hf-release {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
+) -> None:
+    pass

src/hf_release/commands/release.py

@@ -0,0 +1,222 @@
+"""Primary `release` command — orchestrates the full dual-publish workflow."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+
+from ..config.auth import resolve_gh_token, resolve_hf_token
+from ..core import model_card as card_module
+from ..core.github_client import GHClient
+from ..core.hf_client import HFClient
+from ..core.release_notes import build_notes
+from ..utils.display import (
+    ReleaseArtifact,
+    confirm_plan,
+    console,
+    make_progress,
+    print_dry_run_panel,
+    print_partial_success,
+    print_summary_table,
+)
+from ..utils.exceptions import HFReleaseError
+from ..utils.fs import validate_model_dir, validate_repo_id, validate_version
+
+app = typer.Typer(help="Publish a model release to HF Hub and GitHub simultaneously.")
+
+
+@app.callback(invoke_without_command=True)
+def release(  # noqa: PLR0913 — many CLI params are expected
+    model: Annotated[Path, typer.Option("--model", help="Local model directory.")] = Path("."),
+    version: Annotated[str, typer.Option("--version", "-v", help="Release version, e.g. v1.2.0.")] = "",
+    hf_repo: Annotated[str, typer.Option("--hf-repo", help="HF Hub repo ID (owner/name).")] = "",
+    gh_repo: Annotated[str, typer.Option("--gh-repo", help="GitHub repo ID (owner/name).")] = "",
+    # Auth
+    hf_token: Annotated[Optional[str], typer.Option("--hf-token", envvar="HF_TOKEN", help="HF write token.", show_default=False)] = None,
+    gh_token: Annotated[Optional[str], typer.Option("--gh-token", envvar="GITHUB_TOKEN", help="GitHub PAT.", show_default=False)] = None,
+    # HF options
+    branch: Annotated[str, typer.Option("--branch", help="HF Hub target branch.")] = "main",
+    commit_msg: Annotated[Optional[str], typer.Option("--commit-msg", help="Custom HF commit message.")] = None,
+    ignore: Annotated[Optional[list[str]], typer.Option("--ignore", help="Glob patterns to exclude from upload.")] = None,
+    create_repo: Annotated[bool, typer.Option("--create-repo", help="Create HF repo if it does not exist.")] = False,
+    # GH options
+    release_name: Annotated[Optional[str], typer.Option("--release-name", help="GitHub release display name.")] = None,
+    previous_tag: Annotated[Optional[str], typer.Option("--previous-tag", help="Previous tag for release note range.")] = None,
+    draft: Annotated[bool, typer.Option("--draft", help="Create GitHub release as draft.")] = False,
+    prerelease: Annotated[bool, typer.Option("--prerelease", help="Mark GitHub release as pre-release.")] = False,
+    notes_file: Annotated[Optional[str], typer.Option("--notes-file", help="Local Markdown file to use as release notes.")] = None,
+    # Card options
+    skip_card_sync: Annotated[bool, typer.Option("--skip-card-sync", help="Do not sync model card.")] = False,
+    tags: Annotated[Optional[list[str]], typer.Option("--tags", help="Extra tags to inject into model card metadata.")] = None,
+    # Control flow
+    skip_hf: Annotated[bool, typer.Option("--skip-hf", help="Skip HF Hub push entirely.")] = False,
+    skip_gh: Annotated[bool, typer.Option("--skip-gh", help="Skip GitHub release entirely.")] = False,
+    skip_tag: Annotated[bool, typer.Option("--skip-tag", help="Skip tag creation on both platforms.")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show plan, make no API calls.")] = False,
+    yes: Annotated[bool, typer.Option("--yes", "-y", help="Skip confirmation prompt.")] = False,
+) -> None:
+    # ------------------------------------------------------------------
+    # 1. Validate inputs
+    # ------------------------------------------------------------------
+    if not version:
+        typer.echo("Error: --version is required.", err=True)
+        raise typer.Exit(8)
+    if not hf_repo and not skip_hf:
+        typer.echo("Error: --hf-repo is required (or pass --skip-hf).", err=True)
+        raise typer.Exit(8)
+    if not gh_repo and not skip_gh:
+        typer.echo("Error: --gh-repo is required (or pass --skip-gh).", err=True)
+        raise typer.Exit(8)
+
+    version = validate_version(version)
+    if hf_repo:
+        hf_repo = validate_repo_id(hf_repo, "HF repo")
+    if gh_repo:
+        gh_repo = validate_repo_id(gh_repo, "GitHub repo")
+    if not skip_hf:
+        validate_model_dir(model)
+
+    # ------------------------------------------------------------------
+    # 2. Dry-run plan
+    # ------------------------------------------------------------------
+    plan_steps: list[str] = []
+    if not skip_hf:
+        plan_steps.append(f"Push {model} → HF Hub [{hf_repo}] (branch: {branch})")
+        if not skip_tag:
+            plan_steps.append(f"Create HF tag: {version}")
+        if not skip_card_sync:
+            plan_steps.append(f"Sync model card README → HF Hub [{hf_repo}]")
+    if not skip_gh:
+        plan_steps.append(f"Create GitHub release [{gh_repo}] tag: {version}")
+
+    if dry_run:
+        print_dry_run_panel(plan_steps)
+        raise typer.Exit(0)
+
+    # ------------------------------------------------------------------
+    # 3. Confirmation
+    # ------------------------------------------------------------------
+    if not yes and not confirm_plan(plan_steps):
+        console.print("[yellow]Aborted.[/yellow]")
+        raise typer.Exit(0)
+
+    # ------------------------------------------------------------------
+    # 4. Resolve tokens
+    # ------------------------------------------------------------------
+    hf_tok = resolve_hf_token(hf_token) if not skip_hf else None
+    gh_tok = resolve_gh_token(gh_token) if not skip_gh else None
+
+    hf = HFClient(hf_tok) if hf_tok else None
+    gh = GHClient(gh_tok) if gh_tok else None
+
+    # ------------------------------------------------------------------
+    # 5. Execute steps
+    # ------------------------------------------------------------------
+    completed: list[str] = []
+    failed: list[str] = []
+    artifact = ReleaseArtifact(
+        version=version,
+        hf_repo=hf_repo or None,
+        gh_repo=gh_repo or None,
+        hf_url=None,
+        gh_url=None,
+        hf_tag=None,
+        gh_tag=None,
+    )
+
+    with make_progress() as progress:
+        # --- HF push ---
+        if hf and not skip_hf:
+            task = progress.add_task("Uploading model to HF Hub…", total=None)
+            try:
+                hf.ensure_repo_exists(hf_repo, create=create_repo)
+                commit_url = hf.push_model(
+                    local_path=model,
+                    repo_id=hf_repo,
+                    branch=branch,
+                    commit_message=commit_msg,
+                    ignore_patterns=ignore or [],
+                )
+                artifact.hf_url = f"https://huggingface.co/{hf_repo}"
+                completed.append("HF Hub upload")
+                progress.update(task, description="[green]HF upload done[/green]", completed=1, total=1)
+            except HFReleaseError as exc:
+                failed.append(f"HF Hub upload: {exc}")
+                progress.update(task, description="[red]HF upload failed[/red]", completed=1, total=1)
+
+        # --- HF tag ---
+        if hf and not skip_hf and not skip_tag and "HF Hub upload" in completed:
+            task = progress.add_task(f"Creating HF tag {version}…", total=None)
+            try:
+                hf.create_tag(hf_repo, version)
+                artifact.hf_tag = version
+                artifact.hf_url = f"https://huggingface.co/{hf_repo}/tree/{version}"
+                completed.append("HF tag")
+                progress.update(task, description="[green]HF tag done[/green]", completed=1, total=1)
+            except HFReleaseError as exc:
+                failed.append(f"HF tag: {exc}")
+                progress.update(task, description="[red]HF tag failed[/red]", completed=1, total=1)
+
+        # --- Model card sync ---
+        if hf and not skip_hf and not skip_card_sync and "HF Hub upload" in completed:
+            task = progress.add_task("Syncing model card…", total=None)
+            try:
+                synced = card_module.sync_card(
+                    model_dir=model,
+                    hf_client=hf,
+                    hf_repo=hf_repo,
+                    version=version,
+                    extra_tags=tags or [],
+                )
+                if synced:
+                    completed.append("Model card sync")
+                else:
+                    completed.append("Model card sync (skipped — no README found)")
+                progress.update(task, description="[green]Card sync done[/green]", completed=1, total=1)
+            except HFReleaseError as exc:
+                failed.append(f"Model card sync: {exc}")
+                progress.update(task, description="[red]Card sync failed[/red]", completed=1, total=1)
+
+        # --- GitHub release ---
+        if gh and not skip_gh:
+            task = progress.add_task("Creating GitHub release…", total=None)
+            try:
+                gh_repo_obj = gh.get_repo(gh_repo)
+
+                if not skip_tag:
+                    gh.ensure_tag(gh_repo_obj, version)
+                    artifact.gh_tag = version
+
+                body = build_notes(
+                    version=version,
+                    hf_repo=hf_repo or None,
+                    gh_client=gh,
+                    gh_repo_obj=gh_repo_obj,
+                    previous_tag=previous_tag,
+                    notes_file=notes_file,
+                )
+
+                gh_url = gh.create_release(
+                    repo=gh_repo_obj,
+                    tag_name=version,
+                    name=release_name or version,
+                    body=body,
+                    draft=draft,
+                    prerelease=prerelease,
+                )
+                artifact.gh_url = gh_url
+                completed.append("GitHub release")
+                progress.update(task, description="[green]GitHub release done[/green]", completed=1, total=1)
+            except HFReleaseError as exc:
+                failed.append(f"GitHub release: {exc}")
+                progress.update(task, description="[red]GitHub release failed[/red]", completed=1, total=1)
+
+    # ------------------------------------------------------------------
+    # 6. Summary
+    # ------------------------------------------------------------------
+    if failed:
+        print_partial_success(completed, failed)
+    else:
+        print_summary_table(artifact)

src/hf_release/config/auth.py

@@ -0,0 +1,45 @@
+"""Token resolution: CLI flag → env var → interactive prompt."""
+
+from __future__ import annotations
+
+import os
+
+import typer
+
+from ..utils.exceptions import AuthenticationError
+
+
+def resolve_hf_token(explicit: str | None) -> str:
+    if explicit:
+        return explicit
+    env = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+    if env:
+        return env
+    token = typer.prompt(
+        "Hugging Face write token (set HF_TOKEN to skip this prompt)",
+        hide_input=True,
+    )
+    if not token:
+        raise AuthenticationError(
+            "No Hugging Face token provided.",
+            suggestion="Export HF_TOKEN or pass --hf-token.",
+        )
+    return token
+
+
+def resolve_gh_token(explicit: str | None) -> str:
+    if explicit:
+        return explicit
+    env = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
+    if env:
+        return env
+    token = typer.prompt(
+        "GitHub personal access token (set GITHUB_TOKEN to skip this prompt)",
+        hide_input=True,
+    )
+    if not token:
+        raise AuthenticationError(
+            "No GitHub token provided.",
+            suggestion="Export GITHUB_TOKEN or pass --gh-token.",
+        )
+    return token

src/hf_release/core/github_client.py

@@ -0,0 +1,125 @@
+"""GitHub operations via PyGithub."""
+
+from __future__ import annotations
+
+import github
+from github import Github, GithubException
+from github.Repository import Repository
+
+from ..utils.exceptions import AuthenticationError, ReleaseCreationError, RepoNotFoundError, TagConflictError
+
+
+class GHClient:
+    def __init__(self, token: str) -> None:
+        self._gh = Github(token)
+
+    def get_repo(self, repo_id: str) -> Repository:
+        try:
+            return self._gh.get_repo(repo_id)
+        except GithubException as exc:
+            if exc.status == 401:
+                raise AuthenticationError(
+                    "GitHub token rejected.",
+                    suggestion="Check that GITHUB_TOKEN has 'repo' scope.",
+                ) from exc
+            if exc.status == 404:
+                raise RepoNotFoundError(
+                    f"GitHub repo '{repo_id}' not found.",
+                    suggestion="Check the repo name and token permissions.",
+                ) from exc
+            raise
+
+    # ------------------------------------------------------------------
+    # Tagging
+    # ------------------------------------------------------------------
+
+    def ensure_tag(self, repo: Repository, tag_name: str, message: str | None = None) -> None:
+        """Create an annotated tag pointing to HEAD. Idempotent if same SHA."""
+        try:
+            head_sha = repo.get_branch(repo.default_branch).commit.sha
+            tag_obj = repo.create_git_tag(
+                tag=tag_name,
+                message=message or tag_name,
+                object=head_sha,
+                type="commit",
+            )
+            repo.create_git_ref(ref=f"refs/tags/{tag_name}", sha=tag_obj.sha)
+        except GithubException as exc:
+            if exc.status == 422:
+                # Already exists — check if it points to the same commit
+                try:
+                    existing = repo.get_git_ref(f"tags/{tag_name}")
+                    # If it exists and we can read it, treat as idempotent success
+                    _ = existing
+                    return
+                except GithubException:
+                    pass
+                raise TagConflictError(
+                    f"GitHub tag '{tag_name}' already exists.",
+                    suggestion="Use a different version or delete the existing tag first.",
+                ) from exc
+            raise TagConflictError(f"Failed to create GitHub tag '{tag_name}': {exc}") from exc
+
+    def delete_tag(self, repo: Repository, tag_name: str) -> None:
+        try:
+            ref = repo.get_git_ref(f"tags/{tag_name}")
+            ref.delete()
+        except GithubException as exc:
+            if exc.status == 404:
+                return  # Already gone
+            raise
+
+    # ------------------------------------------------------------------
+    # Releases
+    # ------------------------------------------------------------------
+
+    def _get_previous_tag(self, repo: Repository) -> str | None:
+        try:
+            return repo.get_latest_release().tag_name
+        except GithubException:
+            return None
+
+    def generate_notes(
+        self,
+        repo: Repository,
+        tag_name: str,
+        previous_tag: str | None = None,
+        target_commitish: str | None = None,
+    ) -> str:
+        """Call GitHub's native release-notes generation endpoint."""
+        try:
+            prev = previous_tag or self._get_previous_tag(repo)
+            kwargs: dict = {"tag_name": tag_name}
+            if prev:
+                kwargs["previous_tag_name"] = prev
+            if target_commitish:
+                kwargs["target_commitish"] = target_commitish
+            notes = repo.generate_release_notes(**kwargs)
+            return notes.body
+        except Exception:
+            return ""
+
+    def create_release(
+        self,
+        repo: Repository,
+        tag_name: str,
+        name: str | None = None,
+        body: str | None = None,
+        draft: bool = False,
+        prerelease: bool = False,
+    ) -> str:
+        """Create a GitHub release. Returns the HTML URL."""
+        try:
+            release = repo.create_git_release(
+                tag=tag_name,
+                name=name or tag_name,
+                message=body or "",
+                draft=draft,
+                prerelease=prerelease,
+            )
+            return release.html_url
+        except GithubException as exc:
+            raise ReleaseCreationError(
+                f"Failed to create GitHub release: {exc.data.get('message', exc)}",
+                suggestion="Check that the tag exists and the token has 'repo' write access.",
+            ) from exc

src/hf_release/core/hf_client.py

@@ -0,0 +1,124 @@
+"""Hugging Face Hub operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from huggingface_hub import HfApi, ModelCard
+from huggingface_hub.errors import (
+    EntryNotFoundError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+)
+
+from ..utils.exceptions import AuthenticationError, ModelCardSyncError, RepoNotFoundError, TagConflictError, UploadError
+
+
+class HFClient:
+    def __init__(self, token: str) -> None:
+        self._token = token
+        self._api = HfApi(token=token)
+
+    # ------------------------------------------------------------------
+    # Repo helpers
+    # ------------------------------------------------------------------
+
+    def ensure_repo_exists(self, repo_id: str, create: bool = False) -> None:
+        try:
+            self._api.repo_info(repo_id=repo_id, repo_type="model")
+        except RepositoryNotFoundError:
+            if create:
+                self._api.create_repo(repo_id=repo_id, repo_type="model", private=False)
+            else:
+                raise RepoNotFoundError(
+                    f"HF repo '{repo_id}' not found.",
+                    suggestion="Create it on huggingface.co or pass --create-repo.",
+                )
+        except Exception as exc:
+            if "401" in str(exc) or "403" in str(exc):
+                raise AuthenticationError(
+                    "HF token rejected.",
+                    suggestion="Check that HF_TOKEN has write access to the repo.",
+                ) from exc
+            raise
+
+    # ------------------------------------------------------------------
+    # Upload
+    # ------------------------------------------------------------------
+
+    def push_model(
+        self,
+        local_path: Path,
+        repo_id: str,
+        branch: str = "main",
+        commit_message: str | None = None,
+        ignore_patterns: list[str] | None = None,
+    ) -> str:
+        """Upload a local directory to HF Hub. Returns the commit URL."""
+        msg = commit_message or f"Upload model via hf-release"
+        try:
+            result = self._api.upload_folder(
+                folder_path=str(local_path),
+                repo_id=repo_id,
+                repo_type="model",
+                commit_message=msg,
+                revision=branch,
+                ignore_patterns=ignore_patterns or [],
+            )
+        except RepositoryNotFoundError:
+            raise RepoNotFoundError(
+                f"HF repo '{repo_id}' not found.",
+                suggestion="Create it on huggingface.co or pass --create-repo.",
+            )
+        except Exception as exc:
+            raise UploadError(f"Failed to upload model: {exc}") from exc
+
+        return result if isinstance(result, str) else str(result)
+
+    # ------------------------------------------------------------------
+    # Tagging
+    # ------------------------------------------------------------------
+
+    def create_tag(self, repo_id: str, tag: str, message: str | None = None) -> None:
+        try:
+            self._api.create_tag(
+                repo_id=repo_id,
+                repo_type="model",
+                tag=tag,
+                tag_message=message or tag,
+            )
+        except RevisionNotFoundError:
+            raise TagConflictError(
+                f"Could not create tag '{tag}' on HF repo '{repo_id}': revision not found.",
+                suggestion="Make sure the model was pushed before tagging.",
+            )
+        except Exception as exc:
+            if "already exists" in str(exc).lower():
+                # Tag already there — treat as idempotent success
+                return
+            raise TagConflictError(f"Failed to create HF tag '{tag}': {exc}") from exc
+
+    # ------------------------------------------------------------------
+    # Model card
+    # ------------------------------------------------------------------
+
+    def get_model_card(self, repo_id: str) -> ModelCard | None:
+        try:
+            path = self._api.hf_hub_download(
+                repo_id=repo_id,
+                filename="README.md",
+                repo_type="model",
+            )
+            return ModelCard.load(path)
+        except EntryNotFoundError:
+            return None
+        except RepositoryNotFoundError:
+            raise RepoNotFoundError(f"HF repo '{repo_id}' not found.")
+        except Exception as exc:
+            raise ModelCardSyncError(f"Failed to fetch model card: {exc}") from exc
+
+    def push_model_card(self, card: ModelCard, repo_id: str) -> None:
+        try:
+            card.push_to_hub(repo_id, token=self._token)
+        except Exception as exc:
+            raise ModelCardSyncError(f"Failed to push model card to HF: {exc}") from exc

src/hf_release/core/model_card.py

@@ -0,0 +1,62 @@
+"""Model Card sync between local disk, HF Hub, and GitHub."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from huggingface_hub import ModelCard, ModelCardData
+
+from ..utils.exceptions import ModelCardSyncError
+
+
+def load_local_card(model_dir: Path) -> ModelCard | None:
+    readme = model_dir / "README.md"
+    if not readme.exists():
+        return None
+    try:
+        return ModelCard.load(str(readme))
+    except Exception as exc:
+        raise ModelCardSyncError(f"Failed to parse local README.md: {exc}") from exc
+
+
+def update_card_metadata(card: ModelCard, version: str, extra_tags: list[str] | None = None) -> ModelCard:
+    """Inject version tag and any extra tags into the card frontmatter."""
+    data: ModelCardData = card.data
+    tags: list[str] = list(data.tags or [])
+
+    if version not in tags:
+        tags.append(version)
+    for t in extra_tags or []:
+        if t not in tags:
+            tags.append(t)
+
+    data.tags = tags
+    card.data = data
+    return card
+
+
+def sync_card(
+    *,
+    model_dir: Path | None,
+    hf_client,  # HFClient | None
+    hf_repo: str | None,
+    version: str,
+    extra_tags: list[str] | None = None,
+) -> bool:
+    """
+    Sync model card from local dir → HF Hub.
+    Returns True if a card was pushed, False if skipped.
+    """
+    if model_dir is None or hf_client is None or hf_repo is None:
+        return False
+
+    card = load_local_card(model_dir)
+    if card is None:
+        # Try to pull from HF and update metadata only
+        card = hf_client.get_model_card(hf_repo)
+        if card is None:
+            return False
+
+    card = update_card_metadata(card, version, extra_tags)
+    hf_client.push_model_card(card, hf_repo)
+    return True

src/hf_release/core/release_notes.py

@@ -0,0 +1,60 @@
+"""Release notes generation — three-tier strategy."""
+
+from __future__ import annotations
+
+from github.Repository import Repository
+
+from .github_client import GHClient
+
+
+def build_notes(
+    version: str,
+    hf_repo: str | None,
+    gh_client: GHClient | None,
+    gh_repo_obj: Repository | None,
+    previous_tag: str | None = None,
+    notes_file: str | None = None,
+) -> str:
+    # Tier 0: explicit file override
+    if notes_file:
+        try:
+            with open(notes_file) as f:
+                return f.read()
+        except OSError:
+            pass
+
+    # Tier 1: GitHub native generation
+    if gh_client and gh_repo_obj:
+        notes = gh_client.generate_notes(gh_repo_obj, version, previous_tag)
+        if notes:
+            return _append_ml_artifacts(notes, version, hf_repo, gh_repo_obj.full_name)
+
+    # Tier 3: minimal fallback
+    parts = [f"Release {version}"]
+    if hf_repo:
+        parts.append(f"\n\n**Hugging Face Hub:** https://huggingface.co/{hf_repo}")
+    if gh_repo_obj:
+        parts.append(f"\n**GitHub:** https://github.com/{gh_repo_obj.full_name}/releases/tag/{version}")
+    return "".join(parts)
+
+
+def _append_ml_artifacts(body: str, version: str, hf_repo: str | None, gh_repo: str) -> str:
+    rows = []
+    if hf_repo:
+        rows.append(
+            f"| Hugging Face Hub | [Model files](https://huggingface.co/{hf_repo}/tree/{version}) |"
+        )
+        rows.append(
+            f"| Model Card | [README](https://huggingface.co/{hf_repo}) |"
+        )
+    rows.append(
+        f"| GitHub | [Release](https://github.com/{gh_repo}/releases/tag/{version}) |"
+    )
+
+    section = (
+        "\n\n## ML Artifacts\n\n"
+        "| Platform | Link |\n"
+        "|----------|------|\n"
+        + "\n".join(rows)
+    )
+    return body + section

src/hf_release/utils/display.py

@@ -0,0 +1,101 @@
+"""Centralized Rich display helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.table import Table
+
+# Use stderr so stdout stays clean for piped/script usage
+console = Console(stderr=True)
+
+
+@dataclass
+class ReleaseArtifact:
+    version: str
+    hf_repo: str | None
+    gh_repo: str | None
+    hf_url: str | None
+    gh_url: str | None
+    hf_tag: str | None
+    gh_tag: str | None
+
+
+def make_progress() -> Progress:
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+
+def print_summary_table(artifact: ReleaseArtifact) -> None:
+    table = Table(title=f"Release {artifact.version} — Summary", show_lines=True)
+    table.add_column("Platform", style="bold cyan", no_wrap=True)
+    table.add_column("Repo")
+    table.add_column("Tag", style="green")
+    table.add_column("URL", style="blue")
+
+    if artifact.hf_repo:
+        table.add_row(
+            "Hugging Face Hub",
+            artifact.hf_repo,
+            artifact.hf_tag or "-",
+            artifact.hf_url or "-",
+        )
+    if artifact.gh_repo:
+        table.add_row(
+            "GitHub",
+            artifact.gh_repo,
+            artifact.gh_tag or "-",
+            artifact.gh_url or "-",
+        )
+
+    console.print(table)
+
+
+def print_error(exc: Exception, suggestion: str = "") -> None:
+    suggestion_text = suggestion or getattr(exc, "suggestion", "")
+    body = str(exc)
+    if suggestion_text:
+        body += f"\n\n[dim]Suggestion:[/dim] {suggestion_text}"
+    console.print(Panel(body, title="[bold red]Error[/bold red]", border_style="red"))
+
+
+def print_dry_run_panel(steps: list[str]) -> None:
+    body = "\n".join(f"  • {s}" for s in steps)
+    console.print(
+        Panel(
+            f"[bold]The following actions would be performed:[/bold]\n\n{body}",
+            title="[bold blue]Dry Run[/bold blue]",
+            border_style="blue",
+        )
+    )
+
+
+def print_partial_success(completed: list[str], failed: list[str]) -> None:
+    body = ""
+    if completed:
+        body += "[green]Completed:[/green]\n" + "\n".join(f"  ✓ {s}" for s in completed) + "\n\n"
+    if failed:
+        body += "[red]Failed:[/red]\n" + "\n".join(f"  ✗ {s}" for s in failed)
+    console.print(Panel(body, title="[bold yellow]Partial Success[/bold yellow]", border_style="yellow"))
+
+
+def confirm_plan(steps: list[str]) -> bool:
+    """Print a plan summary and ask for confirmation. Returns True if confirmed."""
+    body = "\n".join(f"  • {s}" for s in steps)
+    console.print(
+        Panel(
+            f"[bold]About to execute:[/bold]\n\n{body}",
+            title="[bold cyan]Release Plan[/bold cyan]",
+            border_style="cyan",
+        )
+    )
+    import typer
+    return typer.confirm("Proceed?")

src/hf_release/utils/exceptions.py

@@ -0,0 +1,55 @@
+"""Custom exception hierarchy for hf-release."""
+
+from __future__ import annotations
+
+
+class HFReleaseError(Exception):
+    """Base exception for all hf-release errors."""
+
+    exit_code: int = 1
+
+    def __init__(self, message: str, suggestion: str = "") -> None:
+        super().__init__(message)
+        self.suggestion = suggestion
+
+
+class AuthenticationError(HFReleaseError):
+    """Raised when a token is missing or invalid."""
+
+    exit_code = 2
+
+
+class RepoNotFoundError(HFReleaseError):
+    """Raised when a HF or GitHub repo does not exist."""
+
+    exit_code = 3
+
+
+class TagConflictError(HFReleaseError):
+    """Raised when a tag already exists with a different SHA."""
+
+    exit_code = 4
+
+
+class ModelCardSyncError(HFReleaseError):
+    """Raised when reading or pushing a model card fails."""
+
+    exit_code = 5
+
+
+class UploadError(HFReleaseError):
+    """Raised when uploading model weights to HF Hub fails."""
+
+    exit_code = 6
+
+
+class ReleaseCreationError(HFReleaseError):
+    """Raised when creating a GitHub release fails."""
+
+    exit_code = 7
+
+
+class ValidationError(HFReleaseError):
+    """Raised for bad input (invalid version string, missing path, etc.)."""
+
+    exit_code = 8

src/hf_release/utils/fs.py

@@ -0,0 +1,49 @@
+"""Local filesystem helpers."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .exceptions import ValidationError
+
+_REPO_ID_RE = re.compile(r"^[a-zA-Z0-9_.\-]+/[a-zA-Z0-9_.\-]+$")
+_VERSION_RE = re.compile(r"^v?\d+\.\d+\.\d+([.\-].+)?$")
+
+
+def validate_model_dir(path: Path) -> Path:
+    if not path.exists():
+        raise ValidationError(
+            f"Model directory does not exist: {path}",
+            suggestion="Pass the correct --model path.",
+        )
+    if not path.is_dir():
+        raise ValidationError(
+            f"--model must be a directory, got a file: {path}",
+            suggestion="Point --model to the directory containing your model files.",
+        )
+    files = list(path.iterdir())
+    if not files:
+        raise ValidationError(
+            f"Model directory is empty: {path}",
+            suggestion="Make sure training has completed and the output directory is correct.",
+        )
+    return path
+
+
+def validate_version(version: str) -> str:
+    if not _VERSION_RE.match(version):
+        raise ValidationError(
+            f"Invalid version string: {version!r}",
+            suggestion="Use semantic versioning like v1.2.0 or 1.2.0.",
+        )
+    return version
+
+
+def validate_repo_id(repo_id: str, label: str = "repo") -> str:
+    if not _REPO_ID_RE.match(repo_id):
+        raise ValidationError(
+            f"Invalid {label} ID: {repo_id!r}",
+            suggestion="Repo IDs must be in 'owner/name' format.",
+        )
+    return repo_id

tests/unit/test_fs.py

@@ -0,0 +1,28 @@
+"""Unit tests for input validation helpers."""
+
+import pytest
+
+from hf_release.utils.fs import validate_repo_id, validate_version
+from hf_release.utils.exceptions import ValidationError
+
+
+@pytest.mark.parametrize("v", ["v1.0.0", "1.0.0", "v0.1.0-alpha", "2.3.4"])
+def test_valid_versions(v):
+    assert validate_version(v) == v
+
+
+@pytest.mark.parametrize("v", ["", "latest", "1.0", "v1", "abc"])
+def test_invalid_versions(v):
+    with pytest.raises(ValidationError):
+        validate_version(v)
+
+
+@pytest.mark.parametrize("r", ["owner/repo", "my-org/my-model_v2", "a/b"])
+def test_valid_repo_ids(r):
+    assert validate_repo_id(r) == r
+
+
+@pytest.mark.parametrize("r", ["", "noslash", "a/b/c", "/repo", "owner/"])
+def test_invalid_repo_ids(r):
+    with pytest.raises(ValidationError):
+        validate_repo_id(r)