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

crackerjack/executors/tool_proxy.py

@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+"""Tool proxy that routes tool calls through adapters with health checks and graceful degradation."""
+
+import asyncio
+import sys
+import time
+import typing as t
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from rich.console import Console
+
+
+@dataclass
+class ToolHealthStatus:
+    """Health status of a tool."""
+
+    is_healthy: bool
+    last_check: float
+    consecutive_failures: int = 0
+    last_error: str | None = None
+    fallback_recommendations: list[str] = field(default_factory=list)
+
+
+@dataclass
+class CircuitBreakerState:
+    """Circuit breaker state for a tool."""
+
+    is_open: bool = False
+    failure_count: int = 0
+    last_failure_time: float = 0
+    next_retry_time: float = 0
+
+    # Circuit breaker thresholds
+    failure_threshold: int = 3
+    retry_timeout: float = 120  # 2 minutes
+
+    def should_attempt(self) -> bool:
+        """Check if we should attempt to use this tool."""
+        if not self.is_open:
+            return True
+
+        # Allow retry after timeout
+        return time.time() >= self.next_retry_time
+
+    def record_failure(self) -> None:
+        """Record a tool failure."""
+        self.failure_count += 1
+        self.last_failure_time = time.time()
+
+        if self.failure_count >= self.failure_threshold:
+            self.is_open = True
+            self.next_retry_time = time.time() + self.retry_timeout
+
+    def record_success(self) -> None:
+        """Record a tool success."""
+        self.failure_count = 0
+        self.is_open = False
+        self.next_retry_time = 0
+
+
+class ToolProxy:
+    """Proxy that routes tool calls through adapters with health checks."""
+
+    def __init__(self, console: Console | None = None):
+        self.console = console or Console()
+        self.health_status: dict[str, ToolHealthStatus] = {}
+        self.circuit_breakers: dict[str, CircuitBreakerState] = {}
+
+        # Tool mappings to adapters
+        self.tool_adapters = {
+            "zuban": self._create_zuban_adapter,
+            "skylos": self._create_skylos_adapter,
+            "ruff": self._create_ruff_adapter,
+            "bandit": self._create_bandit_adapter,
+        }
+
+        # Fallback recommendations
+        self.fallback_tools = {
+            "zuban": ["pyright", "mypy"],
+            "skylos": ["vulture"],
+            "ruff": [],  # Ruff is usually reliable
+            "bandit": [],  # Skip security checks if bandit fails
+        }
+
+    def execute_tool(self, tool_name: str, args: list[str]) -> int:
+        """Execute a tool through its adapter with health checks.
+
+        Args:
+            tool_name: Name of the tool to execute
+            args: Arguments to pass to the tool
+
+        Returns:
+            Exit code (0 for success, non-zero for failure)
+        """
+        try:
+            # Check circuit breaker
+            circuit_breaker = self._get_circuit_breaker(tool_name)
+
+            if not circuit_breaker.should_attempt():
+                self._handle_circuit_breaker_open(tool_name)
+                return self._try_fallback_tools(tool_name, args)
+
+            # Check tool health
+            if not self._check_tool_health(tool_name):
+                self._handle_unhealthy_tool(tool_name)
+                circuit_breaker.record_failure()
+                return self._try_fallback_tools(tool_name, args)
+
+            # Execute through adapter
+            result = self._execute_through_adapter(tool_name, args)
+
+            if result == 0:
+                circuit_breaker.record_success()
+            else:
+                circuit_breaker.record_failure()
+
+            return result
+
+        except Exception as e:
+            self.console.print(f"[red]Tool proxy error for {tool_name}: {e}[/red]")
+            self._get_circuit_breaker(tool_name).record_failure()
+            return self._try_fallback_tools(tool_name, args)
+
+    def _get_circuit_breaker(self, tool_name: str) -> CircuitBreakerState:
+        """Get or create circuit breaker for tool."""
+        if tool_name not in self.circuit_breakers:
+            self.circuit_breakers[tool_name] = CircuitBreakerState()
+        return self.circuit_breakers[tool_name]
+
+    def _check_tool_health(self, tool_name: str) -> bool:
+        """Check if a tool is healthy."""
+        current_time = time.time()
+
+        # Use cached health status if recent (within 30 seconds)
+        if tool_name in self.health_status:
+            status = self.health_status[tool_name]
+            if current_time - status.last_check < 30:
+                return status.is_healthy
+
+        # Perform actual health check
+        is_healthy = self._perform_health_check(tool_name)
+
+        self.health_status[tool_name] = ToolHealthStatus(
+            is_healthy=is_healthy,
+            last_check=current_time,
+            fallback_recommendations=list(self.fallback_tools.get(tool_name, [])),
+        )
+
+        return is_healthy
+
+    def _perform_health_check(self, tool_name: str) -> bool:
+        """Perform actual health check for a tool."""
+        try:
+            if tool_name in self.tool_adapters:
+                # Use adapter health check if available
+                adapter = self.tool_adapters[tool_name]()
+                if adapter and hasattr(adapter, "check_tool_health"):
+                    return bool(adapter.check_tool_health())
+
+            # Tool-specific health checks for known problematic tools
+            if tool_name == "zuban":
+                return self._check_zuban_health()
+            elif tool_name == "skylos":
+                return self._check_skylos_health()
+
+            # Fallback to basic version check
+            import subprocess
+
+            result = subprocess.run(
+                ["uv", "run", tool_name, "--version"],
+                capture_output=True,
+                timeout=10,
+                text=True,
+            )
+            return result.returncode == 0
+
+        except Exception:
+            return False
+
+    def _check_zuban_health(self) -> bool:
+        """Specific health check for Zuban that tests TOML parsing."""
+        import subprocess
+        import tempfile
+
+        try:
+            # Test basic version first
+            result = subprocess.run(
+                ["uv", "run", "zuban", "--version"],
+                capture_output=True,
+                timeout=10,
+                text=True,
+            )
+            if result.returncode != 0:
+                return False
+
+            # Test actual type checking on a minimal file - this triggers TOML parsing
+            with tempfile.TemporaryDirectory() as temp_dir:
+                temp_file = Path(temp_dir) / "test.py"
+                temp_file.write_text("x: int = 1\n")
+
+                # This should trigger the TOML parsing bug if it exists
+                result = subprocess.run(
+                    ["uv", "run", "zuban", "check", str(temp_file)],
+                    capture_output=True,
+                    timeout=5,  # Short timeout to catch panics
+                    text=True,
+                    cwd=Path.cwd(),  # Run from our directory with problematic pyproject.toml
+                )
+
+                # If it exits cleanly (regardless of type errors), tool is healthy
+                # The key is that it doesn't panic with TOML parsing errors
+                return result.returncode in (0, 1)  # 0=no errors, 1=type errors found
+
+        except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+            # Tool timed out or crashed - likely the TOML parsing bug
+            return False
+        except Exception:
+            return False
+
+    def _check_skylos_health(self) -> bool:
+        """Specific health check for Skylos."""
+        import subprocess
+
+        try:
+            result = subprocess.run(
+                ["uv", "run", "skylos", "--version"],
+                capture_output=True,
+                timeout=10,
+                text=True,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def _execute_through_adapter(self, tool_name: str, args: list[str]) -> int:
+        """Execute tool through its adapter if available."""
+        if tool_name in self.tool_adapters:
+            try:
+                # Use async adapter if available
+                return asyncio.run(self._execute_adapter_async(tool_name, args))
+            except Exception as e:
+                self.console.print(
+                    f"[yellow]Adapter execution failed for {tool_name}: {e}[/yellow]"
+                )
+                # Fall back to direct execution
+                pass
+
+        # Direct execution as fallback
+        return self._execute_direct(tool_name, args)
+
+    async def _execute_adapter_async(self, tool_name: str, args: list[str]) -> int:
+        """Execute tool through async adapter."""
+        adapter_factory = self.tool_adapters[tool_name]
+        adapter = adapter_factory()
+
+        # Convert args to file paths for adapter
+        target_files = self._args_to_file_paths(args)
+
+        if hasattr(adapter, "check_with_lsp_or_fallback"):
+            result = await adapter.check_with_lsp_or_fallback(target_files)
+            return 0 if result.success else 1
+
+        return self._execute_direct(tool_name, args)
+
+    def _execute_direct(self, tool_name: str, args: list[str]) -> int:
+        """Execute tool directly without adapter."""
+        import subprocess
+
+        try:
+            cmd = ["uv", "run", tool_name] + args
+            result = subprocess.run(cmd, timeout=300)
+            return result.returncode
+
+        except subprocess.TimeoutExpired:
+            self.console.print(f"[red]Tool {tool_name} timed out[/red]")
+            return 1
+        except Exception as e:
+            self.console.print(
+                f"[red]Direct execution failed for {tool_name}: {e}[/red]"
+            )
+            return 1
+
+    def _args_to_file_paths(self, args: list[str]) -> list[Path]:
+        """Convert command line arguments to file paths."""
+        file_paths = [
+            Path(arg) for arg in args if not arg.startswith("-") and Path(arg).exists()
+        ]
+
+        # Default to current directory if no files specified
+        if not file_paths:
+            file_paths = [Path()]
+
+        return file_paths
+
+    def _try_fallback_tools(self, tool_name: str, args: list[str]) -> int:
+        """Try fallback tools when primary tool fails."""
+        fallbacks = self.fallback_tools.get(tool_name, [])
+
+        if not fallbacks:
+            self.console.print(
+                f"[yellow]No fallback available for {tool_name}. Skipping with warning.[/yellow]"
+            )
+            return 0  # Skip with success to not block workflow
+
+        self.console.print(
+            f"[yellow]Trying fallback tools for {tool_name}: {', '.join(fallbacks)}[/yellow]"
+        )
+
+        for fallback in fallbacks:
+            try:
+                # Check if fallback is healthy
+                if self._check_tool_health(fallback):
+                    result = self._execute_direct(fallback, args)
+                    if result == 0:
+                        self.console.print(
+                            f"[green]Fallback {fallback} succeeded[/green]"
+                        )
+                        return 0
+            except Exception:
+                continue
+
+        self.console.print(
+            f"[yellow]All fallbacks failed for {tool_name}. Continuing...[/yellow]"
+        )
+        return 0  # Don't block workflow on tool failures
+
+    def _handle_circuit_breaker_open(self, tool_name: str) -> None:
+        """Handle when circuit breaker is open."""
+        circuit_breaker = self.circuit_breakers[tool_name]
+        retry_minutes = int((circuit_breaker.next_retry_time - time.time()) / 60)
+
+        self.console.print(
+            f"[yellow]Circuit breaker open for {tool_name}. "
+            f"Will retry in {retry_minutes} minutes.[/yellow]"
+        )
+
+    def _handle_unhealthy_tool(self, tool_name: str) -> None:
+        """Handle when tool is detected as unhealthy."""
+        self.console.print(
+            f"[yellow]Tool {tool_name} is unhealthy. Trying fallbacks...[/yellow]"
+        )
+
+    def _create_zuban_adapter(self) -> t.Any | None:
+        """Create Zuban adapter instance."""
+        try:
+            from crackerjack.adapters.zuban_adapter import ZubanAdapter
+            from crackerjack.models.config import Options
+            from crackerjack.orchestration.execution_strategies import ExecutionContext
+
+            # Create minimal context for adapter
+            options = Options()
+            context = ExecutionContext(pkg_path=Path.cwd(), options=options)
+            return ZubanAdapter(context)
+        except (ImportError, Exception):
+            return None
+
+    def _create_skylos_adapter(self) -> t.Any | None:
+        """Create Skylos adapter instance."""
+        try:
+            from crackerjack.adapters.skylos_adapter import SkylosAdapter
+            from crackerjack.models.config import Options
+            from crackerjack.orchestration.execution_strategies import ExecutionContext
+
+            options = Options()
+            context = ExecutionContext(pkg_path=Path.cwd(), options=options)
+            return SkylosAdapter(context)
+        except (ImportError, Exception):
+            return None
+
+    def _create_ruff_adapter(self) -> t.Any | None:
+        """Create Ruff adapter instance."""
+        # Ruff doesn't have an adapter yet, return None for direct execution
+        return None
+
+    def _create_bandit_adapter(self) -> t.Any | None:
+        """Create Bandit adapter instance."""
+        # Bandit doesn't have an adapter yet, return None for direct execution
+        return None
+
+    def get_tool_status(self) -> dict[str, dict[str, t.Any]]:
+        """Get status of all tools for monitoring."""
+        status = {}
+
+        for tool_name in self.tool_adapters.keys():
+            circuit_breaker = self._get_circuit_breaker(tool_name)
+            health_status = self.health_status.get(tool_name)
+
+            status[tool_name] = {
+                "circuit_breaker_open": circuit_breaker.is_open,
+                "failure_count": circuit_breaker.failure_count,
+                "is_healthy": health_status.is_healthy if health_status else None,
+                "last_health_check": health_status.last_check
+                if health_status
+                else None,
+                "fallback_tools": self.fallback_tools.get(tool_name, []),
+            }
+
+        return status
+
+
+def main() -> None:
+    """Main entry point for tool proxy CLI."""
+    if len(sys.argv) < 2:
+        print("Usage: python -m crackerjack.executors.tool_proxy <tool_name> [args...]")
+        sys.exit(1)
+
+    tool_name = sys.argv[1]
+    args = sys.argv[2:]
+
+    proxy = ToolProxy()
+    exit_code = proxy.execute_tool(tool_name, args)
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()

crackerjack/hooks/lsp_hook.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""
+LSP-aware type checking hook for crackerjack.
+
+This hook communicates with a running Zuban LSP server to perform type checking
+instead of spawning a separate zuban process, providing faster and more efficient
+type checking during pre-commit hooks.
+"""
+
+import sys
+from pathlib import Path
+
+from crackerjack.services.lsp_client import LSPClient
+from rich.console import Console
+
+
+def main() -> int:
+    """Main entry point for LSP hook."""
+    console = Console()
+
+    # Get files to check from command line arguments
+    files_to_check = sys.argv[1:] if len(sys.argv) > 1 else []
+
+    # If no files specified, check project files
+    if not files_to_check:
+        project_path = Path.cwd()
+        lsp_client = LSPClient(console)
+        files_to_check = lsp_client.get_project_files(project_path)
+
+    if not files_to_check:
+        console.print("🔍 No Python files to check")
+        return 0
+
+    # Initialize LSP client
+    lsp_client = LSPClient(console)
+
+    # Check if LSP server is running
+    if not lsp_client.is_server_running():
+        console.print(
+            "⚠️  Zuban LSP server not running, falling back to direct zuban check"
+        )
+        # Fall back to regular zuban execution
+        import subprocess
+
+        try:
+            result = subprocess.run(
+                ["zuban", "check"] + files_to_check,
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if result.stdout:
+                console.print(result.stdout)
+            if result.stderr:
+                console.print(result.stderr, style="red")
+            return result.returncode
+        except (subprocess.TimeoutExpired, FileNotFoundError) as e:
+            console.print(f"❌ Error running zuban: {e}", style="red")
+            return 1
+
+    # Use LSP server for type checking
+    server_info = lsp_client.get_server_info()
+    if server_info:
+        console.print(f"🔍 Using Zuban LSP server (PID: {server_info['pid']})")
+
+    # Check files via LSP
+    diagnostics = lsp_client.check_files(files_to_check)
+
+    # Display results
+    output = lsp_client.format_diagnostics(diagnostics)
+    console.print(output)
+
+    # Return appropriate exit code
+    has_errors = any(diags for diags in diagnostics.values())
+    return 1 if has_errors else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

crackerjack/intelligence/adaptive_learning.py

@@ -34,7 +34,7 @@ class AgentPerformanceMetrics:
     average_execution_time: float = 0.0
     average_confidence: float = 0.0
     success_rate: float = 0.0
-    capability_success_rates: dict[str, float] = field(default_factory=dict)
+    capability_success_rates: dict[str, float] = field(default_factory=dict[str, t.Any])
     recent_performance_trend: float = 0.0
     last_updated: datetime = field(default_factory=datetime.now)
 
@@ -357,7 +357,12 @@ class AdaptiveLearningSystem:
         return insights
 
     def _group_capability_performance(self) -> dict[str, dict[str, list[bool]]]:
-        capability_performance = defaultdict(lambda: defaultdict(list))
+        def make_inner_defaultdict() -> defaultdict[str, list[bool]]:
+            return defaultdict(list)
+
+        capability_performance: dict[str, dict[str, list[bool]]] = defaultdict(
+            make_inner_defaultdict
+        )
 
         for record in self._execution_records[-100:]:
             for capability in record.task_capabilities:
@@ -365,7 +370,7 @@ class AdaptiveLearningSystem:
                     record.success
                 )
 
-        return dict(capability_performance)
+        return dict[str, t.Any](capability_performance)
 
     def _find_capability_experts(
         self, capability: str, agents: dict[str, list[bool]]
@@ -398,7 +403,12 @@ class AdaptiveLearningSystem:
         return self._extract_significant_failure_insights(failure_patterns)
 
     def _group_failure_patterns(self) -> dict[str, dict[str, int]]:
-        failure_patterns = defaultdict(lambda: defaultdict(int))
+        def make_inner_defaultdict() -> defaultdict[str, int]:
+            return defaultdict(int)
+
+        failure_patterns: dict[str, dict[str, int]] = defaultdict(
+            make_inner_defaultdict
+        )
 
         for record in self._execution_records[-100:]:
             if not record.success and record.error_message:
@@ -406,7 +416,7 @@ class AdaptiveLearningSystem:
                 failure_patterns[record.agent_name][error_type] += 1
 
         return {
-            agent_name: dict(patterns)
+            agent_name: dict[str, t.Any](patterns)
             for agent_name, patterns in failure_patterns.items()
         }
 
@@ -471,7 +481,12 @@ class AdaptiveLearningSystem:
         return insights
 
     def _group_task_performance(self) -> dict[str, dict[str, list[bool]]]:
-        task_performance = defaultdict(lambda: defaultdict(list))
+        def make_inner_defaultdict() -> defaultdict[str, list[bool]]:
+            return defaultdict(list)
+
+        task_performance: dict[str, dict[str, list[bool]]] = defaultdict(
+            make_inner_defaultdict
+        )
 
         for record in self._execution_records[-100:]:
             if record.task_hash:
@@ -479,7 +494,7 @@ class AdaptiveLearningSystem:
                     record.success
                 )
 
-        return dict(task_performance)
+        return dict[str, t.Any](task_performance)
 
     def _find_best_performing_agent(
         self, agents: dict[str, list[bool]]
@@ -521,7 +536,7 @@ class AdaptiveLearningSystem:
                 "task_pattern": task_hash,
                 "success_rate": best_rate,
                 "example_task": example_task,
-                "competing_agents": list(agents.keys()),
+                "competing_agents": list[t.Any](agents.keys()),
             },
         )
 
@@ -647,7 +662,7 @@ class AdaptiveLearningSystem:
                 "trend": metrics.recent_performance_trend,
             }
 
-        insights_by_type = defaultdict(int)
+        insights_by_type: dict[str, int] = defaultdict(int)
         for insight in self._learning_insights:
             insights_by_type[insight.insight_type] += 1
 
@@ -657,7 +672,7 @@ class AdaptiveLearningSystem:
             "recent_success_rate": recent_success_rate,
             "agents_tracked": len(self._agent_metrics),
             "insights_discovered": len(self._learning_insights),
-            "insights_by_type": dict(insights_by_type),
+            "insights_by_type": dict[str, t.Any](insights_by_type),
             "top_performers": sorted(
                 agent_summary.items(),
                 key=lambda x: x[1]["success_rate"],

crackerjack/intelligence/agent_orchestrator.py

@@ -90,8 +90,6 @@ class AgentOrchestrator:
                 result = await self._execute_sequential(request, candidates)
             elif request.strategy == ExecutionStrategy.CONSENSUS:
                 result = await self._execute_consensus(request, candidates)
-            else:
-                result = await self._execute_single_best(request, candidates)
 
             execution_time = asyncio.get_event_loop().time() - start_time
             result.execution_time = execution_time
@@ -243,7 +241,6 @@ class AgentOrchestrator:
                 self.logger.warning(
                     f"Sequential agent {candidate.agent.metadata.name} failed: {e}"
                 )
-                continue
 
         return ExecutionResult(
             success=False,
@@ -368,7 +365,7 @@ class AgentOrchestrator:
 
         return result
 
-    def _map_task_to_issue_type(self, task: TaskDescription):
+    def _map_task_to_issue_type(self, task: TaskDescription) -> t.Any:
         from crackerjack.agents.base import IssueType
 
         context_map = {
@@ -395,7 +392,7 @@ class AgentOrchestrator:
 
         return IssueType.FORMATTING
 
-    def _map_task_priority_to_severity(self, task: TaskDescription):
+    def _map_task_priority_to_severity(self, task: TaskDescription) -> t.Any:
         from crackerjack.agents.base import Priority
 
         if task.priority >= 80: