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

gitflow_analytics/tui/screens/analysis_progress_screen.py

@@ -2,22 +2,24 @@
 
 import asyncio
 import time
+from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Optional
 
-from rich.pretty import Pretty
 from textual.binding import Binding
 from textual.containers import Container, Vertical
 from textual.screen import Screen
-from textual.widgets import Footer, Header, Label, Log
+from textual.widgets import Footer, Header, Label, Log, Static
 
 from gitflow_analytics.config import Config
+from gitflow_analytics.core import progress as core_progress
 from gitflow_analytics.core.analyzer import GitAnalyzer
 from gitflow_analytics.core.cache import GitAnalysisCache
 from gitflow_analytics.core.identity import DeveloperIdentityResolver
 from gitflow_analytics.integrations.orchestrator import IntegrationOrchestrator
 
+from ..progress_adapter import TUIProgressService
 from ..widgets.progress_widget import AnalysisProgressWidget
 
 
@@ -56,6 +58,8 @@ class AnalysisProgressScreen(Screen):
         self.analysis_task: Optional[asyncio.Task] = None
         self.analysis_results = {}
         self.start_time = time.time()
+        self.progress_service = None  # Will be initialized on mount
+        self.executor: Optional[ThreadPoolExecutor] = None  # Managed executor for cleanup
 
     def compose(self):
         """Compose the analysis progress screen."""
@@ -82,7 +86,7 @@ class AnalysisProgressScreen(Screen):
                 # Live statistics panel
                 with Container(classes="stats-panel"):
                     yield Label("Live Statistics", classes="panel-title")
-                    yield Pretty({}, id="live-stats")
+                    yield Static("No statistics yet...", id="live-stats")
 
             # Analysis log
             with Container(classes="log-panel"):
@@ -93,7 +97,37 @@ class AnalysisProgressScreen(Screen):
 
     def on_mount(self) -> None:
         """Start analysis when screen mounts."""
