cicaddy-github 0.1.0__py3-none-any.whl

cicaddy_github/__init__.py

@@ -0,0 +1,3 @@
+"""cicaddy-github: GitHub Actions plugin for cicaddy AI agent framework."""
+
+__version__ = "0.1.0"

cicaddy_github/config/settings.py

@@ -0,0 +1,193 @@
+"""Configuration for cicaddy-github (GitHub-specific extension of cicaddy)."""
+
+import logging
+import os
+from typing import Any
+
+from cicaddy.config.settings import CoreSettings
+from pydantic import AliasChoices, Field
+from pydantic_settings import SettingsConfigDict
+
+logger = logging.getLogger(__name__)
+
+
+class Settings(CoreSettings):
+    """Application settings with GitHub Actions platform-specific fields.
+
+    Extends CoreSettings with GitHub-specific configuration such as
+    tokens, repository info, event names, and other CI variables.
+    """
+
+    model_config = SettingsConfigDict(extra="ignore")
+
+    # GitHub configuration (uses built-in Actions variables)
+    github_token: str = Field(
+        default="",
+        validation_alias=AliasChoices("GITHUB_TOKEN"),
+        description="GitHub API token for repository access",
+    )
+    github_repository: str = Field(
+        default="",
+        validation_alias=AliasChoices("GITHUB_REPOSITORY"),
+        description="Repository in owner/name format",
+    )
+    github_ref: str = Field(
+        default="",
+        validation_alias=AliasChoices("GITHUB_REF"),
+        description="Git ref that triggered the workflow",
+    )
+    github_event_name: str = Field(
+        default="",
+        validation_alias=AliasChoices("GITHUB_EVENT_NAME"),
+        description="Name of the event that triggered the workflow",
+    )
+    github_sha: str = Field(
+        default="",
+        validation_alias=AliasChoices("GITHUB_SHA"),
+        description="Commit SHA that triggered the workflow",
+    )
+    github_run_id: str | None = Field(
+        default=None,
+        validation_alias=AliasChoices("GITHUB_RUN_ID"),
+        description="Unique ID for the workflow run",
+    )
+    github_pr_number: str | None = Field(
+        default=None,
+        validation_alias=AliasChoices("GITHUB_PR_NUMBER"),
+        description="Pull request number",
+    )
+    post_pr_comment: bool = Field(
+        default=False,
+        validation_alias=AliasChoices("POST_PR_COMMENT"),
+        description="Whether to post analysis results as PR comment",
+    )
+
+
+def load_settings() -> Settings:
+    """Load settings from environment variables with GitHub Actions defaults."""
+
+    # Handle MCP_SERVERS_CONFIG - default to empty array if missing
+    current_mcp_config = os.getenv("MCP_SERVERS_CONFIG")
+    if not current_mcp_config:
+        os.environ["MCP_SERVERS_CONFIG"] = "[]"
+
+    # Explicitly pass environment variables to work around Pydantic env reading issues
+    env_data: dict[str, Any] = {}
+
+    # GitHub configuration
+    if os.getenv("GITHUB_TOKEN"):
+        env_data["github_token"] = os.getenv("GITHUB_TOKEN")
+    if os.getenv("GITHUB_REPOSITORY"):
+        env_data["github_repository"] = os.getenv("GITHUB_REPOSITORY")
+    if os.getenv("GITHUB_REF"):
+        env_data["github_ref"] = os.getenv("GITHUB_REF")
+    if os.getenv("GITHUB_EVENT_NAME"):
+        env_data["github_event_name"] = os.getenv("GITHUB_EVENT_NAME")
+    if os.getenv("GITHUB_SHA"):
+        env_data["github_sha"] = os.getenv("GITHUB_SHA")
+    if os.getenv("GITHUB_RUN_ID"):
+        env_data["github_run_id"] = os.getenv("GITHUB_RUN_ID")
+    if os.getenv("GITHUB_PR_NUMBER"):
+        env_data["github_pr_number"] = os.getenv("GITHUB_PR_NUMBER")
+
+    # Post PR comment flag
+    post_pr = os.getenv("POST_PR_COMMENT", "").strip()
+    if post_pr:
+        env_data["post_pr_comment"] = post_pr.lower() in ("true", "1", "yes")
+
+    # AI provider configuration
+    if os.getenv("AI_PROVIDER"):
+        env_data["ai_provider"] = os.getenv("AI_PROVIDER")
+    if os.getenv("AI_MODEL"):
+        env_data["ai_model"] = os.getenv("AI_MODEL")
+
+    # AI API keys
+    if os.getenv("GEMINI_API_KEY"):
+        env_data["gemini_api_key"] = os.getenv("GEMINI_API_KEY")
+    if os.getenv("OPENAI_API_KEY"):
+        env_data["openai_api_key"] = os.getenv("OPENAI_API_KEY")
+    if os.getenv("ANTHROPIC_API_KEY"):
+        env_data["anthropic_api_key"] = os.getenv("ANTHROPIC_API_KEY")
+
+    # MCP server configuration
+    if os.getenv("MCP_SERVERS_CONFIG"):
+        env_data["mcp_servers_config"] = os.getenv("MCP_SERVERS_CONFIG")
+
+    # Slack configuration
+    if os.getenv("SLACK_WEBHOOK_URL"):
+        env_data["slack_webhook_url"] = os.getenv("SLACK_WEBHOOK_URL")
+
+    # Agent configuration
+    if os.getenv("AI_TASK_PROMPT"):
+        env_data["review_prompt"] = os.getenv("AI_TASK_PROMPT")
+    if os.getenv("AI_TASK_FILE"):
+        env_data["task_file"] = os.getenv("AI_TASK_FILE")
+    if os.getenv("ANALYSIS_FOCUS"):
+        env_data["analysis_focus"] = os.getenv("ANALYSIS_FOCUS")
+
+    # Git configuration
+    git_diff_context = os.getenv("GIT_DIFF_CONTEXT_LINES")
+    if git_diff_context:
+        env_data["git_diff_context_lines"] = int(git_diff_context)
+
+    # Local tools configuration
+    if os.getenv("ENABLE_LOCAL_TOOLS", "").strip():
+        env_data["enable_local_tools"] = os.getenv("ENABLE_LOCAL_TOOLS", "").lower().strip() in (
+            "true",
+            "1",
+            "yes",
+        )
+    if os.getenv("LOCAL_TOOLS_WORKING_DIR"):
+        env_data["local_tools_working_dir"] = os.getenv("LOCAL_TOOLS_WORKING_DIR")
+
+    # Execution configuration
+    max_exec_env = os.getenv("MAX_EXECUTION_TIME")
+    if max_exec_env == "":
+        os.environ.pop("MAX_EXECUTION_TIME", None)
+    elif max_exec_env:
+        try:
+            max_exec_time = int(max_exec_env)
+            if 60 <= max_exec_time <= 7200:
+                env_data["max_execution_time"] = max_exec_time
+            else:
+                logger.warning(
+                    f"MAX_EXECUTION_TIME {max_exec_time} out of range [60, 7200], using default 600"
+                )
+                os.environ.pop("MAX_EXECUTION_TIME", None)
+                env_data["max_execution_time"] = 600
+        except ValueError:
+            logger.warning(f"Invalid MAX_EXECUTION_TIME value '{max_exec_env}', using default 600")
+            os.environ.pop("MAX_EXECUTION_TIME", None)
+            env_data["max_execution_time"] = 600
+
+    context_safety_env = os.getenv("CONTEXT_SAFETY_FACTOR")
+    if context_safety_env == "":
+        os.environ.pop("CONTEXT_SAFETY_FACTOR", None)
+    elif context_safety_env:
+        try:
+            safety_factor = float(context_safety_env)
+            if 0.5 <= safety_factor <= 0.97:
+                env_data["context_safety_factor"] = safety_factor
+            else:
+                logger.warning(
+                    f"CONTEXT_SAFETY_FACTOR {safety_factor} out of range [0.5, 0.97], "
+                    "using default 0.85"
+                )
+                os.environ.pop("CONTEXT_SAFETY_FACTOR", None)
+                env_data["context_safety_factor"] = 0.85
+        except ValueError:
+            logger.warning(
+                f"Invalid CONTEXT_SAFETY_FACTOR value '{context_safety_env}', using default 0.85"
+            )
+            os.environ.pop("CONTEXT_SAFETY_FACTOR", None)
+            env_data["context_safety_factor"] = 0.85
+
+    # Logging configuration
+    if os.getenv("LOG_LEVEL"):
+        env_data["log_level"] = os.getenv("LOG_LEVEL")
+
+    # Report configuration
+    if os.getenv("REPORT_TEMPLATE"):
+        env_data["report_template"] = os.getenv("REPORT_TEMPLATE")
+
+    return Settings(**env_data)

