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

crackerjack/executors/async_hook_executor.py

@@ -1,15 +1,19 @@
 import asyncio
 import time
 import typing as t
+from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
+from acb.logger import Logger
 
+from crackerjack.config import get_console_width
 from crackerjack.config.hooks import HookDefinition, HookStrategy, RetryPolicy
 from crackerjack.models.protocols import HookLockManagerProtocol
 from crackerjack.models.task import HookResult
-from crackerjack.services.logging import LoggingContext, get_logger
+from crackerjack.services.logging import LoggingContext
 
 
 @dataclass
@@ -52,8 +56,10 @@ class AsyncHookExecutionResult:
 
 
 class AsyncHookExecutor:
+    @depends.inject
     def __init__(
         self,
+        logger: Inject[Logger],
         console: Console,
         pkg_path: Path,
         max_concurrent: int = 4,
@@ -66,9 +72,12 @@ class AsyncHookExecutor:
         self.max_concurrent = max_concurrent
         self.timeout = timeout
         self.quiet = quiet
-        self.logger = get_logger("crackerjack.async_hook_executor")
+        self.logger = logger
 
         self._semaphore = asyncio.Semaphore(max_concurrent)
+        self._running_processes: set = set()  # Track running subprocesses
+        self._last_stdout: bytes | None = None
+        self._last_stderr: bytes | None = None
 
         if hook_lock_manager is None:
             from crackerjack.executors.hook_lock_manager import (
@@ -99,7 +108,7 @@ class AsyncHookExecutor:
                 max_workers=getattr(strategy, "max_workers", self.max_concurrent),
             )
 
-            self._print_strategy_header(strategy)
+            # Header is displayed by PhaseCoordinator; suppress here to avoid duplicates
 
             estimated_sequential = sum(
                 getattr(hook, "timeout", 30) for hook in strategy.hooks
@@ -156,20 +165,8 @@ class AsyncHookExecutor:
         }
 
     def _print_strategy_header(self, strategy: HookStrategy) -> None:
-        self.console.print("\n" + "-" * 74)
-        if strategy.name == "fast":
-            self.console.print(
-                "[bold bright_cyan]🔍 HOOKS[/ bold bright_cyan] [bold bright_white]Running code quality checks (async)[/ bold bright_white]",
-            )
-        elif strategy.name == "comprehensive":
-            self.console.print(
-                "[bold bright_cyan]🔍 HOOKS[/ bold bright_cyan] [bold bright_white]Running comprehensive quality checks (async)[/ bold bright_white]",
-            )
-        else:
-            self.console.print(
-                f"[bold bright_cyan]🔍 HOOKS[/ bold bright_cyan] [bold bright_white]Running {strategy.name} hooks (async)[/ bold bright_white]",
-            )
-        self.console.print("-" * 74 + "\n")
+        # Intentionally no-op: PhaseCoordinator controls stage headers
+        return None
 
     async def _execute_sequential(self, strategy: HookStrategy) -> list[HookResult]:
         results: list[HookResult] = []
@@ -218,6 +215,69 @@ class AsyncHookExecutor:
 
         return results
 
+    async def cleanup(self) -> None:
+        """Clean up any remaining resources before event loop closes."""
+        await self._cleanup_running_processes()
+        self._running_processes.clear()
+        await self._cleanup_pending_tasks()
+
+    async def _cleanup_running_processes(self) -> None:
+        """Terminate all running subprocesses."""
+        for proc in list(self._running_processes):
+            await self._terminate_single_process(proc)
+
+    async def _terminate_single_process(self, proc: asyncio.subprocess.Process) -> None:
+        """Terminate a single subprocess safely."""
+        try:
+            if proc.returncode is None:
+                proc.kill()
+                await self._wait_for_process_termination(proc)
+        except ProcessLookupError:
+            pass
+        except Exception:
+            pass
+
+    async def _wait_for_process_termination(
+        self, proc: asyncio.subprocess.Process
+    ) -> None:
+        """Wait briefly for process to terminate."""
+        with suppress(TimeoutError, RuntimeError):
+            await asyncio.wait_for(proc.wait(), timeout=0.1)
+
+    async def _cleanup_pending_tasks(self) -> None:
+        """Cancel any pending hook-related tasks."""
+        with suppress(RuntimeError):
+            loop = asyncio.get_running_loop()
+            pending_tasks = self._get_pending_hook_tasks(loop)
+            await self._cancel_tasks(pending_tasks)
+
+    def _get_pending_hook_tasks(self, loop: asyncio.AbstractEventLoop) -> list:
+        """Get list of pending hook-related tasks."""
+        return [
+            task
+            for task in asyncio.all_tasks(loop)
+            if not task.done() and "hook" in str(task).lower()
+        ]
+
+    async def _cancel_tasks(self, tasks: list) -> None:
+        """Cancel a list of tasks safely."""
+        for task in tasks:
+            if not task.done():
+                await self._cancel_single_task(task)
+
+    async def _cancel_single_task(self, task: asyncio.Task) -> None:
+        """Cancel a single task safely."""
+        try:
+            task.cancel()
+            await asyncio.wait_for(task, timeout=0.1)
+        except (TimeoutError, asyncio.CancelledError):
+            pass
+        except RuntimeError as e:
+            if "Event loop is closed" in str(e):
+                return
+            else:
+                raise
+
     async def _execute_single_hook(self, hook: HookDefinition) -> HookResult:
         async with self._semaphore:
             if self.hook_lock_manager.requires_lock(hook.name):
@@ -257,11 +317,7 @@ class AsyncHookExecutor:
                 timeout=timeout_val,
             )
 
