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

crackerjack/services/changelog_automation.py

@@ -4,9 +4,10 @@ import re
 from datetime import datetime
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
-from .git import GitService
+from crackerjack.models.protocols import GitServiceProtocol
 
 
 class ChangelogEntry:
@@ -33,7 +34,10 @@ class ChangelogEntry:
 class ChangelogGenerator:
     """Generate and update changelogs based on git commits."""
 
-    def __init__(self, console: Console, git_service: GitService) -> None:
+    @depends.inject
+    def __init__(
+        self, console: Inject[Console], git_service: Inject[GitServiceProtocol]
+    ) -> None:
         self.console = console
         self.git = git_service
 

crackerjack/services/command_execution_service.py

@@ -0,0 +1,305 @@
+"""Unified command execution service with consistent error handling and timeouts."""
+
+import asyncio
+import subprocess
+from pathlib import Path
+
+from loguru import logger
+
+
+class CommandExecutionService:
+    """Unified command execution with consistent error handling, timeouts, and caching."""
+
+    def __init__(self, default_timeout: int = 30):
+        """
+        Initialize the command execution service.
+
+        Args:
+            default_timeout: Default timeout in seconds for commands
+        """
+        self.default_timeout = default_timeout
+
+    async def run_command(
+        self,
+        cmd: str | list[str],
+        cwd: str | Path | None = None,
+        env: dict[str, str] | None = None,
+        timeout: int | None = None,
+        capture_output: bool = True,
+        check: bool = True,
+    ) -> subprocess.CompletedProcess:
+        """
+        Run a command with timeout and error handling.
+
+        Args:
+            cmd: Command to run as a string or list of strings
+            cwd: Working directory to run the command in
+            env: Environment variables to use
+            timeout: Timeout in seconds (uses default if not specified)
+            capture_output: Whether to capture stdout/stderr
+            check: If True, raises exception on non-zero exit code
+
+        Returns:
+            CompletedProcess instance with results
+
+        Raises:
+            subprocess.TimeoutExpired: If command times out
+            subprocess.CalledProcessError: If command fails and check=True
+        """
+        timeout = timeout or self.default_timeout
+        str_cmd = " ".join(cmd) if isinstance(cmd, list) else cmd
+        logger.debug(f"Executing command: {str_cmd}")
+
+        try:
+            self._get_executable(cmd)
+            process = await self._create_subprocess(cmd, capture_output, cwd, env)
+            return await self._execute_process(
+                process, cmd, str_cmd, timeout, check, capture_output
+            )
+        except FileNotFoundError:
+            logger.error(f"Command not found: {self._get_executable(cmd)}")
+            raise
+        except Exception as e:
+            logger.error(f"Command execution failed: {str_cmd}, Error: {e}")
+            raise
+
+    def _get_executable(self, cmd: str | list[str]) -> str:
+        """Extract executable name from command."""
+        if isinstance(cmd, list):
+            return cmd[0] if cmd else ""
+        else:
+            parts = cmd.split()
+            return parts[0] if parts else ""
+
+    async def _create_subprocess(
+        self,
+        cmd: str | list[str],
+        capture_output: bool,
+        cwd: str | Path | None,
+        env: dict[str, str] | None,
+    ) -> asyncio.subprocess.Process:
+        """Create subprocess with proper configuration."""
+        return await asyncio.create_subprocess_exec(
+            *(cmd if isinstance(cmd, list) else cmd.split()),
+            stdout=asyncio.subprocess.PIPE if capture_output else None,
+            stderr=asyncio.subprocess.PIPE if capture_output else None,
+            cwd=cwd,
+            env=env,
+        )
+
+    async def _execute_process(
+        self,
+        process: asyncio.subprocess.Process,
+        cmd: str | list[str],
+        str_cmd: str,
+        timeout: int,
+        check: bool,
+        capture_output: bool,
+    ) -> subprocess.CompletedProcess:
+        """Execute the process and handle the result."""
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=timeout
+            )
+
+            return_code = process.returncode if process.returncode is not None else 0
+            completed_process = subprocess.CompletedProcess(
+                cmd,
+                return_code,
+                stdout.decode() if stdout else None,
+                stderr.decode() if stderr else None,
+            )
+
+            if check and process.returncode != 0:
+                logger.error(
+                    f"Command failed with exit code {process.returncode}: {str_cmd}"
+                )
+                raise subprocess.CalledProcessError(
+                    return_code,
+                    cmd,
+                    output=completed_process.stdout,
+                    stderr=completed_process.stderr,
+                )
+
+            logger.debug(f"Command completed successfully: {str_cmd}")
+            return completed_process
+
+        except TimeoutError:
+            # Handle timeout
+            process.kill()
+            await process.wait()  # Ensure process is cleaned up
+            logger.error(f"Command timed out after {timeout}s: {str_cmd}")
+            raise subprocess.TimeoutExpired(cmd, timeout)
+
+    def run_command_sync(
+        self,
+        cmd: str | list[str],
+        cwd: str | Path | None = None,
+        env: dict[str, str] | None = None,
+        timeout: int | None = None,
+        capture_output: bool = True,
+        check: bool = True,
+    ) -> subprocess.CompletedProcess:
+        """
+        Synchronous version of run_command.
+
+        Args:
+            cmd: Command to run as a string or list of strings
+            cwd: Working directory to run the command in
+            env: Environment variables to use
+            timeout: Timeout in seconds (uses default if not specified)
+            capture_output: Whether to capture stdout/stderr
+            check: If True, raises exception on non-zero exit code
+
+        Returns:
+            CompletedProcess instance with results
+        """
+        timeout = timeout or self.default_timeout
+        str_cmd = " ".join(cmd) if isinstance(cmd, list) else cmd
+
+        try:
+            logger.debug(f"Executing sync command: {str_cmd}")
+
+            result = subprocess.run(
+                cmd,
+                cwd=cwd,
+                env=env,
+                timeout=timeout,
+                capture_output=capture_output,
+                text=True,  # Return strings instead of bytes
+                check=check,
+            )
+
+            logger.debug(f"Sync command completed: {str_cmd}")
+            return result
+
+        except subprocess.TimeoutExpired:
+            logger.error(f"Sync command timed out after {timeout}s: {str_cmd}")
+            raise
+        except Exception as e:
+            logger.error(f"Sync command execution failed: {str_cmd}, Error: {e}")
+            raise
+
+    async def run_multiple_commands(
+        self,
+        commands: list[str | list[str]],
+        cwd: str | Path | None = None,
+        env: dict[str, str] | None = None,
+        timeout: int | None = None,
+        parallel: bool = False,
+    ) -> list[subprocess.CompletedProcess]:
+        """
+        Run multiple commands sequentially or in parallel.
+
+        Args:
+            commands: List of commands to run
+            cwd: Working directory to run the commands in
+            env: Environment variables to use
+            timeout: Timeout in seconds for each command
+            parallel: If True, run commands in parallel; otherwise sequentially
+
+        Returns:
+            List of CompletedProcess instances with results
+        """
+        results = []
+
+        if parallel:
+            # Run commands in parallel
+            tasks = [
+                self.run_command(cmd, cwd=cwd, env=env, timeout=timeout)
+                for cmd in commands
+            ]
+            results = await asyncio.gather(*tasks)
+        else:
+            # Run commands sequentially
+            for cmd in commands:
+                result = await self.run_command(cmd, cwd=cwd, env=env, timeout=timeout)
+                results.append(result)
+
+        return results
+
+    async def command_exists(self, command: str) -> bool:
+        """
+        Check if a command exists in the system.
+
+        Args:
+            command: Command to check
+
+        Returns:
+            True if command exists, False otherwise
+        """
+        try:
+            # Try running 'which' on Unix-like systems or 'where' on Windows
+            import platform
+
+            if platform.system() == "Windows":
+                check_cmd = ["where", command]
+            else:
+                check_cmd = ["which", command]
+
+            result = await self.run_command(
+                check_cmd,
+                capture_output=True,
+                check=False,  # Don't raise on non-zero exit (which returns 1 if not found)
+            )
+
+            return result.returncode == 0
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            # If the check command itself fails, command likely doesn't exist
+            return False
+
+    async def run_command_with_retries(
+        self,
+        cmd: str | list[str],
+        max_retries: int = 3,
+        cwd: str | Path | None = None,
+        env: dict[str, str] | None = None,
+        timeout: int | None = None,
+        capture_output: bool = True,
+        check: bool = True,
+        backoff_factor: float = 1.0,
+    ) -> subprocess.CompletedProcess:
+        """
+        Run a command with retry logic.
+
+        Args:
+            cmd: Command to run
+            max_retries: Maximum number of retry attempts
+            cwd: Working directory
+            env: Environment variables
+            timeout: Timeout for each attempt
+            capture_output: Whether to capture output
+            check: Whether to check return code
+            backoff_factor: Factor by which to multiply wait time between retries
+
+        Returns:
+            CompletedProcess instance with results
+        """
+        for attempt in range(
+            max_retries + 1
+        ):  # +1 because first attempt doesn't count as retry
+            try:
+                return await self.run_command(
+                    cmd,
+                    cwd=cwd,
+                    env=env,
+                    timeout=timeout,
+                    capture_output=capture_output,
+                    check=check,
+                )
+            except (subprocess.TimeoutExpired, subprocess.CalledProcessError) as e:
+                if attempt == max_retries:
+                    # Last attempt, re-raise the exception
+                    logger.error(f"Command failed after {max_retries} retries: {cmd}")
+                    raise
+                else:
+                    # Wait before retrying with exponential backoff
+                    wait_time = backoff_factor * (2**attempt)
+                    logger.warning(
+                        f"Command failed on attempt {attempt + 1}, "
+                        f"retrying in {wait_time}s: {cmd}. Error: {e}"
+                    )
+                    await asyncio.sleep(wait_time)
+
+        # This line should never be reached due to the loop logic
+        raise RuntimeError("Unexpected error in run_command_with_retries")

