gitflow-analytics 3.6.2__py3-none-any.whl → 3.7.4__py3-none-any.whl

gitflow_analytics/cli.py

@@ -14,25 +14,28 @@ from typing import Any, Optional, cast
 
 import click
 import git
-import pandas as pd
 import yaml
 
 from ._version import __version__
 from .config import ConfigLoader
-from .core.analyzer import GitAnalyzer
-from .core.cache import GitAnalysisCache
-from .core.git_auth import preflight_git_authentication
-from .core.identity import DeveloperIdentityResolver
-from .integrations.orchestrator import IntegrationOrchestrator
-from .metrics.dora import DORAMetricsCalculator
-from .reports.analytics_writer import AnalyticsReportGenerator
-from .reports.csv_writer import CSVReportGenerator
-from .reports.json_exporter import ComprehensiveJSONExporter
-from .reports.narrative_writer import NarrativeReportGenerator
-from .reports.weekly_trends_writer import WeeklyTrendsWriter
-from .training.pipeline import CommitClassificationTrainer
 from .ui.progress_display import create_progress_display
 
+# Heavy imports are lazy-loaded to improve CLI startup time
+# These imports add 1-2 seconds to startup but are only needed for actual analysis
+# from .core.analyzer import GitAnalyzer
+# from .core.cache import GitAnalysisCache
+# from .core.git_auth import preflight_git_authentication
+# from .core.identity import DeveloperIdentityResolver
+# from .integrations.orchestrator import IntegrationOrchestrator
+# from .metrics.dora import DORAMetricsCalculator
+# from .reports.analytics_writer import AnalyticsReportGenerator
+# from .reports.csv_writer import CSVReportGenerator
+# from .reports.json_exporter import ComprehensiveJSONExporter
+# from .reports.narrative_writer import NarrativeReportGenerator
+# from .reports.weekly_trends_writer import WeeklyTrendsWriter
+# from .training.pipeline import CommitClassificationTrainer
+# import pandas as pd  # Only used in one location, lazy loaded
+
 logger = logging.getLogger(__name__)
 
 
@@ -257,64 +260,33 @@ class ImprovedErrorHandler:
         click.echo("\nFor help: gitflow-analytics help", err=True)
 
 
-class TUIAsDefaultGroup(click.Group):
+class AnalyzeAsDefaultGroup(click.Group):
     """
-    Custom Click group that defaults to TUI when no explicit subcommand is provided.
-    This allows 'gitflow-analytics -c config.yaml' to launch the TUI by default.
-    For explicit CLI analysis, use 'gitflow-analytics analyze -c config.yaml'
+    Custom Click group that defaults to analyze when no explicit subcommand is provided.
+    This allows 'gitflow-analytics -c config.yaml' to run analysis by default.
     """
 
     def parse_args(self, ctx, args):
-        """Override parse_args to default to TUI unless explicit subcommand or CLI-only options."""
+        """Override parse_args to default to analyze unless explicit subcommand provided."""
         # Check if the first argument is a known subcommand
         if args and args[0] in self.list_commands(ctx):
             return super().parse_args(ctx, args)
 
-        # Check for global options that should NOT be routed to TUI
+        # Check for global options that should NOT be routed to analyze
         global_options = {"--version", "--help", "-h"}
         if args and args[0] in global_options:
             return super().parse_args(ctx, args)
 
-        # Check if we have arguments that indicate explicit CLI analysis request
-        cli_only_indicators = {
-            "--no-rich",
-            "--generate-csv",
-            "--validate-only",
-            "--warm-cache",
-            "--validate-cache",
-            "--qualitative-only",
-        }
-
-        # If user explicitly requests CLI-only features, route to analyze
-        if args and any(arg in cli_only_indicators for arg in args):
+        # For all other cases (including -c config.yaml), default to analyze
+        if args and args[0].startswith("-"):
             new_args = ["analyze"] + args
             return super().parse_args(ctx, new_args)
 
