gitflow-analytics 1.0.0__py3-none-any.whl → 1.0.3__py3-none-any.whl

gitflow_analytics/integrations/github_integration.py

@@ -1,7 +1,9 @@
 """GitHub API integration for PR and issue enrichment."""
-from datetime import datetime, timedelta
-from typing import List, Dict, Any, Optional
+
 import time
+from datetime import datetime, timezone
+from typing import Any, Optional
+
 from github import Github
 from github.GithubException import RateLimitExceededException, UnknownObjectException
 
@@ -10,151 +12,163 @@ from ..core.cache import GitAnalysisCache
 
 class GitHubIntegration:
     """Integrate with GitHub API for PR and issue data."""
-    
-    def __init__(self, token: str, cache: GitAnalysisCache, 
-                 rate_limit_retries: int = 3, backoff_factor: int = 2):
+
+    def __init__(
+        self,
+        token: str,
+        cache: GitAnalysisCache,
+        rate_limit_retries: int = 3,
+        backoff_factor: int = 2,
+        allowed_ticket_platforms: Optional[list[str]] = None,
+    ):
         """Initialize GitHub integration."""
         self.github = Github(token)
         self.cache = cache
         self.rate_limit_retries = rate_limit_retries
         self.backoff_factor = backoff_factor
-    
-    def enrich_repository_with_prs(self, repo_name: str, commits: List[Dict[str, Any]], 
-                                  since: datetime) -> List[Dict[str, Any]]:
+        self.allowed_ticket_platforms = allowed_ticket_platforms
+
+    def enrich_repository_with_prs(
+        self, repo_name: str, commits: list[dict[str, Any]], since: datetime
+    ) -> list[dict[str, Any]]:
         """Enrich repository commits with PR data."""
         try:
             repo = self.github.get_repo(repo_name)
         except UnknownObjectException:
             print(f"   ⚠️  GitHub repo not found: {repo_name}")
             return []
-        
+
         # Get PRs for the time period
         prs = self._get_pull_requests(repo, since)
-        
+
         # Build commit to PR mapping
         commit_to_pr = {}
         for pr in prs:
             pr_data = self._extract_pr_data(pr)
-            
+
             # Cache PR data
             self.cache.cache_pr(repo_name, pr_data)
-            
+
             # Map commits to this PR
             for commit in pr.get_commits():
                 commit_to_pr[commit.sha] = pr_data
-        
+
         # Enrich commits with PR data
         enriched_prs = []
         for commit in commits:
-            if commit['hash'] in commit_to_pr:
-                pr_data = commit_to_pr[commit['hash']]
-                
+            if commit["hash"] in commit_to_pr:
+                pr_data = commit_to_pr[commit["hash"]]
+
                 # Use PR story points if commit doesn't have them
-                if not commit.get('story_points') and pr_data.get('story_points'):
-                    commit['story_points'] = pr_data['story_points']
-                
+                if not commit.get("story_points") and pr_data.get("story_points"):
+                    commit["story_points"] = pr_data["story_points"]
+
                 # Add PR reference
-                commit['pr_number'] = pr_data['number']
-                commit['pr_title'] = pr_data['title']
-                
+                commit["pr_number"] = pr_data["number"]
+                commit["pr_title"] = pr_data["title"]
+
                 # Add to PR list if not already there
                 if pr_data not in enriched_prs:
                     enriched_prs.append(pr_data)
-        
+
         return enriched_prs
-    
-    def _get_pull_requests(self, repo, since: datetime) -> List[Any]:
+
+    def _get_pull_requests(self, repo, since: datetime) -> list[Any]:
         """Get pull requests with rate limit handling."""
         prs = []
-        
+
+        # Ensure since is timezone-aware for comparison with GitHub's timezone-aware datetimes
+        if since.tzinfo is None:
+            since = since.replace(tzinfo=timezone.utc)
+
         for attempt in range(self.rate_limit_retries):
             try:
                 # Get all PRs updated since the date
-                for pr in repo.get_pulls(state='all', sort='updated', direction='desc'):
+                for pr in repo.get_pulls(state="all", sort="updated", direction="desc"):
                     if pr.updated_at < since:
                         break
-                    
+
                     # Only include PRs that were merged in our time period
                     if pr.merged and pr.merged_at >= since:
                         prs.append(pr)
-                
+
                 return prs
-                
+
             except RateLimitExceededException:
                 if attempt < self.rate_limit_retries - 1:
-                    wait_time = self.backoff_factor ** attempt
+                    wait_time = self.backoff_factor**attempt
                     print(f"   ⏳ GitHub rate limit hit, waiting {wait_time}s...")
                     time.sleep(wait_time)
                 else:
                     print("   ❌ GitHub rate limit exceeded, skipping PR enrichment")
                     return []
