vbumper 0.1.0__tar.gz

vbumper-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.3
+Name: vbumper
+Version: 0.1.0
+Summary: Comprehensive version bumper for Python projects
+Author: Danny Stewart
+Author-email: danny@stewart.cc
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: dsbase (>=0.2.2,<0.3.0)
+Project-URL: Repository, https://github.com/dannystewart/dsbin
+Description-Content-Type: text/markdown
+
+# vbumper
+
+A comprehensive version management tool for Python projects.
+
+It handles version bumping in a wide variety of formats, including pre-releases, development versions, and Git operations following PEP 440. It supports major.minor.patch versioning, with pre-release and post-release versions including dev, alpha, beta, rc, and post.
+
+## Usage
+
+```python
+# Regular version bumping
+vbumper                # 1.2.3    -> 1.2.4
+vbumper minor          # 1.2.3    -> 1.3.0
+vbumper major          # 1.2.3    -> 2.0.0
+
+# Pre-release versions
+vbumper dev            # 1.2.3    -> 1.2.4.dev0
+vbumper alpha          # 1.2.3    -> 1.2.4a1
+vbumper beta           # 1.2.4a1  -> 1.2.4b1
+vbumper rc             # 1.2.4b1  -> 1.2.4rc1
+vbumper patch          # 1.2.4rc1 -> 1.2.4
+
+# Post-release version
+vbumper post           # 1.2.4    -> 1.2.4.post1
+```
+
+All operations also include Git tagging and pushing changes to remote repository.
+

vbumper-0.1.0/README.md

@@ -0,0 +1,26 @@
+# vbumper
+
+A comprehensive version management tool for Python projects.
+
+It handles version bumping in a wide variety of formats, including pre-releases, development versions, and Git operations following PEP 440. It supports major.minor.patch versioning, with pre-release and post-release versions including dev, alpha, beta, rc, and post.
+
+## Usage
+
+```python
+# Regular version bumping
+vbumper                # 1.2.3    -> 1.2.4
+vbumper minor          # 1.2.3    -> 1.3.0
+vbumper major          # 1.2.3    -> 2.0.0
+
+# Pre-release versions
+vbumper dev            # 1.2.3    -> 1.2.4.dev0
+vbumper alpha          # 1.2.3    -> 1.2.4a1
+vbumper beta           # 1.2.4a1  -> 1.2.4b1
+vbumper rc             # 1.2.4b1  -> 1.2.4rc1
+vbumper patch          # 1.2.4rc1 -> 1.2.4
+
+# Post-release version
+vbumper post           # 1.2.4    -> 1.2.4.post1
+```
+
+All operations also include Git tagging and pushing changes to remote repository.

vbumper-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "vbumper"
+version = "0.1.0"
+description = "Comprehensive version bumper for Python projects"
+authors = [{ name = "Danny Stewart", email = "danny@stewart.cc" }]
+urls = { repository = "https://github.com/dannystewart/dsbin" }
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "dsbase (>=0.2.2,<0.3.0)",
+]
+
+[tool.poetry.group.dev.dependencies]
+mypy = ">=1.15.0"
+ruff = ">=0.11.2"
+
+[build-system]
+requires = ["poetry-core>=2.0"]
+build-backend = "poetry.core.masonry.api"
+
+[project.scripts]
+vbumper = "vbumper.main:main"

vbumper-0.1.0/src/vbumper/__init__.py

@@ -0,0 +1,27 @@
+"""Version management tool for Python projects.
+
+Handles version bumping, pre-releases, development versions, and git operations following PEP 440.
+Supports major.minor.patch versioning with dev/alpha/beta/rc prerelease (and post-release) versions.
+
+Usage:
+    # Regular version bumping
+    dsbump                # 1.2.3    -> 1.2.4
+    dsbump minor          # 1.2.3    -> 1.3.0
+    dsbump major          # 1.2.3    -> 2.0.0
+
+    # Pre-release versions
+    dsbump dev            # 1.2.3    -> 1.2.4.dev0
+    dsbump alpha          # 1.2.3    -> 1.2.4a1
+    dsbump beta           # 1.2.4a1  -> 1.2.4b1
+    dsbump rc             # 1.2.4b1  -> 1.2.4rc1
+    dsbump patch          # 1.2.4rc1 -> 1.2.4
+
+    # Post-release version
+    dsbump post           # 1.2.4    -> 1.2.4.post1
+
+All operations include git tagging and pushing changes to remote repository.
+"""
+
+from __future__ import annotations
+
+from .vbumper import VersionBumper

