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

crackerjack/managers/test_manager_backup.py

@@ -172,7 +172,7 @@ class TestManagementImpl:
             self.console.print("[yellow]⚠️[/ yellow] Coverage ratchet disabled")
 
     def get_coverage_ratchet_status(self) -> dict[str, t.Any]:
-        return self.coverage_ratchet.get_status_report()
+        return self.coverage_ratchet.get_ratchet_data()
 
     def _run_test_command(
         self,
@@ -482,9 +482,8 @@ class TestManagementImpl:
         self._handle_running_test(line, progress)
 
     def _handle_collection_completion(self, line: str, progress: TestProgress) -> bool:
-        if match := re.search(
-            r"collected (\d +) items?", line
-        ):  # REGEX OK: parsing pytest collection output
+        match = re.search(r"collected (\d+) items?", line)
+        if match:
             progress.update(
                 total_tests=int(match.group(1)),
                 is_collecting=False,
@@ -728,7 +727,7 @@ class TestManagementImpl:
         import os
 
         cpu_count = os.cpu_count() or 1
-        test_files = list(self.pkg_path.glob("tests/test_*.py"))
+        test_files = list[t.Any](self.pkg_path.glob("tests/test_*.py"))
         if len(test_files) < 5:
             return min(2, cpu_count)
 
@@ -737,7 +736,7 @@ class TestManagementImpl:
     def _get_test_timeout(self, options: OptionsProtocol) -> int:
         if options.test_timeout > 0:
             return options.test_timeout
-        test_files = list(self.pkg_path.glob("tests/test_*.py"))
+        test_files = list[t.Any](self.pkg_path.glob("tests/test_*.py"))
         base_timeout = 300
 
         import math
@@ -1020,7 +1019,9 @@ class TestManagementImpl:
         test_dir = self.pkg_path / "tests"
         if not test_dir.exists():
             issues.append("tests directory not found")
-        test_files = list(test_dir.glob("test_ *.py")) if test_dir.exists() else []
+        test_files = (
+            list[t.Any](test_dir.glob("test_ *.py")) if test_dir.exists() else []
+        )
         if not test_files:
             issues.append("no test files found")
         if issues:
@@ -1035,7 +1036,7 @@ class TestManagementImpl:
         test_dir = self.pkg_path / "tests"
         if not test_dir.exists():
             return {"test_files": 0, "total_tests": 0, "test_lines": 0}
-        test_files = list(test_dir.glob("test_ *.py"))
+        test_files = list[t.Any](test_dir.glob("test_ *.py"))
         total_lines = 0
         total_tests = 0
         for test_file in test_files:
@@ -1070,5 +1071,5 @@ class TestManagementImpl:
             return None
 
     def has_tests(self) -> bool:
-        test_files = list(self.pkg_path.glob("tests/test_*.py"))
+        test_files = list[t.Any](self.pkg_path.glob("tests/test_*.py"))
         return len(test_files) > 0

crackerjack/mcp/cache.py

@@ -97,7 +97,7 @@ class ErrorCache:
         ]
 
     def get_common_patterns(self, limit: int = 20) -> list[ErrorPattern]:
-        patterns = list(self.patterns.values())
+        patterns = list[t.Any](self.patterns.values())
         patterns.sort(key=lambda p: p.frequency, reverse=True)
         return patterns[:limit]
 
@@ -252,7 +252,7 @@ class ErrorCache:
         successful_fixes = sum(1 for result in self.fix_results if result.success)
         frequencies = [pattern.frequency for pattern in self.patterns.values()]
         avg_frequency = sum(frequencies) / len(frequencies) if frequencies else 0
-        type_counts = {}
+        type_counts: dict[str, int] = {}
         for pattern in self.patterns.values():
             type_counts[pattern.error_type] = type_counts.get(pattern.error_type, 0) + 1
 

crackerjack/mcp/client_runner.py

@@ -22,7 +22,7 @@ def is_mcp_server_running(host: str = "localhost", port: int = 5173) -> bool:
         sock.close()
 
 
-async def ensure_mcp_server_running() -> subprocess.Popen | None:
+async def ensure_mcp_server_running() -> subprocess.Popen[bytes] | None:
     console = Console()
 
     if is_mcp_server_running():

crackerjack/mcp/context.py

@@ -33,7 +33,7 @@ class BatchedStateSaver:
         self._pending_saves: dict[str, t.Callable[[], None]] = {}
         self._last_save_time: dict[str, float] = {}
 
-        self._save_task: asyncio.Task | None = None
+        self._save_task: asyncio.Task[None] | None = None
         self._running = False
         self._lock = asyncio.Lock()
 
@@ -85,7 +85,7 @@ class BatchedStateSaver:
         ready_saves = []
 
         async with self._lock:
-            for save_id, last_time in list(self._last_save_time.items()):
+            for save_id, last_time in list[t.Any](self._last_save_time.items()):
                 if now - last_time >= self.debounce_delay:
                     ready_saves.append(save_id)
 
@@ -106,7 +106,7 @@ class BatchedStateSaver:
 
     async def _flush_saves(self) -> None:
         async with self._lock:
-            save_ids = list(self._pending_saves.keys())
+            save_ids = list[t.Any](self._pending_saves.keys())
 
         if save_ids:
             await self._execute_saves(save_ids)
@@ -130,7 +130,6 @@ class MCPServerConfig:
     cache_dir: Path | None = None
 
     def __post_init__(self) -> None:
-        # Validate all paths using secure path validation
         self.project_path = SecurePathValidator.validate_safe_path(self.project_path)
 
         if self.progress_dir:
@@ -149,13 +148,12 @@ class MCPServerContext:
     def __init__(self, config: MCPServerConfig) -> None:
         self.config = config
 
-        # Resource management
         self.resource_manager = ResourceManager()
         self.network_manager = NetworkResourceManager()
         register_global_resource_manager(self.resource_manager)
 
         self.console: Console | None = None
-        self.cli_runner = None
+        self.cli_runner: WorkflowOrchestrator | None = None
         self.state_manager: StateManager | None = None
         self.error_cache: ErrorCache | None = None
         self.rate_limiter: RateLimitMiddleware | None = None
@@ -174,61 +172,172 @@ class MCPServerContext:
         )
         self._websocket_process_lock = asyncio.Lock()
         self._websocket_cleanup_registered = False