-            repo_root = (
-                self.pkg_path.parent
-                if self.pkg_path.name == "crackerjack"
-                else self.pkg_path
-            )
+            repo_root = self._get_repo_root()
             process = await asyncio.create_subprocess_exec(
                 *cmd,
                 cwd=repo_root,
@@ -269,68 +325,188 @@ class AsyncHookExecutor:
                 stderr=asyncio.subprocess.PIPE,
             )
 
-            try:
-                stdout, stderr = await asyncio.wait_for(
-                    process.communicate(),
-                    timeout=timeout_val,
-                )
-            except TimeoutError:
-                process.kill()
-                await process.wait()
-                duration = time.time() - start_time
-
-                self.logger.warning(
-                    "Hook execution timed out",
-                    hook=hook.name,
-                    timeout=timeout_val,
-                    duration_seconds=round(duration, 2),
-                )
+            # Track this process for cleanup
+            self._running_processes.add(process)
 
-                return HookResult(
-                    id=hook.name,
-                    name=hook.name,
-                    status="timeout",
-                    duration=duration,
-                    issues_found=[f"Hook timed out after {duration: .1f}s"],
-                    stage=hook.stage.value,
-                )
+            result = await self._execute_process_with_timeout(
+                process, hook, timeout_val, start_time
+            )
+            if result is not None:
+                return result
 
+            # Process completed successfully
             duration = time.time() - start_time
-            output_text = (
-                (stdout.decode() + stderr.decode()) if stdout and stderr else ""
+            return await self._build_success_result(process, hook, duration)
+
+        except RuntimeError as e:
+            return self._handle_runtime_error(e, hook, start_time)
+        except Exception as e:
+            return self._handle_general_error(e, hook, start_time)
+
+    def _get_repo_root(self) -> Path:
+        """Determine the repository root directory.
+
+        Returns pkg_path directly to ensure hooks run in the correct project directory
+        regardless of the project name.
+        """
+        return self.pkg_path
+
+    async def _execute_process_with_timeout(
+        self,
+        process: asyncio.subprocess.Process,
+        hook: HookDefinition,
+        timeout_val: int,
+        start_time: float,
+    ) -> HookResult | None:
+        """Execute process with timeout handling. Returns HookResult on timeout, None on success."""
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=timeout_val,
             )
