gitflow-analytics 3.13.8__py3-none-any.whl → 3.13.10__py3-none-any.whl

gitflow_analytics/_version.py

@@ -1,4 +1,4 @@
 """Version information for gitflow-analytics."""
 
-__version__ = "3.13.8"
+__version__ = "3.13.10"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

gitflow_analytics/cli.py

@@ -5546,7 +5546,7 @@ def aliases_command(
 
                     # Fetch commits
                     repo_commits = analyzer.analyze_repository(
-                        repo_config.path, start_date=start_date, branch=repo_config.branch
+                        repo_config.path, since=start_date, branch=repo_config.branch
                     )
 
                     if repo_commits:

gitflow_analytics/config/aliases.py

@@ -86,8 +86,11 @@ class AliasesManager:
     def load(self) -> None:
         """Load aliases from file.
 
-        Loads developer aliases from the configured YAML file. If the file
-        doesn't exist or is empty, initializes with an empty alias list.
+        Loads developer aliases from the configured YAML file. Supports both:
+        1. developer_aliases format (legacy and recommended)
+        2. teams-based format with nested members structure
+
+        If the file doesn't exist or is empty, initializes with an empty alias list.
 
         Raises:
             yaml.YAMLError: If the YAML file is malformed
@@ -101,22 +104,61 @@ class AliasesManager:
                 data = yaml.safe_load(f) or {}
 
             self.aliases = []
-            for alias_data in data.get("developer_aliases", []):
-                # Support both 'primary_email' (new) and 'canonical_email' (old)
-                primary_email = alias_data.get("primary_email") or alias_data.get("canonical_email")
-
-                if not primary_email:
-                    logger.warning(f"Skipping alias entry without primary_email: {alias_data}")
-                    continue
-
-                self.aliases.append(
-                    DeveloperAlias(
-                        primary_email=primary_email,
-                        aliases=alias_data.get("aliases", []),
-                        name=alias_data.get("name"),
-                        confidence=alias_data.get("confidence", 1.0),
-                        reasoning=alias_data.get("reasoning", ""),
+
+            # Format 1: developer_aliases list (recommended)
+            if "developer_aliases" in data:
+                for alias_data in data.get("developer_aliases", []):
+                    # Support both 'primary_email' (new) and 'canonical_email' (old)
+                    primary_email = alias_data.get("primary_email") or alias_data.get(
+                        "canonical_email"
                     )
+
+                    if not primary_email:
+                        logger.warning(f"Skipping alias entry without primary_email: {alias_data}")
+                        continue
+
+                    self.aliases.append(
+                        DeveloperAlias(
+                            primary_email=primary_email,
+                            aliases=alias_data.get("aliases", []),
+                            name=alias_data.get("name"),
+                            confidence=alias_data.get("confidence", 1.0),
+                            reasoning=alias_data.get("reasoning", ""),
+                        )
+                    )
+
+            # Format 2: teams-based structure
+            elif "teams" in data:
+                teams = data.get("teams", {})
+                for team_name, team_data in teams.items():
+                    members = team_data.get("members", {})
+                    for member_name, member_data in members.items():
+                        # Extract emails (primary is first, rest are aliases)
+                        emails = member_data.get("emails", [])
+                        if not emails:
+                            logger.warning(
+                                f"Skipping team member '{member_name}' in team '{team_name}' - no emails provided"
+                            )
+                            continue
+
+                        primary_email = emails[0]
+                        alias_emails = emails[1:] if len(emails) > 1 else []
+
+                        self.aliases.append(
+                            DeveloperAlias(
+                                primary_email=primary_email,
+                                aliases=alias_emails,
+                                name=member_name,
+                                confidence=1.0,
+                                reasoning=f"From team: {team_name}",
+                            )
+                        )
+
+            else:
+                # Unknown format - log warning
+                logger.warning(
+                    f"Aliases file {self.aliases_path} has unrecognized structure. "
+                    f"Expected 'developer_aliases' or 'teams' key. Found keys: {list(data.keys())}"
                 )
 
             logger.info(f"Loaded {len(self.aliases)} developer aliases from {self.aliases_path}")

gitflow_analytics/pm_framework/adapters/jira_adapter.py

@@ -109,25 +109,25 @@ class JiraTicketCache:
             # Indexes for efficient querying
             conn.execute(
                 """
-                CREATE INDEX IF NOT EXISTS idx_project_key 
+                CREATE INDEX IF NOT EXISTS idx_project_key
                 ON jira_tickets(project_key)
             """
             )
             conn.execute(
                 """
-                CREATE INDEX IF NOT EXISTS idx_expires_at 
+                CREATE INDEX IF NOT EXISTS idx_expires_at
                 ON jira_tickets(expires_at)
             """
             )
             conn.execute(
                 """
-                CREATE INDEX IF NOT EXISTS idx_status 
+                CREATE INDEX IF NOT EXISTS idx_status
                 ON jira_tickets(status)
             """
             )
             conn.execute(
                 """
-                CREATE INDEX IF NOT EXISTS idx_updated_at 
+                CREATE INDEX IF NOT EXISTS idx_updated_at
                 ON jira_tickets(updated_at)
             """
             )
@@ -161,7 +161,7 @@ class JiraTicketCache:
             cursor.execute(
                 """
                 SELECT ticket_data, expires_at, access_count
-                FROM jira_tickets 
+                FROM jira_tickets
                 WHERE ticket_key = ? AND expires_at > CURRENT_TIMESTAMP
             """,
                 (ticket_key,),
@@ -172,7 +172,7 @@ class JiraTicketCache:
                 # Update access statistics
                 cursor.execute(
                     """
-                    UPDATE jira_tickets 
+                    UPDATE jira_tickets
                     SET access_count = ?, last_accessed = CURRENT_TIMESTAMP
                     WHERE ticket_key = ?
                 """,
@@ -302,7 +302,7 @@ class JiraTicketCache:
             cursor = conn.cursor()
             cursor.execute(
                 """
-                UPDATE jira_tickets 
+                UPDATE jira_tickets
                 SET expires_at = DATETIME('now', '-1 hour')
                 WHERE ticket_key = ?
             """,
@@ -366,7 +366,7 @@ class JiraTicketCache:
 
             cursor.execute(
                 """
-                SELECT COUNT(*) as fresh FROM jira_tickets 
+                SELECT COUNT(*) as fresh FROM jira_tickets
                 WHERE expires_at > CURRENT_TIMESTAMP
             """
             )
@@ -374,7 +374,7 @@ class JiraTicketCache:
 
             cursor.execute(
                 """
-                SELECT COUNT(*) as expired FROM jira_tickets 
+                SELECT COUNT(*) as expired FROM jira_tickets
                 WHERE expires_at <= CURRENT_TIMESTAMP
             """
             )
@@ -383,10 +383,10 @@ class JiraTicketCache:
             # Project distribution
             cursor.execute(
                 """
-                SELECT project_key, COUNT(*) as count 
-                FROM jira_tickets 
+                SELECT project_key, COUNT(*) as count
+                FROM jira_tickets
                 WHERE expires_at > CURRENT_TIMESTAMP
-                GROUP BY project_key 
+                GROUP BY project_key
                 ORDER BY count DESC
                 LIMIT 10
             """
@@ -396,10 +396,10 @@ class JiraTicketCache:
             # Access patterns
             cursor.execute(
                 """
-                SELECT AVG(access_count) as avg_access, 
+                SELECT AVG(access_count) as avg_access,
                        MAX(access_count) as max_access,
                        COUNT(*) as accessed_tickets
-                FROM jira_tickets 
+                FROM jira_tickets
                 WHERE access_count > 1 AND expires_at > CURRENT_TIMESTAMP
             """
             )
@@ -408,7 +408,7 @@ class JiraTicketCache:
             # Recent activity
             cursor.execute(
                 """
-                SELECT COUNT(*) as recent FROM jira_tickets 
+                SELECT COUNT(*) as recent FROM jira_tickets
                 WHERE cached_at > DATETIME('now', '-24 hours')
             """
             )
@@ -1405,18 +1405,42 @@ class JIRAAdapter(BasePlatformAdapter):
         Returns:
             Story points as integer, or None if not found.
         """
+        # Track which fields were tried for debugging
+        tried_fields = []
+        found_values = {}
+
         # Try configured story point fields first
         for field_id in self.story_point_fields:
+            tried_fields.append(field_id)
             if field_id in fields and fields[field_id] is not None:
                 value = fields[field_id]
+                found_values[field_id] = value
                 try:
                     if isinstance(value, (int, float)):
+                        logger.debug(f"Found story points in field '{field_id}': {value}")
                         return int(value)
                     elif isinstance(value, str) and value.strip():
-                        return int(float(value.strip()))
-                except (ValueError, TypeError):
+                        points = int(float(value.strip()))
+                        logger.debug(f"Found story points in field '{field_id}': {points}")
+                        return points
+                except (ValueError, TypeError) as e:
+                    logger.debug(f"Field '{field_id}' has value {value} but failed to parse: {e}")
                     continue
 
+        # Log diagnostic information if no story points found
+        logger.debug(f"Story points not found. Tried fields: {tried_fields}")
+        if found_values:
+            logger.debug(f"Fields with non-null values (but unparseable): {found_values}")
+
+        # Log all available custom fields for debugging
+        custom_fields = {k: v for k, v in fields.items() if k.startswith("customfield_")}
+        if custom_fields:
+            logger.debug(f"Available custom fields in this issue: {list(custom_fields.keys())}")
+            logger.info(
+                "Story points not found. Use 'discover-storypoint-fields' command "
+                "to identify the correct custom field ID for your JIRA instance."
+            )
+
         # Use base class method as fallback
         return super()._extract_story_points(fields)
 

gitflow_analytics/reports/base.py

@@ -11,15 +11,13 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Union
 
-from ..models.database import Database
-
 logger = logging.getLogger(__name__)
 
 
 @dataclass
 class ReportMetadata:
     """Metadata for report generation."""
-    
+
     generated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     generation_time_seconds: float = 0.0
     source_repositories: List[str] = field(default_factory=list)
@@ -37,45 +35,45 @@ class ReportMetadata:
 @dataclass
 class ReportData:
     """Standardized data container for report generation.
-    
+
     This class provides a unified interface for passing data to report generators,
     ensuring all generators have access to the same data structure.
     """
-    
+
     # Core data
     commits: List[Dict[str, Any]] = field(default_factory=list)
     pull_requests: List[Dict[str, Any]] = field(default_factory=list)
     developer_stats: List[Dict[str, Any]] = field(default_factory=list)
-    
+
     # Analysis results
     activity_data: List[Dict[str, Any]] = field(default_factory=list)
     focus_data: List[Dict[str, Any]] = field(default_factory=list)
     insights_data: List[Dict[str, Any]] = field(default_factory=list)
     ticket_analysis: Dict[str, Any] = field(default_factory=dict)
-    
+
     # Metrics
     pr_metrics: Dict[str, Any] = field(default_factory=dict)
     dora_metrics: Dict[str, Any] = field(default_factory=dict)
     branch_health_metrics: List[Dict[str, Any]] = field(default_factory=list)
-    
+
     # Project management data
     pm_data: Optional[Dict[str, Any]] = None
     story_points_data: Optional[Dict[str, Any]] = None
-    
+
     # Qualitative analysis
     qualitative_results: List[Dict[str, Any]] = field(default_factory=list)
     chatgpt_summary: Optional[str] = None
-    
+
     # Metadata
     metadata: ReportMetadata = field(default_factory=ReportMetadata)
-    
+
     # Configuration
     config: Dict[str, Any] = field(default_factory=dict)
-    
+
     def get_required_fields(self) -> Set[str]:
         """Get the set of required fields for basic report generation."""
         return {"commits", "developer_stats"}
-    
+
     def validate(self) -> bool:
         """Validate that required data is present and properly formatted."""
         # Check required fields
@@ -83,7 +81,7 @@ class ReportData:
             if not getattr(self, field_name, None):
                 logger.warning(f"Required field '{field_name}' is empty or missing")
                 return False
-        
+
         # Validate commits have required fields
         if self.commits:
             required_commit_fields = {"hash", "author_email", "timestamp"}
@@ -92,14 +90,14 @@ class ReportData:
             if missing_fields:
                 logger.warning(f"Commits missing required fields: {missing_fields}")
                 return False
-        
+
         return True
 
 
 @dataclass
 class ReportOutput:
     """Container for report generation output."""
-    
+
     success: bool
     file_path: Optional[Path] = None
     content: Optional[Union[str, bytes]] = None
@@ -112,20 +110,20 @@ class ReportOutput:
 
 class BaseReportGenerator(ABC):
     """Abstract base class for all report generators.
-    
+
     This class defines the interface that all report generators must implement,
     ensuring consistency across different report formats.
     """
-    
+
     def __init__(
         self,
         anonymize: bool = False,
         exclude_authors: Optional[List[str]] = None,
         identity_resolver: Optional[Any] = None,
-        config: Optional[Dict[str, Any]] = None
+        config: Optional[Dict[str, Any]] = None,
     ):
         """Initialize the report generator.
-        
+
         Args:
             anonymize: Whether to anonymize developer identities
             exclude_authors: List of authors to exclude from reports
@@ -138,230 +136,253 @@ class BaseReportGenerator(ABC):
         self.config = config or {}
         self._anonymization_map: Dict[str, str] = {}
         self._anonymous_counter = 0
-        
+
         # Set up logging
         self.logger = logging.getLogger(self.__class__.__name__)
-    
+
     @abstractmethod
     def generate(self, data: ReportData, output_path: Optional[Path] = None) -> ReportOutput:
         """Generate the report.
-        
+
         Args:
             data: Standardized report data
             output_path: Optional path to write the report to
-            
+
         Returns:
             ReportOutput containing the results of generation
         """
         pass
-    
+
     @abstractmethod
     def get_required_fields(self) -> List[str]:
         """Get the list of required data fields for this report generator.
-        
+
         Returns:
             List of field names that must be present in ReportData
         """
         pass
-    
+
     @abstractmethod
     def get_format_type(self) -> str:
         """Get the format type this generator produces.
-        
+
         Returns:
             Format identifier (e.g., 'csv', 'markdown', 'json', 'html')
         """
         pass
-    
+
     def validate_data(self, data: ReportData) -> bool:
         """Validate that the required data is present and properly formatted.
-        
+
         Args:
             data: Report data to validate
-            
+
         Returns:
             True if data is valid, False otherwise
         """
         required_fields = self.get_required_fields()
-        
+
         for field_name in required_fields:
             if not hasattr(data, field_name):
                 self.logger.error(f"Missing required field: {field_name}")
                 return False
-            
+
             field_value = getattr(data, field_name)
             if field_value is None:
                 self.logger.error(f"Required field '{field_name}' is None")
                 return False
-            
+
             # Check if collections are empty when they shouldn't be
             if isinstance(field_value, (list, dict)) and not field_value:
                 if field_name in ["commits", "developer_stats"]:  # Core required fields
                     self.logger.error(f"Required field '{field_name}' is empty")
                     return False
-        
+
         return True
-    
+
     def pre_process(self, data: ReportData) -> ReportData:
         """Pre-process data before report generation.
-        
+
         This method can be overridden by subclasses to perform any necessary
         data transformation or filtering before the main generation logic.
-        
+
         Args:
             data: Input report data
-            
+
         Returns:
             Processed report data
         """
         # Apply author exclusions if configured
         if self.exclude_authors:
             data = self._filter_excluded_authors(data)
-        
+
         # Apply anonymization if configured
         if self.anonymize:
             data = self._anonymize_data(data)
-        
+
         return data
-    
+
     def post_process(self, output: ReportOutput) -> ReportOutput:
         """Post-process the report output.
-        
+
         This method can be overridden by subclasses to perform any necessary
         post-processing on the generated report.
-        
+
         Args:
             output: Initial report output
-            
+
         Returns:
             Processed report output
         """
         return output
-    
+
     def _filter_excluded_authors(self, data: ReportData) -> ReportData:
         """Filter out excluded authors from the report data.
-        
+
         Args:
             data: Input report data
-            
+
         Returns:
             Filtered report data
         """
         if not self.exclude_authors:
             return data
-        
+
         excluded_lower = [author.lower() for author in self.exclude_authors]
-        
+
         # Filter commits
         if data.commits:
             data.commits = [
-                commit for commit in data.commits
+                commit
+                for commit in data.commits
                 if not self._should_exclude_author(commit, excluded_lower)
             ]
-        
+
         # Filter developer stats
         if data.developer_stats:
             data.developer_stats = [
-                dev for dev in data.developer_stats
+                dev
+                for dev in data.developer_stats
                 if not self._should_exclude_developer(dev, excluded_lower)
             ]
-        
+
         # Update other data structures as needed
         for field_name in ["activity_data", "focus_data", "insights_data"]:
             field_value = getattr(data, field_name, None)
             if field_value:
                 filtered = [
-                    item for item in field_value
+                    item
+                    for item in field_value
                     if not self._should_exclude_item(item, excluded_lower)
                 ]
                 setattr(data, field_name, filtered)
-        
+
         return data
-    
+
     def _should_exclude_author(self, commit: Dict[str, Any], excluded_lower: List[str]) -> bool:
         """Check if a commit author should be excluded.
-        
+
+        WHY: Commits may not have canonical_id populated, so we need to check
+        all available identity fields to properly match exclusion patterns.
+
         Args:
             commit: Commit data
             excluded_lower: Lowercase list of excluded authors
-            
+
         Returns:
             True if author should be excluded
         """
-        # Check canonical_id first
-        canonical_id = commit.get("canonical_id", "")
-        if canonical_id and canonical_id.lower() in excluded_lower:
-            return True
-        
-        # Check other identity fields
-        for field in ["author_email", "author_name", "author"]:
+        # Build list of all identity values to check
+        identity_values = []
+
+        # Collect all identity fields (canonical_id may not be present)
+        for field in ["canonical_id", "author_email", "author_name", "author"]:
             value = commit.get(field, "")
-            if value and value.lower() in excluded_lower:
+            if value:
+                identity_values.append(value.lower())
+
+        # Check if any identity matches exclusion list
+        for identity in identity_values:
+            if identity in excluded_lower:
                 return True
-        
-        # Check for bot patterns
+            # Also check if any excluded pattern is a substring (for partial matches)
+            for excluded in excluded_lower:
+                if excluded in identity or identity in excluded:
+                    return True
+
+        # Check for bot patterns in author name and email
         author_name = commit.get("author_name", "").lower()
         author_email = commit.get("author_email", "").lower()
-        
+
         bot_indicators = ["[bot]", "bot@", "-bot", "_bot", ".bot"]
         for indicator in bot_indicators:
             if indicator in author_name or indicator in author_email:
                 return True
-        
+
         return False
-    
+
     def _should_exclude_developer(self, dev: Dict[str, Any], excluded_lower: List[str]) -> bool:
         """Check if a developer should be excluded.
-        
+
         Args:
             dev: Developer data
             excluded_lower: Lowercase list of excluded authors
-            
+
         Returns:
             True if developer should be excluded
         """
         # Check various identity fields
         identity_fields = [
-            "canonical_id", "primary_email", "primary_name",
-            "developer", "author", "name", "display_name"
+            "canonical_id",
+            "primary_email",
+            "primary_name",
+            "developer",
+            "author",
+            "name",
+            "display_name",
         ]
-        
+
         for field in identity_fields:
             value = dev.get(field, "")
             if value and value.lower() in excluded_lower:
                 return True
-        
+
         return False
-    
+
     def _should_exclude_item(self, item: Dict[str, Any], excluded_lower: List[str]) -> bool:
         """Generic exclusion check for data items.
-        
+
         Args:
             item: Data item to check
             excluded_lower: Lowercase list of excluded authors
-            
+
         Returns:
             True if item should be excluded
         """
         # Try common identity fields
         identity_fields = [
-            "canonical_id", "developer", "author", "author_email",
-            "primary_email", "name", "display_name"
+            "canonical_id",
+            "developer",
+            "author",
+            "author_email",
+            "primary_email",
+            "name",
+            "display_name",
         ]
-        
+
         for field in identity_fields:
             value = item.get(field, "")
             if value and value.lower() in excluded_lower:
                 return True
-        
+
         return False
-    
+
     def _anonymize_data(self, data: ReportData) -> ReportData:
         """Anonymize developer identities in the report data.
-        
+
         Args:
             data: Input report data
-            
+
         Returns:
             Anonymized report data
         """
@@ -369,123 +390,134 @@ class BaseReportGenerator(ABC):
         if data.commits:
             for commit in data.commits:
                 self._anonymize_commit(commit)
-        
+
         # Anonymize developer stats
         if data.developer_stats:
             for dev in data.developer_stats:
                 self._anonymize_developer(dev)
-        
+
         # Anonymize other data structures
         for field_name in ["activity_data", "focus_data", "insights_data"]:
             field_value = getattr(data, field_name, None)
             if field_value:
                 for item in field_value:
                     self._anonymize_item(item)
-        
+
         return data
-    
+
     def _anonymize_commit(self, commit: Dict[str, Any]) -> None:
         """Anonymize a commit record in-place.
-        
+
         Args:
             commit: Commit data to anonymize
         """
         for field in ["author_name", "author_email", "canonical_id"]:
             if field in commit:
                 commit[field] = self._get_anonymous_name(commit[field])
-    
+
     def _anonymize_developer(self, dev: Dict[str, Any]) -> None:
         """Anonymize a developer record in-place.
-        
+
         Args:
             dev: Developer data to anonymize
         """
         identity_fields = [
-            "canonical_id", "primary_email", "primary_name",
-            "developer", "author", "name", "display_name"
+            "canonical_id",
+            "primary_email",
+            "primary_name",
+            "developer",
+            "author",
+            "name",
+            "display_name",
         ]
-        
+
         for field in identity_fields:
             if field in dev:
                 dev[field] = self._get_anonymous_name(dev[field])
-    
+
     def _anonymize_item(self, item: Dict[str, Any]) -> None:
         """Anonymize a generic data item in-place.
-        
+
         Args:
             item: Data item to anonymize
         """
         identity_fields = [
-            "canonical_id", "developer", "author", "author_email",
-            "primary_email", "name", "display_name", "author_name"
+            "canonical_id",
+            "developer",
+            "author",
+            "author_email",
+            "primary_email",
+            "name",
+            "display_name",
+            "author_name",
         ]
-        
+
         for field in identity_fields:
             if field in item:
                 item[field] = self._get_anonymous_name(item[field])
-    
+
     def _get_anonymous_name(self, original: str) -> str:
         """Get an anonymous name for a given original name.
-        
+
         Args:
             original: Original name to anonymize
-            
+
         Returns:
             Anonymous name
         """
         if not original:
             return original
-        
+
         if original not in self._anonymization_map:
             self._anonymous_counter += 1
             self._anonymization_map[original] = f"Developer{self._anonymous_counter:03d}"
-        
+
         return self._anonymization_map[original]
-    
+
     def write_to_file(self, content: Union[str, bytes], output_path: Path) -> None:
         """Write report content to a file.
-        
+
         Args:
             content: Report content to write
             output_path: Path to write to
         """
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         if isinstance(content, bytes):
             output_path.write_bytes(content)
         else:
             output_path.write_text(content, encoding="utf-8")
-        
+
         self.logger.info(f"Report written to {output_path}")
 
 
 class CompositeReportGenerator(BaseReportGenerator):
     """Generator that can produce multiple report formats in a single run."""
-    
+
     def __init__(self, generators: List[BaseReportGenerator], **kwargs):
         """Initialize composite generator with multiple sub-generators.
-        
+
         Args:
             generators: List of report generators to compose
             **kwargs: Additional arguments passed to base class
         """
         super().__init__(**kwargs)
         self.generators = generators
-    
+
     def generate(self, data: ReportData, output_path: Optional[Path] = None) -> ReportOutput:
         """Generate reports using all configured generators.
-        
+
         Args:
             data: Report data
             output_path: Base output path (will be modified per generator)
-            
+
         Returns:
             Composite report output
         """
         outputs = []
         errors = []
         warnings = []
-        
+
         for generator in self.generators:
             try:
                 # Determine output path for this generator
@@ -493,45 +525,45 @@ class CompositeReportGenerator(BaseReportGenerator):
                 if output_path:
                     suffix = self._get_suffix_for_format(generator.get_format_type())
                     gen_output_path = output_path.with_suffix(suffix)
-                
+
                 # Generate report
                 output = generator.generate(data, gen_output_path)
                 outputs.append(output)
-                
+
                 # Collect errors and warnings
                 errors.extend(output.errors)
                 warnings.extend(output.warnings)
-                
+
             except Exception as e:
                 self.logger.error(f"Error in {generator.__class__.__name__}: {e}")
                 errors.append(f"{generator.__class__.__name__}: {str(e)}")
-        
+
         # Create composite output
         return ReportOutput(
             success=all(o.success for o in outputs),
             errors=errors,
             warnings=warnings,
-            metadata={"outputs": outputs}
+            metadata={"outputs": outputs},
         )
-    
+
     def get_required_fields(self) -> List[str]:
         """Get union of all required fields from sub-generators."""
         required = set()
         for generator in self.generators:
             required.update(generator.get_required_fields())
         return list(required)
-    
+
     def get_format_type(self) -> str:
         """Get composite format type."""
         formats = [g.get_format_type() for g in self.generators]
         return f"composite[{','.join(formats)}]"
-    
+
     def _get_suffix_for_format(self, format_type: str) -> str:
         """Get file suffix for a given format type.
-        
+
         Args:
             format_type: Format type identifier
-            
+
         Returns:
             File suffix including dot
         """
@@ -542,83 +574,89 @@ class CompositeReportGenerator(BaseReportGenerator):
             "html": ".html",
             "xml": ".xml",
             "yaml": ".yaml",
-            "pdf": ".pdf"
+            "pdf": ".pdf",
         }
         return suffix_map.get(format_type, f".{format_type}")
 
 
 class ChainedReportGenerator(BaseReportGenerator):
     """Generator that chains multiple generators, passing output of one as input to the next."""
-    
+
     def __init__(self, generators: List[BaseReportGenerator], **kwargs):
         """Initialize chained generator.
-        
+
         Args:
             generators: Ordered list of generators to chain
             **kwargs: Additional arguments passed to base class
         """
         super().__init__(**kwargs)
         self.generators = generators
-    
+
     def generate(self, data: ReportData, output_path: Optional[Path] = None) -> ReportOutput:
         """Generate reports in sequence, chaining outputs.
-        
+
         Args:
             data: Initial report data
             output_path: Final output path
-            
+
         Returns:
             Final report output
         """
         current_data = data
         outputs = []
-        
+
         for i, generator in enumerate(self.generators):
             try:
                 # Generate report
-                is_last = (i == len(self.generators) - 1)
+                is_last = i == len(self.generators) - 1
                 gen_output_path = output_path if is_last else None
-                
+
                 output = generator.generate(current_data, gen_output_path)
                 outputs.append(output)
-                
+
                 if not output.success:
                     return ReportOutput(
                         success=False,
                         errors=[f"Chain broken at {generator.__class__.__name__}"] + output.errors,
-                        metadata={"completed_steps": outputs}
+                        metadata={"completed_steps": outputs},
                     )
-                
+
                 # Transform output to input for next generator if not last
                 if not is_last and output.content:
                     current_data = self._transform_output_to_input(output, current_data)
-                
+
             except Exception as e:
                 self.logger.error(f"Error in chain at {generator.__class__.__name__}: {e}")
                 return ReportOutput(
                     success=False,
                     errors=[f"Chain error at {generator.__class__.__name__}: {str(e)}"],
-                    metadata={"completed_steps": outputs}
+                    metadata={"completed_steps": outputs},
                 )
-        
+
         # Return the final output
-        return outputs[-1] if outputs else ReportOutput(success=False, errors=["No generators in chain"])
-    
+        return (
+            outputs[-1]
+            if outputs
+            else ReportOutput(success=False, errors=["No generators in chain"])
+        )
+
     def get_required_fields(self) -> List[str]:
         """Get required fields from first generator in chain."""
         return self.generators[0].get_required_fields() if self.generators else []
-    
+
     def get_format_type(self) -> str:
         """Get format type of final generator in chain."""
         return self.generators[-1].get_format_type() if self.generators else "unknown"
-    
-    def _transform_output_to_input(self, output: ReportOutput, original_data: ReportData) -> ReportData:
+
+    def _transform_output_to_input(
+        self, output: ReportOutput, original_data: ReportData
+    ) -> ReportData:
         """Transform generator output to input for next generator.
-        
+
         Args:
             output: Output from previous generator
             original_data: Original input data
-            
+
         Returns:
             Transformed data for next generator
         """
@@ -639,10 +677,10 @@ class ChainedReportGenerator(BaseReportGenerator):
             qualitative_results=original_data.qualitative_results,
             chatgpt_summary=original_data.chatgpt_summary,
             metadata=original_data.metadata,
-            config=original_data.config
+            config=original_data.config,
         )
-        
+
         # Add previous output to config for next generator
         new_data.config["previous_output"] = output
-        
-        return new_data
+
+        return new_data

{gitflow_analytics-3.13.8.dist-info → gitflow_analytics-3.13.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitflow-analytics
-Version: 3.13.8
+Version: 3.13.10
 Summary: Analyze Git repositories for developer productivity insights
 Author-email: Bob Matyas <bobmatnyc@gmail.com>
 License: MIT

{gitflow_analytics-3.13.8.dist-info → gitflow_analytics-3.13.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
 gitflow_analytics/__init__.py,sha256=W3Jaey5wuT1nBPehVLTIRkVIyBa5jgYOlBKc_UFfh-4,773
-gitflow_analytics/_version.py,sha256=NrK5CHkptcEXHAM0rsxaSuosWfuwaiMjAT1Ujb8Vq50,138
-gitflow_analytics/cli.py,sha256=Yd_fLDwme6po7brH0ZrbzGVFCKLOmRnkYDfGC6yHfz4,310519
+gitflow_analytics/_version.py,sha256=1hnXysCLNSvcker8swzDyvO7lN7GKp5_EBB4vZHzJnQ,139
+gitflow_analytics/cli.py,sha256=VROaW-gh_A9P1fjKkvxHodU9Ci2tGr9vCqQFU3MYqG8,310514
 gitflow_analytics/config.py,sha256=XRuxvzLWyn_ML7mDCcuZ9-YFNAEsnt33vIuWxQQ_jxg,1033
 gitflow_analytics/constants.py,sha256=GXEncUJS9ijOI5KWtQCTANwdqxPfXpw-4lNjhaWTKC4,2488
 gitflow_analytics/verify_activity.py,sha256=q82VnU8FhHEPlnupYMvh1XtyaDJfIPPg-AI8cSM0PIk,27054
@@ -15,7 +15,7 @@ gitflow_analytics/cli_wizards/install_wizard.py,sha256=gz5c1NYeGLCzs-plL6ju7GXn7
 gitflow_analytics/cli_wizards/menu.py,sha256=Jcz4aTimVQ2kt1z9yC3I8uWUrmxitLvCvvSgem_nRpI,26106
 gitflow_analytics/cli_wizards/run_launcher.py,sha256=J6G_C7IqxPg7_GhAfbV99D1dIIWwb1s_qmHC7Iv2iGI,15038
 gitflow_analytics/config/__init__.py,sha256=KziRIbBJctB5LOLcKLzELWA1rXwjS6-C2_DeM_hT9rM,1133
-gitflow_analytics/config/aliases.py,sha256=z9F0X6qbbF544Tw7sHlOoBj5mpRSddMkCpoKLzvVzDU,10960
+gitflow_analytics/config/aliases.py,sha256=Q_dNTyN3rVWUUeaqqxFL9cwhz48RmYFBiH2CXU8YPJA,12886
 gitflow_analytics/config/errors.py,sha256=IBKhAIwJ4gscZFnLDyE3jEp03wn2stPR7JQJXNSIfok,10386
 gitflow_analytics/config/loader.py,sha256=khhxlt14TE_J-q-07cuhGpvmatU9Ttii0oMcKnsFpMA,38084
 gitflow_analytics/config/profiles.py,sha256=61lGoRScui3kBE63Bb9CSA442ISVjD_TupCEK-Yh7Yk,7947
@@ -59,7 +59,7 @@ gitflow_analytics/pm_framework/models.py,sha256=uikCapq6KGe_zbWymzvNFvJaN38Nld9i
 gitflow_analytics/pm_framework/orchestrator.py,sha256=q2-Lh5J-Ak823UTwKJkV0O4nBksA5XZ8htz-L70GuZA,27418
 gitflow_analytics/pm_framework/registry.py,sha256=ggUHS3WFsKXifaYPZgY15r2vGZEKyx-G33bjIv0kwJQ,13636
 gitflow_analytics/pm_framework/adapters/__init__.py,sha256=vS5btB-yIwVHZfoFYacWxHk3HszxIMWLnvBUgVDdNDU,1756
-gitflow_analytics/pm_framework/adapters/jira_adapter.py,sha256=E5-NuKHFDGkqObjhWvXqoEsVVnLXrnAiF2v81hTYQ7A,72527
+gitflow_analytics/pm_framework/adapters/jira_adapter.py,sha256=zBMNd9dVsxAkahbsUN_6jy4fFHHLDxDN3375R-DPkZ8,73767
 gitflow_analytics/qualitative/__init__.py,sha256=fwlb_xrv7Gatjylk5wclzckZxyss8K5cdZhhTHMWfYw,1184
 gitflow_analytics/qualitative/chatgpt_analyzer.py,sha256=nQDk1Rf2z2svpsnXoz0mxbwLXytFo3EgImbegg53FvI,11816
 gitflow_analytics/qualitative/enhanced_analyzer.py,sha256=iPftj8fQt6m2wd9pepV_YhteuFo3oUrVA9iC-Kb2ssE,92819
@@ -92,7 +92,7 @@ gitflow_analytics/qualitative/utils/metrics.py,sha256=_Gfyfrenxv-ynkSxVnkGpViROC
 gitflow_analytics/qualitative/utils/text_processing.py,sha256=j3fF5K9DYuRauKGIAxnezyGmqedXkR9wIXailkhG0BY,9205
 gitflow_analytics/reports/__init__.py,sha256=bU43ev2EDMKsCEQEzCyZU5yO2ZL4Oymq4N_3YD3pCQg,2156
 gitflow_analytics/reports/analytics_writer.py,sha256=Dp_7-W5XQIY_ddDEVuTOYHpjAzuxu35i8zx09aAqGRc,45303
-gitflow_analytics/reports/base.py,sha256=IjYX7PbnpVyyB6LI6dz_oLd3vtYsu1eBB978X0zIJDE,23203
+gitflow_analytics/reports/base.py,sha256=-ov2dWgf8KNlYFU0sfcqqf_lSOhgJDPBPaFVmWeL-Lw,23110
 gitflow_analytics/reports/branch_health_writer.py,sha256=Yfd4rGQLx1oBK8tA8t_jQ0b3OeTXEb4GJYrPbXHmsBU,13111
 gitflow_analytics/reports/classification_writer.py,sha256=3kyISHrLXUu8h4vtqBfn0N_k9uESfa2dSUX_MYqEQsc,46115
 gitflow_analytics/reports/cli_integration.py,sha256=4znVx9arRT6WQHvbS4MDjJmdg_8HBLdegXGqH00qAqw,15361
@@ -127,9 +127,9 @@ gitflow_analytics/ui/__init__.py,sha256=UBhYhZMvwlSrCuGWjkIdoP2zNbiQxOHOli-I8mqI
 gitflow_analytics/ui/progress_display.py,sha256=omCS86mCQR0QeMoM0YnsV3Gf2oALsDLu8u7XseQU6lk,59306
 gitflow_analytics/utils/__init__.py,sha256=YE3E5Mx-LmVRqLIgUUwDmbstm6gkpeavYHrQmVjwR3o,197
 gitflow_analytics/utils/commit_utils.py,sha256=TBgrWW73EODGOegGCF79ch0L0e5R6gpydNWutiQOa14,1356
-gitflow_analytics-3.13.8.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
-gitflow_analytics-3.13.8.dist-info/METADATA,sha256=SB9ftI95cTtgIWpy2Jq5a-gfUMm1QwFl5dpuVsC2qe4,40374
-gitflow_analytics-3.13.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gitflow_analytics-3.13.8.dist-info/entry_points.txt,sha256=ZOsX0GLsnMysp5FWPOfP_qyoS7WJ8IgcaDFDxWBYl1g,98
-gitflow_analytics-3.13.8.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
-gitflow_analytics-3.13.8.dist-info/RECORD,,
+gitflow_analytics-3.13.10.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
+gitflow_analytics-3.13.10.dist-info/METADATA,sha256=XRdT0GCYrgE2aNmzw9GWnFbQRyO57zK3zwC1ByglvxQ,40375
+gitflow_analytics-3.13.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gitflow_analytics-3.13.10.dist-info/entry_points.txt,sha256=ZOsX0GLsnMysp5FWPOfP_qyoS7WJ8IgcaDFDxWBYl1g,98
+gitflow_analytics-3.13.10.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
+gitflow_analytics-3.13.10.dist-info/RECORD,,

{gitflow_analytics-3.13.8.dist-info → gitflow_analytics-3.13.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any