✨ Integrate automatic changelog generation in release script

Implement automatic changelog generation during release process

This change enhances the release workflow by leveraging the recently
added version name feature:

- Add get_previous_tag() to determine the previous release tag
- Implement generate_changelog() to create changelog entries
- Update git commit process to include CHANGELOG.md
- Improve code formatting with consistent function spacing
- Add error handling for subprocess calls with check=False
- Fix file handling with proper encoding parameters

This creates a seamless release experience where version bumping
and changelog generation happen in a single coordinated workflow.

Author: hyperb1iss

scripts/release.py

@@ -36,34 +36,40 @@
 # Gradient colors for the banner
 GRADIENT_COLORS = [
     (138, 43, 226),  # BlueViolet
-    (75, 0, 130),    # Indigo
-    (0, 191, 255),   # DeepSkyBlue
+    (75, 0, 130),  # Indigo
+    (0, 191, 255),  # DeepSkyBlue
     (30, 144, 255),  # DodgerBlue
     (138, 43, 226),  # BlueViolet
-    (75, 0, 130),    # Indigo
-    (0, 191, 255),   # DeepSkyBlue
+    (75, 0, 130),  # Indigo
+    (0, 191, 255),  # DeepSkyBlue
 ]
 
+
 def print_colored(message: str, color: str) -> None:
     """Print a message with a specific color."""
     print(f"{color}{message}{COLOR_RESET}")
 
+
 def print_step(step: str) -> None:
     """Print a step in the process with a specific color."""
     print_colored(f"\n✨ {step}", COLOR_STEP)
 
+
 def print_error(message: str) -> None:
     """Print an error message with a specific color."""
     print_colored(f"❌ Error: {message}", COLOR_ERROR)
 
+
 def print_success(message: str) -> None:
     """Print a success message with a specific color."""
     print_colored(f"✅ {message}", COLOR_SUCCESS)
 
+
 def print_warning(message: str) -> None:
     """Print a warning message with a specific color."""
     print_colored(f"⚠️  {message}", COLOR_WARNING)
 
+
 def generate_gradient(colors: List[Tuple[int, int, int]], steps: int) -> List[str]:
     """Generate a list of color codes for a smooth multi-color gradient."""
     gradient = []
