actions_executor.py

"""Executes triage actions on GitHub notifications."""

from __future__ import annotations

import logging
from typing import Any, Dict, List

from github_api_client import GitHubAPIClient

logger = logging.getLogger(__name__)

# Map priority+action combinations to concrete GitHub operations
_ACTION_HANDLERS = {
    "mute": "_mute",
    "archive": "_archive",
    "review_now": "_flag_review_now",
    "review_later": "_noop",
}


class ActionsExecutor:
    """Executes triage actions returned by the LLM classifier."""

    def __init__(self, client: GitHubAPIClient, dry_run: bool = False):
        self._client = client
        self._dry_run = dry_run
        self._executed: List[Dict] = []

    def execute(self, notification: Dict[str, Any], classification: Dict[str, Any]) -> Dict:
        """Execute the appropriate action for a classified notification.

        Args:
            notification: Raw GitHub notification dict
            classification: Result from LLMClassifier.classify()

        Returns:
            Dict with keys: thread_id, action, priority, executed, dry_run
        """
        thread_id = notification["id"]
        action = classification.get("action", "review_later")
        priority = classification.get("priority", "P2")

        result = {
            "thread_id": thread_id,
            "action": action,
            "priority": priority,
            "executed": False,
            "dry_run": self._dry_run,
        }

        handler_name = _ACTION_HANDLERS.get(action, "_noop")
        handler = getattr(self, handler_name, self._noop)

        if self._dry_run:
            logger.info("[DRY RUN] Would execute %s on thread %s", action, thread_id)
            result["executed"] = True
        else:
            try:
                handler(notification, thread_id)
                result["executed"] = True
                logger.info("Executed %s on thread %s (priority=%s)", action, thread_id, priority)
            except Exception as exc:
                logger.error("Action %s failed on thread %s: %s", action, thread_id, exc)
                result["error"] = str(exc)

        self._executed.append(result)
        return result

    def get_execution_summary(self) -> Dict:
        """Return summary stats for this session."""
        total = len(self._executed)
        by_action = {}
        for r in self._executed:
            by_action[r["action"]] = by_action.get(r["action"], 0) + 1
        return {"total": total, "by_action": by_action}

    # -----------------------------------------------------------------------
    # Private action handlers
    # -----------------------------------------------------------------------

    def _mute(self, notification: Dict, thread_id: str) -> None:
        self._client.mute_thread(thread_id)
        self._client.mark_thread_read(thread_id)

    def _archive(self, notification: Dict, thread_id: str) -> None:
        self._client.mark_thread_read(thread_id)

    def _flag_review_now(self, notification: Dict, thread_id: str) -> None:
        # Mark unread so it stays prominent; optionally add P1 label
        repo = notification.get("repository", {})
        owner_repo = repo.get("full_name", "")
        subject = notification.get("subject", {})
        ntype = subject.get("type", "")
        if owner_repo and ntype in ("PullRequest", "Issue"):
            try:
                parts = owner_repo.split("/")
                # Extract issue/PR number from URL
                url = subject.get("url", "")
                if url:
                    number = int(url.rstrip("/").split("/")[-1])
                    self._client.add_label(parts[0], parts[1], number, "P1-review-now")
            except Exception as exc:
                logger.debug("Labelling skipped: %s", exc)

    def _noop(self, notification: Dict, thread_id: str) -> None:
        pass