crackerjack 0.30.3__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/errors.py

@@ -31,8 +31,16 @@ class ErrorCode(Enum):
     PERMISSION_ERROR = 6002
     FILE_READ_ERROR = 6003
     FILE_WRITE_ERROR = 6004
+    FILE_TOO_LARGE = 6005
     CODE_CLEANING_ERROR = 7001
     FORMATTING_ERROR = 7002
+    RESOURCE_ERROR = 8001
+    TIMEOUT_ERROR = 8002
+    NETWORK_ERROR = 8003
+    DEPENDENCY_ERROR = 8004
+    VALIDATION_ERROR = 8005
+    SECURITY_ERROR = 8006
+    GENERAL_ERROR = 9000
     UNKNOWN_ERROR = 9001
     NOT_IMPLEMENTED = 9002
     UNEXPECTED_ERROR = 9999
@@ -43,7 +51,7 @@ class CrackerjackError(Exception):
         self,
         message: str,
         error_code: ErrorCode,
-        details: str | None = None,
+        details: str | dict[str, t.Any] | None = None,
         recovery: str | None = None,
         exit_code: int = 1,
     ) -> None:
@@ -56,31 +64,267 @@ class CrackerjackError(Exception):
 
 
 class ConfigError(CrackerjackError):
-    pass
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode = ErrorCode.CONFIG_PARSE_ERROR,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=error_code,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
 
 
 class ExecutionError(CrackerjackError):
-    pass
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode = ErrorCode.COMMAND_EXECUTION_ERROR,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=error_code,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
 
 
-class TestError(CrackerjackError):
-    pass
+class TestExecutionError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode = ErrorCode.TEST_EXECUTION_ERROR,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=error_code,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
 
 
 class PublishError(CrackerjackError):
-    pass
+    def __init__(
+        self,
+        message: str,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.PUBLISH_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
 
 
 class GitError(CrackerjackError):
-    pass
+    def __init__(
+        self,
+        message: str,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.GIT_COMMAND_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
 
 
 class FileError(CrackerjackError):
-    pass
+    def __init__(
+        self,
+        message: str,
+        error_code: ErrorCode = ErrorCode.FILE_NOT_FOUND,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=error_code,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
 
 
 class CleaningError(CrackerjackError):
-    pass
+    def __init__(
+        self,
+        message: str,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.EXTERNAL_TOOL_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+class NetworkError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        details: str | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.NETWORK_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+class DependencyError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        details: str | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.DEPENDENCY_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+class ResourceError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        details: str | dict[str, t.Any] | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.RESOURCE_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+class ValidationError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        details: str | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.VALIDATION_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+class TimeoutError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        details: str | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.TIMEOUT_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+class SecurityError(CrackerjackError):
+    def __init__(
+        self,
+        message: str,
+        details: str | None = None,
+        recovery: str | None = None,
+        exit_code: int = 1,
+    ) -> None:
+        super().__init__(
+            message=message,
+            error_code=ErrorCode.SECURITY_ERROR,
+            details=details,
+            recovery=recovery,
+            exit_code=exit_code,
+        )
+
+
+def _format_error_for_ai_agent(error: CrackerjackError, verbose: bool) -> str:
+    import json
+
+    error_data = {
+        "status": "error",
+        "error_code": error.error_code.name,
+        "code": error.error_code.value,
+        "message": error.message,
+    }
+    if verbose and error.details:
+        error_data["details"] = (
+            json.dumps(error.details)
+            if isinstance(error.details, dict)
+            else error.details
+        )
+    if error.recovery:
+        error_data["recovery"] = error.recovery
+
+    return json.dumps(error_data)
+
+
+def _format_error_for_console(error: CrackerjackError, verbose: bool) -> Panel:
+    title = f"Error {error.error_code.value}: {error.error_code.name}"
+    content = [error.message]
+
+    if verbose and error.details:
+        content.extend(("\n[white]Details: [/white]", str(error.details)))
+    if error.recovery:
+        content.extend(("\n[green]Recovery suggestion: [/green]", str(error.recovery)))
+
+    return Panel(
+        "\n".join(content),
+        title=title,
+        border_style="red",
+        title_align="left",
+        expand=False,
+    )
 
 
 def handle_error(
@@ -91,38 +335,12 @@ def handle_error(
     exit_on_error: bool = True,
 ) -> None:
     if ai_agent:
-        import json
-
-        error_data = {
-            "status": "error",
-            "error_code": error.error_code.name,
-            "code": error.error_code.value,
-            "message": error.message,
-        }
-        if verbose and error.details:
-            error_data["details"] = error.details
-        if error.recovery:
-            error_data["recovery"] = error.recovery
-        formatted_json = json.dumps(error_data)
+        formatted_json = _format_error_for_ai_agent(error, verbose)
         console.print(f"[json]{formatted_json}[/json]")
     else:
-        title = f"Error {error.error_code.value}: {error.error_code.name}"
-        content = [error.message]
-        if verbose and error.details:
-            content.extend(("\n[white]Details:[/white]", str(error.details)))
-        if error.recovery:
-            content.extend(
-                ("\n[green]Recovery suggestion:[/green]", str(error.recovery))
-            )
-        console.print(
-            Panel(
-                "\n".join(content),
-                title=title,
-                border_style="red",
-                title_align="left",
-                expand=False,
-            )
-        )
+        panel = _format_error_for_console(error, verbose)
+        console.print(panel)
+
     if exit_on_error:
         sys.exit(error.exit_code)
 
@@ -131,7 +349,6 @@ def check_file_exists(path: Path, error_message: str) -> None:
     if not path.exists():
         raise FileError(
             message=error_message,
-            error_code=ErrorCode.FILE_NOT_FOUND,
             details=f"The file at {path} does not exist.",
             recovery="Check the file path and ensure the file exists.",
         )
@@ -148,10 +365,15 @@ def check_command_result(
         stderr = getattr(result, "stderr", "")
         details = f"Command '{command}' failed with return code {result.returncode}."
         if stderr:
-            details += f"\nStandard error output:\n{stderr}"
+            details += f"\nStandard error output: \n{stderr}"
         raise ExecutionError(
             message=error_message,
             error_code=error_code,
             details=details,
             recovery=recovery,
         )
+
+
+def format_error_report(error: CrackerjackError) -> str:
+    """Format an error for reporting purposes."""
+    return f"Error {error.error_code.value}: {error.message}"

crackerjack/executors/__init__.py

@@ -0,0 +1,11 @@
+from .async_hook_executor import AsyncHookExecutor
+from .cached_hook_executor import CachedHookExecutor, SmartCacheManager
+from .hook_executor import HookExecutionResult, HookExecutor
+
+__all__ = [
+    "AsyncHookExecutor",
+    "CachedHookExecutor",
+    "HookExecutionResult",
+    "HookExecutor",
+    "SmartCacheManager",
+]