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

crackerjack/executors/hook_lock_manager.py

@@ -4,11 +4,12 @@ import logging
 import os
 import time
 import typing as t
+import uuid
 from collections import defaultdict
-from contextlib import AbstractAsyncContextManager, asynccontextmanager, suppress
+from contextlib import asynccontextmanager, suppress
 from pathlib import Path
 
-from ..config.global_lock_config import GlobalLockConfig
+from ..config.global_lock_config import GlobalLockConfig, get_global_lock_config
 
 
 class HookLockManager:
@@ -28,9 +29,12 @@ class HookLockManager:
             "complexipy",
         }
 
-        self._hook_locks: dict[str, asyncio.Lock] = defaultdict(asyncio.Lock)
+        # Create locks for all hooks that require them
+        self._hook_locks: dict[str, asyncio.Lock] = {
+            hook_name: asyncio.Lock() for hook_name in self._hooks_requiring_locks
+        }
 
-        self._global_config = GlobalLockConfig()
+        self._global_config = get_global_lock_config()
         self._global_lock_enabled = self._global_config.enabled
         self._active_global_locks: set[str] = set()
         self._heartbeat_tasks: dict[str, asyncio.Task[None]] = {}
@@ -59,9 +63,7 @@ class HookLockManager:
         return hook_name in self._hooks_requiring_locks
 
     @asynccontextmanager
-    async def acquire_hook_lock(
-        self, hook_name: str
-    ) -> AbstractAsyncContextManager[None]:
+    async def acquire_hook_lock(self, hook_name: str) -> t.AsyncIterator[None]:
         if not self.requires_lock(hook_name):
             yield
             return
@@ -220,7 +222,7 @@ class HookLockManager:
                     )
 
     async def _attempt_lock_acquisition(self, hook_name: str, lock_path: Path) -> None:
