Release Management

#!/bin/bash
# Release Management Scripts
# Automate semantic versioning and GitHub releases

set -euo pipefail

# =============================================================================
# VERSION DETECTION
# =============================================================================

# Get current version from latest git tag
get_current_version() {
  local version
  version=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
  echo "${version#v}"  # Remove 'v' prefix
}

# Parse version components
parse_version() {
  local version="$1"
  local major minor patch

  IFS='.' read -r major minor patch <<< "${version%%-*}"
  patch="${patch%%+*}"  # Remove build metadata

  echo "$major $minor $patch"
}

# =============================================================================
# VERSION BUMPING
# =============================================================================

# Bump version based on type
bump_version() {
  local bump_type="$1"
  local current
  current=$(get_current_version)

  local major minor patch
  read -r major minor patch <<< "$(parse_version "$current")"

  case "$bump_type" in
    major)
      major=$((major + 1))
      minor=0
      patch=0
      ;;
    minor)
      minor=$((minor + 1))
      patch=0
      ;;
    patch)
      patch=$((patch + 1))
      ;;
    *)
      echo "Invalid bump type: $bump_type"
      echo "Use: major, minor, or patch"
      return 1
      ;;
  esac

  echo "$major.$minor.$patch"
}

# Interactive version bump with change analysis
smart_bump() {
  echo "=== Smart Version Bump ==="
  echo ""

  local current
  current=$(get_current_version)
  echo "Current version: v$current"
  echo ""

  # Analyze commits since last release
  echo "Analyzing commits since v$current..."
  echo ""

  local breaking=0 features=0 fixes=0 other=0

  while IFS= read -r commit; do
    case "$commit" in
      *"BREAKING"*|*"!"*)
        ((breaking++))
        ;;
      feat*)
        ((features++))
        ;;
      fix*)
        ((fixes++))
        ;;
      *)
        ((other++))
        ;;
    esac
  done < <(git log "v$current"..HEAD --format=%s 2>/dev/null || true)

  echo "Commits since last release:"
  echo "  Breaking changes: $breaking"
  echo "  Features: $features"
  echo "  Fixes: $fixes"
  echo "  Other: $other"
  echo ""

  # Suggest bump type
  local suggested="patch"
  if [[ $breaking -gt 0 ]]; then
    suggested="major"
  elif [[ $features -gt 0 ]]; then
    suggested="minor"
  fi

  local new_major new_minor new_patch
  new_major=$(bump_version major)
  new_minor=$(bump_version minor)
  new_patch=$(bump_version patch)

  echo "Suggested: $suggested"
  echo ""
  echo "Options:"
  echo "  1) major -> v$new_major"
  echo "  2) minor -> v$new_minor"
  echo "  3) patch -> v$new_patch"
  echo "  4) custom"
  echo "  5) cancel"
  echo ""

  read -p "Select option [1-5]: " choice

  case "$choice" in
    1) echo "$new_major" ;;
    2) echo "$new_minor" ;;
    3) echo "$new_patch" ;;
    4)
      read -p "Enter version (without v): " custom
      echo "$custom"
      ;;
    5|*)
      echo "Cancelled"
      return 1
      ;;
  esac
}

# =============================================================================
# RELEASE CREATION
# =============================================================================