vbumper-0.1.0/src/vbumper/bump_type.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from functools import total_ordering
+
+
+@total_ordering
+class BumpType(StrEnum):
+    """Version bump types following PEP 440.
+
+    Progression:
+    - Pre-release: dev -> alpha -> beta -> rc
+    - Release: patch -> minor -> major
+    - Post-release: post (only after final release)
+    """
+
+    DEV = "dev"
+    ALPHA = "alpha"
+    BETA = "beta"
+    RC = "rc"
+    POST = "post"
+    PATCH = "patch"
+    MINOR = "minor"
+    MAJOR = "major"
+
+    @property
+    def is_prerelease(self) -> bool:
+        """Whether this is a pre-release version type."""
+        return self in {self.DEV, self.ALPHA, self.BETA, self.RC}
+
+    @property
+    def is_release(self) -> bool:
+        """Whether this is a regular release version type."""
+        return self in {self.PATCH, self.MINOR, self.MAJOR}
+
+    @property
+    def version_suffix(self) -> str:
+        """Get the suffix used in version strings."""
+        match self:
+            case self.DEV:
+                return ".dev"
+            case self.ALPHA:
+                return "a"
+            case self.BETA:
+                return "b"
+            case self.RC:
+                return "rc"
+            case self.POST:
+                return ".post"
+            case _:
+                return ""
+
+    def sort_value(self) -> int:
+        """Get numeric sort value for comparison."""
+        order = {
+            self.DEV: -1,
+            self.ALPHA: 0,
+            self.BETA: 1,
+            self.RC: 2,
+            self.POST: 10,
+            self.PATCH: 3,
+            self.MINOR: 4,
+            self.MAJOR: 5,
+        }
+        return order[self]
+
+    def __lt__(self, other: BumpType | str) -> bool:
+        """Compare bump types for ordering."""
+        try:
+            other = BumpType(other)
+        except ValueError:
+            return NotImplemented
+        return self.sort_value() < other.sort_value()
+
+    def can_progress_to(self, other: BumpType) -> bool:
+        """Check if this version type can progress to another."""
+        # Can't go backwards in pre-release chain
+        if self.is_prerelease and other.is_prerelease:
+            return self.sort_value() < other.sort_value()
+
+        # Can't add post-release to pre-release
+        if self.is_prerelease and other == self.POST:
+            return False
+
+        # Can always go to a release version
+        if other.is_release:
+            return True
+
+        # Can add post-release to release versions
+        return bool(self.is_release and other == self.POST)

