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

crackerjack/documentation/reference_generator.py

@@ -485,44 +485,74 @@ class ReferenceGenerator:
         Returns:
             Enhanced commands with workflow info
         """
-        # Define common workflow patterns
-        workflow_patterns = {
+        workflow_patterns = self._get_workflow_patterns()
+
+        for command in commands.values():
+            self._assign_command_workflows(command, workflow_patterns)
+            self._add_ai_context_to_command(command)
+
+        return commands
+
+    def _get_workflow_patterns(self) -> dict[str, list[str]]:
+        """Get workflow patterns for command categorization.
+
+        Returns:
+            Dictionary mapping workflow names to pattern lists
+        """
+        return {
             "development": ["test", "format", "lint", "type-check"],
             "release": ["version", "build", "publish", "tag"],
             "maintenance": ["clean", "update", "optimize", "backup"],
             "monitoring": ["status", "health", "metrics", "logs"],
         }
 
-        for command in commands.values():
-            # Assign workflows based on command name patterns
-            for workflow, patterns in workflow_patterns.items():
-                if any(pattern in command.name for pattern in patterns):
-                    command.common_workflows.append(workflow)
-
-            # Add AI context based on command purpose
-            if "test" in command.name:
-                command.ai_context.update(
-                    {
-                        "purpose": "quality_assurance",
-                        "automation_level": "high",
-                        "ai_agent_compatible": True,
-                    }
-                )
-                command.success_patterns.append("All tests passed")
-                command.failure_patterns.append("Test failures detected")
-
-            elif "format" in command.name or "lint" in command.name:
-                command.ai_context.update(
-                    {
-                        "purpose": "code_quality",
-                        "automation_level": "high",
-                        "ai_agent_compatible": True,
-                    }
-                )
-                command.success_patterns.append("No formatting issues")
-                command.failure_patterns.append("Style violations found")
+    def _assign_command_workflows(
+        self, command: CommandInfo, workflow_patterns: dict[str, list[str]]
+    ) -> None:
+        """Assign workflows to a command based on name patterns.
 
-        return commands
+        Args:
+            command: Command to assign workflows to
+            workflow_patterns: Workflow patterns to match against
+        """
+        for workflow, patterns in workflow_patterns.items():
+            if any(pattern in command.name for pattern in patterns):
+                command.common_workflows.append(workflow)
+
+    def _add_ai_context_to_command(self, command: CommandInfo) -> None:
+        """Add AI context to a command based on its purpose.
+
+        Args:
+            command: Command to enhance with AI context
+        """
+        if "test" in command.name:
+            self._add_test_ai_context(command)
+        elif "format" in command.name or "lint" in command.name:
+            self._add_quality_ai_context(command)
+
+    def _add_test_ai_context(self, command: CommandInfo) -> None:
+        """Add AI context for test-related commands."""
+        command.ai_context.update(
+            {
+                "purpose": "quality_assurance",
+                "automation_level": "high",
+                "ai_agent_compatible": True,
+            }
+        )
+        command.success_patterns.append("All tests passed")
+        command.failure_patterns.append("Test failures detected")
+
+    def _add_quality_ai_context(self, command: CommandInfo) -> None:
+        """Add AI context for code quality commands."""
+        command.ai_context.update(
+            {
+                "purpose": "code_quality",
+                "automation_level": "high",
+                "ai_agent_compatible": True,
+            }
+        )
+        command.success_patterns.append("No formatting issues")
+        command.failure_patterns.append("Style violations found")
 
     def _categorize_commands(
         self, commands: dict[str, CommandInfo]
@@ -536,8 +566,18 @@ class ReferenceGenerator:
             Dictionary of category to command names
         """
         categories: dict[str, list[str]] = {}
+        category_patterns = self._get_category_patterns()
+
+        for command in commands.values():
+            category = self._determine_command_category(command, category_patterns)
+            command.category = category
+            self._add_command_to_category(categories, category, command.name)
+
+        return categories
 