-        temp_path = lock_path.with_suffix(".tmp")
+        temp_path = lock_path.with_suffix(f".tmp.{uuid.uuid4().hex}")
 
         lock_data = {
             "session_id": self._global_config.session_id,
@@ -239,7 +241,9 @@ class HookLockManager:
             temp_path.chmod(0o600)
 
             try:
-                temp_path.rename(lock_path)
+                # Use os.link() for atomic exclusive creation - fails if target exists
+                # (Path.rename() will replace existing file, which breaks lock semantics)
+                os.link(str(temp_path), str(lock_path))
                 self.logger.debug(f"Successfully created global lock file: {lock_path}")
             except FileExistsError:
                 with suppress(OSError):
@@ -473,6 +477,9 @@ class HookLockManager:
 
     def add_hook_to_lock_list(self, hook_name: str) -> None:
         self._hooks_requiring_locks.add(hook_name)
+        # Create lock for this hook if it doesn't already exist
+        if hook_name not in self._hook_locks:
+            self._hook_locks[hook_name] = asyncio.Lock()
         self.logger.info(f"Added {hook_name} to hooks requiring locks")
 
     def remove_hook_from_lock_list(self, hook_name: str) -> None:
@@ -497,7 +504,13 @@ class HookLockManager:
 
     def enable_global_lock(self, enabled: bool = True) -> None:
         self._global_lock_enabled = enabled
-        self._global_config.enabled = enabled
+        # Update the settings model if supported
+        if hasattr(self._global_config._settings, "enabled"):
+            # Create a new settings object with updated enabled value
+            new_settings = self._global_config._settings.model_copy(
+                update={"enabled": enabled}
+            )
+            self._global_config._settings = new_settings
         self.logger.info(
             f"Global lock functionality {'enabled' if enabled else 'disabled'}"
         )
@@ -533,18 +546,9 @@ class HookLockManager:
     def _process_lock_file(
         self, lock_file: Path, max_age_hours: float, current_time: float
     ) -> int:
-        try:
-            file_age_hours = (current_time - lock_file.stat().st_mtime) / 3600
-
-            if file_age_hours > max_age_hours:
-                return self._cleanup_stale_lock_file(
-                    lock_file, max_age_hours, current_time
-                )
-            return 0
-
-        except OSError as e:
-            self.logger.warning(f"Could not process lock file {lock_file}: {e}")
-            return 0
+        # Always attempt to check lock file data (file mtime is unreliable in tests)
+        # The JSON data's last_heartbeat is the source of truth for staleness
+        return self._cleanup_stale_lock_file(lock_file, max_age_hours, current_time)
 
     def _cleanup_stale_lock_file(
         self, lock_file: Path, max_age_hours: float, current_time: float
@@ -639,6 +643,11 @@ class HookLockManager:
         return stats
 
     def configure_from_options(self, options: t.Any) -> None:
+        """Configure lock manager from CLI options.
+
+        This is a synchronous method because it only performs configuration
+        updates without needing to await any async operations.
+        """
         self._global_config = GlobalLockConfig.from_options(options)
         self._global_lock_enabled = self._global_config.enabled
 

crackerjack/executors/individual_hook_executor.py

@@ -5,9 +5,12 @@ import typing as t
 from dataclasses import dataclass
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
 
+from crackerjack.cli.formatting import separator as make_separator
+from crackerjack.config import get_console_width
 from crackerjack.config.hooks import HookDefinition, HookStrategy
+from crackerjack.executors.hook_executor import HookExecutionResult
 from crackerjack.models.protocols import HookLockManagerProtocol
 from crackerjack.models.task import HookResult
 from crackerjack.services.regex_patterns import SAFE_PATTERNS
@@ -354,6 +357,7 @@ class IndividualHookExecutor:
         self,
         strategy: HookStrategy,
     ) -> IndividualExecutionResult:
+        """Execute hook strategy with individual (sequential) execution and progress tracking."""
         start_time = time.time()
         self._print_strategy_header(strategy)
 
@@ -364,6 +368,37 @@ class IndividualHookExecutor:
 
         return self._finalize_execution_result(strategy, execution_state, start_time)
 
+    async def execute_strategy(
+        self,
+        strategy: HookStrategy,
+    ) -> HookExecutionResult:  # Changed return type to match base class
+        """Execute hook strategy - API-compatible method matching other executors."""
+        start_time = time.time()
+        self._print_strategy_header(strategy)
+
+        execution_state = self._initialize_execution_state()
+
+        for hook in strategy.hooks:
+            await self._execute_single_hook_in_strategy(hook, execution_state)
+
+        # Call finalize with original strategy name instead of modified one
+        total_duration = time.time() - start_time
+        success = all(r.status == "passed" for r in execution_state["hook_results"])
+
+        self._print_individual_summary(
+            strategy,
+            execution_state["hook_results"],
+            execution_state["hook_progress"],
+        )
+
+        # Return HookExecutionResult to maintain interface compatibility
+        return HookExecutionResult(
+            strategy_name=strategy.name,  # Use original name, not with "_individual" suffix
+            results=execution_state["hook_results"],
+            total_duration=total_duration,
+            success=success,
+        )
+
     def _initialize_execution_state(self) -> dict[str, t.Any]:
         return {"hook_results": [], "hook_progress": [], "execution_order": []}
 
@@ -431,13 +466,7 @@ class IndividualHookExecutor:
         if self.progress_callback:
             self.progress_callback(progress)
 
-        if self.hook_lock_manager.requires_lock(hook.name):
-            self.console.print(
-                f"\n[bold cyan]🔍 Running {hook.name} (with lock)[/ bold cyan]"
-            )
-        else:
-            self.console.print(f"\n[bold cyan]🔍 Running {hook.name}[/ bold cyan]")
-
+        # Don't print verbose "Running..." messages - the dotted-line format shows status
         cmd = hook.get_command()
 
         try:
@@ -458,11 +487,16 @@ class IndividualHookExecutor:
                     parsed_output["errors"] + parsed_output["warnings"]
                 )
 
+                status = "passed" if result.returncode == 0 else "failed"
+                # Ensure failed hooks always have at least 1 issue count
+                issues_count = 1 if status == "failed" else 0
+
                 hook_result = HookResult(
                     id=hook.name,
                     name=hook.name,
-                    status="passed" if result.returncode == 0 else "failed",
+                    status=status,
                     duration=progress.duration or 0,
+                    issues_count=issues_count,
                 )
 
                 self._print_hook_summary(hook.name, hook_result, progress)
@@ -479,6 +513,7 @@ class IndividualHookExecutor:
                 name=hook.name,
                 status="failed",
                 duration=hook.timeout,
+                issues_count=1,  # Timeout counts as 1 issue
             )
         except Exception as e:
             progress.status = "failed"
@@ -490,6 +525,7 @@ class IndividualHookExecutor:
                 name=hook.name,
                 status="failed",
                 duration=progress.duration or 0,