-        self._websocket_health_check_task: asyncio.Task | None = None
+        self._websocket_health_check_task: asyncio.Task[None] | None = None
 
         self._initialized = False
         self._startup_tasks: list[t.Callable[[], t.Awaitable[None]]] = []
         self._shutdown_tasks: list[t.Callable[[], t.Awaitable[None]]] = []
 
-    async def initialize(self) -> None:
-        if self._initialized:
-            return
-
+    async def _auto_setup_git_working_directory(self) -> None:
+        """Auto-detect and setup git working directory for enhanced DX."""
         try:
-            if self.config.stdio_mode:
-                null_file = io.StringIO()
-                self.console = Console(file=null_file, force_terminal=False)
-            else:
-                self.console = Console(force_terminal=True)
+            git_root = await self._detect_git_repository()
+            if git_root:
+                await self._log_git_detection(git_root)
 
-            self.progress_dir.mkdir(exist_ok=True)
+        except Exception as e:
+            self._handle_git_setup_failure(e)
 
-            self.cli_runner = WorkflowOrchestrator(
-                console=self.console,
-                pkg_path=self.config.project_path,
-            )
+    async def _detect_git_repository(self) -> Path | None:
+        """Detect if we're in a git repository and return the root path."""
 
-            self.state_manager = StateManager(
-                self.config.state_dir or Path.home() / ".cache" / "crackerjack-mcp",
-                self.batched_saver,
-            )
+        current_dir = Path.cwd()
 
-            self.error_cache = ErrorCache(
-                self.config.cache_dir or Path.home() / ".cache" / "crackerjack-mcp",
-            )
+        # Check if we're in a git repository
+        if not self._is_git_repository(current_dir):
+            return None
 
-            self.rate_limiter = RateLimitMiddleware(self.config.rate_limit_config)
+        return self._get_git_root_directory(current_dir)
 