# Create a new release
create_release() {
  local version="${1:-}"
  local title="${2:-}"
  local draft="${3:-false}"
  local prerelease="${4:-false}"

  if [[ -z "$version" ]]; then
    echo "Usage: create_release VERSION [TITLE] [draft] [prerelease]"
    return 1
  fi

  # Ensure version has v prefix for tag
  local tag="v${version#v}"

  echo "=== Creating Release $tag ==="
  echo ""

  # Check we're on main
  local current_branch
  current_branch=$(git branch --show-current)
  if [[ "$current_branch" != "main" && "$current_branch" != "master" ]]; then
    echo "⚠️  Warning: Not on main/master branch (on $current_branch)"
    read -p "Continue anyway? (y/N) " confirm
    if [[ "$confirm" != "y" ]]; then
      echo "Cancelled"
      return 1
    fi
  fi

  # Ensure working directory is clean
  if [[ -n $(git status --porcelain) ]]; then
    echo "❌ Working directory not clean. Commit or stash changes first."
    return 1
  fi

  # Pull latest
  echo "Pulling latest changes..."
  git pull origin "$current_branch"

  # Create tag
  echo "Creating tag $tag..."
  if [[ -n "$title" ]]; then
    git tag -a "$tag" -m "$title"
  else
    git tag -a "$tag" -m "Release $tag"
  fi

  # Push tag
  echo "Pushing tag..."
  git push origin "$tag"

  # Create GitHub release
  echo "Creating GitHub release..."

  local gh_args=(
    "--generate-notes"
  )

  if [[ -n "$title" ]]; then
    gh_args+=("--title" "$title")
  else
    gh_args+=("--title" "Release $tag")
  fi

  if [[ "$draft" == "true" ]]; then
    gh_args+=("--draft")
  fi

  if [[ "$prerelease" == "true" ]]; then
    gh_args+=("--prerelease")
  fi

  gh release create "$tag" "${gh_args[@]}"

  echo ""
  echo "✅ Release $tag created successfully!"
  echo ""
  echo "View: gh release view $tag --web"
}

# Create a draft release for review
create_draft_release() {
  local version
  version=$(smart_bump)

  if [[ -z "$version" || "$version" == "Cancelled" ]]; then
    return 1
  fi

  read -p "Release title (optional): " title
  create_release "$version" "$title" "true" "false"
}

# Create a pre-release (alpha/beta/rc)
create_prerelease() {
  local base_version="$1"
  local stage="${2:-beta}"  # alpha, beta, rc
  local number="${3:-1}"

  local version="${base_version}-${stage}.${number}"
  create_release "$version" "Pre-release $version" "false" "true"
}

# =============================================================================
# RELEASE WORKFLOW
# =============================================================================

# Full release workflow
release_workflow() {
  echo "=== Release Workflow ==="
  echo ""

  # Step 1: Ensure clean state
  echo "Step 1: Checking repository state..."
  git fetch origin

  local current_branch
  current_branch=$(git branch --show-current)

  if [[ "$current_branch" != "main" ]]; then
    echo "Switching to main..."
    git checkout main
    git pull origin main
  fi

  if [[ -n $(git status --porcelain) ]]; then
    echo "❌ Working directory not clean"
    return 1
  fi

  echo "✅ Repository is clean"
  echo ""

  # Step 2: Show what's changed
  echo "Step 2: Changes since last release..."
  local current
  current=$(get_current_version)

  echo ""
  echo "Commits since v$current:"
  git log "v$current"..HEAD --oneline | head -20
  echo ""

  # Step 3: Determine version
  echo "Step 3: Determine new version..."
  local new_version
  new_version=$(smart_bump)

  if [[ -z "$new_version" || "$new_version" == "Cancelled" ]]; then
    return 1
  fi

  echo ""
  echo "New version: v$new_version"
  echo ""

  # Step 4: Update version files (optional)
  echo "Step 4: Update version files..."
  update_version_files "$new_version"

  # Step 5: Create release
  echo "Step 5: Create release..."
  read -p "Create as draft first? (Y/n) " draft_choice

  local is_draft="true"
  if [[ "$draft_choice" == "n" || "$draft_choice" == "N" ]]; then
    is_draft="false"
  fi

  read -p "Release title (or Enter for default): " title
  title="${title:-Release v$new_version}"

  create_release "$new_version" "$title" "$is_draft" "false"

  echo ""
  echo "✅ Release workflow complete!"

  if [[ "$is_draft" == "true" ]]; then
    echo ""
    echo "Next steps:"
    echo "  1. Review draft release notes"
    echo "  2. Publish: gh release edit v$new_version --draft=false"
  fi
}

# =============================================================================
# VERSION FILE UPDATES
# =============================================================================

