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

gitflow_analytics/config/profiles.py

@@ -0,0 +1,264 @@
+"""Configuration profiles and presets for GitFlow Analytics."""
+
+from typing import Any, Optional
+
+
+class ConfigurationProfile:
+    """Base class for configuration profiles."""
+
+    name: str = ""
+    description: str = ""
+
+    @classmethod
+    def get_settings(cls) -> dict[str, Any]:
+        """Get the profile settings.
+
+        Returns:
+            Dictionary of configuration settings for this profile
+        """
+        raise NotImplementedError
+
+
+class PerformanceProfile(ConfigurationProfile):
+    """Performance-optimized configuration profile.
+
+    This profile prioritizes speed over accuracy and completeness.
+    Suitable for large codebases or quick analysis runs.
+    """
+
+    name = "performance"
+    description = "Optimized for speed with large repositories"
+
+    @classmethod
+    def get_settings(cls) -> dict[str, Any]:
+        """Get performance-optimized settings."""
+        return {
+            "analysis": {
+                "branch_analysis": {
+                    "strategy": "main_only",
+                    "max_branches_per_repo": 10,
+                    "branch_commit_limit": 500,
+                },
+                "ml_categorization": {
+                    "enabled": False,  # Disable ML for speed
+                    "batch_size": 500,
+                },
+                "commit_classification": {
+                    "enabled": False,  # Disable classification for speed
+                },
+                "llm_classification": {
+                    "enabled": False,  # Disable LLM for speed
+                },
+            },
+            "cache": {
+                "ttl_hours": 336,  # 2 weeks cache
+                "max_size_mb": 1000,
+            },
+            "output": {
+                "formats": ["csv"],  # CSV only for speed
+            },
+        }
+
+
+class QualityProfile(ConfigurationProfile):
+    """Quality-focused configuration profile.
+
+    This profile enables all analysis features for maximum insight.
+    Suitable for detailed analysis and reporting.
+    """
+
+    name = "quality"
+    description = "Maximum analysis depth and accuracy"
+
+    @classmethod
+    def get_settings(cls) -> dict[str, Any]:
+        """Get quality-focused settings."""
+        return {
+            "analysis": {
+                "branch_analysis": {
+                    "strategy": "smart",
+                    "max_branches_per_repo": 100,
+                    "active_days_threshold": 180,
+                    "branch_commit_limit": 2000,
+                },
+                "ml_categorization": {
+                    "enabled": True,
+                    "min_confidence": 0.7,
+                    "semantic_weight": 0.8,
+                    "batch_size": 50,
+                },
+                "commit_classification": {
+                    "enabled": True,
+                    "confidence_threshold": 0.6,
+                    "auto_retrain": True,
+                },
+                "auto_identity_analysis": True,
+            },
+            "cache": {
+                "ttl_hours": 72,  # Shorter cache for freshness
+                "max_size_mb": 500,
+            },
+            "output": {
+                "formats": ["csv", "markdown", "json"],
+            },
+        }
+
+
+class BalancedProfile(ConfigurationProfile):
+    """Balanced configuration profile.
+
+    This profile provides a good balance between performance and quality.
+    Suitable for most use cases.
+    """
+
+    name = "balanced"
+    description = "Balanced performance and quality (default)"
+
+    @classmethod
+    def get_settings(cls) -> dict[str, Any]:
+        """Get balanced settings."""
+        return {
+            "analysis": {
+                "branch_analysis": {
+                    "strategy": "smart",
+                    "max_branches_per_repo": 50,
+                    "active_days_threshold": 90,
+                    "branch_commit_limit": 1000,
+                },
+                "ml_categorization": {
+                    "enabled": True,
+                    "min_confidence": 0.6,
+                    "semantic_weight": 0.7,
+                    "batch_size": 100,
+                },
+                "commit_classification": {
+                    "enabled": True,
+                    "confidence_threshold": 0.5,
+                },
+            },
+            "cache": {
+                "ttl_hours": 168,  # 1 week
+                "max_size_mb": 500,
+            },
+            "output": {
+                "formats": ["csv", "markdown"],
+            },
+        }
+
+
+class MinimalProfile(ConfigurationProfile):
+    """Minimal configuration profile.
+
+    This profile runs only essential analysis features.
+    Suitable for basic metrics and quick overview.
+    """
+
+    name = "minimal"
+    description = "Essential features only"
+
+    @classmethod
+    def get_settings(cls) -> dict[str, Any]:
+        """Get minimal settings."""
+        return {
+            "analysis": {
+                "branch_analysis": {
+                    "strategy": "main_only",
+                },
+                "ml_categorization": {
+                    "enabled": False,
+                },
+                "commit_classification": {
+                    "enabled": False,
+                },
+                "llm_classification": {
+                    "enabled": False,
+                },
+                "auto_identity_analysis": False,
+            },
+            "output": {
+                "formats": ["csv"],
+            },
+            "cache": {
+                "ttl_hours": 720,  # 30 days
+            },
+        }
+
+
+class ProfileManager:
+    """Manages configuration profiles."""
+
+    # Registry of available profiles
+    _profiles: dict[str, type[ConfigurationProfile]] = {
+        "performance": PerformanceProfile,
+        "quality": QualityProfile,
+        "balanced": BalancedProfile,
+        "minimal": MinimalProfile,
+    }
+
+    @classmethod
+    def get_profile(cls, name: str) -> Optional[type[ConfigurationProfile]]:
+        """Get a configuration profile by name.
+
+        Args:
+            name: Profile name
+
+        Returns:
+            Profile class or None if not found
+        """
+        return cls._profiles.get(name.lower())
+
+    @classmethod
+    def list_profiles(cls) -> dict[str, str]:
+        """List available profiles.
+
+        Returns:
+            Dictionary of profile names to descriptions
+        """
+        return {name: profile.description for name, profile in cls._profiles.items()}
+
+    @classmethod
+    def apply_profile(cls, config_data: dict[str, Any], profile_name: str) -> dict[str, Any]:
+        """Apply a profile to configuration data.
+
+        Args:
+            config_data: Base configuration data
+            profile_name: Name of profile to apply
+
+        Returns:
+            Updated configuration data with profile settings
+
+        Raises:
+            ValueError: If profile not found
+        """
+        profile_class = cls.get_profile(profile_name)
+        if not profile_class:
+            available = ", ".join(cls._profiles.keys())
+            raise ValueError(
+                f"Unknown configuration profile: {profile_name}. "
+                f"Available profiles: {available}"
+            )
+
+        profile_settings = profile_class.get_settings()
+        # Profile settings are the base, config_data overrides them
+        return cls._deep_merge(profile_settings, config_data)
+
+    @staticmethod
+    def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+        """Deep merge two dictionaries.
+
+        Args:
+            base: Base dictionary
+            override: Dictionary with values to override
+
+        Returns:
+            Merged dictionary
+        """
+        result = base.copy()
+
+        for key, value in override.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = ProfileManager._deep_merge(result[key], value)
+            else:
+                result[key] = value
+
+        return result