cicaddy_github/github_integration/agents.py

@@ -0,0 +1,268 @@
+"""GitHub AI Agents for PR review and task execution."""
+
+import os
+from typing import Any
+
+from cicaddy.agent.base import BaseAIAgent
+from cicaddy.tools import ToolRegistry
+from cicaddy.utils.logger import get_logger
+
+from cicaddy_github.config.settings import Settings
+from cicaddy_github.github_integration.analyzer import GitHubAnalyzer
+from cicaddy_github.github_integration.tools import get_all_tools
+from cicaddy_github.security.leak_detector import LeakDetector
+
+logger = get_logger(__name__)
+
+BOT_COMMENT_MARKER_PR_REVIEW = "<!-- cicaddy-action:pr-review -->"
+
+
+class GitHubTaskAgent(BaseAIAgent):
+    """AI Agent for scheduled tasks and changelog generation."""
+
+    def __init__(self, settings: Settings | None = None):
+        super().__init__(settings)
+        self.leak_detector = LeakDetector()
+
+    async def _setup_local_tools(self):
+        """Setup local tools including git operations for changelog."""
+        await super()._setup_local_tools()
+        if self.local_tool_registry is None:
+            self.local_tool_registry = ToolRegistry(server_name="local")
+        # Register git tools as local tools
+        for t in get_all_tools():
+            self.local_tool_registry.register(t)
+        logger.info(f"Registered git tools: {self.local_tool_registry.list_tool_names()}")
+
+    async def _setup_platform_integration(self):
+        """Setup GitHub analyzer for API access."""
+        token = os.getenv("GITHUB_TOKEN", "")
+        repository = os.getenv("GITHUB_REPOSITORY", "")
+        working_dir = getattr(self.settings, "local_tools_working_dir", None) or "."
+
+        if token and repository:
+            try:
+                self.platform_analyzer = GitHubAnalyzer(
+                    token=token, repository=repository, working_dir=working_dir
+                )
+                logger.info(f"GitHub analyzer initialized for {repository}")
+            except Exception as e:
+                logger.warning(f"Failed to initialize GitHub analyzer: {e}")
+        else:
+            logger.debug("GitHub analyzer not initialized (missing token or repository)")
+
+    async def get_analysis_context(self) -> dict[str, Any]:
+        """Get task-specific context."""
+        return {
+            "analysis_type": "task",
+            "repository": os.getenv("GITHUB_REPOSITORY", ""),
+            "ref": os.getenv("GITHUB_REF", ""),
+            "sha": os.getenv("GITHUB_SHA", ""),
+        }
+
+    def build_analysis_prompt(self, context: dict[str, Any]) -> str:
+        """Build analysis prompt for task execution.
+
+        Supports DSPy YAML task definitions via AI_TASK_FILE.
+        Falls back to inline prompt or default.
+        """
+        task_file = os.getenv("AI_TASK_FILE")
+        if task_file:
+            dspy_prompt = self.build_dspy_prompt(task_file, context)
+            if dspy_prompt:
+                return dspy_prompt
+
+        task_prompt = os.getenv("AI_TASK_PROMPT", "")
+        if task_prompt:
+            return task_prompt
+
+        return (
+            "Analyze the repository and provide a summary of recent changes. "
+            "Use the available git tools to gather information."
+        )
+
+    async def send_notifications(self, report: dict[str, Any], analysis_result: dict[str, Any]):
+        """Send notifications via Slack (sanitized)."""
+        # Sanitize outputs before sending
+        if "ai_analysis" in analysis_result:
+            analysis_result["ai_analysis"] = self.leak_detector.sanitize_text(
+                analysis_result["ai_analysis"]
+            )
+        await super().send_notifications(report, analysis_result)
+
+    def get_session_id(self) -> str:
+        """Get unique session ID for this task."""
+        run_id = os.getenv("GITHUB_RUN_ID", "unknown")
+        return f"task_{run_id}"
+
+
+class GitHubPRAgent(BaseAIAgent):
+    """AI Agent specialized for pull request analysis and code review."""
+
+    def __init__(self, settings: Settings | None = None):
+        super().__init__(settings)
+        self.pr_number = settings.github_pr_number if settings else os.getenv("GITHUB_PR_NUMBER")
+        self.leak_detector = LeakDetector()
+
+    async def _setup_local_tools(self):
+        """Setup local tools for PR review."""
+        await super()._setup_local_tools()
+        if self.local_tool_registry is None:
+            self.local_tool_registry = ToolRegistry(server_name="local")
+        for t in get_all_tools():
+            self.local_tool_registry.register(t)
+
+    async def _setup_platform_integration(self):
+        """Setup GitHub analyzer for PR access."""
+        token = os.getenv("GITHUB_TOKEN", "")
+        repository = os.getenv("GITHUB_REPOSITORY", "")
+        working_dir = getattr(self.settings, "local_tools_working_dir", None) or "."
+
+        if token and repository:
+            try:
+                self.platform_analyzer = GitHubAnalyzer(
+                    token=token, repository=repository, working_dir=working_dir
+                )
+                logger.info(f"GitHub analyzer initialized for {repository}")
+            except Exception as e:
+                logger.warning(f"Failed to initialize GitHub analyzer: {e}")
+
+    async def get_diff_content(self) -> str:
+        """Get pull request diff content."""
+        if not self.pr_number:
+            raise ValueError("No PR number provided")
+        if not self.platform_analyzer:
+            raise ValueError("GitHub analyzer not initialized")
+
+        return await self.platform_analyzer.get_pull_request_diff(
+            int(self.pr_number),
+            context_lines=getattr(self.settings, "git_diff_context_lines", 3),
+        )
+
+    async def get_review_context(self) -> dict[str, Any]:
+        """Get pull request specific context."""
+        if not self.pr_number:
+            raise ValueError("No PR number provided")
+        if not self.platform_analyzer:
+            raise ValueError("GitHub analyzer not initialized")
+
+        pr_data = await self.platform_analyzer.get_pull_request_data(int(self.pr_number))
+        return {
+            "pull_request": pr_data,
+            "analysis_type": "pull_request",
+            "pr_number": self.pr_number,
+        }
+
+    async def get_analysis_context(self) -> dict[str, Any]:
+        """Get analysis context including PR data and diff."""
+        context = await self.get_review_context()
+
+        # Get diff content
+        diff_content = await self.get_diff_content()
+        context["diff"] = diff_content
+
+        # Add repository info
+        context["repository"] = os.getenv("GITHUB_REPOSITORY", "")
+
+        return context
+
+    def build_analysis_prompt(self, context: dict[str, Any]) -> str:
+        """Build analysis prompt for PR code review.
+
+        Supports DSPy YAML task definitions via AI_TASK_FILE.
+        Falls back to built-in prompt.
+        """
+        task_file = os.getenv("AI_TASK_FILE")
+        if task_file:
+            pr_context = self._prepare_dspy_context(context)
+            dspy_prompt = self.build_dspy_prompt(task_file, pr_context)
+            if dspy_prompt:
+                return dspy_prompt
+
+        pr_data = context["pull_request"]
+        diff_content = context["diff"]
+
+        return f"""You are an AI agent performing pull request code review.
+
+Repository: {context.get("repository", "Unknown")}
+Pull Request: {pr_data["title"]}
+Description: {pr_data.get("description", "No description")}
+Author: {pr_data.get("author", {}).get("name", "Unknown")}
+Target Branch: {pr_data.get("target_branch", "Unknown")}
+Source Branch: {pr_data.get("source_branch", "Unknown")}
+
+Code Changes:
+```diff
+{diff_content}
+```
+
+Instructions:
+1. Analyze the code changes thoroughly
+2. Identify bugs, security issues, and potential problems
+3. Suggest improvements for code quality and maintainability
+4. Provide actionable, specific feedback
+
+Please provide your comprehensive analysis in markdown format.
+"""
+
+    def _prepare_dspy_context(self, context: dict[str, Any]) -> dict[str, Any]:
+        """Prepare context with PR-specific data for DSPy prompt building."""
+        pr_context = context.copy()
+        pr_data = context.get("pull_request", {})
+        pr_context["pr_title"] = pr_data.get("title", "Unknown")
+        pr_context["pr_description"] = pr_data.get("description", "")
+        pr_context["pr_author"] = pr_data.get("author", {}).get("name", "Unknown")
+        pr_context["target_branch"] = pr_data.get("target_branch", "Unknown")
+        pr_context["source_branch"] = pr_data.get("source_branch", "Unknown")
+        pr_context["pr_number"] = self.pr_number
+        pr_context["diff_content"] = context.get("diff", "")
+        return pr_context
+
+    async def send_notifications(self, report: dict[str, Any], analysis_result: dict[str, Any]):
+        """Send notifications via PR comment and Slack."""
+        # Sanitize outputs
+        if "ai_analysis" in analysis_result:
+            analysis_result["ai_analysis"] = self.leak_detector.sanitize_text(
+                analysis_result["ai_analysis"]
+            )
+
+        # Post PR comment if enabled (updates existing bot comment in-place)
+        post_comment = getattr(self.settings, "post_pr_comment", False)
+        if post_comment and self.platform_analyzer and self.pr_number:
+            try:
+                comment = self._format_pr_comment(analysis_result)
+                await self.platform_analyzer.post_pr_comment(
+                    int(self.pr_number), comment, comment_marker=BOT_COMMENT_MARKER_PR_REVIEW
+                )
+                logger.info(f"Posted analysis to PR #{self.pr_number}")
+            except Exception as e:
+                logger.error(
+                    f"Failed to post PR comment: {self.leak_detector.sanitize_text(str(e))}"
+                )
+                logger.debug("PR comment post traceback:", exc_info=True)
+
+        # Send Slack notification using parent class
+        await super().send_notifications(report, analysis_result)
+
+    def _format_pr_comment(self, analysis_result: dict[str, Any]) -> str:
+        """Format analysis results as a PR comment.
+
+        The hidden marker is prepended so the bot can find and update its own
+        comment later.  No heading is injected — the AI analysis output already
+        contains its own structure.
+        """
+        comment = f"{BOT_COMMENT_MARKER_PR_REVIEW}\n"
+
+        if "ai_analysis" in analysis_result:
+            comment += analysis_result["ai_analysis"] + "\n"
+
+        comment += (
+            "\n<!-- cicaddy-footer -->\n---\n"
+            "*Generated with [cicaddy-action]"
+            "(https://github.com/redhat-community-ai-tools/cicaddy-action)*"
+        )
+        return comment
+
+    def get_session_id(self) -> str:
+        """Get unique session ID for this PR analysis."""
+        return f"pr_{self.pr_number or 'unknown'}"