crackerjack 0.33.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/dynamic_config.py

@@ -21,6 +21,7 @@ class HookMetadata(t.TypedDict):
     language: str | None
     entry: str | None
     experimental: bool
+    pass_filenames: bool | None
 
 
 class ConfigMode(t.TypedDict):
@@ -48,6 +49,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": "system",
             "entry": "uv run python -m crackerjack.tools.validate_regex_patterns",
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "trailing-whitespace",
@@ -65,6 +67,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "end-of-file-fixer",
@@ -82,6 +85,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "check-yaml",
@@ -99,6 +103,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "check-toml",
@@ -116,6 +121,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "check-added-large-files",
@@ -133,6 +139,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
     ],
     "package_management": [
@@ -152,6 +159,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
     ],
     "security": [
@@ -171,6 +179,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "bandit",
@@ -188,6 +197,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
     ],
     "formatting": [
@@ -207,6 +217,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "ruff-check",
@@ -224,6 +235,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "ruff-format",
@@ -241,6 +253,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "mdformat",
@@ -258,25 +271,27 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
     ],
     "analysis": [
         {
-            "id": "vulture",
-            "name": None,
-            "repo": "https://github.com/jendrikseipp/vulture",
-            "rev": "v2.14",
+            "id": "skylos",
+            "name": "skylos-dead-code-detection",
+            "repo": "local",
+            "rev": "",
             "tier": 3,
-            "time_estimate": 2.0,
+            "time_estimate": 0.1,
             "stages": ["pre-push", "manual"],
-            "args": None,
-            "files": "^crackerjack/.*\\.py$",
+            "args": ["crackerjack"],
+            "files": None,
             "exclude": None,
             "additional_dependencies": None,
             "types_or": None,
-            "language": None,
-            "entry": None,
+            "language": "system",
+            "entry": "skylos",
             "experimental": False,
+            "pass_filenames": False,
         },
         {
             "id": "creosote",
@@ -294,6 +309,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "complexipy",
@@ -311,6 +327,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
             "id": "refurb",
@@ -328,61 +345,46 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "language": None,
             "entry": None,
             "experimental": False,
+            "pass_filenames": None,
         },
         {
-            "id": "pyright",
-            "name": None,
-            "repo": "https://github.com/RobertCraigie/pyright-python",
-            "rev": "v1.1.405",
+            "id": "zuban",
+            "name": "zuban-type-checking",
+            "repo": "local",
+            "rev": "",
             "tier": 3,
-            "time_estimate": 5.0,
+            "time_estimate": 0.15,
             "stages": ["pre-push", "manual"],
-            "args": None,
-            "files": "^crackerjack/.*\\.py$",
-            "exclude": r"^crackerjack/(mcp|plugins)/.*\.py$|crackerjack/code_cleaner\.py$",
+            "args": ["--config-file", "mypy.ini", "./crackerjack"],
+            "files": None,
+            "exclude": None,
             "additional_dependencies": None,
             "types_or": None,
-            "language": None,
-            "entry": None,
+            "language": "system",
+            "entry": "uv run zuban check",
             "experimental": False,
-        },
-    ],
-    "experimental": [
-        {
-            "id": "pyrefly",
-            "name": "pyrefly",
-            "repo": "local",
-            "rev": "",
-            "tier": 3,
-            "time_estimate": 5.0,
-            "stages": ["manual"],
-            "args": ["--check"],
-            "files": "^crackerjack/.*\\.py$",
-            "exclude": None,
-            "additional_dependencies": ["pyrefly >= 0.1.0"],
-            "types_or": ["python"],
-            "language": "python",
-            "entry": "python -m pyrefly",
-            "experimental": True,
+            "pass_filenames": False,
         },
         {
-            "id": "ty",
-            "name": "ty",
+            "id": "pyright",
+            "name": "pyright-type-checking",
             "repo": "local",
             "rev": "",
             "tier": 3,
-            "time_estimate": 2.0,
-            "stages": ["manual"],
-            "args": ["--check"],
+            "time_estimate": 0.25,
+            "stages": ["pre-push", "manual"],
+            "args": [],
             "files": "^crackerjack/.*\\.py$",
-            "exclude": None,
-            "additional_dependencies": ["ty >= 0.1.0"],
-            "types_or": ["python"],
-            "language": "python",
-            "entry": "python -m ty",
-            "experimental": True,
+            "exclude": r"^crackerjack/(mcp|plugins)/.*\.py$|crackerjack/code_cleaner\.py$",
+            "additional_dependencies": None,
+            "types_or": None,
+            "language": "system",
+            "entry": "uv run pyright",
+            "experimental": False,
+            "pass_filenames": None,
         },
     ],
+    "experimental": [],
 }
 
 CONFIG_MODES: dict[str, ConfigMode] = {
@@ -430,6 +432,9 @@ PRE_COMMIT_TEMPLATE = """repos:
         {%- if hook.args %}
         args: {{ hook.args | tojson }}
         {%- endif %}
+        {%- if hook.pass_filenames is not none %}
+        pass_filenames: {{ hook.pass_filenames | lower }}
+        {%- endif %}
         {%- if hook.files %}
         files: {{ hook.files }}
         {%- endif %}
@@ -580,7 +585,7 @@ def generate_config_for_mode(
 
 
 def get_available_modes() -> list[str]:
-    return list(CONFIG_MODES.keys())
+    return list[t.Any](CONFIG_MODES.keys())
 
 
 def add_experimental_hook(hook_id: str, hook_config: HookMetadata) -> None:

crackerjack/executors/async_hook_executor.py

@@ -70,14 +70,14 @@ class AsyncHookExecutor:
 
         self._semaphore = asyncio.Semaphore(max_concurrent)
 
-        # Use dependency injection for hook lock manager
         if hook_lock_manager is None:
-            # Import here to avoid circular imports
             from crackerjack.executors.hook_lock_manager import (
                 hook_lock_manager as default_manager,
             )
 
-            self.hook_lock_manager = default_manager
+            self.hook_lock_manager: HookLockManagerProtocol = t.cast(
+                HookLockManagerProtocol, default_manager
+            )
         else:
             self.hook_lock_manager = hook_lock_manager
 
@@ -143,11 +143,9 @@ class AsyncHookExecutor:
             )
 
     def get_lock_statistics(self) -> dict[str, t.Any]:
-        """Get comprehensive lock usage statistics for monitoring."""
         return self.hook_lock_manager.get_lock_stats()
 
     def get_comprehensive_status(self) -> dict[str, t.Any]:
-        """Get comprehensive status including lock manager status."""
         return {
             "executor_config": {
                 "max_concurrent": self.max_concurrent,
@@ -158,7 +156,7 @@ class AsyncHookExecutor:
         }
 
     def _print_strategy_header(self, strategy: HookStrategy) -> None:
-        self.console.print("\n" + "-" * 80)
+        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]",
@@ -171,7 +169,7 @@ class AsyncHookExecutor:
             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("-" * 80 + "\n")
+        self.console.print("-" * 74 + "\n")
 
     async def _execute_sequential(self, strategy: HookStrategy) -> list[HookResult]:
         results: list[HookResult] = []
@@ -200,21 +198,21 @@ class AsyncHookExecutor:
             tasks = [self._execute_single_hook(hook) for hook in other_hooks]
             parallel_results = await asyncio.gather(*tasks, return_exceptions=True)
 
-            for i, result in enumerate(parallel_results):
-                if isinstance(result, Exception):
+            for i, task_result in enumerate(parallel_results):
+                if isinstance(task_result, Exception):
                     hook = other_hooks[i]
                     error_result = HookResult(
                         id=getattr(hook, "name", f"hook_{i}"),
                         name=getattr(hook, "name", f"hook_{i}"),
                         status="error",
                         duration=0.0,
-                        issues_found=[str(result)],
+                        issues_found=[str(task_result)],
                         stage=hook.stage.value,
                     )
                     results.append(error_result)
                     self._display_hook_result(error_result)
                 else:
-                    hook_result = t.cast("HookResult", result)
+                    hook_result = t.cast(HookResult, task_result)
                     results.append(hook_result)
                     self._display_hook_result(hook_result)
 
@@ -222,7 +220,6 @@ class AsyncHookExecutor:
 
     async def _execute_single_hook(self, hook: HookDefinition) -> HookResult:
         async with self._semaphore:
-            # Check if hook requires sequential execution
             if self.hook_lock_manager.requires_lock(hook.name):
                 self.logger.debug(
                     f"Hook {hook.name} requires sequential execution lock"
@@ -232,7 +229,6 @@ class AsyncHookExecutor:
                         f"[dim]🔒 {hook.name} (sequential execution)[/dim]"
                     )
 
-            # Acquire hook-specific lock if required (e.g., for complexipy)
             if self.hook_lock_manager.requires_lock(hook.name):
                 self.logger.debug(
                     f"Hook {hook.name} requires sequential execution lock"
@@ -242,7 +238,7 @@ class AsyncHookExecutor:
                         f"[dim]🔒 {hook.name} (sequential execution)[/dim]"
                     )
 
-                async with self.hook_lock_manager.acquire_hook_lock(hook.name):  # type: ignore
+                async with self.hook_lock_manager.acquire_hook_lock(hook.name):
                     return await self._run_hook_subprocess(hook)
             else:
                 return await self._run_hook_subprocess(hook)
@@ -261,7 +257,6 @@ class AsyncHookExecutor:
                 timeout=timeout_val,
             )
 
-            # Pre-commit must run from repository root, not package directory
             repo_root = (
                 self.pkg_path.parent
                 if self.pkg_path.name == "crackerjack"

crackerjack/executors/cached_hook_executor.py

@@ -50,62 +50,120 @@ class CachedHookExecutor:
         )
 
         start_time = time.time()
-        results: list[HookResult] = []
-        cache_hits = 0
-        cache_misses = 0
+        execution_context = self._initialize_execution_context(strategy)
 
+        for hook_def in strategy.hooks:
+            self._execute_single_hook_with_cache(hook_def, execution_context)
+
+        return self._build_execution_result(strategy, execution_context, start_time)
+
+    def _initialize_execution_context(self, strategy: HookStrategy) -> dict[str, t.Any]:
+        """Initialize execution context for the strategy."""
         relevant_files = self._get_relevant_files_for_strategy(strategy)
         current_file_hashes = self.file_hasher.get_files_hash_list(relevant_files)
 
-        for hook_def in strategy.hooks:
-            cached_result = None
-            try:
-                cached_result = self.cache.get_hook_result(
-                    hook_def.name,
-                    current_file_hashes,
+        return {
+            "results": [],
+            "cache_hits": 0,
+            "cache_misses": 0,
+            "current_file_hashes": current_file_hashes,
+        }
+
+    def _execute_single_hook_with_cache(
+        self, hook_def: HookDefinition, context: dict[str, t.Any]
+    ) -> None:
+        """Execute a single hook with caching logic."""
+        cached_result = self._get_cached_result(
+            hook_def, context["current_file_hashes"]
+        )
+
+        if cached_result and self._is_cache_valid(cached_result, hook_def):
+            self._handle_cache_hit(hook_def, cached_result, context)
+        else:
+            self._handle_cache_miss(hook_def, context)
+
+    def _get_cached_result(
+        self, hook_def: HookDefinition, current_file_hashes: list[str]
+    ) -> HookResult | None:
+        """Get cached result for a hook definition."""
+        try:
+            if hook_def.name in self.cache.EXPENSIVE_HOOKS:
+                tool_version = self._get_tool_version(hook_def.name)
+                return self.cache.get_expensive_hook_result(
+                    hook_def.name, current_file_hashes, tool_version
+                )
+            else:
+                return self.cache.get_hook_result(hook_def.name, current_file_hashes)
+        except Exception as e:
+            self.logger.warning(f"Cache error for hook {hook_def.name}: {e}")
+            return None
+
+    def _handle_cache_hit(
+        self,
+        hook_def: HookDefinition,
+        cached_result: HookResult,
+        context: dict[str, t.Any],
+    ) -> None:
+        """Handle a cache hit scenario."""
+        self.logger.debug(f"Using cached result for hook: {hook_def.name}")
+        context["results"].append(cached_result)
+        context["cache_hits"] += 1
+
+    def _handle_cache_miss(
+        self, hook_def: HookDefinition, context: dict[str, t.Any]
+    ) -> None:
+        """Handle a cache miss scenario."""
+        self.logger.debug(f"Executing hook (cache miss): {hook_def.name}")
+
+        hook_result = self.base_executor.execute_single_hook(hook_def)
+        context["results"].append(hook_result)
+        context["cache_misses"] += 1
+
+        if hook_result.status == "passed":
+            self._cache_successful_result(
+                hook_def, hook_result, context["current_file_hashes"]
+            )
+
+    def _cache_successful_result(
+        self,
+        hook_def: HookDefinition,
+        hook_result: HookResult,
+        current_file_hashes: list[str],
+    ) -> None:
+        """Cache a successful hook result."""
+        try:
+            if hook_def.name in self.cache.EXPENSIVE_HOOKS:
+                tool_version = self._get_tool_version(hook_def.name)
+                self.cache.set_expensive_hook_result(
+                    hook_def.name, current_file_hashes, hook_result, tool_version
                 )
-            except Exception as e:
-                self.logger.warning(f"Cache error for hook {hook_def.name}: {e}")
-                cached_result = None
-
-            if cached_result and self._is_cache_valid(cached_result, hook_def):
-                self.logger.debug(f"Using cached result for hook: {hook_def.name}")
-                results.append(cached_result)
-                cache_hits += 1
             else:
-                self.logger.debug(f"Executing hook (cache miss): {hook_def.name}")
-
-                hook_result = self.base_executor.execute_single_hook(hook_def)
-                results.append(hook_result)
-                cache_misses += 1
-
-                if hook_result.status == "passed":
-                    try:
-                        self.cache.set_hook_result(
-                            hook_def.name,
-                            current_file_hashes,
-                            hook_result,
-                        )
-                    except Exception as e:
-                        self.logger.warning(
-                            f"Failed to cache result for {hook_def.name}: {e}",
-                        )
+                self.cache.set_hook_result(
+                    hook_def.name, current_file_hashes, hook_result
+                )
+        except Exception as e:
+            self.logger.warning(f"Failed to cache result for {hook_def.name}: {e}")
 
+    def _build_execution_result(
+        self, strategy: HookStrategy, context: dict[str, t.Any], start_time: float
+    ) -> HookExecutionResult:
+        """Build the final execution result."""
         total_time = time.time() - start_time
-        success = all(result.status == "passed" for result in results)
+        success = all(result.status == "passed" for result in context["results"])
 
         self.logger.info(
-            f"Cached strategy '{strategy.name}' completed in {total_time: .2f}s-"
-            f"Success: {success}, Cache hits: {cache_hits}, Cache misses: {cache_misses}",
+            f"Cached strategy '{strategy.name}' completed in {total_time:.2f}s - "
+            f"Success: {success}, Cache hits: {context['cache_hits']}, "
+            f"Cache misses: {context['cache_misses']}"
         )
 
         return HookExecutionResult(
             strategy_name=strategy.name,
-            results=results,
+            results=context["results"],
             success=success,
             total_duration=total_time,
-            cache_hits=cache_hits,
-            cache_misses=cache_misses,
+            cache_hits=context["cache_hits"],
+            cache_misses=context["cache_misses"],
         )
 
     def _get_relevant_files_for_strategy(self, strategy: HookStrategy) -> list[Path]:
@@ -118,7 +176,7 @@ class CachedHookExecutor:
 
         files: list[Path] = []
         for pattern in patterns:
-            files.extend(list(self.pkg_path.rglob(pattern)))
+            files.extend(list[t.Any](self.pkg_path.rglob(pattern)))
 
         return [f for f in files if f.is_file() and not self._should_ignore_file(f)]
 
@@ -177,6 +235,21 @@ class CachedHookExecutor:
     def cleanup_cache(self) -> dict[str, int]:
         return self.cache.cleanup_all()
 
+    def _get_tool_version(self, tool_name: str) -> str | None:
+        """Get version of a tool for cache invalidation."""
+        # This is a simplified version - in production, you might want to
+        # actually call the tool to get its version
+        version_mapping = {
+            "pyright": "1.1.0",  # Could be dynamic: subprocess.run(["pyright", "--version"])
+            "bandit": "1.7.5",
+            "vulture": "2.7.0",
+            "complexipy": "0.13.0",
+            "refurb": "1.17.0",
+            "ruff": "0.1.0",
+            "gitleaks": "8.18.0",
+        }
+        return version_mapping.get(tool_name)
+
 
 class SmartCacheManager:
     def __init__(self, cached_executor: CachedHookExecutor) -> None:
@@ -203,7 +276,8 @@ class SmartCacheManager:
         }
         if hook_name in formatting_hooks:
             recent_changes = project_state.get("recent_changes", 0)
-            return recent_changes < 5
+            result: bool = recent_changes < 5
+            return result
 
         return True
 
@@ -237,6 +311,6 @@ class SmartCacheManager:
 
         return {
             "recent_changes": recent_changes,
-            "total_python_files": len(list(pkg_path.rglob("*.py"))),
+            "total_python_files": len(list[t.Any](pkg_path.rglob("*.py"))),
             "project_size": "large" if recent_changes > 50 else "small",
         }