crackerjack 0.31.10__py3-none-any.whl → 0.31.13__py3-none-any.whl

crackerjack/core/autofix_coordinator.py

@@ -1,200 +1,283 @@
-"""Autofix coordination and retry logic for crackerjack workflows."""
-
-import logging
 import subprocess
-import typing as t
 from pathlib import Path
 
 from rich.console import Console
 
+from crackerjack.services.logging import get_logger
+
 
 class AutofixCoordinator:
     def __init__(self, console: Console, pkg_path: Path) -> None:
         self.console = console
         self.pkg_path = pkg_path
-        self.logger = logging.getLogger("crackerjack.autofix")
+        self.logger = get_logger("crackerjack.autofix")
+        # For testing purposes, we need to set a name attribute
+        # We use setattr to avoid type checker issues since BoundLogger doesn't have a name attribute
+        setattr(self.logger, "name", "crackerjack.autofix")
 
-    def apply_autofix_for_hooks(self, mode: str, hook_results: list[t.Any]) -> bool:
-        self.logger.debug(
-            f"Applying autofix for {mode} mode with {len(hook_results)} hook results",
-        )
+    def apply_autofix_for_hooks(self, mode: str, hook_results: list[object]) -> bool:
         try:
             if self._should_skip_autofix(hook_results):
-                self.logger.info(
-                    f"Skipping autofix for {mode} - unfixable error patterns detected",
-                )
                 return False
+
             if mode == "fast":
-                result = self._apply_fast_stage_fixes()
-                self.logger.debug(f"Fast stage fixes result: {result}")
-                return result
-            if mode == "comprehensive":
-                result = self._apply_comprehensive_stage_fixes(hook_results)
-                self.logger.debug(f"Comprehensive stage fixes result: {result}")
-                return result
-            self.logger.warning(f"Unknown autofix mode: {mode}")
-            return False
+                return self._apply_fast_stage_fixes()
+            elif mode == "comprehensive":
+                return self._apply_comprehensive_stage_fixes(hook_results)
+            else:
+                self.logger.warning(f"Unknown autofix mode: {mode}")
+                return False
         except Exception as e:
-            self.logger.error(f"Auto-fix error in {mode} mode: {e}", exc_info=True)
-            self.console.print(f"[dim red]Auto-fix error: {e}[/dim red]")
+            self.logger.exception("Error applying autofix", error=str(e))
             return False
 
     def apply_fast_stage_fixes(self) -> bool:
-        """Public interface for applying fast stage fixes."""
         return self._apply_fast_stage_fixes()
 
-    def apply_comprehensive_stage_fixes(self, hook_results: list[t.Any]) -> bool:
-        """Public interface for applying comprehensive stage fixes."""
+    def apply_comprehensive_stage_fixes(self, hook_results: list[object]) -> bool:
         return self._apply_comprehensive_stage_fixes(hook_results)
 
     def run_fix_command(self, cmd: list[str], description: str) -> bool:
-        """Public interface for running fix commands."""
         return self._run_fix_command(cmd, description)
 
-    def check_tool_success_patterns(self, cmd: list[str], result: t.Any) -> bool:
-        """Public interface for checking tool success patterns."""
+    def check_tool_success_patterns(self, cmd: list[str], result: object) -> bool:
         return self._check_tool_success_patterns(cmd, result)
 
     def validate_fix_command(self, cmd: list[str]) -> bool:
-        """Public interface for validating fix commands."""
         return self._validate_fix_command(cmd)
 
-    def validate_hook_result(self, result: t.Any) -> bool:
-        """Public interface for validating hook results."""
+    def validate_hook_result(self, result: object) -> bool:
         return self._validate_hook_result(result)
 
-    def should_skip_autofix(self, hook_results: list[t.Any]) -> bool:
-        """Public interface for checking if autofix should be skipped."""
+    def should_skip_autofix(self, hook_results: list[object]) -> bool:
         return self._should_skip_autofix(hook_results)
 
     def _apply_fast_stage_fixes(self) -> bool:
         return self._execute_fast_fixes()
 
-    def _execute_fast_fixes(self) -> bool:
-        fixes_applied = False
-        fix_commands = [
-            (["uv", "run", "ruff", "format", "."], "ruff formatting"),
-            (["uv", "run", "ruff", "check", ".", "--fix"], "ruff auto-fixes"),
-        ]
-        for cmd, description in fix_commands:
-            if self._run_fix_command(cmd, description):
-                fixes_applied = True
-
-        return fixes_applied
-
-    def _apply_comprehensive_stage_fixes(self, hook_results: list[t.Any]) -> bool:
-        fixes_applied = False
-        if self._apply_fast_stage_fixes():
-            fixes_applied = True
+    def _apply_comprehensive_stage_fixes(self, hook_results: list[object]) -> bool:
         failed_hooks = self._extract_failed_hooks(hook_results)