# Update version in common files
update_version_files() {
  local version="$1"

  # package.json
  if [[ -f "package.json" ]]; then
    echo "Updating package.json..."
    # Use node if available, otherwise sed
    if command -v node >/dev/null; then
      node -e "
        const pkg = require('./package.json');
        pkg.version = '$version';
        require('fs').writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
      "
    else
      sed -i.bak "s/\"version\": \".*\"/\"version\": \"$version\"/" package.json
      rm -f package.json.bak
    fi
  fi

  # pyproject.toml
  if [[ -f "pyproject.toml" ]]; then
    echo "Updating pyproject.toml..."
    sed -i.bak "s/^version = \".*\"/version = \"$version\"/" pyproject.toml
    rm -f pyproject.toml.bak
  fi

  # Cargo.toml
  if [[ -f "Cargo.toml" ]]; then
    echo "Updating Cargo.toml..."
    sed -i.bak "s/^version = \".*\"/version = \"$version\"/" Cargo.toml
    rm -f Cargo.toml.bak
  fi

  # Commit version bump if changes were made
  if [[ -n $(git status --porcelain) ]]; then
    echo "Committing version bump..."
    git add -A
    git commit -m "chore: Bump version to $version"
    git push origin main
  fi
}

# =============================================================================
# HOTFIX WORKFLOW
# =============================================================================

# Create hotfix release
hotfix_release() {
  local fix_description="$1"

  if [[ -z "$fix_description" ]]; then
    echo "Usage: hotfix_release 'Description of the fix'"
    return 1
  fi

  echo "=== Hotfix Release ==="
  echo ""

  local current
  current=$(get_current_version)
  local new_version
  new_version=$(bump_version patch)

  echo "Current: v$current"
  echo "Hotfix:  v$new_version"
  echo ""

  # Create release with hotfix note
  create_release "$new_version" "Hotfix: $fix_description" "false" "false"
}

# =============================================================================
# USAGE
# =============================================================================

usage() {
  cat << 'EOF'
Release Management Scripts

Commands:
  get_current_version      Get current version from git tags
  bump_version TYPE        Bump version (major|minor|patch)
  smart_bump               Interactive version bump with commit analysis
  create_release VER       Create a new release
  create_draft_release     Create a draft release for review
  create_prerelease VER    Create a pre-release (alpha/beta/rc)
  release_workflow         Full guided release workflow
  hotfix_release DESC      Create a hotfix patch release

Examples:
  source release-scripts.sh

  # Quick patch release
  create_release "1.2.4" "Bug fixes"

  # Full workflow
  release_workflow

  # Hotfix
  hotfix_release "Fix critical auth bypass"

  # Pre-release
  create_prerelease "2.0.0" "beta" "1"  # Creates v2.0.0-beta.1
EOF
}

# Show usage if run directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
  usage
fi

#!/usr/bin/env python3
"""
Version Manager
Manages semantic versioning and changelog generation for releases
Usage: ./version-manager.py [command] [options]

Commands:
  current      Show current version
  bump         Bump version (major|minor|patch)
  changelog    Generate changelog from commits
  validate     Validate version string
"""

import argparse
import json
import re
import subprocess
import sys
from dataclasses import dataclass
from datetime import UTC, datetime
from pathlib import Path


@dataclass
class Commit:
    """Represents a parsed commit."""

    hash: str
    type: str
    scope: str | None
    description: str
    body: str
    breaking: bool = False


@dataclass
class Version:
    """Semantic version representation."""

    major: int
    minor: int
    patch: int
    prerelease: str | None = None
    build: str | None = None

    @classmethod
    def parse(cls, version_str: str) -> "Version":
        """Parse a version string like '1.2.3' or 'v1.2.3-beta.1+build.123'."""
        version_str = version_str.lstrip("v")

        # Handle prerelease and build metadata
        prerelease = None
        build = None

        if "+" in version_str:
            version_str, build = version_str.split("+", 1)

        if "-" in version_str:
            version_str, prerelease = version_str.split("-", 1)

        parts = version_str.split(".")
        if len(parts) < 3:
            parts.extend(["0"] * (3 - len(parts)))

        return cls(
            major=int(parts[0]),
            minor=int(parts[1]),
            patch=int(parts[2]),
            prerelease=prerelease,
            build=build,
        )

    def __str__(self) -> str:
        version = f"{self.major}.{self.minor}.{self.patch}"
        if self.prerelease:
            version += f"-{self.prerelease}"
        if self.build:
            version += f"+{self.build}"
        return version

    def bump_major(self) -> "Version":
        return Version(self.major + 1, 0, 0)

    def bump_minor(self) -> "Version":
        return Version(self.major, self.minor + 1, 0)

    def bump_patch(self) -> "Version":
        return Version(self.major, self.minor, self.patch + 1)


