glreview 0.1.0__py3-none-any.whl

glreview/gitlab.py

@@ -0,0 +1,398 @@
+"""GitLab integration via python-gitlab library."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from functools import lru_cache
+
+import gitlab
+from gitlab.exceptions import GitlabAuthenticationError, GitlabGetError
+
+
+@dataclass
+class GitLabConfig:
+    """GitLab connection configuration."""
+
+    url: str
+    private_token: str | None = None
+    job_token: str | None = None
+    oauth_token: str | None = None
+
+    @classmethod
+    def from_environment(cls, host: str | None = None) -> "GitLabConfig":
+        """Create config from environment variables.
+
+        Checks (in order):
+            1. CI_JOB_TOKEN (for CI pipelines)
+            2. GITLAB_PRIVATE_TOKEN
+            3. GITLAB_TOKEN (alias)
+            4. GITLAB_OAUTH_TOKEN
+
+        Args:
+            host: GitLab host (e.g., "gitlab.com"). If None, uses GITLAB_URL env
+                  or defaults to "gitlab.com".
+
+        Returns:
+            GitLabConfig instance.
+        """
+        url = os.environ.get("GITLAB_URL")
+        if not url:
+            url = f"https://{host}" if host else "https://gitlab.com"
+
+        return cls(
+            url=url,
+            job_token=os.environ.get("CI_JOB_TOKEN"),
+            private_token=os.environ.get("GITLAB_PRIVATE_TOKEN")
+            or os.environ.get("GITLAB_TOKEN"),
+            oauth_token=os.environ.get("GITLAB_OAUTH_TOKEN"),
+        )
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Check if any authentication token is configured."""
+        return bool(self.private_token or self.job_token or self.oauth_token)
+
+
+@lru_cache(maxsize=1)
+def _get_gitlab_client(url: str, token: str | None, job_token: str | None) -> gitlab.Gitlab:
+    """Get a cached GitLab client instance."""
+    if job_token:
+        return gitlab.Gitlab(url, job_token=job_token)
+    elif token:
+        return gitlab.Gitlab(url, private_token=token)
+    else:
+        return gitlab.Gitlab(url)
+
+
+def get_gitlab_client(config: GitLabConfig | None = None) -> gitlab.Gitlab | None:
+    """Get a GitLab client instance.
+
+    Args:
+        config: GitLab configuration. If None, reads from environment.
+
+    Returns:
+        Authenticated GitLab client, or None if not configured.
+    """
+    if config is None:
+        config = GitLabConfig.from_environment()
+
+    if not config.is_authenticated:
+        return None
+
+    try:
+        gl = _get_gitlab_client(
+            config.url,
+            config.private_token or config.oauth_token,
+            config.job_token,
+        )
+        gl.auth()
+        return gl
+    except GitlabAuthenticationError:
+        return None
+
+
+def gitlab_available(host: str | None = None) -> bool:
+    """Check if GitLab authentication is available.
+
+    Args:
+        host: GitLab host to check against.
+
+    Returns:
+        True if authenticated successfully.
+    """
+    config = GitLabConfig.from_environment(host)
+    if not config.is_authenticated:
+        return False
+
+    client = get_gitlab_client(config)
+    return client is not None
+
+
+@dataclass
+class GitLabIssue:
+    """Represents a GitLab issue."""
+
+    number: str
+    url: str
+    title: str
+    state: str
+    assignees: list[str]
+    labels: list[str]
+
+    @classmethod
+    def from_api_response(cls, issue) -> "GitLabIssue":
+        """Create from python-gitlab issue object."""
+        return cls(
+            number=str(issue.iid),
+            url=issue.web_url,
+            title=issue.title,
+            state=issue.state,
+            assignees=[a["username"] for a in issue.assignees] if issue.assignees else [],
+            labels=issue.labels or [],
+        )
+
+
+@dataclass
+class GitLabMember:
+    """Represents a GitLab project member."""
+
+    username: str
+    name: str
+    access_level: int
+
+    @property
+    def access_level_name(self) -> str:
+        """Human-readable access level."""
+        levels = {
+            50: "Owner",
+            40: "Maintainer",
+            30: "Developer",
+            20: "Reporter",
+            10: "Guest",
+        }
+        return levels.get(self.access_level, f"Level {self.access_level}")
+
+    @classmethod
+    def from_api_response(cls, member) -> "GitLabMember":
+        """Create from python-gitlab member object."""
+        return cls(
+            username=member.username,
+            name=member.name,
+            access_level=member.access_level,
+        )
+
+
+def _get_project(gl: gitlab.Gitlab, project_path: str):
+    """Get a project by path.
+
+    Args:
+        gl: GitLab client.
+        project_path: Project path (e.g., "user/project").
+
+    Returns:
+        Project object or None.
+    """
+    try:
+        return gl.projects.get(project_path)
+    except GitlabGetError:
+        return None
+
+
+def create_issue(
+    title: str,
+    description: str,
+    project_path: str,
+    host: str | None = None,
+    labels: list[str] | None = None,
+    assignee: str | None = None,
+) -> GitLabIssue | None:
+    """Create a GitLab issue.
+
+    Args:
+        title: Issue title.
+        description: Issue body (markdown).
+        project_path: Project path (e.g., "user/project").
+        host: GitLab host.
+        labels: Labels to apply.
+        assignee: Username to assign (without @).
+
+    Returns:
+        Created issue, or None on failure.
+    """
+    config = GitLabConfig.from_environment(host)
+    gl = get_gitlab_client(config)
+
+    if not gl:
+        return None
+
+    project = _get_project(gl, project_path)
+    if not project:
+        return None
+
+    issue_data = {
+        "title": title,
+        "description": description,
+    }
+
+    if labels:
+        issue_data["labels"] = labels
+
+    if assignee:
+        # Look up user ID from username
+        username = assignee.lstrip("@")
+        try:
+            users = gl.users.list(username=username)
+            if users:
+                issue_data["assignee_ids"] = [users[0].id]
+        except Exception:
+            pass  # Continue without assignee if lookup fails
+
+    try:
+        issue = project.issues.create(issue_data)
+        return GitLabIssue.from_api_response(issue)
+    except Exception:
+        return None
+
+
+def get_issue(
+    issue_number: str,
+    project_path: str,
+    host: str | None = None,
+) -> GitLabIssue | None:
+    """Get details for an issue.
+
+    Args:
+        issue_number: Issue number (without #).
+        project_path: Project path (e.g., "user/project").
+        host: GitLab host.
+
+    Returns:
+        Issue details, or None if not found.
+    """
+    config = GitLabConfig.from_environment(host)
+    gl = get_gitlab_client(config)
+
+    if not gl:
+        return None
+
+    project = _get_project(gl, project_path)
+    if not project:
+        return None
+
+    try:
+        issue = project.issues.get(int(issue_number))
+        return GitLabIssue.from_api_response(issue)
+    except Exception:
+        return None
+
+
+def get_project_members(
+    project_path: str,
+    host: str | None = None,
+) -> list[GitLabMember]:
+    """Get all project members.
+
+    Args:
+        project_path: Project path (e.g., "user/project").
+        host: GitLab host.
+
+    Returns:
+        List of members, empty list on failure.
+    """
+    config = GitLabConfig.from_environment(host)
+    gl = get_gitlab_client(config)
+
+    if not gl:
+        return []
+
+    project = _get_project(gl, project_path)
+    if not project:
+        return []
+
+    try:
+        # Get all members including inherited
+        members = project.members_all.list(all=True)
+        return [GitLabMember.from_api_response(m) for m in members]
+    except Exception:
+        return []
+
+
+def close_issue(
+    issue_number: str,
+    project_path: str,
+    host: str | None = None,
+    comment: str | None = None,
+) -> bool:
+    """Close a GitLab issue.
+
+    Args:
+        issue_number: Issue number (without #).
+        project_path: Project path (e.g., "user/project").
+        host: GitLab host.
+        comment: Optional comment to add before closing.
+
+    Returns:
+        True if closed successfully, False otherwise.
+    """
+    config = GitLabConfig.from_environment(host)
+    gl = get_gitlab_client(config)
+
+    if not gl:
+        return False
+
+    project = _get_project(gl, project_path)
+    if not project:
+        return False
+
+    try:
+        issue = project.issues.get(int(issue_number))
+
+        # Add comment if provided
+        if comment:
+            issue.notes.create({"body": comment})
+
+        # Close the issue
+        issue.state_event = "close"
+        issue.save()
+        return True
+    except Exception:
+        return False
+
+
+def add_issue_comment(
+    issue_number: str,
+    project_path: str,
+    comment: str,
+    host: str | None = None,
+) -> bool:
+    """Add a comment to a GitLab issue.
+
+    Args:
+        issue_number: Issue number (without #).
+        project_path: Project path (e.g., "user/project").
+        comment: Comment text.
+        host: GitLab host.
+
+    Returns:
+        True if comment added successfully, False otherwise.
+    """
+    config = GitLabConfig.from_environment(host)
+    gl = get_gitlab_client(config)
+
+    if not gl:
+        return False
+
+    project = _get_project(gl, project_path)
+    if not project:
+        return False
+
+    try:
+        issue = project.issues.get(int(issue_number))
+        issue.notes.create({"body": comment})
+        return True
+    except Exception:
+        return False
+
+
+def get_compare_url(
+    project: str,
+    host: str,
+    from_commit: str,
+    to_commit: str,
+) -> str:
+    """Generate a GitLab compare URL.
+
+    Args:
+        project: Project path (e.g., "user/project").
+        host: GitLab host (e.g., "gitlab.com").
+        from_commit: Base commit SHA.
+        to_commit: Head commit SHA.
+
+    Returns:
+        Compare URL.
+    """
+    return (
+        f"https://{host}/{project}/-/compare/"
+        f"{from_commit}...{to_commit}?from_project_id=&straight=false"
+    )

