crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/config/__init__.py

@@ -1,3 +1,60 @@
+from contextlib import suppress
+from pathlib import Path
+
+from acb.console import Console
+from acb.depends import depends
+from acb.logger import Logger
+
+# Import protocols for service registration
+from crackerjack.models.protocols import (
+    ChangelogGeneratorProtocol,
+    CoverageBadgeServiceProtocol,
+    CoverageRatchetProtocol,
+    DebugServiceProtocol,
+    GitServiceProtocol,
+    LoggerProtocol,
+    MemoryOptimizerProtocol,
+    PerformanceBenchmarkProtocol,
+    PerformanceCacheProtocol,
+    PerformanceMonitorProtocol,
+    QualityBaselineProtocol,
+    QualityIntelligenceProtocol,
+    VersionAnalyzerProtocol,
+)
+from crackerjack.services.changelog_automation import ChangelogGenerator
+from crackerjack.services.coverage_badge_service import CoverageBadgeService
+from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+# Import service implementations
+from crackerjack.services.debug import get_ai_agent_debugger
+from crackerjack.services.git import GitService
+from crackerjack.services.lsp_client import LSPClient
+from crackerjack.services.memory_optimizer import MemoryOptimizer
+from crackerjack.services.monitoring.performance_benchmarks import (
+    PerformanceBenchmarkService,
+)
+from crackerjack.services.monitoring.performance_cache import (
+    FileSystemCache,
+    GitOperationCache,
+    get_filesystem_cache,
+    get_git_cache,
+    get_performance_cache,
+)
+from crackerjack.services.monitoring.performance_monitor import get_performance_monitor
+from crackerjack.services.parallel_executor import (
+    AsyncCommandExecutor,
+    ParallelHookExecutor,
+    get_async_executor,
+    get_parallel_executor,
+)
+from crackerjack.services.quality.quality_baseline_enhanced import (
+    EnhancedQualityBaselineService,
+)
+from crackerjack.services.quality.quality_intelligence import (
+    QualityIntelligenceService,
+)
+from crackerjack.services.version_analyzer import VersionAnalyzer
+
 from .hooks import (
     COMPREHENSIVE_STRATEGY,
     FAST_STRATEGY,
@@ -7,6 +64,200 @@ from .hooks import (
     HookStrategy,
     RetryPolicy,
 )
+from .loader import load_settings, load_settings_async
+from .settings import CrackerjackSettings
+
+
+def get_console_width() -> int:
+    """Return the preferred console width from settings or pyproject.
+
+    Priority:
+    1) ACB settings (CrackerjackSettings.console.width)
+    2) pyproject.toml [tool.crackerjack].terminal_width
+    3) Default: 70
+    """
+    # 1) Try ACB settings via DI
+    with suppress(Exception):
+        settings = depends.get_sync(CrackerjackSettings)
+        width = getattr(getattr(settings, "console", None), "width", None)
+        if isinstance(width, int) and width > 0:
+            return width
+
+    # 2) Try pyproject.toml
+    with suppress(Exception):
+        from pathlib import Path as _P
+
+        import tomli
+
+        pyproj = _P("pyproject.toml")
+        if pyproj.exists():
+            with pyproj.open("rb") as f:
+                data = tomli.load(f)
+            width = (
+                data.get("tool", {}).get("crackerjack", {}).get("terminal_width", None)
+            )
+            if isinstance(width, int) and width > 0:
+                return width
+
+    # 3) Default
+    return 70
+
+
+# Load settings from YAML files using layered configuration
+settings_instance = load_settings(CrackerjackSettings)
+depends.set(CrackerjackSettings, settings_instance)
+
+# Register ACB Logger (auto-registers itself, but set explicitly for clarity)
+# But first, ensure we don't have an empty tuple registered for Logger
+from crackerjack.utils.dependency_guard import (
+    ensure_logger_dependency,
+    validate_dependency_registration,
+)
+
+ensure_logger_dependency()
+
+# Explicitly set logger instances if not already set properly
+try:
+    current_logger = depends.get_sync(Logger)
+    if isinstance(current_logger, tuple) and len(current_logger) == 0:
+        logger_instance = Logger()
+        depends.set(Logger, logger_instance)
+        depends.set(LoggerProtocol, logger_instance)  # Also register as LoggerProtocol
+    else:
+        # Logger is already properly registered, just ensure LoggerProtocol is too
+        depends.set(LoggerProtocol, current_logger)
+except Exception:
+    # Logger not registered at all, so register it
+    logger_instance = Logger()
+    depends.set(Logger, logger_instance)
+    depends.set(LoggerProtocol, logger_instance)  # Also register as LoggerProtocol
+
+
+def register_services() -> None:
+    """Register all service instances with ACB dependency injection system.
+
+    Services are registered at application initialization to ensure proper
+    dependency ordering and lifecycle management. This follows ACB's pattern
+    of centralizing service registration rather than having services register
+    themselves or be instantiated in consumers.
+
+    The order of registration is important to ensure that dependencies are met:
+    1.  Core utility services (Debug, Performance Monitoring, Memory, Caching)
+    2.  Specialized cache services (Git, Filesystem)
+    3.  Quality-related services (Baseline, Intelligence)
+    4.  Manager-layer services (Coverage, Git, Versioning, Changelog, LSP)
+    """
+    # 1. Register Debug Service
+    # Uses factory function to handle environment detection
+    debugger = get_ai_agent_debugger()
+    depends.set(DebugServiceProtocol, debugger)
+
+    # 2. Register Performance Monitor
+    # Core performance tracking service
+    performance_monitor = get_performance_monitor()
+    depends.set(PerformanceMonitorProtocol, performance_monitor)
+
+    # 3. Register Memory Optimizer
+    # Memory management and optimization
+    memory_optimizer = MemoryOptimizer.get_instance()
+    depends.set(MemoryOptimizerProtocol, memory_optimizer)
+
+    # 4. Register Performance Cache
+    # Caching layer for performance optimization
+    performance_cache = get_performance_cache()
+    depends.set(PerformanceCacheProtocol, performance_cache)
+
+    # 5. Register Performance Benchmark Service
+    # The service should be registered automatically via @depends.inject
+    # in the service implementation, but if not let's create and register it manually
+    try:
+        # First, try to get the already registered instance
+        try:
+            performance_benchmarks = depends.get_sync(PerformanceBenchmarkProtocol)
+        except Exception:
+            # If not registered, create it using proper DI
+            console = depends.get_sync(Console)
+            logger = depends.get_sync(
+                Logger
+            )  # Get the logger instead of LoggerProtocol
+            pkg_path = Path.cwd()  # Use current directory as fallback
+            performance_benchmarks = PerformanceBenchmarkService(
+                console=console, logger=logger, pkg_path=pkg_path
+            )
+            # Register the newly created instance
+            depends.set(PerformanceBenchmarkProtocol, performance_benchmarks)
+    except Exception as e:
+        # Log the error to help with debugging
+        print(f"WARNING: Failed to register PerformanceBenchmarkService: {e}")
+        # Performance benchmarking will be disabled
+        pass
+
+    # 6. Register Parallel Executor Services
+    # For parallel and async hook execution
+    parallel_executor = get_parallel_executor()
+    depends.set(ParallelHookExecutor, parallel_executor)
+
+    async_executor = get_async_executor()
+    depends.set(AsyncCommandExecutor, async_executor)
+
+    # 7. Register Specialized Cache Services
+    # Git and filesystem caching
+    git_cache = get_git_cache()
+    depends.set(GitOperationCache, git_cache)
+
+    filesystem_cache = get_filesystem_cache()
+    depends.set(FileSystemCache, filesystem_cache)
+
+    # 8. Register Quality Baseline Service
+    # Foundation for quality tracking and intelligence
+    with suppress(Exception):
+        quality_baseline = EnhancedQualityBaselineService()
+        depends.set(QualityBaselineProtocol, quality_baseline)
+
+        # 9. Register Quality Intelligence Service
+        # Depends on quality baseline service
+        quality_intelligence = QualityIntelligenceService(quality_baseline)
+        depends.set(QualityIntelligenceProtocol, quality_intelligence)
+
+    # 10. Register Manager Layer Services
+    # Services used by test_manager.py and publish_manager.py
+
+    # Get console and pkg_path for service initialization
+    with suppress(Exception):
+        console = depends.get_sync(Console)
+        pkg_path = depends.get_sync(Path)
+
+        # 10a. Coverage Ratchet Service (protocol-based)
+        coverage_ratchet = CoverageRatchetService(pkg_path)
+        depends.set(CoverageRatchetProtocol, coverage_ratchet)
+
+        # 10b. Coverage Badge Service (protocol-based)
+        coverage_badge = depends.inject_sync(
+            CoverageBadgeService, console=console, project_root=pkg_path
+        )
+        depends.set(CoverageBadgeServiceProtocol, coverage_badge)
+
+        # 10c. Git Service (protocol-based, foundation for dependent services)
+        git_service = GitService(pkg_path)
+        depends.set(GitServiceProtocol, git_service)
+
+        # 10d. Version Analyzer (protocol-based, depends on git_service)
+        version_analyzer = VersionAnalyzer(git_service)
+        depends.set(VersionAnalyzerProtocol, version_analyzer)
+
+        # 10e. Changelog Generator (protocol-based, ACB DI injects dependencies)
+        changelog_generator = ChangelogGenerator()
+        depends.set(ChangelogGeneratorProtocol, changelog_generator)
+
+        # 10f. LSP Client (concrete type - optional service with graceful fallback)
+        with suppress(Exception):
+            lsp_client = LSPClient()
+            depends.set(LSPClient, lsp_client)
+
+
+# Service registration is called explicitly by application entry point
+# to avoid circular import issues during module initialization.
+# Call register_services() after all modules are loaded, typically in __main__.py
 
 __all__ = [
     "COMPREHENSIVE_STRATEGY",
@@ -16,4 +267,9 @@ __all__ = [
     "HookStage",
     "HookStrategy",
     "RetryPolicy",
+    "CrackerjackSettings",
+    "load_settings",
+    "load_settings_async",
+    "register_services",
+    "get_console_width",
 ]

crackerjack/config/global_lock_config.py

@@ -1,70 +1,207 @@
-import os
+from __future__ import annotations
+
 import socket
-from dataclasses import dataclass, field
+import typing as t
+from contextlib import suppress
 from pathlib import Path
 
-from ..models.protocols import OptionsProtocol
+from acb.depends import depends
 
+from crackerjack.config.settings import CrackerjackSettings, GlobalLockSettings
 
-@dataclass
-class GlobalLockConfig:
-    enabled: bool = True
-    timeout_seconds: float = 600.0
-    stale_lock_hours: float = 2.0
-    lock_directory: Path = field(
-        default_factory=lambda: Path.home() / ".crackerjack" / "locks"
-    )
-    session_heartbeat_interval: float = 30.0
-    max_retry_attempts: int = 3
-    retry_delay_seconds: float = 5.0
-    enable_lock_monitoring: bool = True
 
-    @classmethod
-    def from_options(
-        cls: type["GlobalLockConfig"], options: "OptionsProtocol"
-    ) -> "GlobalLockConfig":
-        enabled = not options.disable_global_locks
-        timeout_seconds = float(options.global_lock_timeout)
-
-        default_lock_dir = Path.home() / ".crackerjack" / "locks"
-        lock_directory = (
-            Path(options.global_lock_dir)
-            if options.global_lock_dir
-            else default_lock_dir
+class GlobalLockConfig:
+    """Compatibility wrapper for global lock settings.
+
+    Supports both APIs:
+    - New API: GlobalLockConfig(settings=GlobalLockSettings(...))
+    - Old API: GlobalLockConfig(lock_directory=path, timeout_seconds=600, ...)
+    """
+
+    def _should_build_from_compatibility_params(
+        self,
+        enabled: bool | None,
+        timeout_seconds: float | None,
+        stale_lock_hours: float | None,
+        lock_directory: Path | None,
+        session_heartbeat_interval: float | None,
+        max_retry_attempts: int | None,
+        retry_delay_seconds: float | None,
+        enable_lock_monitoring: bool | None,
+    ) -> bool:
+        """Check if any backwards compatibility parameters are provided."""
+        return any(
+            param is not None
+            for param in (
+                enabled,
+                timeout_seconds,
+                stale_lock_hours,
+                lock_directory,
+                session_heartbeat_interval,
+                max_retry_attempts,
+                retry_delay_seconds,
+                enable_lock_monitoring,
+            )
         )
 
-        config = cls(
-            enabled=enabled,
-            timeout_seconds=timeout_seconds,
-            lock_directory=lock_directory,
+    def _build_settings_from_compatibility_params(
+        self,
+        enabled: bool | None,
+        timeout_seconds: float | None,
+        stale_lock_hours: float | None,
+        lock_directory: Path | None,
+        session_heartbeat_interval: float | None,
+        max_retry_attempts: int | None,
+        retry_delay_seconds: float | None,
+        enable_lock_monitoring: bool | None,
+    ) -> GlobalLockSettings:
+        """Build settings from backwards compatibility parameters."""
+        # Get defaults from CrackerjackSettings
+        default_settings = depends.get_sync(CrackerjackSettings).global_lock
+        # Create a copy with overrides
+        settings_dict = {
+            "enabled": enabled if enabled is not None else default_settings.enabled,
+            "timeout_seconds": (
+                timeout_seconds
+                if timeout_seconds is not None
+                else default_settings.timeout_seconds
+            ),
+            "stale_lock_hours": (
+                stale_lock_hours
+                if stale_lock_hours is not None
+                else default_settings.stale_lock_hours
+            ),
+            "lock_directory": (
+                lock_directory
+                if lock_directory is not None
+                else default_settings.lock_directory
+            ),
+            "session_heartbeat_interval": (
+                session_heartbeat_interval
+                if session_heartbeat_interval is not None
+                else default_settings.session_heartbeat_interval
+            ),
+            "max_retry_attempts": (
+                max_retry_attempts
+                if max_retry_attempts is not None
+                else default_settings.max_retry_attempts
+            ),
+            "retry_delay_seconds": (
+                retry_delay_seconds
+                if retry_delay_seconds is not None
+                else default_settings.retry_delay_seconds
+            ),
+            "enable_lock_monitoring": (
+                enable_lock_monitoring
+                if enable_lock_monitoring is not None
+                else default_settings.enable_lock_monitoring
+            ),
+        }
+        return GlobalLockSettings(**settings_dict)
+
+    def __init__(
+        self,
+        settings: GlobalLockSettings | None = None,
+        # Backwards compatibility parameters
+        enabled: bool | None = None,
+        timeout_seconds: float | None = None,
+        stale_lock_hours: float | None = None,
+        lock_directory: Path | None = None,
+        session_heartbeat_interval: float | None = None,
+        max_retry_attempts: int | None = None,
+        retry_delay_seconds: float | None = None,
+        enable_lock_monitoring: bool | None = None,
+    ) -> None:
+        # If any backwards compatibility parameters are provided, build settings from them
+        if self._should_build_from_compatibility_params(
+            enabled,
+            timeout_seconds,
+            stale_lock_hours,
+            lock_directory,
+            session_heartbeat_interval,
+            max_retry_attempts,
+            retry_delay_seconds,
+            enable_lock_monitoring,
+        ):
+            settings = self._build_settings_from_compatibility_params(
+                enabled,
+                timeout_seconds,
+                stale_lock_hours,
+                lock_directory,
+                session_heartbeat_interval,
+                max_retry_attempts,
+                retry_delay_seconds,
+                enable_lock_monitoring,
+            )
+
+        base_settings = settings or depends.get_sync(CrackerjackSettings).global_lock
+        self._settings = base_settings.model_copy()
+        self.session_id = (
+            getattr(self._settings, "session_id", None) or self._generate_session_id()
         )
+        self.hostname = (
+            getattr(self._settings, "hostname", None) or socket.gethostname()
+        )
+        self._ensure_lock_directory()
 
-        return config
-
-    def __post_init__(self) -> None:
-        self.lock_directory.mkdir(parents=True, exist_ok=True)
+    @staticmethod
+    def _generate_session_id() -> str:
+        import uuid
 
-        self.lock_directory.chmod(0o700)
+        return uuid.uuid4().hex[:8]
 
-    @property
-    def hostname(self) -> str:
-        return socket.gethostname()
+    def _ensure_lock_directory(self) -> None:
+        lock_dir = self._settings.lock_directory
+        lock_dir.mkdir(parents=True, exist_ok=True)
+        # Enforce secure permissions (owner rwx only)
+        with suppress(Exception):
+            lock_dir.chmod(0o700)
 
-    @property
-    def session_id(self) -> str:
-        return f"{self.hostname}_{os.getpid()}"
+    def __getattr__(self, item: str):
+        return getattr(self._settings, item)
 
     def get_lock_path(self, hook_name: str) -> Path:
-        return self.lock_directory / f"{hook_name}.lock"
-
-    def get_heartbeat_path(self, hook_name: str) -> Path:
-        return self.lock_directory / f"{hook_name}.heartbeat"
-
-    def is_valid_lock_file(self, lock_path: Path) -> bool:
-        if not lock_path.exists():
-            return False
+        safe_name = hook_name.replace("/", "_")
+        return self._settings.lock_directory / f"{safe_name}.lock"
 
-        import time
-
-        file_age_hours = (time.time() - lock_path.stat().st_mtime) / 3600
-        return file_age_hours < self.stale_lock_hours
+    @classmethod
+    def from_options(cls, options: t.Any) -> GlobalLockConfig:
+        """Create GlobalLockConfig from CLI options object.
+
+        Supports two formats:
+        1. Nested: options.global_lock with GlobalLockSettings-like fields
+        2. Flat: options with global_lock_* prefixed fields (from CLI)
+
+        Synchronous method - no async operations needed.
+        """
+        base_settings = depends.get_sync(CrackerjackSettings).global_lock
+        overrides = getattr(options, "global_lock", None)
+
+        # Handle nested global_lock object
+        if overrides is not None:
+            custom = base_settings.model_copy()
+            for field in custom.model_fields:
+                if hasattr(overrides, field):
+                    setattr(custom, field, getattr(overrides, field))
+            return cls(custom)
+
+        # Handle flat CLI options with global_lock_* prefix
+        params: dict[str, t.Any] = {}
+        if hasattr(options, "disable_global_locks"):
+            params["enabled"] = not options.disable_global_locks
+        if hasattr(options, "global_lock_timeout"):
+            params["timeout_seconds"] = float(options.global_lock_timeout)
+        if hasattr(options, "global_lock_dir") and options.global_lock_dir:
+            params["lock_directory"] = Path(options.global_lock_dir)
+        # Note: global_lock_cleanup is handled at runtime, not in config
+
+        # If any options were provided, create config with them
+        if params:
+            return cls(**params)
+
+        # Otherwise use defaults
+        return cls(base_settings)
+
+
+def get_global_lock_config() -> GlobalLockConfig:
+    return GlobalLockConfig()