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

gitflow_analytics/cli_rich.py

@@ -1,8 +1,7 @@
 """Rich CLI components for GitFlow Analytics with beautiful terminal output."""
 
-from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from rich import box
 from rich.console import Console
@@ -18,7 +17,6 @@ from rich.progress import (
     TimeElapsedColumn,
 )
 from rich.table import Table
-from rich.text import Text
 from rich.tree import Tree
 
 from ._version import __version__
@@ -27,11 +25,11 @@ from ._version import __version__
 class RichProgressDisplay:
     """
     Rich terminal display for GitFlow Analytics progress and results.
-    
+
     WHY: Provides a clean, structured interface that shows users exactly what's happening
     during analysis without the complexity of a full TUI. Uses Rich library for
     beautiful terminal output with progress bars, tables, and status indicators.
-    
+
     DESIGN DECISION: Chose to use Rich's Live display for real-time updates because:
     - Allows multiple progress bars and status updates in a single view
     - Provides structured layout with panels and tables
@@ -51,7 +49,7 @@ class RichProgressDisplay:
             console=self.console,
         )
         self.live: Optional[Live] = None
-        self._tasks: Dict[str, TaskID] = {}
+        self._tasks: dict[str, TaskID] = {}
 
     def show_header(self) -> None:
         """Display the application header."""
@@ -74,30 +72,30 @@ class RichProgressDisplay:
     ) -> None:
         """
         Display configuration validation status.
-        
+
         WHY: Users need immediate feedback on whether their configuration is valid
         before starting analysis. This prevents wasted time on invalid configs.
         """
         config_tree = Tree("[bold]Configuration Status[/bold]")
-        
+
         # Config file status
         config_tree.add(f"[green]✓[/green] Config: {config_path}")
-        
+
         # GitHub configuration
         if github_org:
             github_status = "[green]✓[/green]" if github_token_valid else "[red]✗[/red]"
             token_status = "Token: ✓" if github_token_valid else "Token: ✗"
             config_tree.add(f"{github_status} GitHub: {github_org} ({token_status})")
-        
+
         # JIRA configuration
         if jira_configured:
             jira_status = "[green]✓[/green]" if jira_valid else "[red]✗[/red]"
             cred_status = "Credentials: ✓" if jira_valid else "Credentials: ✗"
             config_tree.add(f"{jira_status} JIRA: configured ({cred_status})")
-        
+
         # Analysis period
         config_tree.add(f"Analysis Period: {analysis_weeks} weeks")
-        
+
         self.console.print(config_tree)
         self.console.print()
 
@@ -117,7 +115,9 @@ class RichProgressDisplay:
         task_id = self.progress.add_task(description, total=total)
         self._tasks[name] = task_id
 
-    def update_progress_task(self, name: str, advance: int = 1, description: Optional[str] = None) -> None:
+    def update_progress_task(
+        self, name: str, advance: int = 1, description: Optional[str] = None
+    ) -> None:
         """Update progress for a specific task."""
         if name in self._tasks:
             kwargs = {"advance": advance}
@@ -135,10 +135,10 @@ class RichProgressDisplay:
             if description:
                 self.progress.update(self._tasks[name], description=description)
 
-    def show_repository_discovery(self, repos: List[Dict[str, Any]]) -> None:
+    def show_repository_discovery(self, repos: list[dict[str, Any]]) -> None:
         """
         Display repository discovery results.
-        
+
         WHY: Users need to see which repositories were discovered and their status
         before analysis begins, especially with organization-based discovery.
         """
@@ -146,7 +146,7 @@ class RichProgressDisplay:
             return
 
         self.console.print(f"[bold]Repository Discovery[/bold] - Found {len(repos)} repositories")
-        
+
         repo_tree = Tree("")
         for repo in repos:
             status = "[green]✓[/green]" if repo.get("exists", True) else "[red]✗[/red]"
@@ -156,7 +156,7 @@ class RichProgressDisplay:
                 repo_tree.add(f"{status} {name} ({github_repo})")
             else:
                 repo_tree.add(f"{status} {name}")
-        
+
         self.console.print(repo_tree)
         self.console.print()
 
@@ -171,31 +171,31 @@ class RichProgressDisplay:
     ) -> None:
         """
         Display analysis results summary.
