gitflow-analytics 3.7.0__py3-none-any.whl → 3.7.4__py3-none-any.whl

gitflow_analytics/_version.py

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

gitflow_analytics/cli.py

@@ -944,7 +944,7 @@ def analyze(
             data_fetcher = GitDataFetcher(
                 cache=cache,
                 branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-                allowed_ticket_platforms=cfg.analysis.ticket_platforms,
+                allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
                 exclude_paths=cfg.analysis.exclude_paths,
             )
 
@@ -1135,9 +1135,7 @@ def analyze(
         analyzer = GitAnalyzer(
             cache,
             branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=cfg.analysis.exclude_paths,
             story_point_patterns=cfg.analysis.story_point_patterns,
             ml_categorization_config=ml_config,
@@ -1164,9 +1162,28 @@ def analyze(
                 # Use a 'repos' directory in the config directory for cloned repositories
                 config_dir = Path(config).parent if config else Path.cwd()
                 repos_dir = config_dir / "repos"
-                discovered_repos = cfg.discover_organization_repositories(clone_base_path=repos_dir)
+
+                # Progress callback for repository discovery
+                def discovery_progress(repo_name, count):
+                    if display and display._live:
+                        display.update_progress_task(
+                            "main",
+                            description=f"🔍 Discovering: {repo_name} ({count} repos checked)",
+                            completed=15 + min(count % 5, 4),  # Show some movement
+                        )
+                    else:
+                        # Simple inline progress - just show count
+                        click.echo(f"\r   📦 Checking repositories... {count}", nl=False)
+
+                discovered_repos = cfg.discover_organization_repositories(
+                    clone_base_path=repos_dir, progress_callback=discovery_progress
+                )
                 repositories_to_analyze = discovered_repos
 
+                # Clear the progress line
+                if not (display and display._live):
+                    click.echo("\r" + " " * 60 + "\r", nl=False)  # Clear line
+
                 if display and display._live:
                     # We're in full-screen mode, update progress and initialize repo list
                     display.update_progress_task(
@@ -1703,14 +1720,14 @@ def analyze(
                             "📊 No commits or batches found for date range - proceeding with data fetch"
                         )
 
-            # PROCEED WITH EMERGENCY FETCH if validation didn't pass
+            # PROCEED WITH INITIAL FETCH if validation didn't pass
             if not validation_passed:
                 if display:
                     display.print_status(
-                        "Data validation failed - running emergency data fetch", "warning"
+                        "Data validation failed - running initial data fetch", "warning"
                     )
                 else:
-                    click.echo("⚠️ Data validation failed - running emergency data fetch")
+                    click.echo("⚠️ Data validation failed - running initial data fetch")
 
                 # Force data fetch for all repositories since we have no batches
                 repos_needing_analysis = repositories_to_analyze
@@ -1719,12 +1736,12 @@ def analyze(
                 if repos_needing_analysis:
                     if display:
                         display.print_status(
-                            f"Emergency fetch: Fetching data for {len(repos_needing_analysis)} repositories...",
+                            f"Initial fetch: Fetching data for {len(repos_needing_analysis)} repositories...",
                             "info",
                         )
                     else:
                         click.echo(
-                            f"🚨 Emergency fetch: Fetching data for {len(repos_needing_analysis)} repositories..."
+                            f"🚨 Initial fetch: Fetching data for {len(repos_needing_analysis)} repositories..."
                         )
                         click.echo(
                             "   📋 Reason: Need to ensure commits and batches exist for classification"
@@ -1760,89 +1777,163 @@ def analyze(
                             # Check if repo exists, clone if needed (critical for organization mode)
                             if not repo_path.exists():
                                 if repo_config.github_repo and cfg.github.organization:
-                                    if display:
-                                        display.print_status(
-                                            f"   📥 Cloning {repo_config.github_repo} from GitHub...",
-                                            "info",
-                                        )
-                                    else:
-                                        click.echo(f"   📥 Cloning {repo_config.github_repo} from GitHub...")
-                                    try:
-                                        # Ensure parent directory exists
-                                        repo_path.parent.mkdir(parents=True, exist_ok=True)
-
-                                        # Build clone URL with authentication
-                                        clone_url = f"https://github.com/{repo_config.github_repo}.git"
-                                        if cfg.github.token:
-                                            clone_url = f"https://{cfg.github.token}@github.com/{repo_config.github_repo}.git"
-
-                                        # Clone using subprocess for better control
-                                        env = os.environ.copy()
-                                        env["GIT_TERMINAL_PROMPT"] = "0"
-                                        env["GIT_ASKPASS"] = ""
-                                        env["GCM_INTERACTIVE"] = "never"
-
-                                        cmd = ["git", "clone", "--config", "credential.helper="]
-                                        if repo_config.branch:
-                                            cmd.extend(["-b", repo_config.branch])
-                                        cmd.extend([clone_url, str(repo_path)])
-
-                                        result = subprocess.run(
-                                            cmd,
-                                            env=env,
-                                            capture_output=True,
-                                            text=True,
-                                            timeout=30,
-                                        )
+                                    # Retry logic for cloning
+                                    max_retries = 2
+                                    retry_count = 0
+                                    clone_success = False
+
+                                    while retry_count <= max_retries and not clone_success:
+                                        if retry_count > 0:
+                                            if display:
+                                                display.print_status(
+                                                    f"   🔄 Retry {retry_count}/{max_retries}: {repo_config.github_repo}",
+                                                    "warning",
+                                                )
+                                            else:
+                                                click.echo(
+                                                    f"   🔄 Retry {retry_count}/{max_retries}: {repo_config.github_repo}"
+                                                )
+                                        else:
+                                            if display:
+                                                display.print_status(
+                                                    f"   📥 Cloning {repo_config.github_repo} from GitHub...",
+                                                    "info",
+                                                )
+                                            else:
+                                                click.echo(
+                                                    f"   📥 Cloning {repo_config.github_repo} from GitHub..."
+                                                )
+
+                                        try:
+                                            # Ensure parent directory exists
+                                            repo_path.parent.mkdir(parents=True, exist_ok=True)
+
+                                            # Build clone URL with authentication
+                                            clone_url = (
+                                                f"https://github.com/{repo_config.github_repo}.git"
+                                            )
+                                            if cfg.github.token:
+                                                clone_url = f"https://{cfg.github.token}@github.com/{repo_config.github_repo}.git"
+
+                                            # Clone using subprocess for better control
+                                            env = os.environ.copy()
+                                            env["GIT_TERMINAL_PROMPT"] = "0"
+                                            env["GIT_ASKPASS"] = ""
+                                            env["GCM_INTERACTIVE"] = "never"
+                                            env["GIT_PROGRESS"] = "1"  # Force progress output
+
+                                            cmd = [
+                                                "git",
+                                                "clone",
+                                                "--progress",
+                                                "--config",
+                                                "credential.helper=",
+                                            ]
+                                            if repo_config.branch:
+                                                cmd.extend(["-b", repo_config.branch])
+                                            cmd.extend([clone_url, str(repo_path)])
+
+                                            # Track start time for timeout reporting
+                                            import time
+
+                                            start_time = time.time()
+                                            timeout_seconds = 300  # 5 minutes for large repos
+
+                                            # Run without capturing stderr to show git progress
+                                            result = subprocess.run(
+                                                cmd,
+                                                env=env,
+                                                stdout=subprocess.PIPE,
+                                                stderr=None,  # Let stderr (progress) flow to terminal
+                                                text=True,
+                                                timeout=timeout_seconds,
+                                            )
 
-                                        if result.returncode != 0:
-                                            error_msg = result.stderr or result.stdout
-                                            if any(
-                                                x in error_msg.lower()
-                                                for x in ["authentication", "permission denied", "401", "403"]
-                                            ):
+                                            elapsed = time.time() - start_time
+
+                                            if result.returncode != 0:
+                                                error_msg = "Clone failed"
+                                                if any(
+                                                    x in error_msg.lower()
+                                                    for x in [
+                                                        "authentication",
+                                                        "permission denied",
+                                                        "401",
+                                                        "403",
+                                                    ]
+                                                ):
+                                                    if display:
+                                                        display.print_status(
+                                                            f"   ❌ Authentication failed for {repo_config.github_repo}",
+                                                            "error",
+                                                        )
+                                                    else:
+                                                        click.echo(
+                                                            f"   ❌ Authentication failed for {repo_config.github_repo}"
+                                                        )
+                                                    break  # Don't retry auth failures
+                                                else:
+                                                    raise subprocess.CalledProcessError(
+                                                        result.returncode,
+                                                        cmd,
+                                                        result.stdout,
+                                                        result.stderr,
+                                                    )
+                                            else:
+                                                clone_success = True
                                                 if display:
                                                     display.print_status(
-                                                        f"   ❌ Authentication failed for {repo_config.github_repo}",
-                                                        "error",
+                                                        f"   ✅ Cloned {repo_config.github_repo} ({elapsed:.1f}s)",
+                                                        "success",
                                                     )
                                                 else:
                                                     click.echo(
-                                                        f"   ❌ Authentication failed for {repo_config.github_repo}"
+                                                        f"   ✅ Cloned {repo_config.github_repo} ({elapsed:.1f}s)"
                                                     )
-                                                continue
+
+                                        except subprocess.TimeoutExpired:
+                                            retry_count += 1
+                                            if display:
+                                                display.print_status(
+                                                    f"   ⏱️  Clone timeout after {timeout_seconds}s: {repo_config.github_repo}",
+                                                    "error",
+                                                )
                                             else:
-                                                raise subprocess.CalledProcessError(
-                                                    result.returncode, cmd, result.stdout, result.stderr
+                                                click.echo(
+                                                    f"   ⏱️  Clone timeout after {timeout_seconds}s: {repo_config.github_repo}"
                                                 )
+                                            # Clean up partial clone
+                                            if repo_path.exists():
+                                                import shutil
 
-                                        if display:
-                                            display.print_status(
-                                                f"   ✅ Cloned {repo_config.github_repo}", "success"
-                                            )
-                                        else:
-                                            click.echo(f"   ✅ Cloned {repo_config.github_repo}")
+                                                shutil.rmtree(repo_path, ignore_errors=True)
+                                            if retry_count > max_retries:
+                                                if display:
+                                                    display.print_status(
+                                                        f"   ❌ Skipping {repo_config.github_repo} after {max_retries} timeouts",
+                                                        "error",
+                                                    )
+                                                else:
+                                                    click.echo(
+                                                        f"   ❌ Skipping {repo_config.github_repo} after {max_retries} timeouts"
+                                                    )
+                                                break
+                                            continue  # Try again
+
+                                        except Exception as e:
+                                            retry_count += 1
+                                            if display:
+                                                display.print_status(
+                                                    f"   ❌ Clone error: {e}", "error"
+                                                )
+                                            else:
+                                                click.echo(f"   ❌ Clone error: {e}")
+                                            if retry_count > max_retries:
+                                                break
+                                            continue  # Try again
 
-                                    except subprocess.TimeoutExpired:
-                                        if display:
-                                            display.print_status(
-                                                f"   ❌ Clone timeout for {repo_config.github_repo}",
-                                                "error",
-                                            )
-                                        else:
-                                            click.echo(f"   ❌ Clone timeout for {repo_config.github_repo}")
-                                        continue
-                                    except Exception as e:
-                                        if display:
-                                            display.print_status(
-                                                f"   ❌ Failed to clone {repo_config.github_repo}: {e}",
-                                                "error",
-                                            )
-                                        else:
-                                            click.echo(
-                                                f"   ❌ Failed to clone {repo_config.github_repo}: {e}"
-                                            )
-                                        continue
+                                    if not clone_success:
+                                        continue  # Skip this repo and move to next
                                 else:
                                     # No github_repo configured, can't clone
                                     if display:
@@ -1928,15 +2019,15 @@ def analyze(
 
                     if display:
                         display.print_status(
-                            f"Emergency fetch complete: {total_commits} commits, {total_tickets} tickets",
+                            f"Initial fetch complete: {total_commits} commits, {total_tickets} tickets",
                             "success",
                         )
                     else:
                         click.echo(
-                            f"🚨 Emergency fetch complete: {total_commits} commits, {total_tickets} tickets"
+                            f"🚨 Initial fetch complete: {total_commits} commits, {total_tickets} tickets"
                         )
 
-                    # RE-VALIDATE after emergency fetch
+                    # RE-VALIDATE after initial fetch
                     with cache.get_session() as session:
                         final_commits = (
                             session.query(CachedCommit)
@@ -1961,7 +2052,7 @@ def analyze(
                         )
 
                         if final_commits == 0:
-                            error_msg = "❌ CRITICAL: Emergency fetch completed but still 0 commits stored in database"
+                            error_msg = "❌ CRITICAL: Initial fetch completed but still 0 commits stored in database"
                             if display:
                                 display.print_status(error_msg, "error")
                             else:
@@ -1969,7 +2060,9 @@ def analyze(
                             click.echo(
                                 f"   📅 Date range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}"
                             )
-                            click.echo(f"   📊 Emergency stats: {total_commits} commits reported")
+                            click.echo(
+                                f"   📊 Initial fetch stats: {total_commits} commits reported"
+                            )
                             click.echo(
                                 f"   🗃️ Database result: {final_commits} commits, {final_batches} batches"
                             )
@@ -1983,7 +2076,7 @@ def analyze(
                                 "      - Repository has no commits in the specified time range"
                             )
                             raise click.ClickException(
-                                "Emergency fetch failed validation - no data available for classification"
+                                "Initial fetch failed validation - no data available for classification"
                             )
 
                         if display:
@@ -2342,25 +2435,33 @@ def analyze(
                                 env["GIT_TERMINAL_PROMPT"] = "0"
                                 env["GIT_ASKPASS"] = ""
                                 env["GCM_INTERACTIVE"] = "never"
+                                env["GIT_PROGRESS"] = "1"  # Force progress output
 
                                 # Build git clone command
-                                cmd = ["git", "clone", "--config", "credential.helper="]
+                                cmd = [
+                                    "git",
+                                    "clone",
+                                    "--progress",
+                                    "--config",
+                                    "credential.helper=",
+                                ]
                                 if repo_config.branch:
                                     cmd.extend(["-b", repo_config.branch])
                                 cmd.extend([clone_url, str(repo_config.path)])
 
-                                # Run with timeout to prevent hanging
+                                # Run with timeout to prevent hanging, let progress show on stderr
                                 result = subprocess.run(
                                     cmd,
                                     env=env,
-                                    capture_output=True,
+                                    stdout=subprocess.PIPE,
+                                    stderr=None,  # Let stderr (progress) flow to terminal
                                     text=True,
-                                    timeout=30,  # 30 second timeout
+                                    timeout=120,  # Increase timeout for large repos
                                 )
 
                                 if result.returncode != 0:
                                     raise git.GitCommandError(
-                                        cmd, result.returncode, stderr=result.stderr
+                                        cmd, result.returncode, stderr="Clone failed"
                                     )
                             except subprocess.TimeoutExpired:
                                 if display:
@@ -2409,13 +2510,19 @@ def analyze(
                                     cmd = [
                                         "git",
                                         "clone",
+                                        "--progress",
                                         "--config",
                                         "credential.helper=",
                                         clone_url,
                                         str(repo_config.path),
                                     ]
                                     result = subprocess.run(
-                                        cmd, env=env, capture_output=True, text=True, timeout=30
+                                        cmd,
+                                        env=env,
+                                        stdout=subprocess.PIPE,
+                                        stderr=None,
+                                        text=True,
+                                        timeout=120,
                                     )
                                     if result.returncode != 0:
                                         raise git.GitCommandError(
@@ -4192,9 +4299,7 @@ def fetch(
         data_fetcher = GitDataFetcher(
             cache=cache,
             branch_mapping_rules=getattr(cfg.analysis, "branch_mapping_rules", {}),
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=getattr(cfg.analysis, "exclude_paths", None),
         )
 
@@ -4217,9 +4322,23 @@ def fetch(
                 # Use a 'repos' directory in the config directory for cloned repositories
                 config_dir = Path(config).parent if config else Path.cwd()
                 repos_dir = config_dir / "repos"
-                discovered_repos = cfg.discover_organization_repositories(clone_base_path=repos_dir)
+
+                # Progress callback for repository discovery
+                def discovery_progress(repo_name, count):
+                    if display:
+                        display.print_status(f"   📦 Checking: {repo_name} ({count})", "info")
+                    else:
+                        click.echo(f"\r   📦 Checking repositories... {count}", nl=False)
+
+                discovered_repos = cfg.discover_organization_repositories(
+                    clone_base_path=repos_dir, progress_callback=discovery_progress
+                )
                 repositories_to_fetch = discovered_repos
 
+                # Clear the progress line
+                if not display:
+                    click.echo("\r" + " " * 60 + "\r", nl=False)  # Clear line
+
                 if display:
                     display.print_status(
                         f"Found {len(discovered_repos)} repositories in organization", "success"
@@ -4400,6 +4519,8 @@ def cache_stats(config: Path) -> None:
     - Decide when to clear cache
     - Troubleshoot slow analyses
     """
+    from .core.cache import GitAnalysisCache
+
     try:
         cfg = ConfigLoader.load(config)
         cache = GitAnalysisCache(cfg.cache.directory)
@@ -4454,6 +4575,8 @@ def merge_identity(config: Path, dev1: str, dev2: str) -> None:
     - Refreshes cached statistics
     - Updates identity mappings
     """
+    from .core.identity import DeveloperIdentityResolver
+
     try:
         cfg = ConfigLoader.load(config)
         identity_resolver = DeveloperIdentityResolver(cfg.cache.directory / "identities.db")
@@ -4719,6 +4842,7 @@ def discover_storypoint_fields(config: Path) -> None:
             return
 
         # Initialize PM integration (currently JIRA)
+        from .core.cache import GitAnalysisCache
         from .integrations.jira_integration import JIRAIntegration
 
         # Create minimal cache for integration
@@ -4802,6 +4926,9 @@ def identities(config: Path, weeks: int, apply: bool) -> None:
       Mappings are saved to 'analysis.identity.manual_mappings'
       Bot exclusions go to 'analysis.exclude.authors'
     """
+    from .core.analyzer import GitAnalyzer
+    from .core.cache import GitAnalysisCache
+
     try:
         cfg = ConfigLoader.load(config)
         cache = GitAnalysisCache(cfg.cache.directory)
@@ -4862,9 +4989,7 @@ def identities(config: Path, weeks: int, apply: bool) -> None:
         analyzer = GitAnalyzer(
             cache,
             branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=cfg.analysis.exclude_paths,
             story_point_patterns=cfg.analysis.story_point_patterns,
             ml_categorization_config=ml_config,
@@ -5032,6 +5157,8 @@ def aliases_command(
     """
     try:
         from .config.aliases import AliasesManager, DeveloperAlias
+        from .core.analyzer import GitAnalyzer
+        from .core.cache import GitAnalysisCache
         from .identity_llm.analyzer import LLMIdentityAnalyzer
 
         # Load configuration
@@ -5099,9 +5226,7 @@ def aliases_command(
         analyzer = GitAnalyzer(
             cache,
             branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=cfg.analysis.exclude_paths,
             story_point_patterns=cfg.analysis.story_point_patterns,
             ml_categorization_config=ml_config,
@@ -5335,6 +5460,8 @@ def list_developers(config: Path) -> None:
     - Finding developer email addresses
     - Checking contribution statistics
     """
+    from .core.identity import DeveloperIdentityResolver
+
     try:
         cfg = ConfigLoader.load(config)
         identity_resolver = DeveloperIdentityResolver(cfg.cache.directory / "identities.db")
@@ -5468,6 +5595,8 @@ def train(
       - scikit-learn and pandas dependencies
       - ~100MB disk space for model storage
     """
+    from .core.cache import GitAnalysisCache
+    from .integrations.orchestrator import IntegrationOrchestrator
 
     # Configure logging
     if log.upper() != "NONE":
@@ -5551,8 +5680,18 @@ def train(
             try:
                 config_dir = Path(config).parent if config else Path.cwd()
                 repos_dir = config_dir / "repos"
-                discovered_repos = cfg.discover_organization_repositories(clone_base_path=repos_dir)
+
+                # Progress callback for repository discovery
+                def discovery_progress(repo_name, count):
+                    click.echo(f"\r   📦 Checking repositories... {count}", nl=False)
+
+                discovered_repos = cfg.discover_organization_repositories(
+                    clone_base_path=repos_dir, progress_callback=discovery_progress
+                )
                 repositories_to_analyze = discovered_repos
+
+                # Clear the progress line and show result
+                click.echo("\r" + " " * 60 + "\r", nl=False)
                 click.echo(f"✅ Found {len(discovered_repos)} repositories in organization")
             except Exception as e:
                 click.echo(f"❌ Failed to discover repositories: {e}")

gitflow_analytics/config/repository.py

@@ -20,12 +20,13 @@ class RepositoryManager:
         self.github_config = github_config
 
     def discover_organization_repositories(
-        self, clone_base_path: Optional[Path] = None
+        self, clone_base_path: Optional[Path] = None, progress_callback=None
     ) -> list[RepositoryConfig]:
         """Discover repositories from GitHub organization.
 
         Args:
             clone_base_path: Base directory where repos should be cloned/found.
+            progress_callback: Optional callback function(repo_name, count) for progress updates.
 
         Returns:
             List of discovered repository configurations.
@@ -42,7 +43,14 @@ class RepositoryManager:
             if clone_base_path is None:
                 raise ValueError("No base path available for repository cloning")
 
+            repo_count = 0
             for repo in org.get_repos():
+                repo_count += 1
+
+                # Call progress callback if provided
+                if progress_callback:
+                    progress_callback(repo.name, repo_count)
+
                 # Skip archived repositories
                 if repo.archived:
                     continue

gitflow_analytics/config/schema.py

@@ -456,3 +456,42 @@ class Config:
             raise ValueError(
                 f"Failed to discover repositories from organization {self.github.organization}: {e}"
             ) from e
+
+    def get_effective_ticket_platforms(self) -> list[str]:
+        """Get the effective list of ticket platforms to extract.
+
+        If ticket_platforms is explicitly configured in analysis config, use that.
+        Otherwise, infer from which PM platforms are actually configured.
+
+        Returns:
+            List of ticket platform names to extract (e.g., ['jira', 'github'])
+        """
+        # If explicitly configured, use that
+        if self.analysis.ticket_platforms is not None:
+            return self.analysis.ticket_platforms
+
+        # Otherwise, infer from configured PM platforms
+        platforms = []
+
+        # Check modern PM framework config
+        if self.pm:
+            if hasattr(self.pm, "jira") and self.pm.jira:
+                platforms.append("jira")
+            if hasattr(self.pm, "linear") and self.pm.linear:
+                platforms.append("linear")
+            if hasattr(self.pm, "clickup") and self.pm.clickup:
+                platforms.append("clickup")
+
+        # Check legacy JIRA config
+        if (self.jira or self.jira_integration) and "jira" not in platforms:
+            platforms.append("jira")
+
+        # Always include GitHub if we have GitHub configured (for issue tracking)
+        if self.github.token:
+            platforms.append("github")
+
+        # If nothing configured, fall back to common platforms
+        if not platforms:
+            platforms = ["jira", "github", "clickup", "linear"]
+
+        return platforms

gitflow_analytics/identity_llm/analysis_pass.py

@@ -155,8 +155,13 @@ class IdentityAnalysisPass:
             existing_emails.add(email.lower())
 
         for new_mapping in new_mappings:
-            # New mappings use primary_email
-            canonical_email = new_mapping["primary_email"].lower()
+            # New mappings use primary_email, but support canonical_email for backward compat
+            canonical_email = (
+                new_mapping.get("primary_email") or new_mapping.get("canonical_email", "")
+            ).lower()
+            if not canonical_email:
+                logger.warning(f"Skipping mapping with no email: {new_mapping}")
+                continue
             if canonical_email not in existing_emails:
                 existing_mappings.append(new_mapping)
                 logger.info(f"Added identity mapping for: {canonical_email}")

{gitflow_analytics-3.7.0.dist-info → gitflow_analytics-3.7.4.dist-info}/METADATA

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

{gitflow_analytics-3.7.0.dist-info → gitflow_analytics-3.7.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 gitflow_analytics/__init__.py,sha256=W3Jaey5wuT1nBPehVLTIRkVIyBa5jgYOlBKc_UFfh-4,773
-gitflow_analytics/_version.py,sha256=T-QbXBKclZrHBaB4-SQ98LRwBVn2vxV_-Cib1L8W30g,137
-gitflow_analytics/cli.py,sha256=11n4M0TCTM_Wsc1KaJQxizb0hlUCobCGl84kQDdlxfM,265577
+gitflow_analytics/_version.py,sha256=xZ8QK9HyXEtX-sea8S5xFccBqQR_dn4tQAInEXd1CqY,137
+gitflow_analytics/cli.py,sha256=pYW6V0b6SRa3-NyOmXGQhf5emcKHUHgOVL2PFOAS8LQ,273331
 gitflow_analytics/config.py,sha256=XRuxvzLWyn_ML7mDCcuZ9-YFNAEsnt33vIuWxQQ_jxg,1033
 gitflow_analytics/constants.py,sha256=GXEncUJS9ijOI5KWtQCTANwdqxPfXpw-4lNjhaWTKC4,2488
 gitflow_analytics/verify_activity.py,sha256=aRQnmypf5NDasXudf2iz_WdJnCWtwlbAiJ5go0DJLSU,27050
@@ -18,8 +18,8 @@ gitflow_analytics/config/aliases.py,sha256=z9F0X6qbbF544Tw7sHlOoBj5mpRSddMkCpoKL
 gitflow_analytics/config/errors.py,sha256=IBKhAIwJ4gscZFnLDyE3jEp03wn2stPR7JQJXNSIfok,10386
 gitflow_analytics/config/loader.py,sha256=EiksTB1Uqey63FxIvuud_kMdab3sNDfuICE_RwMLYFA,37290
 gitflow_analytics/config/profiles.py,sha256=yUjFAWW6uzOUdi5qlPE-QV9681HigyrLiSJFpL8X9A0,7967
-gitflow_analytics/config/repository.py,sha256=maptMAdCKDsuMAfoTAaTrMPVfVd_tKNLRenvuPe1-t4,4350
-gitflow_analytics/config/schema.py,sha256=lFN80-YcSqu33UwiJryFHn8F5_zX619AaJXSuJ3aht8,15271
+gitflow_analytics/config/repository.py,sha256=u7JHcKvqmXOl3i7EmNUfJ6wtjzElxPMyXRkATnVyQ0I,4685
+gitflow_analytics/config/schema.py,sha256=XP2VTpMzGIZ-dn0OcCNIgmTFe6_sIFyJarLcy-zGg2A,16753
 gitflow_analytics/config/validator.py,sha256=l7AHjXYJ8wEmyA1rn2WiItZXtAiRb9YBLjFCDl53qKM,5907
 gitflow_analytics/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gitflow_analytics/core/analyzer.py,sha256=59kGObzjziOb8geFyZMKCUvWmo3hcXE0eTgrjYEc1XA,58736
@@ -39,7 +39,7 @@ gitflow_analytics/extractors/ml_tickets.py,sha256=js5OFmbZt9JHy5r_crehhuB1Mxrkdf
 gitflow_analytics/extractors/story_points.py,sha256=IggP-Ei832oV9aD08a3li08kmjF3BqyU9i8EgAZcpfs,5324
 gitflow_analytics/extractors/tickets.py,sha256=2s5Iu7eZXVi8yl9Yme5HKzrJo3mDjzsSOUr_iJGUeLM,43799
 gitflow_analytics/identity_llm/__init__.py,sha256=tpWDwapm6zIyb8LxLO8A6pHlE3wNorT_fBL-Yp9-XnU,250
-gitflow_analytics/identity_llm/analysis_pass.py,sha256=lYfjM6f82agXstTrUBsS0R9-ipfRnviIqe8ExkjKnvc,9459
+gitflow_analytics/identity_llm/analysis_pass.py,sha256=FJF1BEGekHRY4i5jasgxxL_UWFGYP5kBkvn8hAtMorY,9728
 gitflow_analytics/identity_llm/analyzer.py,sha256=-a7lUJt_Dlgx9aNOH1YlFqPe7BSxtwY2RoGruIzwrzs,17932
 gitflow_analytics/identity_llm/models.py,sha256=F1RN6g8og9esj-m4TPY_928Ci9TA43G9NFNHYf4zHHQ,2677
 gitflow_analytics/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -115,16 +115,14 @@ gitflow_analytics/security/extractors/__init__.py,sha256=K64IAhS0k47J5oUFNmm1NcL
 gitflow_analytics/security/extractors/dependency_checker.py,sha256=Tb-Rb4G7jJkH_hsvH3dmEV2SyqjN8ycTHjgItObnCHg,14601
 gitflow_analytics/security/extractors/secret_detector.py,sha256=aa2YiKeR6SurWHMHU5fr71Q83stSmIRKvwWFpp0IVFs,6857
 gitflow_analytics/security/extractors/vulnerability_scanner.py,sha256=TWK1fPMN5s_EM8AwTFpkxRjXEsHIMwxYUZQqM2l5dV0,12682
-gitflow_analytics/security/reports/__init__.py,sha256=C6a4tHi-xCtTE5sSkQU7bjhRtEGE9l-ApUC13DVZqVQ,125
-gitflow_analytics/security/reports/security_report.py,sha256=W0DXpR2ddej0Di6X6YqI6U05M08oTPjW8VWWHdNrGCg,15466
 gitflow_analytics/training/__init__.py,sha256=YT5p7Wm4U8trzLnbS5FASJBWPMKhqp3rlAThjpxWnxo,143
 gitflow_analytics/training/model_loader.py,sha256=xGZLSopGxDhC--2XN6ytRgi2CyjOKY4zS4fZ-ZlO6lM,13245
 gitflow_analytics/training/pipeline.py,sha256=PQegTk_-OsPexVyRDfiy-3Df-7pcs25C4vPASr-HT9E,19951
 gitflow_analytics/ui/__init__.py,sha256=UBhYhZMvwlSrCuGWjkIdoP2zNbiQxOHOli-I8mqIZUE,441
 gitflow_analytics/ui/progress_display.py,sha256=3xJnCOSs1DRVAfS-rTu37EsLfWDFW5-mbv-bPS9NMm4,59182
-gitflow_analytics-3.7.0.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
-gitflow_analytics-3.7.0.dist-info/METADATA,sha256=lkG2AphxDMqNDGPU9jC6vDoMqlEcrCug3R8FwgFhuKY,34051
-gitflow_analytics-3.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gitflow_analytics-3.7.0.dist-info/entry_points.txt,sha256=a3y8HnfLOvK1QVOgAkDY6VQXXm3o9ZSQRZrpiaS3hEM,65
-gitflow_analytics-3.7.0.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
-gitflow_analytics-3.7.0.dist-info/RECORD,,
+gitflow_analytics-3.7.4.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
+gitflow_analytics-3.7.4.dist-info/METADATA,sha256=lfxt6pRpjIjcpNDvEpbZxur80jVaUDVoCS7taWt8BO8,34051
+gitflow_analytics-3.7.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gitflow_analytics-3.7.4.dist-info/entry_points.txt,sha256=a3y8HnfLOvK1QVOgAkDY6VQXXm3o9ZSQRZrpiaS3hEM,65
+gitflow_analytics-3.7.4.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
+gitflow_analytics-3.7.4.dist-info/RECORD,,

gitflow_analytics/security/reports/__init__.py

@@ -1,5 +0,0 @@
-"""Security reporting module."""
-
-from .security_report import SecurityReportGenerator
-
-__all__ = ["SecurityReportGenerator"]

gitflow_analytics/security/reports/security_report.py

@@ -1,358 +0,0 @@
-"""Generate security analysis reports."""
-
-import json
-import csv
-from typing import List, Dict, Any, Optional
-from pathlib import Path
-from datetime import datetime
-from ..security_analyzer import SecurityAnalysis
-
-
-class SecurityReportGenerator:
-    """Generate various format reports for security findings."""
-
-    def __init__(self, output_dir: Optional[Path] = None):
-        """Initialize report generator.
-
-        Args:
-            output_dir: Directory for report output
-        """
-        self.output_dir = output_dir or Path("reports")
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-    def generate_reports(self, analyses: List[SecurityAnalysis], summary: Dict[str, Any]) -> Dict[str, Path]:
-        """Generate all report formats.
-
-        Args:
-            analyses: List of security analyses
-            summary: Summary statistics
-
-        Returns:
-            Dictionary of report type to file path
-        """
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        reports = {}
-
-        # Generate Markdown report
-        md_path = self.output_dir / f"security_report_{timestamp}.md"
-        self._generate_markdown_report(analyses, summary, md_path)
-        reports["markdown"] = md_path
-
-        # Generate JSON report
-        json_path = self.output_dir / f"security_findings_{timestamp}.json"
-        self._generate_json_report(analyses, summary, json_path)
-        reports["json"] = json_path
-
-        # Generate CSV report
-        csv_path = self.output_dir / f"security_issues_{timestamp}.csv"
-        self._generate_csv_report(analyses, csv_path)
-        reports["csv"] = csv_path
-
-        # Generate SARIF report if requested
-        if any(a.total_findings > 0 for a in analyses):
-            sarif_path = self.output_dir / f"security_sarif_{timestamp}.json"
-            self._generate_sarif_report(analyses, sarif_path)
-            reports["sarif"] = sarif_path
-
-        return reports
-
-    def _generate_markdown_report(self, analyses: List[SecurityAnalysis], summary: Dict, path: Path) -> None:
-        """Generate comprehensive Markdown security report."""
-        with open(path, 'w') as f:
-            # Header
-            f.write("# 🔒 Security Analysis Report\n\n")
-            f.write(f"**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
-
-            # Executive Summary
-            f.write("## 📊 Executive Summary\n\n")
-            f.write(f"- **Commits Analyzed**: {summary['total_commits']}\n")
-            f.write(f"- **Commits with Issues**: {summary['commits_with_issues']}\n")
-            f.write(f"- **Total Findings**: {summary['total_findings']}\n")
-            f.write(f"- **Risk Level**: **{summary['risk_level']}** (Score: {summary['average_risk_score']})\n\n")
-
-            # Risk Assessment
-            self._write_risk_assessment(f, summary)
-
-            # Severity Distribution
-            f.write("## 🎯 Severity Distribution\n\n")
-            severity = summary['severity_distribution']
-            if severity['critical'] > 0:
-                f.write(f"- 🔴 **Critical**: {severity['critical']}\n")
-            if severity['high'] > 0:
-                f.write(f"- 🟠 **High**: {severity['high']}\n")
-            if severity['medium'] > 0:
-                f.write(f"- 🟡 **Medium**: {severity['medium']}\n")
-            if severity['low'] > 0:
-                f.write(f"- 🟢 **Low**: {severity['low']}\n")
-            f.write("\n")
-
-            # Top Issues
-            if summary['top_issues']:
-                f.write("## 🔝 Top Security Issues\n\n")
-                f.write("| Issue Type | Severity | Occurrences | Affected Files |\n")
-                f.write("|------------|----------|-------------|----------------|\n")
-                for issue in summary['top_issues']:
-                    f.write(f"| {issue['type']} | {issue['severity'].upper()} | "
-                           f"{issue['occurrences']} | {issue['affected_files']} |\n")
-                f.write("\n")
-
-            # Detailed Findings by Category
-            self._write_detailed_findings(f, analyses)
-
-            # LLM Insights
-            if 'llm_insights' in summary and summary['llm_insights']:
-                f.write("## 🤖 AI Security Insights\n\n")
-                f.write(summary['llm_insights'])
-                f.write("\n\n")
-
-            # Recommendations
-            f.write("## 💡 Recommendations\n\n")
-            for rec in summary['recommendations']:
-                f.write(f"- {rec}\n")
-            f.write("\n")
-
-            # Appendix - All Findings
-            f.write("## 📋 Detailed Findings\n\n")
-            self._write_all_findings(f, analyses)
-
-    def _write_risk_assessment(self, f, summary: Dict) -> None:
-        """Write risk assessment section."""
-        risk_level = summary['risk_level']
-        score = summary['average_risk_score']
-
-        f.write("## ⚠️ Risk Assessment\n\n")
-
-        if risk_level == "CRITICAL":
-            f.write("### 🚨 CRITICAL RISK DETECTED\n\n")
-            f.write("Immediate action required. Critical security vulnerabilities have been identified "
-                   "that could lead to severe security breaches.\n\n")
-        elif risk_level == "HIGH":
-            f.write("### 🔴 High Risk\n\n")
-            f.write("Significant security issues detected that should be addressed urgently.\n\n")
-        elif risk_level == "MEDIUM":
-            f.write("### 🟡 Medium Risk\n\n")
-            f.write("Moderate security concerns identified that should be addressed in the near term.\n\n")
-        else:
-            f.write("### 🟢 Low Risk\n\n")
-            f.write("Minor security issues detected. Continue with regular security practices.\n\n")
-
-        # Risk score visualization
-        f.write("**Risk Score Breakdown**:\n")
-        f.write("```\n")
-        bar_length = 50
-        filled = int(score / 100 * bar_length)
-        bar = "█" * filled + "░" * (bar_length - filled)
-        f.write(f"[{bar}] {score:.1f}/100\n")
-        f.write("```\n\n")
-
-    def _write_detailed_findings(self, f, analyses: List[SecurityAnalysis]) -> None:
-        """Write detailed findings by category."""
-        # Aggregate findings
-        all_secrets = []
-        all_vulnerabilities = []
-        all_dependencies = []
-        all_llm = []
-
-        for analysis in analyses:
-            all_secrets.extend(analysis.secrets)
-            all_vulnerabilities.extend(analysis.vulnerabilities)
-            all_dependencies.extend(analysis.dependency_issues)
-            all_llm.extend(analysis.llm_findings)
-
-        # Secrets Section
-        if all_secrets:
-            f.write("## 🔑 Exposed Secrets\n\n")
-            f.write(f"**Total**: {len(all_secrets)} potential secrets detected\n\n")
-
-            # Group by secret type
-            by_type = {}
-            for secret in all_secrets:
-                secret_type = secret.get('secret_type', 'unknown')
-                if secret_type not in by_type:
-                    by_type[secret_type] = []
-                by_type[secret_type].append(secret)
-
-            for secret_type, secrets in sorted(by_type.items()):
-                f.write(f"### {secret_type.replace('_', ' ').title()}\n")
-                for s in secrets[:5]:  # Show first 5 of each type
-                    f.write(f"- **File**: `{s.get('file', 'unknown')}`\n")
-                    f.write(f"  - Line: {s.get('line', 'N/A')}\n")
-                    f.write(f"  - Pattern: `{s.get('match', 'N/A')}`\n")
-                if len(secrets) > 5:
-                    f.write(f"  - *... and {len(secrets) - 5} more*\n")
-                f.write("\n")
-
-        # Vulnerabilities Section
-        if all_vulnerabilities:
-            f.write("## 🛡️ Code Vulnerabilities\n\n")
-            f.write(f"**Total**: {len(all_vulnerabilities)} vulnerabilities detected\n\n")
-
-            # Group by vulnerability type
-            by_type = {}
-            for vuln in all_vulnerabilities:
-                vuln_type = vuln.get('vulnerability_type', 'unknown')
-                if vuln_type not in by_type:
-                    by_type[vuln_type] = []
-                by_type[vuln_type].append(vuln)
-
-            for vuln_type, vulns in sorted(by_type.items()):
-                f.write(f"### {vuln_type.replace('_', ' ').title()}\n")
-                for v in vulns[:5]:
-                    f.write(f"- **File**: `{v.get('file', 'unknown')}:{v.get('line', 'N/A')}`\n")
-                    f.write(f"  - Tool: {v.get('tool', 'N/A')}\n")
-                    f.write(f"  - Message: {v.get('message', 'N/A')}\n")
-                if len(vulns) > 5:
-                    f.write(f"  - *... and {len(vulns) - 5} more*\n")
-                f.write("\n")
-
-        # Dependencies Section
-        if all_dependencies:
-            f.write("## 📦 Vulnerable Dependencies\n\n")
-            f.write(f"**Total**: {len(all_dependencies)} vulnerable dependencies\n\n")
-
-            for dep in all_dependencies[:10]:
-                f.write(f"- **{dep.get('package', 'unknown')}** @ {dep.get('version', 'unknown')}\n")
-                f.write(f"  - File: `{dep.get('file', 'unknown')}`\n")
-                if dep.get('cve'):
-                    f.write(f"  - CVE: {dep['cve']}\n")
-                f.write(f"  - Message: {dep.get('message', 'N/A')}\n")
-            if len(all_dependencies) > 10:
-                f.write(f"\n*... and {len(all_dependencies) - 10} more vulnerable dependencies*\n")
-            f.write("\n")
-
-    def _write_all_findings(self, f, analyses: List[SecurityAnalysis]) -> None:
-        """Write all findings in detail."""
-        for analysis in analyses:
-            if analysis.total_findings == 0:
-                continue
-
-            f.write(f"### Commit: `{analysis.commit_hash[:8]}`\n")
-            f.write(f"**Time**: {analysis.timestamp.strftime('%Y-%m-%d %H:%M:%S')}\n")
-            f.write(f"**Files Changed**: {len(analysis.files_changed)}\n")
-            f.write(f"**Risk Score**: {analysis.risk_score:.1f}\n\n")
-
-            if analysis.secrets:
-                f.write("**Secrets**:\n")
-                for s in analysis.secrets:
-                    f.write(f"- {s.get('secret_type', 'unknown')}: {s.get('file', 'N/A')}\n")
-
-            if analysis.vulnerabilities:
-                f.write("**Vulnerabilities**:\n")
-                for v in analysis.vulnerabilities:
-                    f.write(f"- {v.get('vulnerability_type', 'unknown')}: {v.get('file', 'N/A')}\n")
-
-            f.write("\n---\n\n")
-
-    def _generate_json_report(self, analyses: List[SecurityAnalysis], summary: Dict, path: Path) -> None:
-        """Generate JSON report with all findings."""
-        report = {
-            "metadata": {
-                "generated": datetime.now().isoformat(),
-                "version": "1.0.0"
-            },
-            "summary": summary,
-            "analyses": []
-        }
-
-        for analysis in analyses:
-            report["analyses"].append({
-                "commit_hash": analysis.commit_hash,
-                "timestamp": analysis.timestamp.isoformat(),
-                "files_changed": analysis.files_changed,
-                "risk_score": analysis.risk_score,
-                "findings": {
-                    "secrets": analysis.secrets,
-                    "vulnerabilities": analysis.vulnerabilities,
-                    "dependency_issues": analysis.dependency_issues,
-                    "llm_findings": analysis.llm_findings
-                },
-                "metrics": {
-                    "total": analysis.total_findings,
-                    "critical": analysis.critical_count,
-                    "high": analysis.high_count,
-                    "medium": analysis.medium_count,
-                    "low": analysis.low_count
-                }
-            })
-
-        with open(path, 'w') as f:
-            json.dump(report, f, indent=2)
-
-    def _generate_csv_report(self, analyses: List[SecurityAnalysis], path: Path) -> None:
-        """Generate CSV report of all findings."""
-        with open(path, 'w', newline='') as f:
-            writer = csv.DictWriter(f, fieldnames=[
-                'commit_hash', 'timestamp', 'type', 'severity',
-                'category', 'file', 'line', 'message', 'tool', 'confidence'
-            ])
-            writer.writeheader()
-
-            for analysis in analyses:
-                # Write all findings
-                for finding in (analysis.secrets + analysis.vulnerabilities +
-                              analysis.dependency_issues + analysis.llm_findings):
-                    writer.writerow({
-                        'commit_hash': analysis.commit_hash[:8],
-                        'timestamp': analysis.timestamp.isoformat(),
-                        'type': finding.get('type', 'unknown'),
-                        'severity': finding.get('severity', 'medium'),
-                        'category': finding.get('vulnerability_type',
-                                              finding.get('secret_type', 'unknown')),
-                        'file': finding.get('file', ''),
-                        'line': finding.get('line', ''),
-                        'message': finding.get('message', ''),
-                        'tool': finding.get('tool', finding.get('source', '')),
-                        'confidence': finding.get('confidence', '')
-                    })
-
-    def _generate_sarif_report(self, analyses: List[SecurityAnalysis], path: Path) -> None:
-        """Generate SARIF format report for GitHub Security tab integration."""
-        sarif = {
-            "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
-            "version": "2.1.0",
-            "runs": [{
-                "tool": {
-                    "driver": {
-                        "name": "GitFlow Analytics Security",
-                        "version": "1.0.0",
-                        "informationUri": "https://github.com/yourusername/gitflow-analytics"
-                    }
-                },
-                "results": []
-            }]
-        }
-
-        for analysis in analyses:
-            for finding in (analysis.secrets + analysis.vulnerabilities):
-                result = {
-                    "ruleId": finding.get('vulnerability_type',
-                                        finding.get('secret_type', 'unknown')),
-                    "level": self._severity_to_sarif_level(finding.get('severity', 'medium')),
-                    "message": {
-                        "text": finding.get('message', 'Security issue detected')
-                    },
-                    "locations": [{
-                        "physicalLocation": {
-                            "artifactLocation": {
-                                "uri": finding.get('file', 'unknown')
-                            },
-                            "region": {
-                                "startLine": finding.get('line', 1)
-                            }
-                        }
-                    }]
-                }
-                sarif["runs"][0]["results"].append(result)
-
-        with open(path, 'w') as f:
-            json.dump(sarif, f, indent=2)
-
-    def _severity_to_sarif_level(self, severity: str) -> str:
-        """Convert severity to SARIF level."""
-        mapping = {
-            "critical": "error",
-            "high": "error",
-            "medium": "warning",
-            "low": "note"
-        }
-        return mapping.get(severity.lower(), "warning")