#!/bin/python
import subprocess
import os
import re
from datetime import datetime
from typing import List, Optional, Tuple, Dict
def get_version_from_changelog(file_path="CHANGELOG.md"):
"""Extract the most recent version from the changelog file."""
try:
with open(file_path, 'r') as file:
for line in file:
match = re.search(r'## \[(.*?)\]', line)
if match:
return match.group(1)
except FileNotFoundError:
pass
return None
def add_version(current_version: str, increment_type: str = "patch") -> str:
"""
Increment the version number according to semantic versioning.
Args:
current_version: The current version string (e.g., "1.2.3")
increment_type: The part of the version to increment ("major", "minor", or "patch")
Returns:
The new version string
"""
if not current_version:
return "0.1.0" # Default starting version
# Parse version components
match = re.match(r'^(\d+)\.(\d+)\.(\d+)(-([a-zA-Z0-9.-]+))?(\+([a-zA-Z0-9.-]+))?$', current_version)
if not match:
raise ValueError(f"Invalid version format: {current_version}. Expected format: X.Y.Z[-prerelease][+build]")
major, minor, patch = int(match.group(1)), int(match.group(2)), int(match.group(3))
prerelease = match.group(5) if match.group(4) else None
build = match.group(7) if match.group(6) else None
# Increment appropriate component
if increment_type == "major":
major += 1
minor = 0
patch = 0
prerelease = None # Clear prerelease on major version bump
elif increment_type == "minor":
minor += 1
patch = 0
prerelease = None # Clear prerelease on minor version bump
elif increment_type == "patch":
patch += 1
prerelease = None # Clear prerelease on patch version bump
elif increment_type.startswith("pre"):
# Handle prerelease versions
if prerelease:
# If it's already a prerelease, try to increment its number
pre_parts = prerelease.split('.')
if len(pre_parts) > 1 and pre_parts[-1].isdigit():
pre_parts[-1] = str(int(pre_parts[-1]) + 1)
prerelease = '.'.join(pre_parts)
else:
prerelease = f"{prerelease}.1"
else:
# Start a new prerelease version
prerelease_type = increment_type[3:] or "alpha" # Extract alpha/beta/rc or default to alpha
prerelease = f"{prerelease_type}.1"
else:
raise ValueError(
f"Invalid increment type: {increment_type}. Expected 'major', 'minor', 'patch', or 'pre[type]'")
# Construct new version
new_version = f"{major}.{minor}.{patch}"
if prerelease:
new_version += f"-{prerelease}"
if build:
new_version += f"+{build}"
return new_version
class ChangelogGenerator:
def __init__(self):
version = get_version_from_changelog() or "0.1.0"
# print(version)
self.version: str = version
self.changes: Dict[str, List[str]] = {
"Added": [],
"Changed": [],
"Deprecated": [],
"Removed": [],
"Fixed": [],
"Security": []
}
def increment_version(self, increment_type: str = "patch"):
"""
Increment the version number according to semantic versioning.
Args:
increment_type: The part of the version to increment
("major", "minor", "patch", or "pre[type]")
"""
self.version = add_version(self.version, increment_type)
return self.version
def get_git_diff(self, file_path: str, staged: bool = False) -> str:
"""Get git diff for a file."""
try:
if not os.path.exists(file_path) and not staged:
return ""
cmd = ['git', 'diff']
if staged:
cmd.append('--cached')
cmd.append('--')
cmd.append(file_path)
result = subprocess.run(
cmd,
capture_output=True,
text=True,
check=False
)
return result.stdout
except subprocess.CalledProcessError:
return ""
def analyze_file_changes(self, file_path: str, staged: bool = False) -> str:
"""Analyze file changes to determine the type of change."""
diff = self.get_git_diff(file_path, staged)
# Simple rule-based classification
if not os.path.exists(file_path) and not staged:
return "Removed"
elif os.path.exists(file_path) and not staged:
return "Added" if "+++" in diff else "Changed"
# For staged files
if "new file" in diff:
return "Added"
elif "deleted file" in diff:
return "Removed"
elif "security" in diff.lower() or "vuln" in diff.lower():
return "Security"
elif "deprecat" in diff.lower():
return "Deprecated"
elif "fix" in diff.lower() or "bug" in diff.lower():
return "Fixed"
else:
return "Changed"
def add_change(self, change_type: str, message: str):
"""Add a change to the changelog."""
if change_type in self.changes:
self.changes[change_type].append(message)
def generate_changelog(self, staged: bool = False) -> str:
"""Generate a changelog based on git changes."""
try:
# Get changed files
if staged:
result = subprocess.run(
['git', 'diff', '--cached', '--name-only'],
capture_output=True,
text=True,
check=True
)
else:
result = subprocess.run(
['git', 'ls-files', '--modified', '--others', '--exclude-standard'],
capture_output=True,
text=True,
check=True
)
files = result.stdout.strip().split('\n')
# Analyze each file
for file in files:
if file:
change_type = self.analyze_file_changes(file, staged)
self.add_change(change_type, f"Changes in {file}")
# Generate markdown
today = datetime.now().strftime("%Y-%m-%d")
changelog = f"## [{self.version}] - {today}\n\n"
for section, changes in self.changes.items():
if changes:
changelog += f"### {section}\n"
for change in changes:
changelog += f"- {change}\n"
changelog += "\n"
return changelog
except subprocess.CalledProcessError as e:
print(f"Error executing git command: {e}")
return ""
def update_changelog_file(self, output_file: str = "CHANGELOG.md", staged: bool = False,
increment_type: str = None):
"""
Update the CHANGELOG.md file.
Args:
output_file: Path to the changelog file
staged: Whether to include staged changes only
increment_type: If provided, increment the version before updating
("major", "minor", "patch", or None to keep current version)
"""
# Increment version if requested
if increment_type:
self.increment_version(increment_type)
new_changes = self.generate_changelog(staged)
if not new_changes:
return
try:
existing_content = ""
if os.path.exists(output_file):
with open(output_file, 'r', encoding='utf-8') as f:
existing_content = f.read()
with open(output_file, 'w', encoding='utf-8') as f:
if not existing_content:
f.write("# Changelog\n\n")
f.write("All notable changes to this project will be documented in this file.\n\n")
f.write(new_changes)
else:
# Insert new changes after the header
parts = existing_content.split('\n\n', 2)
f.write(parts[0] + '\n\n')
if len(parts) > 1:
f.write(parts[1] + '\n\n')
f.write(new_changes)
if len(parts) > 2:
f.write(parts[2])
except Exception as e:
print(f"Error updating changelog file: {e}")
def main():
generator = ChangelogGenerator()
# Check for command-line arguments to determine increment type
import sys
increment_type = "patch" # Default increment
if len(sys.argv) > 1:
increment_type = sys.argv[1] # Use provided increment type
generator.update_changelog_file(staged=True, increment_type=increment_type)
print(f"Updated changelog to version {generator.version}")
if __name__ == "__main__":
main()