crackerjack/services/config_integrity.py

@@ -1,15 +1,58 @@
+import tomllib
+import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
+from crackerjack.exceptions.config import ConfigIntegrityError
+from crackerjack.models.protocols import ConfigIntegrityServiceProtocol, ServiceProtocol
 
-class ConfigIntegrityService:
-    def __init__(self, console: Console, project_path: Path) -> None:
+
+class ConfigIntegrityService(ConfigIntegrityServiceProtocol, ServiceProtocol):
+    @depends.inject
+    def __init__(self, console: Inject[Console], project_path: Path) -> None:
         self.console = console
         self.project_path = project_path
         self.cache_dir = Path.home() / ".cache" / "crackerjack"
         self.cache_dir.mkdir(parents=True, exist_ok=True)
 
+    def initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
+
     def check_config_integrity(self) -> bool:
         config_files = [
             ".pre-commit-config.yaml",
@@ -20,13 +63,21 @@ class ConfigIntegrityService:
 
         for file_name in config_files:
             file_path = self.project_path / file_name
-            if file_path.exists() and self._check_file_drift(file_path):
-                drift_detected = True
+            if file_path.exists():
+                try:
+                    if self._check_file_drift(file_path):
+                        drift_detected = True
+                except ConfigIntegrityError as e:
+                    self.console.print(
+                        f"[red]❌ Error checking {file_path.name}: {e}[/ red]"
+                    )
+                    drift_detected = True
 
-        if not self._has_required_config_sections():
-            self.console.print(
-                "[yellow]⚠️ Configuration missing required sections[/ yellow]",
-            )
+        try:
+            if not self._has_required_config_sections():
+                drift_detected = True
+        except ConfigIntegrityError as e:
+            self.console.print(f"[red]❌ Configuration integrity error: {e}[/ red]")
             drift_detected = True
 
         return drift_detected
@@ -39,50 +90,43 @@ class ConfigIntegrityService:
             current_hash = hash(current_content)
 
             if cache_file.exists():
-                from contextlib import suppress
-
-                with suppress(OSError, ValueError):
-                    cached_hash = int(cache_file.read_text().strip())
-                    if current_hash != cached_hash:
-                        self.console.print(
-                            f"[yellow]⚠️ {file_path.name} has been modified manually[/ yellow]",
-                        )
-                        return True
+                cached_hash = int(cache_file.read_text().strip())
+                if current_hash != cached_hash:
+                    self.console.print(
+                        f"[yellow]⚠️ {file_path.name} has been modified manually[/ yellow]",
+                    )
+                    return True
 
             cache_file.write_text(str(current_hash))
             return False
 
         except OSError as e:
-            self.console.print(f"[red]❌ Error checking {file_path.name}: {e}[/ red]")
-            return False
+            raise ConfigIntegrityError(
+                f"Failed to check file drift for {file_path.name}: {e}"
+            ) from e
 
     def _has_required_config_sections(self) -> bool:
         pyproject = self.project_path / "pyproject.toml"
         if not pyproject.exists():
-            return False
+            raise ConfigIntegrityError("pyproject.toml not found.")
 
         try:
-            import tomllib
-
             with pyproject.open("rb") as f:
                 config = tomllib.load(f)
+        except Exception as e:
+            raise ConfigIntegrityError(f"Error parsing pyproject.toml: {e}") from e
 
-            required = ["tool.ruff", "tool.pyright", "tool.pytest.ini_options"]
-
-            for section in required:
-                keys = section.split(".")
-                current = config
+        required = ["tool.ruff", "tool.pyright", "tool.pytest.ini_options"]
 
-                for key in keys:
-                    if key not in current:
-                        self.console.print(
-                            f"[yellow]⚠️ Missing required config section: {section}[/ yellow]",
-                        )
-                        return False
-                    current = current[key]
+        for section in required:
+            keys = section.split(".")
+            current = config
 
-            return True
+            for key in keys:
+                if key not in current:
+                    raise ConfigIntegrityError(
+                        f"Missing required config section: {section} in pyproject.toml"
+                    )
+                current = current[key]
 
-        except Exception as e:
-            self.console.print(f"[red]❌ Error parsing pyproject.toml: {e}[/ red]")
-            return False
+        return True

crackerjack/services/config_merge.py

@@ -6,27 +6,30 @@ from pathlib import Path
 import tomli
 import tomli_w
 import yaml
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
+from acb.logger import Logger
 
 from crackerjack.models.protocols import (
     ConfigMergeServiceProtocol,
     FileSystemInterface,
     GitInterface,
 )
-from crackerjack.services.logging import get_logger
 
 
 class ConfigMergeService(ConfigMergeServiceProtocol):
+    @depends.inject
     def __init__(
         self,
-        console: Console,
-        filesystem: FileSystemInterface,
-        git_service: GitInterface,
+        console: Inject[Console],
+        filesystem: Inject[FileSystemInterface],
+        git_service: Inject[GitInterface],
+        logger: Inject[Logger],
     ) -> None:
         self.console = console
         self.filesystem = filesystem
         self.git_service = git_service
-        self.logger = get_logger("crackerjack.config_merge")
+        self.logger = logger
 
     def smart_merge_pyproject(
         self,