octotui 0.1.3__py3-none-any.whl

octotui/gac_integration.py

@@ -0,0 +1,183 @@
+"""GAC (Git Auto Commit) integration for Octotui.
+
+This module provides the main integration class for GAC functionality,
+including commit message generation using AI models.
+"""
+
+from pathlib import Path
+from typing import Optional, Dict
+
+# TODO: Add unit tests for commit message generation
+# TODO: Add integration tests for GAC configuration loading
+# TODO: Test error handling for missing API keys
+
+# Graceful GAC import handling - app should work even if GAC is not installed
+try:
+    import gac
+
+    GAC_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    GAC_AVAILABLE = False
+    gac = None  # type: ignore
+
+from octotui.gac_provider_registry import GACProviderRegistry
+
+
+class GACIntegration:
+    """Integration class for GAC (Git Auto Commit) functionality.
+
+    This class handles loading GAC configuration and generating commit messages
+    using the GAC library with proper validation and error handling.
+    """
+
+    def __init__(self, git_sidebar):
+        """Initialize GAC integration.
+
+        Args:
+            git_sidebar: GitStatusSidebar instance for accessing git status/diff
+        """
+        self.git_sidebar = git_sidebar
+        self.config = self._load_config()
+
+    def _load_config(self) -> Optional[Dict[str, str]]:
+        """Load GAC configuration from ~/.gac.env file.
+
+        Returns:
+            Dict of config values, or None if file doesn't exist
+        """
+        gac_env_file = Path.home() / ".gac.env"
+        if not gac_env_file.exists():
+            return None
+
+        config = {}
+        try:
+            with open(gac_env_file, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if line and "=" in line and not line.startswith("#"):
+                        key, value = line.split("=", 1)
+                        config[key.strip()] = value.strip().strip("\"'")
+            self.config = config
+            return config
+        except Exception:
+            return None
+
+    def is_configured(self) -> bool:
+        """Check if GAC is properly configured.
+
+        Returns:
+            True if configuration exists and is valid
+        """
+        self.config = self._load_config()
+        if not self.config:
+            return False
+        return True
+
+    def generate_commit_message(
+        self,
+        staged_only: bool = True,
+        one_liner: bool = False,
+        verbose: bool = False,
+        hint: str = "",
+        scope: Optional[str] = None,
+    ) -> Optional[str]:
+        """Generate a commit message using GAC with stable tuple-based API.
+
+        This method uses GAC's stable public API with tuple-based prompts:
+        - gac.build_prompt() returns (system_prompt, user_prompt)
+        - gac.generate_commit_message() accepts prompt=(system, user)
+
+        Args:
+            staged_only: Only include staged changes in the commit
+            one_liner: Generate a single-line commit message
+            verbose: Generate a more detailed commit message
+            hint: Optional hint to guide the AI commit message generation
+            scope: Optional scope for the commit (currently unused by GAC)
+
+        Returns:
+            Generated commit message string, or None if generation fails
+
+        Raises:
+            ImportError: If GAC package is not installed
+            ValueError: If GAC is not configured, no changes exist, or generation fails
+        """
+        # Check if GAC is available before attempting to use it
+        if not GAC_AVAILABLE or gac is None:
+            raise ImportError(
+                "GAC package not found. Install with: uv pip install 'gac>=0.18.0'\n"
+                "GAC provides AI-powered commit message generation."
+            )
+
+        if not self.is_configured():
+            raise ValueError("GAC is not configured. Please configure it first.")
+
+        try:
+            # Get git status and diff from sidebar
+            status = self.git_sidebar.get_git_status()
+            if staged_only:
+                diff = self.git_sidebar.get_staged_diff()
+            else:
+                diff = self.git_sidebar.get_full_diff()
+
+            if not diff.strip():
+                raise ValueError("No changes to commit")
+
+            # Get diff stat for file changes summary (required by GAC)
+            # This provides a summary like: "file1.py | 10 +++++-----"
+            try:
+                if staged_only:
+                    diff_stat = (
+                        self.git_sidebar.repo.git.diff("--cached", "--stat")
+                        if self.git_sidebar.repo
+                        else ""
+                    )
+                else:
+                    diff_stat = (
+                        self.git_sidebar.repo.git.diff("--stat")
+                        if self.git_sidebar.repo
+                        else ""
+                    )
+            except Exception:
+                diff_stat = ""  # Fallback to empty if stat fails
+
+            # Build the prompt using GAC's stable API (safe because we checked GAC_AVAILABLE above)
+            # Returns tuple: (system_prompt, user_prompt)
+            # Note: verbose parameter not supported in GAC 1.4.1 - upgrade GAC to use it:
+            #       uv pip install --upgrade gac
+            system_prompt, user_prompt = gac.build_prompt(  # type: ignore
+                status=status,
+                processed_diff=diff,
+                diff_stat=diff_stat,  # Required parameter for GAC
+                one_liner=one_liner,
+                hint=hint,
+            )
+
+            # Get the configured model
+            model = self.config.get("GAC_MODEL")
+            if not model:
+                raise ValueError("GAC_MODEL not set in configuration")
+
+            # Validate model format (provider:model)
+            registry = GACProviderRegistry()
+            is_valid, error_msg = registry.validate_model_format(model)
+            if not is_valid:
+                raise ValueError(f"Invalid model format: {error_msg}")
+
+            # Generate commit message using tuple-based prompt format
+            # This is the stable public API as of GAC latest versions
+            commit_message = gac.generate_commit_message(  # type: ignore
+                model=model, prompt=(system_prompt, user_prompt), quiet=True
+            )
+
+            if not commit_message or not commit_message.strip():
+                raise ValueError("GAC returned an empty commit message")
+
+            return commit_message.strip()
+
+        except ValueError:
+            # Re-raise ValueError as-is (these are our validation errors)
+            raise
+        except Exception as e:
+            # Wrap other exceptions with more context
+            error_type = type(e).__name__
+            raise ValueError(f"GAC generation failed ({error_type}): {str(e)}")

octotui/gac_provider_registry.py

@@ -0,0 +1,199 @@
+"""GAC provider registry - extracts providers from GAC at runtime."""
+
+import logging
+import re
+from typing import Dict, Tuple, Optional
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Try to import from GAC
+try:
+    import gac
+    from gac import init_cli
+
+    GAC_AVAILABLE = True
+except (ImportError, ModuleNotFoundError):
+    GAC_AVAILABLE = False
+    gac = None  # type: ignore
+    init_cli = None  # type: ignore
+
+
+def _extract_providers_from_gac() -> Optional[Dict[str, Tuple[str, str]]]:
+    """Extract provider list from GAC's init_cli module by reading source file.
+
+    Returns:
+        Dict mapping provider_key -> (display_name, default_model), or None if extraction fails
+    """
+    if not GAC_AVAILABLE or init_cli is None:
+        return None
+
+    try:
+        # Get the module file path
+        module_file = Path(init_cli.__file__)
+        if not module_file.exists():
+            logger.debug(f"GAC init_cli file not found: {module_file}")
+            return None
+
+        # Read the source file
+        source = module_file.read_text(encoding="utf-8")
+
+        # Find the providers list in _configure_model function
+        # Pattern: providers = [ ... ("Name", "model"), ... ]
+        # Use bracket-counting to handle nested brackets (e.g., list comprehensions)
+        start_match = re.search(r"providers\s*=\s*\[", source)
+        if not start_match:
+            logger.debug("Could not find providers list in GAC's init_cli")
+            return None
+
+        # Find the matching closing bracket by counting brackets
+        start_pos = start_match.end()
+        bracket_count = 1
+        pos = start_pos
+
+        while pos < len(source) and bracket_count > 0:
+            if source[pos] == "[":
+                bracket_count += 1
+            elif source[pos] == "]":
+                bracket_count -= 1
+            pos += 1
+
+        if bracket_count != 0:
+            logger.debug("Could not find matching closing bracket for providers list")
+            return None
+
+        providers_text = source[start_pos : pos - 1]
+
+        # Parse tuples: ("Display Name", "model")
+        tuple_pattern = r'\("([^"]+)",\s*"([^"]*)"\)'
+        matches = re.findall(tuple_pattern, providers_text)
+
+        if not matches:
+            logger.debug("Could not parse provider tuples from GAC")
+            return None
+
+        # Convert to our format: provider_key -> (display_name, default_model)
+        result = {}
+        for display_name, default_model in matches:
+            # Generate provider key using GAC's logic (from line 112 of init_cli.py)
+            provider_key = (
+                display_name.lower()
+                .replace(".", "")
+                .replace(" ", "-")
+                .replace("(", "")
+                .replace(")", "")
+            )
+            result[provider_key] = (display_name, default_model)
+
+        logger.debug(f"Successfully extracted {len(result)} providers from GAC")
+        return result
+
+    except Exception as e:
+        logger.debug(f"Failed to extract providers from GAC: {e}")
+        return None
+
+
+class GACProviderRegistry:
+    """Registry for GAC AI providers - extracts from GAC at runtime."""
+
+    # Cache for extracted providers
+    _cached_providers: Optional[Dict[str, Tuple[str, str]]] = None
+
+    @classmethod
+    def get_supported_providers(cls) -> Dict[str, Tuple[str, str]]:
+        """Get dictionary of supported providers from GAC.
+
+        Returns:
+            Dict mapping provider_key -> (display_name, default_model)
+        """
+        # Use cache if available
+        if cls._cached_providers is not None:
+            return cls._cached_providers.copy()
+
+        # Try to extract from GAC
+        if GAC_AVAILABLE:
+            providers = _extract_providers_from_gac()
+            if providers:
+                cls._cached_providers = providers
+                logger.info(f"Loaded {len(providers)} providers from GAC")
+                return providers.copy()
+
+        # Fallback: return empty dict with warning
+        logger.warning(
+            "Could not load providers from GAC - GAC may not be installed or provider extraction failed. Provider list will be empty."
+        )
+        return {}
+
+    @classmethod
+    def get_suggested_models(cls, provider: str) -> list[str]:
+        """Get list of suggested models for a provider.
+
+        Args:
+            provider: Provider key (e.g., "anthropic", "openai")
+
+        Returns:
+            List of suggested model names
+        """
+        providers = cls.get_supported_providers()
+        if provider not in providers:
+            return []
+
+        _, default_model = providers[provider]
+        if not default_model:
+            return []
+
+        return [default_model]
+
+    @classmethod
+    def get_default_model(cls, provider: str) -> str:
+        """Get the default model for a provider.
+
+        Args:
+            provider: Provider key
+
+        Returns:
+            Default model name, or empty string if none
+        """
+        providers = cls.get_supported_providers()
+        if provider not in providers:
+            return ""
+
+        _, default_model = providers[provider]
+        return default_model
+
+    @classmethod
+    def is_local_provider(cls, provider: str) -> bool:
+        """Check if provider is local (no API key needed).
+
+        Args:
+            provider: Provider key
+
+        Returns:
+            True if local provider
+        """
+        return provider in ("ollama", "lm-studio")
+
+    @classmethod
+    def validate_model_format(cls, model: str) -> Tuple[bool, str]:
+        """Validate model string format.
+
+        Args:
+            model: Full model string (provider:model)
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not model:
+            return False, "Model cannot be empty"
+
+        if ":" not in model:
+            return False, "Model must be in format 'provider:model'"
+
+        provider, model_name = model.split(":", 1)
+
+        if not provider.strip():
+            return False, "Provider name cannot be empty"
+        if not model_name.strip():
+            return False, "Model name cannot be empty"
+
+        return True, ""