+        if not failed_hooks:
+            return True
+
         hook_specific_fixes = self._get_hook_specific_fixes(failed_hooks)
+
+        # Run fast fixes first
+        if not self._execute_fast_fixes():
+            return False
+
+        # Apply hook-specific fixes
+        all_successful = True
         for cmd, description in hook_specific_fixes:
-            if self._run_fix_command(cmd, description):
-                fixes_applied = True
+            if not self._run_fix_command(cmd, description):
+                all_successful = False
 
-        return fixes_applied
+        return all_successful
 
-    def _extract_failed_hooks(self, hook_results: list[t.Any]) -> set[str]:
-        failed_hooks: set[str] = set()
+    def _extract_failed_hooks(self, hook_results: list[object]) -> set[str]:
+        failed_hooks = set()
         for result in hook_results:
-            if self._validate_hook_result(result):
-                hook_name: str = getattr(result, "name", "").lower()
-                hook_status: str = getattr(result, "status", "")
-                if hook_status == "Failed" and hook_name:
-                    failed_hooks.add(hook_name)
-
+            if (
+                self._validate_hook_result(result)
+                and getattr(result, "status", "") == "Failed"
+            ):
+                failed_hooks.add(getattr(result, "name", ""))
         return failed_hooks
 
     def _get_hook_specific_fixes(
-        self,
-        failed_hooks: set[str],
+        self, failed_hooks: set[str]
     ) -> list[tuple[list[str], str]]:
-        hook_specific_fixes: list[tuple[list[str], str]] = []
+        fixes = []
+
         if "bandit" in failed_hooks:
-            hook_specific_fixes.append(
-                (["uv", "run", "bandit", "-f", "json", ".", "-ll"], "bandit analysis"),
-            )
+            fixes.append((["uv", "run", "bandit", "-r", "."], "bandit analysis"))
+
+        return fixes
+
+    def _execute_fast_fixes(self) -> bool:
+        fixes = [
+            (["uv", "run", "ruff", "format", "."], "format code"),
+            (["uv", "run", "ruff", "check", "--fix", "."], "fix code style"),
+        ]
 
-        return hook_specific_fixes
+        all_successful = True
+        for cmd, description in fixes:
+            if not self._run_fix_command(cmd, description):
+                all_successful = False
+
+        return all_successful
 
     def _run_fix_command(self, cmd: list[str], description: str) -> bool:
         if not self._validate_fix_command(cmd):
+            self.logger.warning(f"Invalid fix command: {cmd}")
             return False
+
         try:
+            self.logger.info(f"Running fix command: {description}")
             result = subprocess.run(
                 cmd,
-                check=False,
+                cwd=self.pkg_path,
                 capture_output=True,
                 text=True,
-                timeout=30,
-                cwd=self.pkg_path,
+                timeout=300,
             )
             return self._handle_command_result(result, description)
-        except Exception:
+        except Exception as e:
+            self.logger.exception(
+                f"Error running fix command: {description}", error=str(e)
+            )
             return False
 
     def _handle_command_result(
-        self,
-        result: subprocess.CompletedProcess[str],
-        description: str,
+        self, result: subprocess.CompletedProcess[str], description: str
     ) -> bool:
-        return bool(result.returncode == 0 or self._is_successful_fix(result))
+        if result.returncode == 0:
+            self.logger.info(f"Fix command succeeded: {description}")
+            return True
+
+        if self._is_successful_fix(result):
+            self.logger.info(f"Fix command applied changes: {description}")
+            return True
+
+        self.logger.warning(
+            f"Fix command failed: {description}",
+            returncode=result.returncode,
+            stderr=result.stderr[:200] if result.stderr else "No stderr",
+        )
+        return False
 
     def _is_successful_fix(self, result: subprocess.CompletedProcess[str]) -> bool:
-        output = result.stdout.lower()
-        return "fixed" in output or "reformatted" in output
+        success_indicators = [
+            "fixed",
+            "formatted",
+            "reformatted",
+            "updated",
+            "changed",
+            "removed",
+        ]
 
-    def _check_tool_success_patterns(self, cmd: list[str], result: t.Any) -> bool:
-        """Check if a tool command result indicates success."""
-        if not cmd or len(cmd) < 3:
+        # Handle case where result might be a Mock object in tests
+        if hasattr(result, "stdout") and hasattr(result, "stderr"):
+            # Handle the case where stdout/stderr might be Mock objects
+            stdout = getattr(result, "stdout", "") or ""
+            stderr = getattr(result, "stderr", "") or ""
+            # If they're Mock objects, convert to string
+            if not isinstance(stdout, str):
+                stdout = str(stdout)
+            if not isinstance(stderr, str):
+                stderr = str(stderr)
+            output = stdout + stderr
+        else:
+            # For test mocks or other objects
+            output = str(result)
+
+        output_lower = output.lower()
+
+        return any(indicator in output_lower for indicator in success_indicators)
+
+    def _check_tool_success_patterns(self, cmd: list[str], result: object) -> bool:
+        if not cmd:
             return False
 