-        
+
         WHY: Provides users with key metrics at a glance after analysis completes.
         Uses a structured table format for easy scanning of important numbers.
         """
         self.console.print()
-        
+
         summary_table = Table(title="[bold]Analysis Summary[/bold]", box=box.ROUNDED)
         summary_table.add_column("Metric", style="cyan", width=20)
         summary_table.add_column("Value", style="green", width=15)
-        
+
         summary_table.add_row("Total Commits", f"{total_commits:,}")
         summary_table.add_row("Total PRs", f"{total_prs:,}")
         summary_table.add_row("Active Developers", f"{active_developers:,}")
         summary_table.add_row("Ticket Coverage", f"{ticket_coverage:.1f}%")
         summary_table.add_row("Story Points", f"{story_points:,}")
-        
+
         if qualitative_analyzed > 0:
             summary_table.add_row("Qualitative Analysis", f"{qualitative_analyzed:,} commits")
-        
+
         self.console.print(summary_table)
 
-    def show_dora_metrics(self, dora_metrics: Dict[str, Any]) -> None:
+    def show_dora_metrics(self, dora_metrics: dict[str, Any]) -> None:
         """
         Display DORA metrics in a structured format.
-        
+
         WHY: DORA metrics are key performance indicators that teams care about.
         Displaying them prominently helps users understand their team's performance level.
         """
@@ -203,37 +203,37 @@ class RichProgressDisplay:
             return
 
         self.console.print()
-        
+
         dora_table = Table(title="[bold]DORA Metrics[/bold]", box=box.ROUNDED)
         dora_table.add_column("Metric", style="cyan", width=25)
         dora_table.add_column("Value", style="yellow", width=20)
-        
+
         # Deployment frequency
         df_category = dora_metrics.get("deployment_frequency", {}).get("category", "Unknown")
         dora_table.add_row("Deployment Frequency", df_category)
-        
+
         # Lead time
         lead_time = dora_metrics.get("lead_time_hours", 0)
         dora_table.add_row("Lead Time", f"{lead_time:.1f} hours")
-        
+
         # Change failure rate
         cfr = dora_metrics.get("change_failure_rate", 0)
         dora_table.add_row("Change Failure Rate", f"{cfr:.1f}%")
-        
+
         # MTTR
         mttr = dora_metrics.get("mttr_hours", 0)
         dora_table.add_row("MTTR", f"{mttr:.1f} hours")
-        
+
         # Performance level
         perf_level = dora_metrics.get("performance_level", "Unknown")
         dora_table.add_row("Performance Level", f"[bold]{perf_level}[/bold]")
-        
+
         self.console.print(dora_table)
 
-    def show_qualitative_stats(self, qual_stats: Dict[str, Any]) -> None:
+    def show_qualitative_stats(self, qual_stats: dict[str, Any]) -> None:
         """
         Display qualitative analysis statistics.
