gitflow-analytics 1.3.6__py3-none-any.whl → 1.3.11__py3-none-any.whl

gitflow_analytics/_version.py

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

gitflow_analytics/cli.py

@@ -1069,6 +1069,7 @@ def analyze(
 
                 # Perform data fetch for repositories that need analysis
                 from .core.data_fetcher import GitDataFetcher
+                from .core.progress import get_progress_service
 
                 data_fetcher = GitDataFetcher(
                     cache=cache,
@@ -1083,74 +1084,105 @@ def analyze(
                 orchestrator = IntegrationOrchestrator(cfg, cache)
                 jira_integration = orchestrator.integrations.get("jira")
 
+                # Get progress service for overall repository progress
+                progress = get_progress_service()
+
                 # Fetch data for repositories that need analysis
                 total_commits = 0
                 total_tickets = 0
 
-                for repo_config in repos_needing_analysis:
-                    try:
-                        repo_path = Path(repo_config.path)
-                        project_key = repo_config.project_key or repo_path.name
-
-                        # Progress callback for fetch
-                        def progress_callback(message: str):
-                            if display:
-                                display.print_status(f"   {message}", "info")
-
-                        # Fetch repository data
-                        result = data_fetcher.fetch_repository_data(
-                            repo_path=repo_path,
-                            project_key=project_key,
-                            weeks_back=weeks,
-                            branch_patterns=getattr(repo_config, "branch_patterns", None),
-                            jira_integration=jira_integration,
-                            progress_callback=progress_callback,
-                            start_date=start_date,
-                            end_date=end_date,
-                        )
+                # Create top-level progress for all repositories
+                with progress.progress(
+                    total=len(repos_needing_analysis),
+                    description="Processing repositories",
+                    unit="repos",
+                ) as repos_progress_ctx:
 
-                        total_commits += result["stats"]["total_commits"]
-                        total_tickets += result["stats"]["unique_tickets"]
+                    for idx, repo_config in enumerate(repos_needing_analysis, 1):
+                        try:
+                            repo_path = Path(repo_config.path)
+                            project_key = repo_config.project_key or repo_path.name
 
-                        if display:
-                            display.print_status(
-                                f"   ✅ {project_key}: {result['stats']['total_commits']} commits, "
-                                f"{result['stats']['unique_tickets']} tickets",
-                                "success",
+                            # Update overall progress description
+                            progress.set_description(
+                                repos_progress_ctx,
+                                f"Repository {idx}/{len(repos_needing_analysis)}: {project_key}",
                             )
 
-                        # Mark repository analysis as complete
-                        cache.mark_repository_analysis_complete(
-                            repo_path=str(repo_path),
-                            repo_name=repo_config.name,
-                            project_key=project_key,
-                            analysis_start=start_date,
-                            analysis_end=end_date,
-                            weeks_analyzed=weeks,
-                            commit_count=result["stats"]["total_commits"],
-                            ticket_count=result["stats"]["unique_tickets"],
-                            config_hash=config_hash,
-                        )
+                            # Progress callback for fetch
+                            def progress_callback(message: str):
+                                if display:
+                                    display.print_status(f"   {message}", "info")
 
-                    except Exception as e:
-                        if display:
-                            display.print_status(
-                                f"   ❌ Error fetching {project_key}: {e}", "error"
+                            # Fetch repository data
+                            # For organization discovery, use branch patterns from analysis config
+                            # Default to ["*"] to analyze all branches when not specified
+                            branch_patterns = None
+                            if hasattr(cfg.analysis, "branch_patterns"):
+                                branch_patterns = cfg.analysis.branch_patterns
+                            elif cfg.github.organization:
+                                # For organization discovery, default to analyzing all branches
+                                branch_patterns = ["*"]
+
+                            result = data_fetcher.fetch_repository_data(
+                                repo_path=repo_path,
+                                project_key=project_key,
+                                weeks_back=weeks,
+                                branch_patterns=branch_patterns,
+                                jira_integration=jira_integration,
+                                progress_callback=progress_callback,
+                                start_date=start_date,
+                                end_date=end_date,
                             )
-                        else:
-                            click.echo(f"   ❌ Error fetching {project_key}: {e}")
 
-                        # Mark repository analysis as failed
-                        with contextlib.suppress(Exception):
-                            cache.mark_repository_analysis_failed(
+                            total_commits += result["stats"]["total_commits"]
+                            total_tickets += result["stats"]["unique_tickets"]
+
+                            if display:
+                                display.print_status(
+                                    f"   ✅ {project_key}: {result['stats']['total_commits']} commits, "
+                                    f"{result['stats']['unique_tickets']} tickets",
+                                    "success",
+                                )
+
+                            # Mark repository analysis as complete
+                            cache.mark_repository_analysis_complete(
                                 repo_path=str(repo_path),
                                 repo_name=repo_config.name,
+                                project_key=project_key,
                                 analysis_start=start_date,
                                 analysis_end=end_date,
-                                error_message=str(e),
+                                weeks_analyzed=weeks,
+                                commit_count=result["stats"]["total_commits"],
+                                ticket_count=result["stats"]["unique_tickets"],
                                 config_hash=config_hash,
                             )
-                        continue
+
+                            # Update overall repository progress
+                            progress.update(repos_progress_ctx)
+
+                        except Exception as e:
+                            if display:
+                                display.print_status(
+                                    f"   ❌ Error fetching {project_key}: {e}", "error"
+                                )
+                            else:
+                                click.echo(f"   ❌ Error fetching {project_key}: {e}")
+
+                            # Mark repository analysis as failed
+                            with contextlib.suppress(Exception):
+                                cache.mark_repository_analysis_failed(
+                                    repo_path=str(repo_path),
+                                    repo_name=repo_config.name,
+                                    analysis_start=start_date,
+                                    analysis_end=end_date,
+                                    error_message=str(e),
+                                    config_hash=config_hash,
+                                )
+
+                            # Update progress even on failure
+                            progress.update(repos_progress_ctx)
+                            continue
 
                 if display:
                     display.print_status(
@@ -1322,11 +1354,20 @@ def analyze(
                                     display.print_status(f"   {message}", "info")
 
                             # Fetch repository data
+                            # For organization discovery, use branch patterns from analysis config
+                            # Default to ["*"] to analyze all branches when not specified
+                            branch_patterns = None
+                            if hasattr(cfg.analysis, "branch_patterns"):
+                                branch_patterns = cfg.analysis.branch_patterns
+                            elif cfg.github.organization:
+                                # For organization discovery, default to analyzing all branches
+                                branch_patterns = ["*"]
+
                             result = data_fetcher.fetch_repository_data(
                                 repo_path=repo_path,
                                 project_key=project_key,
                                 weeks_back=weeks,
-                                branch_patterns=getattr(repo_config, "branch_patterns", None),
+                                branch_patterns=branch_patterns,
                                 jira_integration=jira_integration,
                                 progress_callback=progress_callback,
                                 start_date=start_date,
@@ -3649,11 +3690,20 @@ def fetch(
                         click.echo(f"   {message}")
 
                 # Fetch repository data
+                # For organization discovery, use branch patterns from analysis config
+                # Default to ["*"] to analyze all branches when not specified
+                branch_patterns = None
+                if hasattr(cfg.analysis, "branch_patterns"):
+                    branch_patterns = cfg.analysis.branch_patterns
+                elif cfg.github.organization:
+                    # For organization discovery, default to analyzing all branches
+                    branch_patterns = ["*"]
+
                 result = data_fetcher.fetch_repository_data(
                     repo_path=repo_path,
                     project_key=project_key,
                     weeks_back=weeks,
-                    branch_patterns=getattr(repo_config, "branch_patterns", None),
+                    branch_patterns=branch_patterns,
                     jira_integration=jira_integration,
                     progress_callback=progress_callback,
                     start_date=start_date,

gitflow_analytics/config/loader.py

@@ -555,6 +555,7 @@ class ConfigLoader:
             branch_mapping_rules=analysis_data.get("branch_mapping_rules", {}),
             ticket_platforms=analysis_data.get("ticket_platforms"),
             auto_identity_analysis=analysis_data.get("identity", {}).get("auto_analysis", True),
+            branch_patterns=analysis_data.get("branch_patterns"),
             branch_analysis=branch_analysis_config,
             ml_categorization=ml_categorization_config,
             commit_classification=commit_classification_config,

gitflow_analytics/config/schema.py

@@ -305,6 +305,9 @@ class AnalysisConfig:
     branch_mapping_rules: dict[str, list[str]] = field(default_factory=dict)
     ticket_platforms: Optional[list[str]] = None
     auto_identity_analysis: bool = True  # Enable automatic identity analysis by default
+    branch_patterns: Optional[list[str]] = (
+        None  # Branch patterns to analyze (e.g., ["*"] for all branches)
+    )
     branch_analysis: BranchAnalysisConfig = field(default_factory=BranchAnalysisConfig)
     ml_categorization: MLCategorization = field(default_factory=MLCategorization)
     commit_classification: CommitClassificationConfig = field(

gitflow_analytics/core/data_fetcher.py

@@ -5,11 +5,9 @@ focusing purely on data collection from Git repositories and ticket systems
 without performing any LLM-based classification.
 """
 
-import contextlib
 import logging
 import os
 import subprocess
-from collections import defaultdict
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Optional
@@ -117,37 +115,55 @@ class GitDataFetcher:
                 f"🔍 DEBUG: Calculated date range from weeks_back: {start_date} to {end_date}"
             )
 
-        # Step 1: Collect all commits organized by day
+        # Get progress service for top-level progress tracking
+        progress = get_progress_service()
+
+        # Step 1: Collect all commits organized by day with enhanced progress tracking
         logger.info("🔍 DEBUG: About to fetch commits by day")
         logger.info("Fetching commits organized by day...")
-        daily_commits = self._fetch_commits_by_day(
-            repo_path, project_key, start_date, end_date, branch_patterns, progress_callback
-        )
-        logger.info(f"🔍 DEBUG: Fetched {len(daily_commits)} days of commits")
-
-        # Step 2: Extract and fetch all referenced tickets
-        logger.info("🔍 DEBUG: About to extract ticket references")
-        logger.info("Extracting ticket references...")
-        ticket_ids = self._extract_all_ticket_references(daily_commits)
-        logger.info(f"🔍 DEBUG: Extracted {len(ticket_ids)} ticket IDs")
-
-        if jira_integration and ticket_ids:
-            logger.info(f"Fetching {len(ticket_ids)} unique tickets from JIRA...")
-            self._fetch_detailed_tickets(
-                ticket_ids, jira_integration, project_key, progress_callback
+
+        # Create top-level progress for this repository
+        with progress.progress(
+            total=3,  # Three main steps: fetch commits, extract tickets, store data
+            description=f"Processing {project_key}",
+            unit="steps",
+        ) as repo_progress_ctx:
+
+            # Step 1: Fetch commits
+            progress.set_description(repo_progress_ctx, f"{project_key}: Fetching commits")
+            daily_commits = self._fetch_commits_by_day(
+                repo_path, project_key, start_date, end_date, branch_patterns, progress_callback
             )
+            logger.info(f"🔍 DEBUG: Fetched {len(daily_commits)} days of commits")
+            progress.update(repo_progress_ctx)
+
+            # Step 2: Extract and fetch all referenced tickets
+            progress.set_description(repo_progress_ctx, f"{project_key}: Processing tickets")
+            logger.info("🔍 DEBUG: About to extract ticket references")
+            logger.info("Extracting ticket references...")
+            ticket_ids = self._extract_all_ticket_references(daily_commits)
+            logger.info(f"🔍 DEBUG: Extracted {len(ticket_ids)} ticket IDs")
+
+            if jira_integration and ticket_ids:
+                logger.info(f"Fetching {len(ticket_ids)} unique tickets from JIRA...")
+                self._fetch_detailed_tickets(
+                    ticket_ids, jira_integration, project_key, progress_callback
+                )
 
-        # Step 3: Store commit-ticket correlations
-        logger.info("Building commit-ticket correlations...")
-        correlations_created = self._build_commit_ticket_correlations(daily_commits, repo_path)
+            # Build commit-ticket correlations
+            logger.info("Building commit-ticket correlations...")
+            correlations_created = self._build_commit_ticket_correlations(daily_commits, repo_path)
+            progress.update(repo_progress_ctx)
 
-        # Step 4: Store daily commit batches
-        logger.info(
-            f"🔍 DEBUG: About to store daily batches. Daily commits has {len(daily_commits)} days"
-        )
-        logger.info("Storing daily commit batches...")
-        batches_created = self._store_daily_batches(daily_commits, repo_path, project_key)
-        logger.info(f"🔍 DEBUG: Storage complete. Batches created: {batches_created}")
+            # Step 3: Store daily commit batches
+            progress.set_description(repo_progress_ctx, f"{project_key}: Storing data")
+            logger.info(
+                f"🔍 DEBUG: About to store daily batches. Daily commits has {len(daily_commits)} days"
+            )
+            logger.info("Storing daily commit batches...")
+            batches_created = self._store_daily_batches(daily_commits, repo_path, project_key)
+            logger.info(f"🔍 DEBUG: Storage complete. Batches created: {batches_created}")
+            progress.update(repo_progress_ctx)
 
         # CRITICAL FIX: Verify actual storage before reporting success
         session = self.database.get_session()
@@ -219,8 +235,7 @@ class GitDataFetcher:
             logger.error(f"Failed to open repository at {repo_path}: {e}")
             return {}
 
-        # Collect commits from all relevant branches
-        all_commits = []
+        # Get branches to analyze
         branches_to_analyze = self._get_branches_to_analyze(repo, branch_patterns)
 
         if not branches_to_analyze:
@@ -229,54 +244,98 @@ class GitDataFetcher:
 
         logger.info(f"Analyzing branches: {branches_to_analyze}")
 
-        for branch_name in branches_to_analyze:
-            try:
-                branch_commits = list(
-                    repo.iter_commits(branch_name, since=start_date, until=end_date, reverse=False)
-                )
+        # Calculate days to process
+        current_date = start_date.date()
+        end_date_only = end_date.date()
+        days_to_process = []
+        while current_date <= end_date_only:
+            days_to_process.append(current_date)
+            current_date += timedelta(days=1)
 
-                logger.debug(
-                    f"Found {len(branch_commits)} commits in branch {branch_name} for date range"
-                )
+        logger.info(
+            f"Processing {len(days_to_process)} days from {start_date.date()} to {end_date.date()}"
+        )
+
+        # Get progress service for nested progress tracking
+        progress = get_progress_service()
+
+        # Dictionary to store commits by day
+        daily_commits = {}
+        all_commit_hashes = set()  # Track all hashes for deduplication
+
+        # Create nested progress for day-by-day processing
+        with progress.progress(
+            total=len(days_to_process),
+            description=f"Fetching commits for {project_key}",
+            unit="days",
+            nested=True,
+        ) as day_progress_ctx:
+
+            for day_date in days_to_process:
+                # Update description to show current day
+                day_str = day_date.strftime("%Y-%m-%d")
+                progress.set_description(day_progress_ctx, f"{project_key}: Processing {day_str}")
+
+                # Calculate day boundaries
+                day_start = datetime.combine(day_date, datetime.min.time(), tzinfo=timezone.utc)
+                day_end = datetime.combine(day_date, datetime.max.time(), tzinfo=timezone.utc)
 
-                for commit in branch_commits:
-                    # Include merge commits like the original analyzer
-                    # The original analyzer marks merge commits with is_merge=True but doesn't skip them
+                day_commits = []
+                commits_found_today = 0
 
-                    # Extract commit data with full metadata
-                    commit_data = self._extract_commit_data(
-                        commit, branch_name, project_key, repo_path
+                # Process each branch for this specific day
+                for branch_name in branches_to_analyze:
+                    try:
+                        # Fetch commits for this specific day and branch
+                        branch_commits = list(
+                            repo.iter_commits(
+                                branch_name, since=day_start, until=day_end, reverse=False
+                            )
+                        )
+
+                        for commit in branch_commits:
+                            # Skip if we've already processed this commit
+                            if commit.hexsha in all_commit_hashes:
+                                continue
+
+                            # Extract commit data with full metadata
+                            commit_data = self._extract_commit_data(
+                                commit, branch_name, project_key, repo_path
+                            )
+                            if commit_data:
+                                day_commits.append(commit_data)
+                                all_commit_hashes.add(commit.hexsha)
+                                commits_found_today += 1
+
+                    except Exception as e:
+                        logger.warning(
+                            f"Error processing branch {branch_name} for day {day_str}: {e}"
+                        )
+                        continue
+
+                # Store commits for this day if any were found
+                if day_commits:
+                    # Sort commits by timestamp
+                    day_commits.sort(key=lambda c: c["timestamp"])
+                    daily_commits[day_str] = day_commits
+
+                    # Incremental caching - store commits for this day immediately
+                    self._store_day_commits_incremental(
+                        repo_path, day_str, day_commits, project_key
                     )
-                    if commit_data:
-                        all_commits.append(commit_data)
 
-            except Exception as e:
-                logger.warning(f"Error processing branch {branch_name}: {e}")
-                continue
-
-        # Deduplicate commits (same commit may appear in multiple branches)
-        seen_hashes = set()
-        unique_commits = []
-        for commit_data in all_commits:
-            commit_hash = commit_data["commit_hash"]
-            if commit_hash not in seen_hashes:
-                seen_hashes.add(commit_hash)
-                unique_commits.append(commit_data)
-
-        # Organize commits by day
-        daily_commits = defaultdict(list)
-        for commit_data in unique_commits:
-            # Convert timestamp to date key
-            commit_date = commit_data["timestamp"].date()
-            date_key = commit_date.strftime("%Y-%m-%d")
-            daily_commits[date_key].append(commit_data)
-
-        # Sort commits within each day by timestamp
-        for date_key in daily_commits:
-            daily_commits[date_key].sort(key=lambda c: c["timestamp"])
-
-        logger.info(f"Collected {len(unique_commits)} commits across {len(daily_commits)} days")
-        return dict(daily_commits)
+                    logger.debug(f"Found {commits_found_today} commits on {day_str}")
+
+                # Update progress callback if provided
+                if progress_callback:
+                    progress_callback(f"Processed {day_str}: {commits_found_today} commits")
+
+                # Update progress bar
+                progress.update(day_progress_ctx)
+
+        total_commits = sum(len(commits) for commits in daily_commits.values())
+        logger.info(f"Collected {total_commits} unique commits across {len(daily_commits)} days")
+        return daily_commits
 
     def _extract_commit_data(
         self, commit: Any, branch_name: str, project_key: str, repo_path: Path
@@ -373,114 +432,102 @@ class GitDataFetcher:
         """Get list of branches to analyze based on patterns.
 
         WHY: Robust branch detection that handles missing remotes, missing default branches,
-        and provides good fallback behavior. Based on the approach used in the existing analyzer.
+        and provides good fallback behavior. When no patterns specified, analyzes ALL branches
+        to capture the complete development picture.
 
         DESIGN DECISION:
-        - Try default branches first, fall back to all available branches
+        - When no patterns: analyze ALL accessible branches (not just main)
+        - When patterns specified: match against those patterns only
         - Handle missing remotes gracefully
         - Skip remote tracking branches to avoid duplicates
         - Use actual branch existence checking rather than assuming branches exist
         """
-        if not branch_patterns:
-            # Get all available branches (local branches preferred)
-            available_branches = []
+        # Collect all available branches (local branches preferred)
+        available_branches = []
 
-            # First, try local branches
-            try:
-                local_branches = [branch.name for branch in repo.branches]
-                available_branches.extend(local_branches)
-                logger.debug(f"Found local branches: {local_branches}")
-            except Exception as e:
-                logger.debug(f"Error getting local branches: {e}")
+        # First, try local branches
+        try:
+            local_branches = [branch.name for branch in repo.branches]
+            available_branches.extend(local_branches)
+            logger.debug(f"Found local branches: {local_branches}")
+        except Exception as e:
+            logger.debug(f"Error getting local branches: {e}")
 
-            # If we have remotes, also consider remote branches (but clean the names)
+        # If we have remotes, also consider remote branches (but clean the names)
+        try:
+            if repo.remotes and hasattr(repo.remotes, "origin"):
+                remote_branches = [
+                    ref.name.replace("origin/", "")
+                    for ref in repo.remotes.origin.refs
+                    if not ref.name.endswith("HEAD")  # Skip HEAD ref
+                ]
+                # Only add remote branches that aren't already in local branches
+                for branch in remote_branches:
+                    if branch not in available_branches:
+                        available_branches.append(branch)
+                logger.debug(f"Found remote branches: {remote_branches}")
+        except Exception as e:
+            logger.debug(f"Error getting remote branches: {e}")
+
+        # If no branches found, fallback to trying common names directly
+        if not available_branches:
+            logger.warning("No branches found via normal detection, falling back to common names")
+            available_branches = ["main", "master", "develop", "dev"]
+
+        # Filter branches based on patterns if provided
+        if branch_patterns:
+            import fnmatch
+
+            matching_branches = []
+            for pattern in branch_patterns:
+                matching = [
+                    branch for branch in available_branches if fnmatch.fnmatch(branch, pattern)
+                ]
+                matching_branches.extend(matching)
+            # Remove duplicates while preserving order
+            branches_to_test = list(dict.fromkeys(matching_branches))
+        else:
+            # No patterns specified - analyze ALL branches for complete coverage
+            branches_to_test = available_branches
+            logger.info(
+                f"No branch patterns specified - will analyze all {len(branches_to_test)} branches"
+            )
+
+        # Test that branches are actually accessible
+        accessible_branches = []
+        for branch in branches_to_test:
             try:
-                if repo.remotes and hasattr(repo.remotes, "origin"):
-                    remote_branches = [
-                        ref.name.replace("origin/", "")
-                        for ref in repo.remotes.origin.refs
-                        if not ref.name.endswith("HEAD")  # Skip HEAD ref
-                    ]
-                    # Only add remote branches that aren't already in local branches
-                    for branch in remote_branches:
-                        if branch not in available_branches:
-                            available_branches.append(branch)
-                    logger.debug(f"Found remote branches: {remote_branches}")
+                next(iter(repo.iter_commits(branch, max_count=1)), None)
+                accessible_branches.append(branch)
             except Exception as e:
-                logger.debug(f"Error getting remote branches: {e}")
+                logger.debug(f"Branch {branch} not accessible: {e}")
 
-            # If no branches found, fallback to trying common names directly
-            if not available_branches:
-                logger.warning(
-                    "No branches found via normal detection, falling back to common names"
-                )
-                available_branches = ["main", "master", "develop", "dev"]
-
-            # Try default main branches first, in order of preference
+        if not accessible_branches:
+            # Last resort: try to find ANY working branch
+            logger.warning("No accessible branches found from patterns/default, trying fallback")
             main_branches = ["main", "master", "develop", "dev"]
             for branch in main_branches:
                 if branch in available_branches:
-                    # Test that we can actually access this branch
                     try:
-                        # Just try to get the commit object to verify branch exists and is accessible
                         next(iter(repo.iter_commits(branch, max_count=1)), None)
-                        logger.info(f"Using main branch: {branch}")
+                        logger.info(f"Using fallback main branch: {branch}")
                         return [branch]
-                    except Exception as e:
-                        logger.debug(f"Branch {branch} exists but not accessible: {e}")
+                    except Exception:
                         continue
 
-            # If no main branches work, try the first available branch that actually works
+            # Try any available branch
             for branch in available_branches:
                 try:
                     next(iter(repo.iter_commits(branch, max_count=1)), None)
                     logger.info(f"Using fallback branch: {branch}")
                     return [branch]
-                except Exception as e:
-                    logger.debug(f"Branch {branch} not accessible: {e}")
+                except Exception:
                     continue
 
-            # Last resort: return empty list (will be handled gracefully by caller)
             logger.warning("No accessible branches found")
             return []
 
-        # Use specified patterns - match against all available branches
-        import fnmatch
-
-        available_branches = []
-
-        # Collect all branches (local and remote)
-        with contextlib.suppress(Exception):
-            available_branches.extend([branch.name for branch in repo.branches])
-
-        try:
-            if repo.remotes and hasattr(repo.remotes, "origin"):
-                remote_branches = [
-                    ref.name.replace("origin/", "")
-                    for ref in repo.remotes.origin.refs
-                    if not ref.name.endswith("HEAD")
-                ]
-                for branch in remote_branches:
-                    if branch not in available_branches:
-                        available_branches.append(branch)
-        except Exception:
-            pass
-
-        # Match patterns against available branches
-        matching_branches = []
-        for pattern in branch_patterns:
-            matching = [branch for branch in available_branches if fnmatch.fnmatch(branch, pattern)]
-            matching_branches.extend(matching)
-
-        # Test that matched branches are actually accessible
-        accessible_branches = []
-        for branch in list(set(matching_branches)):  # Remove duplicates
-            try:
-                next(iter(repo.iter_commits(branch, max_count=1)), None)
-                accessible_branches.append(branch)
-            except Exception as e:
-                logger.debug(f"Matched branch {branch} not accessible: {e}")
-
+        logger.info(f"Will analyze {len(accessible_branches)} branches: {accessible_branches}")
         return accessible_branches
 
     def _update_repository(self, repo) -> bool:
@@ -516,7 +563,7 @@ class GitDataFetcher:
                 # Run git fetch with timeout
                 try:
                     result = subprocess.run(
-                        ["git", "fetch", "--all", "--config", "credential.helper="],
+                        ["git", "fetch", "--all"],
                         cwd=repo.working_dir,
                         env=env,
                         capture_output=True,
@@ -553,7 +600,7 @@ class GitDataFetcher:
                         # Pull latest changes using subprocess
                         try:
                             result = subprocess.run(
-                                ["git", "pull", "--config", "credential.helper="],
+                                ["git", "pull"],
                                 cwd=repo.working_dir,
                                 env=env,
                                 capture_output=True,
@@ -1191,3 +1238,48 @@ class GitDataFetcher:
             logger.warning(f"Error calculating commit stats for {commit.hexsha[:8]}: {e}")
 
         return stats
+
+    def _store_day_commits_incremental(
+        self, repo_path: Path, date_str: str, commits: list[dict[str, Any]], project_key: str
+    ) -> None:
+        """Store commits for a single day incrementally to enable progress tracking.
+
+        This method stores commits immediately after fetching them for a day,
+        allowing for better progress tracking and recovery from interruptions.
+
+        Args:
+            repo_path: Path to the repository
+            date_str: Date string in YYYY-MM-DD format
+            commits: List of commit data for the day
+            project_key: Project identifier
+        """
+        try:
+            # Transform commits to cache format
+            cache_format_commits = []
+            for commit in commits:
+                cache_format_commit = {
+                    "hash": commit["commit_hash"],
+                    "author_name": commit.get("author_name", ""),
+                    "author_email": commit.get("author_email", ""),
+                    "message": commit.get("message", ""),
+                    "timestamp": commit["timestamp"],
+                    "branch": commit.get("branch", "main"),
+                    "is_merge": commit.get("is_merge", False),
+                    "files_changed_count": commit.get("files_changed_count", 0),
+                    "insertions": commit.get("lines_added", 0),
+                    "deletions": commit.get("lines_deleted", 0),
+                    "story_points": commit.get("story_points"),
+                    "ticket_references": commit.get("ticket_references", []),
+                }
+                cache_format_commits.append(cache_format_commit)
+
+            # Use bulk store for efficiency
+            if cache_format_commits:
+                bulk_stats = self.cache.bulk_store_commits(str(repo_path), cache_format_commits)
+                logger.debug(
+                    f"Incrementally stored {bulk_stats['inserted']} commits for {date_str} "
+                    f"({bulk_stats['skipped']} already cached)"
+                )
+        except Exception as e:
+            # Log error but don't fail - commits will be stored again in batch at the end
+            logger.warning(f"Failed to incrementally store commits for {date_str}: {e}")

{gitflow_analytics-1.3.6.dist-info → gitflow_analytics-1.3.11.dist-info}/METADATA

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

{gitflow_analytics-1.3.6.dist-info → gitflow_analytics-1.3.11.dist-info}/RECORD

@@ -1,6 +1,6 @@
 gitflow_analytics/__init__.py,sha256=yN1dyAUu4l9qX-YNAGRItEf4RFFe-5GQiOntXPIfdxo,683
-gitflow_analytics/_version.py,sha256=9PnCSmhRIvnAdYvd_L43lJY5JxZ9voHOQOlNDFzIYB8,137
-gitflow_analytics/cli.py,sha256=RtXDOZlE3fq-xV0sWIvU_F1Slwr9Ma23CJNIdSrO8s0,207102
+gitflow_analytics/_version.py,sha256=bXQpvOWe_1iZd8zp8muFij7XZbsWHLHtQWQK6axVbUc,138
+gitflow_analytics/cli.py,sha256=TI1v_IqiR_DpMp6N7IGH9aZDNkk7qwzgEc4kLtWTM8k,210011
 gitflow_analytics/cli_rich.py,sha256=1Heeyadbqpn5d13jtI7jtcrpmbA0BmPY9lnMXrgSncI,19326
 gitflow_analytics/config.py,sha256=XRuxvzLWyn_ML7mDCcuZ9-YFNAEsnt33vIuWxQQ_jxg,1033
 gitflow_analytics/classification/__init__.py,sha256=p8shPUZpGaw7-ivhfAVrPDbSP2LrpvWC1WEsBJIg-PI,969
@@ -11,16 +11,16 @@ gitflow_analytics/classification/linguist_analyzer.py,sha256=HjLx9mM7hGXtrvMba6o
 gitflow_analytics/classification/model.py,sha256=2KbmFh9MpyvHMcNHbqwUTAAVLHHu3MiTfFIPyZSGa-8,16356
 gitflow_analytics/config/__init__.py,sha256=lzFOHsJGoeDHuu_NEgcSeUFwU0bgV3lnL9w0Pyc4FI0,1037
 gitflow_analytics/config/errors.py,sha256=IBKhAIwJ4gscZFnLDyE3jEp03wn2stPR7JQJXNSIfok,10386
-gitflow_analytics/config/loader.py,sha256=afdr_uQN5BDhK0iEIbUL4O3XbDVtCSEWZ-by_zp8E58,34172
+gitflow_analytics/config/loader.py,sha256=oG6D6jEoVuK69a0060Oo2I9BEsZPs0jiE9YY7tzOv3Q,34238
 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=NQO2KmaVDaCiPH6kwmMvAOw7cwufSjp3-Gpwl8-ox2U,14636
+gitflow_analytics/config/schema.py,sha256=JOeu8VCgCvYs5B1oQuogQsRTO3UINdQlPNezyoGLoY4,14761
 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
 gitflow_analytics/core/branch_mapper.py,sha256=1L1ctrhTEqMZ61eS1nZRkcyaarLipeQgotw4HdXcSmM,7407
 gitflow_analytics/core/cache.py,sha256=O3I_1Jbuj3GcnUo6CBe0nEJ_8fxKY2wcxeq9sff-OhY,67807
-gitflow_analytics/core/data_fetcher.py,sha256=eroe7MKA6g9_3Uxs03DSXAYX65Rc6_JyLYlcRi11xPo,52987
+gitflow_analytics/core/data_fetcher.py,sha256=eO06-3lQ5O4j5d9Df8Qs4wT-1bvlLcUKbsgNe7L1LTU,57341
 gitflow_analytics/core/identity.py,sha256=k7i-vcRJ2eiTU0_kYGY5QOhxcqnitibTTx7DVONW0kg,31237
 gitflow_analytics/core/metrics_storage.py,sha256=hNXVXjpAaPHYoBFUCj_qR-hs9g8PbQKux_5esyevNEQ,21199
 gitflow_analytics/core/progress.py,sha256=KUQU7ToX63JvPTm8RRy31OmnVeqzc8HfrdGpb2ZvtoY,12509
@@ -114,9 +114,9 @@ gitflow_analytics/tui/widgets/__init__.py,sha256=85l6vkJuRGJNvej-nUZZoNg562zl_1J
 gitflow_analytics/tui/widgets/data_table.py,sha256=8fGNG4m7H41vCid3QwCHJa7bd8qu_DKrDf22iCks3XA,8722
 gitflow_analytics/tui/widgets/export_modal.py,sha256=L-XKPOc6u-fow2TudPgDnC0kXZM1WZuGd_jahtV8lhg,10737
 gitflow_analytics/tui/widgets/progress_widget.py,sha256=Qny6Q1nU0Pr3aj4aHfXLaRjya9MH3rldR2HWYiaQyGE,6167
-gitflow_analytics-1.3.6.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
-gitflow_analytics-1.3.6.dist-info/METADATA,sha256=lkK6bJEnq7bp50-CI5adwJtGQxP4ush1UeRdV9k_pak,34091
-gitflow_analytics-1.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gitflow_analytics-1.3.6.dist-info/entry_points.txt,sha256=a3y8HnfLOvK1QVOgAkDY6VQXXm3o9ZSQRZrpiaS3hEM,65
-gitflow_analytics-1.3.6.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
-gitflow_analytics-1.3.6.dist-info/RECORD,,
+gitflow_analytics-1.3.11.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
+gitflow_analytics-1.3.11.dist-info/METADATA,sha256=jMKDbH-PaYIUhDMkUWO3NDVlOgE-dMoMu-pzEB9KpgI,34092
+gitflow_analytics-1.3.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gitflow_analytics-1.3.11.dist-info/entry_points.txt,sha256=a3y8HnfLOvK1QVOgAkDY6VQXXm3o9ZSQRZrpiaS3hEM,65
+gitflow_analytics-1.3.11.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
+gitflow_analytics-1.3.11.dist-info/RECORD,,