gitflow-analytics 3.4.7__py3-none-any.whl → 3.5.2__py3-none-any.whl

gitflow_analytics/_version.py

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

gitflow_analytics/cli.py

@@ -342,11 +342,28 @@ def cli(ctx: click.Context) -> None:
     \b
     COMMANDS:
       analyze    Analyze repositories and generate reports (default)
+      install    Interactive installation wizard
+      run        Interactive launcher with preferences
+      aliases    Generate developer identity aliases using LLM
       identities Manage developer identity resolution
       train      Train ML models for commit classification
       fetch      Fetch external data (GitHub PRs, PM tickets)
       help       Show detailed help and documentation
 
+    \b
+    EXAMPLES:
+      # Interactive installation
+      gitflow-analytics install
+
+      # Interactive launcher
+      gitflow-analytics run -c config.yaml
+
+      # Generate developer aliases
+      gitflow-analytics aliases -c config.yaml --apply
+
+      # Run analysis
+      gitflow-analytics -c config.yaml --weeks 4
+
     \b
     For detailed command help: gitflow-analytics COMMAND --help
     For documentation: https://github.com/yourusername/gitflow-analytics
@@ -4857,6 +4874,342 @@ def identities(config: Path, weeks: int, apply: bool) -> None:
         sys.exit(1)
 
 
