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

gitflow_analytics/core/cache.py

@@ -1,14 +1,12 @@
 """Caching layer for Git analysis with SQLite backend."""
-import hashlib
+from contextlib import contextmanager
 from datetime import datetime, timedelta
-from typing import List, Optional, Dict, Any
 from pathlib import Path
-from contextlib import contextmanager
+from typing import Any, Dict, List, Optional
 
-from sqlalchemy.orm import Session
 from sqlalchemy import and_
 
-from ..models.database import Database, CachedCommit, PullRequestCache, IssueCache
+from ..models.database import CachedCommit, Database, IssueCache, PullRequestCache
 
 
 class GitAnalysisCache:

gitflow_analytics/core/identity.py

@@ -1,15 +1,14 @@
 """Developer identity resolution with persistence."""
-import uuid
 import difflib
-from datetime import datetime
-from typing import Dict, List, Optional, Set, Tuple, Any
+import uuid
 from collections import defaultdict
 from contextlib import contextmanager
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple
 
-from sqlalchemy.orm import Session
-from sqlalchemy import and_, or_
+from sqlalchemy import and_
 
-from ..models.database import Database, DeveloperIdentity, DeveloperAlias
+from ..models.database import Database, DeveloperAlias, DeveloperIdentity
 
 
 class DeveloperIdentityResolver:

gitflow_analytics/extractors/base.py

@@ -1,6 +1,6 @@
 """Base classes for pluggable extractors."""
 from abc import ABC, abstractmethod
-from typing import Any, Optional, List, Dict
+from typing import Any, Dict, List, Optional
 
 
 class ExtractorBase(ABC):

gitflow_analytics/extractors/story_points.py

@@ -1,6 +1,6 @@
 """Story point extraction from commits and pull requests."""
 import re
-from typing import Optional, List, Dict, Any
+from typing import Any, Dict, List, Optional
 
 
 class StoryPointExtractor:

gitflow_analytics/extractors/tickets.py

@@ -1,14 +1,20 @@
 """Ticket reference extraction for multiple platforms."""
 import re
-from typing import List, Dict, Any, Set
 from collections import defaultdict
+from typing import Any, Dict, List
 
 
 class TicketExtractor:
     """Extract ticket references from various issue tracking systems."""
     
-    def __init__(self):
-        """Initialize with patterns for different platforms."""
+    def __init__(self, allowed_platforms=None):
+        """Initialize with patterns for different platforms.
+        
+        Args:
+            allowed_platforms: List of platforms to extract tickets from.
+                              If None, all platforms are allowed.
+        """
+        self.allowed_platforms = allowed_platforms
         self.patterns = {
             'jira': [
                 r'([A-Z]{2,10}-\d+)',  # Standard JIRA format: PROJ-123
@@ -28,9 +34,12 @@ class TicketExtractor:
             ]
         }
         
-        # Compile patterns
+        # Compile patterns only for allowed platforms
         self.compiled_patterns = {}
         for platform, patterns in self.patterns.items():
+            # Skip platforms not in allowed list
+            if self.allowed_platforms and platform not in self.allowed_platforms:
+                continue
             self.compiled_patterns[platform] = [
                 re.compile(pattern, re.IGNORECASE if platform != 'jira' else 0) 
                 for pattern in patterns

gitflow_analytics/integrations/github_integration.py

@@ -1,7 +1,8 @@
 """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, Dict, List, Optional
+
 from github import Github
 from github.GithubException import RateLimitExceededException, UnknownObjectException
 
@@ -12,12 +13,14 @@ 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):
+                 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
+        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]]:
@@ -67,6 +70,10 @@ class GitHubIntegration:
         """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
@@ -97,7 +104,7 @@ class GitHubIntegration:
         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 ''}"

gitflow_analytics/integrations/jira_integration.py

@@ -0,0 +1,272 @@
+"""JIRA API integration for story point and ticket enrichment."""
+import base64
+from typing import Any, Dict, List, Optional, Set
+
+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 {}

gitflow_analytics/integrations/orchestrator.py

@@ -1,10 +1,11 @@
 """Integration orchestrator for multiple platforms."""
-from typing import Dict, Any, List, Optional
-from datetime import datetime
 import json
+from datetime import datetime
+from typing import Any, Dict, List
 
 from ..core.cache import GitAnalysisCache
 from .github_integration import GitHubIntegration
+from .jira_integration import JIRAIntegration
 
 
 class IntegrationOrchestrator:
@@ -22,8 +23,24 @@ class IntegrationOrchestrator:
                 config.github.token,
                 cache,
                 config.github.max_retries,
-                config.github.backoff_factor
+                config.github.backoff_factor,
+                allowed_ticket_platforms=getattr(config.analysis, 'ticket_platforms', None)
             )
+        
+        # Initialize JIRA integration if configured
+        if config.jira and config.jira.access_user and config.jira.access_token:
+            # Get JIRA specific settings if available
+            jira_settings = getattr(config, 'jira_integration', {})
+            if hasattr(jira_settings, 'enabled') and jira_settings.enabled:
+                base_url = getattr(config.jira, 'base_url', None)
+                if base_url:
+                    self.integrations['jira'] = JIRAIntegration(
+                        base_url,
+                        config.jira.access_user,
+                        config.jira.access_token,
+                        cache,
+                        story_point_fields=getattr(jira_settings, 'story_point_fields', None)
+                    )
     
     def enrich_repository_data(self, repo_config: Any, commits: List[Dict[str, Any]], 
                              since: datetime) -> Dict[str, Any]:
@@ -52,10 +69,19 @@ class IntegrationOrchestrator:
             except Exception as e:
                 print(f"   ⚠️  GitHub enrichment failed: {e}")
         