-        # For all other cases (including -c config.yaml), default to TUI
-        if args and args[0].startswith("-"):
-            # Check if TUI dependencies are available
-            try:
-                import importlib.util
-
-                textual_spec = importlib.util.find_spec("textual")
-                # TUI is available - route to TUI
-                if textual_spec is not None:
-                    new_args = ["tui"] + args
-                    return super().parse_args(ctx, new_args)
-                else:
-                    # TUI not available - fallback to analyze
-                    new_args = ["analyze"] + args
-                    return super().parse_args(ctx, new_args)
-            except (ImportError, ValueError):
-                # TUI not available - fallback to analyze
-                new_args = ["analyze"] + args
-                return super().parse_args(ctx, new_args)
-
         # Otherwise, use default behavior
         return super().parse_args(ctx, args)
 
 
-@click.group(cls=TUIAsDefaultGroup, invoke_without_command=True)
+@click.group(cls=AnalyzeAsDefaultGroup, invoke_without_command=True)
 @click.version_option(version=__version__, prog_name="GitFlow Analytics")
 @click.help_option("-h", "--help")
 @click.pass_context
@@ -374,119 +346,6 @@ def cli(ctx: click.Context) -> None:
         ctx.exit(0)
 
 
-# TUI command - Terminal User Interface
-@cli.command(name="tui")
-@click.option(
-    "--config",
-    "-c",
-    type=click.Path(exists=True, path_type=Path),
-    default=None,
-    help="Path to YAML configuration file (optional - can be loaded in TUI)",
-)
-@click.option(
-    "--weeks",
-    "-w",
-    type=int,
-    default=None,
-    help="Number of weeks to analyze (passed to TUI)",
-)
-@click.option(
-    "--clear-cache",
-    is_flag=True,
-    help="Clear cache before analysis (passed to TUI)",
-)
-@click.option(
-    "--output",
-    "-o",
-    type=click.Path(path_type=Path),
-    default=None,
-    help="Output directory for reports (passed to TUI)",
-)
-def tui_command(
-    config: Optional[Path],
-    weeks: Optional[int],
-    clear_cache: bool,
-    output: Optional[Path],
-) -> None:
-    """Launch the Terminal User Interface for GitFlow Analytics.
-
-    \b
-    The TUI provides an interactive interface for:
-    - Loading and editing configuration files
-    - Running analysis with real-time progress updates
-    - Viewing results in an organized, navigable format
-    - Exporting reports in various formats
-
-    \b
-    FEATURES:
-    • Full-screen terminal interface with keyboard navigation
-    • Real-time progress tracking during analysis
-    • Interactive configuration management
-    • Results browser with filtering and export options
-    • Built-in help system and keyboard shortcuts
-
-    \b
-    EXAMPLES:
-    # Launch TUI without pre-loading configuration
-    gitflow-analytics tui
-
-    # Launch TUI with a specific configuration file
-    gitflow-analytics tui -c config.yaml
-
-    \b
-    KEYBOARD SHORTCUTS:
-    • Ctrl+Q / Ctrl+C: Quit application
-    • F1: Show help
-    • Ctrl+D: Toggle dark/light mode
-    • Escape: Go back/cancel current action
-    """
-    try:
-        # Import TUI components only when needed
-        from .tui.app import GitFlowAnalyticsApp
-
-        # Create and run the TUI application
-        app = GitFlowAnalyticsApp()
-
-        # Pass CLI parameters to TUI
-        if weeks is not None:
-            app.default_weeks = weeks
-        if clear_cache:
-            app.clear_cache_on_start = True
-        if output:
-            app.default_output_dir = output
-
-        # If config path provided, try to load it
-        if config:
-            try:
-                from .config import ConfigLoader
-
-                loaded_config = ConfigLoader.load(config)
-                app.config = loaded_config
-                app.config_path = config
-                app.initialization_complete = True
-            except Exception as e:
-                # Don't fail - let TUI handle config loading
-                click.echo(f"⚠️  Could not pre-load config: {e}")
-                click.echo("   You can load the configuration within the TUI.")
-
-        # Run the TUI
-        app.run()
-
-    except ImportError as e:
-        click.echo("❌ TUI dependencies not installed.", err=True)
-        click.echo(f"   Error: {e}", err=True)
-        click.echo("\n💡 Install TUI dependencies:", err=True)
-        click.echo("   pip install 'gitflow-analytics[tui]'", err=True)
-        click.echo("   # or", err=True)
-        click.echo("   pip install textual>=0.41.0", err=True)
-        sys.exit(1)
-    except Exception as e:
-        click.echo(f"❌ Failed to launch TUI: {e}", err=True)
-        if "--debug" in sys.argv:
-            raise
-        sys.exit(1)
-
-
 @cli.command(name="analyze")
 @click.option(
     "--config",
@@ -534,7 +393,7 @@ def tui_command(
     "--no-rich",
     is_flag=True,
     default=True,
-    help="Disable rich terminal output (simple output is default to prevent TUI hanging)",
+    help="Disable rich terminal output (use simple text progress instead)",
 )
 @click.option(
     "--log",
@@ -697,8 +556,20 @@ def analyze(
 ) -> None:
     """Analyze Git repositories using configuration file."""
 
-    # Initialize progress service early with the correct style
+    # Lazy imports: Only load heavy dependencies when actually running analysis
+    # This improves CLI startup time from ~2s to <100ms for commands like --help
+    from .core.analyzer import GitAnalyzer
+    from .core.cache import GitAnalysisCache
+    from .core.git_auth import preflight_git_authentication
+    from .core.identity import DeveloperIdentityResolver
     from .core.progress import get_progress_service
+    from .integrations.orchestrator import IntegrationOrchestrator
+    from .metrics.dora import DORAMetricsCalculator
+    from .reports.analytics_writer import AnalyticsReportGenerator
+    from .reports.csv_writer import CSVReportGenerator
+    from .reports.json_exporter import ComprehensiveJSONExporter
+    from .reports.narrative_writer import NarrativeReportGenerator
+    from .reports.weekly_trends_writer import WeeklyTrendsWriter
 
     try:
         from ._version import __version__
@@ -710,7 +581,7 @@ def analyze(
     # Initialize progress service with user's preference
     progress = get_progress_service(display_style=progress_style, version=version)
 
-    # Initialize display - simple output by default to prevent TUI hanging
+    # Initialize display - simple output by default for better compatibility
     # Create display - only create if rich output is explicitly enabled (--no-rich=False)
     display = (
         create_progress_display(style="simple" if no_rich else "rich", version=__version__)
@@ -1073,7 +944,7 @@ def analyze(
             data_fetcher = GitDataFetcher(
                 cache=cache,
                 branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-                allowed_ticket_platforms=cfg.analysis.ticket_platforms,
+                allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
                 exclude_paths=cfg.analysis.exclude_paths,
             )
 
@@ -1264,9 +1135,7 @@ def analyze(
         analyzer = GitAnalyzer(
             cache,
             branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=cfg.analysis.exclude_paths,
             story_point_patterns=cfg.analysis.story_point_patterns,
             ml_categorization_config=ml_config,
@@ -1293,9 +1162,28 @@ def analyze(
                 # Use a 'repos' directory in the config directory for cloned repositories
                 config_dir = Path(config).parent if config else Path.cwd()
                 repos_dir = config_dir / "repos"
-                discovered_repos = cfg.discover_organization_repositories(clone_base_path=repos_dir)
+
+                # Progress callback for repository discovery
+                def discovery_progress(repo_name, count):
+                    if display and display._live:
+                        display.update_progress_task(
+                            "main",
+                            description=f"🔍 Discovering: {repo_name} ({count} repos checked)",
+                            completed=15 + min(count % 5, 4),  # Show some movement
+                        )
+                    else:
+                        # Simple inline progress - just show count
+                        click.echo(f"\r   📦 Checking repositories... {count}", nl=False)
+
+                discovered_repos = cfg.discover_organization_repositories(
+                    clone_base_path=repos_dir, progress_callback=discovery_progress
+                )
                 repositories_to_analyze = discovered_repos
 
+                # Clear the progress line
+                if not (display and display._live):
+                    click.echo("\r" + " " * 60 + "\r", nl=False)  # Clear line
+
                 if display and display._live:
                     # We're in full-screen mode, update progress and initialize repo list
                     display.update_progress_task(
@@ -1832,14 +1720,14 @@ def analyze(
                             "📊 No commits or batches found for date range - proceeding with data fetch"
                         )
 
-            # PROCEED WITH EMERGENCY FETCH if validation didn't pass
+            # PROCEED WITH INITIAL FETCH if validation didn't pass
             if not validation_passed:
                 if display:
                     display.print_status(
-                        "Data validation failed - running emergency data fetch", "warning"
+                        "Data validation failed - running initial data fetch", "warning"
                     )
                 else:
-                    click.echo("⚠️ Data validation failed - running emergency data fetch")
+                    click.echo("⚠️ Data validation failed - running initial data fetch")
 
                 # Force data fetch for all repositories since we have no batches
                 repos_needing_analysis = repositories_to_analyze
@@ -1848,12 +1736,12 @@ def analyze(
                 if repos_needing_analysis:
                     if display:
                         display.print_status(
-                            f"Emergency fetch: Fetching data for {len(repos_needing_analysis)} repositories...",
+                            f"Initial fetch: Fetching data for {len(repos_needing_analysis)} repositories...",
                             "info",
                         )
                     else:
                         click.echo(
-                            f"🚨 Emergency fetch: Fetching data for {len(repos_needing_analysis)} repositories..."
+                            f"🚨 Initial fetch: Fetching data for {len(repos_needing_analysis)} repositories..."
                         )
                         click.echo(
                             "   📋 Reason: Need to ensure commits and batches exist for classification"
@@ -1886,6 +1774,176 @@ def analyze(
                             repo_path = Path(repo_config.path)
                             project_key = repo_config.project_key or repo_path.name
 
+                            # Check if repo exists, clone if needed (critical for organization mode)
+                            if not repo_path.exists():
+                                if repo_config.github_repo and cfg.github.organization:
+                                    # Retry logic for cloning
+                                    max_retries = 2
+                                    retry_count = 0
+                                    clone_success = False
+
+                                    while retry_count <= max_retries and not clone_success:
+                                        if retry_count > 0:
+                                            if display:
+                                                display.print_status(
+                                                    f"   🔄 Retry {retry_count}/{max_retries}: {repo_config.github_repo}",
+                                                    "warning",
+                                                )
+                                            else:
+                                                click.echo(
+                                                    f"   🔄 Retry {retry_count}/{max_retries}: {repo_config.github_repo}"
+                                                )
+                                        else:
+                                            if display:
+                                                display.print_status(
+                                                    f"   📥 Cloning {repo_config.github_repo} from GitHub...",
+                                                    "info",
+                                                )
+                                            else:
+                                                click.echo(
+                                                    f"   📥 Cloning {repo_config.github_repo} from GitHub..."
+                                                )
+
+                                        try:
+                                            # Ensure parent directory exists
+                                            repo_path.parent.mkdir(parents=True, exist_ok=True)
+
+                                            # Build clone URL with authentication
+                                            clone_url = (
+                                                f"https://github.com/{repo_config.github_repo}.git"
+                                            )
+                                            if cfg.github.token:
+                                                clone_url = f"https://{cfg.github.token}@github.com/{repo_config.github_repo}.git"
+
+                                            # Clone using subprocess for better control
+                                            env = os.environ.copy()
+                                            env["GIT_TERMINAL_PROMPT"] = "0"
+                                            env["GIT_ASKPASS"] = ""
+                                            env["GCM_INTERACTIVE"] = "never"
+                                            env["GIT_PROGRESS"] = "1"  # Force progress output
+
+                                            cmd = [
+                                                "git",
+                                                "clone",
+                                                "--progress",
+                                                "--config",
+                                                "credential.helper=",
+                                            ]
+                                            if repo_config.branch:
+                                                cmd.extend(["-b", repo_config.branch])
+                                            cmd.extend([clone_url, str(repo_path)])
+
+                                            # Track start time for timeout reporting
+                                            import time
+
+                                            start_time = time.time()
+                                            timeout_seconds = 300  # 5 minutes for large repos
+
+                                            # Run without capturing stderr to show git progress
+                                            result = subprocess.run(
+                                                cmd,
+                                                env=env,
+                                                stdout=subprocess.PIPE,
+                                                stderr=None,  # Let stderr (progress) flow to terminal
+                                                text=True,
+                                                timeout=timeout_seconds,
+                                            )
+
+                                            elapsed = time.time() - start_time
+
+                                            if result.returncode != 0:
+                                                error_msg = "Clone failed"
+                                                if any(
+                                                    x in error_msg.lower()
+                                                    for x in [
+                                                        "authentication",
+                                                        "permission denied",
+                                                        "401",
+                                                        "403",
+                                                    ]
+                                                ):
+                                                    if display:
+                                                        display.print_status(
+                                                            f"   ❌ Authentication failed for {repo_config.github_repo}",
+                                                            "error",
+                                                        )
+                                                    else:
+                                                        click.echo(
+                                                            f"   ❌ Authentication failed for {repo_config.github_repo}"
+                                                        )
+                                                    break  # Don't retry auth failures
+                                                else:
+                                                    raise subprocess.CalledProcessError(
+                                                        result.returncode,
+                                                        cmd,
+                                                        result.stdout,
+                                                        result.stderr,
+                                                    )
+                                            else:
+                                                clone_success = True
+                                                if display:
+                                                    display.print_status(
+                                                        f"   ✅ Cloned {repo_config.github_repo} ({elapsed:.1f}s)",
+                                                        "success",
+                                                    )
+                                                else:
+                                                    click.echo(
+                                                        f"   ✅ Cloned {repo_config.github_repo} ({elapsed:.1f}s)"
+                                                    )
+
+                                        except subprocess.TimeoutExpired:
+                                            retry_count += 1
+                                            if display:
+                                                display.print_status(
+                                                    f"   ⏱️  Clone timeout after {timeout_seconds}s: {repo_config.github_repo}",
+                                                    "error",
+                                                )
+                                            else:
+                                                click.echo(
+                                                    f"   ⏱️  Clone timeout after {timeout_seconds}s: {repo_config.github_repo}"
+                                                )
+                                            # Clean up partial clone
+                                            if repo_path.exists():
+                                                import shutil
+
+                                                shutil.rmtree(repo_path, ignore_errors=True)
+                                            if retry_count > max_retries:
+                                                if display:
+                                                    display.print_status(
+                                                        f"   ❌ Skipping {repo_config.github_repo} after {max_retries} timeouts",
+                                                        "error",
+                                                    )
+                                                else:
+                                                    click.echo(
+                                                        f"   ❌ Skipping {repo_config.github_repo} after {max_retries} timeouts"
+                                                    )
+                                                break
+                                            continue  # Try again
+
+                                        except Exception as e:
+                                            retry_count += 1
+                                            if display:
+                                                display.print_status(
+                                                    f"   ❌ Clone error: {e}", "error"
+                                                )
+                                            else:
+                                                click.echo(f"   ❌ Clone error: {e}")
+                                            if retry_count > max_retries:
+                                                break
+                                            continue  # Try again
+
+                                    if not clone_success:
+                                        continue  # Skip this repo and move to next
+                                else:
+                                    # No github_repo configured, can't clone
+                                    if display:
+                                        display.print_status(
+                                            f"   ❌ Repository not found: {repo_path}", "error"
+                                        )
+                                    else:
+                                        click.echo(f"   ❌ Repository not found: {repo_path}")
+                                    continue
+
                             # Progress callback for fetch
                             def progress_callback(message: str):
                                 if display:
@@ -1961,15 +2019,15 @@ def analyze(
 
                     if display:
                         display.print_status(
-                            f"Emergency fetch complete: {total_commits} commits, {total_tickets} tickets",
+                            f"Initial fetch complete: {total_commits} commits, {total_tickets} tickets",
                             "success",
                         )
                     else:
                         click.echo(
-                            f"🚨 Emergency fetch complete: {total_commits} commits, {total_tickets} tickets"
+                            f"🚨 Initial fetch complete: {total_commits} commits, {total_tickets} tickets"
                         )
 
-                    # RE-VALIDATE after emergency fetch
+                    # RE-VALIDATE after initial fetch
                     with cache.get_session() as session:
                         final_commits = (
                             session.query(CachedCommit)
@@ -1994,7 +2052,7 @@ def analyze(
                         )
 
                         if final_commits == 0:
-                            error_msg = "❌ CRITICAL: Emergency fetch completed but still 0 commits stored in database"
+                            error_msg = "❌ CRITICAL: Initial fetch completed but still 0 commits stored in database"
                             if display:
                                 display.print_status(error_msg, "error")
                             else:
@@ -2002,7 +2060,9 @@ def analyze(
                             click.echo(
                                 f"   📅 Date range: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}"
                             )
-                            click.echo(f"   📊 Emergency stats: {total_commits} commits reported")
+                            click.echo(
+                                f"   📊 Initial fetch stats: {total_commits} commits reported"
+                            )
                             click.echo(
                                 f"   🗃️ Database result: {final_commits} commits, {final_batches} batches"
                             )
@@ -2016,7 +2076,7 @@ def analyze(
                                 "      - Repository has no commits in the specified time range"
                             )
                             raise click.ClickException(
-                                "Emergency fetch failed validation - no data available for classification"
+                                "Initial fetch failed validation - no data available for classification"
                             )
 
                         if display:
@@ -2375,25 +2435,33 @@ def analyze(
                                 env["GIT_TERMINAL_PROMPT"] = "0"
                                 env["GIT_ASKPASS"] = ""
                                 env["GCM_INTERACTIVE"] = "never"
+                                env["GIT_PROGRESS"] = "1"  # Force progress output
 
                                 # Build git clone command
-                                cmd = ["git", "clone", "--config", "credential.helper="]
+                                cmd = [
+                                    "git",
+                                    "clone",
+                                    "--progress",
+                                    "--config",
+                                    "credential.helper=",
+                                ]
                                 if repo_config.branch:
                                     cmd.extend(["-b", repo_config.branch])
                                 cmd.extend([clone_url, str(repo_config.path)])
 
-                                # Run with timeout to prevent hanging
+                                # Run with timeout to prevent hanging, let progress show on stderr
                                 result = subprocess.run(
                                     cmd,
                                     env=env,
-                                    capture_output=True,
+                                    stdout=subprocess.PIPE,
+                                    stderr=None,  # Let stderr (progress) flow to terminal
                                     text=True,
-                                    timeout=30,  # 30 second timeout
+                                    timeout=120,  # Increase timeout for large repos
                                 )
 
                                 if result.returncode != 0:
                                     raise git.GitCommandError(
-                                        cmd, result.returncode, stderr=result.stderr
+                                        cmd, result.returncode, stderr="Clone failed"
                                     )
                             except subprocess.TimeoutExpired:
                                 if display:
@@ -2442,13 +2510,19 @@ def analyze(
                                     cmd = [
                                         "git",
                                         "clone",
+                                        "--progress",
                                         "--config",
                                         "credential.helper=",
                                         clone_url,
                                         str(repo_config.path),
                                     ]
                                     result = subprocess.run(
-                                        cmd, env=env, capture_output=True, text=True, timeout=30
+                                        cmd,
+                                        env=env,
+                                        stdout=subprocess.PIPE,
+                                        stderr=None,
+                                        text=True,
+                                        timeout=120,
                                     )
                                     if result.returncode != 0:
                                         raise git.GitCommandError(
@@ -3567,6 +3641,9 @@ def analyze(
                 logger.debug("Starting narrative report generation")
                 narrative_gen = NarrativeReportGenerator()
 
+                # Lazy import pandas - only needed for CSV reading in narrative generation
+                import pandas as pd
+
                 # Load activity distribution data
                 logger.debug("Loading activity distribution data")
                 activity_df = pd.read_csv(activity_report)
@@ -4111,7 +4188,7 @@ def analyze(
     "--no-rich",
     is_flag=True,
     default=True,
-    help="Disable rich terminal output (simple output is default to prevent TUI hanging)",
+    help="Disable rich terminal output (use simple text progress instead)",
 )
 def fetch(
     config: Path,
@@ -4161,7 +4238,7 @@ def fetch(
       - Use --clear-cache to force fresh fetch
     """
     # Initialize display
-    # Create display - simple output by default to prevent TUI hanging, rich only when explicitly enabled
+    # Create display - simple output by default for better compatibility, rich only when explicitly enabled
     display = (
         create_progress_display(style="simple" if no_rich else "rich", version=__version__)
         if not no_rich
@@ -4186,6 +4263,10 @@ def fetch(
         logger = logging.getLogger(__name__)
 
     try:
+        # Lazy imports
+        from .core.cache import GitAnalysisCache
+        from .integrations.orchestrator import IntegrationOrchestrator
+
         if display:
             display.show_header()
 
@@ -4218,9 +4299,7 @@ def fetch(
         data_fetcher = GitDataFetcher(
             cache=cache,
             branch_mapping_rules=getattr(cfg.analysis, "branch_mapping_rules", {}),
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=getattr(cfg.analysis, "exclude_paths", None),
         )
 
@@ -4243,9 +4322,23 @@ def fetch(
                 # Use a 'repos' directory in the config directory for cloned repositories
                 config_dir = Path(config).parent if config else Path.cwd()
                 repos_dir = config_dir / "repos"
-                discovered_repos = cfg.discover_organization_repositories(clone_base_path=repos_dir)
+
+                # Progress callback for repository discovery
+                def discovery_progress(repo_name, count):
+                    if display:
+                        display.print_status(f"   📦 Checking: {repo_name} ({count})", "info")
+                    else:
+                        click.echo(f"\r   📦 Checking repositories... {count}", nl=False)
+
+                discovered_repos = cfg.discover_organization_repositories(
+                    clone_base_path=repos_dir, progress_callback=discovery_progress
+                )
                 repositories_to_fetch = discovered_repos
 
+                # Clear the progress line
+                if not display:
+                    click.echo("\r" + " " * 60 + "\r", nl=False)  # Clear line
+
                 if display:
                     display.print_status(
                         f"Found {len(discovered_repos)} repositories in organization", "success"
@@ -4426,6 +4519,8 @@ def cache_stats(config: Path) -> None:
     - Decide when to clear cache
     - Troubleshoot slow analyses
     """
+    from .core.cache import GitAnalysisCache
+
     try:
         cfg = ConfigLoader.load(config)
         cache = GitAnalysisCache(cfg.cache.directory)
@@ -4480,6 +4575,8 @@ def merge_identity(config: Path, dev1: str, dev2: str) -> None:
     - Refreshes cached statistics
     - Updates identity mappings
     """
+    from .core.identity import DeveloperIdentityResolver
+
     try:
         cfg = ConfigLoader.load(config)
         identity_resolver = DeveloperIdentityResolver(cfg.cache.directory / "identities.db")
@@ -4745,6 +4842,7 @@ def discover_storypoint_fields(config: Path) -> None:
             return
 
         # Initialize PM integration (currently JIRA)
+        from .core.cache import GitAnalysisCache
         from .integrations.jira_integration import JIRAIntegration
 
         # Create minimal cache for integration
@@ -4828,6 +4926,9 @@ def identities(config: Path, weeks: int, apply: bool) -> None:
       Mappings are saved to 'analysis.identity.manual_mappings'
       Bot exclusions go to 'analysis.exclude.authors'
     """
+    from .core.analyzer import GitAnalyzer
+    from .core.cache import GitAnalysisCache
+
     try:
         cfg = ConfigLoader.load(config)
         cache = GitAnalysisCache(cfg.cache.directory)
@@ -4888,9 +4989,7 @@ def identities(config: Path, weeks: int, apply: bool) -> None:
         analyzer = GitAnalyzer(
             cache,
             branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=cfg.analysis.exclude_paths,
             story_point_patterns=cfg.analysis.story_point_patterns,
             ml_categorization_config=ml_config,
@@ -5058,6 +5157,8 @@ def aliases_command(
     """
     try:
         from .config.aliases import AliasesManager, DeveloperAlias
+        from .core.analyzer import GitAnalyzer
+        from .core.cache import GitAnalysisCache
         from .identity_llm.analyzer import LLMIdentityAnalyzer
 
         # Load configuration
@@ -5125,9 +5226,7 @@ def aliases_command(
         analyzer = GitAnalyzer(
             cache,
             branch_mapping_rules=cfg.analysis.branch_mapping_rules,
-            allowed_ticket_platforms=getattr(
-                cfg.analysis, "ticket_platforms", ["jira", "github", "clickup", "linear"]
-            ),
+            allowed_ticket_platforms=cfg.get_effective_ticket_platforms(),
             exclude_paths=cfg.analysis.exclude_paths,
             story_point_patterns=cfg.analysis.story_point_patterns,
             ml_categorization_config=ml_config,
@@ -5361,6 +5460,8 @@ def list_developers(config: Path) -> None:
     - Finding developer email addresses
     - Checking contribution statistics
     """
+    from .core.identity import DeveloperIdentityResolver
+
     try:
         cfg = ConfigLoader.load(config)
         identity_resolver = DeveloperIdentityResolver(cfg.cache.directory / "identities.db")
@@ -5494,6 +5595,8 @@ def train(
       - scikit-learn and pandas dependencies
       - ~100MB disk space for model storage
     """
+    from .core.cache import GitAnalysisCache
+    from .integrations.orchestrator import IntegrationOrchestrator
 
     # Configure logging
     if log.upper() != "NONE":
@@ -5577,8 +5680,18 @@ def train(
             try:
                 config_dir = Path(config).parent if config else Path.cwd()
                 repos_dir = config_dir / "repos"
-                discovered_repos = cfg.discover_organization_repositories(clone_base_path=repos_dir)
+
+                # Progress callback for repository discovery
+                def discovery_progress(repo_name, count):
+                    click.echo(f"\r   📦 Checking repositories... {count}", nl=False)
+
+                discovered_repos = cfg.discover_organization_repositories(
+                    clone_base_path=repos_dir, progress_callback=discovery_progress
+                )
                 repositories_to_analyze = discovered_repos
+
+                # Clear the progress line and show result
+                click.echo("\r" + " " * 60 + "\r", nl=False)
                 click.echo(f"✅ Found {len(discovered_repos)} repositories in organization")
             except Exception as e:
                 click.echo(f"❌ Failed to discover repositories: {e}")
@@ -5604,6 +5717,9 @@ def train(
         # Initialize trainer
         click.echo("🧠 Initializing training pipeline...")
         try:
+            # Lazy import - only needed for train command
+            from .training.pipeline import CommitClassificationTrainer
+
             trainer = CommitClassificationTrainer(
                 config=cfg, cache=cache, orchestrator=orchestrator, training_config=training_config
             )
@@ -5939,6 +6055,10 @@ def training_statistics(config: Path) -> None:
     - Compare different model versions
     """
     try:
+        # Lazy imports
+        from .core.cache import GitAnalysisCache
+        from .training.pipeline import CommitClassificationTrainer
+
         cfg = ConfigLoader.load(config)
         cache = GitAnalysisCache(cfg.cache.directory)