recce-cloud-nightly 1.26.0.20251119__py3-none-any.whl

recce_cloud/ci_providers/base.py

@@ -0,0 +1,82 @@
+"""
+Base CI provider interface.
+"""
+
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class CIInfo:
+    """Information extracted from CI environment."""
+
+    platform: Optional[str] = None  # "github-actions", "gitlab-ci", etc.
+    cr_number: Optional[int] = None  # Change request number (PR/MR)
+    cr_url: Optional[str] = None  # Change request URL (for session linking)
+    session_type: Optional[str] = None  # "cr", "prod", "dev"
+    commit_sha: Optional[str] = None  # Full commit SHA
+    base_branch: Optional[str] = None  # Target/base branch
+    source_branch: Optional[str] = None  # Source/head branch
+    repository: Optional[str] = None  # Repository path (owner/repo or group/project)
+    access_token: Optional[str] = None  # CI-provided access token (GITHUB_TOKEN, CI_JOB_TOKEN)
+
+
+class BaseCIProvider(ABC):
+    """Abstract base class for CI provider detection and info extraction."""
+
+    @abstractmethod
+    def can_handle(self) -> bool:
+        """
+        Check if this provider can handle the current environment.
+
+        Returns:
+            True if the provider's CI platform is detected
+        """
+        pass
+
+    @abstractmethod
+    def extract_ci_info(self) -> CIInfo:
+        """
+        Extract CI information from environment variables.
+
+        Returns:
+            CIInfo object with extracted information
+        """
+        pass
+
+    @staticmethod
+    def run_git_command(command: list[str]) -> Optional[str]:
+        """
+        Run a git command and return output.
+
+        Args:
+            command: Git command as list (e.g., ['git', 'rev-parse', 'HEAD'])
+
+        Returns:
+            Command output stripped of whitespace, or None if command fails
+        """
+        try:
+            result = subprocess.run(command, capture_output=True, text=True, check=True, timeout=5)
+            return result.stdout.strip()
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
+            return None
+
+    @staticmethod
+    def determine_session_type(cr_number: Optional[int], source_branch: Optional[str]) -> str:
+        """
+        Determine session type based on context.
+
+        Args:
+            cr_number: Change request number (PR/MR)
+            source_branch: Source branch name
+
+        Returns:
+            Session type: "cr", "prod", or "dev"
+        """
+        if cr_number is not None:
+            return "cr"
+        if source_branch in ["main", "master"]:
+            return "prod"
+        return "dev"

recce_cloud/ci_providers/detector.py