@@ -82,28 +88,33 @@ def generate_gradient(colors: List[Tuple[int, int, int]], steps: int) -> List[st
 
     return gradient
 
+
 def strip_ansi(text: str) -> str:
     """Remove ANSI color codes from a string."""
     ansi_escape = re.compile(r"\x1B[@-_][0-?]*[ -/]*[@-~]")
     return ansi_escape.sub("", text)
 
+
 def apply_gradient(text: str, gradient: List[str], line_number: int) -> str:
     """Apply gradient colors diagonally to text."""
     return "".join(
         f"{gradient[(i + line_number) % len(gradient)]}{char}"
         for i, char in enumerate(text)
     )
 
+
 def center_text(text: str, width: int) -> str:
     """Center text, accounting for ANSI color codes and Unicode widths."""
     visible_length = wcswidth(strip_ansi(text))
     padding = (width - visible_length) // 2
     return f"{' ' * padding}{text}{' ' * (width - padding - visible_length)}"
 
+
 def center_block(block: List[str], width: int) -> List[str]:
     """Center a block of text within a given width."""
     return [center_text(line, width) for line in block]
 
+
 def create_banner() -> str:
     """Create a beautiful cosmic-themed banner with diagonal gradient."""
     banner_width = 80
@@ -133,57 +144,84 @@ def create_banner() -> str:
 
     release_manager_text = COLOR_STEP + "Release Manager"
 
-    banner.extend([
-        f"{COLOR_BORDER}╰{'─' * (banner_width - 2)}╯",
-        center_text(f"{COLOR_STAR}∴｡　　･ﾟ*｡☆ {release_manager_text}{COLOR_STAR} ☆｡*ﾟ･　 ｡∴", banner_width),
-        center_text(f"{COLOR_STAR}･ ｡ ☆ ∴｡　　･ﾟ*｡★･ ∴｡　　･ﾟ*｡☆ ･ ｡ ☆ ∴｡", banner_width),
-    ])
+    banner.extend(
+        [
+            f"{COLOR_BORDER}╰{'─' * (banner_width - 2)}╯",
+            center_text(
+                f"{COLOR_STAR}∴｡　　･ﾟ*｡☆ {release_manager_text}{COLOR_STAR} ☆｡*ﾟ･　 ｡∴",
+                banner_width,
+            ),
+            center_text(
+                f"{COLOR_STAR}･ ｡ ☆ ∴｡　　･ﾟ*｡★･ ∴｡　　･ﾟ*｡☆ ･ ｡ ☆ ∴｡", banner_width
+            ),
+        ]
+    )
 
     return "\n".join(banner)
 
+
 def print_logo() -> None:
     """Print the banner/logo for the release manager."""
     print(create_banner())
 
+
 def check_tool_installed(tool_name: str) -> None:
     """Check if a tool is installed."""
     if shutil.which(tool_name) is None:
         print_error(f"{tool_name} is not installed. Please install it and try again.")
         sys.exit(1)
 
+
 def check_branch() -> None:
     """Ensure we're on the main branch."""
-    current_branch = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"]).decode().strip()
+    current_branch = (
+        subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+        .decode()
+        .strip()
+    )
     if current_branch != "main":
         print_error("You must be on the main branch to release.")
         sys.exit(1)
 
+
 def check_uncommitted_changes() -> None:
     """Check for uncommitted changes."""
-    result = subprocess.run(["git", "diff-index", "--quiet", "HEAD", "--"], capture_output=True)
+    result = subprocess.run(
+        ["git", "diff-index", "--quiet", "HEAD", "--"], capture_output=True, check=False
+    )
     if result.returncode != 0:
-        print_error("You have uncommitted changes. Please commit or stash them before releasing.")
+        print_error(
+            "You have uncommitted changes. Please commit or stash them before releasing."
+        )
         sys.exit(1)
 
+
 def get_current_version() -> str:
     """Get the current version from Cargo.toml."""
-    with open("Cargo.toml", "r") as f:
+    with open("Cargo.toml", "r", encoding="utf-8") as f:
         content = f.read()
     match = re.search(r'version\s*=\s*"(\d+\.\d+\.\d+)"', content)
     if match:
         return match.group(1)
     print_error("Could not find version in Cargo.toml")
     sys.exit(1)
 
+
 def update_version(new_version: str) -> None:
     """Update the version in Cargo.toml."""
-    with open("Cargo.toml", "r") as f:
+    with open("Cargo.toml", "r", encoding="utf-8") as f:
         content = f.read()
-    updated_content = re.sub(r'^(version\s*=\s*)"(\d+\.\d+\.\d+)"', f'\\1"{new_version}"', content, flags=re.MULTILINE)
-    with open("Cargo.toml", "w") as f:
+    updated_content = re.sub(
+        r'^(version\s*=\s*)"(\d+\.\d+\.\d+)"',
+        f'\\1"{new_version}"',
+        content,
+        flags=re.MULTILINE,
+    )
+    with open("Cargo.toml", "w", encoding="utf-8") as f:
         f.write(updated_content)
     print_success(f"Updated version in Cargo.toml to {new_version}")
 
+
 def run_checks() -> None:
     """Run cargo check and cargo test."""
     print_step("Running cargo check")
@@ -192,19 +230,90 @@ def run_checks() -> None:
     subprocess.run(["cargo", "test"], check=True)
     print_success("All checks passed")
 
+
+def get_previous_tag() -> str:
+    """Get the most recent tag before the current HEAD."""
+    try:
+        # First, get all tags sorted by creation date (most recent first)
+        all_tags = (
+            subprocess.check_output(["git", "tag", "--sort=-creatordate"], text=True)
+            .strip()
+            .split("\n")
+        )
+
+        # Check if we have any tags at all
+        if not all_tags or all_tags[0] == "":
+            print_warning("No tags found. Using initial commit as reference.")
+            return subprocess.check_output(
+                ["git", "rev-list", "--max-parents=0", "HEAD"], text=True
+            ).strip()
+
+        # If we have at least two tags, return the second one
+        if len(all_tags) >= 2:
+            return all_tags[1]
+
+        # If we only have one tag, use the initial commit
+        print_warning("Could not find previous tag. Using initial commit as reference.")
+        return subprocess.check_output(
+            ["git", "rev-list", "--max-parents=0", "HEAD"], text=True
+        ).strip()
+    except subprocess.CalledProcessError:
+        print_warning("Could not find previous tag. Using initial commit as reference.")
+        # If no previous tag exists, return the initial commit hash
+        return subprocess.check_output(
+            ["git", "rev-list", "--max-parents=0", "HEAD"], text=True
+        ).strip()
+
+
+def generate_changelog(new_version: str) -> None:
+    """Generate changelog using git-iris."""
+    print_step("Generating changelog with git-iris")
+    previous_tag = get_previous_tag()
+
+    try:
+        print_step(
+            f"Updating changelog from {previous_tag} to HEAD with version {new_version}"
+        )
+        subprocess.run(
+            [
+                "cargo",
+                "run",
+                "--",
+                "changelog",
+                "--from",
+                previous_tag,
+                "--to",
+                "HEAD",
+                "--update",
+                "--version-name",
+                new_version,
+            ],
+            check=True,
+        )
+        print_success("Changelog updated successfully")
+    except subprocess.CalledProcessError as e:
+        print_error(f"Failed to generate changelog: {str(e)}")
+        sys.exit(1)
+
+
 def show_changes() -> bool:
     """Show changes and ask for confirmation."""
     print_warning("The following files will be modified:")
-    subprocess.run(["git", "status", "--porcelain"])
-    confirmation = input(f"{COLOR_VERSION_PROMPT}Do you want to proceed with these changes? (y/N): {COLOR_RESET}").lower()
+    subprocess.run(["git", "status", "--porcelain"], check=False)
+    confirmation = input(
+        f"{COLOR_VERSION_PROMPT}Do you want to proceed with these changes? (y/N): {COLOR_RESET}"
+    ).lower()
     return confirmation == "y"
 
+
 def commit_and_push(version: str) -> None:
     """Commit and push changes to the repository."""
     print_step("Committing and pushing changes")
     try:
-        subprocess.run(["git", "add", "Cargo.*"], check=True)
-        subprocess.run(["git", "commit", "-m", f":rocket: Release version {version}"], check=True)
+        subprocess.run(["git", "add", "Cargo.*", "CHANGELOG.md"], check=True)
+        subprocess.run(
+            ["git", "commit", "-m", f":rocket: Release version {version}"], check=True
+        )
         subprocess.run(["git", "push"], check=True)
         subprocess.run(["git", "tag", f"v{version}"], check=True)
         subprocess.run(["git", "push", "--tags"], check=True)
@@ -213,10 +322,12 @@ def commit_and_push(version: str) -> None:
         print_error(f"Git operations failed: {str(e)}")
         sys.exit(1)
 
+
 def is_valid_version(version: str) -> bool:
     """Validate version format."""
     return re.match(r"^\d+\.\d+\.\d+$", version) is not None
 
+
 def main() -> None:
     """Main function to handle the release process."""
     print_logo()
@@ -229,22 +340,31 @@ def main() -> None:
     check_uncommitted_changes()
 
     current_version = get_current_version()
-    new_version = input(f"{COLOR_VERSION_PROMPT}Current version is {current_version}. What should the new version be? {COLOR_RESET}")
+    new_version = input(
+        f"{COLOR_VERSION_PROMPT}Current version is {current_version}. What should the new version be? {COLOR_RESET}"
+    )
 
     if not is_valid_version(new_version):
-        print_error("Invalid version format. Please use semantic versioning (e.g., 1.2.3).")
+        print_error(
+            "Invalid version format. Please use semantic versioning (e.g., 1.2.3)."
+        )
         sys.exit(1)
 
     update_version(new_version)
     run_checks()
 
+    generate_changelog(new_version)
+
     if not show_changes():
         print_error("Release cancelled.")
         sys.exit(1)
 
     commit_and_push(new_version)
 
-    print_success(f"\n🎉✨ {PROJECT_NAME} v{new_version} has been successfully released! ✨🎉")
+    print_success(
+        f"\n🎉✨ {PROJECT_NAME} v{new_version} has been successfully released! ✨🎉"
+    )
+
 
 if __name__ == "__main__":
-    main()
+    main()