-            return_code = process.returncode if process.returncode is not None else -1
-            parsed_output = self._parse_hook_output(return_code, output_text)
+            # Process completed normally - remove from tracking
+            self._running_processes.discard(process)
+            # Store output for later use
+            self._last_stdout = stdout
+            self._last_stderr = stderr
+            return None
+        except TimeoutError:
+            return await self._handle_process_timeout(
+                process, hook, timeout_val, start_time
+            )
+
+    async def _handle_process_timeout(
+        self,
+        process: asyncio.subprocess.Process,
+        hook: HookDefinition,
+        timeout_val: int,
+        start_time: float,
+    ) -> HookResult:
+        """Handle process timeout by killing process and returning timeout result."""
+        await self._terminate_process_safely(process, hook)
+        duration = time.time() - start_time
+
+        self.logger.warning(
+            "Hook execution timed out",
+            hook=hook.name,
+            timeout=timeout_val,
+            duration_seconds=round(duration, 2),
+        )
 
-            status = "passed" if return_code == 0 else "failed"
+        return HookResult(
+            id=hook.name,
+            name=hook.name,
+            status="timeout",
+            duration=duration,
+            issues_found=[f"Hook timed out after {duration: .1f}s"],
+            issues_count=1,  # Timeout counts as 1 issue
+            stage=hook.stage.value,
+            exit_code=124,  # Standard timeout exit code
+            error_message=f"Hook execution exceeded timeout of {timeout_val}s",
+            is_timeout=True,
+        )
 