glreview/registry.py

@@ -0,0 +1,179 @@
+"""Registry for tracking review status of modules."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterator
+
+SCHEMA_VERSION = "1"
+
+
+@dataclass
+class ModuleStatus:
+    """Review status for a single module."""
+
+    path: str
+    status: str = "needs_review"  # needs_review, in_progress, reviewed, needs_update
+    priority: str = "medium"
+    lines: int = 0
+    reviewers_required: int = 1
+    last_reviewed_commit: str | None = None
+    last_reviewed_date: str | None = None
+    reviewers: list[str] = field(default_factory=list)
+    review_issue: str | None = None
+    assigned_reviewer: str | None = None
+    review_started_commit: str | None = None  # Commit when review was started
+    notes: str = ""
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {k: v for k, v in asdict(self).items() if k != "path"}
+
+    @classmethod
+    def from_dict(cls, path: str, data: dict) -> "ModuleStatus":
+        """Create from dictionary."""
+        return cls(
+            path=path,
+            status=data.get("status", "needs_review"),
+            priority=data.get("priority", "medium"),
+            lines=data.get("lines", 0),
+            reviewers_required=data.get("reviewers_required", 1),
+            last_reviewed_commit=data.get("last_reviewed_commit"),
+            last_reviewed_date=data.get("last_reviewed_date"),
+            reviewers=data.get("reviewers", []),
+            review_issue=data.get("review_issue"),
+            assigned_reviewer=data.get("assigned_reviewer"),
+            review_started_commit=data.get("review_started_commit"),
+            notes=data.get("notes", ""),
+        )
+
+
+@dataclass
+class Registry:
+    """Registry of module review statuses."""
+
+    modules: dict[str, ModuleStatus] = field(default_factory=dict)
+    last_updated: str | None = None
+    current_commit: str | None = None
+
+    def get(self, path: str) -> ModuleStatus | None:
+        """Get the status for a module."""
+        return self.modules.get(path)
+
+    def set(self, status: ModuleStatus) -> None:
+        """Set the status for a module."""
+        self.modules[status.path] = status
+
+    def remove(self, path: str) -> bool:
+        """Remove a module from the registry. Returns True if it existed."""
+        if path in self.modules:
+            del self.modules[path]
+            return True
+        return False
+
+    def __iter__(self) -> Iterator[ModuleStatus]:
+        """Iterate over all module statuses."""
+        return iter(self.modules.values())
+
+    def __len__(self) -> int:
+        """Return the number of modules in the registry."""
+        return len(self.modules)
+
+    def filter(
+        self,
+        status: str | None = None,
+        priority: str | None = None,
+    ) -> Iterator[ModuleStatus]:
+        """Filter modules by status and/or priority."""
+        for module in self:
+            if status and module.status != status:
+                continue
+            if priority and module.priority != priority:
+                continue
+            yield module
+
+    @property
+    def summary(self) -> dict[str, int]:
+        """Get a summary of review statuses."""
+        counts = {
+            "total": 0,
+            "reviewed": 0,
+            "needs_review": 0,
+            "in_progress": 0,
+            "needs_update": 0,
+            "total_lines": 0,
+            "reviewed_lines": 0,
+        }
+        for module in self:
+            counts["total"] += 1
+            counts["total_lines"] += module.lines
+
+            if module.status == "reviewed":
+                counts["reviewed"] += 1
+                counts["reviewed_lines"] += module.lines
+            elif module.status == "in_progress":
+                counts["in_progress"] += 1
+            elif module.status in ("needs_review", "needs_update"):
+                counts[module.status] += 1
+
+        return counts
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "version": SCHEMA_VERSION,
+            "last_updated": self.last_updated,
+            "current_commit": self.current_commit,
+            "modules": {path: mod.to_dict() for path, mod in self.modules.items()},
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Registry":
+        """Create from dictionary."""
+        modules = {}
+        for path, mod_data in data.get("modules", {}).items():
+            modules[path] = ModuleStatus.from_dict(path, mod_data)
+
+        return cls(
+            modules=modules,
+            last_updated=data.get("last_updated"),
+            current_commit=data.get("current_commit"),
+        )
+
+
+def load_registry(path: Path) -> Registry:
+    """Load registry from a JSON file.
+
+    Args:
+        path: Path to the registry file.
+
+    Returns:
+        Registry object. Returns empty registry if file doesn't exist.
+    """
+    if not path.exists():
+        return Registry()
+
+    with open(path) as f:
+        data = json.load(f)
+
+    return Registry.from_dict(data)
+
+
+def save_registry(registry: Registry, path: Path, commit: str | None = None) -> None:
+    """Save registry to a JSON file.
+
+    Args:
+        registry: Registry to save.
+        path: Path to write to.
+        commit: Current git commit SHA to record.
+    """
+    registry.last_updated = datetime.now(timezone.utc).isoformat()
+    if commit:
+        registry.current_commit = commit
+
+    with open(path, "w") as f:
+        json.dump(registry.to_dict(), f, indent=2)
+        f.write("\n")