Build an AI Release Notes Generator from Git

pip install anthropic

import subprocess
import json

def get_commits(from_ref: str, to_ref: str = "HEAD") -> list[dict]:
    """Extract commits between two git refs."""
    sep = "---COMMIT---"
    fmt = f"%H{sep}%an{sep}%s{sep}%b"

    result = subprocess.run(
        ["git", "log", f"{from_ref}..{to_ref}",
         "--format=" + fmt, "--no-merges"],
        capture_output=True, text=True, check=True
    )

    commits = []
    for line in result.stdout.strip().split("\n"):
        if not line.strip():
            continue
        parts = line.split(sep)
        if len(parts) >= 3:
            commits.append({
                "hash": parts[0][:8],
                "author": parts[1],
                "subject": parts[2],
                "body": parts[3] if len(parts) > 3 else "",
            })
    return commits

import anthropic

client = anthropic.Anthropic(
    api_key="sk-your-ezai-key",
    base_url="https://ezaiapi.com",
)

def generate_notes(commits: list[dict], version: str) -> str:
    """Send commits to Claude, get back formatted release notes."""
    commit_text = "\n".join(
        f"- [{c['hash']}] {c['subject']}"
        + (f" — {c['body']}" if c["body"] else "")
        for c in commits
    )

    prompt = f"""You are a technical writer generating release notes.

Given these git commits for version {version}, produce clean
markdown release notes. Rules:

1. Group into: ✨ Features, 🐛 Bug Fixes, ⚡ Performance,
   🔧 Maintenance, 📚 Documentation (skip empty groups)
2. Rewrite cryptic commit messages into user-facing descriptions
3. Deduplicate commits that fix the same thing
4. Skip commits that are just typo fixes or formatting
5. Include the short hash in parentheses after each item
6. Output ONLY the markdown, no preamble

Commits:
{commit_text}"""

    message = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text

import argparse, sys

def main():
    parser = argparse.ArgumentParser(
        description="Generate release notes from git history"
    )
    parser.add_argument("from_ref", help="Start ref (tag/branch/SHA)")
    parser.add_argument("to_ref", nargs="?", default="HEAD")
    parser.add_argument("--version", "-v", default="Unreleased")
    parser.add_argument("--output", "-o", help="Write to file")
    args = parser.parse_args()

    commits = get_commits(args.from_ref, args.to_ref)
    if not commits:
        print("No commits found between refs.", file=sys.stderr)
        sys.exit(1)

    print(f"Found {len(commits)} commits. Generating notes...",
          file=sys.stderr)

    notes = generate_notes(commits, args.version)

    if args.output:
        with open(args.output, "w") as f:
            f.write(notes)
        print(f"Written to {args.output}", file=sys.stderr)
    else:
        print(notes)

if __name__ == "__main__":
    main()

# Generate notes between two tags
python release_notes.py v1.2.0 v1.3.0 --version "v1.3.0"

# Save to a file
python release_notes.py v1.2.0 --version "v1.3.0" -o CHANGELOG.md

# .github/workflows/release-notes.yml
name: Generate Release Notes
on:
  push:
    tags: ["v*"]

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Full history for git log

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - run: pip install anthropic

      - name: Get previous tag
        id: prev
        run: |
          PREV=$(git tag --sort=-v:refname | sed -n '2p')
          echo "tag=$PREV" >> $GITHUB_OUTPUT

      - name: Generate notes
        env:
          ANTHROPIC_API_KEY: ${{ secrets.EZAI_API_KEY }}
        run: |
          python release_notes.py \
            ${{ steps.prev.outputs.tag }} \
            ${{ github.ref_name }} \
            --version "${{ github.ref_name }}" \
            -o notes.md

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          body_path: notes.md

# Filter out noise before sending to Claude
SKIP_PATTERNS = ["wip", "fixup", "typo", "formatting"]

def filter_commits(commits: list[dict], max_count: int = 200):
    filtered = [
        c for c in commits
        if not any(
            p in c["subject"].lower() for p in SKIP_PATTERNS
        )
    ]
    if len(filtered) > max_count:
        filtered = filtered[:max_count]
        filtered.append({
            "hash": "...",
            "author": "",
            "subject": f"(+{len(commits) - max_count} more commits)",
            "body": "",
        })
    return filtered

## v1.3.0

### ✨ Features
- Add WebSocket support for real-time streaming responses (a3f2c1d)
- New `/usage` endpoint returns per-model token breakdown (b7e9f0a)
- Support for Gemini 2.5 Pro via unified gateway (c1d4e8b)

### 🐛 Bug Fixes
- Fix rate limiter not resetting after key rotation (d5a2b3c)
- Resolve timeout on large streaming responses over 60s (e8f1a2d)

### ⚡ Performance
- Cache model routing decisions, reducing lookup time by 40% (f2c3d4e)

### 🔧 Maintenance
- Upgrade Anthropic SDK to 0.42.0 (a1b2c3d)
- Migrate CI from Jenkins to GitHub Actions (b4c5d6e)