cicaddy-gitlab 0.1.0__py3-none-any.whl

cicaddy_gitlab/__init__.py

@@ -0,0 +1 @@
+"""GitLab platform plugin for cicaddy AI agent."""

cicaddy_gitlab/agent/__init__.py

@@ -0,0 +1 @@
+"""Agent modules for cicaddy-gitlab plugin."""

cicaddy_gitlab/agent/base.py

@@ -0,0 +1,29 @@
+"""BaseAIAgent with GitLab platform integration."""
+
+from cicaddy.agent.base import BaseAIAgent as _CicaddyBaseAIAgent
+from cicaddy.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class BaseAIAgent(_CicaddyBaseAIAgent):
+    """BaseAIAgent with GitLab _setup_platform_integration override."""
+
+    async def _setup_platform_integration(self):
+        """Setup GitLab platform integration if project_id is available."""
+        project_id = getattr(self.settings, "project_id", None)
+        if project_id:
+            from cicaddy_gitlab.gitlab_integration.analyzer import GitLabAnalyzer
+
+            gitlab_api_url = getattr(self.settings, "gitlab_api_url", "")
+            gitlab_token = getattr(self.settings, "gitlab_token", "")
+            logger.info(f"Initializing GitLab analyzer with URL: {gitlab_api_url}")
+            logger.info(f"Project ID: {project_id}")
+            self.platform_analyzer = GitLabAnalyzer(
+                token=gitlab_token,
+                api_url=gitlab_api_url,
+                project_id=project_id,
+                ssl_verify=self.settings.ssl_verify,
+            )
+        else:
+            logger.warning("No project ID available - platform analyzer disabled")

cicaddy_gitlab/agent/base_review_agent.py

@@ -0,0 +1,135 @@
+"""BaseReviewAgent with GitLab platform integration.
+
+This class mirrors cicaddy's BaseReviewAgent interface but inherits from
+cicaddy_gitlab's BaseAIAgent instead of cicaddy's BaseAIAgent. This is
+required because cicaddy's BaseAIAgent has a no-op _setup_platform_integration(),
+while cicaddy_gitlab's BaseAIAgent overrides it to initialize the GitLabAnalyzer
+for posting MR comments and accessing the GitLab API.
+
+MRO: MergeRequestAgent -> BaseReviewAgent (this) -> BaseAIAgent (cicaddy_gitlab)
+     -> BaseAIAgent (cicaddy) -> ABC
+"""
+
+from typing import Any, Dict, Optional
+
+from cicaddy.config.settings import Settings
+from cicaddy.git.diff_analyzer import DiffAnalyzer
+from cicaddy.utils.logger import get_logger
+
+from cicaddy_gitlab.agent.base import BaseAIAgent
+
+logger = get_logger(__name__)
+
+
+class BaseReviewAgent(BaseAIAgent):
+    """Base class for code review agents with GitLab platform integration.
+
+    Inherits from cicaddy_gitlab.agent.base.BaseAIAgent to get GitLabAnalyzer
+    initialization via _setup_platform_integration(). MergeRequestAgent extends
+    this class to gain both diff analysis and GitLab API capabilities.
+    """
+
+    def __init__(self, settings: Optional[Settings] = None):
+        super().__init__(settings)
+        self.diff_analyzer: Optional[DiffAnalyzer] = None
+
+    async def initialize(self):
+        """Initialize the review agent with diff analyzer."""
+        await super().initialize()
+
+        # Initialize diff analyzer with git working directory
+        working_dir = getattr(self.settings, "git_working_directory", None)
+        self.diff_analyzer = DiffAnalyzer(working_directory=working_dir)
+
+        logger.info(
+            "Review agent initialized",
+            diff_analyzer_available=self.diff_analyzer is not None,
+            git_working_directory=working_dir,
+        )
+
+    async def get_analysis_context(self) -> Dict[str, Any]:
+        """Gather analysis context including diff and review-specific information."""
+        if not self.diff_analyzer:
+            raise ValueError("Diff analyzer not initialized - call initialize() first")
+
+        logger.info("Gathering analysis context for review")
+
+        # Get diff content
+        try:
+            diff_content = await self.get_diff_content()
+        except Exception as e:
+            logger.error(f"Failed to get diff content: {e}")
+            diff_content = f"Error retrieving diff: {str(e)}"
+
+        # Get review-specific context
+        try:
+            review_context = await self.get_review_context()
+        except Exception as e:
+            logger.error(f"Failed to get review context: {e}")
+            review_context = {"error": f"Failed to get review context: {str(e)}"}
+
+        # Get project information if GitLab analyzer is available
+        project_info = {}
+        if self.platform_analyzer:
+            try:
+                project_info = await self.platform_analyzer.get_project_info()
+            except Exception as e:
+                logger.warning(f"Could not get project info: {e}")
+                project_info = {"name": "Unknown Project", "error": str(e)}
+
+        # Combine all context
+        context = {
+            "project": project_info,
+            "diff": diff_content,
+            "platform_available": self.platform_analyzer is not None,
+            "timestamp": self.start_time.isoformat(),
+            "diff_lines": len(diff_content.splitlines()) if diff_content else 0,
+            **review_context,
+        }
+
+        logger.info(
+            "Analysis context gathered",
+            diff_lines=context["diff_lines"],
+            analysis_type=context.get("analysis_type", "unknown"),
+            platform_available=context["platform_available"],
+        )
+
+        return context
+
+    async def get_diff_summary(self) -> Dict[str, Any]:
+        """Generate a summary of the diff changes."""
+        try:
+            diff_content = await self.get_diff_content()
+
+            lines = diff_content.splitlines()
+            added_lines = len([line for line in lines if line.startswith("+")])
+            removed_lines = len([line for line in lines if line.startswith("-")])
+            modified_files = len(
+                [line for line in lines if line.startswith("diff --git")]
+            )
+
+            return {
+                "total_lines": len(lines),
+                "added_lines": added_lines,
+                "removed_lines": removed_lines,
+                "modified_files": modified_files,
+                "has_changes": len(lines) > 0,
+            }
+
+        except Exception as e:
+            logger.error(f"Failed to generate diff summary: {e}")
+            return {
+                "total_lines": 0,
+                "added_lines": 0,
+                "removed_lines": 0,
+                "modified_files": 0,
+                "has_changes": False,
+                "error": str(e),
+            }
+
+    def _validate_initialized(self):
+        """Validate that the agent is properly initialized."""
+        if not self.diff_analyzer:
+            raise ValueError(
+                "Review agent not properly initialized - diff analyzer missing"
+            )

