pymelos 0.1.3__py3-none-any.whl

pymelos/filters/since.py

@@ -0,0 +1,98 @@
+"""Git-based package filtering (--since)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pymelos.workspace.package import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+def get_changed_files(
+    root: Path,
+    since: str,
+    *,
+    include_untracked: bool = True,
+) -> set[Path]:
+    """Get files changed since a git reference.
+
+    Args:
+        root: Repository root.
+        since: Git reference (branch, tag, commit).
+        include_untracked: Include untracked files.
+
+    Returns:
+        Set of changed file paths (relative to root).
+    """
+    from pymelos.git import get_changed_files_since
+
+    return get_changed_files_since(root, since, include_untracked=include_untracked)
+
+
+def get_changed_packages(
+    workspace: Workspace,
+    since: str,
+    *,
+    include_dependents: bool = False,
+) -> list[Package]:
+    """Get packages that have changed since a git reference.
+
+    Args:
+        workspace: Workspace instance.
+        since: Git reference.
+        include_dependents: Also include packages that depend on changed packages.
+
+    Returns:
+        List of changed packages.
+    """
+    changed_files = get_changed_files(workspace.root, since)
+
+    # Map changed files to packages
+    changed_packages: list[Package] = []
+
+    for package in workspace.packages.values():
+        # Check if any changed file is within this package
+        for changed_file in changed_files:
+            abs_changed = workspace.root / changed_file
+            try:
+                abs_changed.relative_to(package.path)
+                if package not in changed_packages:
+                    changed_packages.append(package)
+                break
+            except ValueError:
+                continue
+
+    if include_dependents:
+        affected = workspace.get_affected_packages(changed_packages)
+        return affected
+
+    return changed_packages
+
+
+def filter_by_since(
+    packages: list[Package],
+    workspace: Workspace,
+    since: str | None,
+    *,
+    include_dependents: bool = False,
+) -> list[Package]:
+    """Filter packages to only those changed since a git reference.
+
+    Args:
+        packages: List of packages to filter.
+        workspace: Workspace instance.
+        since: Git reference.
+        include_dependents: Also include packages that depend on changed packages.
+
+    Returns:
+        Filtered list of packages.
+    """
+    if not since:
+        return packages
+
+    changed = get_changed_packages(workspace, since, include_dependents=include_dependents)
+    changed_names = {p.name for p in changed}
+
+    return [p for p in packages if p.name in changed_names]

pymelos/git/__init__.py

@@ -0,0 +1,69 @@
+"""Git operations."""
+
+from pymelos.git.changes import (
+    get_changed_files_since,
+    get_commits_since,
+    get_files_in_commit,
+    get_merge_base,
+    is_ancestor,
+)
+from pymelos.git.commits import (
+    Commit,
+    get_commit,
+    get_commits,
+    get_commits_affecting_path,
+)
+from pymelos.git.repo import (
+    get_current_branch,
+    get_current_commit,
+    get_default_branch,
+    get_repo_root,
+    is_clean,
+    is_git_repo,
+    run_git_command,
+    run_git_command_async,
+)
+from pymelos.git.tags import (
+    Tag,
+    create_tag,
+    delete_tag,
+    get_latest_package_tag,
+    get_latest_tag,
+    get_package_tags,
+    get_tags_for_commit,
+    list_tags,
+    parse_version_from_tag,
+)
+
+__all__ = [
+    # Repo
+    "is_git_repo",
+    "get_repo_root",
+    "run_git_command",
+    "run_git_command_async",
+    "get_current_branch",
+    "get_current_commit",
+    "is_clean",
+    "get_default_branch",
+    # Changes
+    "get_changed_files_since",
+    "get_files_in_commit",
+    "get_commits_since",
+    "is_ancestor",
+    "get_merge_base",
+    # Commits
+    "Commit",
+    "get_commits",
+    "get_commit",
+    "get_commits_affecting_path",
+    # Tags
+    "Tag",
+    "list_tags",
+    "get_latest_tag",
+    "get_tags_for_commit",
+    "create_tag",
+    "delete_tag",
+    "parse_version_from_tag",
+    "get_package_tags",
+    "get_latest_package_tag",
+]

pymelos/git/changes.py

@@ -0,0 +1,153 @@
+"""Git change detection."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pymelos.git.repo import run_git_command
+
+
+def get_changed_files_since(
+    cwd: Path,
+    since: str,
+    *,
+    include_untracked: bool = True,
+) -> set[Path]:
+    """Get files changed since a git reference.
+
+    Args:
+        cwd: Working directory (repository root).
+        since: Git reference (branch, tag, commit SHA).
+        include_untracked: Include untracked files.
+
+    Returns:
+        Set of changed file paths (relative to cwd).
+    """
+    changed: set[Path] = set()
+
+    # Get files changed between since ref and HEAD
+    result = run_git_command(
+        ["diff", "--name-only", f"{since}...HEAD"],
+        cwd=cwd,
+        check=False,
+    )
+    if result.returncode == 0:
+        for line in result.stdout.strip().split("\n"):
+            if line:
+                changed.add(Path(line))
+
+    # Get staged changes
+    result = run_git_command(
+        ["diff", "--name-only", "--cached"],
+        cwd=cwd,
+        check=False,
+    )
+    if result.returncode == 0:
+        for line in result.stdout.strip().split("\n"):
+            if line:
+                changed.add(Path(line))
+
+    # Get unstaged changes
+    result = run_git_command(
+        ["diff", "--name-only"],
+        cwd=cwd,
+        check=False,
+    )
+    if result.returncode == 0:
+        for line in result.stdout.strip().split("\n"):
+            if line:
+                changed.add(Path(line))
+
+    # Get untracked files
+    if include_untracked:
+        result = run_git_command(
+            ["ls-files", "--others", "--exclude-standard"],
+            cwd=cwd,
+            check=False,
+        )
+        if result.returncode == 0:
+            for line in result.stdout.strip().split("\n"):
+                if line:
+                    changed.add(Path(line))
+
+    return changed
+
+
+def get_files_in_commit(cwd: Path, commit: str) -> set[Path]:
+    """Get files changed in a specific commit.
+
+    Args:
+        cwd: Working directory.
+        commit: Commit SHA.
+
+    Returns:
+        Set of file paths changed in the commit.
+    """
+    result = run_git_command(
+        ["diff-tree", "--no-commit-id", "--name-only", "-r", commit],
+        cwd=cwd,
+    )
+    files: set[Path] = set()
+    for line in result.stdout.strip().split("\n"):
+        if line:
+            files.add(Path(line))
+    return files
+
+
+def get_commits_since(
+    cwd: Path,
+    since: str,
+    *,
+    path: Path | None = None,
+) -> list[str]:
+    """Get commit SHAs since a reference.
+
+    Args:
+        cwd: Working directory.
+        since: Git reference.
+        path: Optional path to filter commits.
+
+    Returns:
+        List of commit SHAs (newest first).
+    """
+    args = ["log", "--format=%H", f"{since}..HEAD"]
+    if path:
+        args.extend(["--", str(path)])
+
+    result = run_git_command(args, cwd=cwd)
+    commits = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
+    return commits
+
+
+def is_ancestor(cwd: Path, commit: str, ancestor: str) -> bool:
+    """Check if ancestor is an ancestor of commit.
+
+    Args:
+        cwd: Working directory.
+        commit: Commit to check.
+        ancestor: Potential ancestor.
+
+    Returns:
+        True if ancestor is an ancestor of commit.
+    """
+    result = run_git_command(
+        ["merge-base", "--is-ancestor", ancestor, commit],
+        cwd=cwd,
+        check=False,
+    )
+    return result.returncode == 0
+
+
+def get_merge_base(cwd: Path, ref1: str, ref2: str) -> str:
+    """Get the merge base between two refs.
+
+    Args:
+        cwd: Working directory.
+        ref1: First reference.
+        ref2: Second reference.
+
+    Returns:
+        Merge base commit SHA.
+    """
+    result = run_git_command(["merge-base", ref1, ref2], cwd=cwd)
+    return result.stdout.strip()