+@cli.command(name="aliases")
+@click.option(
+    "--config",
+    "-c",
+    type=click.Path(exists=True, path_type=Path),
+    required=True,
+    help="Path to configuration file",
+)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(path_type=Path),
+    help="Output path for aliases.yaml (default: same dir as config)",
+)
+@click.option(
+    "--confidence-threshold",
+    type=float,
+    default=0.9,
+    help="Minimum confidence threshold for LLM matches (default: 0.9)",
+)
+@click.option(
+    "--apply", is_flag=True, help="Automatically update config to use generated aliases file"
+)
+@click.option(
+    "--weeks", type=int, default=12, help="Number of weeks of history to analyze (default: 12)"
+)
+def aliases_command(
+    config: Path,
+    output: Optional[Path],
+    confidence_threshold: float,
+    apply: bool,
+    weeks: int,
+) -> None:
+    """Generate developer identity aliases using LLM analysis.
+
+    \b
+    This command analyzes commit history and uses LLM to identify
+    developer aliases (same person with different email addresses).
+    Results are saved to aliases.yaml which can be shared across
+    multiple config files.
+
+    \b
+    EXAMPLES:
+        # Generate aliases and review
+        gitflow-analytics aliases -c config.yaml
+
+        # Generate and apply automatically
+        gitflow-analytics aliases -c config.yaml --apply
+
+        # Save to specific location
+        gitflow-analytics aliases -c config.yaml -o ~/shared/aliases.yaml
+
+        # Use longer history for better accuracy
+        gitflow-analytics aliases -c config.yaml --weeks 24
+
+    \b
+    CONFIGURATION:
+        Aliases are saved to aliases.yaml and can be referenced in
+        multiple config files for consistent identity resolution.
+    """
+    try:
+        from .config.aliases import AliasesManager, DeveloperAlias
+        from .identity_llm.analyzer import LLMIdentityAnalyzer
+
+        # Load configuration
+        click.echo(f"\n📋 Loading configuration from {config}...")
+        cfg = ConfigLoader.load(config)
+
+        # Determine output path
+        if not output:
+            output = config.parent / "aliases.yaml"
+
+        click.echo(f"🔍 Analyzing developer identities (last {weeks} weeks)")
+        click.echo(f"📊 Confidence threshold: {confidence_threshold:.0%}")
+        click.echo(f"💾 Output: {output}\n")
+
+        # Set up date range
+        end_date = datetime.now(timezone.utc)
+        start_date = end_date - timedelta(weeks=weeks)
+
+        # Analyze repositories to collect commits
+        click.echo("📥 Fetching commit history...\n")
+        cache = GitAnalysisCache(cfg.cache.directory)
+
+        # Prepare ML categorization config for analyzer
+        ml_config = None
+        if hasattr(cfg.analysis, "ml_categorization"):
+            ml_config = {
+                "enabled": cfg.analysis.ml_categorization.enabled,
+                "min_confidence": cfg.analysis.ml_categorization.min_confidence,
+                "semantic_weight": cfg.analysis.ml_categorization.semantic_weight,
+                "file_pattern_weight": cfg.analysis.ml_categorization.file_pattern_weight,
+                "hybrid_threshold": cfg.analysis.ml_categorization.hybrid_threshold,
+                "cache_duration_days": cfg.analysis.ml_categorization.cache_duration_days,
+                "batch_size": cfg.analysis.ml_categorization.batch_size,
+                "enable_caching": cfg.analysis.ml_categorization.enable_caching,
+                "spacy_model": cfg.analysis.ml_categorization.spacy_model,
+            }
+
+        # LLM classification configuration
+        llm_config = {
+            "enabled": cfg.analysis.llm_classification.enabled,
+            "api_key": cfg.analysis.llm_classification.api_key,
+            "model": cfg.analysis.llm_classification.model,
+            "confidence_threshold": cfg.analysis.llm_classification.confidence_threshold,
+            "max_tokens": cfg.analysis.llm_classification.max_tokens,
+            "temperature": cfg.analysis.llm_classification.temperature,
+            "timeout_seconds": cfg.analysis.llm_classification.timeout_seconds,
+            "cache_duration_days": cfg.analysis.llm_classification.cache_duration_days,
+            "enable_caching": cfg.analysis.llm_classification.enable_caching,
+            "max_daily_requests": cfg.analysis.llm_classification.max_daily_requests,
+            "domain_terms": cfg.analysis.llm_classification.domain_terms,
+        }
+
+        # Configure branch analysis
+        branch_analysis_config = {
+            "strategy": cfg.analysis.branch_analysis.strategy,
+            "max_branches_per_repo": cfg.analysis.branch_analysis.max_branches_per_repo,
+            "active_days_threshold": cfg.analysis.branch_analysis.active_days_threshold,
+            "include_main_branches": cfg.analysis.branch_analysis.include_main_branches,
+            "always_include_patterns": cfg.analysis.branch_analysis.always_include_patterns,
+            "always_exclude_patterns": cfg.analysis.branch_analysis.always_exclude_patterns,
+            "enable_progress_logging": cfg.analysis.branch_analysis.enable_progress_logging,
+            "branch_commit_limit": cfg.analysis.branch_analysis.branch_commit_limit,
+        }
+
+        analyzer = GitAnalyzer(
+            cache,
+            branch_mapping_rules=cfg.analysis.branch_mapping_rules,
+            allowed_ticket_platforms=getattr(
+                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
+            ),
+            exclude_paths=cfg.analysis.exclude_paths,
+            story_point_patterns=cfg.analysis.story_point_patterns,
+            ml_categorization_config=ml_config,
+            llm_config=llm_config,
+            branch_analysis_config=branch_analysis_config,
+        )
+
+        all_commits = []
+
+        # Get repositories to analyze
+        repositories = cfg.repositories if cfg.repositories else []
+
+        if not repositories:
+            click.echo("❌ No repositories configured", err=True)
+            sys.exit(1)
+
+        # Collect commits from all repositories
+        with click.progressbar(
+            repositories,
+            label="Analyzing repositories",
+            item_show_func=lambda r: r.name if r else "",
+        ) as repos:
+            for repo_config in repos:
+                try:
+                    if not repo_config.path.exists():
+                        continue
+
+                    # Fetch commits
+                    repo_commits = analyzer.analyze_repository(
+                        repo_config.path, start_date=start_date, branch=repo_config.branch
+                    )
+
+                    if repo_commits:
+                        all_commits.extend(repo_commits)
+
+                except Exception as e:
+                    click.echo(f"\n⚠️  Warning: Failed to analyze repository: {e}", err=True)
+                    continue
+
+        click.echo(f"\n✅ Collected {len(all_commits)} commits\n")
+
+        if not all_commits:
+            click.echo("❌ No commits found to analyze", err=True)
+            sys.exit(1)
+
+        # Initialize LLM identity analyzer
+        click.echo("🤖 Running LLM identity analysis...\n")
+
+        # Get OpenRouter API key from config
+        api_key = None
+        if cfg.chatgpt and cfg.chatgpt.api_key:
+            # Resolve environment variable if needed
+            api_key_value = cfg.chatgpt.api_key
+            if api_key_value.startswith("${") and api_key_value.endswith("}"):
+                var_name = api_key_value[2:-1]
+                api_key = os.getenv(var_name)
+            else:
+                api_key = api_key_value
+
+        if not api_key:
+            click.echo(
+                "⚠️  No OpenRouter API key configured - using heuristic analysis only", err=True
+            )
+
+        llm_analyzer = LLMIdentityAnalyzer(
+            api_key=api_key, confidence_threshold=confidence_threshold
+        )
+
+        # Run analysis
+        result = llm_analyzer.analyze_identities(all_commits)
+
+        click.echo("✅ Analysis complete:")
+        click.echo(f"   - Found {len(result.clusters)} identity clusters")
+        click.echo(f"   - {len(result.unresolved_identities)} unresolved identities")
+        click.echo(f"   - Method: {result.analysis_metadata.get('analysis_method', 'unknown')}\n")
+
+        # Create aliases manager and add clusters
+        aliases_mgr = AliasesManager(output)
+
+        # Load existing aliases if file exists
+        if output.exists():
+            click.echo(f"📂 Loading existing aliases from {output}...")
+            aliases_mgr.load()
+            existing_count = len(aliases_mgr.aliases)
+            click.echo(f"   Found {existing_count} existing aliases\n")
+
+        # Add new clusters
+        new_count = 0
+        updated_count = 0
+
+        for cluster in result.clusters:
+            # Check if this is a new or updated alias
+            existing = aliases_mgr.get_alias(cluster.canonical_email)
+
+            alias = DeveloperAlias(
+                name=cluster.preferred_display_name or cluster.canonical_name,
+                primary_email=cluster.canonical_email,
+                aliases=[a.email for a in cluster.aliases],
+                confidence=cluster.confidence,
+                reasoning=(
+                    cluster.reasoning[:200] if cluster.reasoning else ""
+                ),  # Truncate for readability
+            )
+
+            if existing:
+                updated_count += 1
+            else:
+                new_count += 1
+
+            aliases_mgr.add_alias(alias)
+
+        # Save aliases
+        click.echo("💾 Saving aliases...\n")
+        aliases_mgr.save()
+
+        click.echo(f"✅ Saved to {output}")
+        click.echo(f"   - New aliases: {new_count}")
+        click.echo(f"   - Updated aliases: {updated_count}")
+        click.echo(f"   - Total aliases: {len(aliases_mgr.aliases)}\n")
+
+        # Display summary
+        if aliases_mgr.aliases:
+            click.echo("📋 Generated Aliases:\n")
+
+            for alias in sorted(aliases_mgr.aliases, key=lambda a: a.primary_email):
+                name_display = (
+                    f"{alias.name} <{alias.primary_email}>" if alias.name else alias.primary_email
+                )
+                click.echo(f"  • {name_display}")
+
+                if alias.aliases:
+                    for alias_email in alias.aliases:
+                        click.echo(f"    → {alias_email}")
+
+                if alias.confidence < 1.0:
+                    confidence_color = (
+                        "green"
+                        if alias.confidence >= 0.9
+                        else "yellow" if alias.confidence >= 0.8 else "red"
+                    )
+                    click.echo("    Confidence: ", nl=False)
+                    click.secho(f"{alias.confidence:.0%}", fg=confidence_color)
+
+                click.echo()  # Blank line between aliases
+
+        # Apply to config if requested
+        if apply:
+            click.echo(f"🔄 Updating {config} to reference aliases file...\n")
+
+            # Read current config
+            with open(config) as f:
+                config_data = yaml.safe_load(f)
+
+            # Ensure analysis section exists
+            if "analysis" not in config_data:
+                config_data["analysis"] = {}
+
+            if "identity" not in config_data["analysis"]:
+                config_data["analysis"]["identity"] = {}
+
+            # Calculate relative path from config to aliases file
+            try:
+                rel_path = output.relative_to(config.parent)
+                config_data["analysis"]["identity"]["aliases_file"] = str(rel_path)
+            except ValueError:
+                # Not relative, use absolute
+                config_data["analysis"]["identity"]["aliases_file"] = str(output)
+
+            # Remove manual_mappings if present (now in aliases file)
+            if "manual_identity_mappings" in config_data["analysis"].get("identity", {}):
+                del config_data["analysis"]["identity"]["manual_identity_mappings"]
+                click.echo("   Removed inline manual_identity_mappings (now in aliases file)")
+
+            # Save updated config
+            with open(config, "w") as f:
+                yaml.dump(config_data, f, default_flow_style=False, sort_keys=False)
+
+            click.echo(f"✅ Updated {config}")
+            click.echo(
+                f"   Added: analysis.identity.aliases_file = "
+                f"{config_data['analysis']['identity']['aliases_file']}\n"
+            )
+
+        # Summary and next steps
+        click.echo("✨ Identity alias generation complete!\n")
+
+        if not apply:
+            click.echo("💡 Next steps:")
+            click.echo(f"   1. Review the aliases in {output}")
+            click.echo("   2. Update your config.yaml to reference the aliases file:")
+            click.echo("      analysis:")
+            click.echo("        identity:")
+            click.echo(f"          aliases_file: {output.name}")
+            click.echo("   3. Or run with --apply flag to update automatically\n")
+
+    except Exception as e:
+        click.echo(f"\n❌ Error generating aliases: {e}", err=True)
+        import traceback
+
+        if os.getenv("GITFLOW_DEBUG"):
+            traceback.print_exc()
+        sys.exit(1)
+
+
 @cli.command()
 @click.option(
     "--config",

gitflow_analytics/cli_wizards/install_wizard.py

@@ -4,10 +4,12 @@ This module provides a user-friendly installation experience with credential val
 and comprehensive configuration generation.
 """
 
+import getpass
 import logging
 import os
 import stat
 import subprocess
+import sys
 import time
 from datetime import datetime
 from pathlib import Path
@@ -27,6 +29,55 @@ logger = logging.getLogger(__name__)
 class InstallWizard:
     """Interactive installation wizard for GitFlow Analytics setup."""
 
+    # Installation profiles
+    PROFILES = {
+        "1": {
+            "name": "Standard",
+            "description": "GitHub + JIRA + AI (Full featured)",
+            "github": True,
+            "repositories": "manual",
+            "jira": True,
+            "ai": True,
+            "analysis": True,
+        },
+        "2": {
+            "name": "GitHub Only",
+            "description": "GitHub integration without PM tools",
+            "github": True,
+            "repositories": "manual",
+            "jira": False,
+            "ai": False,
+            "analysis": True,
+        },
+        "3": {
+            "name": "Organization Mode",
+            "description": "Auto-discover repos from GitHub org",
+            "github": True,
+            "repositories": "organization",
+            "jira": True,
+            "ai": True,
+            "analysis": True,
+        },
+        "4": {
+            "name": "Minimal",
+            "description": "Local repos only, no integrations",
+            "github": False,
+            "repositories": "local",
+            "jira": False,
+            "ai": False,
+            "analysis": True,
+        },
+        "5": {
+            "name": "Custom",
+            "description": "Configure everything manually",
+            "github": None,  # Ask user
+            "repositories": None,  # Ask user
+            "jira": None,  # Ask user
+            "ai": None,  # Ask user
+            "analysis": True,
+        },
+    }
+
     def __init__(self, output_dir: Path, skip_validation: bool = False):
         """Initialize the installation wizard.
 
@@ -38,10 +89,56 @@ class InstallWizard:
         self.skip_validation = skip_validation
         self.config_data = {}
         self.env_data = {}
+        self.profile = None  # Selected installation profile
 
         # Ensure output directory exists
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
+    def _is_interactive(self) -> bool:
+        """Check if running in interactive terminal.
+
+        Returns:
+            True if stdin and stdout are connected to a TTY
+        """
+        return sys.stdin.isatty() and sys.stdout.isatty()
+
+    def _get_password(self, prompt: str, field_name: str = "password") -> str:
+        """Get password input with non-interactive detection.
+
+        Args:
+            prompt: Prompt text to display
+            field_name: Field name for error messages
+
+        Returns:
+            Password string
+        """
+        if self._is_interactive():
+            return getpass.getpass(prompt)
+        else:
+            click.echo(f"⚠️  Non-interactive mode detected - {field_name} will be visible", err=True)
+            return click.prompt(prompt, hide_input=False)
+
+    def _select_profile(self) -> dict:
+        """Let user select installation profile."""
+        click.echo("\n📋 Installation Profiles")
+        click.echo("=" * 60 + "\n")
+
+        for key, profile in self.PROFILES.items():
+            click.echo(f"  {key}. {profile['name']}")
+            click.echo(f"     {profile['description']}")
+            click.echo()
+
+        profile_choice = click.prompt(
+            "Select installation profile",
+            type=click.Choice(list(self.PROFILES.keys())),
+            default="1",
+        )
+
+        selected = self.PROFILES[profile_choice].copy()
+        click.echo(f"\n✅ Selected: {selected['name']}\n")
+
+        return selected
+
     def run(self) -> bool:
         """Run the installation wizard.
 
@@ -53,22 +150,48 @@ class InstallWizard:
             click.echo("=" * 50)
             click.echo()
 
-            # Step 1: GitHub Setup (REQUIRED)
-            if not self._setup_github():
-                return False
+            # Step 0: Select profile
+            self.profile = self._select_profile()
 
-            # Step 2: Repository Configuration
-            if not self._setup_repositories():
+            # Step 1: GitHub Setup (conditional based on profile)
+            if self.profile["github"] is not False:
+                if not self._setup_github():
+                    return False
+            else:
+                # Minimal mode - no GitHub
+                pass
+
+            # Step 2: Repository Configuration (based on profile)
+            if self.profile["repositories"] == "organization":
+                # Organization mode - already handled in GitHub setup
+                pass
+            elif self.profile["repositories"] == "manual":
+                if not self._setup_repositories():
+                    return False
+            elif self.profile["repositories"] == "local":
+                if not self._setup_local_repositories():
+                    return False
+            elif self.profile["repositories"] is None and not self._setup_repositories():
+                # Custom mode - ask user
                 return False
 
-            # Step 3: JIRA Setup (OPTIONAL)
-            self._setup_jira()
+            # Step 3: JIRA Setup (conditional based on profile)
+            if self.profile["jira"]:
+                self._setup_jira()
+            elif self.profile["jira"] is None:
+                # Custom mode - ask user
+                self._setup_jira()
 
-            # Step 4: OpenRouter/ChatGPT Setup (OPTIONAL)
-            self._setup_ai()
+            # Step 4: OpenRouter/ChatGPT Setup (conditional based on profile)
+            if self.profile["ai"]:
+                self._setup_ai()
+            elif self.profile["ai"] is None:
+                # Custom mode - ask user
+                self._setup_ai()
 
             # Step 5: Analysis Configuration
-            self._setup_analysis()
+            if self.profile["analysis"]:
+                self._setup_analysis()
 
             # Step 6: Generate Files
             if not self._generate_files():
@@ -123,10 +246,8 @@ class InstallWizard:
                 click.echo(f"⏳ Waiting {delay} seconds before retry...")
                 time.sleep(delay)
 
-            token = click.prompt(
-                "Enter GitHub Personal Access Token",
-                hide_input=True,
-                type=str,
+            token = self._get_password(
+                "Enter GitHub Personal Access Token: ", "GitHub token"
             ).strip()
 
             if not token:
@@ -319,6 +440,61 @@ class InstallWizard:
         self.config_data["github"]["repositories"] = repositories
         return True
 
+    def _setup_local_repositories(self) -> bool:
+        """Setup local repository paths (no GitHub).
+
+        Returns:
+            True if setup successful, False otherwise
+        """
+        click.echo("\n📦 Local Repository Mode")
+        click.echo("Specify local Git repository paths to analyze.")
+        click.echo()
+
+        repositories = []
+        while True:
+            repo_path_str = click.prompt(
+                "Enter repository path (or press Enter to finish)",
+                type=str,
+                default="",
+                show_default=False,
+            ).strip()
+
+            if not repo_path_str:
+                if not repositories:
+                    click.echo("❌ At least one repository is required")
+                    continue
+                break
+
+            # Validate path is safe
+            path_obj = self._validate_directory_path(repo_path_str, "Repository path")
+            if path_obj is None:
+                continue  # Re-prompt
+
+            if not path_obj.exists():
+                click.echo(f"⚠️  Path does not exist: {path_obj}")
+                if not click.confirm("Add anyway?", default=False):
+                    continue
+
+            # Check if it's a git repository
+            if (path_obj / ".git").exists():
+                click.echo(f"✅ Valid git repository: {path_obj}")
+            else:
+                click.echo(f"⚠️  Not a git repository: {path_obj}")
+                if not click.confirm("Add anyway?", default=False):
+                    continue
+
+            repo_name = click.prompt("Repository name", default=path_obj.name)
+
+            repositories.append({"name": repo_name, "path": str(path_obj)})
+            click.echo(f"Added repository #{len(repositories)}\n")
+
+            if not click.confirm("Add another repository?", default=False):
+                break
+
+        # Store repositories directly without GitHub section
+        self.config_data["repositories"] = repositories
+        return True
+
     def _setup_jira(self) -> None:
         """Setup JIRA integration (optional)."""
         click.echo("\n📋 Step 3: JIRA Setup (OPTIONAL)")
@@ -347,7 +523,7 @@ class InstallWizard:
 
             base_url = click.prompt("JIRA base URL", type=str).strip()
             access_user = click.prompt("JIRA email", type=str).strip()
-            access_token = click.prompt("JIRA API token", hide_input=True, type=str).strip()
+            access_token = self._get_password("JIRA API token: ", "JIRA token").strip()
 
             if not all([base_url, access_user, access_token]):
                 click.echo("❌ All JIRA fields are required")
@@ -550,7 +726,7 @@ class InstallWizard:
                 click.echo(f"⏳ Waiting {delay} seconds before retry...")
                 time.sleep(delay)
 
-            api_key = click.prompt("Enter API key", hide_input=True, type=str).strip()
+            api_key = self._get_password("Enter API key: ", "AI API key").strip()
 
             if not api_key:
                 click.echo("❌ API key cannot be empty")
@@ -700,6 +876,75 @@ class InstallWizard:
         self.config_data["analysis"]["output_directory"] = output_dir
         self.config_data["analysis"]["cache_directory"] = cache_dir
 
+        # NEW: Aliases configuration
+        click.echo("\n🔗 Developer Identity Aliases")
+        click.echo("-" * 40 + "\n")
+
+        click.echo("Aliases consolidate multiple email addresses for the same developer.")
+        click.echo("You can use a shared aliases.yaml file across multiple configs.\n")
+
+        use_aliases = click.confirm("Configure aliases file?", default=True)
+
+        if use_aliases:
+            aliases_options = [
+                "1. Create new aliases.yaml in this directory",
+                "2. Use existing shared aliases file",
+                "3. Generate aliases using LLM (after installation)",
+            ]
+
+            click.echo("\nOptions:")
+            for option in aliases_options:
+                click.echo(f"  {option}")
+
+            aliases_choice = click.prompt(
+                "\nSelect option", type=click.Choice(["1", "2", "3"]), default="1"
+            )
+
+            if aliases_choice == "1":
+                # Create new aliases file
+                aliases_path = "aliases.yaml"
+
+                # Ensure analysis.identity section exists
+                if "identity" not in self.config_data.get("analysis", {}):
+                    if "analysis" not in self.config_data:
+                        self.config_data["analysis"] = {}
+                    self.config_data["analysis"]["identity"] = {}
+
+                self.config_data["analysis"]["identity"]["aliases_file"] = aliases_path
+
+                # Create empty aliases file
+                from ..config.aliases import AliasesManager
+
+                aliases_full_path = self.output_dir / aliases_path
+                aliases_mgr = AliasesManager(aliases_full_path)
+                aliases_mgr.save()  # Creates empty file with comments
+
+                click.echo(f"\n✅ Created {aliases_path}")
+                click.echo("   Generate aliases after installation with:")
+                click.echo("   gitflow-analytics aliases -c config.yaml --apply\n")
+
+            elif aliases_choice == "2":
+                # Use existing file
+                aliases_path = click.prompt(
+                    "Path to aliases.yaml (relative to config)", default="../shared/aliases.yaml"
+                )
+
+                # Ensure analysis.identity section exists
+                if "identity" not in self.config_data.get("analysis", {}):
+                    if "analysis" not in self.config_data:
+                        self.config_data["analysis"] = {}
+                    self.config_data["analysis"]["identity"] = {}
+
+                self.config_data["analysis"]["identity"]["aliases_file"] = aliases_path
+
+                click.echo(f"\n✅ Configured to use: {aliases_path}\n")
+
+            else:  # choice == "3"
+                # Will generate after installation
+                click.echo("\n💡 After installation, run:")
+                click.echo("   gitflow-analytics aliases -c config.yaml --apply")
+                click.echo("   This will analyze your repos and generate aliases automatically.\n")
+
     def _clear_sensitive_data(self) -> None:
         """Clear sensitive data from memory after use."""
         sensitive_keys = ["TOKEN", "KEY", "PASSWORD", "SECRET"]
@@ -852,7 +1097,7 @@ class InstallWizard:
             from ..config import ConfigLoader
 
             ConfigLoader.load(config_path)
-            click.echo("✅ Configuration loaded successfully")
+            click.echo("✅ Configuration validated successfully")
 
             # Offer to run first analysis
             if click.confirm("\nRun initial analysis now?", default=False):
@@ -861,7 +1106,7 @@ class InstallWizard:
             return True
 
         except Exception as e:
-            click.echo("⚠️  Configuration validation warning occurred")
+            click.echo(f"❌ Configuration validation failed: {e}", err=True)
             click.echo("You may need to adjust the configuration manually.")
             logger.error(f"Configuration validation error type: {type(e).__name__}")
             return True  # Don't fail installation on validation error

gitflow_analytics/cli_wizards/run_launcher.py

@@ -139,13 +139,104 @@ class InteractiveLauncher:
             logger.warning(f"Could not load preferences: {e}")
             self.preferences = {}
 
+    def _get_available_repositories(self) -> list[str]:
+        """Get list of available repositories from config.
+
+        Supports both explicit repository configuration and organization mode.
+
+        Returns:
+            List of repository names
+        """
+        repos = []
+
+        # Check for organization mode
+        try:
+            with open(self.config_path) as f:
+                config_data = yaml.safe_load(f)
+
+            github_config = config_data.get("github", {})
+
+            if github_config.get("organization"):
+                # Organization mode - fetch repos from GitHub
+                token = self._resolve_env_var(github_config.get("token", ""))
+                if token:
+                    from github import Github
+
+                    try:
+                        gh = Github(token)
+                        org_name = github_config["organization"]
+                        org = gh.get_organization(org_name)
+
+                        # Get all non-archived repos
+                        for repo in org.get_repos(type="all"):
+                            if not repo.archived:
+                                repos.append(repo.full_name)
+
+                        if repos:
+                            click.echo(
+                                f"🔍 Discovered {len(repos)} repositories from organization '{org_name}'\n"
+                            )
+                    except Exception as e:
+                        click.echo(
+                            f"⚠️  Could not fetch organization repos: {type(e).__name__}", err=True
+                        )
+                        logger.error(f"Organization repo fetch error: {e}")
+
+            # Fall back to explicit repositories
+            if not repos and self.config and self.config.repositories:
+                repos = [repo.path.name for repo in self.config.repositories]
+
+        except Exception as e:
+            logger.warning(f"Could not determine repositories: {e}")
+            # Final fallback
+            if self.config and self.config.repositories:
+                repos = [repo.path.name for repo in self.config.repositories]
+
+        return repos
+
+    def _resolve_env_var(self, value: str) -> str:
+        """Resolve environment variable in config value.
+
+        Args:
+            value: Config value that may contain ${VAR_NAME}
+
+        Returns:
+            Resolved value
+        """
+        import os
+        import re
+
+        # Load .env file if it exists next to config
+        env_path = self.config_path.parent / ".env"
+        if env_path.exists():
+            try:
+                with open(env_path) as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith("#") and "=" in line:
+                            key, val = line.split("=", 1)
+                            os.environ.setdefault(key.strip(), val.strip())
+            except Exception as e:
+                logger.debug(f"Could not load .env: {e}")
+
+        # Resolve ${VAR_NAME} patterns
+        pattern = r"\$\{([^}]+)\}"
+
+        def replace_var(match):
+            var_name = match.group(1)
+            return os.environ.get(var_name, match.group(0))
+
+        return re.sub(pattern, replace_var, value)
+
     def _select_repositories(self) -> list[str]:
         """Interactive repository selection with multi-select.
 
         Returns:
             List of selected repository names.
         """
-        if not self.config or not self.config.repositories:
+        # Check for organization mode first
+        repos = self._get_available_repositories()
+        if not repos:
             click.echo("❌ No repositories configured!")
             return []
 
@@ -155,10 +246,9 @@ class InteractiveLauncher:
         last_selected = self.preferences.get("last_selected_repos", [])
 
         # Display repositories with numbering and selection status
-        for i, repo in enumerate(self.config.repositories, 1):
-            repo_name = repo.path.name
+        for i, repo_name in enumerate(repos, 1):
             status = "✓" if repo_name in last_selected else " "
-            click.echo(f"   [{status}] {i}. {repo_name} ({repo.path})")
+            click.echo(f"   [{status}] {i}. {repo_name}")
 
         # Get user selection
         click.echo("\n📝 Select repositories:")
@@ -169,7 +259,7 @@ class InteractiveLauncher:
         selection = click.prompt("Selection", default="", show_default=False).strip()
 
         if selection.lower() == "all":
-            selected = [repo.path.name for repo in self.config.repositories]
+            selected = repos
             click.echo(f"✅ Selected all {len(selected)} repositories\n")
             return selected
         elif not selection and last_selected:
@@ -177,7 +267,7 @@ class InteractiveLauncher:
             return last_selected
         elif not selection:
             # Default to all repos if no previous selection
-            selected = [repo.path.name for repo in self.config.repositories]
+            selected = repos
             click.echo(f"✅ Selected all {len(selected)} repositories (default)\n")
             return selected
         else:
@@ -186,8 +276,8 @@ class InteractiveLauncher:
                 indices = [int(x.strip()) for x in selection.split(",")]
                 selected = []
                 for i in indices:
-                    if 1 <= i <= len(self.config.repositories):
-                        selected.append(self.config.repositories[i - 1].path.name)
+                    if 1 <= i <= len(repos):
+                        selected.append(repos[i - 1])
                     else:
                         click.echo(f"⚠️  Invalid index: {i} (ignored)")
 

gitflow_analytics/config/__init__.py

@@ -6,6 +6,7 @@ sub-modules while maintaining backward compatibility.
 """
 
 # Re-export main interfaces for backward compatibility
+from .aliases import AliasesManager, DeveloperAlias
 from .loader import ConfigLoader
 from .schema import (
     AnalysisConfig,
@@ -40,4 +41,6 @@ __all__ = [
     "LLMClassificationConfig",
     "CommitClassificationConfig",
     "BranchAnalysisConfig",
+    "AliasesManager",
+    "DeveloperAlias",
 ]

gitflow_analytics/config/aliases.py

@@ -0,0 +1,306 @@
+"""Developer identity aliases management.
+
+This module provides functionality for managing developer identity aliases
+across multiple configuration files. Aliases can be shared to maintain
+consistent identity resolution across different analysis configurations.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeveloperAlias:
+    """A developer alias configuration.
+
+    Represents a single developer with their primary email and all known aliases.
+    Supports both manual and LLM-generated alias configurations with confidence scores.
+    """
+
+    primary_email: str
+    aliases: list[str] = field(default_factory=list)
+    name: Optional[str] = None
+    confidence: float = 1.0
+    reasoning: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary format for YAML serialization.
+
+        Returns:
+            Dictionary representation with optional fields omitted if not set
+        """
+        result: dict[str, Any] = {
+            "primary_email": self.primary_email,
+            "aliases": self.aliases,
+        }
+
+        if self.name:
+            result["name"] = self.name
+
+        # Only include confidence and reasoning for LLM-generated aliases
+        if self.confidence < 1.0:
+            result["confidence"] = round(self.confidence, 2)
+            if self.reasoning:
+                result["reasoning"] = self.reasoning
+
+        return result
+
+
+class AliasesManager:
+    """Manages developer identity aliases.
+
+    Provides functionality to load, save, and manipulate developer identity aliases.
+    Supports both manual aliases (confidence=1.0) and LLM-generated aliases with
+    confidence scores and reasoning.
+
+    Example:
+        >>> manager = AliasesManager(Path("aliases.yaml"))
+        >>> manager.load()
+        >>> manager.add_alias(DeveloperAlias(
+        ...     primary_email="john@company.com",
+        ...     aliases=["jdoe@gmail.com"],
+        ...     name="John Doe"
+        ... ))
+        >>> manager.save()
+    """
+
+    def __init__(self, aliases_path: Optional[Path] = None):
+        """Initialize aliases manager.
+
+        Args:
+            aliases_path: Path to aliases.yaml file. If None, aliases must be
+                         added programmatically or loaded from another source.
+        """
+        self.aliases_path = aliases_path
+        self.aliases: list[DeveloperAlias] = []
+
+        if aliases_path and aliases_path.exists():
+            self.load()
+
+    def load(self) -> None:
+        """Load aliases from file.
+
+        Loads developer aliases from the configured YAML file. If the file
+        doesn't exist or is empty, initializes with an empty alias list.
+
+        Raises:
+            yaml.YAMLError: If the YAML file is malformed
+        """
+        if not self.aliases_path or not self.aliases_path.exists():
+            logger.debug("No aliases file found or path not set")
+            return
+
+        try:
+            with open(self.aliases_path) as f:
+                data = yaml.safe_load(f) or {}
+
+            self.aliases = []
+            for alias_data in data.get("developer_aliases", []):
+                # Support both 'primary_email' (new) and 'canonical_email' (old)
+                primary_email = alias_data.get("primary_email") or alias_data.get("canonical_email")
+
+                if not primary_email:
+                    logger.warning(f"Skipping alias entry without primary_email: {alias_data}")
+                    continue
+
+                self.aliases.append(
+                    DeveloperAlias(
+                        primary_email=primary_email,
+                        aliases=alias_data.get("aliases", []),
+                        name=alias_data.get("name"),
+                        confidence=alias_data.get("confidence", 1.0),
+                        reasoning=alias_data.get("reasoning", ""),
+                    )
+                )
+
+            logger.info(f"Loaded {len(self.aliases)} developer aliases from {self.aliases_path}")
+
+        except yaml.YAMLError as e:
+            logger.error(f"Error parsing aliases file {self.aliases_path}: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"Error loading aliases file {self.aliases_path}: {e}")
+            raise
+
+    def save(self) -> None:
+        """Save aliases to file.
+
+        Writes all developer aliases to the configured YAML file with proper
+        formatting and comments. Creates the parent directory if it doesn't exist.
+
+        Raises:
+            OSError: If file cannot be written
+        """
+        if not self.aliases_path:
+            logger.warning("No aliases path configured, cannot save")
+            return
+
+        # Ensure directory exists
+        self.aliases_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # Build data structure with comments
+            data = {
+                "# Developer Identity Aliases": None,
+                "# Generated by GitFlow Analytics": None,
+                "# Share this file across multiple config files": None,
+                "# Each alias maps multiple email addresses to a single developer": None,
+                "developer_aliases": [alias.to_dict() for alias in self.aliases],
+            }
+
+            with open(self.aliases_path, "w") as f:
+                # Custom YAML dump to preserve comments
+                f.write("# Developer Identity Aliases\n")
+                f.write("# Generated by GitFlow Analytics\n")
+                f.write("# Share this file across multiple config files\n")
+                f.write("# Each alias maps multiple email addresses to a single developer\n\n")
+
+                # Write the aliases list
+                yaml.dump(
+                    {"developer_aliases": data["developer_aliases"]},
+                    f,
+                    default_flow_style=False,
+                    sort_keys=False,
+                    allow_unicode=True,
+                )
+
+            logger.info(f"Saved {len(self.aliases)} developer aliases to {self.aliases_path}")
+
+        except Exception as e:
+            logger.error(f"Error saving aliases file {self.aliases_path}: {e}")
+            raise
+
+    def add_alias(self, alias: DeveloperAlias) -> None:
+        """Add or update a developer alias.
+
+        If an alias with the same primary email already exists, it will be replaced.
+        This ensures there is only one alias configuration per developer.
+
+        Args:
+            alias: The developer alias to add or update
+        """
+        # Remove existing alias for same primary email
+        self.aliases = [a for a in self.aliases if a.primary_email != alias.primary_email]
+        self.aliases.append(alias)
+        logger.debug(f"Added/updated alias for {alias.primary_email}")
+
+    def remove_alias(self, primary_email: str) -> bool:
+        """Remove a developer alias by primary email.
+
+        Args:
+            primary_email: The primary email of the alias to remove
+
+        Returns:
+            True if an alias was removed, False if not found
+        """
+        original_count = len(self.aliases)
+        self.aliases = [a for a in self.aliases if a.primary_email != primary_email]
+        removed = len(self.aliases) < original_count
+        if removed:
+            logger.debug(f"Removed alias for {primary_email}")
+        return removed
+
+    def get_alias(self, primary_email: str) -> Optional[DeveloperAlias]:
+        """Get a developer alias by primary email.
+
+        Args:
+            primary_email: The primary email to look up
+
+        Returns:
+            The developer alias if found, None otherwise
+        """
+        for alias in self.aliases:
+            if alias.primary_email == primary_email:
+                return alias
+        return None
+
+    def to_manual_mappings(self) -> list[dict[str, Any]]:
+        """Convert aliases to config manual_identity_mappings format.
+
+        Converts the internal alias representation to the format expected
+        by the GitFlow Analytics configuration's manual_identity_mappings field.
+
+        Returns:
+            List of manual identity mapping dictionaries
+        """
+        mappings = []
+        for alias in self.aliases:
+            mapping: dict[str, Any] = {"primary_email": alias.primary_email}
+
+            if alias.name:
+                mapping["name"] = alias.name
+
+            mapping["aliases"] = alias.aliases
+
+            # Include confidence and reasoning for LLM-generated mappings
+            if alias.confidence < 1.0:
+                mapping["confidence"] = alias.confidence
+                if alias.reasoning:
+                    mapping["reasoning"] = alias.reasoning
+
+            mappings.append(mapping)
+
+        return mappings
+
+    def merge_from_mappings(self, mappings: list[dict[str, Any]]) -> None:
+        """Merge aliases from manual identity mappings.
+
+        Takes manual identity mappings from a config file and merges them
+        into the current alias set. Existing aliases are preserved unless
+        they conflict with the new mappings.
+
+        Args:
+            mappings: List of manual identity mapping dictionaries
+        """
+        for mapping in mappings:
+            # Support both field name variants
+            primary_email = mapping.get("primary_email") or mapping.get("canonical_email")
+
+            if not primary_email:
+                logger.warning(f"Skipping mapping without primary_email: {mapping}")
+                continue
+
+            alias = DeveloperAlias(
+                primary_email=primary_email,
+                aliases=mapping.get("aliases", []),
+                name=mapping.get("name"),
+                confidence=mapping.get("confidence", 1.0),
+                reasoning=mapping.get("reasoning", ""),
+            )
+
+            self.add_alias(alias)
+
+    def get_statistics(self) -> dict[str, Any]:
+        """Get statistics about the aliases.
+
+        Returns:
+            Dictionary with statistics including total aliases, manual vs LLM-generated,
+            average confidence, etc.
+        """
+        if not self.aliases:
+            return {
+                "total_aliases": 0,
+                "manual_aliases": 0,
+                "llm_aliases": 0,
+                "avg_confidence": 0.0,
+                "total_email_addresses": 0,
+            }
+
+        manual_count = sum(1 for a in self.aliases if a.confidence == 1.0)
+        llm_count = len(self.aliases) - manual_count
+        avg_confidence = sum(a.confidence for a in self.aliases) / len(self.aliases)
+        total_emails = sum(len(a.aliases) + 1 for a in self.aliases)  # +1 for primary
+
+        return {
+            "total_aliases": len(self.aliases),
+            "manual_aliases": manual_count,
+            "llm_aliases": llm_count,
+            "avg_confidence": round(avg_confidence, 3),
+            "total_email_addresses": total_emails,
+        }

gitflow_analytics/config/loader.py

@@ -1,5 +1,6 @@
 """YAML configuration loading and environment variable expansion."""
 
+import logging
 import os
 from pathlib import Path
 from typing import Any, Optional, Union
@@ -33,6 +34,8 @@ from .schema import (
 )
 from .validator import ConfigValidator
 
+logger = logging.getLogger(__name__)
+
 
 class ConfigLoader:
     """Load and validate configuration from YAML files."""
@@ -533,6 +536,36 @@ class ConfigLoader:
             BranchAnalysisConfig(**branch_data) if branch_data else BranchAnalysisConfig()
         )
 
+        # Process aliases file and manual identity mappings
+        manual_mappings = list(analysis_data.get("identity", {}).get("manual_mappings", []))
+        aliases_file_path = None
+
+        # Load aliases from external file if specified
+        aliases_file = analysis_data.get("identity", {}).get("aliases_file")
+        if aliases_file:
+            aliases_path = Path(aliases_file).expanduser()
+            # Make relative paths relative to config file directory
+            if not aliases_path.is_absolute():
+                aliases_path = config_path.parent / aliases_path
+
+            aliases_file_path = aliases_path
+
+            # Load and merge aliases if file exists
+            if aliases_path.exists():
+                try:
+                    from .aliases import AliasesManager
+
+                    aliases_mgr = AliasesManager(aliases_path)
+                    # Merge aliases with existing manual mappings
+                    manual_mappings.extend(aliases_mgr.to_manual_mappings())
+                    logger.info(
+                        f"Loaded {len(aliases_mgr.aliases)} identity aliases from {aliases_path}"
+                    )
+                except Exception as e:
+                    logger.warning(f"Could not load aliases file {aliases_path}: {e}")
+            else:
+                logger.warning(f"Aliases file not found: {aliases_path}")
+
         return AnalysisConfig(
             story_point_patterns=analysis_data.get(
                 "story_point_patterns",
@@ -550,7 +583,8 @@ class ConfigLoader:
             similarity_threshold=analysis_data.get("identity", {}).get(
                 "similarity_threshold", 0.85
             ),
-            manual_identity_mappings=analysis_data.get("identity", {}).get("manual_mappings", []),
+            manual_identity_mappings=manual_mappings,
+            aliases_file=aliases_file_path,
             default_ticket_platform=analysis_data.get("default_ticket_platform"),
             branch_mapping_rules=analysis_data.get("branch_mapping_rules", {}),
             ticket_platforms=analysis_data.get("ticket_platforms"),

gitflow_analytics/config/schema.py

@@ -301,6 +301,7 @@ class AnalysisConfig:
     exclude_paths: list[str] = field(default_factory=list)
     similarity_threshold: float = 0.85
     manual_identity_mappings: list[dict[str, Any]] = field(default_factory=list)
+    aliases_file: Optional[Path] = None  # Path to shared aliases.yaml file
     default_ticket_platform: Optional[str] = None
     branch_mapping_rules: dict[str, list[str]] = field(default_factory=dict)
     ticket_platforms: Optional[list[str]] = None

{gitflow_analytics-3.4.7.dist-info → gitflow_analytics-3.5.2.dist-info}/METADATA

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

{gitflow_analytics-3.4.7.dist-info → gitflow_analytics-3.5.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 gitflow_analytics/__init__.py,sha256=yN1dyAUu4l9qX-YNAGRItEf4RFFe-5GQiOntXPIfdxo,683
-gitflow_analytics/_version.py,sha256=dupKhjqgdnT_nCus1JhoKEyp5K9agx_0vf-cvvs_Nzc,137
-gitflow_analytics/cli.py,sha256=A0aXFPk4GSw1_s5Oiol4nnoGwZ8VCJHUq-wDreKAvzQ,244683
+gitflow_analytics/_version.py,sha256=VlHh9eAQ34bIRsu31l61B7n-gUeASgbwjJXQ9Hp_IbQ,137
+gitflow_analytics/cli.py,sha256=gKfN-fbEPQqEQVgE693xU5yKSlR4TeVXjoI-vG5oIPA,258433
 gitflow_analytics/config.py,sha256=XRuxvzLWyn_ML7mDCcuZ9-YFNAEsnt33vIuWxQQ_jxg,1033
 gitflow_analytics/constants.py,sha256=GXEncUJS9ijOI5KWtQCTANwdqxPfXpw-4lNjhaWTKC4,2488
 gitflow_analytics/verify_activity.py,sha256=aRQnmypf5NDasXudf2iz_WdJnCWtwlbAiJ5go0DJLSU,27050
@@ -11,14 +11,15 @@ gitflow_analytics/classification/feature_extractor.py,sha256=W82vztPQO8-MFw9Yt17
 gitflow_analytics/classification/linguist_analyzer.py,sha256=HjLx9mM7hGXtrvMba6osovHJLAacTx9oDmN6CS5w0bE,17687
 gitflow_analytics/classification/model.py,sha256=2KbmFh9MpyvHMcNHbqwUTAAVLHHu3MiTfFIPyZSGa-8,16356
 gitflow_analytics/cli_wizards/__init__.py,sha256=D73D97cS1hZsB_fCQQaAiWtd_w2Lb8TtcGc9Pn2DIyE,343
-gitflow_analytics/cli_wizards/install_wizard.py,sha256=SAsPiBWqFfkD3UWOg8aR1Kuj6GBpHHEa6oss3iiuM9A,35644
-gitflow_analytics/cli_wizards/run_launcher.py,sha256=jWtRyw5WSfTMElQ-HQm9gPHMx7AI1Lhp3jlNnaBFpzQ,11919
-gitflow_analytics/config/__init__.py,sha256=lzFOHsJGoeDHuu_NEgcSeUFwU0bgV3lnL9w0Pyc4FI0,1037
+gitflow_analytics/cli_wizards/install_wizard.py,sha256=aQepE3ThhBPyOjkDj-_p0fKZ2OEVTlq7d_6HEt4JrkQ,44871
+gitflow_analytics/cli_wizards/run_launcher.py,sha256=J6G_C7IqxPg7_GhAfbV99D1dIIWwb1s_qmHC7Iv2iGI,15038
+gitflow_analytics/config/__init__.py,sha256=KziRIbBJctB5LOLcKLzELWA1rXwjS6-C2_DeM_hT9rM,1133
+gitflow_analytics/config/aliases.py,sha256=z9F0X6qbbF544Tw7sHlOoBj5mpRSddMkCpoKLzvVzDU,10960
 gitflow_analytics/config/errors.py,sha256=IBKhAIwJ4gscZFnLDyE3jEp03wn2stPR7JQJXNSIfok,10386
-gitflow_analytics/config/loader.py,sha256=aS-A9_uuoj7T58pVdKv_J2qWxbXw0JUMveBsRYpGVHE,35862
+gitflow_analytics/config/loader.py,sha256=EiksTB1Uqey63FxIvuud_kMdab3sNDfuICE_RwMLYFA,37290
 gitflow_analytics/config/profiles.py,sha256=yUjFAWW6uzOUdi5qlPE-QV9681HigyrLiSJFpL8X9A0,7967
 gitflow_analytics/config/repository.py,sha256=maptMAdCKDsuMAfoTAaTrMPVfVd_tKNLRenvuPe1-t4,4350
-gitflow_analytics/config/schema.py,sha256=jIim7dD9jKrBZT4PSigI5Xzj8t6gbLVpyakLF8j25bY,15195
+gitflow_analytics/config/schema.py,sha256=lFN80-YcSqu33UwiJryFHn8F5_zX619AaJXSuJ3aht8,15271
 gitflow_analytics/config/validator.py,sha256=l7AHjXYJ8wEmyA1rn2WiItZXtAiRb9YBLjFCDl53qKM,5907
 gitflow_analytics/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gitflow_analytics/core/analyzer.py,sha256=59kGObzjziOb8geFyZMKCUvWmo3hcXE0eTgrjYEc1XA,58736
@@ -132,9 +133,9 @@ gitflow_analytics/tui/widgets/export_modal.py,sha256=L-XKPOc6u-fow2TudPgDnC0kXZM
 gitflow_analytics/tui/widgets/progress_widget.py,sha256=Qny6Q1nU0Pr3aj4aHfXLaRjya9MH3rldR2HWYiaQyGE,6167
 gitflow_analytics/ui/__init__.py,sha256=UBhYhZMvwlSrCuGWjkIdoP2zNbiQxOHOli-I8mqIZUE,441
 gitflow_analytics/ui/progress_display.py,sha256=3xJnCOSs1DRVAfS-rTu37EsLfWDFW5-mbv-bPS9NMm4,59182
-gitflow_analytics-3.4.7.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
-gitflow_analytics-3.4.7.dist-info/METADATA,sha256=sDGcvDukmYF2I-sQOvXL-IKzNtYnhrWZxM50Wlgjqxk,34122
-gitflow_analytics-3.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gitflow_analytics-3.4.7.dist-info/entry_points.txt,sha256=a3y8HnfLOvK1QVOgAkDY6VQXXm3o9ZSQRZrpiaS3hEM,65
-gitflow_analytics-3.4.7.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
-gitflow_analytics-3.4.7.dist-info/RECORD,,
+gitflow_analytics-3.5.2.dist-info/licenses/LICENSE,sha256=xwvSwY1GYXpRpmbnFvvnbmMwpobnrdN9T821sGvjOY0,1066
+gitflow_analytics-3.5.2.dist-info/METADATA,sha256=7TWOkZxt3KP7_w30_hufQiB8JKsNC6ZGJcPHwNRyMAc,34122
+gitflow_analytics-3.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gitflow_analytics-3.5.2.dist-info/entry_points.txt,sha256=a3y8HnfLOvK1QVOgAkDY6VQXXm3o9ZSQRZrpiaS3hEM,65
+gitflow_analytics-3.5.2.dist-info/top_level.txt,sha256=CQyxZXjKvpSB1kgqqtuE0PCRqfRsXZJL8JrYpJKtkrk,18
+gitflow_analytics-3.5.2.dist-info/RECORD,,