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

gitflow_analytics/tui/screens/loading_screen.py

@@ -1,348 +0,0 @@
-"""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

@@ -1,321 +0,0 @@
-"""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)