@@ -0,0 +1,147 @@
+"""
+CI provider detection and orchestration.
+"""
+
+import logging
+import os
+from typing import Optional
+
+from recce_cloud.ci_providers.base import BaseCIProvider, CIInfo
+from recce_cloud.ci_providers.github_actions import GitHubActionsProvider
+from recce_cloud.ci_providers.gitlab_ci import GitLabCIProvider
+
+logger = logging.getLogger(__name__)
+
+
+class CIDetector:
+    """
+    Detects CI platform and extracts information.
+
+    Supports:
+    - GitHub Actions
+    - GitLab CI/CD
+    - Generic fallback (git commands)
+    """
+
+    # Order matters: check in priority order
+    PROVIDERS = [
+        GitHubActionsProvider,
+        GitLabCIProvider,
+    ]
+
+    @classmethod
+    def detect(cls) -> CIInfo:
+        """
+        Detect CI platform and extract information.
+
+        Returns:
+            CIInfo object with detected information
+        """
+        # Try each provider in order
+        for provider_class in cls.PROVIDERS:
+            provider = provider_class()
+            if provider.can_handle():
+                logger.info(f"CI Platform: {provider_class.__name__.replace('Provider', '')}")
+                ci_info = provider.extract_ci_info()
+                cls._log_detected_values(ci_info)
+                return ci_info
+
+        # No CI platform detected, use generic fallback
+        logger.info("No CI platform detected, using git fallback")
+        ci_info = cls._fallback_detection()
+        cls._log_detected_values(ci_info)
+        return ci_info
+
+    @classmethod
+    def apply_overrides(
+        cls,
+        ci_info: CIInfo,
+        cr: Optional[int] = None,
+        session_type: Optional[str] = None,
+    ) -> CIInfo:
+        """
+        Apply manual overrides to detected CI information.
+
+        Args:
+            ci_info: Detected CI information
+            cr: Manual change request number override
+            session_type: Manual session type override
+
+        Returns:
+            CIInfo with overrides applied
+        """
+        # Log overrides
+        if cr is not None and cr != ci_info.cr_number:
+            logger.info(f"Using manual override: --cr {cr} (detected: {ci_info.cr_number})")
+            ci_info.cr_number = cr
+            # Rebuild CR URL if we have repository info
+            if ci_info.repository:
+                if ci_info.platform == "github-actions":
+                    ci_info.cr_url = f"https://github.com/{ci_info.repository}/pull/{cr}"
+                elif ci_info.platform == "gitlab-ci":
+                    server_url = os.getenv("CI_SERVER_URL", "https://gitlab.com")
+                    ci_info.cr_url = f"{server_url}/{ci_info.repository}/-/merge_requests/{cr}"
+
+        if session_type is not None and session_type != ci_info.session_type:
+            logger.info(f"Using manual override: --type {session_type} (detected: {ci_info.session_type})")
+            ci_info.session_type = session_type
+
+        # Re-determine session type if CR was overridden
+        if cr is not None:
+            if session_type is None:  # Only if not manually overridden
+                ci_info.session_type = BaseCIProvider.determine_session_type(ci_info.cr_number, ci_info.source_branch)
+
+        return ci_info
+
+    @classmethod
+    def _fallback_detection(cls) -> CIInfo:
+        """
+        Fallback detection using git commands when no CI platform is detected.
+
+        Returns:
+            CIInfo with basic git information
+        """
+        commit_sha = BaseCIProvider.run_git_command(["git", "rev-parse", "HEAD"])
+        source_branch = BaseCIProvider.run_git_command(["git", "branch", "--show-current"])
+
+        session_type = BaseCIProvider.determine_session_type(None, source_branch)
+
+        return CIInfo(
+            platform=None,
+            cr_number=None,
+            session_type=session_type,
+            commit_sha=commit_sha,
+            base_branch="main",  # Default
+            source_branch=source_branch,
+            repository=None,
+        )
+
+    @classmethod
+    def _log_detected_values(cls, ci_info: CIInfo) -> None:
+        """
+        Log detected values for transparency.
+
+        Args:
+            ci_info: Detected CI information
+        """
+        if ci_info.cr_number is not None:
+            if ci_info.platform == "github-actions":
+                logger.info(f"Detected PR number: {ci_info.cr_number}")
+            elif ci_info.platform == "gitlab-ci":
+                logger.info(f"Detected MR number: {ci_info.cr_number}")
+            else:
+                logger.info(f"Detected CR number: {ci_info.cr_number}")
+        else:
+            logger.info("No CR number detected")
+
+        if ci_info.commit_sha:
+            logger.info(f"Detected commit SHA: {ci_info.commit_sha[:8]}...")
+        else:
+            logger.warning("Could not detect commit SHA")
+
+        logger.info(f"Detected base branch: {ci_info.base_branch}")
+        logger.info(f"Detected source branch: {ci_info.source_branch}")
+        logger.info(f"Session type: {ci_info.session_type}")
+
+        if ci_info.repository:
+            logger.info(f"Repository: {ci_info.repository}")

recce_cloud/ci_providers/github_actions.py

@@ -0,0 +1,136 @@
+"""
+GitHub Actions CI provider.
+"""
+
+import json
+import os
+from typing import Optional
+
+from recce_cloud.ci_providers.base import BaseCIProvider, CIInfo
+
+
+class GitHubActionsProvider(BaseCIProvider):
+    """GitHub Actions CI provider implementation."""
+
+    def can_handle(self) -> bool:
+        """
+        Check if running in GitHub Actions.
+
+        Returns:
+            True if GITHUB_ACTIONS environment variable is 'true'
+        """
+        return os.getenv("GITHUB_ACTIONS") == "true"
+
+    def extract_ci_info(self) -> CIInfo:
+        """
+        Extract CI information from GitHub Actions environment.
+
+        Environment variables used:
+        - GITHUB_EVENT_PATH: Path to event payload JSON (for PR number)
+        - GITHUB_SHA: Commit SHA
+        - GITHUB_BASE_REF: Base/target branch (PR only)
+        - GITHUB_HEAD_REF: Source/head branch (PR only)
+        - GITHUB_REF_NAME: Branch name (fallback)
+        - GITHUB_REPOSITORY: Repository (owner/repo)
+        - GITHUB_TOKEN: Default access token (automatically provided by GitHub Actions)
+
+        Returns:
+            CIInfo object with extracted information
+        """
+        cr_number = self._extract_pr_number()
+        commit_sha = self._extract_commit_sha()
+        base_branch = self._extract_base_branch()
+        source_branch = self._extract_source_branch()
+        repository = os.getenv("GITHUB_REPOSITORY")
+        access_token = os.getenv("GITHUB_TOKEN")
+
+        # Build CR URL (PR URL) if we have the necessary information
+        cr_url = None
+        if cr_number is not None and repository:
+            cr_url = f"https://github.com/{repository}/pull/{cr_number}"
+
+        session_type = self.determine_session_type(cr_number, source_branch)
+
+        return CIInfo(
+            platform="github-actions",
+            cr_number=cr_number,
+            cr_url=cr_url,
+            session_type=session_type,
+            commit_sha=commit_sha,
+            base_branch=base_branch,
+            source_branch=source_branch,
+            repository=repository,
+            access_token=access_token,
+        )
+
+    def _extract_pr_number(self) -> Optional[int]:
+        """
+        Extract PR number from GitHub event payload.
+
+        Returns:
+            PR number if detected, None otherwise
+        """
+        event_path = os.getenv("GITHUB_EVENT_PATH")
+        if not event_path or not os.path.exists(event_path):
+            return None
+
+        try:
+            with open(event_path, "r") as f:
+                event_data = json.load(f)
+                pr_data = event_data.get("pull_request", {})
+                pr_number = pr_data.get("number")
+                if pr_number is not None:
+                    return int(pr_number)
+        except (json.JSONDecodeError, ValueError, OSError):
+            pass
+
+        return None
+
+    def _extract_commit_sha(self) -> Optional[str]:
+        """
+        Extract commit SHA from GitHub Actions environment.
+
+        Returns:
+            Commit SHA if detected, falls back to git command
+        """
+        commit_sha = os.getenv("GITHUB_SHA")
+        if commit_sha:
+            return commit_sha
+
+        # Fallback to git command
+        return self.run_git_command(["git", "rev-parse", "HEAD"])
+
+    def _extract_base_branch(self) -> str:
+        """
+        Extract base/target branch from GitHub Actions environment.
+
+        Returns:
+            Base branch name, defaults to 'main' if not detected
+        """
+        # GITHUB_BASE_REF is only set for pull_request events
+        base_branch = os.getenv("GITHUB_BASE_REF")
+        if base_branch:
+            return base_branch
+
+        # Default to main
+        return "main"
+
+    def _extract_source_branch(self) -> Optional[str]:
+        """
+        Extract source/head branch from GitHub Actions environment.
+
+        Returns:
+            Source branch name if detected
+        """
+        # GITHUB_HEAD_REF is only set for pull_request events
+        source_branch = os.getenv("GITHUB_HEAD_REF")
+        if source_branch:
+            return source_branch
+
+        # Fallback to GITHUB_REF_NAME
+        source_branch = os.getenv("GITHUB_REF_NAME")
+        if source_branch:
+            return source_branch
+
+        # Fallback to git command
+        return self.run_git_command(["git", "branch", "--show-current"])

recce_cloud/ci_providers/gitlab_ci.py

@@ -0,0 +1,130 @@
+"""
+GitLab CI/CD provider.
+"""
+
+import os
+from typing import Optional
+
+from recce_cloud.ci_providers.base import BaseCIProvider, CIInfo
+
+
+class GitLabCIProvider(BaseCIProvider):
+    """GitLab CI/CD provider implementation."""
+
+    def can_handle(self) -> bool:
+        """
+        Check if running in GitLab CI.
+
+        Returns:
+            True if GITLAB_CI environment variable is 'true'
+        """
+        return os.getenv("GITLAB_CI") == "true"
+
+    def extract_ci_info(self) -> CIInfo:
+        """
+        Extract CI information from GitLab CI environment.
+
+        Environment variables used:
+        - CI_MERGE_REQUEST_IID: Merge request number
+        - CI_COMMIT_SHA: Commit SHA
+        - CI_MERGE_REQUEST_TARGET_BRANCH_NAME: Target branch (MR only)
+        - CI_MERGE_REQUEST_SOURCE_BRANCH_NAME: Source branch (MR only)
+        - CI_COMMIT_REF_NAME: Branch name (fallback)
+        - CI_PROJECT_PATH: Repository path (group/project)
+        - CI_SERVER_URL: GitLab instance URL (defaults to https://gitlab.com)
+        - CI_JOB_TOKEN: Default access token (automatically provided by GitLab CI)
+
+        Returns:
+            CIInfo object with extracted information
+        """
+        cr_number = self._extract_mr_number()
+        commit_sha = self._extract_commit_sha()
+        base_branch = self._extract_base_branch()
+        source_branch = self._extract_source_branch()
+        repository = os.getenv("CI_PROJECT_PATH")
+        access_token = os.getenv("CI_JOB_TOKEN")
+
+        # Build CR URL (MR URL) if we have the necessary information
+        cr_url = None
+        if cr_number is not None and repository:
+            server_url = os.getenv("CI_SERVER_URL", "https://gitlab.com")
+            cr_url = f"{server_url}/{repository}/-/merge_requests/{cr_number}"
+
+        session_type = self.determine_session_type(cr_number, source_branch)
+
+        return CIInfo(
+            platform="gitlab-ci",
+            cr_number=cr_number,
+            cr_url=cr_url,
+            session_type=session_type,
+            commit_sha=commit_sha,
+            base_branch=base_branch,
+            source_branch=source_branch,
+            repository=repository,
+            access_token=access_token,
+        )
+
+    def _extract_mr_number(self) -> Optional[int]:
+        """
+        Extract MR number from GitLab CI environment.
+
+        Returns:
+            MR number if detected, None otherwise
+        """
+        mr_iid = os.getenv("CI_MERGE_REQUEST_IID")
+        if mr_iid:
+            try:
+                return int(mr_iid)
+            except ValueError:
+                pass
+
+        return None
+
+    def _extract_commit_sha(self) -> Optional[str]:
+        """
+        Extract commit SHA from GitLab CI environment.
+
+        Returns:
+            Commit SHA if detected, falls back to git command
+        """
+        commit_sha = os.getenv("CI_COMMIT_SHA")
+        if commit_sha:
+            return commit_sha
+
+        # Fallback to git command
+        return self.run_git_command(["git", "rev-parse", "HEAD"])
+
+    def _extract_base_branch(self) -> str:
+        """
+        Extract base/target branch from GitLab CI environment.
+
+        Returns:
+            Base branch name, defaults to 'main' if not detected
+        """
+        # CI_MERGE_REQUEST_TARGET_BRANCH_NAME is only set for merge request pipelines
+        base_branch = os.getenv("CI_MERGE_REQUEST_TARGET_BRANCH_NAME")
+        if base_branch:
+            return base_branch
+
+        # Default to main
+        return "main"
+
+    def _extract_source_branch(self) -> Optional[str]:
+        """
+        Extract source branch from GitLab CI environment.
+
+        Returns:
+            Source branch name if detected
+        """
+        # CI_MERGE_REQUEST_SOURCE_BRANCH_NAME is only set for merge request pipelines
+        source_branch = os.getenv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME")
+        if source_branch:
+            return source_branch
+
+        # Fallback to CI_COMMIT_REF_NAME
+        source_branch = os.getenv("CI_COMMIT_REF_NAME")
+        if source_branch:
+            return source_branch
+
+        # Fallback to git command
+        return self.run_git_command(["git", "branch", "--show-current"])