-        # Future: Add other platform integrations here
-        # - ClickUp
-        # - JIRA
-        # - Linear
+        # JIRA enrichment for story points
+        if 'jira' in self.integrations:
+            jira = self.integrations['jira']
+            try:
+                # Enrich commits with JIRA story points
+                jira.enrich_commits_with_jira_data(commits)
+                
+                # Enrich PRs with JIRA story points
+                if enrichment['prs']:
+                    jira.enrich_prs_with_jira_data(enrichment['prs'])
+                    
+            except Exception as e:
+                print(f"   ⚠️  JIRA enrichment failed: {e}")
         
         return enrichment
     

gitflow_analytics/metrics/dora.py

@@ -1,7 +1,7 @@
 """DORA (DevOps Research and Assessment) metrics calculation."""
-from datetime import datetime, timedelta
-from typing import List, Dict, Any, Optional
-from collections import defaultdict
+from datetime import datetime
+from typing import Any, Dict, List
+
 import numpy as np
 
 

gitflow_analytics/models/database.py

@@ -1,11 +1,11 @@
 """Database models for GitFlow Analytics using SQLAlchemy."""
 from datetime import datetime
-from typing import Optional
-from sqlalchemy import create_engine, Column, String, Integer, Float, DateTime, Boolean, JSON, Index
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker, Session
 from pathlib import Path
 
+from sqlalchemy import JSON, Boolean, Column, DateTime, Float, Index, Integer, String, create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import Session, sessionmaker
+
 Base = declarative_base()
 
 class CachedCommit(Base):

gitflow_analytics/reports/analytics_writer.py

@@ -26,7 +26,11 @@ class AnalyticsReportGenerator:
         
         # Calculate totals
         total_commits = len(commits)
-        total_lines = sum(c['insertions'] + c['deletions'] for c in commits)
+        total_lines = sum(
+            c.get('filtered_insertions', c.get('insertions', 0)) + 
+            c.get('filtered_deletions', c.get('deletions', 0)) 
+            for c in commits
+        )
         total_files = sum(c['files_changed'] for c in commits)
         
         # Group by developer and project
@@ -39,8 +43,11 @@ class AnalyticsReportGenerator:
             project = commit.get('project_key', 'UNKNOWN')
             
             dev_project_activity[dev_id][project]['commits'] += 1
-            dev_project_activity[dev_id][project]['lines'] += commit['insertions'] + commit['deletions']
-            dev_project_activity[dev_id][project]['files'] += commit['files_changed']
+            dev_project_activity[dev_id][project]['lines'] += (
+                commit.get('filtered_insertions', commit.get('insertions', 0)) + 
+                commit.get('filtered_deletions', commit.get('deletions', 0))
+            )
+            dev_project_activity[dev_id][project]['files'] += commit.get('filtered_files_changed', commit.get('files_changed', 0))
             dev_project_activity[dev_id][project]['story_points'] += commit.get('story_points', 0) or 0
         
         # Build report data
@@ -162,7 +169,10 @@ class AnalyticsReportGenerator:
                 projects[project_key] += 1
                 
                 # Lines changed per project
-                lines_changed = commit['insertions'] + commit['deletions']
+                lines_changed = (
+                    commit.get('filtered_insertions', commit.get('insertions', 0)) + 
+                    commit.get('filtered_deletions', commit.get('deletions', 0))
+                )
                 project_lines[project_key] += lines_changed
                 
                 # Weekly distribution

gitflow_analytics/reports/csv_writer.py

@@ -90,7 +90,12 @@ class CSVReportGenerator:
         # Overall statistics
         total_commits = len(commits)
         total_story_points = sum(c.get('story_points', 0) or 0 for c in commits)
-        total_lines = sum(c['insertions'] + c['deletions'] for c in commits)
+        # Use filtered stats if available, otherwise fall back to raw stats
+        total_lines = sum(
+            c.get('filtered_insertions', c.get('insertions', 0)) + 
+            c.get('filtered_deletions', c.get('deletions', 0)) 
+            for c in commits
+        )
         
         summary_data.append({
             'metric': 'Total Commits',
@@ -231,9 +236,12 @@ class CSVReportGenerator:
             # Aggregate metrics
             weekly_data[key]['commits'] += 1
             weekly_data[key]['story_points'] += commit.get('story_points', 0) or 0
-            weekly_data[key]['lines_added'] += commit.get('insertions', 0)
-            weekly_data[key]['lines_removed'] += commit.get('deletions', 0)
-            weekly_data[key]['files_changed'] += commit.get('files_changed', 0)
+            
+            # Use filtered stats if available, otherwise fall back to raw stats
+            weekly_data[key]['lines_added'] += commit.get('filtered_insertions', commit.get('insertions', 0))
+            weekly_data[key]['lines_removed'] += commit.get('filtered_deletions', commit.get('deletions', 0))
+            weekly_data[key]['files_changed'] += commit.get('filtered_files_changed', commit.get('files_changed', 0))
+            
             weekly_data[key]['complexity_delta'] += commit.get('complexity_delta', 0.0)
             
             # Track tickets

gitflow_analytics/reports/narrative_writer.py

@@ -78,7 +78,11 @@ class NarrativeReportGenerator:
         """Write executive summary section."""
         total_commits = len(commits)
         total_developers = len(developer_stats)
-        total_lines = sum(c['insertions'] + c['deletions'] for c in commits)
+        total_lines = sum(
+            c.get('filtered_insertions', c.get('insertions', 0)) + 
+            c.get('filtered_deletions', c.get('deletions', 0)) 
+            for c in commits
+        )
         
         report.write(f"- **Total Commits**: {total_commits:,}\n")
         report.write(f"- **Active Developers**: {total_developers}\n")