pymelos 0.1.3__py3-none-any.whl

pymelos/uv/sync.py

@@ -0,0 +1,168 @@
+"""uv sync operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pymelos.uv.client import run_uv, run_uv_async
+
+
+def sync(
+    cwd: Path,
+    *,
+    frozen: bool = False,
+    locked: bool = True,
+    all_extras: bool = False,
+    dev: bool = True,
+    all_packages: bool = True,
+) -> tuple[int, str, str]:
+    """Run uv sync at the specified path.
+
+    Args:
+        cwd: Working directory (workspace root).
+        frozen: Use frozen dependencies (no updates).
+        locked: Require lock file to be up to date.
+        all_extras: Install all extras.
+        dev: Install dev dependencies.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+    """
+    args = ["sync"]
+
+    if frozen:
+        args.append("--frozen")
+    if locked:
+        args.append("--locked")
+    if all_extras:
+        args.append("--all-extras")
+    if all_packages:
+        args.append("--all-packages")
+    if not dev:
+        args.append("--no-dev")
+
+    result = run_uv(args, cwd=cwd, check=False)
+    return result.returncode, result.stdout, result.stderr
+
+
+async def sync_async(
+    cwd: Path,
+    *,
+    frozen: bool = False,
+    locked: bool = True,
+    all_extras: bool = False,
+    dev: bool = True,
+    all_packages: bool = True,
+) -> tuple[int, str, str]:
+    """Run uv sync asynchronously.
+
+    Args:
+        cwd: Working directory.
+        frozen: Use frozen dependencies.
+        locked: Require lock file to be up to date.
+        all_extras: Install all extras.
+        dev: Install dev dependencies.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+    """
+    args = ["sync"]
+
+    if frozen:
+        args.append("--frozen")
+    if locked:
+        args.append("--locked")
+    if all_extras:
+        args.append("--all-extras")
+    if all_packages:
+        args.append("--all-packages")
+
+    if not dev:
+        args.append("--no-dev")
+
+    return await run_uv_async(args, cwd=cwd, check=False)
+
+
+def lock(cwd: Path) -> tuple[int, str, str]:
+    """Update the lock file.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+    """
+    result = run_uv(["lock"], cwd=cwd, check=False)
+    return result.returncode, result.stdout, result.stderr
+
+
+def add_dependency(
+    cwd: Path,
+    package: str,
+    *,
+    dev: bool = False,
+    extras: list[str] | None = None,
+) -> tuple[int, str, str]:
+    """Add a dependency.
+
+    Args:
+        cwd: Working directory.
+        package: Package to add (e.g., "requests>=2.0").
+        dev: Add as dev dependency.
+        extras: Extras to include.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+    """
+    args = ["add", package]
+
+    if dev:
+        args.append("--dev")
+    if extras:
+        for extra in extras:
+            args.extend(["--extra", extra])
+
+    result = run_uv(args, cwd=cwd, check=False)
+    return result.returncode, result.stdout, result.stderr
+
+
+def remove_dependency(
+    cwd: Path,
+    package: str,
+    *,
+    dev: bool = False,
+) -> tuple[int, str, str]:
+    """Remove a dependency.
+
+    Args:
+        cwd: Working directory.
+        package: Package to remove.
+        dev: Remove from dev dependencies.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+    """
+    args = ["remove", package]
+
+    if dev:
+        args.append("--dev")
+
+    result = run_uv(args, cwd=cwd, check=False)
+    return result.returncode, result.stdout, result.stderr
+
+
+def pip_list(cwd: Path) -> list[tuple[str, str]]:
+    """List installed packages.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        List of (name, version) tuples.
+    """
+    result = run_uv(["pip", "list", "--format", "json"], cwd=cwd)
+
+    import json
+
+    packages = json.loads(result.stdout)
+    return [(p["name"], p["version"]) for p in packages]

pymelos/versioning/__init__.py

@@ -0,0 +1,57 @@
+"""Semantic versioning and release management."""
+
+from pymelos.versioning.changelog import (
+    generate_changelog_entry,
+    get_latest_version_from_changelog,
+    prepend_to_changelog,
+    read_changelog,
+)
+from pymelos.versioning.conventional import (
+    ParsedCommit,
+    determine_bump,
+    filter_commits_by_type,
+    group_commits_by_type,
+    is_conventional_commit,
+    parse_commit,
+    parse_commit_message,
+)
+from pymelos.versioning.semver import (
+    BumpType,
+    Version,
+    compare_versions,
+    is_valid_semver,
+)
+from pymelos.versioning.updater import (
+    find_version_files,
+    get_pyproject_version,
+    update_all_versions,
+    update_init_version,
+    update_pyproject_version,
+)
+
+__all__ = [
+    # SemVer
+    "Version",
+    "BumpType",
+    "is_valid_semver",
+    "compare_versions",
+    # Conventional Commits
+    "ParsedCommit",
+    "parse_commit",
+    "parse_commit_message",
+    "determine_bump",
+    "is_conventional_commit",
+    "filter_commits_by_type",
+    "group_commits_by_type",
+    # Changelog
+    "generate_changelog_entry",
+    "prepend_to_changelog",
+    "read_changelog",
+    "get_latest_version_from_changelog",
+    # Updater
+    "update_pyproject_version",
+    "get_pyproject_version",
+    "update_init_version",
+    "find_version_files",
+    "update_all_versions",
+]

pymelos/versioning/changelog.py

@@ -0,0 +1,189 @@
+"""Changelog generation."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+
+from pymelos.versioning.conventional import ParsedCommit, group_commits_by_type
+
+
+def generate_changelog_entry(
+    version: str,
+    commits: list[ParsedCommit],
+    *,
+    date: datetime | None = None,
+    package_name: str | None = None,
+    sections: list[tuple[str, str]] | None = None,
+    hidden_types: set[str] | None = None,
+) -> str:
+    """Generate a changelog entry for a release.
+
+    Args:
+        version: New version string.
+        commits: Commits included in this release.
+        date: Release date (defaults to now).
+        package_name: Package name (for multi-package repos).
+        sections: List of (type, title) tuples for section ordering.
+        hidden_types: Commit types to exclude from changelog.
+
+    Returns:
+        Markdown changelog entry.
+    """
+    if date is None:
+        date = datetime.now(timezone.utc)
+
+    date_str = date.strftime("%Y-%m-%d")
+
+    # Build header
+    if package_name:
+        header = f"## [{package_name}@{version}] - {date_str}\n"
+    else:
+        header = f"## [{version}] - {date_str}\n"
+
+    # Default sections
+    if sections is None:
+        sections = [
+            ("feat", "Features"),
+            ("fix", "Bug Fixes"),
+            ("perf", "Performance"),
+            ("refactor", "Refactoring"),
+            ("docs", "Documentation"),
+            ("style", "Style"),
+            ("test", "Tests"),
+            ("chore", "Chores"),
+            ("ci", "CI"),
+            ("build", "Build"),
+            ("revert", "Reverts"),
+        ]
+
+    hidden = hidden_types or {"docs", "style", "chore", "ci", "test"}
+
+    # Group commits
+    grouped = group_commits_by_type(commits)
+
+    # Build sections
+    lines: list[str] = [header]
+
+    # Breaking changes first
+    breaking_commits = [c for c in commits if c.breaking]
+    if breaking_commits:
+        lines.append("\n### BREAKING CHANGES\n")
+        for commit in breaking_commits:
+            scope = f"**{commit.scope}:** " if commit.scope else ""
+            lines.append(f"- {scope}{commit.description}")
+            if commit.body and "BREAKING CHANGE:" in commit.body:
+                # Extract breaking change description
+                for line in commit.body.split("\n"):
+                    if line.startswith("BREAKING CHANGE:"):
+                        bc_desc = line.replace("BREAKING CHANGE:", "").strip()
+                        lines.append(f"  - {bc_desc}")
+                        break
+        lines.append("")
+
+    # Other sections
+    for commit_type, title in sections:
+        if commit_type in hidden:
+            continue
+
+        type_commits = grouped.get(commit_type, [])
+        # Filter out breaking changes (already shown)
+        type_commits = [c for c in type_commits if not c.breaking]
+
+        if not type_commits:
+            continue
+
+        lines.append(f"\n### {title}\n")
+        for commit in type_commits:
+            scope = f"**{commit.scope}:** " if commit.scope else ""
+            sha_link = f"([{commit.sha[:7]}])" if commit.sha else ""
+            lines.append(f"- {scope}{commit.description} {sha_link}".rstrip())
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def _create_new_changelog(entry: str) -> str:
+    """Create new changelog content with header."""
+    return f"""# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+{entry}
+"""
+
+
+def _find_insert_index(lines: list[str]) -> int:
+    """Find index to insert new changelog entry."""
+    for i, line in enumerate(lines):
+        if line.startswith("## ["):
+            return i
+        if line.startswith("# ") or not line.strip():
+            continue
+    return len(lines)
+
+
+def prepend_to_changelog(
+    changelog_path: Path,
+    entry: str,
+    *,
+    create_if_missing: bool = True,
+) -> None:
+    """Prepend a changelog entry to an existing changelog file.
+
+    Args:
+        changelog_path: Path to CHANGELOG.md.
+        entry: Changelog entry to prepend.
+        create_if_missing: Create the file if it doesn't exist.
+    """
+    if not changelog_path.exists():
+        if not create_if_missing:
+            raise FileNotFoundError(f"Changelog not found: {changelog_path}")
+        changelog_path.write_text(_create_new_changelog(entry), encoding="utf-8")
+        return
+
+    lines = changelog_path.read_text(encoding="utf-8").split("\n")
+    insert_index = _find_insert_index(lines)
+    new_lines = lines[:insert_index] + [entry.strip(), ""] + lines[insert_index:]
+    changelog_path.write_text("\n".join(new_lines), encoding="utf-8")
+
+
+def read_changelog(changelog_path: Path) -> str | None:
+    """Read changelog content.
+
+    Args:
+        changelog_path: Path to CHANGELOG.md.
+
+    Returns:
+        Changelog content or None if not found.
+    """
+    if not changelog_path.exists():
+        return None
+    return changelog_path.read_text(encoding="utf-8")
+
+
+def get_latest_version_from_changelog(changelog_path: Path) -> str | None:
+    """Extract the latest version from a changelog.
+
+    Args:
+        changelog_path: Path to CHANGELOG.md.
+
+    Returns:
+        Latest version string or None if not found.
+    """
+    content = read_changelog(changelog_path)
+    if not content:
+        return None
+
+    import re
+
+    # Match version headers like: ## [1.2.3] or ## [pkg@1.2.3]
+    pattern = r"## \[(?:[\w-]+@)?(\d+\.\d+\.\d+(?:-[\w.]+)?)\]"
+    match = re.search(pattern, content)
+
+    if match:
+        return match.group(1)
+    return None