-            await self.batched_saver.start()
+    def _is_git_repository(self, current_dir: Path) -> bool:
+        """Check if the current directory is within a git repository."""
+        import subprocess
 
-            for task in self._startup_tasks:
-                await task()
+        git_check = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True,
+            text=True,
+            cwd=current_dir,
+        )
+        return git_check.returncode == 0
+
+    def _get_git_root_directory(self, current_dir: Path) -> Path | None:
+        """Get the git repository root directory."""
+        import subprocess
+
+        git_root_result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            cwd=current_dir,
+        )
+
+        if git_root_result.returncode == 0:
+            git_root = Path(git_root_result.stdout.strip())
+            return git_root if git_root.exists() else None
+        return None
+
+    async def _log_git_detection(self, git_root: Path) -> None:
+        """Log git repository detection to stderr and console."""
+
+        # Log to stderr for Claude to see
+        self._log_to_stderr(git_root)
+
+        # Log to console if available
+        self._log_to_console(git_root)
+
+    def _log_to_stderr(self, git_root: Path) -> None:
+        """Log git detection messages to stderr."""
+        import sys
+
+        print(
+            f"📍 Crackerjack MCP: Git repository detected at {git_root}",
+            file=sys.stderr,
+        )
+        print(
+            f"💡 Tip: Auto-setup git working directory with: git_set_working_dir('{git_root}')",
+            file=sys.stderr,
+        )
+
+    def _log_to_console(self, git_root: Path) -> None:
+        """Log git detection messages to console if available."""
+        if self.console:
+            self.console.print(f"🔧 Auto-detected git repository: {git_root}")
+            self.console.print(
+                f"💡 Recommend: Use `mcp__git__git_set_working_dir` with path='{git_root}'"
+            )
+
+    def _handle_git_setup_failure(self, error: Exception) -> None:
+        """Handle git setup failure with graceful fallback."""
+        if self.console:
+            self.console.print(
+                f"[dim]Git auto-setup failed (non-critical): {error}[/dim]"
+            )
+
+    async def initialize(self) -> None:
+        if self._initialized:
+            return
 
+        try:
+            await self._perform_initialization_sequence()
             self._initialized = True
 
         except Exception as e:
-            self.cli_runner = None
-            self.state_manager = None
-            self.error_cache = None
-            self.rate_limiter = None
-            msg = f"Failed to initialize MCP server context: {e}"
-            raise RuntimeError(msg) from e
+            self._handle_initialization_failure(e)
+
+    async def _perform_initialization_sequence(self) -> None:
+        """Perform the complete initialization sequence."""
+        self._setup_console()
+        self._setup_directories()
+        await self._initialize_components()
+        await self._finalize_initialization()
+
+    def _handle_initialization_failure(self, error: Exception) -> None:
+        """Handle initialization failure with cleanup and error propagation."""
+        self._cleanup_failed_initialization()
+        msg = f"Failed to initialize MCP server context: {error}"
+        raise RuntimeError(msg) from error
+
+    def _setup_console(self) -> None:
+        """Setup console based on configuration mode."""
+        if self.config.stdio_mode:
+            null_file = io.StringIO()
+            self.console = Console(file=null_file, force_terminal=False)
+        else:
+            self.console = Console(force_terminal=True)
+
+    def _setup_directories(self) -> None:
+        """Setup required directories."""
+        self.progress_dir.mkdir(exist_ok=True)
+
+    async def _initialize_components(self) -> None:
+        """Initialize all service components."""
+        self.cli_runner = WorkflowOrchestrator(
+            console=self.console,
+            pkg_path=self.config.project_path,
+        )
+
+        self.state_manager = StateManager(
+            self.config.state_dir or Path.home() / ".cache" / "crackerjack-mcp",
+            self.batched_saver,
+        )
+
+        self.error_cache = ErrorCache(
+            self.config.cache_dir or Path.home() / ".cache" / "crackerjack-mcp",
+        )
+
+        self.rate_limiter = RateLimitMiddleware(self.config.rate_limit_config)
+        await self.batched_saver.start()
+
+    async def _finalize_initialization(self) -> None:
+        """Complete initialization with optional setup and startup tasks."""
+        # Auto-setup git working directory for enhanced DX
+        await self._auto_setup_git_working_directory()
+
+        for task in self._startup_tasks:
+            await task()
+
+    def _cleanup_failed_initialization(self) -> None:
+        """Cleanup components after failed initialization."""
+        self.cli_runner = None
+        self.state_manager = None
+        self.error_cache = None
+        self.rate_limiter = None
 
     async def shutdown(self) -> None:
         if not self._initialized:
             return
 