-        
+
         WHY: Qualitative analysis can be expensive (time/cost), so users need
         visibility into processing efficiency and costs incurred.
         """
@@ -242,17 +242,17 @@ class RichProgressDisplay:
 
         processing_summary = qual_stats.get("processing_summary", {})
         llm_stats = qual_stats.get("llm_statistics", {})
-        
+
         self.console.print()
-        
+
         qual_table = Table(title="[bold]Qualitative Analysis Stats[/bold]", box=box.ROUNDED)
         qual_table.add_column("Metric", style="cyan", width=25)
         qual_table.add_column("Value", style="magenta", width=20)
-        
+
         # Processing speed
         commits_per_sec = processing_summary.get("commits_per_second", 0)
         qual_table.add_row("Processing Speed", f"{commits_per_sec:.1f} commits/sec")
-        
+
         # Method breakdown
         method_breakdown = processing_summary.get("method_breakdown", {})
         cache_pct = method_breakdown.get("cache", 0)
@@ -261,20 +261,170 @@ class RichProgressDisplay:
         qual_table.add_row("Cache Usage", f"{cache_pct:.1f}%")
         qual_table.add_row("NLP Processing", f"{nlp_pct:.1f}%")
         qual_table.add_row("LLM Processing", f"{llm_pct:.1f}%")
-        
+
         # LLM costs if available
         if llm_stats.get("model_usage") == "available":
             cost_tracking = llm_stats.get("cost_tracking", {})
             total_cost = cost_tracking.get("total_cost", 0)
             if total_cost > 0:
                 qual_table.add_row("LLM Cost", f"${total_cost:.4f}")
-        
+
         self.console.print(qual_table)
 
-    def show_reports_generated(self, output_dir: Path, report_files: List[str]) -> None:
+    def show_llm_cost_summary(
+        self, cost_stats: dict[str, Any], identity_costs: Optional[dict[str, Any]] = None
+    ) -> None:
+        """
+        Display comprehensive LLM usage and cost summary.
+
+        WHY: LLM usage can be expensive and users need visibility into:
+        - Token consumption by component (identity analysis, qualitative analysis)
+        - Cost breakdown and budget utilization
+        - Optimization suggestions to reduce costs
+
+        DESIGN DECISION: Separate method from qualitative stats because:
+        - Cost tracking spans multiple components (identity + qualitative)
+        - Users need this summary even when qualitative analysis is disabled
+        - Provides actionable cost optimization suggestions
+
+        Args:
+            cost_stats: Cost statistics from qualitative analysis
+            identity_costs: Optional cost statistics from identity analysis
+        """
+        # Check if we have any cost data to display
+        has_qual_costs = cost_stats and cost_stats.get("total_cost", 0) > 0
+        has_identity_costs = identity_costs and identity_costs.get("total_cost", 0) > 0
+
+        if not (has_qual_costs or has_identity_costs):
+            return
+
+        self.console.print()
+
+        # Create main cost summary table
+        cost_table = Table(title="[bold]🤖 LLM Usage Summary[/bold]", box=box.ROUNDED)
+        cost_table.add_column("Component", style="cyan", width=20)
+        cost_table.add_column("Calls", style="yellow", width=8)
+        cost_table.add_column("Tokens", style="green", width=12)
+        cost_table.add_column("Cost", style="magenta", width=12)
+
+        total_calls = 0
+        total_tokens = 0
+        total_cost = 0.0
+        budget_info = {}
+
+        # Add identity analysis costs if available
+        if has_identity_costs:
+            identity_calls = identity_costs.get("total_calls", 0)
+            identity_tokens = identity_costs.get("total_tokens", 0)
+            identity_cost = identity_costs.get("total_cost", 0)
+
+            cost_table.add_row(
+                "Identity Analysis",
+                f"{identity_calls:,}",
+                f"{identity_tokens:,}",
+                f"${identity_cost:.4f}",
+            )
+
+            total_calls += identity_calls
+            total_tokens += identity_tokens
+            total_cost += identity_cost
+
+        # Add qualitative analysis costs if available
+        if has_qual_costs:
+            qual_calls = cost_stats.get("total_calls", 0)
+            qual_tokens = cost_stats.get("total_tokens", 0)
+            qual_cost = cost_stats.get("total_cost", 0)
+
+            cost_table.add_row(
+                "Qualitative Analysis", f"{qual_calls:,}", f"{qual_tokens:,}", f"${qual_cost:.4f}"
+            )
+
+            total_calls += qual_calls
+            total_tokens += qual_tokens
+            total_cost += qual_cost
+
+            # Extract budget information (assuming it's in qualitative cost stats)
+            budget_info = {
+                "daily_budget": cost_stats.get("daily_budget", 5.0),
+                "daily_spend": cost_stats.get("daily_spend", total_cost),
+                "remaining_budget": cost_stats.get("remaining_budget", 5.0 - total_cost),
+            }
+
+        # Add total row
+        if total_calls > 0:
+            cost_table.add_row(
+                "[bold]Total[/bold]",
+                f"[bold]{total_calls:,}[/bold]",
+                f"[bold]{total_tokens:,}[/bold]",
+                f"[bold]${total_cost:.4f}[/bold]",
+            )
+
+        self.console.print(cost_table)
+
+        # Display budget information if available
+        if budget_info:
+            daily_budget = budget_info.get("daily_budget", 5.0)
+            remaining = budget_info.get("remaining_budget", daily_budget - total_cost)
+            utilization = (total_cost / daily_budget) * 100 if daily_budget > 0 else 0
+
+            budget_text = f"Budget: ${daily_budget:.2f}, Remaining: ${remaining:.2f}, Utilization: {utilization:.1f}%"
+
+            # Color code based on utilization
+            if utilization >= 90:
+                budget_color = "red"
+            elif utilization >= 70:
+                budget_color = "yellow"
+            else:
+                budget_color = "green"
+
+            self.console.print(f"   [{budget_color}]💰 {budget_text}[/{budget_color}]")
+
+        # Display cost optimization suggestions if we have detailed stats
+        suggestions = []
+        if has_qual_costs and "model_usage" in cost_stats:
+            model_usage = cost_stats.get("model_usage", {})
+
+            # Check for expensive model usage
+            expensive_models = ["anthropic/claude-3-opus", "openai/gpt-4"]
+            expensive_cost = sum(
+                model_usage.get(model, {}).get("cost", 0) for model in expensive_models
+            )
+
+            if expensive_cost > total_cost * 0.3:
+                suggestions.append(
+                    "Consider using cheaper models (Claude Haiku, GPT-3.5) for routine tasks (save ~40%)"
+                )
+
+            # Check for free model opportunities
+            free_usage = model_usage.get("meta-llama/llama-3.1-8b-instruct:free", {}).get(
+                "cost", -1
+            )
+            if free_usage == 0 and total_cost > 0.01:  # If free models available but not used much
+                suggestions.append(
+                    "Increase usage of free Llama models for simple classification tasks"
+                )
+
+        # Budget-based suggestions
+        if budget_info:
+            utilization = (total_cost / budget_info.get("daily_budget", 5.0)) * 100
+            if utilization > 80:
+                suggestions.append(
+                    "Approaching daily budget limit - consider increasing NLP confidence threshold"
+                )
+
+        # Display suggestions
+        if suggestions:
+            self.console.print()
+            self.console.print("[bold]💡 Cost Optimization Suggestions:[/bold]")
+            for suggestion in suggestions:
+                self.console.print(f"   • {suggestion}")
+
+        self.console.print()
+
+    def show_reports_generated(self, output_dir: Path, report_files: list[str]) -> None:
         """
         Display generated reports with file paths.