-            self.logger.info(
-                "Hook execution completed",
+    async def _terminate_process_safely(
+        self,
+        process: asyncio.subprocess.Process,
+        hook: HookDefinition,
+    ) -> None:
+        """Safely terminate a process and handle termination errors."""
+        try:
+            process.kill()
+            await asyncio.wait_for(process.wait(), timeout=0.1)
+            self._running_processes.discard(process)
+        except (TimeoutError, RuntimeError) as e_wait:
+            self._log_termination_error(e_wait, hook)
+            self._running_processes.discard(process)
+
+    def _log_termination_error(
+        self,
+        error: Exception,
+        hook: HookDefinition,
+    ) -> None:
+        """Log process termination errors appropriately."""
+        error_str = str(error)
+        if "Event loop is closed" in error_str:
+            self.logger.debug(
+                "Event loop closed while waiting for process termination",
                 hook=hook.name,
-                status=status,
-                duration_seconds=round(duration, 2),
-                return_code=process.returncode,
-                files_processed=parsed_output.get("files_processed", 0),
-                issues_count=len(parsed_output.get("issues", [])),
             )
-
-            return HookResult(
-                id=parsed_output.get("hook_id", hook.name),
-                name=hook.name,
-                status=status,
-                duration=duration,
-                files_processed=parsed_output.get("files_processed", 0),
-                issues_found=parsed_output.get("issues", []),
-                stage=hook.stage.value,
+        elif "handle" in error_str.lower() or "pid" in error_str.lower():
+            self.logger.debug(
+                "Subprocess handle issue during termination",
+                hook=hook.name,
             )
 
-        except Exception as e:
+    async def _build_success_result(
+        self,
+        process: asyncio.subprocess.Process,
+        hook: HookDefinition,
+        duration: float,
+    ) -> HookResult:
+        """Build HookResult from successful process execution."""
+        output_text = self._decode_process_output(self._last_stdout, self._last_stderr)
+        return_code = process.returncode if process.returncode is not None else -1
+        parsed_output = self._parse_hook_output(return_code, output_text, hook.name)
+
+        status = "passed" if return_code == 0 else "failed"
+
+        self.logger.info(
+            "Hook execution completed",
+            hook=hook.name,
+            status=status,
+            duration_seconds=round(duration, 2),
+            return_code=process.returncode,
+            files_processed=parsed_output.get("files_processed", 0),
+            issues_count=len(parsed_output.get("issues", [])),
+        )
+
+        issues = parsed_output.get("issues", [])
+        # If hook failed but has no parsed issues, use raw output as error details
+        if status == "failed" and not issues and output_text:
+            # Split output into lines and take first 10 non-empty lines as issues
+            error_lines = [
+                line.strip() for line in output_text.split("\n") if line.strip()
+            ][:10]
+            issues = error_lines or ["Hook failed with non-zero exit code"]
+
+        # Ensure failed hooks always have at least 1 issue count
+        issues_count = max(len(issues), 1 if status == "failed" else 0)
+
+        return HookResult(
+            id=parsed_output.get("hook_id", hook.name),
+            name=hook.name,
+            status=status,
+            duration=duration,
+            files_processed=parsed_output.get("files_processed", 0),
+            issues_found=issues,
+            issues_count=issues_count,
+            stage=hook.stage.value,
+            exit_code=return_code,  # Include exit code for debugging
+            error_message=output_text[:500]
+            if status == "failed" and output_text
+            else None,  # First 500 chars of error
+            is_timeout=False,
+        )
+
+    def _decode_process_output(self, stdout: bytes | None, stderr: bytes | None) -> str:
+        """Decode process stdout and stderr into a single string."""
+        stdout_text = stdout.decode() if stdout else ""
+        stderr_text = stderr.decode() if stderr else ""
+        return stdout_text + stderr_text
+
+    def _handle_runtime_error(
+        self,
+        error: RuntimeError,
+        hook: HookDefinition,
+        start_time: float,
+    ) -> HookResult:
+        """Handle RuntimeError during hook execution."""
+        if "Event loop is closed" in str(error):
             duration = time.time() - start_time
-            self.logger.exception(
-                "Hook execution failed with exception",
+            self.logger.warning(
+                "Event loop closed during hook execution, returning error",
                 hook=hook.name,
-                error=str(e),
-                error_type=type(e).__name__,
                 duration_seconds=round(duration, 2),
             )
             return HookResult(
@@ -338,11 +514,212 @@ class AsyncHookExecutor:
                 name=hook.name,
                 status="error",
                 duration=duration,
-                issues_found=[str(e)],
+                issues_found=["Event loop closed during execution"],
+                issues_count=1,  # Error counts as 1 issue
                 stage=hook.stage.value,
+                exit_code=1,
+                error_message="Event loop closed during hook execution",
+                is_timeout=False,
             )
+        else:
+            raise
+
+    def _handle_general_error(
+        self,
+        error: Exception,
+        hook: HookDefinition,
+        start_time: float,
+    ) -> HookResult:
+        """Handle general exceptions during hook execution."""
+        duration = time.time() - start_time
+        self.logger.exception(
+            "Hook execution failed with exception",
+            hook=hook.name,
+            error=str(error),
+            error_type=type(error).__name__,
+            duration_seconds=round(duration, 2),
+        )
+        return HookResult(
+            id=hook.name,
+            name=hook.name,
+            status="error",
+            duration=duration,
+            issues_found=[str(error)],
+            issues_count=1,  # Error counts as 1 issue
+            stage=hook.stage.value,
+            exit_code=1,
+            error_message=f"{type(error).__name__}: {error}",
+            is_timeout=False,
+        )
+
+    def _parse_semgrep_output_async(self, output: str) -> int:
+        """Parse Semgrep output to count files with issues, not total files scanned."""
+
+        # Try JSON parsing first
+        json_result = self._try_parse_semgrep_json(output)
+        if json_result is not None:
+            return json_result
+
+        # Fall back to text pattern matching
+        return self._parse_semgrep_text_patterns(output)
+
+    def _try_parse_semgrep_json(self, output: str) -> int | None:
+        """Try to parse Semgrep JSON output."""
+
+        try:
+            stripped_output = output.strip()
 
-    def _parse_hook_output(self, returncode: int, output: str) -> dict[str, t.Any]:
+            # Try parsing entire output as JSON
+            if stripped_output.startswith("{"):
+                count = self._extract_file_count_from_json(stripped_output)
+                if count is not None:
+                    return count
+
+            # Try line-by-line JSON parsing
+            return self._parse_semgrep_json_lines(output)
+        except Exception:
+            return None
+
+    def _extract_file_count_from_json(self, json_str: str) -> int | None:
+        """Extract file count from JSON string."""
+        import json
+
+        try:
+            json_data = json.loads(json_str)
+            if "results" in json_data:
+                file_paths = {
+                    result.get("path") for result in json_data.get("results", [])
+                }
+                return len([p for p in file_paths if p])
+        except json.JSONDecodeError:
+            pass
+        return None
+
+    def _parse_semgrep_json_lines(self, output: str) -> int | None:
+        """Parse JSON from individual lines in output."""
+
+        lines = output.splitlines()
+        for line in lines:
+            line = line.strip()
+            if line.startswith("{") and line.endswith("}"):
+                count = self._extract_file_count_from_json(line)
+                if count is not None:
+                    return count
+        return None
+
+    def _parse_semgrep_text_patterns(self, output: str) -> int:
+        """Parse Semgrep text output using regex patterns."""
+        import re
+
+        semgrep_patterns = [
+            r"found\s+(\d+)\s+issues?\s+in\s+(\d+)\s+files?",
+            r"found\s+no\s+issues",
+            r"scanning\s+(\d+)\s+files?",
+        ]
+
+        for pattern in semgrep_patterns:
+            matches = re.findall(pattern, output, re.IGNORECASE)
+            if matches:
+                result = self._process_semgrep_matches(matches, output)
+                if result is not None:
+                    return result
+
+        return 0
+
+    def _process_semgrep_matches(self, matches: list, output: str) -> int | None:
+        """Process regex matches from Semgrep output."""
+        for match in matches:
+            if isinstance(match, tuple):
+                if len(match) == 2:
+                    issue_count, file_count = int(match[0]), int(match[1])
+                    return file_count if issue_count > 0 else 0
+                elif len(match) == 1 and "no issues" not in output.lower():
+                    continue
+            elif "no issues" in output.lower():
+                return 0
+        return None
+
+    def _parse_semgrep_issues_async(self, output: str) -> list[str]:
+        """Parse semgrep JSON output to extract both findings and errors.
+
+        Semgrep returns JSON with two arrays:
+        - "results": Security/code quality findings
+        - "errors": Configuration, download, or execution errors
+
+        This method extracts issues from both arrays to provide comprehensive error reporting.
+        """
+        import json
+
+        issues = []
+
+        try:
+            # Try to parse as JSON
+            json_data = json.loads(output.strip())
+
+            # Extract findings from results array
+            if "results" in json_data:
+                for result in json_data.get("results", []):
+                    # Format: "file.py:line - rule_id: message"
+                    path = result.get("path", "unknown")
+                    line_num = result.get("start", {}).get("line", "?")
+                    rule_id = result.get("check_id", "unknown-rule")
+                    message = result.get("extra", {}).get(
+                        "message", "Security issue detected"
+                    )
+                    issues.append(f"{path}:{line_num} - {rule_id}: {message}")
+
+            # Extract errors from errors array (config errors, download failures, etc.)
+            if "errors" in json_data:
+                for error in json_data.get("errors", []):
+                    error_type = error.get("type", "SemgrepError")
+                    error_msg = error.get("message", str(error))
+                    issues.append(f"{error_type}: {error_msg}")
+
+        except json.JSONDecodeError:
+            # If JSON parsing fails, return raw output (shouldn't happen with --json flag)
+            if output.strip():
+                issues = [line.strip() for line in output.split("\n") if line.strip()][
+                    :10
+                ]
+
+        return issues
+
+    def _parse_hook_output(
+        self, returncode: int, output: str, hook_name: str = ""
+    ) -> dict[str, t.Any]:
+        """Parse hook output to extract file counts and other metrics.
+
+        Args:
+            returncode: Exit code from the subprocess
+            output: Raw output from the hook execution
+            hook_name: Name of the hook being executed to allow special handling
+
+        Returns:
+            Dictionary with parsed results including files_processed
+        """
+        result = self._initialize_parse_result(returncode, output)
+
+        # Special handling for semgrep
+        if hook_name == "semgrep":
+            result["files_processed"] = self._parse_semgrep_output_async(output)
+            result["issues"] = self._parse_semgrep_issues_async(output)
+            return result
+
+        # Special handling for check-added-large-files
+        if hook_name == "check-added-large-files":
+            result["files_processed"] = self._parse_large_files_output(
+                output, returncode
+            )
+            return result
+
+        # General hook parsing
+        result["files_processed"] = self._extract_file_count_from_output(output)
+        return result
+
+    def _initialize_parse_result(
+        self, returncode: int, output: str
+    ) -> dict[str, t.Any]:
+        """Initialize result dictionary with default values."""
         return {
             "hook_id": None,
             "exit_code": returncode,
@@ -351,13 +728,98 @@ class AsyncHookExecutor:
             "raw_output": output,
         }
 
+    def _parse_large_files_output(self, output: str, returncode: int) -> int:
+        """Parse check-added-large-files output to count files exceeding size limit."""
+
+        clean_output = output.replace("\\n", "\n").replace("\\t", "\t")
+
+        # Try to find explicit failure patterns
+        failure_count = self._find_large_file_failures(clean_output)
+        if failure_count is not None:
+            return failure_count
+
+        # Check for "all files under limit" success case
+        if self._is_all_files_under_limit(clean_output, returncode):
+            return 0
+
+        # If hook failed but no pattern matched, assume at least 1 file failed
+        if returncode != 0:
+            return 1
+
+        # Default: no large files found
+        return 0
+
+    def _find_large_file_failures(self, clean_output: str) -> int | None:
+        """Find count of files that exceeded size limit."""
+        import re
+
+        failure_patterns = [
+            r"large file(?:s)? found:?\s*(\d+)",
+            r"found\s+(\d+)\s+large file",
+            r"(\d+)\s+file(?:s)?\s+exceed(?:ed)?\s+size\s+limit",
+            r"(\d+)\s+large file(?:s)?\s+found",
+            r"(\d+)\s+file(?:s)?\s+(?:failed|violated|exceeded)",
+        ]
+
+        for pattern in failure_patterns:
+            matches = re.findall(pattern, clean_output, re.IGNORECASE)
+            if matches:
+                return int(max([int(m) for m in matches if m.isdigit()]))
+
+        return None
+
+    def _is_all_files_under_limit(self, clean_output: str, returncode: int) -> bool:
+        """Check if output indicates all files are under size limit."""
+        import re
+
+        pattern = r"All files are under size limit"
+        return bool(re.search(pattern, clean_output, re.IGNORECASE) and returncode == 0)
+
+    def _extract_file_count_from_output(self, output: str) -> int:
+        """Extract file count from general hook output."""
+        import re
+
+        clean_output = output.replace("\\n", "\n").replace("\\t", "\t")
+        patterns = self._get_file_count_patterns()
+
+        all_matches = []
+        for pattern in patterns:
+            matches = re.findall(pattern, clean_output, re.IGNORECASE)
+            if matches:
+                all_matches.extend([int(m) for m in matches if m.isdigit()])
+
+        return max(all_matches) if all_matches else 0
+
+    def _get_file_count_patterns(self) -> list[str]:
+        """Get regex patterns for extracting file counts from hook output."""
+        return [
+            r"(\d+)\s+files?\s+(?:processed|checked|examined|scanned|formatted|found|affected)",
+            r"found\s+(\d+)\s+files?",
+            r"(\d+)\s+files?\s+with\s+issues?",
+            r"(\d+)\s+files?\s+(?:would\s+be|were)\s+(?:formatted|modified|fixed)",
+            r"(\d+)\s+files?\s+would\s+be\s+?(?:formatted|fixed|updated)",
+            r"(\d+)\s+files?\s+?(?:formatted|fixed|updated)",
+            r"(\d+)\s+files?\s+formatted",
+            r"analyzed\s+(\d+)\s+deps",
+            r"(\d+)\s+findings?",
+            r"(\d+)\s+issues?\s+found",
+            r"(\d+)\s+tests ran",
+            r"(\d+)\s+files\s+scanned",
+            r"Checked\s+(\d+)\s+files?",
+            r"for\s+(\d+)\s+files?",
+            r"(\d+)\s+files?",
+        ]
+
     def _display_hook_result(self, result: HookResult) -> None:
-        dots = "." * (60 - len(result.name))
+        if self.quiet:
+            return
+        width = get_console_width()
+        dots = "." * max(0, (width - len(result.name)))
         status_text = "Passed" if result.status == "passed" else "Failed"
         status_color = "green" if result.status == "passed" else "red"
 
         self.console.print(
-            f"{result.name}{dots}[{status_color}]{status_text}[/{status_color}]",
+            f"{result.name}{dots}[{status_color}]{status_text}[/{status_color}]"
         )
 
         if result.status != "passed" and result.issues_found: