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

gitflow_analytics/tui/screens/loading_screen.py

@@ -0,0 +1,348 @@
+"""Loading screen for GitFlow Analytics TUI startup."""
+
+import asyncio
+import time
+from typing import Any, Optional
+
+from textual.binding import Binding
+from textual.containers import Center, Container, Vertical
+from textual.message import Message
+from textual.screen import Screen
+from textual.widgets import Footer, Header, Label, LoadingIndicator, Static
+
+from ..widgets.progress_widget import AnalysisProgressWidget
+
+
+class LoadingScreen(Screen):
+    """
+    Loading screen displayed during application startup and heavy initialization.
+
+    WHY: The TUI application needs to load configurations, spaCy models, and other
+    heavy resources during startup. This screen provides user feedback about the
+    loading process instead of showing a black screen, improving user experience.
+
+    DESIGN DECISION: Uses a combination of progress indicators and status messages
+    to show both overall progress and specific loading steps. This keeps users
+    informed about what's happening and that the application is responsive.
+    """
+
+    BINDINGS = [
+        Binding("ctrl+c", "cancel", "Cancel Loading"),
+        Binding("escape", "cancel", "Cancel Loading"),
+    ]
+
+    def __init__(
+        self,
+        loading_message: str = "Initializing GitFlow Analytics...",
+        *,
+        name: Optional[str] = None,
+        id: Optional[str] = None,
+    ) -> None:
+        super().__init__(name=name, id=id)
+        self.loading_message = loading_message
+        self.loading_task: Optional[asyncio.Task] = None
+        self.start_time = time.time()
+        self.cancelled = False
+
+    def compose(self):
+        """Compose the loading screen with progress indicators."""
+        yield Header()
+
+        with Container(id="loading-container"):
+            # Main loading title
+            yield Label("GitFlow Analytics", classes="screen-title")
+            yield Label("Developer Productivity Analysis", classes="help-text center")
+
+            # Loading animation and message
+            with Center(), Vertical(id="loading-content"):
+                yield LoadingIndicator(id="main-spinner")
+                yield Label(self.loading_message, classes="center", id="loading-message")
+
+                # Overall progress bar
+                yield AnalysisProgressWidget("Startup Progress", total=100.0, id="startup-progress")
+
+                # Status messages
+                with Container(classes="status-panel"):
+                    yield Label("Status", classes="panel-title")
+                    yield Static("Starting up...", id="status-message")
+
+                # Loading steps indicators
+                with Container(classes="stats-panel"):
+                    yield Label("Loading Steps", classes="panel-title")
+                    with Vertical(id="loading-steps"):
+                        yield Static("⏳ Initializing application...", id="step-init")
+                        yield Static("⏳ Loading configuration...", id="step-config")
+                        yield Static("⏳ Preparing analysis engine...", id="step-engine")
+                        yield Static("⏳ Loading NLP models...", id="step-nlp")
+                        yield Static("⏳ Finalizing setup...", id="step-finalize")
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Start loading process when screen mounts."""
+        self.loading_task = asyncio.create_task(self._simulate_loading())
+
+    async def _simulate_loading(self) -> None:
+        """
+        Simulate the loading process with progress updates.
+
+        WHY: This provides visual feedback during startup initialization.
+        In practice, this would be replaced by actual initialization calls.
+        """
+        progress_widget = self.query_one("#startup-progress", AnalysisProgressWidget)
+        status_message = self.query_one("#status-message", Static)
+
+        try:
+            # Step 1: Initialize application (20%)
+            await self._update_step("step-init", "✅ Application initialized", "success")
+            status_message.update("Initializing core components...")
+            progress_widget.update_progress(20, "Core components ready")
+            await asyncio.sleep(0.3)
+
+            if self.cancelled:
+                return
+
+            # Step 2: Load configuration (40%)
+            await self._update_step("step-config", "✅ Configuration loaded", "success")
+            status_message.update("Loading configuration files...")
+            progress_widget.update_progress(40, "Configuration loaded")
+            await asyncio.sleep(0.5)
+
+            if self.cancelled:
+                return
+
+            # Step 3: Prepare analysis engine (60%)
+            await self._update_step("step-engine", "✅ Analysis engine ready", "success")
+            status_message.update("Preparing Git analysis engine...")
+            progress_widget.update_progress(60, "Analysis engine initialized")
+            await asyncio.sleep(0.4)
+
+            if self.cancelled:
+                return
+
+            # Step 4: Load NLP models (85%) - This is the heavy operation
+            await self._update_step("step-nlp", "⏳ Loading spaCy models...", "warning")
+            status_message.update("Loading natural language processing models...")
+            progress_widget.update_progress(70, "Loading spaCy models...")
+            await asyncio.sleep(1.2)  # Simulate spaCy model loading time
+
+            if self.cancelled:
+                return
+
+            await self._update_step("step-nlp", "✅ NLP models loaded", "success")
+            progress_widget.update_progress(85, "NLP models ready")
+
+            # Step 5: Finalize setup (100%)
+            await self._update_step("step-finalize", "✅ Setup complete", "success")
+            status_message.update("Finalizing application setup...")
+            progress_widget.update_progress(100, "GitFlow Analytics ready!")
+            await asyncio.sleep(0.3)
+
+            # Show completion message briefly
+            loading_message = self.query_one("#loading-message", Label)
+            loading_message.update("Loading complete! Starting application...")
+
+            elapsed_time = time.time() - self.start_time
+            status_message.update(f"Ready! Loaded in {elapsed_time:.1f} seconds")
+
+            # Wait a moment to show completion
+            await asyncio.sleep(0.8)
+
+            # Signal that loading is complete
+            self.app.post_message(self.LoadingComplete())
+
+        except asyncio.CancelledError:
+            progress_widget.update_progress(0, "Loading cancelled")
+            status_message.update("Loading cancelled by user")
+        except Exception as e:
+            progress_widget.update_progress(0, f"Error: {str(e)[:50]}...")
+            status_message.update(f"Loading failed: {e}")
+            self.app.notify(f"Loading failed: {e}", severity="error")
+
+    async def _update_step(self, step_id: str, message: str, status: str) -> None:
+        """
+        Update a loading step with status.
+
+        @param step_id: ID of the step element to update
+        @param message: Status message to display
+        @param status: Status type (success, warning, error)
+        """
+        step_element = self.query_one(f"#{step_id}", Static)
+        step_element.update(message)
+
+        # Apply appropriate styling based on status
+        step_element.remove_class("success", "warning", "error")
+        step_element.add_class(status)
+
+    def update_loading_message(self, message: str) -> None:
+        """
+        Update the main loading message.
+
+        @param message: New loading message to display
+        """
+        try:
+            loading_message = self.query_one("#loading-message", Label)
+            loading_message.update(message)
+        except Exception:
+            pass  # Ignore if element not found
+
+    def update_progress(self, percentage: float, status: str) -> None:
+        """
+        Update the overall progress bar.
+
+        @param percentage: Progress percentage (0-100)
+        @param status: Status message to display
+        """
+        try:
+            progress_widget = self.query_one("#startup-progress", AnalysisProgressWidget)
+            progress_widget.update_progress(percentage, status)
+        except Exception:
+            pass  # Ignore if element not found
+
+    def update_status(self, status: str) -> None:
+        """
+        Update the status message.
+
+        @param status: Status message to display
+        """
+        try:
+            status_message = self.query_one("#status-message", Static)
+            status_message.update(status)
+        except Exception:
+            pass  # Ignore if element not found
+
+    def action_cancel(self) -> None:
+        """Cancel the loading process."""
+        self.cancelled = True
+        if self.loading_task and not self.loading_task.done():
+            self.loading_task.cancel()
+        self.app.post_message(self.LoadingCancelled())
+
+    class LoadingComplete(Message):
+        """Message sent when loading is complete."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+    class LoadingCancelled(Message):
+        """Message sent when loading is cancelled."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+
+class InitializationLoadingScreen(LoadingScreen):
+    """
+    Specialized loading screen for real application initialization.
+
+    WHY: This version of the loading screen performs actual initialization
+    tasks instead of just simulating them, providing real progress feedback
+    during startup.
+    """
+
+    def __init__(self, config_loader_func=None, nlp_init_func=None, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.config_loader_func = config_loader_func
+        self.nlp_init_func = nlp_init_func
+        self.initialization_data = {}
+
+    async def _simulate_loading(self) -> None:
+        """
+        Perform actual initialization tasks with progress updates.
+
+        WHY: This replaces the simulation with real initialization work,
+        allowing the loading screen to show progress of actual operations.
+        """
+        progress_widget = self.query_one("#startup-progress", AnalysisProgressWidget)
+        status_message = self.query_one("#status-message", Static)
+
+        try:
+            # Step 1: Initialize application (20%)
+            await self._update_step("step-init", "✅ Application initialized", "success")
+            status_message.update("Initializing core components...")
+            progress_widget.update_progress(20, "Core components ready")
+            await asyncio.sleep(0.1)
+
+            if self.cancelled:
+                return
+
+            # Step 2: Load configuration (40%)
+            status_message.update("Discovering configuration files...")
+            await self._update_step("step-config", "⏳ Loading configuration...", "warning")
+
+            if self.config_loader_func:
+                config_result = await asyncio.get_event_loop().run_in_executor(
+                    None, self.config_loader_func
+                )
+                self.initialization_data["config"] = config_result
+
+            await self._update_step("step-config", "✅ Configuration loaded", "success")
+            progress_widget.update_progress(40, "Configuration ready")
+            await asyncio.sleep(0.1)
+
+            if self.cancelled:
+                return
+
+            # Step 3: Prepare analysis engine (60%)
+            await self._update_step("step-engine", "✅ Analysis engine ready", "success")
+            status_message.update("Preparing Git analysis components...")
+            progress_widget.update_progress(60, "Analysis engine initialized")
+            await asyncio.sleep(0.2)
+
+            if self.cancelled:
+                return
+
+            # Step 4: Load NLP models (85%) - Heavy operation
+            config = self.initialization_data.get("config")
+            if config and getattr(config, "qualitative", None) and config.qualitative.enabled:
+                await self._update_step("step-nlp", "⏳ Loading spaCy models...", "warning")
+                status_message.update("Loading natural language processing models...")
+                progress_widget.update_progress(70, "Loading spaCy models...")
+
+                if self.nlp_init_func:
+                    nlp_result = await asyncio.get_event_loop().run_in_executor(
+                        None, self.nlp_init_func, config
+                    )
+                    self.initialization_data["nlp"] = nlp_result
+
+                await self._update_step("step-nlp", "✅ NLP models loaded", "success")
+                progress_widget.update_progress(85, "NLP models ready")
+            else:
+                await self._update_step("step-nlp", "⏸️ NLP models skipped", "warning")
+                progress_widget.update_progress(85, "NLP models skipped (qualitative disabled)")
+
+            if self.cancelled:
+                return
+
+            # Step 5: Finalize setup (100%)
+            await self._update_step("step-finalize", "✅ Setup complete", "success")
+            status_message.update("Finalizing application setup...")
+            progress_widget.update_progress(100, "GitFlow Analytics ready!")
+
+            # Show completion message briefly
+            loading_message = self.query_one("#loading-message", Label)
+            loading_message.update("Initialization complete! Starting application...")
+
+            elapsed_time = time.time() - self.start_time
+            status_message.update(f"Ready! Initialized in {elapsed_time:.1f} seconds")
+
+            # Wait a moment to show completion
+            await asyncio.sleep(0.5)
+
+            # Signal that loading is complete with initialization data
+            self.app.post_message(self.InitializationComplete(self.initialization_data))
+
+        except asyncio.CancelledError:
+            progress_widget.update_progress(0, "Initialization cancelled")
+            status_message.update("Initialization cancelled by user")
+        except Exception as e:
+            progress_widget.update_progress(0, f"Error: {str(e)[:50]}...")
+            status_message.update(f"Initialization failed: {e}")
+            self.app.notify(f"Initialization failed: {e}", severity="error")
+
+    class InitializationComplete(Message):
+        """Message sent when initialization is complete with data."""
+
+        def __init__(self, data: dict[str, Any]) -> None:
+            super().__init__()
+            self.data = data

gitflow_analytics/tui/screens/main_screen.py

@@ -0,0 +1,321 @@
+"""Main screen for GitFlow Analytics TUI."""
+
+from pathlib import Path
+from typing import Optional
+
+from textual.binding import Binding
+from textual.containers import Container, Vertical
+from textual.message import Message
+from textual.screen import Screen
+from textual.widgets import Button, Footer, Header, Label, Rule, Static
+
+from gitflow_analytics.config import Config
+
+
+class MainScreen(Screen):
+    """
+    Main dashboard screen showing project information and navigation options.
+
+    WHY: Serves as the primary entry point for the TUI, providing users with
+    an overview of their configuration and clear navigation to all major features.
+
+    DESIGN DECISION: Uses a dashboard layout rather than a menu-driven approach
+    to provide immediate visibility into the current configuration status and
+    quick access to common operations.
+    """
+
+    BINDINGS = [
+        Binding("ctrl+q", "quit", "Quit"),
+        Binding("ctrl+n", "new_analysis", "New Analysis"),
+        Binding("ctrl+o", "open_config", "Open Config"),
+        Binding("f1", "help", "Help"),
+        Binding("c", "cache_status", "Cache Status"),
+        Binding("i", "manage_identities", "Identities"),
+    ]
+
+    class NewAnalysisRequested(Message):
+        """Message sent when new analysis is requested."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+    class ConfigurationRequested(Message):
+        """Message sent when configuration is requested."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+    class CacheStatusRequested(Message):
+        """Message sent when cache status is requested."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+    class IdentityManagementRequested(Message):
+        """Message sent when identity management is requested."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+    class HelpRequested(Message):
+        """Message sent when help is requested."""
+
+        def __init__(self) -> None:
+            super().__init__()
+
+    def __init__(
+        self,
+        config: Optional[Config] = None,
+        config_path: Optional[Path] = None,
+        *,
+        name: Optional[str] = None,
+        id: Optional[str] = None,
+    ) -> None:
+        super().__init__(name=name, id=id)
+        self.config = config
+        self.config_path = config_path
+
+    def compose(self):
+        """Compose the main screen."""
+        yield Header()
+
+        with Container(id="main-container"):
+            yield Label("GitFlow Analytics", classes="screen-title")
+            yield Static("Developer Productivity Analysis Tool", id="subtitle")
+
+            # Configuration status section
+            with Container(classes="status-panel"):
+                yield Label("Configuration Status", classes="section-title")
+
+                if self.config:
+                    config_status = (
+                        f"✅ Loaded: {self.config_path}"
+                        if self.config_path
+                        else "✅ Configuration loaded"
+                    )
+                    yield Static(config_status, id="config-status")
+
+                    # Show key configuration details
+                    details = self._get_config_summary()
+                    yield Static(details, id="config-details")
+                else:
+                    yield Static("❌ No configuration loaded", id="config-status")
+                    yield Static(
+                        "Load or create a configuration to begin analysis", id="config-help"
+                    )
+
+            yield Rule()
+
+            # Main actions section
+            with Container(classes="actions-panel"):
+                yield Label("Available Actions", classes="section-title")
+
+                with Vertical(id="action-buttons"):
+                    if self.config:
+                        yield Button("🚀 Run Analysis", variant="primary", id="run-analysis")
+                        yield Button("📊 View Cache Status", id="cache-status")
+                        yield Button("👥 Manage Developer Identities", id="manage-identities")
+                        yield Button("⚙️ Edit Configuration", id="edit-config")
+                    else:
+                        yield Button("📁 Load Configuration", variant="primary", id="load-config")
+                        yield Button("➕ Create New Configuration", id="new-config")
+
+                    yield Rule()
+                    yield Button("❓ Help & Documentation", id="help")
+
+            # Quick stats section (if config loaded)
+            if self.config:
+                with Container(classes="stats-panel"):
+                    yield Label("Quick Information", classes="section-title")
+                    stats = self._get_quick_stats()
+                    yield Static(stats, id="quick-stats")
+
+        yield Footer()
+
+    def _get_config_summary(self) -> str:
+        """
+        Generate configuration summary for display.
+
+        WHY: Provides users with immediate visibility into their current
+        configuration without needing to navigate to a separate screen.
+        """
+        if not self.config:
+            return ""
+
+        lines = []
+
+        # Repository count
+        repo_count = len(self.config.repositories) if self.config.repositories else 0
+        if self.config.github.organization and not self.config.repositories:
+            lines.append(f"• Organization: {self.config.github.organization} (auto-discovery)")
+        else:
+            lines.append(f"• Repositories: {repo_count} configured")
+
+        # GitHub integration
+        if self.config.github.token:
+            lines.append("✅ GitHub API configured")
+        else:
+            lines.append("⚠️ GitHub API not configured")
+
+        # Qualitative analysis
+        if (
+            hasattr(self.config, "qualitative")
+            and self.config.qualitative
+            and self.config.qualitative.enabled
+        ):
+            lines.append("✅ Qualitative analysis enabled")
+        else:
+            lines.append("⚠️ Qualitative analysis disabled")
+
+        # JIRA integration
+        if hasattr(self.config, "jira") and self.config.jira and self.config.jira.base_url:
+            lines.append("✅ JIRA integration configured")
+        else:
+            lines.append("⚠️ JIRA integration not configured")
+
+        # Cache configuration
+        lines.append(f"• Cache TTL: {self.config.cache.ttl_hours}h")
+
+        return "\n".join(lines)
+
+    def _get_quick_stats(self) -> str:
+        """
+        Generate quick statistics if cache data is available.
+
+        WHY: Shows users what data is already available from previous runs,
+        helping them understand if they need to run a new analysis.
+        """
+        try:
+            from ....core.cache import GitAnalysisCache
+
+            cache = GitAnalysisCache(self.config.cache.directory)
+            stats = cache.get_cache_stats()
+
+            lines = []
+            lines.append(f"• Cached commits: {stats['cached_commits']:,}")
+            lines.append(f"• Cached PRs: {stats['cached_prs']:,}")
+            lines.append(f"• Cached issues: {stats['cached_issues']:,}")
+
+            if stats["stale_commits"] > 0:
+                lines.append(f"• Stale entries: {stats['stale_commits']:,}")
+
+            # Cache size
+            import os
+
+            cache_size = 0
+            try:
+                for root, _dirs, files in os.walk(self.config.cache.directory):
+                    for f in files:
+                        cache_size += os.path.getsize(os.path.join(root, f))
+                cache_size_mb = cache_size / 1024 / 1024
+                lines.append(f"• Cache size: {cache_size_mb:.1f} MB")
+            except Exception:
+                pass
+
+            return "\n".join(lines)
+
+        except Exception:
+            return "Cache statistics unavailable"
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events."""
+        button_actions = {
+            "run-analysis": self._run_analysis,
+            "load-config": self._load_config,
+            "new-config": self._new_config,
+            "edit-config": self._edit_config,
+            "cache-status": self._cache_status,
+            "manage-identities": self._manage_identities,
+            "help": self._show_help,
+        }
+
+        action = button_actions.get(event.button.id)
+        if action:
+            action()
+
+    def _run_analysis(self) -> None:
+        """Request new analysis."""
+        if not self.config:
+            self.notify("Please load or create a configuration first", severity="error")
+            return
+        self.post_message(self.NewAnalysisRequested())
+
+    def _load_config(self) -> None:
+        """Request configuration loading."""
+        self.post_message(self.ConfigurationRequested())
+
+    def _new_config(self) -> None:
+        """Request new configuration creation."""
+        self.post_message(self.ConfigurationRequested())
+
+    def _edit_config(self) -> None:
+        """Request configuration editing."""
+        self.post_message(self.ConfigurationRequested())
+
+    def _cache_status(self) -> None:
+        """Request cache status display."""
+        self.post_message(self.CacheStatusRequested())
+
+    def _manage_identities(self) -> None:
+        """Request identity management."""
+        self.post_message(self.IdentityManagementRequested())
+
+    def _show_help(self) -> None:
+        """Request help display."""
+        self.post_message(self.HelpRequested())
+
+    # Action handlers for key bindings
+    def action_quit(self) -> None:
+        """Quit the application."""
+        self.app.exit()
+
+    def action_new_analysis(self) -> None:
+        """Start new analysis via keyboard shortcut."""
+        self._run_analysis()
+
+    def action_open_config(self) -> None:
+        """Open configuration via keyboard shortcut."""
+        self._load_config()
+
+    def action_help(self) -> None:
+        """Show help via keyboard shortcut."""
+        self._show_help()
+
+    def action_cache_status(self) -> None:
+        """Show cache status via keyboard shortcut."""
+        self._cache_status()
+
+    def action_manage_identities(self) -> None:
+        """Manage identities via keyboard shortcut."""
+        self._manage_identities()
+
+    def update_config(self, config: Config, config_path: Optional[Path] = None) -> None:
+        """
+        Update the configuration and refresh the display.
+
+        WHY: Allows the main screen to be updated when configuration changes
+        without requiring a full screen rebuild, maintaining user context.
+        """
+        self.config = config
+        self.config_path = config_path
+
+        # Update configuration status
+        if self.config:
+            config_status = (
+                f"✅ Loaded: {self.config_path}" if self.config_path else "✅ Configuration loaded"
+            )
+            self.query_one("#config-status", Static).update(config_status)
+
+            # Update configuration details
+            details = self._get_config_summary()
+            self.query_one("#config-details", Static).update(details)
+
+            # Update quick stats if available
+            try:
+                stats = self._get_quick_stats()
+                self.query_one("#quick-stats", Static).update(stats)
+            except Exception:
+                pass
+
+        # Refresh to rebuild buttons with new state
+        self.refresh(recompose=True)