+                issues_count=1,  # Error counts as 1 issue
             )
 
     async def _run_command_with_streaming(
@@ -519,14 +555,11 @@ class IndividualHookExecutor:
         return self._create_completed_process(cmd, process, stdout_lines, stderr_lines)
 
     async def _create_subprocess(self, cmd: list[str]) -> asyncio.subprocess.Process:
-        repo_root = (
-            self.pkg_path.parent
-            if self.pkg_path.name == "crackerjack"
-            else self.pkg_path
-        )
+        # Use pkg_path directly as the working directory for hook execution
+        # This ensures hooks run in the correct project directory regardless of project name
         return await asyncio.create_subprocess_exec(
             *cmd,
-            cwd=repo_root,
+            cwd=self.pkg_path,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
         )
@@ -602,8 +635,8 @@ class IndividualHookExecutor:
         ):
             self.progress_callback(progress)
 
+    @staticmethod
     async def _wait_for_process_completion(
-        self,
         process: asyncio.subprocess.Process,
         tasks: list[asyncio.Task[None]],
         timeout: int,
@@ -611,8 +644,8 @@ class IndividualHookExecutor:
         await asyncio.wait_for(process.wait(), timeout=timeout)
         await asyncio.gather(*tasks, return_exceptions=True)
 
+    @staticmethod
     def _handle_process_timeout(
-        self,
         process: asyncio.subprocess.Process,
         tasks: list[asyncio.Task[None]],
     ) -> None:
@@ -620,8 +653,8 @@ class IndividualHookExecutor:
         for task in tasks:
             task.cancel()
 
+    @staticmethod
     def _create_completed_process(
-        self,
         cmd: list[str],
         process: asyncio.subprocess.Process,
         stdout_lines: list[str],
@@ -651,22 +684,23 @@ class IndividualHookExecutor:
         result: HookResult,
         progress: HookProgress,
     ) -> None:
+        """Print hook result in dotted-line format matching pre-commit style.
+
+        Format: hook-name.......................................... ✅
+        """
         status_icon = "✅" if result.status == "passed" else "❌"
-        duration_str = f"{progress.duration: .1f}s" if progress.duration else "0.0s"
 
-        summary_parts: list[str] = []
-        if progress.errors_found > 0:
-            summary_parts.append(f"{progress.errors_found} errors")
-        if progress.warnings_found > 0:
-            summary_parts.append(f"{progress.warnings_found} warnings")
-        if progress.files_processed > 0:
-            summary_parts.append(f"{progress.files_processed} files")
+        # Calculate dotted line (same logic as base HookExecutor)
+        max_width = get_console_width()
+        content_width = max_width - 4  # Adjusted for icon and padding
 
-        summary = ", ".join(summary_parts) if summary_parts else "clean"
+        if len(hook_name) > content_width:
+            line = hook_name[: content_width - 3] + "..."
+        else:
+            dots_needed = max(0, content_width - len(hook_name))
+            line = hook_name + ("." * dots_needed)
 
-        self.console.print(
-            f"[bold]{status_icon} {hook_name}[/ bold] - {duration_str}-{summary}",
-        )
+        self.console.print(f"{line} {status_icon}")
 
     def _print_individual_summary(
         self,
@@ -680,7 +714,7 @@ class IndividualHookExecutor:
         total_warnings = sum(p.warnings_found for p in progress_list)
         total_duration = sum(p.duration or 0 for p in progress_list)
 
-        self.console.print("\n" + "-" * 74)
+        self.console.print("\n" + make_separator("-", get_console_width()))
         self.console.print(
             f"[bold]📊 INDIVIDUAL EXECUTION SUMMARY[/ bold]-{strategy.name.upper()}",
         )
@@ -702,4 +736,4 @@ class IndividualHookExecutor:
                     )
                     self.console.print(f" ❌ {progress.hook_name}-{error_summary}")
 
-        self.console.print("-" * 74)
+        self.console.print(make_separator("-", get_console_width()))

crackerjack/executors/lsp_aware_hook_executor.py

@@ -1,8 +1,10 @@
 import time
 import typing as t
+from contextlib import suppress
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
 from crackerjack.config.hooks import HookDefinition, HookStrategy
 from crackerjack.executors.hook_executor import HookExecutionResult, HookExecutor
@@ -19,18 +21,25 @@ except ImportError:
 class LSPAwareHookExecutor(HookExecutor):
     """Hook executor that can leverage LSP server for enhanced performance."""
 
+    @depends.inject
     def __init__(
         self,
-        console: Console,
+        console: Inject[Console],
         pkg_path: Path,
         verbose: bool = False,
         quiet: bool = False,
+        debug: bool = False,
         use_tool_proxy: bool = True,
+        use_incremental: bool = False,
+        git_service: t.Any | None = None,
     ) -> None:
-        super().__init__(console, pkg_path, verbose, quiet)
-        self.lsp_client = LSPClient(console)
+        super().__init__(
+            console, pkg_path, verbose, quiet, debug, use_incremental, git_service
+        )
+        self.lsp_client = LSPClient()
         self.use_tool_proxy = use_tool_proxy and ToolProxy is not None
-        self.tool_proxy = ToolProxy(console) if self.use_tool_proxy else None
+        self.tool_proxy = ToolProxy() if self.use_tool_proxy else None
+        self.debug = debug
 
     def execute_strategy(self, strategy: HookStrategy) -> HookExecutionResult:
         """Execute hook strategy with LSP optimization where possible."""
@@ -38,24 +47,14 @@ class LSPAwareHookExecutor(HookExecutor):
         results = []
 
         # Check if LSP server is available
-        lsp_available = self.lsp_client.is_server_running()
-
-        if lsp_available and not self.quiet:
-            server_info = self.lsp_client.get_server_info()
-            if server_info:
-                self.console.print(
-                    f"🔍 LSP server available (PID: {server_info['pid']}), using optimized execution"
-                )
+        lsp_available = self._check_lsp_availability()
 
         # Execute hooks with LSP optimization and tool proxy resilience
         for hook in strategy.hooks:
-            if self._should_use_lsp_for_hook(hook, lsp_available):
-                result = self._execute_lsp_hook(hook)
-            elif self._should_use_tool_proxy(hook):
-                result = self._execute_hook_with_proxy(hook)
-            else:
-                result = self.execute_single_hook(hook)
+            self._handle_progress_start(len(strategy.hooks))
+            result = self._execute_single_hook_with_strategies(hook, lsp_available)
             results.append(result)
+            self._handle_progress_completion(len(strategy.hooks))
 
         duration = time.time() - start_time
         success = all(result.status in ("passed", "skipped") for result in results)
@@ -68,6 +67,51 @@ class LSPAwareHookExecutor(HookExecutor):
             concurrent_execution=False,
         )
 