-        # Run custom shutdown tasks first
         for task in reversed(self._shutdown_tasks):
             try:
                 await task()
@@ -236,24 +345,19 @@ class MCPServerContext:
                 if self.console:
                     self.console.print(f"[red]Error during shutdown: {e}[/red]")
 
-        # Cancel health check task
         if self._websocket_health_check_task:
             self._websocket_health_check_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await self._websocket_health_check_task
             self._websocket_health_check_task = None
 
-        # Stop WebSocket server
         await self._stop_websocket_server()
 
-        # Stop rate limiter
         if self.rate_limiter:
             await self.rate_limiter.stop()
 
-        # Stop batched saver
         await self.batched_saver.stop()
 
-        # Clean up all managed resources
         try:
             await self.network_manager.cleanup_all()
         except Exception as e:
@@ -314,21 +418,31 @@ class MCPServerContext:
             if await self._check_existing_websocket_server():
                 return True
 
-            if self.console:
-                self.console.print(
-                    f"🚀 Starting WebSocket server on localhost: {self.websocket_server_port}...",
-                )
+            self._print_websocket_startup_message()
+            return await self._attempt_websocket_startup()
 
-            try:
-                await self._spawn_websocket_process()
-                await self._register_websocket_cleanup()
-                return await self._wait_for_websocket_startup()
+    def _print_websocket_startup_message(self) -> None:
+        """Print websocket server startup message."""
+        if self.console:
+            self.console.print(
+                f"🚀 Starting WebSocket server on localhost: {self.websocket_server_port}...",
+            )
 
-            except Exception as e:
-                if self.console:
-                    self.console.print(f"❌ Failed to start WebSocket server: {e}")
-                await self._cleanup_dead_websocket_process()
-                return False
+    async def _attempt_websocket_startup(self) -> bool:
+        """Attempt to start the websocket server with error handling."""
+        try:
+            await self._spawn_websocket_process()
+            await self._register_websocket_cleanup()
+            return await self._wait_for_websocket_startup()
+        except Exception as e:
+            await self._handle_websocket_startup_failure(e)
+            return False
+
+    async def _handle_websocket_startup_failure(self, error: Exception) -> None:
+        """Handle websocket server startup failure."""
+        if self.console:
+            self.console.print(f"❌ Failed to start WebSocket server: {error}")
+        await self._cleanup_dead_websocket_process()
 
     async def _check_existing_websocket_server(self) -> bool:
         if (
@@ -369,7 +483,6 @@ class MCPServerContext:
             start_new_session=True,
         )
 