def run_git(args: list[str], cwd: Path | None = None) -> tuple[int, str]:
    """Run a git command and return exit code and output."""
    try:
        result = subprocess.run(
            ["git", *args],
            capture_output=True,
            text=True,
            cwd=cwd,
            timeout=30,
        )
        return result.returncode, result.stdout.strip()
    except (subprocess.TimeoutExpired, FileNotFoundError):
        return 1, ""


def get_current_version(cwd: Path | None = None) -> Version | None:
    """Get current version from git tags."""
    code, output = run_git(["describe", "--tags", "--abbrev=0"], cwd)
    if code == 0 and output:
        return Version.parse(output)
    return Version(0, 0, 0)


def get_commits_since_tag(tag: str | None, cwd: Path | None = None) -> list[Commit]:
    """Get commits since the specified tag."""
    if tag:
        code, output = run_git(["log", f"{tag}..HEAD", "--format=%H|%s|%b%n---COMMIT---"], cwd)
    else:
        code, output = run_git(["log", "--format=%H|%s|%b%n---COMMIT---"], cwd)

    if code != 0:
        return []

    commits = []
    for commit_text in output.split("---COMMIT---"):
        commit_text = commit_text.strip()
        if not commit_text:
            continue

        lines = commit_text.split("\n")
        if not lines:
            continue

        first_line = lines[0]
        parts = first_line.split("|", 2)
        if len(parts) < 2:
            continue

        commit_hash = parts[0]
        subject = parts[1]
        body = parts[2] if len(parts) > 2 else ""

        # Parse conventional commit format: type(scope): description
        match = re.match(r"^(\w+)(?:\(([^)]+)\))?(!)?:\s*(.+)$", subject)
        if match:
            commit_type = match.group(1).lower()
            scope = match.group(2)
            breaking = match.group(3) == "!" or "BREAKING" in body.upper()
            description = match.group(4)
        else:
            commit_type = "other"
            scope = None
            breaking = "BREAKING" in body.upper()
            description = subject

        commits.append(
            Commit(
                hash=commit_hash[:7],
                type=commit_type,
                scope=scope,
                description=description,
                body=body,
                breaking=breaking,
            )
        )

    return commits


def suggest_bump(commits: list[Commit]) -> str:
    """Suggest version bump type based on commits."""
    has_breaking = any(c.breaking for c in commits)
    has_features = any(c.type == "feat" for c in commits)

    if has_breaking:
        return "major"
    elif has_features:
        return "minor"
    return "patch"


def generate_changelog(commits: list[Commit], version: Version) -> str:
    """Generate changelog from commits."""
    categories = {
        "Breaking Changes": [],
        "Features": [],
        "Bug Fixes": [],
        "Performance": [],
        "Documentation": [],
        "Other": [],
    }

    type_mapping = {
        "feat": "Features",
        "fix": "Bug Fixes",
        "perf": "Performance",
        "docs": "Documentation",
        "refactor": "Other",
        "style": "Other",
        "test": "Other",
        "chore": "Other",
        "ci": "Other",
    }

    for commit in commits:
        if commit.breaking:
            categories["Breaking Changes"].append(commit)
        else:
            category = type_mapping.get(commit.type, "Other")
            categories[category].append(commit)

    lines = [
        f"## [{version}] - {datetime.now(UTC).strftime('%Y-%m-%d')}",
        "",
    ]

    for category, category_commits in categories.items():
        if not category_commits:
            continue

        lines.append(f"### {category}")
        lines.append("")

        for commit in category_commits:
            scope_str = f"**{commit.scope}:** " if commit.scope else ""
            lines.append(f"- {scope_str}{commit.description} ({commit.hash})")

        lines.append("")

    return "\n".join(lines)


def update_version_file(path: Path, version: Version) -> bool:
    """Update version in a file."""
    if not path.exists():
        return False

    content = path.read_text()
    version_str = str(version)

    # Try different patterns
    patterns = [
        (r'"version":\s*"[^"]*"', f'"version": "{version_str}"'),
        (r"^version\s*=\s*['\"].*['\"]", f'version = "{version_str}"', re.MULTILINE),
        (r"__version__\s*=\s*['\"].*['\"]", f'__version__ = "{version_str}"'),
    ]

    updated = False
    for pattern in patterns:
        flags = pattern[2] if len(pattern) > 2 else 0
        if re.search(pattern[0], content, flags):
            content = re.sub(pattern[0], pattern[1], content, flags=flags)
            updated = True

    if updated:
        path.write_text(content)

    return updated


def find_version_files(cwd: Path) -> list[Path]:
    """Find files that typically contain version numbers."""
    candidates = [
        "package.json",
        "pyproject.toml",
        "Cargo.toml",
        "setup.py",
        "version.py",
        "__version__.py",
    ]

    found = []
    for candidate in candidates:
        path = cwd / candidate
        if path.exists():
            found.append(path)

    return found


def cmd_current(args: argparse.Namespace) -> int:
    """Show current version."""
    cwd = Path(args.path).resolve()
    version = get_current_version(cwd)

    if args.json:
        print(
            json.dumps(
                {
                    "version": str(version) if version else None,
                    "major": version.major if version else 0,
                    "minor": version.minor if version else 0,
                    "patch": version.patch if version else 0,
                }
            )
        )
    else:
        print(f"v{version}" if version else "No version found")

    return 0


def cmd_bump(args: argparse.Namespace) -> int:
    """Bump version."""
    cwd = Path(args.path).resolve()
    current = get_current_version(cwd) or Version(0, 0, 0)

    # Get commits to analyze
    current_tag = f"v{current}" if current.major > 0 or current.minor > 0 or current.patch > 0 else None
    commits = get_commits_since_tag(current_tag, cwd)

    bump_type = args.type
    if bump_type == "auto":
        bump_type = suggest_bump(commits)

    if bump_type == "major":
        new_version = current.bump_major()
    elif bump_type == "minor":
        new_version = current.bump_minor()
    else:
        new_version = current.bump_patch()

    if args.json:
        print(
            json.dumps(
                {
                    "current": str(current),
                    "new": str(new_version),
                    "bump_type": bump_type,
                    "commits_analyzed": len(commits),
                    "has_breaking": any(c.breaking for c in commits),
                    "has_features": any(c.type == "feat" for c in commits),
                }
            )
        )
    else:
        print(f"Current version: v{current}")
        print(f"Bump type: {bump_type}")
        print(f"New version: v{new_version}")
        print(f"\nCommits analyzed: {len(commits)}")

        if not args.dry_run:
            # Update version files
            version_files = find_version_files(cwd)
            for vf in version_files:
                if update_version_file(vf, new_version):
                    print(f"Updated: {vf}")

            print("\nTo create the release:")
            print("  git add .")
            print(f'  git commit -m "chore: Bump version to {new_version}"')
            print(f'  git tag -a "v{new_version}" -m "Release v{new_version}"')
            print(f'  git push origin "v{new_version}"')

    return 0


def cmd_changelog(args: argparse.Namespace) -> int:
    """Generate changelog."""
    cwd = Path(args.path).resolve()
    current = get_current_version(cwd) or Version(0, 0, 0)

    version = Version.parse(args.version) if args.version else current.bump_patch()

    current_tag = f"v{current}" if current.major > 0 or current.minor > 0 or current.patch > 0 else None
    commits = get_commits_since_tag(current_tag, cwd)

    if not commits:
        print("No commits found since last release", file=sys.stderr)
        return 1

    changelog = generate_changelog(commits, version)

    if args.json:
        print(
            json.dumps(
                {
                    "version": str(version),
                    "commits": len(commits),
                    "changelog": changelog,
                }
            )
        )
    else:
        print(changelog)

    return 0