cicaddy_gitlab/agent/branch_agent.py

@@ -0,0 +1,100 @@
+"""GitLab-specific BranchReviewAgent with commit comment posting.
+
+The core cicaddy BranchReviewAgent handles branch review logic and Slack
+notifications. This subclass re-parents it under cicaddy_gitlab's
+BaseReviewAgent (which initializes GitLabAnalyzer) and adds GitLab
+commit comment posting on top of the core notification behavior.
+
+MRO: BranchReviewAgent (this) -> BaseReviewAgent (cicaddy_gitlab)
+     -> BaseAIAgent (cicaddy_gitlab) -> BranchReviewAgent (cicaddy)
+     -> BaseReviewAgent (cicaddy) -> BaseAIAgent (cicaddy) -> ABC
+"""
+
+import os
+from typing import Any, Dict
+
+from cicaddy.agent.branch_agent import BranchReviewAgent as CoreBranchReviewAgent
+from cicaddy.utils.logger import get_logger
+
+from cicaddy_gitlab.agent.base_review_agent import BaseReviewAgent
+
+logger = get_logger(__name__)
+
+BOT_NOTE_MARKER = "<!-- cicaddy-gitlab:branch-review -->"
+
+
+class BranchReviewAgent(BaseReviewAgent, CoreBranchReviewAgent):
+    """BranchReviewAgent with GitLab platform integration.
+
+    Combines cicaddy core's branch review logic with GitLab's
+    BaseReviewAgent for platform integration. Adds GitLab commit
+    comment posting on top of core notification behavior.
+    """
+
+    async def send_notifications(
+        self, report: Dict[str, Any], analysis_result: Dict[str, Any]
+    ):
+        """Send notifications via Slack and post GitLab commit comment."""
+        logger.info(
+            f"Sending notifications for branch review: "
+            f"{self.source_branch} -> {self.target_branch}"
+        )
+        await super().send_notifications(report, analysis_result)
+        await self._post_gitlab_commit_comment(report, analysis_result)
+
+    async def _post_gitlab_commit_comment(
+        self, report: Dict[str, Any], analysis_result: Dict[str, Any]
+    ):
+        """Post analysis results as a comment to the current commit."""
+        if not self.platform_analyzer:
+            logger.debug("No platform analyzer available, skipping commit comment")
+            return
+
+        commit_sha = os.getenv("CI_COMMIT_SHA")
+        if not commit_sha:
+            logger.debug("No CI_COMMIT_SHA available, skipping commit comment")
+            return
+
+        try:
+            comment_content = self._format_gitlab_comment(report, analysis_result)
+            result = await self.platform_analyzer.post_commit_note(
+                commit_sha, comment_content, note_marker=BOT_NOTE_MARKER
+            )
+            logger.info(
+                f"Posted analysis comment to commit {commit_sha[:8]}, "
+                f"note ID: {result.get('id')}"
+            )
+        except Exception as e:
+            logger.error(f"Failed to post GitLab commit comment: {e}")
+
+    def _format_gitlab_comment(
+        self, report: Dict[str, Any], analysis_result: Dict[str, Any]
+    ) -> str:
+        """Format analysis results for GitLab commit comment.
+
+        The hidden marker is prepended so the bot can find and update its
+        own note later.
+        """
+        ai_analysis = analysis_result.get("ai_analysis", "No analysis available")
+        status = analysis_result.get("status", "unknown")
+        execution_time = analysis_result.get("execution_time", 0)
+        project_name = report.get("project", "Unknown Project")
+        status_icon = "pass" if status == "success" else "fail"
+
+        return f"""{BOT_NOTE_MARKER}
+## AI Branch Analysis Results ({status_icon})
+
+**Project:** {project_name}
+**Branch:** {self.source_branch} -> {self.target_branch}
+**Status:** {status.title()}
+**Execution Time:** {execution_time:.1f}s
+**Report ID:** `{report.get("report_id", "unknown")}`
+
+### Analysis Summary
+
+{ai_analysis}
+
+<!-- cicaddy-footer -->
+---
+*Analysis by cicaddy-gitlab AI Agent | Report: `{report.get("report_id", "N/A")}`*
+"""