vbumper-0.1.0/src/vbumper/git.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from dsbase.util import handle_interrupt
+
+from vbumper.bump_type import BumpType
+
+if TYPE_CHECKING:
+    from logging import Logger
+
+    from vbumper.versions import VersionHelper
+
+
+@dataclass
+class GitHelper:
+    """Helper class for git operations."""
+
+    version_helper: VersionHelper
+    logger: Logger
+    commit_message: str | None = None
+    cleanup_tags: bool = False
+    push_to_remote: bool = True
+
+    @handle_interrupt()
+    def check_git_state(self) -> None:
+        """Check if we're in a git repository and on a valid branch."""
+        try:  # Check if we're in a git repo
+            subprocess.run(["git", "rev-parse", "--git-dir"], check=True, capture_output=True)
+        except subprocess.CalledProcessError:
+            self.logger.error("Not a git repository.")
+            sys.exit(1)
+
+        # Check if we're on a branch (not in detached HEAD state)
+        result = subprocess.run(
+            ["git", "symbolic-ref", "--short", "HEAD"], capture_output=True, text=True, check=False
+        )
+        if result.returncode != 0:
+            self.logger.error("Not on a git branch (detached HEAD state).")
+            sys.exit(1)
+
+    @handle_interrupt()
+    def detect_version_prefix(self) -> str:
+        """Detect whether versions are tagged with 'v' prefix based on existing tags.
+
+        Returns:
+            "v" if versions use v-prefix, "" if they use bare numbers
+        """
+        try:
+            # Get all tags sorted by version
+            result = subprocess.run(
+                ["git", "tag", "--sort=v:refname"], capture_output=True, text=True, check=True
+            )
+            tags = result.stdout.strip().split("\n")
+
+            # Filter out empty results
+            tags = [tag for tag in tags if tag]
+            if not tags:
+                # Default to "v" prefix for new projects
+                return "v"
+
+            # Look at the most recent tag that starts with either v or a number
+            for tag in reversed(tags):
+                if tag.startswith("v") or tag[0].isdigit():
+                    return "v" if tag.startswith("v") else ""
+
+            # If no matching tags found, default to "v" prefix
+            return "v"
+
+        except subprocess.CalledProcessError:
+            # If git commands fail, default to "v" prefix
+            return "v"
+
+    @handle_interrupt()
+    def tag_current_version(self) -> None:
+        """Tag and push the current version without incrementing.
+
+        Creates a new commit with the current version number, then tags and pushes it.
+
+        Args:
+            commit_message: Custom commit message (if None, default is used).
+        """
+        pyproject = Path("pyproject.toml")
+        if not pyproject.exists():
+            self.logger.error("No pyproject.toml found in current directory.")
+            sys.exit(1)
+
+        self.check_git_state()
+        current_version = self.version_helper.get_version()
+        version_prefix = self.detect_version_prefix()
+        tag_name = f"{version_prefix}{current_version}"
+
+        # Check if tag already exists
+        if (
+            subprocess.run(
+                ["git", "rev-parse", tag_name], capture_output=True, check=False
+            ).returncode
+            == 0
+        ):
+            self.logger.error("Tag %s already exists.", tag_name)
+            sys.exit(1)
+
+        # Create a new commit with the current version number
+        has_other_changes = self.commit_version_change(current_version)
+        if has_other_changes:
+            self.logger.info(
+                "Committed pyproject.toml without version change. "
+                "Other changes in the working directory were skipped and preserved."
+            )
+
+        # Create tag
+        subprocess.run(["git", "tag", tag_name], check=True)
+
+        # Push changes and tags
+        subprocess.run(["git", "push"], check=True)
+        subprocess.run(["git", "push", "--tags"], check=True)
+
+        self.logger.info("Successfully tagged and pushed version %s!", current_version)
+
+    @handle_interrupt()
+    def perform_tag_cleanup(self, old_ver: str, new_ver: str) -> None:
+        """Remove all pre-release tags for relevant versions.
+
+        Removes tags based on version bump type:
+        - Major bump (1.x -> 2.x): Removes all 1.x pre-release tags
+        - Minor bump (1.1 -> 1.2): Removes all 1.1.x pre-release tags
+        - Patch bump (1.1.1 -> 1.1.2): Removes only 1.1.2 pre-release tags
+        """
+        self.logger.debug(
+            "Checking for pre-release tags to clean up when moving from %s to %s.",
+            old_ver,
+            new_ver,
+        )
+
+        patterns = self._identify_tag_patterns(old_ver, new_ver)
+
+        all_tags = set()
+        for pattern in patterns:
+            result = subprocess.run(
+                ["git", "tag", "-l", pattern], capture_output=True, text=True, check=True
+            )
+            tags = result.stdout.strip().split("\n")
+            if tags and tags[0]:  # Check if we actually found any tags
+                all_tags.update(tags)
+
+        if all_tags:
+            self.logger.info("Cleaning up %d pre-release tags.", len(all_tags))
+            self._remove_found_tags(all_tags)
+
+    def _identify_tag_patterns(self, old_ver: str, new_ver: str) -> list[str]:
+        """Find tag patterns to clean up based on version bump.
+
+        Determines which pre-release tags should be cleaned up based on the type of version bump
+        (major/minor/patch).
+
+        Returns:
+            List of glob patterns matching tags to be removed.
+        """
+        old = self.version_helper.parse_version(old_ver)
+        new = self.version_helper.parse_version(new_ver)
+
+        version_prefix = self.detect_version_prefix()
+
+        prerelease_patterns = [
+            t.version_suffix + "*"
+            for t in [BumpType.DEV, BumpType.ALPHA, BumpType.BETA, BumpType.RC]
+        ]
+
+        patterns = []
+        if new.major > old.major:
+            patterns.extend(
+                f"{version_prefix}{old.major}.*{pattern}" for pattern in prerelease_patterns
+            )
+        elif new.minor > old.minor:
+            patterns.extend(
+                f"{version_prefix}{old.major}.{old.minor}.*{pattern}"
+                for pattern in prerelease_patterns
+            )
+        else:
+            patterns.extend(
+                f"{version_prefix}{new.major}.{new.minor}.{new.patch}{pattern}"
+                for pattern in prerelease_patterns
+            )
+
+        return patterns
+
+    @handle_interrupt()
+    def _remove_found_tags(self, found_tags: set[str]) -> None:
+        """Remove identified pre-release tags.
+
+        Removes tags both locally and from remote if it exists. Remote tag deletion failures are
+        ignored as tags might not exist remotely.
+
+        Args:
+            found_tags: Set of tag names to remove.
+        """
+        # Remove local tags
+        for tag in found_tags:
+            self.logger.info("Removing tag: %s", tag)
+            subprocess.run(["git", "tag", "-d", tag], check=True)
+
+        # Remove remote tags if remote exists
+        remote_check = subprocess.run(
+            ["git", "remote"], capture_output=True, text=True, check=False
+        )
+        if remote_check.stdout.strip():
+            self.logger.debug("Removing remote tags...")
+            subprocess.run(
+                ["git", "push", "--delete", "origin", *list(found_tags)],
+                capture_output=True,
+                check=False,
+            )
+
+    def commit_version_change(self, new_version: str) -> bool:
+        """Commit version change to git.
+
+        Args:
+            new_version: The new version string.
+            commit_message: Optional custom commit message.
+
+        Returns:
+            True if there were other uncommitted changes, False otherwise.
+        """
+        # Check for uncommitted changes
+        result = subprocess.run(
+            ["git", "status", "--porcelain"], capture_output=True, text=True, check=True
+        )
+        has_other_changes = any(
+            not line.endswith("pyproject.toml") for line in result.stdout.splitlines()
+        )
+
+        # Stage only pyproject.toml
+        subprocess.run(["git", "add", "pyproject.toml"], check=True)
+
+        # Use custom message if provided, otherwise use default
+        message = self.commit_message or f"Bump version to {new_version}"
+        subprocess.run(["git", "commit", "-m", message], check=True)
+
+        return has_other_changes
+
+    def should_perform_cleanup(
+        self, bump_type: BumpType | str | list[BumpType] | None, new_ver: str
+    ) -> bool:
+        """Determine if tag cleanup should be performed.
+
+        Args:
+            bump_type: The type of version bump performed.
+            new_ver: The new version string.
+        """
+        if isinstance(bump_type, list):
+            # If the last bump type in the list isn't a pre-release, clean up tags
+            if not bump_type:
+                return False
+            return not bump_type[-1].is_prerelease
+
+        if isinstance(bump_type, BumpType):
+            version = self.version_helper.parse_version(new_ver)
+            # If new version is a release version
+            return version.pre_type is None
+
+        if isinstance(bump_type, str) and bump_type.count(".") >= 2:  # Explicit version
+            return not any(
+                t.version_suffix in bump_type
+                for t in [BumpType.DEV, BumpType.ALPHA, BumpType.BETA, BumpType.RC]
+            )
+
+        return False
+
+    def create_and_push_tag(self, tag_name: str) -> None:
+        """Create and push a git tag."""
+        if (  # Check if tag already exists
+            subprocess.run(
+                ["git", "rev-parse", tag_name], capture_output=True, check=False
+            ).returncode
+            == 0
+        ):
+            self.logger.error("Tag %s already exists.", tag_name)
+            sys.exit(1)
+
+        # Create tag and push
+        subprocess.run(["git", "tag", tag_name], check=True)
+        subprocess.run(["git", "push"], check=True)
+        subprocess.run(["git", "push", "--tags"], check=True)
+
+    @handle_interrupt()
+    def handle_git_operations(
+        self,
+        new_version: str,
+        bump_type: BumpType | str | list[BumpType] | None,
+        current_version: str,
+    ) -> None:
+        """Handle git commit, tag, and push operations.
+
+        Args:
+            new_version: The version string to tag with.
+            bump_type: The type of version bump performed.
+            current_version: The previous version string.
+        """
+        version_prefix = self.detect_version_prefix()
+        tag_name = f"{version_prefix}{new_version}"
+
+        # Handle version bump commit if needed
+        if bump_type is not None:
+            has_other_changes = self.commit_version_change(new_version)
+            if has_other_changes:
+                self.logger.info(
+                    "Committed pyproject.toml with the version bump. "
+                    "Other changes in the working directory were skipped and preserved."
+                )
+
+        # Clean up pre-release tags when moving to a release version (if cleanup=True)
+        if self.cleanup_tags and self.should_perform_cleanup(bump_type, new_version):
+            self.perform_tag_cleanup(current_version, new_version)
+
+        # Create tag
+        if (  # Check if tag already exists
+            subprocess.run(
+                ["git", "rev-parse", tag_name], capture_output=True, check=False
+            ).returncode
+            == 0
+        ):
+            self.logger.error("Tag %s already exists.", tag_name)
+            sys.exit(1)
+
+        subprocess.run(["git", "tag", tag_name], check=True)
+
+        if self.push_to_remote:  # Push changes and tags
+            subprocess.run(["git", "push"], check=True)
+            subprocess.run(["git", "push", "--tags"], check=True)
+        else:
+            self.logger.info(
+                "Changes committed and tagged locally. Use 'git push && git push --tags' to push to remote."
+            )

