iflow-mcp-m507_ai-soc-agent 1.0.0__py3-none-any.whl

src/integrations/eng/github/github_client.py

@@ -0,0 +1,169 @@
+"""
+GitHub client for creating project items and recommendations.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Any, Optional
+
+from ....core.config import SamiConfig
+from ....core.errors import IntegrationError
+from ....core.logging import get_logger
+from .github_http import GitHubHttpClient
+
+
+logger = get_logger("sami.integrations.github.client")
+
+
+class GitHubClient:
+    """
+    Client for interacting with GitHub Projects API to create project items and recommendations.
+    """
+
+    def __init__(
+        self,
+        http_client: GitHubHttpClient,
+        fine_tuning_project_id: str,
+        engineering_project_id: str,
+    ) -> None:
+        """
+        Initialize GitHub client.
+        
+        Args:
+            http_client: HTTP client for GitHub API
+            fine_tuning_project_id: GitHub project ID for fine-tuning recommendations
+            engineering_project_id: GitHub project ID for engineering/visibility recommendations
+        """
+        self._http = http_client
+        self.fine_tuning_project_id = fine_tuning_project_id
+        self.engineering_project_id = engineering_project_id
+
+    @classmethod
+    def from_config(cls, config: SamiConfig) -> "GitHubClient":
+        """
+        Factory to construct a client from ``SamiConfig``.
+        
+        Args:
+            config: SamiConfig instance with GitHub configuration
+        
+        Returns:
+            GitHubClient instance
+        
+        Raises:
+            IntegrationError: If GitHub configuration is not set
+        """
+        if not config.eng or not config.eng.github:
+            raise IntegrationError("GitHub configuration is not set in SamiConfig")
+
+        github_config = config.eng.github
+        http_client = GitHubHttpClient(
+            api_token=github_config.api_token,
+            timeout_seconds=github_config.timeout_seconds,
+            verify_ssl=github_config.verify_ssl,
+        )
+        
+        return cls(
+            http_client=http_client,
+            fine_tuning_project_id=github_config.fine_tuning_project_id,
+            engineering_project_id=github_config.engineering_project_id,
+        )
+
+    def create_fine_tuning_recommendation(
+        self,
+        title: str,
+        description: str,
+        content_id: Optional[str] = None,
+        content_type: str = "DraftIssue",
+    ) -> Dict[str, Any]:
+        """
+        Create a fine-tuning recommendation project item in GitHub.
+        
+        Args:
+            title: Item title
+            description: Item description/body
+            content_id: Optional content ID (for linking to issues/PRs)
+            content_type: Content type (DraftIssue, Issue, PullRequest). Default: DraftIssue
+        
+        Returns:
+            Dictionary with project item information
+        """
+        logger.info(f"Creating fine-tuning recommendation: {title}")
+        
+        # GitHub Projects API v1 (REST) - Note: v1 is deprecated but still functional
+        # We use REST API v1 for simplicity: POST /projects/columns/{column_id}/cards
+        
+        # Get the project columns
+        columns = self._http.get(f"/projects/{self.fine_tuning_project_id}/columns")
+        
+        if not columns:
+            raise IntegrationError("No columns found in fine-tuning project")
+        
+        # Use the first column
+        column_id = columns[0].get("id")
+        
+        # Create a card/item in the column
+        # For draft issues, we use note parameter
+        card_data = {
+            "note": f"## {title}\n\n{description}",
+        }
+        
+        card = self._http.post(f"/projects/columns/{column_id}/cards", json_data=card_data)
+        
+        logger.info(f"Created fine-tuning recommendation project item: {card.get('id')}")
+        return card
+
+    def create_visibility_recommendation(
+        self,
+        title: str,
+        description: str,
+        content_id: Optional[str] = None,
+        content_type: str = "DraftIssue",
+    ) -> Dict[str, Any]:
+        """
+        Create a visibility/engineering recommendation project item in GitHub.
+        
+        Args:
+            title: Item title
+            description: Item description/body
+            content_id: Optional content ID (for linking to issues/PRs)
+            content_type: Content type (DraftIssue, Issue, PullRequest). Default: DraftIssue
+        
+        Returns:
+            Dictionary with project item information
+        """
+        logger.info(f"Creating visibility recommendation: {title}")
+        
+        # Get the project columns
+        columns = self._http.get(f"/projects/{self.engineering_project_id}/columns")
+        
+        if not columns:
+            raise IntegrationError("No columns found in engineering project")
+        
+        # Use the first column
+        column_id = columns[0].get("id")
+        
+        # Create a card/item in the column
+        card_data = {
+            "note": f"## {title}\n\n{description}",
+        }
+        
+        card = self._http.post(f"/projects/columns/{column_id}/cards", json_data=card_data)
+        
+        logger.info(f"Created visibility recommendation project item: {card.get('id')}")
+        return card
+
+    def ping(self) -> bool:
+        """
+        Check if GitHub API is reachable.
+        
+        Returns:
+            True if API is reachable, False otherwise
+        """
+        try:
+            # Try to get authenticated user
+            self._http.get("/user")
+            return True
+        except IntegrationError:
+            logger.exception("GitHub ping failed")
+            return False
+

src/integrations/eng/github/github_http.py

@@ -0,0 +1,158 @@
+"""
+Low-level HTTP client for GitHub API.
+
+This module is responsible for:
+- authentication (Personal Access Token)
+- building URLs
+- making HTTP requests
+- basic error handling
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import requests
+
+from ....core.errors import IntegrationError
+from ....core.logging import get_logger
+
+
+logger = get_logger("sami.integrations.github.http")
+
+
+@dataclass
+class GitHubHttpClient:
+    """
+    Simple HTTP client for GitHub's REST API.
+    
+    GitHub API documentation: https://docs.github.com/en/rest
+    """
+
+    api_token: str
+    timeout_seconds: int = 30
+    verify_ssl: bool = True
+
+    def _headers(self) -> Dict[str, str]:
+        """Get authentication headers."""
+        return {
+            "Authorization": f"Bearer {self.api_token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+
+    def _build_url(self, endpoint: str) -> str:
+        """
+        Build a full URL from an endpoint.
+        
+        Args:
+            endpoint: API endpoint path (e.g., "/repos/{owner}/{repo}/projects")
+        
+        Returns:
+            Full URL string
+        """
+        base_url = "https://api.github.com"
+        endpoint = endpoint.lstrip("/")
+        return f"{base_url}/{endpoint}"
+
+    def _handle_github_error(self, response: requests.Response) -> None:
+        """
+        Raise IntegrationError if the response indicates an error.
+        
+        Args:
+            response: HTTP response object
+        
+        Raises:
+            IntegrationError: If the response indicates an error
+        """
+        if response.status_code < 400:
+            return
+
+        try:
+            error_data = response.json()
+            message = error_data.get("message", f"HTTP {response.status_code}")
+            errors = error_data.get("errors", [])
+            if errors:
+                error_details = "; ".join([str(e) for e in errors])
+                message = f"{message}: {error_details}"
+        except Exception:
+            message = f"HTTP {response.status_code}: {response.text[:200]}"
+
+        raise IntegrationError(f"GitHub API error: {message}")
+
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        json_data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make an HTTP request to GitHub API.
+        
+        Args:
+            method: HTTP method (GET, POST, PUT, PATCH, DELETE)
+            endpoint: API endpoint path
+            json_data: JSON payload (for POST, PUT, PATCH)
+            params: Query parameters
+        
+        Returns:
+            Response JSON as dictionary
+        
+        Raises:
+            IntegrationError: If the request fails
+        """
+        url = self._build_url(endpoint)
+        headers = self._headers()
+
+        try:
+            logger.debug(f"GitHub {method} {url}")
+            if params:
+                logger.debug(f"  Query params: {params}")
+            if json_data:
+                logger.debug(f"  JSON payload: {json.dumps(json_data)[:200]}...")
+
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=json_data,
+                params=params,
+                timeout=self.timeout_seconds,
+                verify=self.verify_ssl,
+            )
+
+            logger.debug(f"GitHub response status: {response.status_code}")
+            if response.status_code >= 400:
+                logger.error(f"GitHub API error - Status: {response.status_code}, URL: {url}, Response: {response.text[:500]}")
+
+            self._handle_github_error(response)
+
+            if response.status_code == 204:  # No Content
+                return {}
+
+            return response.json()
+
+        except requests.exceptions.Timeout as e:
+            raise IntegrationError(f"GitHub API request timeout: {e}") from e
+        except requests.exceptions.RequestException as e:
+            raise IntegrationError(f"GitHub API request failed: {e}") from e
+
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """GET request."""
+        return self.request("GET", endpoint, params=params)
+
+    def post(self, endpoint: str, json_data: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """POST request."""
+        return self.request("POST", endpoint, json_data=json_data, params=params)
+
+    def put(self, endpoint: str, json_data: Optional[Dict[str, Any]] = None, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """PUT request."""
+        return self.request("PUT", endpoint, json_data=json_data, params=params)
+
+    def delete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """DELETE request."""
+        return self.request("DELETE", endpoint, params=params)
+

src/integrations/eng/trello/__init__.py

@@ -0,0 +1,8 @@
+"""
+Trello integration for engineering task management.
+"""
+
+from .trello_client import TrelloClient
+
+__all__ = ["TrelloClient"]
+

src/integrations/eng/trello/trello_client.py

@@ -0,0 +1,207 @@
+"""
+Trello client for creating tasks and recommendations.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Any, Optional
+
+from ....core.config import SamiConfig
+from ....core.errors import IntegrationError
+from ....core.logging import get_logger
+from .trello_http import TrelloHttpClient
+
+
+logger = get_logger("sami.integrations.trello.client")
+
+
+class TrelloClient:
+    """
+    Client for interacting with Trello API to create tasks and recommendations.
+    """
+
+    def __init__(self, http_client: TrelloHttpClient, fine_tuning_board_id: str, engineering_board_id: str) -> None:
+        """
+        Initialize Trello client.
+        
+        Args:
+            http_client: HTTP client for Trello API
+            fine_tuning_board_id: Trello board ID for fine-tuning recommendations
+            engineering_board_id: Trello board ID for engineering/visibility recommendations
+        """
+        self._http = http_client
+        self.fine_tuning_board_id = fine_tuning_board_id
+        self.engineering_board_id = engineering_board_id
+
+    @classmethod
+    def from_config(cls, config: SamiConfig) -> "TrelloClient":
+        """
+        Factory to construct a client from ``SamiConfig``.
+        
+        Args:
+            config: SamiConfig instance with Trello configuration
+        
+        Returns:
+            TrelloClient instance
+        
+        Raises:
+            IntegrationError: If Trello configuration is not set
+        """
+        if not config.eng or not config.eng.trello:
+            raise IntegrationError("Trello configuration is not set in SamiConfig")
+
+        trello_config = config.eng.trello
+        http_client = TrelloHttpClient(
+            api_key=trello_config.api_key,
+            api_token=trello_config.api_token,
+            timeout_seconds=trello_config.timeout_seconds,
+            verify_ssl=trello_config.verify_ssl,
+        )
+        
+        return cls(
+            http_client=http_client,
+            fine_tuning_board_id=trello_config.fine_tuning_board_id,
+            engineering_board_id=trello_config.engineering_board_id,
+        )
+
+    def create_fine_tuning_recommendation(
+        self,
+        title: str,
+        description: str,
+        list_name: Optional[str] = None,
+        labels: Optional[list[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a fine-tuning recommendation card on the fine-tuning board.
+        
+        Args:
+            title: Card title
+            description: Card description
+            list_name: Optional list name (defaults to first list on board)
+            labels: Optional list of label names to add to the card
+        
+        Returns:
+            Dictionary with card information
+        """
+        logger.info(f"Creating fine-tuning recommendation: {title}")
+        
+        # Get lists on the board
+        lists = self._http.get(f"/1/boards/{self.fine_tuning_board_id}/lists")
+        
+        # Find the target list
+        target_list_id = None
+        if list_name:
+            for list_item in lists:
+                if list_item.get("name") == list_name:
+                    target_list_id = list_item.get("id")
+                    break
+            if not target_list_id:
+                raise IntegrationError(f"List '{list_name}' not found on fine-tuning board")
+        else:
+            # Use the first list if no list_name specified
+            if not lists:
+                raise IntegrationError("No lists found on fine-tuning board")
+            target_list_id = lists[0].get("id")
+        
+        # Create the card
+        card_data = {
+            "name": title,
+            "desc": description,
+            "idList": target_list_id,
+        }
+        
+        card = self._http.post("/1/cards", json_data=card_data)
+        
+        # Add labels if provided
+        if labels:
+            board_labels = self._http.get(f"/1/boards/{self.fine_tuning_board_id}/labels")
+            label_map = {label.get("name"): label.get("id") for label in board_labels if label.get("name")}
+            
+            for label_name in labels:
+                if label_name in label_map:
+                    # Trello API uses POST /1/cards/{id}/idLabels with value parameter
+                    self._http.post(f"/1/cards/{card['id']}/idLabels", params={"value": label_map[label_name]})
+                else:
+                    logger.warning(f"Label '{label_name}' not found on board, skipping")
+        
+        logger.info(f"Created fine-tuning recommendation card: {card.get('id')}")
+        return card
+
+    def create_visibility_recommendation(
+        self,
+        title: str,
+        description: str,
+        list_name: Optional[str] = None,
+        labels: Optional[list[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a visibility/engineering recommendation card on the engineering board.
+        
+        Args:
+            title: Card title
+            description: Card description
+            list_name: Optional list name (defaults to first list on board)
+            labels: Optional list of label names to add to the card
+        
+        Returns:
+            Dictionary with card information
+        """
+        logger.info(f"Creating visibility recommendation: {title}")
+        
+        # Get lists on the board
+        lists = self._http.get(f"/1/boards/{self.engineering_board_id}/lists")
+        
+        # Find the target list
+        target_list_id = None
+        if list_name:
+            for list_item in lists:
+                if list_item.get("name") == list_name:
+                    target_list_id = list_item.get("id")
+                    break
+            if not target_list_id:
+                raise IntegrationError(f"List '{list_name}' not found on engineering board")
+        else:
+            # Use the first list if no list_name specified
+            if not lists:
+                raise IntegrationError("No lists found on engineering board")
+            target_list_id = lists[0].get("id")
+        
+        # Create the card
+        card_data = {
+            "name": title,
+            "desc": description,
+            "idList": target_list_id,
+        }
+        
+        card = self._http.post("/1/cards", json_data=card_data)
+        
+        # Add labels if provided
+        if labels:
+            board_labels = self._http.get(f"/1/boards/{self.engineering_board_id}/labels")
+            label_map = {label.get("name"): label.get("id") for label in board_labels if label.get("name")}
+            
+            for label_name in labels:
+                if label_name in label_map:
+                    # Trello API uses POST /1/cards/{id}/idLabels with value parameter
+                    self._http.post(f"/1/cards/{card['id']}/idLabels", params={"value": label_map[label_name]})
+                else:
+                    logger.warning(f"Label '{label_name}' not found on board, skipping")
+        
+        logger.info(f"Created visibility recommendation card: {card.get('id')}")
+        return card
+
+    def ping(self) -> bool:
+        """
+        Check if Trello API is reachable.
+        
+        Returns:
+            True if API is reachable, False otherwise
+        """
+        try:
+            # Try to get boards for the authenticated user
+            self._http.get("/1/members/me/boards", params={"limit": 1})
+            return True
+        except IntegrationError:
+            logger.exception("Trello ping failed")
+            return False
+