+    def _check_lsp_availability(self) -> bool:
+        """Check if LSP server is available and print info message."""
+        lsp_available = self.lsp_client.is_server_running()
+
+        if lsp_available and not self.quiet:
+            server_info = self.lsp_client.get_server_info()
+            if server_info:
+                self.console.print(
+                    f"🔍 LSP server available (PID: {server_info['pid']}), using optimized execution"
+                )
+
+        return lsp_available
+
+    def _execute_single_hook_with_strategies(
+        self, hook: HookDefinition, lsp_available: bool
+    ) -> HookResult:
+        """Execute a single hook using appropriate strategy."""
+        if self._should_use_lsp_for_hook(hook, lsp_available):
+            return self._execute_lsp_hook(hook)
+        elif self._should_use_tool_proxy(hook):
+            return self._execute_hook_with_proxy(hook)
+
+        return self.execute_single_hook(hook)
+
+    def _handle_progress_start(self, total_hooks: int | None = None) -> None:
+        """Handle progress start callback."""
+        with suppress(Exception):
+            callback = getattr(self, "_progress_start_callback", None)
+            if callback:
+                # _total_hooks/_started_hooks are initialized by set_progress_callbacks on base class
+                self._started_hooks += 1  # type: ignore[attr-defined]
+                total = self._total_hooks or total_hooks  # type: ignore[attr-defined]
+                if total:
+                    callback(self._started_hooks, total)  # type: ignore[attr-defined]
+
+    def _handle_progress_completion(self, total_hooks: int | None = None) -> None:
+        """Handle progress completion callback."""
+        with suppress(Exception):
+            callback = getattr(self, "_progress_callback", None)
+            if callback:
+                self._completed_hooks += 1  # type: ignore[attr-defined]
+                total = self._total_hooks or total_hooks  # type: ignore[attr-defined]
+                if total:
+                    callback(self._completed_hooks, total)  # type: ignore[attr-defined]
+
     def _should_use_lsp_for_hook(
         self, hook: HookDefinition, lsp_available: bool
     ) -> bool:
@@ -108,13 +152,32 @@ class LSPAwareHookExecutor(HookExecutor):
 
         self._display_lsp_results(hook, has_errors, output, summary)
 
+        # Create hook result
+        return self._create_lsp_hook_result(
+            hook, duration, has_errors, output, diagnostics
+        )
+
+    def _create_lsp_hook_result(
+        self,
+        hook: HookDefinition,
+        duration: float,
+        has_errors: bool,
+        output: str,
+        diagnostics: dict,
+    ) -> HookResult:
+        """Create the HookResult for LSP execution."""
+        # Ensure failed hooks always have at least 1 issue count
+        issues_found = [output] if has_errors else []
+        issues_count = max(len(issues_found), 1 if has_errors else 0)
+
         return HookResult(
             id=f"{hook.name}-lsp-{int(time.time())}",
             name=f"{hook.name}-lsp",
             status="failed" if has_errors else "passed",
             duration=duration,
             files_processed=len(diagnostics),
-            issues_found=[output] if has_errors else [],
+            issues_found=issues_found,
+            issues_count=issues_count,
         )
 
     def _format_lsp_output(self, diagnostics: dict[str, t.Any], duration: float) -> str:
@@ -163,50 +226,66 @@ class LSPAwareHookExecutor(HookExecutor):
         start_time = time.time()
 
         try:
-            if not self.quiet:
-                self.console.print(
-                    f"🛡️ Using resilient execution for {hook.name}", style="blue"
-                )
+            return self._perform_proxy_execution(hook, start_time)
+        except Exception as e:
+            return self._handle_proxy_execution_error(hook, start_time, e)
 
-            # Parse hook entry to extract tool name and args
-            tool_name, args = self._parse_hook_entry(hook)
+    def _perform_proxy_execution(
+        self, hook: HookDefinition, start_time: float
+    ) -> HookResult:
+        """Perform the actual proxy execution."""
+        if not self.quiet:
+            self.console.print(
+                f"🛡️ Using resilient execution for {hook.name}", style="blue"
+            )
 
-            # Execute through tool proxy
-            if self.tool_proxy is not None:
-                exit_code = self.tool_proxy.execute_tool(tool_name, args)
-            else:
-                exit_code = -1  # Error code when tool proxy is not available
+        # Parse hook entry to extract tool name and args
+        tool_name, args = self._parse_hook_entry(hook)
 
-            duration = time.time() - start_time
-            status = "passed" if exit_code == 0 else "failed"
+        # Execute through tool proxy
+        if self.tool_proxy is not None:
+            exit_code = self.tool_proxy.execute_tool(tool_name, args)
+        else:
+            exit_code = -1  # Error code when tool proxy is not available
 
-            # Get tool status for output
-            tool_status = (
-                self.tool_proxy.get_tool_status().get(tool_name, {})
-                if self.tool_proxy is not None
-                else {}
-            )
-            output = self._format_proxy_output(tool_name, tool_status, duration)
-
-            return HookResult(
-                id=f"{hook.name}-proxy-{int(time.time())}",
-                name=f"{hook.name}-proxy",
-                status=status,
-                duration=duration,
-                files_processed=1,  # Placeholder value
-                issues_found=[output] if status == "failed" else [],
-            )
+        duration = time.time() - start_time
+        status = "passed" if exit_code == 0 else "failed"
 
-        except Exception as e:
-            duration = time.time() - start_time
-            error_msg = f"Tool proxy execution failed: {e}"
+        # Get tool status for output
+        tool_status = (
+            self.tool_proxy.get_tool_status().get(tool_name, {})
+            if self.tool_proxy is not None
+            else {}
+        )
+        output = self._format_proxy_output(tool_name, tool_status, duration)
 
-            if not self.quiet:
-                self.console.print(f"❌ {hook.name} (proxy): {error_msg}", style="red")
-                self.console.print(f"🔄 Falling back to regular {hook.name} execution")
+        # Ensure failed hooks always have at least 1 issue count
+        issues_found = [output] if status == "failed" else []
+        issues_count = max(len(issues_found), 1 if status == "failed" else 0)
+
+        return HookResult(
+            id=f"{hook.name}-proxy-{int(time.time())}",
+            name=f"{hook.name}-proxy",
+            status=status,
+            duration=duration,
+            files_processed=1,  # Placeholder value
+            issues_found=issues_found,
+            issues_count=issues_count,
+        )
+
+    def _handle_proxy_execution_error(
+        self, hook: HookDefinition, start_time: float, error: Exception
+    ) -> HookResult:
+        """Handle proxy execution errors with fallback."""
+        time.time() - start_time
+        error_msg = f"Tool proxy execution failed: {error}"
 
-            # Fallback to regular execution
-            return self.execute_single_hook(hook)
+        if not self.quiet:
+            self.console.print(f"❌ {hook.name} (proxy): {error_msg}", style="red")
+            self.console.print(f"🔄 Falling back to regular {hook.name} execution")
+
+        # Fallback to regular execution
+        return self.execute_single_hook(hook)
 
     def _parse_hook_entry(self, hook: HookDefinition) -> tuple[str, list[str]]:
         """Parse hook entry to extract tool name and arguments."""