vbumper-0.1.0/src/vbumper/main.py

@@ -0,0 +1,59 @@
+"""Version management tool for Python projects."""
+
+from __future__ import annotations
+
+import argparse
+
+from dsbase.util import dsbase_setup
+
+from vbumper import VersionBumper
+from vbumper.bump_type import BumpType
+
+dsbase_setup()
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "type",
+        nargs="*",
+        default=[BumpType.PATCH],
+        help="version bump type(s): major, minor, patch, dev, alpha, beta, rc, post, or x.y.z",
+    )
+    parser.add_argument("-f", "--force", action="store_true", help="skip confirmation prompt")
+    parser.add_argument(
+        "--cleanup",
+        action="store_true",
+        help="clean up pre-release tags when finalizing a version",
+    )
+    parser.add_argument(
+        "-m",
+        "--message",
+        help="custom commit message (default: 'Bump version to x.y.z')",
+    )
+
+    # Mutually exclusive group for push options
+    push_group = parser.add_mutually_exclusive_group()
+    push_group.add_argument(
+        "--keep-version",
+        action="store_true",
+        help="tag and push the current version without incrementing",
+    )
+    push_group.add_argument(
+        "--no-push",
+        action="store_true",
+        help="commit and tag changes but don't push to remote",
+    )
+
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Perform version bump."""
+    args = parse_args()
+    VersionBumper(args).perform_bump()
+
+
+if __name__ == "__main__":
+    main()

vbumper-0.1.0/src/vbumper/vbumper.py

@@ -0,0 +1,196 @@
+"""Version management tool for Python projects."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from dsbase.env import DSEnv
+from dsbase.log import LocalLogger
+from dsbase.shell import confirm_action
+from dsbase.util import dsbase_setup, handle_interrupt
+
+from vbumper.bump_type import BumpType
+from vbumper.git import GitHelper
+from vbumper.versions import VersionHelper
+
+if TYPE_CHECKING:
+    import argparse
+
+dsbase_setup()
+
+
+class VersionBumper:
+    """Version management tool for Python projects."""
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        # Create DSEnv to manage debug flag
+        env = DSEnv()
+        env.add_debug_var()
+
+        # Create logger with debug flag; use simple logger if debug is off
+        self.logger = LocalLogger().get_logger(
+            level="debug" if env.debug else "info", simple=not env.debug
+        )
+
+        # Parse command-line arguments into instance variables
+        self.keep_version = args.keep_version
+        self.force = args.force
+        self.type = args.type
+
+        # Whether to push changes to remote (default is True unless --no-push is specified)
+        self.push_to_remote = not args.no_push
+
+        # Verify and load pyproject.toml
+        self.pyproject_path = Path("pyproject.toml")
+        if not self.pyproject_path.exists():
+            self.logger.error("No pyproject.toml found in current directory.")
+            sys.exit(1)
+
+        # Initialize helpers
+        self.version_helper = VersionHelper(self.pyproject_path, self.logger)
+        self.git = GitHelper(
+            self.version_helper, self.logger, args.message, args.cleanup, self.push_to_remote
+        )
+
+        # Get current version as a Version object
+        self.current_version = self.version_helper.get_version_object()
+        self.current_ver_str = str(self.current_version)
+
+    def perform_bump(self) -> None:
+        """Perform version bump."""
+        try:
+            # Handle --keep-version flag (tag current version without incrementing)
+            if self.keep_version:
+                if self.type and self.type != [BumpType.PATCH.value]:
+                    self.logger.error("--keep-version cannot be used with version bump arguments")
+                    sys.exit(1)
+                self.git.tag_current_version()
+                return
+
+            # Default to patch if no types specified
+            type_args = self.type or [BumpType.PATCH.value]
+            bump_type = self.version_helper.parse_bump_types(type_args)
+
+            # Calculate new version
+            new_version_obj = self.current_version
+
+            # If we have multiple bump types, sort them in a consistent order
+            if isinstance(bump_type, list):
+                # Sort and apply bumps in logical order
+                sorted_bumps = self._sort_bump_types(bump_type)
+                for bt in sorted_bumps:
+                    new_version_obj = self.version_helper.bump_version(bt, new_version_obj)
+            else:
+                new_version_obj = self.version_helper.bump_version(bump_type, self.current_version)
+
+            new_version_str = str(new_version_obj)
+
+            # Show version info
+            self.logger.info("Current version: %s", self.current_ver_str)
+            self.logger.info("Will bump to:    %s", new_version_str)
+
+            # Prompt for confirmation unless --force is used
+            if not self.force:
+                if not confirm_action("Proceed with version bump?"):
+                    self.logger.info("Version bump cancelled.")
+                    return
+
+            self.update_version(bump_type, new_version_str)
+        except Exception as e:
+            self.logger.error(str(e))
+            sys.exit(1)
+
+    def _sort_bump_types(self, bump_types: list[BumpType]) -> list[BumpType]:
+        """Sort bump types in logical order: major/minor/patch, then pre-release, then post."""
+        # First apply all regular version bumps (major, minor, patch) in that order
+        regular_bumps = [bt for bt in bump_types if bt.is_release]
+        # Sort by priority (major > minor > patch)
+        regular_bumps.sort(reverse=True)
+
+        # Then apply all pre-release bumps in order (dev, alpha, beta, rc)
+        prerelease_bumps = [bt for bt in bump_types if bt.is_prerelease]
+        prerelease_bumps.sort()
+
+        # Finally apply post if present
+        post_bumps = [bt for bt in bump_types if bt == BumpType.POST]
+
+        # Combine in the right order
+        return regular_bumps + prerelease_bumps + post_bumps
+
+    @handle_interrupt()
+    def update_version(self, bump_type: BumpType | str | list[BumpType], new_version: str) -> None:
+        """Update version, create git tag, and push changes.
+
+        Args:
+            bump_type: The version's BumpType or list of BumpTypes, or a specific version string.
+            new_version: The calculated new version string.
+        """
+        try:
+            self.git.check_git_state()
+
+            # Update version in pyproject.toml
+            if bump_type is not None:
+                self._update_version_in_pyproject(self.pyproject_path, new_version)
+
+            # Handle git operations
+            self.git.handle_git_operations(new_version, bump_type, self.current_ver_str)
+
+            # Log success
+            action = "tagged" if bump_type is None else "updated to"
+            push_status = "" if self.push_to_remote else " (not pushed)"
+            self.logger.info("Successfully %s v%s%s!", action, new_version, push_status)
+
+        except Exception as e:
+            self.logger.error("Version update failed: %s", str(e))
+            raise
+
+    def _update_version_in_pyproject(self, pyproject: Path, new_version: str) -> None:
+        """Update version in pyproject.toml while preserving formatting."""
+        content = pyproject.read_text()
+        lines = content.splitlines()
+
+        # Find the version line
+        version_line_idx = None
+        in_project = False
+
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            if stripped.startswith("[project]"):
+                in_project = True
+            elif stripped.startswith("["):  # Any other section
+                in_project = False
+
+            if in_project and stripped.startswith("version"):
+                version_line_idx = i
+                break
+
+        if version_line_idx is None:
+            self.logger.error("Could not find version field in project section.")
+            sys.exit(1)
+
+        # Update the version line while preserving indentation
+        current_line = lines[version_line_idx]
+        if "=" in current_line:
+            before_version = current_line.split("=")[0]
+            quote_char = '"' if '"' in current_line else "'"
+            lines[version_line_idx] = f"{before_version}= {quote_char}{new_version}{quote_char}"
+
+        # Verify the new content is valid TOML before writing
+        new_content = "\n".join(lines) + "\n"
+        try:
+            import tomllib
+
+            tomllib.loads(new_content)
+        except tomllib.TOMLDecodeError:
+            self.logger.error("Version update would create invalid TOML. Aborting.")
+            sys.exit(1)
+
+        # Write back the file
+        pyproject.write_text(new_content)
+
+        # Verify the changes
+        if self.version_helper.get_version() != new_version:
+            self.logger.error("Version update failed verification.")
+            sys.exit(1)