-        self.analysis_task = asyncio.create_task(self._run_analysis())
+        # Initialize progress service for TUI
+        self.progress_service = TUIProgressService(asyncio.get_event_loop())
+        self.analysis_task = asyncio.create_task(self._run_analysis_wrapper())
+
+    def on_unmount(self) -> None:
+        """Cleanup when screen unmounts."""
+        # Cancel the analysis task if it's still running
+        if self.analysis_task and not self.analysis_task.done():
+            self.analysis_task.cancel()
+            # Don't wait for cancellation to complete to avoid blocking
+
+        # Shutdown the executor to cleanup threads immediately
+        if self.executor:
+            self.executor.shutdown(wait=False)
+            self.executor = None
+
+    async def _run_analysis_wrapper(self) -> None:
+        """Wrapper for analysis that handles cancellation gracefully."""
+        try:
+            await self._run_analysis()
+        except asyncio.CancelledError:
+            # Silently handle cancellation - this is expected during shutdown
+            pass
+        except Exception as e:
+            # Log unexpected errors if the app is still running
+            if self.app and self.app.is_running:
+                try:
+                    log = self.query_one("#analysis-log", Log)
+                    log.write_line(f"❌ Unexpected error: {e}")
+                except Exception:
+                    pass
 
     async def _run_analysis(self) -> None:
         """
@@ -168,12 +202,26 @@ class AnalysisProgressScreen(Screen):
             )
 
         except asyncio.CancelledError:
-            log.write_line("❌ Analysis cancelled by user")
-            overall_progress.update_progress(0, "Cancelled")
+            # Check if the app is still running before updating UI
+            if self.app and self.app.is_running:
+                try:
+                    log.write_line("❌ Analysis cancelled by user")
+                    overall_progress.update_progress(0, "Cancelled")
+                except Exception:
+                    # Silently ignore if we can't update the UI
+                    pass
+            # Re-raise for the wrapper to handle
+            raise
         except Exception as e:
-            log.write_line(f"❌ Analysis failed: {e}")
-            overall_progress.update_progress(0, f"Error: {str(e)[:50]}...")
-            self.notify(f"Analysis failed: {e}", severity="error")
+            # Check if the app is still running before updating UI
+            if self.app and self.app.is_running:
+                try:
+                    log.write_line(f"❌ Analysis failed: {e}")
+                    overall_progress.update_progress(0, f"Error: {str(e)[:50]}...")
+                    self.notify(f"Analysis failed: {e}", severity="error")
+                except Exception:
+                    # Silently ignore if we can't update the UI
+                    pass
 
     async def _initialize_components(self, log: Log) -> None:
         """Initialize analysis components."""
@@ -191,12 +239,20 @@ class AnalysisProgressScreen(Screen):
         )
 
         log.write_line("🔍 Initializing analyzer...")
+
+        # Enable branch analysis with progress logging for TUI
+        branch_analysis_config = {
+            "enable_progress_logging": True,
+            "strategy": "all",
+        }
+
         self.analyzer = GitAnalyzer(
             self.cache,
             branch_mapping_rules=self.config.analysis.branch_mapping_rules,
             allowed_ticket_platforms=getattr(self.config.analysis, "ticket_platforms", None),
             exclude_paths=self.config.analysis.exclude_paths,
             story_point_patterns=self.config.analysis.story_point_patterns,
+            branch_analysis_config=branch_analysis_config,
         )
 
         log.write_line("🔗 Initializing integrations...")
@@ -242,7 +298,10 @@ class AnalysisProgressScreen(Screen):
 
     async def _analyze_repositories(self, repositories: list, log: Log) -> tuple:
         """Analyze all repositories and return commits and PRs."""
+        # Import progress module at the top of the function
+
         repo_progress = self.query_one("#repo-progress", AnalysisProgressWidget)
+        overall_progress = self.query_one("#overall-progress", AnalysisProgressWidget)
 
         all_commits = []
         all_prs = []
@@ -251,53 +310,177 @@ class AnalysisProgressScreen(Screen):
         end_date = datetime.now(timezone.utc)
         start_date = end_date - timedelta(weeks=self.weeks)
 
-        for i, repo_config in enumerate(repositories):
-            progress = (i / len(repositories)) * 100
-            repo_progress.update_progress(progress, f"Analyzing {repo_config.name}...")
+        # Create progress adapter for repository analysis
+        repo_adapter = self.progress_service.create_adapter("repo", repo_progress)
 
-            log.write_line(f"📁 Analyzing {repo_config.name}...")
+        # Set initial stats for the adapter
+        repo_adapter.processing_stats["total"] = len(repositories)
 
-            try:
-                # Clone repository if needed
-                if not repo_config.path.exists() and repo_config.github_repo:
-                    log.write_line(f"   📥 Cloning {repo_config.github_repo}...")
-                    await self._clone_repository(repo_config, log)
-
-                # Analyze commits
-                commits = self.analyzer.analyze_repository(
-                    repo_config.path, start_date, repo_config.branch
-                )
+        # Temporarily replace the global progress service with our adapter
+        original_progress_service = core_progress._progress_service
+        core_progress._progress_service = repo_adapter
 
-                # Add project key and resolve identities
-                for commit in commits:
-                    commit["project_key"] = repo_config.project_key or commit.get(
-                        "inferred_project", "UNKNOWN"
-                    )
-                    commit["canonical_id"] = self.identity_resolver.resolve_developer(
-                        commit["author_name"], commit["author_email"]
-                    )
+        total_repos = len(repositories)
+
+        # Clone repositories that don't exist locally first
+        for repo_config in repositories:
+            if not repo_config.path.exists() and repo_config.github_repo:
+                log.write_line(f"   📥 Cloning {repo_config.github_repo}...")
+                await self._clone_repository(repo_config, log)
 
-                all_commits.extend(commits)
-                log.write_line(f"   ✅ Found {len(commits)} commits")
+        # Check if we should use async processing (for multiple repositories)
+        # We use async processing for 2+ repositories to keep the UI responsive
+        use_async = len(repositories) > 1
 
-                # Update live stats
-                await self._update_live_stats(
+        if use_async:
+            log.write_line(f"🚀 Starting async analysis of {len(repositories)} repositories...")
+
+            # Import data fetcher for parallel processing
+            from gitflow_analytics.core.data_fetcher import GitDataFetcher
+            from gitflow_analytics.tui.progress_adapter import TUIProgressAdapter
+
+            # Create and set up progress adapter for parallel processing
+            tui_progress_adapter = TUIProgressAdapter(repo_progress)
+            tui_progress_adapter.set_event_loop(asyncio.get_event_loop())
+
+            # Replace the global progress service so parallel processing can use it
+            # We'll restore the original one after processing
+            core_progress._progress_service = tui_progress_adapter
+
+            # Create data fetcher
+            # Use skip_remote_fetch=True when analyzing already-cloned repositories
+            # to avoid authentication issues with expired tokens
+            data_fetcher = GitDataFetcher(cache=self.cache, skip_remote_fetch=True)
+
+            # Prepare repository configurations for parallel processing
+            repo_configs = []
+            for repo_config in repositories:
+                repo_configs.append(
                     {
-                        "repositories_analyzed": i + 1,
-                        "total_repositories": len(repositories),
-                        "total_commits": len(all_commits),
-                        "current_repo": repo_config.name,
+                        "path": str(repo_config.path),
+                        "project_key": repo_config.project_key or repo_config.name,
+                        "branch_patterns": [repo_config.branch] if repo_config.branch else None,
                     }
                 )
 
-                # Small delay to allow UI updates
-                await asyncio.sleep(0.1)
+            # Run parallel processing in executor to avoid blocking
+            loop = asyncio.get_event_loop()
+
+            # Update overall progress
+            overall_progress.update_progress(25, "Running parallel repository analysis...")
+
+            try:
+                # Process repositories asynchronously with yielding for UI updates
+                parallel_results = await self._process_repositories_async(
+                    data_fetcher,
+                    repo_configs,
+                    start_date,
+                    end_date,
+                    repo_progress,
+                    overall_progress,
+                    log,
+                )
+
+                # Process results
+                for project_key, result in parallel_results["results"].items():
+                    if result and "commits" in result:
+                        commits_data = result["commits"]
+                        # Add project key and resolve identities
+                        for commit in commits_data:
+                            commit["project_key"] = project_key
+                            commit["canonical_id"] = self.identity_resolver.resolve_developer(
+                                commit["author_name"], commit["author_email"]
+                            )
+                        all_commits.extend(commits_data)
+                        log.write_line(f"   ✅ {project_key}: {len(commits_data)} commits")
+
+                # Log final statistics
+                stats = parallel_results.get("statistics", {})
+                log.write_line("\n📊 Analysis Statistics:")
+                log.write_line(f"   Total: {stats.get('total', 0)} repositories")
+                log.write_line(f"   Success: {stats.get('success', 0)} (have commits)")
+                log.write_line(
+                    f"   No Commits: {stats.get('no_commits', 0)} (no activity in period)"
+                )
+                log.write_line(f"   Failed: {stats.get('failed', 0)} (processing errors)")
+                log.write_line(f"   Timeout: {stats.get('timeout', 0)}")
 
             except Exception as e:
-                log.write_line(f"   ❌ Error analyzing {repo_config.name}: {e}")
-                continue
+                log.write_line(f"   ❌ Async processing failed: {e}")
+                log.write_line("   Falling back to sequential processing...")
+                use_async = False
+            finally:
+                # Restore original progress service
+                core_progress._progress_service = original_progress_service
+
+        # Sequential processing fallback or for single repository
+        if not use_async:
+            # Ensure we have an executor for sequential processing
+            if not self.executor:
+                self.executor = ThreadPoolExecutor(max_workers=1)
+
+            for i, repo_config in enumerate(repositories):
+                # Update overall progress based on repository completion
+                overall_pct = 20 + ((i / total_repos) * 30)  # 20-50% range for repo analysis
+                overall_progress.update_progress(
+                    overall_pct, f"Analyzing repositories ({i+1}/{total_repos})..."
+                )
+
+                repo_progress.update_progress(0, f"Analyzing {repo_config.name}...")
+
+                log.write_line(f"📁 Analyzing {repo_config.name}...")
+
+                try:
+                    log.write_line(f"   ⏳ Starting analysis of {repo_config.name}...")
+
+                    # Run repository analysis in a thread to avoid blocking
+                    loop = asyncio.get_event_loop()
+                    commits = await loop.run_in_executor(
+                        (
+                            self.executor if self.executor else None
+                        ),  # Use managed executor if available
+                        self.analyzer.analyze_repository,
+                        repo_config.path,
+                        start_date,
+                        repo_config.branch,
+                    )
+
+                    log.write_line(f"   ✓ Analysis complete for {repo_config.name}")
+
+                    # Add project key and resolve identities
+                    for commit in commits:
+                        commit["project_key"] = repo_config.project_key or commit.get(
+                            "inferred_project", "UNKNOWN"
+                        )
+                        commit["canonical_id"] = self.identity_resolver.resolve_developer(
+                            commit["author_name"], commit["author_email"]
+                        )
+
+                    all_commits.extend(commits)
+                    log.write_line(f"   ✅ Found {len(commits)} commits")
+
+                    # Update live stats
+                    await self._update_live_stats(
+                        {
+                            "repositories_analyzed": i + 1,
+                            "total_repositories": len(repositories),
+                            "total_commits": len(all_commits),
+                            "current_repo": repo_config.name,
+                        }
+                    )
+
+                    # Small delay to allow UI updates
+                    await asyncio.sleep(0.05)  # Reduced delay for more responsive updates
+
+                except Exception as e:
+                    log.write_line(f"   ❌ Error analyzing {repo_config.name}: {e}")
+                    continue
+
+        # Restore original progress service
+        core_progress._progress_service = original_progress_service
 
         repo_progress.complete(f"Completed {len(repositories)} repositories")
+        overall_progress.update_progress(50, f"Analyzed {len(all_commits)} commits")
         return all_commits, all_prs
 
     async def _enrich_with_integrations(self, repositories: list, commits: list, log: Log) -> None:
@@ -441,6 +624,166 @@ class AnalysisProgressScreen(Screen):
             log.write_line(f"   ❌ Qualitative analysis failed: {e}")
             qual_progress.update_progress(0, f"Error: {str(e)[:30]}...")
 
+    async def _process_repositories_async(
+        self,
+        data_fetcher,
+        repo_configs: list,
+        start_date: datetime,
+        end_date: datetime,
+        repo_progress: AnalysisProgressWidget,
+        overall_progress: AnalysisProgressWidget,
+        log: Log,
+    ) -> dict:
+        """
+        Process repositories asynchronously with proper yielding for UI updates.
+
+        This method processes repositories one at a time but yields control back
+        to the event loop between each repository to allow UI updates.
+        """
+        results = {
+            "results": {},
+            "statistics": {
+                "total": len(repo_configs),
+                "processed": 0,
+                "success": 0,
+                "no_commits": 0,
+                "failed": 0,
+                "timeout": 0,
+            },
+        }
+
+        stats = results["statistics"]
+        loop = asyncio.get_event_loop()
+
+        # Create a managed executor for this analysis
+        if not self.executor:
+            self.executor = ThreadPoolExecutor(max_workers=1)
+
+        for i, repo_config in enumerate(repo_configs):
+            project_key = repo_config["project_key"]
+
+            # Update progress before processing
+            percentage = (i / stats["total"]) * 100
+            repo_progress.update_progress(
+                percentage, f"Processing {project_key} ({i+1}/{stats['total']})..."
+            )
+
+            # Update overall progress
+            overall_percentage = 25 + ((i / stats["total"]) * 25)  # 25-50% range
+            overall_progress.update_progress(
+                overall_percentage, f"Analyzing repository {i+1}/{stats['total']}: {project_key}"
+            )
+
+            log.write_line(f"🔍 Processing {project_key} ({i+1}/{stats['total']})...")
+
+            try:
+                # Run the actual repository processing in a thread to avoid blocking
+                # but await it properly so we can yield between repositories
+                result = await loop.run_in_executor(
+                    self.executor,  # Use managed executor instead of default
+                    self._process_single_repository_sync,
+                    data_fetcher,
+                    repo_config,
+                    self.weeks,
+                    start_date,
+                    end_date,
+                )
+
+                # Check for commits - data fetcher returns 'daily_commits' not 'commits'
+                if result:
+                    # Extract commits from daily_commits structure
+                    daily_commits = result.get("daily_commits", {})
+                    total_commits = result.get("stats", {}).get("total_commits", 0)
+
+                    # Convert daily_commits to flat commits list
+                    commits = []
+                    for date_str, day_commits in daily_commits.items():
+                        commits.extend(day_commits)
+
+                    # Add flattened commits to result for compatibility
+                    result["commits"] = commits
+
+                    if total_commits > 0 or commits:
+                        results["results"][project_key] = result
+                        stats["success"] += 1
+                        log.write_line(f"   ✅ {project_key}: {total_commits} commits")
+                    else:
+                        stats["no_commits"] += 1
+                        log.write_line(f"   ⏸️  {project_key}: No commits in analysis period")
+                else:
+                    stats["failed"] += 1
+                    log.write_line(f"   ❌ {project_key}: Failed to process")
+
+            except Exception as e:
+                stats["failed"] += 1
+                log.write_line(f"   ❌ {project_key}: Error - {str(e)[:50]}...")
+
+            stats["processed"] += 1
+
+            # Update progress after processing
+            percentage = ((i + 1) / stats["total"]) * 100
+            repo_progress.update_progress(
+                percentage, f"Completed {project_key} ({i+1}/{stats['total']})"
+            )
+
+            # Yield control to event loop for UI updates
+            # This is the key to keeping the UI responsive
+            await asyncio.sleep(0.01)
+
+            # Also update live stats
+            await self._update_live_stats(
+                {
+                    "repositories_analyzed": stats["processed"],
+                    "total_repositories": stats["total"],
+                    "successful": stats["success"],
+                    "no_commits": stats["no_commits"],
+                    "failed": stats["failed"],
+                    "current_repo": project_key if i < len(repo_configs) - 1 else "Complete",
+                }
+            )
+
+        # Final progress update
+        repo_progress.complete(f"Processed {stats['total']} repositories")
+
+        # Cleanup executor after processing
+        if self.executor:
+            self.executor.shutdown(wait=False)
+            self.executor = None
+
+        return results
+
+    def _process_single_repository_sync(
+        self,
+        data_fetcher,
+        repo_config: dict,
+        weeks_back: int,
+        start_date: datetime,
+        end_date: datetime,
+    ) -> Optional[dict]:
+        """
+        Synchronous wrapper for processing a single repository.
+
+        This runs in a thread executor to avoid blocking the event loop.
+        """
+        try:
+            # Process the repository using data fetcher
+            result = data_fetcher.fetch_repository_data(
+                repo_path=Path(repo_config["path"]),
+                project_key=repo_config["project_key"],
+                weeks_back=weeks_back,
+                branch_patterns=repo_config.get("branch_patterns"),
+                jira_integration=None,
+                progress_callback=None,
+                start_date=start_date,
+                end_date=end_date,
+            )
+            return result
+        except Exception as e:
+            import logging
+
+            logging.getLogger(__name__).error(f"Error processing {repo_config['project_key']}: {e}")
+            return None
+
     async def _clone_repository(self, repo_config, log: Log) -> None:
         """Clone repository if needed."""
         try:
@@ -477,14 +820,32 @@ class AnalysisProgressScreen(Screen):
 
     async def _update_live_stats(self, stats: dict[str, Any]) -> None:
         """Update live statistics display."""
-        stats_widget = self.query_one("#live-stats", Pretty)
-        stats_widget.update(stats)
+        try:
+            stats_widget = self.query_one("#live-stats", Static)
+
+            # Format stats for display
+            stats_text = "\n".join(
+                [f"• {key.replace('_', ' ').title()}: {value}" for key, value in stats.items()]
+            )
+            stats_widget.update(stats_text)
+        except Exception:
+            # Silently ignore if widget doesn't exist (e.g., in testing)
+            pass
 
     def action_cancel(self) -> None:
         """Cancel the analysis."""
         if self.analysis_task and not self.analysis_task.done():
             self.analysis_task.cancel()
-        self.app.pop_screen()
+            # Give the task a moment to cancel cleanly
+            asyncio.create_task(self._delayed_pop_screen())
+        else:
+            self.app.pop_screen()
+
+    async def _delayed_pop_screen(self) -> None:
+        """Pop screen after a brief delay to allow cancellation to complete."""
+        await asyncio.sleep(0.1)
+        if self.app and self.app.is_running:
+            self.app.pop_screen()
 
     def action_back(self) -> None:
         """Go back to main screen."""