gitflow-analytics 3.9.3__tar.gz → 3.10.6__tar.gz

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/PKG-INFO

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

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/src/gitflow_analytics/_version.py

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

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/src/gitflow_analytics/cli.py

@@ -628,6 +628,27 @@ def analyze(
 
         cfg = ConfigLoader.load(config)
 
+        # Helper function to check if qualitative analysis is enabled
+        # Supports both top-level cfg.qualitative and nested cfg.analysis.qualitative
+        def is_qualitative_enabled() -> bool:
+            """Check if qualitative analysis is enabled in either location."""
+            if cfg.qualitative and cfg.qualitative.enabled:
+                return True
+            return (
+                hasattr(cfg.analysis, "qualitative")
+                and cfg.analysis.qualitative
+                and cfg.analysis.qualitative.enabled
+            )
+
+        # Helper function to get qualitative config from either location
+        def get_qualitative_config():
+            """Get qualitative config from either top-level or nested location."""
+            if cfg.qualitative:
+                return cfg.qualitative
+            if hasattr(cfg.analysis, "qualitative") and cfg.analysis.qualitative:
+                return cfg.analysis.qualitative
+            return None
+
         # Apply CLI overrides for PM integration
         if disable_pm:
             # Disable PM integration if explicitly requested
@@ -2974,9 +2995,8 @@ def analyze(
         # Perform qualitative analysis if enabled
         qualitative_results = []
         qual_cost_stats = None
-        if (
-            enable_qualitative or qualitative_only or (cfg.qualitative and cfg.qualitative.enabled)
-        ) and cfg.qualitative:
+        qual_config = get_qualitative_config()
+        if (enable_qualitative or qualitative_only or is_qualitative_enabled()) and qual_config:
             if display:
                 display.print_status("Performing qualitative analysis...", "info")
             else:
@@ -2988,7 +3008,7 @@ def analyze(
 
                 # Initialize qualitative analysis components
                 qual_db = Database(cfg.cache.directory / "qualitative.db")
-                qual_processor = QualitativeProcessor(cfg.qualitative, qual_db)
+                qual_processor = QualitativeProcessor(qual_config, qual_db)
 
                 # Validate setup
                 is_valid, issues = qual_processor.validate_setup()
@@ -3143,8 +3163,8 @@ def analyze(
                         display.print_status("Continuing with standard analysis...", "info")
                     else:
                         click.echo("   ⏭️  Continuing with standard analysis...")
-        elif enable_qualitative and not cfg.qualitative:
-            warning_msg = "Qualitative analysis requested but not configured in config file\n\nAdd a 'qualitative:' section to your configuration"
+        elif enable_qualitative and not get_qualitative_config():
+            warning_msg = "Qualitative analysis requested but not configured in config file\n\nAdd a 'qualitative:' section (top-level or under 'analysis:') to your configuration"
             if display:
                 display.show_warning(warning_msg)
             else:
@@ -4085,12 +4105,12 @@ def analyze(
                         )
             else:
                 # Show note about token tracking when qualitative analysis is not configured
-                if not (enable_qualitative or (cfg.qualitative and cfg.qualitative.enabled)):
+                if not (enable_qualitative or is_qualitative_enabled()):
                     click.echo(
                         "\n💡 Note: Token/cost tracking is only available with qualitative analysis enabled."
                     )
                     click.echo(
-                        "   Add 'qualitative:' section to your config to enable detailed LLM cost tracking."
+                        "   Add 'qualitative:' section (top-level or under 'analysis:') to your config to enable detailed LLM cost tracking."
                     )
 
             # Display cache statistics in simple format

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/src/gitflow_analytics/cli_wizards/install_wizard.py

@@ -7,6 +7,8 @@ and comprehensive configuration generation.
 import getpass
 import logging
 import os
+import re
+import shutil
 import stat
 import subprocess
 import sys
@@ -18,6 +20,8 @@ from typing import Optional
 import click
 import requests
 import yaml
+from git import GitCommandError, Repo
+from git.exc import InvalidGitRepositoryError
 from github import Github
 from github.GithubException import GithubException
 
@@ -490,6 +494,203 @@ class InstallWizard:
             logger.debug(f"Path validation error: {type(e).__name__}")
             return None
 
+    def _detect_git_url(self, input_str: str) -> Optional[str]:
+        """Detect if input is a Git URL and normalize it.
+
+        Args:
+            input_str: User input string
+
+        Returns:
+            Normalized Git URL if detected, None if it's a local path
+        """
+        import re
+
+        # HTTPS URL patterns
+        https_pattern = r"^https?://[^/]+/[^/]+/[^/]+(?:\.git)?$"
+        # SSH URL pattern
+        ssh_pattern = r"^git@[^:]+:[^/]+/[^/]+(?:\.git)?$"
+
+        input_str = input_str.strip()
+
+        if re.match(https_pattern, input_str, re.IGNORECASE) or re.match(ssh_pattern, input_str):
+            # Ensure .git extension for consistency
+            if not input_str.endswith(".git"):
+                input_str = input_str + ".git"
+            return input_str
+
+        return None
+
+    def _clone_git_repository(self, git_url: str) -> Optional[tuple[Path, str]]:
+        """Clone a Git repository to the local repos/ directory.
+
+        Args:
+            git_url: Git URL to clone
+
+        Returns:
+            Tuple of (local_path, original_url) if successful, None if failed
+        """
+        try:
+            # Extract repository name from URL
+            # Handle both HTTPS and SSH formats
+            match = re.search(r"/([^/]+?)(?:\.git)?$", git_url)
+            if not match:
+                click.echo("❌ Could not extract repository name from URL")
+                return None
+
+            repo_name = match.group(1)
+            click.echo(f"📦 Repository: {repo_name}")
+
+            # Create repos directory in current working directory
+            repos_dir = Path.cwd() / "repos"
+            repos_dir.mkdir(parents=True, exist_ok=True)
+            click.echo(f"📁 Clone directory: {repos_dir}")
+
+            # Target path for cloned repository
+            target_path = repos_dir / repo_name
+
+            # Check if repository already exists
+            if target_path.exists():
+                click.echo(f"⚠️  Directory already exists: {target_path}")
+
+                # Check if it's a valid git repository
+                try:
+                    existing_repo = Repo(target_path)
+                    if existing_repo.working_dir:
+                        click.echo("✅ Found existing git repository")
+
+                        # Check if remote URL matches
+                        try:
+                            origin_url = existing_repo.remotes.origin.url
+                            if origin_url == git_url or self._normalize_git_url(
+                                origin_url
+                            ) == self._normalize_git_url(git_url):
+                                click.echo(f"✅ Remote URL matches: {origin_url}")
+
+                                # Offer to update
+                                if click.confirm(
+                                    "Update existing repository (git pull)?", default=True
+                                ):
+                                    click.echo("🔄 Updating repository...")
+                                    origin = existing_repo.remotes.origin
+                                    origin.pull()
+                                    click.echo("✅ Repository updated")
+
+                                return (target_path, git_url)
+                            else:
+                                click.echo("⚠️  Remote URL mismatch:")
+                                click.echo(f"   Existing: {origin_url}")
+                                click.echo(f"   Requested: {git_url}")
+                                if not click.confirm(
+                                    "Use existing repository anyway?", default=False
+                                ):
+                                    return None
+                                return (target_path, git_url)
+                        except Exception as e:
+                            click.echo(f"⚠️  Could not check remote URL: {type(e).__name__}")
+                            if click.confirm("Use existing repository anyway?", default=False):
+                                return (target_path, git_url)
+                            return None
+                except InvalidGitRepositoryError:
+                    click.echo("❌ Directory exists but is not a git repository")
+                    if not click.confirm("Remove and re-clone?", default=False):
+                        return None
+
+                    # Remove existing directory
+                    shutil.rmtree(target_path)
+                    click.echo("🗑️  Removed existing directory")
+
+            # Clone the repository
+            click.echo(f"🔄 Cloning {git_url}...")
+            click.echo("   This may take a moment depending on repository size...")
+
+            # Clone with progress
+            Repo.clone_from(git_url, target_path, progress=self._get_git_progress())
+
+            # Verify clone succeeded
+            if not (target_path / ".git").exists():
+                click.echo("❌ Clone appeared to succeed but .git directory not found")
+                return None
+
+            click.echo(f"✅ Successfully cloned to: {target_path}")
+            return (target_path, git_url)
+
+        except GitCommandError as e:
+            click.echo("❌ Git clone failed")
+
+            # Parse error message for common issues
+            error_str = str(e).lower()
+            if "authentication failed" in error_str or "permission denied" in error_str:
+                click.echo("🔐 Authentication required")
+                click.echo("   For HTTPS: Configure Git credentials or use a personal access token")
+                click.echo("   For SSH: Ensure your SSH key is added to your Git provider")
+            elif "not found" in error_str or "does not exist" in error_str:
+                click.echo("🔍 Repository not found")
+                click.echo("   Check the URL and ensure you have access")
+            elif "network" in error_str or "timeout" in error_str:
+                click.echo("🌐 Network error")
+                click.echo("   Check your internet connection and try again")
+            else:
+                logger.debug(f"Git clone error type: {type(e).__name__}")
+
+            return None
+
+        except OSError as e:
+            error_type = type(e).__name__
+            click.echo(f"❌ File system error: {error_type}")
+            if "space" in str(e).lower():
+                click.echo("💾 Insufficient disk space")
+            logger.debug(f"Clone file system error: {error_type}")
+            return None
+
+        except Exception as e:
+            error_type = type(e).__name__
+            click.echo(f"❌ Unexpected error during clone: {error_type}")
+            logger.error(f"Clone error type: {error_type}")
+            return None
+
+    def _normalize_git_url(self, url: str) -> str:
+        """Normalize Git URL for comparison.
+
+        Args:
+            url: Git URL to normalize
+
+        Returns:
+            Normalized URL (lowercase, with .git extension)
+        """
+        url = url.lower().strip()
+        if not url.endswith(".git"):
+            url = url + ".git"
+        return url
+
+    def _get_git_progress(self):
+        """Get a Git progress handler for clone operations.
+
+        Returns:
+            Progress handler for GitPython or None
+        """
+        try:
+            from git import RemoteProgress
+
+            class CloneProgress(RemoteProgress):
+                """Progress handler for git clone operations."""
+
+                def __init__(self):
+                    super().__init__()
+                    self.last_percent = 0
+
+                def update(self, op_code, cur_count, max_count=None, message=""):
+                    if max_count:
+                        percent = int((cur_count / max_count) * 100)
+                        # Only show updates every 10%
+                        if percent >= self.last_percent + 10:
+                            click.echo(f"   Progress: {percent}%")
+                            self.last_percent = percent
+
+            return CloneProgress()
+        except Exception:
+            # If progress handler fails, return None (clone will work without it)
+            return None
+
     def _setup_manual_repos(self) -> bool:
         """Setup manual repository configuration.
 
@@ -497,44 +698,66 @@ class InstallWizard:
             True if setup successful, False otherwise
         """
         click.echo("\n📦 Manual Repository Mode")
-        click.echo("You can specify one or more local repository paths.")
+        click.echo("You can specify one or more local repository paths or Git URLs.")
+        click.echo("Supported formats:")
+        click.echo("  • Local path: /path/to/repo or ~/repos/myproject")
+        click.echo("  • HTTPS URL: https://github.com/owner/repo.git")
+        click.echo("  • SSH URL: git@github.com:owner/repo.git")
         click.echo()
 
         repositories = []
         while True:
-            repo_path_str = click.prompt(
-                "Enter repository path (or press Enter to finish)",
+            repo_input = click.prompt(
+                "Enter repository path or Git URL (or press Enter to finish)",
                 type=str,
                 default="",
                 show_default=False,
             ).strip()
 
-            if not repo_path_str:
+            if not repo_input:
                 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):
+            # Check if input is a Git URL
+            git_url = self._detect_git_url(repo_input)
+            if git_url:
+                # Handle Git URL cloning
+                result = self._clone_git_repository(git_url)
+                if result is None:
+                    # Clone failed, ask user if they want to retry or skip
+                    if not click.confirm("Try a different repository?", default=True):
+                        if repositories:
+                            break  # User has other repos, can finish
+                        continue  # User has no repos yet, must add at least one
                     continue
 
-            # Check if it's a git repository
-            if (path_obj / ".git").exists():
-                click.echo(f"✅ Valid git repository: {path_obj}")
+                # Clone successful
+                local_path, original_url = result
+                repositories.append({"path": str(local_path), "git_url": original_url})
+                click.echo(f"Added repository #{len(repositories)}")
             else:
-                click.echo(f"⚠️  Not a git repository: {path_obj}")
-                if not click.confirm("Add anyway?", default=False):
-                    continue
+                # Handle local path
+                path_obj = self._validate_directory_path(repo_input, "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
 
-            repositories.append({"path": str(path_obj)})
-            click.echo(f"Added repository #{len(repositories)}")
+                repositories.append({"path": str(path_obj)})
+                click.echo(f"Added repository #{len(repositories)}")
 
             if not click.confirm("Add another repository?", default=False):
                 break

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/src/gitflow_analytics/config/loader.py

@@ -258,7 +258,14 @@ class ConfigLoader:
         jira_integration_config = cls._process_jira_integration_config(
             data.get("jira_integration", {})
         )
-        qualitative_config = cls._process_qualitative_config(data.get("qualitative", {}))
+
+        # Check for qualitative config in both top-level and nested under analysis
+        # Prioritize top-level for backward compatibility, but support nested location
+        qualitative_data = data.get("qualitative", {})
+        if not qualitative_data and "analysis" in data:
+            qualitative_data = data["analysis"].get("qualitative", {})
+        qualitative_config = cls._process_qualitative_config(qualitative_data)
+
         pm_config = cls._process_pm_config(data.get("pm", {}))
         pm_integration_config = cls._process_pm_integration_config(data.get("pm_integration", {}))
 
@@ -536,6 +543,12 @@ class ConfigLoader:
             BranchAnalysisConfig(**branch_data) if branch_data else BranchAnalysisConfig()
         )
 
+        # Process qualitative configuration (support nested under analysis)
+        qualitative_data = analysis_data.get("qualitative", {})
+        qualitative_config = (
+            cls._process_qualitative_config(qualitative_data) if qualitative_data else None
+        )
+
         # Process aliases file and manual identity mappings
         manual_mappings = list(analysis_data.get("identity", {}).get("manual_mappings", []))
         aliases_file_path = None
@@ -595,6 +608,7 @@ class ConfigLoader:
             commit_classification=commit_classification_config,
             llm_classification=llm_classification_config,
             security=analysis_data.get("security", {}),
+            qualitative=qualitative_config,
         )
 
     @classmethod

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/src/gitflow_analytics/config/schema.py

@@ -316,6 +316,7 @@ class AnalysisConfig:
     )
     llm_classification: LLMClassificationConfig = field(default_factory=LLMClassificationConfig)
     security: Optional[dict[str, Any]] = field(default_factory=dict)  # Security configuration
+    qualitative: Optional["QualitativeConfig"] = None  # Nested qualitative config support
 
 
 @dataclass

{gitflow_analytics-3.9.3 → gitflow_analytics-3.10.6}/src/gitflow_analytics.egg-info/PKG-INFO

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