vbumper-0.1.0/src/vbumper/versions.py

@@ -0,0 +1,353 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from vbumper.bump_type import BumpType
+
+if TYPE_CHECKING:
+    from logging import Logger
+    from pathlib import Path
+
+
+@dataclass
+class Version:
+    """Represents a parsed version."""
+
+    version_string: str
+    major: int
+    minor: int
+    patch: int
+    pre_type: BumpType | None
+    pre_num: int | None
+
+    def __str__(self) -> str:
+        return self.version_string
+
+
+@dataclass
+class VersionHelper:
+    """Helper class for version-related operations."""
+
+    pyproject_path: Path
+    logger: Logger
+
+    def get_version(self) -> str:
+        """Get current version from pyproject.toml."""
+        content = self.pyproject_path.read_text()
+        try:
+            import tomllib
+
+            data = tomllib.loads(content)
+            if "project" in data and "version" in data["project"]:
+                return data["project"]["version"]
+            self.logger.error("Could not find version in pyproject.toml (project.version).")
+            sys.exit(1)
+        except tomllib.TOMLDecodeError:
+            self.logger.error(
+                "Invalid TOML format in pyproject.toml. Do you even know how to use a text editor?"
+            )
+            sys.exit(1)
+
+    def get_version_object(self) -> Version:
+        """Get current version from pyproject.toml as a Version object."""
+        version_str = self.get_version()
+        return self.parse_version(version_str)
+
+    def parse_version(self, version_str: str) -> Version:
+        """Parse version string into a Version object."""
+        major, minor, patch, pre_type, pre_num = self._parse_version_components(version_str)
+        return Version(version_str, major, minor, patch, pre_type, pre_num)
+
+    def _parse_version_components(
+        self, version: str
+    ) -> tuple[int, int, int, BumpType | None, int | None]:
+        """Parse version string into components.
+
+        Args:
+            version: Version string (e.g., '1.2.3', '1.2.3a1', '1.2.3.post1').
+
+        Returns:
+            Tuple of (major, minor, patch, pre-release type, pre-release number).
+            Pre-release type is BumpType.DEV/ALPHA/BETA/RC/POST or None.
+            Pre-release number can be None if no pre-release.
+        """
+        # Handle post suffix (.postN)
+        if ".post" in version:
+            version_part, post_num = version.rsplit(".post", 1)
+            try:
+                pre_num = int(post_num)
+            except ValueError:
+                self.logger.error("Invalid post-release number: %s", post_num)
+                sys.exit(1)
+            major, minor, patch = map(int, version_part.split("."))
+            return major, minor, patch, BumpType.POST, pre_num
+
+        # Handle dev suffix (.devN)
+        if ".dev" in version:
+            version_part, dev_num = version.rsplit(".dev", 1)
+            try:
+                pre_num = int(dev_num)
+            except ValueError:
+                self.logger.error("Invalid dev number: %s", dev_num)
+                sys.exit(1)
+            major, minor, patch = map(int, version_part.split("."))
+            return major, minor, patch, BumpType.DEV, pre_num
+
+        # Handle pre-release suffixes (aN, bN, rcN)
+        suffix_map = {"a": BumpType.ALPHA, "b": BumpType.BETA, "rc": BumpType.RC}
+        for suffix, bump_type in suffix_map.items():
+            if suffix in version:
+                version_part, pre_num = version.rsplit(suffix, 1)
+                try:
+                    major, minor, patch = map(int, version_part.split("."))
+                    return major, minor, patch, bump_type, int(pre_num)
+                except ValueError:
+                    self.logger.error("Invalid pre-release number: %s", pre_num)
+                    sys.exit(1)
+
+        try:  # Parse version numbers
+            major, minor, patch = map(int, version.split("."))
+            return major, minor, patch, None, None
+        except ValueError:
+            self.logger.error(
+                "Invalid version format: %s. Numbers go left to right, champ.", version
+            )
+            sys.exit(1)
+
+    def bump_version(self, bump_type: BumpType | str, version: Version) -> Version:
+        """Calculate new version based on bump type and current version.
+
+        Args:
+            bump_type: Version bump type (major/minor/patch/alpha/beta/rc) or specific version.
+            version: Current version object.
+
+        Returns:
+            New version object.
+        """
+        # Handle explicit version numbers
+        if bump_type.count(".") >= 2:
+            self._handle_explicit_version(bump_type)
+            new_version_str = bump_type
+            return self.parse_version(new_version_str)
+
+        # Convert to enum if it's a string
+        bump_type_enum = BumpType(bump_type) if not isinstance(bump_type, BumpType) else bump_type
+
+        # Handle different bump types
+        if bump_type_enum == BumpType.MAJOR:
+            # Major bump resets minor and patch to 0
+            new_version_str = f"{version.major + 1}.0.0"
+            return self.parse_version(new_version_str)
+
+        if bump_type_enum == BumpType.MINOR:
+            # Minor bump resets patch to 0
+            new_version_str = f"{version.major}.{version.minor + 1}.0"
+            return self.parse_version(new_version_str)
+
+        if bump_type_enum == BumpType.PATCH:
+            # For a patch bump, we need to check if we're finalizing a pre-release
+            if version.pre_type and version.pre_type.is_prerelease:
+                # Finalizing a pre-release - keep same version but drop pre-release suffix
+                new_version_str = f"{version.major}.{version.minor}.{version.patch}"
+            else:
+                # Regular patch bump
+                new_version_str = f"{version.major}.{version.minor}.{version.patch + 1}"
+            return self.parse_version(new_version_str)
+
+        # Handle pre-release and post-release bumps
+        if bump_type_enum.is_prerelease or bump_type_enum == BumpType.POST:
+            # For dev, alpha, beta, rc, post
+            return self._handle_version_modifier(bump_type_enum, version)
+
+        self.logger.error("Invalid bump type: %s", bump_type)
+        sys.exit(1)
+
+    def _handle_special_bump(self, bump_type: BumpType | str, version: Version) -> Version:
+        """Handle special bump types like dev, alpha, beta, rc, post."""
+        bump_type_enum = BumpType(bump_type) if not isinstance(bump_type, BumpType) else bump_type
+
+        # Determine what the next version should be based on the bump type
+        if bump_type_enum == BumpType.DEV:
+            # For dev versions, we want to start with .dev0
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}.dev0"
+        elif bump_type_enum.is_prerelease:
+            # For other pre-releases, we increment to the next version
+            new_version_str = (
+                f"{version.major}.{version.minor}.{version.patch}{bump_type_enum.version_suffix}1"
+            )
+        elif bump_type_enum == BumpType.POST:
+            # For post-releases, we add .post1
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}.post1"
+        else:
+            self.logger.error("Invalid bump type for post-release: %s", bump_type)
+            sys.exit(1)
+
+        return self.parse_version(new_version_str)
+
+    def _get_base_version(self, bump_type: BumpType | str, version: Version) -> Version:
+        """Calculate base version based on bump type."""
+        if bump_type.count(".") >= 2:
+            return self.parse_version(bump_type)
+
+        # Now we know it's a BumpType
+        bump_type_enum = BumpType(bump_type) if not isinstance(bump_type, BumpType) else bump_type
+
+        # Handle pre-release bumping
+        if bump_type_enum.is_prerelease or bump_type_enum == BumpType.POST:
+            return self._handle_version_modifier(bump_type_enum, version)
+
+        # When moving from pre-release to release
+        if version.pre_type and bump_type_enum == BumpType.PATCH:
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}"
+            return self.parse_version(new_version_str)
+
+        # Handle regular version bumping
+        match bump_type_enum:
+            case BumpType.MAJOR:
+                new_version_str = f"{version.major + 1}.0.0"
+            case BumpType.MINOR:
+                new_version_str = f"{version.major}.{version.minor + 1}.0"
+            case BumpType.PATCH:
+                new_version_str = f"{version.major}.{version.minor}.{version.patch + 1}"
+            case _:
+                self.logger.error("Invalid bump type: %s", bump_type)
+                sys.exit(1)
+
+        return self.parse_version(new_version_str)
+
+    def _handle_explicit_version(self, version: str) -> None:
+        """Validate explicit version number format."""
+        # Parse version to extract the base part (major.minor.patch)
+        major, minor, patch, _, _ = self._parse_version_components(version)
+
+        # Validate the numbers
+        if any(n < 0 for n in (major, minor, patch)):
+            self.logger.error("Invalid version number: %s. Numbers cannot be negative.", version)
+            sys.exit(1)
+
+    def _handle_version_modifier(self, bump_type: BumpType, version: Version) -> Version:
+        """Calculate pre-release version bump."""
+        if bump_type == BumpType.POST:
+            return self._handle_post_release(version)
+
+        if bump_type == BumpType.DEV:
+            return self._handle_dev_release(version)
+
+        # Handle alpha, beta, rc
+        return self._handle_prerelease(bump_type, version)
+
+    def _handle_post_release(self, version: Version) -> Version:
+        """Handle post-release version bump."""
+        if version.pre_type == BumpType.POST and version.pre_num:
+            # Increment existing post-release
+            new_version_str = (
+                f"{version.major}.{version.minor}.{version.patch}.post{version.pre_num + 1}"
+            )
+        elif version.pre_type and version.pre_type.is_prerelease:
+            # Can't add post-release to pre-release
+            self.logger.error(
+                "Can't add post-release to %s%s, genius. "
+                "How can you post-release something that isn't released? "
+                "Finalize the version first.",
+                version.pre_type,
+                version.pre_num,
+            )
+            sys.exit(1)
+        else:
+            # Add post-release to regular version
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}.post1"
+
+        return self.parse_version(new_version_str)
+
+    def _handle_dev_release(self, version: Version) -> Version:
+        """Handle dev version bump."""
+        if version.pre_type == BumpType.DEV and version.pre_num is not None:
+            # Increment existing dev version
+            new_version_str = (
+                f"{version.major}.{version.minor}.{version.patch}.dev{version.pre_num + 1}"
+            )
+        else:
+            # Start new dev series
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}.dev0"
+
+        return self.parse_version(new_version_str)
+
+    def _handle_prerelease(self, bump_type: BumpType, version: Version) -> Version:
+        """Handle alpha, beta, rc version bumps."""
+        new_suffix = bump_type.version_suffix
+
+        # Check for invalid progression
+        if version.pre_type and version.pre_type.sort_value() > bump_type.sort_value():
+            self.logger.error(
+                "Can't go backwards from %s to %s, idiot. Version progression is: dev -> alpha -> beta -> rc",
+                version.pre_type.version_suffix,
+                new_suffix,
+            )
+            sys.exit(1)
+
+        # Determine the new version string
+        if version.pre_type == bump_type and version.pre_num is not None:
+            # Increment same pre-release type (e.g., beta1 -> beta2)
+            new_version_str = (
+                f"{version.major}.{version.minor}.{version.patch}{new_suffix}{version.pre_num + 1}"
+            )
+        elif version.pre_type and version.pre_type.is_prerelease and version.pre_type != bump_type:
+            # Progress to next pre-release stage (e.g., alpha1 -> beta1)
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}{new_suffix}1"
+        else:
+            # Start new pre-release series
+            new_version_str = f"{version.major}.{version.minor}.{version.patch}{new_suffix}1"
+
+        return self.parse_version(new_version_str)
+
+    def parse_bump_types(self, type_args: list[str]) -> BumpType | list[BumpType] | str:
+        """Parse bump type arguments into appropriate format."""
+        # Handle explicit version case
+        if len(type_args) == 1 and type_args[0].count(".") >= 2:
+            return type_args[0]
+
+        # Handle multiple bump types
+        bump_types = []
+        for t in type_args:
+            if hasattr(BumpType, t.upper()):
+                bump_types.append(BumpType(t))
+            else:
+                self.logger.error(
+                    "Invalid argument: %s. Must be a bump type (%s) or version number (x.y.z)",
+                    t,
+                    ", ".join(item.value for item in BumpType),
+                )
+                sys.exit(1)
+
+        return bump_types if len(bump_types) > 1 else bump_types[0]
+
+    @staticmethod
+    def detect_version_prefix() -> str:
+        """Detect whether versions are tagged with 'v' prefix based on existing tags."""
+        try:
+            # Get all tags sorted by version
+            result = subprocess.run(
+                ["git", "tag", "--sort=v:refname"], capture_output=True, text=True, check=True
+            )
+            tags = result.stdout.strip().split("\n")
+
+            # Filter out empty results
+            tags = [tag for tag in tags if tag]
+            if not tags:
+                # Default to "v" prefix for new projects
+                return "v"
+
+            # Look at the most recent tag that starts with either v or a number
+            for tag in reversed(tags):
+                if tag.startswith("v") or tag[0].isdigit():
+                    return "v" if tag.startswith("v") else ""
+
+            # If no matching tags found, default to 'v' prefix
+            return "v"
+
+        except subprocess.CalledProcessError:
+            # If git commands fail, default to 'v' prefix
+            return "v"