-        category_patterns = {
+    def _get_category_patterns(self) -> dict[str, list[str]]:
+        """Get category patterns for command classification."""
+        return {
             "development": ["test", "format", "lint", "check", "run"],
             "server": ["server", "start", "stop", "restart", "monitor"],
             "release": ["version", "bump", "publish", "build", "tag"],
@@ -545,27 +585,22 @@ class ReferenceGenerator:
             "utilities": ["clean", "help", "info", "status"],
         }
 
-        for command in commands.values():
-            assigned = False
-
-            # Assign based on patterns
-            for category, patterns in category_patterns.items():
-                if any(pattern in command.name for pattern in patterns):
-                    command.category = category
-                    if category not in categories:
-                        categories[category] = []
-                    categories[category].append(command.name)
-                    assigned = True
-                    break
-
-            # Default category
-            if not assigned:
-                command.category = "general"
-                if "general" not in categories:
-                    categories["general"] = []
-                categories["general"].append(command.name)
-
-        return categories
+    def _determine_command_category(
+        self, command: CommandInfo, category_patterns: dict[str, list[str]]
+    ) -> str:
+        """Determine the category for a command based on patterns."""
+        for category, patterns in category_patterns.items():
+            if any(pattern in command.name for pattern in patterns):
+                return category
+        return "general"
+
+    def _add_command_to_category(
+        self, categories: dict[str, list[str]], category: str, command_name: str
+    ) -> None:
+        """Add command to the specified category."""
+        if category not in categories:
+            categories[category] = []
+        categories[category].append(command_name)
 
     def _generate_workflows(
         self, commands: dict[str, CommandInfo]
@@ -663,7 +698,9 @@ class ReferenceGenerator:
         """Render command categories for markdown."""
         category_lines = []
         for category, command_names in reference.categories.items():
-            category_section = self._render_markdown_category(category, reference.commands, command_names)
+            category_section = self._render_markdown_category(
+                category, reference.commands, command_names
+            )
             category_lines.extend(category_section)
         return category_lines
 
@@ -733,7 +770,9 @@ class ReferenceGenerator:
 
         # Add related commands section
         if command.related_commands:
-            related_lines = self._render_command_related_markdown(command.related_commands)
+            related_lines = self._render_command_related_markdown(
+                command.related_commands
+            )
             lines.extend(related_lines)
 
         return lines
@@ -813,9 +852,11 @@ class ReferenceGenerator:
     def _render_html(self, reference: CommandReference) -> str:
         """Render reference as HTML."""
         html_parts = [
-            self._render_html_header(reference.generated_at.strftime("%Y-%m-%d %H:%M:%S")),
+            self._render_html_header(
+                reference.generated_at.strftime("%Y-%m-%d %H:%M:%S")
+            ),
             self._render_html_commands(reference),
-            "</body></html>"
+            "</body></html>",
         ]
         return "".join(html_parts)
 
@@ -842,7 +883,9 @@ class ReferenceGenerator:
         """Render HTML commands by category."""
         html_parts = []
         for category, command_names in reference.categories.items():
-            category_html = self._render_html_category(category, reference.commands, command_names)
+            category_html = self._render_html_category(
+                category, reference.commands, command_names
+            )
             html_parts.append(category_html)
         return "".join(html_parts)
 
@@ -918,7 +961,9 @@ class ReferenceGenerator:
             "aliases": command.aliases,
         }
 
-    def _serialize_parameters(self, parameters: list[ParameterInfo]) -> list[dict[str, t.Any]]:
+    def _serialize_parameters(
+        self, parameters: list[ParameterInfo]
+    ) -> list[dict[str, t.Any]]:
         """Serialize parameters for JSON output."""
         return [self._serialize_parameter(param) for param in parameters]
 

crackerjack/dynamic_config.py

@@ -192,7 +192,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "stages": ["pre-push", "manual"],
             "args": ["-c", "pyproject.toml", "-r", "-ll"],
             "files": "^crackerjack/.*\\.py$",
-            "exclude": None,
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": None,
@@ -284,9 +284,9 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "tier": 3,
             "time_estimate": 0.1,
             "stages": ["pre-push", "manual"],
-            "args": ["crackerjack"],
+            "args": ["crackerjack", "--exclude", "tests"],
             "files": None,
-            "exclude": None,
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": "system",
@@ -338,9 +338,9 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "tier": 3,
             "time_estimate": 3.0,
             "stages": ["pre-push", "manual"],
-            "args": ["--ignore", "FURB184", "--ignore", "FURB120"],
+            "args": [],
             "files": "^crackerjack/.*\\.py$",
-            "exclude": r"^tests/.*\.py$",
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": None,
@@ -358,7 +358,7 @@ HOOKS_REGISTRY: dict[str, list[HookMetadata]] = {
             "stages": ["pre-push", "manual"],
             "args": ["--config-file", "mypy.ini", "./crackerjack"],
             "files": None,
-            "exclude": None,
+            "exclude": r"^tests/",
             "additional_dependencies": None,
             "types_or": None,
             "language": "system",
@@ -544,7 +544,7 @@ class DynamicConfigGenerator:
         """Update hook configuration to use the detected package directory."""
         # Update skylos hook
         if hook["id"] == "skylos" and hook["args"]:
-            hook["args"] = [self.package_directory]
+            hook["args"] = [self.package_directory, "--exclude", "tests"]
 
         # Update zuban hook
         elif hook["id"] == "zuban" and hook["args"]:
@@ -566,12 +566,24 @@ class DynamicConfigGenerator:
                 "crackerjack", self.package_directory
             )
 
-        # Ensure hooks exclude src directories to avoid JavaScript conflicts
+        # Ensure hooks exclude src directories to avoid JavaScript conflicts and tests
         if hook["exclude"]:
+            # Add src exclusion if not present
             if "src/" not in hook["exclude"]:
                 hook["exclude"] = f"{hook['exclude']}|^src/"
         else:
-            hook["exclude"] = "^src/"
+            # If no exclusion, add both tests and src
+            if hook["id"] in (
+                "skylos",
+                "zuban",
+                "bandit",
+                "refurb",
+                "complexipy",
+                "pyright",
+            ):
+                hook["exclude"] = r"^tests/|^src/"
+            else:
+                hook["exclude"] = "^src/"
 
         return hook
 

crackerjack/interactive.py

@@ -24,7 +24,7 @@ class TaskStatus(Enum):
 
 
 @dataclass
-class WorkflowOptions:
+class InteractiveWorkflowOptions:
     clean: bool = False
     test: bool = False
     publish: str | None = None
@@ -35,7 +35,7 @@ class WorkflowOptions:
     dry_run: bool = False
 
     @classmethod
-    def from_args(cls, args: t.Any) -> "WorkflowOptions":
+    def from_args(cls, args: t.Any) -> "InteractiveWorkflowOptions":
         return cls(
             clean=getattr(args, "clean", False),
             test=getattr(args, "test", False),
@@ -399,7 +399,7 @@ class InteractiveCLI:
 
         self.logger = logging.getLogger("crackerjack.interactive.cli")
 
-    def create_dynamic_workflow(self, options: WorkflowOptions) -> None:
+    def create_dynamic_workflow(self, options: InteractiveWorkflowOptions) -> None:
         builder = WorkflowBuilder(self.console)
 
         workflow_steps = [
@@ -581,7 +581,7 @@ class InteractiveCLI:
             or last_task
         )
 
-    def run_interactive_workflow(self, options: WorkflowOptions) -> bool:
+    def run_interactive_workflow(self, options: InteractiveWorkflowOptions) -> bool:
         self.logger.info(
             f"Starting interactive workflow with options: {options.__dict__}",
         )
@@ -682,7 +682,9 @@ def launch_interactive_cli(version: str, options: t.Any = None) -> None:
     console.print()
 
     workflow_options = (
-        WorkflowOptions.from_args(options) if options else WorkflowOptions()
+        InteractiveWorkflowOptions.from_args(options)
+        if options
+        else InteractiveWorkflowOptions()
     )
     cli.create_dynamic_workflow(workflow_options)
     cli.run_interactive_workflow(workflow_options)

crackerjack/managers/publish_manager.py

@@ -156,7 +156,7 @@ class PublishManagerImpl:
             self.console.print(f"[red]❌[/ red] Version bump failed: {e}")
             raise
 
-    def _prompt_for_version_type(self, recommendation=None) -> str:
+    def _prompt_for_version_type(self, recommendation: t.Any = None) -> str:
         try:
             from rich.prompt import Prompt
 
@@ -178,7 +178,7 @@ class PublishManagerImpl:
             )
             return "patch"
 
-    def _get_version_recommendation(self):
+    def _get_version_recommendation(self) -> t.Any:
         """Get AI-powered version bump recommendation based on git history."""
         try:
             import asyncio
@@ -217,7 +217,7 @@ class PublishManagerImpl:
             self.console.print(f"[yellow]⚠️[/yellow] Version analysis failed: {e}")
             return None
 
-    def _display_version_analysis(self, recommendation):
+    def _display_version_analysis(self, recommendation: t.Any) -> None:
         """Display version analysis in a compact format."""
         if not recommendation:
             return

crackerjack/managers/test_manager.py

@@ -132,21 +132,54 @@ class TestManager:
         try:
             status = self.coverage_ratchet.get_status_report()
 
-            if status.get("status") == "not_initialized":
+            # Check if we have actual coverage data from coverage.json even if ratchet is not initialized
+            coverage_json_path = self.pkg_path / "coverage.json"
+            direct_coverage = None
+
+            if coverage_json_path.exists():
+                try:
+                    import json
+
+                    with coverage_json_path.open() as f:
+                        data = json.load(f)
+                        direct_coverage = data.get("totals", {}).get("percent_covered")
+                except (json.JSONDecodeError, KeyError):
+                    pass  # Fall back to ratchet data
+
+            # If ratchet is not initialized but we have direct coverage data, use it
+            if (
+                not status or status.get("status") == "not_initialized"
+            ) and direct_coverage is not None:
+                return {
+                    "status": "coverage_available",
+                    "coverage_percent": direct_coverage,
+                    "message": "Coverage data available from coverage.json",
+                    "source": "coverage.json",
+                }
+
+            # If ratchet is not initialized and no direct coverage, return not initialized
+            if not status or status.get("status") == "not_initialized":
                 return {
                     "status": "not_initialized",
                     "coverage_percent": 0.0,
                     "message": "Coverage ratchet not initialized",
                 }
 
+            # Use ratchet data, but prefer direct coverage if available and different
+            ratchet_coverage = status.get("current_coverage", 0.0)
+            final_coverage = (
+                direct_coverage if direct_coverage is not None else ratchet_coverage
+            )
+
             return {
                 "status": "active",
-                "coverage_percent": status.get("current_coverage", 0.0),
+                "coverage_percent": final_coverage,
                 "target_coverage": status.get("target_coverage", 100.0),
                 "next_milestone": status.get("next_milestone"),
                 "progress_percent": status.get("progress_percent", 0.0),
                 "last_updated": status.get("last_updated"),
                 "milestones_achieved": status.get("milestones_achieved", []),
+                "source": "coverage.json" if direct_coverage is not None else "ratchet",
             }
         except Exception as e:
             return {
@@ -235,25 +268,64 @@ class TestManager:
             current_coverage = None
             coverage_json_path = self.pkg_path / "coverage.json"
 
+            # Primary: Try to extract from coverage.json
             if coverage_json_path.exists():
-                with coverage_json_path.open() as f:
-                    data = json.load(f)
-                    current_coverage = data.get("totals", {}).get("percent_covered")
+                try:
+                    with coverage_json_path.open() as f:
+                        data = json.load(f)
+                        current_coverage = data.get("totals", {}).get("percent_covered")
+                        if current_coverage is not None:
+                            self.console.print(
+                                f"[dim]📊 Coverage extracted from coverage.json: {current_coverage:.2f}%[/dim]"
+                            )
+                except (json.JSONDecodeError, KeyError) as e:
+                    self.console.print(
+                        f"[yellow]⚠️[/yellow] Failed to parse coverage.json: {e}"
+                    )
 
-            # Fallback to ratchet result if coverage.json not available
+            # Secondary: Try ratchet result if coverage.json failed
             if current_coverage is None:
                 current_coverage = ratchet_result.get("current_coverage")
+                if current_coverage is not None:
+                    self.console.print(
+                        f"[dim]📊 Coverage from ratchet result: {current_coverage:.2f}%[/dim]"
+                    )
 
-            # Final fallback to coverage service
+            # Tertiary: Try coverage service, but only accept non-zero values
             if current_coverage is None:
                 coverage_info = self.get_coverage()
-                current_coverage = coverage_info.get("coverage_percent")
+                fallback_coverage = coverage_info.get("coverage_percent")
+                # Only use fallback if it's meaningful (>0) or if no coverage.json exists
+                if fallback_coverage and (
+                    fallback_coverage > 0 or not coverage_json_path.exists()
+                ):
+                    current_coverage = fallback_coverage
+                    self.console.print(
+                        f"[dim]📊 Coverage from service fallback: {current_coverage:.2f}%[/dim]"
+                    )
+                else:
+                    self.console.print(
+                        "[yellow]⚠️[/yellow] Skipping 0.0% fallback when coverage.json exists"
+                    )
 
-            if current_coverage is not None:
+            # Only update badge if we have valid coverage data
+            if current_coverage is not None and current_coverage >= 0:
                 if self._coverage_badge_service.should_update_badge(current_coverage):
                     self._coverage_badge_service.update_readme_coverage_badge(
                         current_coverage
                     )
+                    self.console.print(
+                        f"[green]✅[/green] Badge updated to {current_coverage:.2f}%"
+                    )
+                else:
+                    self.console.print(
+                        f"[dim]📊 Badge unchanged (current: {current_coverage:.2f}%)[/dim]"
+                    )
+            else:
+                self.console.print(
+                    "[yellow]⚠️[/yellow] No valid coverage data found for badge update"
+                )
+
         except Exception as e:
             # Don't fail the test process if badge update fails
             self.console.print(f"[yellow]⚠️[/yellow] Badge update failed: {e}")

crackerjack/mcp/file_monitor.py

@@ -5,10 +5,20 @@ import typing as t
 from collections.abc import Callable
 from pathlib import Path
 
+# Type aliases for watchdog types
+FileSystemEvent: t.Any
+FileSystemEventHandler: t.Any
+Observer: t.Any
+WATCHDOG_AVAILABLE: bool
+
 try:
-    from watchdog.events import FileSystemEvent, FileSystemEventHandler
-    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEvent as WatchdogFileSystemEvent
+    from watchdog.events import FileSystemEventHandler as WatchdogFileSystemEventHandler
+    from watchdog.observers import Observer as WatchdogObserver
 
+    FileSystemEvent = WatchdogFileSystemEvent
+    FileSystemEventHandler = WatchdogFileSystemEventHandler
+    Observer = WatchdogObserver
     WATCHDOG_AVAILABLE = True
 except ImportError:
     # Type stubs for when watchdog is not available

crackerjack/mcp/rate_limiter.py

@@ -35,14 +35,18 @@ class RateLimiter:
         self.requests_per_hour = requests_per_hour
 
         self.minute_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_minute),  # type: ignore[misc]
+            lambda: deque[float](maxlen=requests_per_minute),  # type: ignore[arg-type,misc]
         )
         self.hour_windows: dict[str, deque[float]] = defaultdict(
-            lambda: deque(maxlen=requests_per_hour),  # type: ignore[misc]
+            lambda: deque[float](maxlen=requests_per_hour),  # type: ignore[arg-type,misc]
         )
 