-        
+
         return prs
-    
-    def _extract_pr_data(self, pr) -> Dict[str, Any]:
+
+    def _extract_pr_data(self, pr) -> dict[str, Any]:
         """Extract relevant data from a GitHub PR object."""
         from ..extractors.story_points import StoryPointExtractor
         from ..extractors.tickets import TicketExtractor
-        
+
         sp_extractor = StoryPointExtractor()
-        ticket_extractor = TicketExtractor()
-        
+        ticket_extractor = TicketExtractor(allowed_platforms=self.allowed_ticket_platforms)
+
         # Extract story points from PR title and body
         pr_text = f"{pr.title} {pr.body or ''}"
         story_points = sp_extractor.extract_from_text(pr_text)
-        
+
         # Extract ticket references
         tickets = ticket_extractor.extract_from_text(pr_text)
-        
+
         # Get commit SHAs
         commit_hashes = [c.sha for c in pr.get_commits()]
-        
+
         return {
-            'number': pr.number,
-            'title': pr.title,
-            'description': pr.body,
-            'author': pr.user.login,
-            'created_at': pr.created_at,
-            'merged_at': pr.merged_at,
-            'story_points': story_points,
-            'labels': [label.name for label in pr.labels],
-            'commit_hashes': commit_hashes,
-            'ticket_references': tickets,
-            'review_comments': pr.review_comments,
-            'changed_files': pr.changed_files,
-            'additions': pr.additions,
-            'deletions': pr.deletions
+            "number": pr.number,
+            "title": pr.title,
+            "description": pr.body,
+            "author": pr.user.login,
+            "created_at": pr.created_at,
+            "merged_at": pr.merged_at,
+            "story_points": story_points,
+            "labels": [label.name for label in pr.labels],
+            "commit_hashes": commit_hashes,
+            "ticket_references": tickets,
+            "review_comments": pr.review_comments,
+            "changed_files": pr.changed_files,
+            "additions": pr.additions,
+            "deletions": pr.deletions,
         }
-    
-    def calculate_pr_metrics(self, prs: List[Dict[str, Any]]) -> Dict[str, Any]:
+
+    def calculate_pr_metrics(self, prs: list[dict[str, Any]]) -> dict[str, Any]:
         """Calculate PR-level metrics."""
         if not prs:
             return {
-                'avg_pr_size': 0,
-                'avg_pr_lifetime_hours': 0,
-                'avg_files_per_pr': 0,
-                'total_review_comments': 0
+                "avg_pr_size": 0,
+                "avg_pr_lifetime_hours": 0,
+                "avg_files_per_pr": 0,
+                "total_review_comments": 0,
             }
-        
-        total_size = sum(pr['additions'] + pr['deletions'] for pr in prs)
-        total_files = sum(pr.get('changed_files', 0) for pr in prs)
-        total_comments = sum(pr.get('review_comments', 0) for pr in prs)
-        
+
+        total_size = sum(pr["additions"] + pr["deletions"] for pr in prs)
+        total_files = sum(pr.get("changed_files", 0) for pr in prs)
+        total_comments = sum(pr.get("review_comments", 0) for pr in prs)
+
         # Calculate average PR lifetime
         lifetimes = []
         for pr in prs:
-            if pr.get('merged_at') and pr.get('created_at'):
-                lifetime = (pr['merged_at'] - pr['created_at']).total_seconds() / 3600
+            if pr.get("merged_at") and pr.get("created_at"):
+                lifetime = (pr["merged_at"] - pr["created_at"]).total_seconds() / 3600
                 lifetimes.append(lifetime)
-        
+
         avg_lifetime = sum(lifetimes) / len(lifetimes) if lifetimes else 0
-        
+
         return {
-            'total_prs': len(prs),
-            'avg_pr_size': total_size / len(prs),
-            'avg_pr_lifetime_hours': avg_lifetime,
-            'avg_files_per_pr': total_files / len(prs),
-            'total_review_comments': total_comments,
-            'prs_with_story_points': sum(1 for pr in prs if pr.get('story_points')),
-            'story_point_coverage': sum(1 for pr in prs if pr.get('story_points')) / len(prs) * 100
-        }
+            "total_prs": len(prs),
+            "avg_pr_size": total_size / len(prs),
+            "avg_pr_lifetime_hours": avg_lifetime,
+            "avg_files_per_pr": total_files / len(prs),
+            "total_review_comments": total_comments,
+            "prs_with_story_points": sum(1 for pr in prs if pr.get("story_points")),
+            "story_point_coverage": sum(1 for pr in prs if pr.get("story_points")) / len(prs) * 100,
+        }

gitflow_analytics/integrations/jira_integration.py