-        
+
         WHY: Users need to know where their reports were saved and what files
         were generated. This provides clear next steps after analysis completes.
         """
@@ -282,14 +432,14 @@ class RichProgressDisplay:
             return
 
         self.console.print()
-        
+
         reports_panel = Panel(
             f"[bold green]✓[/bold green] Reports exported to: [cyan]{output_dir}[/cyan]",
             title="[bold]Generated Reports[/bold]",
             box=box.ROUNDED,
         )
         self.console.print(reports_panel)
-        
+
         # List individual report files
         for report_file in report_files:
             self.console.print(f"  • {report_file}")
@@ -297,7 +447,7 @@ class RichProgressDisplay:
     def show_error(self, error_message: str, show_debug_hint: bool = True) -> None:
         """
         Display error messages in a prominent format.
-        
+
         WHY: Errors need to be clearly visible and actionable. The panel format
         makes them stand out while providing helpful guidance.
         """
@@ -307,7 +457,7 @@ class RichProgressDisplay:
             box=box.HEAVY,
         )
         self.console.print(error_panel)
-        
+
         if show_debug_hint:
             self.console.print("\n[dim]💡 Run with --debug for detailed error information[/dim]")
 
@@ -327,7 +477,7 @@ class RichProgressDisplay:
     def print_status(self, message: str, status: str = "info") -> None:
         """
         Print a status message with appropriate styling.
-        
+
         WHY: Provides consistent status messaging throughout the analysis process.
         Different status types (info, success, warning, error) get appropriate styling.
         """
@@ -346,8 +496,8 @@ class RichProgressDisplay:
 def create_rich_display() -> RichProgressDisplay:
     """
     Factory function to create a Rich progress display.
-    
+
     WHY: Centralizes the creation of the display component and ensures
     consistent configuration across the application.
     """
-    return RichProgressDisplay()
+    return RichProgressDisplay()

gitflow_analytics/config/__init__.py

@@ -0,0 +1,43 @@
+"""Configuration management for GitFlow Analytics.
+
+This module provides configuration loading, validation, and management
+for the GitFlow Analytics tool. It has been refactored into focused
+sub-modules while maintaining backward compatibility.
+"""
+
+# Re-export main interfaces for backward compatibility
+from .loader import ConfigLoader
+from .schema import (
+    AnalysisConfig,
+    BranchAnalysisConfig,
+    CacheConfig,
+    CommitClassificationConfig,
+    Config,
+    GitHubConfig,
+    JIRAConfig,
+    JIRAIntegrationConfig,
+    LLMClassificationConfig,
+    MLCategorization,
+    OutputConfig,
+    PMIntegrationConfig,
+    PMPlatformConfig,
+    RepositoryConfig,
+)
+
+__all__ = [
+    "ConfigLoader",
+    "Config",
+    "RepositoryConfig",
+    "GitHubConfig",
+    "AnalysisConfig",
+    "OutputConfig",
+    "CacheConfig",
+    "JIRAConfig",
+    "JIRAIntegrationConfig",
+    "PMPlatformConfig",
+    "PMIntegrationConfig",
+    "MLCategorization",
+    "LLMClassificationConfig",
+    "CommitClassificationConfig",
+    "BranchAnalysisConfig",
+]