-        tool_name = cmd[2] if len(cmd) > 2 else ""
-
-        # Check if result is a subprocess.CompletedProcess
+        # Handle CompletedProcess objects or Mock objects with returncode attribute
         if hasattr(result, "returncode"):
-            return result.returncode == 0
+            return self._check_process_result_success(result)
 
-        # Check for specific tool success patterns
+        # Check for string patterns in result
         if isinstance(result, str):
-            output_lower = result.lower()
-            if "ruff" in tool_name:
-                return "fixed" in output_lower or "would reformat" in output_lower
-            if "trailing-whitespace" in tool_name:
-                return "fixing" in output_lower or "fixed" in output_lower
+            return self._check_string_result_success(result)
 
         return False
 
+    def _check_process_result_success(self, result: object) -> bool:
+        """Check if a process result indicates success."""
+        if getattr(result, "returncode", 1) == 0:
+            return True
+
+        # Check output for success patterns if return code is non-zero
+        output = self._extract_process_output(result)
+        return self._has_success_patterns(output)
+
+    def _extract_process_output(self, result: object) -> str:
+        """Extract and normalize stdout and stderr from process result."""
+        stdout = getattr(result, "stdout", "") or ""
+        stderr = getattr(result, "stderr", "") or ""
+
+        # Convert to strings if they're not already
+        if not isinstance(stdout, str):
+            stdout = str(stdout)
+        if not isinstance(stderr, str):
+            stderr = str(stderr)
+
+        return stdout + stderr
+
+    def _check_string_result_success(self, result: str) -> bool:
+        """Check if a string result indicates success."""
+        return self._has_success_patterns(result)
+
+    def _has_success_patterns(self, output: str) -> bool:
+        """Check if output contains success patterns."""
+        if not output:
+            return False
+
+        success_patterns = [
+            "fixed",
+            "formatted",
+            "reformatted",
+            "would reformat",
+            "fixing",
+        ]
+
+        output_lower = output.lower()
+        return any(pattern in output_lower for pattern in success_patterns)
+
     def _validate_fix_command(self, cmd: list[str]) -> bool:
-        if len(cmd) < 3:
+        if not cmd or len(cmd) < 2:
             return False
-        if cmd[0] != "uv" or cmd[1] != "run":
+
+        if cmd[0] != "uv":
             return False
-        tool_name = cmd[2]
-        return tool_name in ("ruff", "bandit")
 
-    def _validate_hook_result(self, result: t.Any) -> bool:
-        if not hasattr(result, "name") or not hasattr(result, "status"):
-            self.logger.warning(f"Invalid hook result structure: {type(result)}")
+        if cmd[1] != "run":
             return False
+
+        allowed_tools = [
+            "ruff",
+            "bandit",
+            "trailing-whitespace",
+        ]
+
+        if len(cmd) > 2 and cmd[2] in allowed_tools:
+            return True
+
+        return False
+
+    def _validate_hook_result(self, result: object) -> bool:
         name = getattr(result, "name", None)
         status = getattr(result, "status", None)
-        if not isinstance(name, str) or not name.strip():
-            self.logger.warning(f"Hook result has invalid name: {name}")
+
+        if not name or not isinstance(name, str):
             return False
-        if status not in ("Passed", "Failed", "Skipped", "Error"):
-            self.logger.warning(f"Hook result has invalid status: {status}")
+
+        if not status or not isinstance(status, str):
+            return False
+
+        valid_statuses = ["Passed", "Failed", "Skipped", "Error"]
+        if status not in valid_statuses:
             return False
 
         return True
 
-    def _should_skip_autofix(self, hook_results: list[t.Any]) -> bool:
+    def _should_skip_autofix(self, hook_results: list[object]) -> bool:
         for result in hook_results:
-            if hasattr(result, "raw_output"):
-                output = getattr(result, "raw_output", "")
-                if "ModuleNotFoundError" in output or "ImportError" in output:
-                    self.console.print(
-                        "[dim yellow]  → Skipping autofix (import errors)[/dim yellow]",
-                    )
+            raw_output = getattr(result, "raw_output", None)
+            if raw_output:
+                output_lower = raw_output.lower()
+                # Skip autofix for import errors as they typically require manual intervention
+                if (
+                    "importerror" in output_lower
+                    or "modulenotfounderror" in output_lower
+                ):
+                    self.logger.info("Skipping autofix for import errors")
                     return True
         return False