cicaddy_gitlab/agent/factory.py

@@ -0,0 +1,57 @@
+"""GitLab-specific agent type detection for cicaddy plugin."""
+
+import os
+from typing import Optional
+
+from cicaddy.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def _detect_gitlab_agent_type(settings) -> Optional[str]:
+    """Detect GitLab-specific agent types from CI environment variables.
+
+    Handles merge_request, branch_review, and task detection from GitLab CI
+    variables. Runs at priority 40 (before cicaddy core's detector at 50).
+    """
+    # Merge request context
+    ci_mr_iid = os.getenv("CI_MERGE_REQUEST_IID")
+    if ci_mr_iid:
+        logger.info(f"Detected merge request context: CI_MERGE_REQUEST_IID={ci_mr_iid}")
+        return "merge_request"
+
+    mr_iid = getattr(settings, "merge_request_iid", None)
+    if mr_iid:
+        logger.info(f"Found merge request IID in settings: {mr_iid}")
+        return "merge_request"
+
+    # Task/scheduled context
+    task_type = os.getenv("TASK_TYPE") or os.getenv("CRON_TASK_TYPE")
+    if task_type:
+        logger.info(f"Detected task context: TASK_TYPE={task_type}")
+        return "task"
+
+    # GitLab CI pipeline source detection
+    pipeline_source = os.getenv("CI_PIPELINE_SOURCE")
+    if pipeline_source == "merge_request_event":
+        logger.info(
+            f"Detected merge request context: CI_PIPELINE_SOURCE={pipeline_source}"
+        )
+        return "merge_request"
+    elif pipeline_source == "schedule":
+        logger.info(
+            f"Detected task context: CI_PIPELINE_SOURCE={pipeline_source}, "
+            f"TASK_TYPE={task_type}"
+        )
+        return "task"
+    elif pipeline_source == "push":
+        ci_commit_branch = os.getenv("CI_COMMIT_BRANCH")
+        ci_default_branch = os.getenv("CI_DEFAULT_BRANCH", "main")
+        if ci_commit_branch and ci_commit_branch != ci_default_branch:
+            logger.info(
+                f"Detected branch push context: CI_PIPELINE_SOURCE={pipeline_source}, "
+                f"branch={ci_commit_branch}"
+            )
+            return "branch_review"
+
+    return None