pymelos/versioning/conventional.py

@@ -0,0 +1,216 @@
+"""Conventional commit parsing."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pymelos.versioning.semver import BumpType
+
+if TYPE_CHECKING:
+    from pymelos.git.commits import Commit
+
+# Conventional commit regex
+# Matches: type(scope)!: description
+# Examples:
+#   feat: add new feature
+#   fix(core): fix bug
+#   feat!: breaking change
+#   refactor(api)!: breaking refactor
+CONVENTIONAL_PATTERN = re.compile(
+    r"^(?P<type>feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert)"
+    r"(?:\((?P<scope>[^)]+)\))?"
+    r"(?P<breaking>!)?"
+    r": (?P<description>.+)$",
+    re.IGNORECASE,
+)
+
+# Mapping from commit type to bump type
+TYPE_TO_BUMP: dict[str, BumpType] = {
+    "feat": BumpType.MINOR,
+    "fix": BumpType.PATCH,
+    "perf": BumpType.PATCH,
+    "refactor": BumpType.NONE,
+    "docs": BumpType.NONE,
+    "style": BumpType.NONE,
+    "test": BumpType.NONE,
+    "chore": BumpType.NONE,
+    "ci": BumpType.NONE,
+    "build": BumpType.NONE,
+    "revert": BumpType.PATCH,
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedCommit:
+    """A parsed conventional commit.
+
+    Attributes:
+        sha: Commit SHA.
+        type: Commit type (feat, fix, etc.).
+        scope: Optional scope.
+        description: Commit description.
+        body: Commit body.
+        breaking: Whether this is a breaking change.
+        raw_message: Original commit message.
+    """
+
+    sha: str
+    type: str
+    scope: str | None
+    description: str
+    body: str | None
+    breaking: bool
+    raw_message: str
+
+    @property
+    def bump_type(self) -> BumpType:
+        """Get the version bump type for this commit."""
+        if self.breaking:
+            return BumpType.MAJOR
+        return TYPE_TO_BUMP.get(self.type.lower(), BumpType.NONE)
+
+    @property
+    def formatted_scope(self) -> str:
+        """Get scope formatted for display."""
+        if self.scope:
+            return f"({self.scope})"
+        return ""
+
+    @property
+    def formatted_type(self) -> str:
+        """Get type formatted for changelog."""
+        type_labels = {
+            "feat": "Features",
+            "fix": "Bug Fixes",
+            "perf": "Performance",
+            "refactor": "Refactoring",
+            "docs": "Documentation",
+            "style": "Style",
+            "test": "Tests",
+            "chore": "Chores",
+            "ci": "CI",
+            "build": "Build",
+            "revert": "Reverts",
+        }
+        return type_labels.get(self.type.lower(), self.type.capitalize())
+
+
+def parse_commit_message(message: str, sha: str = "") -> ParsedCommit | None:
+    """Parse a commit message in conventional commit format.
+
+    Args:
+        message: Commit message to parse.
+        sha: Commit SHA.
+
+    Returns:
+        ParsedCommit if the message follows conventional commit format, None otherwise.
+    """
+    lines = message.strip().split("\n")
+    first_line = lines[0]
+
+    match = CONVENTIONAL_PATTERN.match(first_line)
+    if not match:
+        return None
+
+    body = "\n".join(lines[1:]).strip() if len(lines) > 1 else None
+
+    # Check for breaking change in body
+    breaking = bool(match.group("breaking"))
+    if body and ("BREAKING CHANGE:" in body or "BREAKING-CHANGE:" in body):
+        breaking = True
+
+    return ParsedCommit(
+        sha=sha,
+        type=match.group("type").lower(),
+        scope=match.group("scope"),
+        description=match.group("description"),
+        body=body,
+        breaking=breaking,
+        raw_message=message,
+    )
+
+
+def parse_commit(commit: Commit) -> ParsedCommit | None:
+    """Parse a Commit object into a ParsedCommit.
+
+    Args:
+        commit: Git commit object.
+
+    Returns:
+        ParsedCommit if valid, None otherwise.
+    """
+    return parse_commit_message(commit.message, commit.sha)
+
+
+def determine_bump(commits: list[ParsedCommit]) -> BumpType:
+    """Determine the highest bump type from a list of commits.
+
+    Args:
+        commits: List of parsed commits.
+
+    Returns:
+        The highest bump type needed.
+    """
+    if not commits:
+        return BumpType.NONE
+
+    bump = BumpType.NONE
+    for commit in commits:
+        if commit.bump_type > bump:
+            bump = commit.bump_type
+        if bump == BumpType.MAJOR:
+            # Can't go higher
+            break
+
+    return bump
+
+
+def filter_commits_by_type(
+    commits: list[ParsedCommit],
+    types: list[str],
+) -> list[ParsedCommit]:
+    """Filter commits by type.
+
+    Args:
+        commits: List of commits.
+        types: Types to include (e.g., ["feat", "fix"]).
+
+    Returns:
+        Filtered commits.
+    """
+    type_set = {t.lower() for t in types}
+    return [c for c in commits if c.type.lower() in type_set]
+
+
+def group_commits_by_type(
+    commits: list[ParsedCommit],
+) -> dict[str, list[ParsedCommit]]:
+    """Group commits by their type.
+
+    Args:
+        commits: List of commits.
+
+    Returns:
+        Dictionary mapping type to commits.
+    """
+    groups: dict[str, list[ParsedCommit]] = {}
+    for commit in commits:
+        commit_type = commit.type.lower()
+        if commit_type not in groups:
+            groups[commit_type] = []
+        groups[commit_type].append(commit)
+    return groups
+
+
+def is_conventional_commit(message: str) -> bool:
+    """Check if a message follows conventional commit format.
+
+    Args:
+        message: Commit message to check.
+
+    Returns:
+        True if it's a valid conventional commit.
+    """
+    return parse_commit_message(message) is not None