-        self.global_minute_window: deque[float] = deque(maxlen=requests_per_minute * 10)
-        self.global_hour_window: deque[float] = deque(maxlen=requests_per_hour * 10)
+        self.global_minute_window: deque[float] = deque[float](
+            maxlen=requests_per_minute * 10
+        )
+        self.global_hour_window: deque[float] = deque[float](
+            maxlen=requests_per_hour * 10
+        )
 
         self._lock = asyncio.Lock()
 
@@ -126,7 +130,7 @@ class RateLimiter:
         self._remove_expired_entries(self.global_minute_window, minute_cutoff)
         self._remove_expired_entries(self.global_hour_window, hour_cutoff)
 
-    def _remove_expired_entries(self, window: deque, cutoff: float) -> None:
+    def _remove_expired_entries(self, window: deque[float], cutoff: float) -> None:
         while window and window[0] < cutoff:
             window.popleft()
 

crackerjack/mcp/service_watchdog.py

@@ -3,6 +3,7 @@ import socket
 import subprocess
 import sys
 import time
+from contextlib import suppress
 from typing import Any
 
 import aiohttp
@@ -34,7 +35,7 @@ class ServiceConfig:
         self.max_restarts = max_restarts
         self.restart_window = restart_window
 
-        self.process: subprocess.Popen[bytes] | None = None
+        self.process: subprocess.Popen[str] | None = None
         self.restart_count = 0
         self.restart_timestamps: list[float] = []
         self.last_health_check = 0.0