def cmd_validate(args: argparse.Namespace) -> int:
    """Validate version string."""
    try:
        version = Version.parse(args.version)
        if args.json:
            print(
                json.dumps(
                    {
                        "valid": True,
                        "version": str(version),
                        "major": version.major,
                        "minor": version.minor,
                        "patch": version.patch,
                        "prerelease": version.prerelease,
                        "build": version.build,
                    }
                )
            )
        else:
            print(f"Valid: {version}")
        return 0
    except (ValueError, IndexError) as e:
        if args.json:
            print(json.dumps({"valid": False, "error": str(e)}))
        else:
            print(f"Invalid: {e}", file=sys.stderr)
        return 1


def main():
    parser = argparse.ArgumentParser(description="Manage semantic versions and changelogs")
    parser.add_argument("--path", default=".", help="Project path")
    parser.add_argument("--json", action="store_true", help="Output as JSON")

    subparsers = parser.add_subparsers(dest="command", help="Command")

    # current
    subparsers.add_parser("current", help="Show current version")

    # bump
    bump_parser = subparsers.add_parser("bump", help="Bump version")
    bump_parser.add_argument("type", choices=["major", "minor", "patch", "auto"], default="auto", nargs="?")
    bump_parser.add_argument("--dry-run", action="store_true", help="Don't update files")

    # changelog
    changelog_parser = subparsers.add_parser("changelog", help="Generate changelog")
    changelog_parser.add_argument("--version", help="Target version for changelog")

    # validate
    validate_parser = subparsers.add_parser("validate", help="Validate version string")
    validate_parser.add_argument("version", help="Version string to validate")

    args = parser.parse_args()

    if args.command == "current":
        return cmd_current(args)
    elif args.command == "bump":
        return cmd_bump(args)
    elif args.command == "changelog":
        return cmd_changelog(args)
    elif args.command == "validate":
        return cmd_validate(args)
    else:
        parser.print_help()
        return 0


if __name__ == "__main__":
    sys.exit(main())

{
  "skill": "release-management",
  "version": "1.0.0",
  "testCases": [
    {
      "id": "basic-create-a-new-release",
      "rule": "",
      "query": "Create a new release for version 2.1.0 with auto-generated notes from merged PRs. We also need to close the milestone and upload the dist/app.zip build artifact.",
      "expectedBehavior": [
        "Claude ensures main is up to date (git checkout main, git pull)",
        "Creates and pushes a git tag v2.1.0",
        "Runs gh release create v2.1.0 --generate-notes with the build artifact",
        "Closes the milestone via gh api (not --milestone flag)",
        "Follows the standard release workflow order: tag -> release -> milestone close"
      ]
    },
    {
      "id": "edge-we-found-a-critical",
      "rule": "",
      "query": "We found a critical security vulnerability in production on v1.5.3. We need to ship a hotfix release immediately.",
      "expectedBehavior": [
        "Claude follows the hotfix release workflow: branch from release tag v1.5.3",
        "Creates hotfix branch (hotfix/v1.5.4), applies fix, commits",
        "Tags v1.5.4 and creates a GitHub release with clear security hotfix notes",
        "Cherry-picks the fix back to main to keep branches in sync",
        "Uses semantic versioning patch bump (1.5.3 -> 1.5.4)"
      ]
    },
    {
      "id": "negative-add-a-new-endpoint",
      "rule": "",
      "query": "Add a new endpoint to the users API that returns paginated results with cursor-based pagination",
      "expectedBehavior": [
        "Claude does NOT invoke the release-management skill",
        "Implements the API endpoint using standard backend patterns",
        "No release creation, version tagging, or changelog generation"
      ]
    }
  ]
}