gitflow_analytics/config/repository.py

@@ -0,0 +1,124 @@
+"""Repository discovery and management for GitFlow Analytics."""
+
+from pathlib import Path
+from typing import Optional
+
+from github import Github
+
+from .schema import GitHubConfig, RepositoryConfig
+
+
+class RepositoryManager:
+    """Manages repository discovery and configuration."""
+
+    def __init__(self, github_config: GitHubConfig):
+        """Initialize repository manager.
+
+        Args:
+            github_config: GitHub configuration
+        """
+        self.github_config = github_config
+
+    def discover_organization_repositories(
+        self, clone_base_path: Optional[Path] = None
+    ) -> list[RepositoryConfig]:
+        """Discover repositories from GitHub organization.
+
+        Args:
+            clone_base_path: Base directory where repos should be cloned/found.
+
+        Returns:
+            List of discovered repository configurations.
+        """
+        if not self.github_config.organization or not self.github_config.token:
+            return []
+
+        github_client = Github(self.github_config.token, base_url=self.github_config.base_url)
+
+        try:
+            org = github_client.get_organization(self.github_config.organization)
+            discovered_repos = []
+
+            if clone_base_path is None:
+                raise ValueError("No base path available for repository cloning")
+
+            for repo in org.get_repos():
+                # Skip archived repositories
+                if repo.archived:
+                    continue
+
+                # Create repository configuration
+                repo_path = clone_base_path / repo.name
+                repo_config = RepositoryConfig(
+                    name=repo.name,
+                    path=repo_path,
+                    github_repo=repo.full_name,
+                    project_key=repo.name.upper().replace("-", "_"),
+                    branch=repo.default_branch,
+                )
+                discovered_repos.append(repo_config)
+
+            return discovered_repos
+
+        except Exception as e:
+            raise ValueError(
+                f"Failed to discover repositories from organization "
+                f"{self.github_config.organization}: {e}"
+            ) from e
+
+    def process_repository_config(
+        self, repo_data: dict, index: int, config_path: Path
+    ) -> RepositoryConfig:
+        """Process a single repository configuration entry.
+
+        Args:
+            repo_data: Repository configuration data
+            index: Repository index in the list (for error messages)
+            config_path: Path to configuration file (for error messages)
+
+        Returns:
+            RepositoryConfig instance
+
+        Raises:
+            ValueError: If repository configuration is invalid
+        """
+        from .errors import InvalidValueError, MissingFieldError
+
+        # Validate required repository fields
+        if not isinstance(repo_data, dict):
+            raise InvalidValueError(
+                f"repositories[{index}]",
+                type(repo_data).__name__,
+                "must be a YAML object with name and path",
+                config_path,
+                valid_values=["object with 'name' and 'path' fields"],
+            )
+
+        if "name" not in repo_data or repo_data["name"] is None:
+            raise MissingFieldError(
+                "name", f"repositories[{index}]", config_path, example='name: "your-repo-name"'
+            )
+
+        if "path" not in repo_data or repo_data["path"] is None:
+            raise MissingFieldError(
+                "path",
+                f"repositories[{index}] ('{repo_data.get('name', 'unknown')}')",
+                config_path,
+                example='path: "/path/to/repo"',
+            )
+
+        # Handle github_repo with owner/organization fallback
+        github_repo = repo_data.get("github_repo")
+        if github_repo and "/" not in github_repo:
+            if self.github_config.organization:
+                github_repo = f"{self.github_config.organization}/{github_repo}"
+            elif self.github_config.owner:
+                github_repo = f"{self.github_config.owner}/{github_repo}"
+
+        return RepositoryConfig(
+            name=repo_data["name"],
+            path=repo_data["path"],
+            github_repo=github_repo,
+            project_key=repo_data.get("project_key"),
+            branch=repo_data.get("branch"),
+        )