@@ -0,0 +1,284 @@
+"""JIRA API integration for story point and ticket enrichment."""
+
+import base64
+from typing import Any, Optional
+
+import requests
+from requests.exceptions import RequestException
+
+from ..core.cache import GitAnalysisCache
+
+
+class JIRAIntegration:
+    """Integrate with JIRA API for ticket and story point data."""
+
+    def __init__(
+        self,
+        base_url: str,
+        username: str,
+        api_token: str,
+        cache: GitAnalysisCache,
+        story_point_fields: Optional[list[str]] = None,
+    ):
+        """Initialize JIRA integration.
+
+        Args:
+            base_url: JIRA instance base URL (e.g., https://company.atlassian.net)
+            username: JIRA username/email
+            api_token: JIRA API token
+            cache: Git analysis cache for storing JIRA data
+            story_point_fields: List of custom field IDs for story points
+        """
+        self.base_url = base_url.rstrip("/")
+        self.cache = cache
+
+        # Set up authentication
+        credentials = base64.b64encode(f"{username}:{api_token}".encode()).decode()
+        self.headers = {
+            "Authorization": f"Basic {credentials}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+        # Default story point field names/IDs
+        self.story_point_fields = story_point_fields or [
+            "customfield_10016",  # Common story points field
+            "customfield_10021",  # Alternative field
+            "Story Points",  # Field name
+            "storypoints",  # Alternative name
+            "customfield_10002",  # Another common ID
+        ]
+
+        # Cache for field mapping
+        self._field_mapping = None
+
+    def enrich_commits_with_jira_data(self, commits: list[dict[str, Any]]) -> None:
+        """Enrich commits with JIRA story points by looking up ticket references.
+
+        Args:
+            commits: List of commit dictionaries to enrich
+        """
+        # Collect all unique JIRA tickets from commits
+        jira_tickets = set()
+        for commit in commits:
+            ticket_refs = commit.get("ticket_references", [])
+            for ref in ticket_refs:
+                if isinstance(ref, dict) and ref.get("platform") == "jira":
+                    jira_tickets.add(ref["id"])
+                elif isinstance(ref, str) and self._is_jira_ticket(ref):
+                    jira_tickets.add(ref)
+
+        if not jira_tickets:
+            return
+
+        # Fetch ticket data from JIRA
+        ticket_data = self._fetch_tickets_batch(list(jira_tickets))
+
+        # Enrich commits with story points
+        for commit in commits:
+            commit_story_points = 0
+            ticket_refs = commit.get("ticket_references", [])
+
+            for ref in ticket_refs:
+                ticket_id = None
+                if isinstance(ref, dict) and ref.get("platform") == "jira":
+                    ticket_id = ref["id"]
+                elif isinstance(ref, str) and self._is_jira_ticket(ref):
+                    ticket_id = ref
+
+                if ticket_id and ticket_id in ticket_data:
+                    points = ticket_data[ticket_id].get("story_points", 0)
+                    if points:
+                        commit_story_points = max(commit_story_points, points)
+
+            if commit_story_points > 0:
+                commit["story_points"] = commit_story_points
+
+    def enrich_prs_with_jira_data(self, prs: list[dict[str, Any]]) -> None:
+        """Enrich PRs with JIRA story points.
+
+        Args:
+            prs: List of PR dictionaries to enrich
+        """
+        # Similar to commits, extract JIRA tickets from PR titles/descriptions
+        for pr in prs:
+            pr_text = f"{pr.get('title', '')} {pr.get('description', '')}"
+            jira_tickets = self._extract_jira_tickets(pr_text)
+
+            if jira_tickets:
+                ticket_data = self._fetch_tickets_batch(list(jira_tickets))
+
+                # Use the highest story point value found
+                max_points = 0
+                for ticket_id in jira_tickets:
+                    if ticket_id in ticket_data:
+                        points = ticket_data[ticket_id].get("story_points", 0)
+                        max_points = max(max_points, points)
+
+                if max_points > 0:
+                    pr["story_points"] = max_points
+
+    def _fetch_tickets_batch(self, ticket_ids: list[str]) -> dict[str, dict[str, Any]]:
+        """Fetch multiple tickets from JIRA API.
+
+        Args:
+            ticket_ids: List of JIRA ticket IDs
+
+        Returns:
+            Dictionary mapping ticket ID to ticket data
+        """
+        if not ticket_ids:
+            return {}
+
+        # Check cache first
+        cached_tickets = {}
+        tickets_to_fetch = []
+
+        for ticket_id in ticket_ids:
+            cached = self._get_cached_ticket(ticket_id)
+            if cached:
+                cached_tickets[ticket_id] = cached
+            else:
+                tickets_to_fetch.append(ticket_id)
+
+        # Fetch missing tickets from JIRA
+        if tickets_to_fetch:
+            # JIRA JQL has a limit, so batch the requests
+            batch_size = 50
+            for i in range(0, len(tickets_to_fetch), batch_size):
+                batch = tickets_to_fetch[i : i + batch_size]
+                jql = f"key in ({','.join(batch)})"
+
+                try:
+                    response = requests.get(
+                        f"{self.base_url}/rest/api/3/search",
+                        headers=self.headers,
+                        params={
+                            "jql": jql,
+                            "fields": "*all",  # Get all fields to find story points
+                            "maxResults": batch_size,
+                        },
+                    )
+                    response.raise_for_status()
+
+                    data = response.json()
+                    for issue in data.get("issues", []):
+                        ticket_data = self._extract_ticket_data(issue)
+                        cached_tickets[ticket_data["id"]] = ticket_data
+                        self._cache_ticket(ticket_data["id"], ticket_data)
+
+                except RequestException as e:
+                    print(f"   ⚠️  Failed to fetch JIRA tickets: {e}")
+
+        return cached_tickets
+
+    def _extract_ticket_data(self, issue: dict[str, Any]) -> dict[str, Any]:
+        """Extract relevant data from JIRA issue.
+
+        Args:
+            issue: JIRA issue data from API
+
+        Returns:
+            Dictionary with extracted ticket data
+        """
+        fields = issue.get("fields", {})
+
+        # Extract story points from various possible fields
+        story_points = 0
+        for field_id in self.story_point_fields:
+            if field_id in fields and fields[field_id] is not None:
+                try:
+                    story_points = float(fields[field_id])
+                    break
+                except (ValueError, TypeError):
+                    continue
+
+        return {
+            "id": issue["key"],
+            "summary": fields.get("summary", ""),
+            "status": fields.get("status", {}).get("name", ""),
+            "story_points": int(story_points) if story_points else 0,
+            "assignee": (
+                fields.get("assignee", {}).get("displayName", "") if fields.get("assignee") else ""
+            ),
+            "created": fields.get("created", ""),
+            "updated": fields.get("updated", ""),
+        }
+
+    def _is_jira_ticket(self, text: str) -> bool:
+        """Check if text matches JIRA ticket pattern."""
+        import re
+
+        return bool(re.match(r"^[A-Z]{2,10}-\d+$", text))
+
+    def _extract_jira_tickets(self, text: str) -> set[str]:
+        """Extract JIRA ticket IDs from text."""
+        import re
+
+        pattern = r"([A-Z]{2,10}-\d+)"
+        matches = re.findall(pattern, text)
+        return set(matches)
+
+    def _get_cached_ticket(self, ticket_id: str) -> Optional[dict[str, Any]]:
+        """Get ticket data from cache."""
+        # TODO: Implement cache lookup using self.cache
+        # For now, return None to always fetch from API
+        return None
+
+    def _cache_ticket(self, ticket_id: str, ticket_data: dict[str, Any]) -> None:
+        """Cache ticket data."""
+        # TODO: Implement cache storage using self.cache
+        pass
+
+    def validate_connection(self) -> bool:
+        """Validate JIRA connection and credentials.
+
+        Returns:
+            True if connection is valid
+        """
+        try:
+            response = requests.get(f"{self.base_url}/rest/api/3/myself", headers=self.headers)
+            response.raise_for_status()
+            return True
+        except RequestException as e:
+            print(f"   ❌ JIRA connection failed: {e}")
+            return False
+
+    def discover_fields(self) -> dict[str, dict[str, str]]:
+        """Discover all available fields in JIRA instance.
+
+        Returns:
+            Dictionary mapping field IDs to their names and types
+        """
+        try:
+            response = requests.get(f"{self.base_url}/rest/api/3/field", headers=self.headers)
+            response.raise_for_status()
+
+            fields = {}
+            for field in response.json():
+                field_id = field.get("id", "")
+                field_name = field.get("name", "")
+                field_type = (
+                    field.get("schema", {}).get("type", "unknown")
+                    if field.get("schema")
+                    else "unknown"
+                )
+
+                # Look for potential story point fields
+                if any(
+                    term in field_name.lower() for term in ["story", "point", "estimate", "size"]
+                ):
+                    fields[field_id] = {
+                        "name": field_name,
+                        "type": field_type,
+                        "is_custom": field.get("custom", False),
+                    }
+                    print(
+                        f"   📊 Potential story point field: {field_id} = '{field_name}' (type: {field_type})"
+                    )
+
+            return fields
+
+        except RequestException as e:
+            print(f"   ⚠️  Failed to discover JIRA fields: {e}")
+            return {}