-        # Register the process with the network resource manager for automatic cleanup
         if self.websocket_server_process:
             managed_process = self.network_manager.create_subprocess(
                 self.websocket_server_process, timeout=30.0
@@ -391,7 +504,10 @@ class MCPServerContext:
         for _attempt in range(max_attempts):
             await asyncio.sleep(0.5)
 
-            if self.websocket_server_process.poll() is not None:
+            if (
+                self.websocket_server_process is not None
+                and self.websocket_server_process.poll() is not None
+            ):
                 return_code = self.websocket_server_process.returncode
                 if self.console:
                     self.console.print(
@@ -420,7 +536,10 @@ class MCPServerContext:
     async def _cleanup_dead_websocket_process(self) -> None:
         if self.websocket_server_process:
             try:
-                if self.websocket_server_process.poll() is None:
+                if (
+                    self.websocket_server_process is not None
+                    and self.websocket_server_process.poll() is None
+                ):
                     self.websocket_server_process.terminate()
                     try:
                         self.websocket_server_process.wait(timeout=2)
@@ -457,7 +576,8 @@ class MCPServerContext:
         if self.console:
             self.console.print("🛑 Stopping WebSocket server...")
 
-        self.websocket_server_process.terminate()
+        if self.websocket_server_process is not None:
+            self.websocket_server_process.terminate()
 
         if await self._wait_for_graceful_termination():
             return
@@ -466,7 +586,8 @@ class MCPServerContext:
 
     async def _wait_for_graceful_termination(self) -> bool:
         try:
-            self.websocket_server_process.wait(timeout=5)
+            if self.websocket_server_process is not None:
+                self.websocket_server_process.wait(timeout=5)
             if self.console:
                 self.console.print("✅ WebSocket server stopped gracefully")
             return True
@@ -477,10 +598,12 @@ class MCPServerContext:
         if self.console:
             self.console.print("⚡ Force killing unresponsive WebSocket server...")
 
-        self.websocket_server_process.kill()
+        if self.websocket_server_process is not None:
+            self.websocket_server_process.kill()
 
         try:
-            self.websocket_server_process.wait(timeout=2)
+            if self.websocket_server_process is not None:
+                self.websocket_server_process.wait(timeout=2)
             if self.console:
                 self.console.print("💀 WebSocket server force killed")
         except subprocess.TimeoutExpired:
@@ -538,7 +661,8 @@ class MCPServerContext:
                 await self._handle_unresponsive_websocket_server()
 
     async def _handle_dead_websocket_process(self) -> None:
-        return_code = self.websocket_server_process.returncode
+        if self.websocket_server_process is not None:
+            return_code = self.websocket_server_process.returncode
         if self.console:
             self.console.print(
                 f"⚠️ WebSocket server process died (exit code: {return_code}), attempting restart...",
@@ -559,7 +683,7 @@ class MCPServerContext:
         elif self.console:
             self.console.print("❌ Failed to restart WebSocket server")
 
-    def safe_print(self, *args, **kwargs) -> None:
+    def safe_print(self, *args: t.Any, **kwargs: t.Any) -> None:
         if not self.config.stdio_mode and self.console:
             self.console.print(*args, **kwargs)
 
@@ -568,7 +692,6 @@ class MCPServerContext:
             msg = f"Invalid job_id: {job_id}"
             raise ValueError(msg)
 
-        # Use secure path joining to prevent directory traversal
         return SecurePathValidator.secure_path_join(
             self.progress_dir, f"job-{job_id}.json"
         )
@@ -671,7 +794,7 @@ def get_rate_limiter() -> RateLimitMiddleware | None:
     return get_context().rate_limiter
 
 
-def safe_print(*args, **kwargs) -> None:
+def safe_print(*args: t.Any, **kwargs: t.Any) -> None:
     get_context().safe_print(*args, **kwargs)
 
 

crackerjack/mcp/dashboard.py

@@ -1,4 +1,5 @@
 import time
+import typing as t
 from collections import deque
 from datetime import datetime
 from pathlib import Path
@@ -74,7 +75,7 @@ class MetricCard(Static):
         value: str = " --",
         trend: str = "",
         status: str = "",
-        **kwargs,
+        **kwargs: t.Any,
     ) -> None:
         super().__init__(**kwargs)
         self.label = label
@@ -205,7 +206,7 @@ class PerformanceWidget(Static):
     }
     """
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
         self.cpu_history: deque[float] = deque(maxlen=50)
         self.memory_history: deque[float] = deque(maxlen=50)
@@ -307,7 +308,7 @@ class CrackerjackDashboard(App):
     }
     """
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
 
         self.job_collector = JobDataCollector()
@@ -463,7 +464,8 @@ class CrackerjackDashboard(App):
                     "http: / / localhost: 8675 / api / jobs"
                 ) as response:
                     if response.status == 200:
-                        return await response.json()
+                        json_result = await response.json()
+                        return t.cast(dict[str, t.Any], json_result)
                     return {}
         except Exception as e:
             self.log(f"Error fetching WebSocket jobs: {e}")
@@ -471,7 +473,7 @@ class CrackerjackDashboard(App):
 
     async def _collect_jobs_from_filesystem(self) -> dict[str, Any]:
         try:
-            jobs = {}
+            jobs: dict[str, Any] = {}
 
             import tempfile