@@ -125,7 +126,7 @@ class ServiceWatchdog:
         return False
 
     async def _launch_service_process(self, service: ServiceConfig) -> bool:
-        service.process = subprocess.Popen(
+        service.process = subprocess.Popen[str](
             service.command,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
@@ -137,6 +138,8 @@ class ServiceWatchdog:
         return await self._check_process_startup_success(service)
 
     async def _check_process_startup_success(self, service: ServiceConfig) -> bool:
+        if service.process is None:
+            return False
         exit_code = service.process.poll()
         if exit_code is not None:
             return await self._handle_process_died(service, exit_code)
@@ -147,6 +150,8 @@ class ServiceWatchdog:
         service: ServiceConfig,
         exit_code: int,
     ) -> bool:
+        if service.process is None:
+            return False
         stdout, stderr = service.process.communicate()
         error_msg = f"Process died (exit: {exit_code})"
         if stderr and stderr.strip():
@@ -441,8 +446,6 @@ class ServiceWatchdog:
         message: str,
     ) -> None:
         if self.event_queue:
-            from contextlib import suppress
-
             with suppress(Exception):
                 event = {
                     "type": event_type,

crackerjack/mcp/tools/intelligence_tools.py

@@ -147,7 +147,7 @@ async def get_smart_agent_recommendation(
             context=task_context,
         )
 
-        response = {
+        response: dict[str, t.Any] = {
             "task_description": task_description,
             "context_type": context_type,
         }

crackerjack/mcp/tools/proactive_tools.py

@@ -119,7 +119,7 @@ def _create_validation_results(file_path: str) -> dict[str, t.Any]:
 
 
 def _create_pattern_suggestions(problem_context: str) -> dict[str, t.Any]:
-    pattern_suggestions = {
+    pattern_suggestions: dict[str, t.Any] = {
         "context": problem_context,
         "recommended_patterns": [],
         "implementation_guidance": [],

crackerjack/orchestration/execution_strategies.py

@@ -262,10 +262,10 @@ class OrchestrationPlanner:
             hook_plans=hook_plans,
             test_plan=test_plan,
             ai_plan=ai_plan,
-            estimated_total_duration=sum(
-                int(plan["estimated_duration"]) for plan in hook_plans
+            estimated_total_duration=float(
+                sum(int(float(str(plan["estimated_duration"]))) for plan in hook_plans)
             )
-            + test_plan["estimated_duration"],
+            + float(test_plan["estimated_duration"]),
         )
 
     def _estimate_strategy_duration(self, strategy: HookStrategy) -> float:

crackerjack/plugins/hooks.py

@@ -131,9 +131,10 @@ class CustomHookPlugin(HookPluginBase):
         try:
             if hook_def.command is None:
                 return HookResult(
+                    id=f"hook_{hook_def.name}",
                     name=hook_def.name,
                     status="failed",
-                    message="Hook command is None",
+                    issues_found=["Hook command is None"],
                     duration=0.0,
                 )
             cmd = hook_def.command.copy()