pymelos/git/commits.py

@@ -0,0 +1,174 @@
+"""Git commit parsing and analysis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from pymelos.git.repo import run_git_command
+
+
+@dataclass(frozen=True, slots=True)
+class Commit:
+    """Represents a git commit.
+
+    Attributes:
+        sha: Full commit SHA.
+        short_sha: Abbreviated commit SHA.
+        message: Full commit message.
+        subject: First line of commit message.
+        body: Commit message body (after first line).
+        author_name: Commit author name.
+        author_email: Commit author email.
+        timestamp: Unix timestamp of commit.
+    """
+
+    sha: str
+    short_sha: str
+    message: str
+    author_name: str
+    author_email: str
+    timestamp: int
+
+    @property
+    def subject(self) -> str:
+        """First line of commit message."""
+        return self.message.split("\n", 1)[0]
+
+    @property
+    def body(self) -> str | None:
+        """Commit message body (after first line)."""
+        parts = self.message.split("\n", 1)
+        if len(parts) > 1:
+            return parts[1].strip()
+        return None
+
+
+# Format for git log output (fields separated by special delimiter)
+# Uses record separator (%x1e) at end to handle bodies with newlines
+LOG_FORMAT = "%H%x00%h%x00%s%x00%b%x00%an%x00%ae%x00%ct%x1e"
+FIELD_SEPARATOR = "\x00"
+COMMIT_SEPARATOR = "\x1e"  # Record separator
+
+
+def parse_commit_line(line: str) -> Commit | None:
+    """Parse a single commit from git log output.
+
+    Args:
+        line: Output line from git log with LOG_FORMAT.
+
+    Returns:
+        Parsed Commit or None if parsing fails.
+    """
+    parts = line.split(FIELD_SEPARATOR)
+    if len(parts) < 7:
+        return None
+
+    sha, short_sha, subject, body, author_name, author_email, timestamp_str = parts[:7]
+
+    try:
+        timestamp = int(timestamp_str)
+    except ValueError:
+        timestamp = 0
+
+    # Combine subject and body for full message
+    message = subject
+    if body.strip():
+        message = f"{subject}\n\n{body}"
+
+    return Commit(
+        sha=sha,
+        short_sha=short_sha,
+        message=message,
+        author_name=author_name,
+        author_email=author_email,
+        timestamp=timestamp,
+    )
+
+
+def get_commits(
+    cwd: Path,
+    since: str | None = None,
+    until: str | None = None,
+    path: Path | None = None,
+    limit: int | None = None,
+) -> list[Commit]:
+    """Get commits from the repository.
+
+    Args:
+        cwd: Working directory.
+        since: Start reference (exclusive).
+        until: End reference (inclusive). Defaults to HEAD.
+        path: Filter to commits affecting this path.
+        limit: Maximum number of commits.
+
+    Returns:
+        List of commits (newest first).
+    """
+    args = ["log", f"--format={LOG_FORMAT}"]
+
+    if limit:
+        args.append(f"-n{limit}")
+
+    if since and until:
+        args.append(f"{since}..{until}")
+    elif since:
+        args.append(f"{since}..HEAD")
+    elif until:
+        args.append(until)
+
+    if path:
+        args.extend(["--", str(path)])
+
+    result = run_git_command(args, cwd=cwd)
+
+    commits: list[Commit] = []
+    # Split by record separator to handle bodies with newlines
+    for record in result.stdout.split(COMMIT_SEPARATOR):
+        record = record.strip()
+        if record:
+            commit = parse_commit_line(record)
+            if commit:
+                commits.append(commit)
+
+    return commits
+
+
+def get_commit(cwd: Path, ref: str) -> Commit | None:
+    """Get a single commit by reference.
+
+    Args:
+        cwd: Working directory.
+        ref: Git reference (SHA, branch, tag).
+
+    Returns:
+        Commit or None if not found.
+    """
+    args = ["log", "-1", f"--format={LOG_FORMAT}", ref]
+
+    result = run_git_command(args, cwd=cwd, check=False)
+    if result.returncode != 0:
+        return None
+
+    line = result.stdout.strip()
+    if line:
+        return parse_commit_line(line)
+    return None
+
+
+def get_commits_affecting_path(
+    cwd: Path,
+    path: Path,
+    since: str | None = None,
+) -> list[Commit]:
+    """Get commits that affected a specific path.
+
+    Args:
+        cwd: Working directory.
+        path: Path to filter by.
+        since: Start reference (exclusive).
+
+    Returns:
+        List of commits affecting the path.
+    """
+    return get_commits(cwd, since=since, path=path)

pymelos/git/repo.py

@@ -0,0 +1,210 @@
+"""Git repository abstraction."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+from pathlib import Path
+
+from pymelos.errors import GitError
+
+
+def is_git_repo(path: Path) -> bool:
+    """Check if path is inside a git repository.
+
+    Args:
+        path: Path to check.
+
+    Returns:
+        True if path is inside a git repository.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def get_repo_root(path: Path) -> Path:
+    """Get the root directory of the git repository.
+
+    Args:
+        path: Path inside the repository.
+
+    Returns:
+        Path to repository root.
+
+    Raises:
+        GitError: If not inside a git repository.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except subprocess.CalledProcessError as e:
+        raise GitError(
+            "Not inside a git repository",
+            command="git rev-parse --show-toplevel",
+        ) from e
+    except FileNotFoundError as e:
+        raise GitError("Git is not installed") from e
+
+
+def run_git_command(
+    args: list[str],
+    cwd: Path | None = None,
+    *,
+    check: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    """Run a git command synchronously.
+
+    Args:
+        args: Git command arguments (without 'git').
+        cwd: Working directory.
+        check: Raise on non-zero exit code.
+
+    Returns:
+        Completed process result.
+
+    Raises:
+        GitError: If command fails and check is True.
+    """
+    cmd = ["git"] + args
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if check and result.returncode != 0:
+            raise GitError(
+                result.stderr.strip() or f"Command failed with exit code {result.returncode}",
+                command=" ".join(cmd),
+            )
+        return result
+    except FileNotFoundError as e:
+        raise GitError("Git is not installed") from e
+
+
+async def run_git_command_async(
+    args: list[str],
+    cwd: Path | None = None,
+    *,
+    check: bool = True,
+) -> tuple[int, str, str]:
+    """Run a git command asynchronously.
+
+    Args:
+        args: Git command arguments (without 'git').
+        cwd: Working directory.
+        check: Raise on non-zero exit code.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+
+    Raises:
+        GitError: If command fails and check is True.
+    """
+    cmd = ["git"] + args
+
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout_bytes, stderr_bytes = await process.communicate()
+        stdout = stdout_bytes.decode("utf-8", errors="replace")
+        stderr = stderr_bytes.decode("utf-8", errors="replace")
+
+        if check and process.returncode != 0:
+            raise GitError(
+                stderr.strip() or f"Command failed with exit code {process.returncode}",
+                command=" ".join(cmd),
+            )
+
+        return process.returncode or 0, stdout, stderr
+    except FileNotFoundError as e:
+        raise GitError("Git is not installed") from e
+
+
+def get_current_branch(cwd: Path | None = None) -> str:
+    """Get the current git branch name.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Current branch name.
+    """
+    result = run_git_command(["rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
+    return result.stdout.strip()
+
+
+def get_current_commit(cwd: Path | None = None) -> str:
+    """Get the current commit SHA.
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Current commit SHA.
+    """
+    result = run_git_command(["rev-parse", "HEAD"], cwd=cwd)
+    return result.stdout.strip()
+
+
+def is_clean(cwd: Path | None = None) -> bool:
+    """Check if the working directory is clean (no uncommitted changes).
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        True if working directory is clean.
+    """
+    result = run_git_command(["status", "--porcelain"], cwd=cwd, check=False)
+    return not result.stdout.strip()
+
+
+def get_default_branch(cwd: Path | None = None) -> str:
+    """Get the default branch name (main or master).
+
+    Args:
+        cwd: Working directory.
+
+    Returns:
+        Default branch name.
+    """
+    # Try to get from remote
+    result = run_git_command(
+        ["symbolic-ref", "refs/remotes/origin/HEAD"],
+        cwd=cwd,
+        check=False,
+    )
+    if result.returncode == 0:
+        # refs/remotes/origin/main -> main
+        return result.stdout.strip().split("/")[-1]
+
+    # Check if main exists
+    result = run_git_command(["branch", "--list", "main"], cwd=cwd, check=False)
+    if result.stdout.strip():
+        return "main"
+
+    # Default to master
+    return "master"