crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/mcp/progress_monitor.py

@@ -14,6 +14,8 @@ from textual.containers import Container
 from textual.widget import Widget
 from textual.widgets import DataTable, Footer, Label, ProgressBar
 
+from crackerjack.core.timeout_manager import TimeoutStrategy, get_timeout_manager
+
 from .progress_components import (
     ErrorCollector,
     JobDataCollector,
@@ -75,7 +77,7 @@ class AgentStatusPanel(Widget):
             active_agents = activity.get("active_agents", [])
 
             if not active_agents:
-                agents_table.add_row("No active agents", " - ", " - ", " - ", " - ")
+                agents_table.add_row("No active agents", "-", "-", "-", "-")
                 return
 
             for agent in active_agents:
@@ -88,9 +90,9 @@ class AgentStatusPanel(Widget):
 
                 current_issue = agent.get("current_issue", {})
                 issue_type = (
-                    current_issue.get("type", " - ")
+                    current_issue.get("type", "-")
                     if current_issue
-                    else agent.get("issue_type", " - ")
+                    else agent.get("issue_type", "-")
                 )
 
                 status_display = f"{self._get_status_emoji(status)} {status.title()}"
@@ -99,8 +101,8 @@ class AgentStatusPanel(Widget):
                     f"{emoji} {agent_type}",
                     status_display,
                     issue_type,
-                    f"{confidence: .0 % }" if confidence > 0 else " - ",
-                    f"{processing_time: .1f}s" if processing_time > 0 else " - ",
+                    f"{confidence: .0 % }" if confidence > 0 else "-",
+                    f"{processing_time: .1f}s" if processing_time > 0 else "-",
                 )
 
     def _update_stats(self, data: dict) -> None:
@@ -212,7 +214,7 @@ class JobPanel(Widget):
             errors_container.border_title = "❌ Errors"
 
             errors_table = self.query_one(
-                f"#job-errors-{self.job_data.get('job_id', 'unknown')}",
+                f"#job-errors -{self.job_data.get('job_id', 'unknown')}",
                 DataTable,
             )
             errors_table.add_columns("", "", "", "")
@@ -222,7 +224,7 @@ class JobPanel(Widget):
     def _update_errors_table(self) -> None:
         with suppress(Exception):
             errors_table = self.query_one(
-                f"#job-errors-{self.job_data.get('job_id', 'unknown')}",
+                f"#job-errors -{self.job_data.get('job_id', 'unknown')}",
                 DataTable,
             )
             errors_table.clear()
@@ -276,7 +278,7 @@ class JobPanel(Widget):
     def _update_progress_bar(self) -> None:
         with suppress(Exception):
             progress_bar = self.query_one(
-                f"#job-progress-{self.job_data.get('job_id', 'unknown')}",
+                f"#job-progress -{self.job_data.get('job_id', 'unknown')}",
                 ProgressBar,
             )
             progress_value = self.iteration_count / max(self.max_iterations, 1) * 100
@@ -365,7 +367,7 @@ class JobPanel(Widget):
             total=100,
             show_eta=False,
             show_percentage=False,
-            id=f"job-progress-{self.job_data.get('job_id', 'unknown')}",
+            id=f"job-progress -{self.job_data.get('job_id', 'unknown')}",
         )
 
     def _compose_stage_and_status(self) -> ComposeResult:
@@ -401,7 +403,7 @@ class JobPanel(Widget):
     def _compose_errors_column(self) -> ComposeResult:
         with Container(classes="job-errors"):
             yield DataTable(
-                id=f"job-errors-{self.job_data.get('job_id', 'unknown')}",
+                id=f"job-errors -{self.job_data.get('job_id', 'unknown')}",
             )
 
 
@@ -415,12 +417,13 @@ class CrackerjackDashboard(App):
 
     def __init__(self) -> None:
         super().__init__()
-        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
+        self.progress_dir = Path(tempfile.gettempdir()) / "crackerjack - mcp-progress"
         self.websocket_url = "ws://localhost:8675"
         self.refresh_timer = None
         self.active_jobs = {}
         self.completed_jobs_stats = {}
         self.current_polling_method = "File"
+        self.timeout_manager = get_timeout_manager()
 
         self.job_collector = JobDataCollector(self.progress_dir, self.websocket_url)
         self.service_checker = ServiceHealthChecker()
@@ -442,7 +445,7 @@ class CrackerjackDashboard(App):
     def _compose_left_column(self) -> ComposeResult:
         with Container(id="left-column"):
             yield from self._compose_jobs_panel()
-            yield AgentStatusPanel(id="agent-status-panel")
+            yield AgentStatusPanel(id="agent - status-panel")
 
     def _compose_right_column(self) -> ComposeResult:
         with Container(id="right-column"):
@@ -470,7 +473,7 @@ class CrackerjackDashboard(App):
 
     def _compose_discovery_section(self) -> ComposeResult:
         with Container(id="discovery-section"):
-            yield Container(id="job-discovery-container")
+            yield Container(id="job - discovery-container")
 
     def on_mount(self) -> None:
         self._setup_border_titles()
@@ -528,43 +531,113 @@ class CrackerjackDashboard(App):
         self.refresh_timer = self.set_interval(0.5, self._refresh_data)
 
     async def _refresh_data(self) -> None:
-        with suppress(Exception):
-            if hasattr(self, "_refresh_counter"):
-                self._refresh_counter += 1
-            else:
-                self._refresh_counter = 0
-
-            if self._refresh_counter % 10 == 0:
-                await self._ensure_services_running()
-
-            jobs_data = await self._discover_jobs()
+        try:
+            # Refresh cycle with timeout protection
+            async with self.timeout_manager.timeout_context(
+                "network_operations",
+                timeout=10.0,  # Total refresh timeout
+                strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
+            ):
+                if hasattr(self, "_refresh_counter"):
+                    self._refresh_counter += 1
+                else:
+                    self._refresh_counter = 0
+
+                # Ensure services running less frequently to avoid overhead
+                if self._refresh_counter % 20 == 0:  # Every 10 seconds instead of 5
+                    with suppress(Exception):
+                        await self.timeout_manager.with_timeout(
+                            "network_operations",
+                            self._ensure_services_running(),
+                            timeout=5.0,
+                            strategy=TimeoutStrategy.FAIL_FAST,
+                        )
+
+                # Collect data with individual timeouts
+                jobs_data = await self.timeout_manager.with_timeout(
+                    "network_operations",
+                    self._discover_jobs(),
+                    timeout=3.0,
+                    strategy=TimeoutStrategy.FAIL_FAST,
+                )
 
-            services_data = await self._collect_services_data()
+                services_data = await self.timeout_manager.with_timeout(
+                    "network_operations",
+                    self._collect_services_data(),
+                    timeout=2.0,
+                    strategy=TimeoutStrategy.FAIL_FAST,
+                )
 
-            errors_data = await self._collect_recent_errors()
+                errors_data = await self.timeout_manager.with_timeout(
+                    "file_operations",
+                    self._collect_recent_errors(),
+                    timeout=2.0,
+                    strategy=TimeoutStrategy.FAIL_FAST,
+                )
 
-            if jobs_data["individual_jobs"]:
-                jobs_data["individual_jobs"][0].get("project", "crackerjack")
+                # Update UI components
+                self.query_one("#services-panel").border_title = "🔧 Services"
 
-            self.query_one("#services-panel").border_title = "🔧 Services"
+                self._update_jobs_table(jobs_data)
+                self._update_services_table(services_data)
+                self._update_errors_table(errors_data)
+                self._update_job_panels(jobs_data)
+                self._update_agent_panel(jobs_data)
+                self._update_status_bars(jobs_data)
 
-            self._update_jobs_table(jobs_data)
-            self._update_services_table(services_data)
-            self._update_errors_table(errors_data)
-            self._update_job_panels(jobs_data)
-            self._update_agent_panel(jobs_data)
-            self._update_status_bars(jobs_data)
+        except Exception as e:
+            # Log error but don't crash the dashboard
+            with suppress(Exception):
+                console = Console()
+                console.print(f"[red]Dashboard refresh error: {e}[/red]")
 
     async def _discover_jobs(self) -> dict:
-        result = await self.job_collector.discover_jobs()
-        self.current_polling_method = result["method"]
-        return result["data"]
+        try:
+            result = await self.timeout_manager.with_timeout(
+                "network_operations",
+                self.job_collector.discover_jobs(),
+                timeout=5.0,
+                strategy=TimeoutStrategy.FAIL_FAST,
+            )
+            self.current_polling_method = result["method"]
+            return result["data"]
+        except Exception:
+            # Return empty data structure on timeout or error
+            return {
+                "active": 0,
+                "completed": 0,
+                "failed": 0,
+                "total": 0,
+                "individual_jobs": [],
+                "total_issues": 0,
+                "errors_fixed": 0,
+                "errors_failed": 0,
+                "current_errors": 0,
+            }
 
     async def _collect_services_data(self) -> list:
-        return await self.service_checker.collect_services_data()
+        try:
+            return await self.timeout_manager.with_timeout(
+                "network_operations",
+                self.service_checker.collect_services_data(),
+                timeout=3.0,
+                strategy=TimeoutStrategy.FAIL_FAST,
+            )
+        except Exception:
+            # Return minimal service data on timeout
+            return [("Services", "🔴 Timeout", "0")]
 
     async def _collect_recent_errors(self) -> list:
-        return await self.error_collector.collect_recent_errors()
+        try:
+            return await self.timeout_manager.with_timeout(
+                "file_operations",
+                self.error_collector.collect_recent_errors(),
+                timeout=2.0,
+                strategy=TimeoutStrategy.FAIL_FAST,
+            )
+        except Exception:
+            # Return empty error list on timeout
+            return []
 
     def _update_jobs_table(self, jobs_data: dict) -> None:
         with suppress(Exception):
@@ -696,7 +769,7 @@ class CrackerjackDashboard(App):
 
     def _update_agent_panel(self, jobs_data: dict) -> None:
         with suppress(Exception):
-            agent_panel = self.query_one("#agent-status-panel", AgentStatusPanel)
+            agent_panel = self.query_one("#agent - status-panel", AgentStatusPanel)
 
             agent_data = {}
             for job in jobs_data.get("individual_jobs", []):
@@ -709,7 +782,7 @@ class CrackerjackDashboard(App):
 
     def _update_job_panels(self, jobs_data: dict) -> None:
         with suppress(Exception):
-            container = self.query_one("#job-discovery-container")
+            container = self.query_one("#job - discovery-container")
             current_job_ids = self._get_current_job_ids(jobs_data)
 
             self._remove_obsolete_panels(current_job_ids)
@@ -792,17 +865,17 @@ class CrackerjackDashboard(App):
         container.mount(job_panel)
 
     def _handle_placeholder_visibility(self, container) -> None:
-        has_placeholder = bool(container.query("#no-jobs-label"))
+        has_placeholder = bool(container.query("#no - jobs-label"))
 
         if not self.active_jobs and not has_placeholder:
             container.mount(
                 Label(
                     "No active jobs detected. Start a Crackerjack job to see progress here.",
-                    id="no-jobs-label",
+                    id="no - jobs-label",
                 ),
             )
         elif self.active_jobs and has_placeholder:
-            container.query("#no-jobs-label").remove()
+            container.query("#no - jobs-label").remove()
 
     def _update_status_bars(self, jobs_data: dict) -> None:
         pass
@@ -816,7 +889,7 @@ class CrackerjackDashboard(App):
                 table = self.query_one(table_id, DataTable)
                 table.clear()
 
-            container = self.query_one("#job-discovery-container")
+            container = self.query_one("#job - discovery-container")
             container.query("JobPanel").remove()
             container.query("Label").remove()
             self.active_jobs.clear()
@@ -889,14 +962,14 @@ async def run_progress_monitor(
     with suppress(Exception):
         console = Console()
         console.print(
-            "[bold green]🚀 Starting Crackerjack Progress Monitor[/bold green]",
+            "[bold green]🚀 Starting Crackerjack Progress Monitor[/ bold green]",
         )
 
         if enable_watchdog:
-            console.print("[bold yellow]🐕 Service Watchdog: Enabled[/bold yellow]")
+            console.print("[bold yellow]🐕 Service Watchdog: Enabled[/ bold yellow]")
 
         if dev_mode:
-            console.print("[bold cyan]🛠️  Development Mode: Enabled[/bold cyan]")
+            console.print("[bold cyan]🛠️ Development Mode: Enabled[/ bold cyan]")
 
         app = CrackerjackDashboard()
 
@@ -912,7 +985,7 @@ async def run_crackerjack_with_progress(
     with suppress(Exception):
         console = Console()
         console.print(
-            "[bold green]🚀 Starting Crackerjack Progress Monitor[/bold green]",
+            "[bold green]🚀 Starting Crackerjack Progress Monitor[/ bold green]",
         )
 
         app = CrackerjackDashboard()

crackerjack/mcp/rate_limiter.py

@@ -159,7 +159,7 @@ class ResourceMonitor:
                 and len(self.active_jobs) >= self.config.max_concurrent_jobs
             ):
                 console.print(
-                    f"[yellow]🚫 Job {job_id} rejected: max concurrent jobs ({self.config.max_concurrent_jobs}) reached[/yellow]",
+                    f"[yellow]🚫 Job {job_id} rejected: max concurrent jobs ({self.config.max_concurrent_jobs}) reached[/ yellow]",
                 )
                 return False
 
@@ -167,7 +167,7 @@ class ResourceMonitor:
                 await asyncio.wait_for(self.job_locks.acquire(), timeout=0.1)
             except TimeoutError:
                 console.print(
-                    f"[yellow]🚫 Job {job_id} rejected: max concurrent jobs ({self.config.max_concurrent_jobs}) reached[/yellow]",
+                    f"[yellow]🚫 Job {job_id} rejected: max concurrent jobs ({self.config.max_concurrent_jobs}) reached[/ yellow]",
                 )
                 return False
 
@@ -175,12 +175,12 @@ class ResourceMonitor:
                 self.active_jobs[job_id] = time.time()
 
             console.print(
-                f"[green]🎯 Job {job_id} acquired slot ({len(self.active_jobs)} / {self.config.max_concurrent_jobs})[/green]",
+                f"[green]🎯 Job {job_id} acquired slot ({len(self.active_jobs)} / {self.config.max_concurrent_jobs})[/ green]",
             )
             return True
 
         except Exception as e:
-            console.print(f"[red]Error acquiring job slot for {job_id}: {e}[/red]")
+            console.print(f"[red]Error acquiring job slot for {job_id}: {e}[/ red]")
             return False
 
     async def release_job_slot(self, job_id: str) -> None:
@@ -189,7 +189,7 @@ class ResourceMonitor:
                 start_time = self.active_jobs.pop(job_id)
                 duration = time.time() - start_time
                 console.print(
-                    f"[blue]🏁 Job {job_id} completed in {duration: .1f}s ({len(self.active_jobs)} / {self.config.max_concurrent_jobs} active)[/blue]",
+                    f"[blue]🏁 Job {job_id} completed in {duration: .1f}s ({len(self.active_jobs)} / {self.config.max_concurrent_jobs} active)[/ blue]",
                 )
 
         self.job_locks.release()
@@ -208,7 +208,7 @@ class ResourceMonitor:
 
         if stale_jobs:
             console.print(
-                f"[yellow]🧹 Cleaned up {len(stale_jobs)} stale jobs (exceeded {self.config.max_job_duration_minutes}m)[/yellow]",
+                f"[yellow]🧹 Cleaned up {len(stale_jobs)} stale jobs (exceeded {self.config.max_job_duration_minutes}m)[/ yellow]",
             )
 
         return len(stale_jobs)
@@ -221,7 +221,7 @@ class ResourceMonitor:
             size_mb = file_path.stat().st_size / (1024 * 1024)
             if size_mb > self.config.max_file_size_mb:
                 console.print(
-                    f"[red]🚫 File {file_path} ({size_mb: .1f}MB) exceeds limit ({self.config.max_file_size_mb}MB)[/red]",
+                    f"[red]🚫 File {file_path} ({size_mb: .1f}MB) exceeds limit ({self.config.max_file_size_mb}MB)[/ red]",
                 )
                 return False
 
@@ -234,10 +234,10 @@ class ResourceMonitor:
             if not progress_dir.exists():
                 return True
 
-            file_count = len(list(progress_dir.glob("job -* .json")))
+            file_count = len(list(progress_dir.glob("job-* .json")))
             if file_count > self.config.max_progress_files:
                 console.print(
-                    f"[red]🚫 Progress files ({file_count}) exceed limit ({self.config.max_progress_files})[/red]",
+                    f"[red]🚫 Progress files ({file_count}) exceed limit ({self.config.max_progress_files})[/ red]",
                 )
                 return False
 
@@ -278,7 +278,7 @@ class RateLimitMiddleware:
     async def start(self) -> None:
         self._running = True
         self._cleanup_task = asyncio.create_task(self._cleanup_loop())
-        console.print("[green]🛡️ Rate limiting middleware started[/green]")
+        console.print("[green]🛡️ Rate limiting middleware started[/ green]")
 
     async def stop(self) -> None:
         self._running = False
@@ -286,7 +286,7 @@ class RateLimitMiddleware:
             self._cleanup_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await self._cleanup_task
-        console.print("[yellow]🛡️ Rate limiting middleware stopped[/yellow]")
+        console.print("[yellow]🛡️ Rate limiting middleware stopped[/ yellow]")
 
     async def check_request_allowed(
         self,
@@ -314,7 +314,7 @@ class RateLimitMiddleware:
             except asyncio.CancelledError:
                 break
             except Exception as e:
-                console.print(f"[red]Error in cleanup loop: {e}[/red]")
+                console.print(f"[red]Error in cleanup loop: {e}[/ red]")
                 await asyncio.sleep(60)
 
     def get_comprehensive_stats(self) -> dict[str, t.Any]:

crackerjack/mcp/server_core.py

@@ -65,9 +65,9 @@ def _validate_job_id(job_id: str) -> bool:
     if len(job_id) > 50:
         return False
 
-    import re
+    from crackerjack.services.regex_patterns import is_valid_job_id
 
-    return bool(re.match(r"^[a-zA-Z0-9_-]+$", job_id))
+    return is_valid_job_id(job_id)
 
 
 async def _start_websocket_server() -> bool:
@@ -81,7 +81,7 @@ def create_mcp_server() -> t.Any | None:
     if not MCP_AVAILABLE or FastMCP is None:
         return None
 
-    mcp_app = FastMCP("crackerjack-mcp-server")
+    mcp_app = FastMCP("crackerjack - mcp-server")
 
     from crackerjack.slash_commands import get_slash_command_path
 
@@ -129,39 +129,37 @@ def handle_mcp_server_command(
     restart: bool = False,
     websocket_port: int | None = None,
 ) -> None:
-    """Handle MCP server start/stop/restart commands."""
     if stop or restart:
-        console.print("[yellow]Stopping MCP servers...[/yellow]")
-        # Kill any existing MCP server processes
+        console.print("[yellow]Stopping MCP servers...[/ yellow]")
+
         try:
             result = subprocess.run(
-                ["pkill", "-f", "crackerjack-mcp-server"],
+                ["pkill", "- f", "crackerjack - mcp-server"],
                 check=False,
                 capture_output=True,
                 text=True,
                 timeout=10,
             )
             if result.returncode == 0:
-                console.print("[green]✅ MCP servers stopped[/green]")
+                console.print("[green]✅ MCP servers stopped[/ green]")
             else:
-                console.print("[dim]No MCP servers were running[/dim]")
+                console.print("[dim]No MCP servers were running[/ dim]")
         except subprocess.TimeoutExpired:
-            console.print("[red]Timeout stopping MCP servers[/red]")
+            console.print("[red]Timeout stopping MCP servers[/ red]")
         except Exception as e:
-            console.print(f"[red]Error stopping MCP servers: {e}[/red]")
+            console.print(f"[red]Error stopping MCP servers: {e}[/ red]")
 
         if stop:
             return
 
-        # For restart, wait a moment before starting again
         time.sleep(2)
 
     if start or restart:
-        console.print("[green]Starting MCP server...[/green]")
+        console.print("[green]Starting MCP server...[/ green]")
         try:
             main(".", websocket_port)
         except Exception as e:
-            console.print(f"[red]Failed to start MCP server: {e}[/red]")
+            console.print(f"[red]Failed to start MCP server: {e}[/ red]")
 
 
 def _initialize_context(context: MCPServerContext) -> None:
@@ -174,11 +172,8 @@ def _stop_websocket_server() -> None:
     from contextlib import suppress
 
     with suppress(RuntimeError):
-        # Context not initialized, nothing to stop
         context = get_context()
         if context and hasattr(context, "_stop_websocket_server"):
-            # The websocket cleanup is handled asynchronously
-            # and called from the context's cleanup handlers
             pass
 
 
@@ -197,7 +192,6 @@ def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None
         context = MCPServerContext(config)
         context.console = console
 
-        # Set custom WebSocket port if specified
         if websocket_port:
             context.websocket_server_port = websocket_port
 
@@ -205,19 +199,19 @@ def main(project_path_arg: str = ".", websocket_port: int | None = None) -> None
 
         mcp_app = create_mcp_server()
         if not mcp_app:
-            console.print("[red]Failed to create MCP server[/red]")
+            console.print("[red]Failed to create MCP server[/ red]")
             return
 
-        console.print("[green]Starting Crackerjack MCP Server...[/green]")
+        console.print("[green]Starting Crackerjack MCP Server...[/ green]")
         console.print(f"Project path: {project_path}")
         if websocket_port:
             console.print(f"WebSocket port: {websocket_port}")
 
-        console.print("[yellow]MCP app created, about to run...[/yellow]")
+        console.print("[yellow]MCP app created, about to run...[/ yellow]")
         try:
             mcp_app.run()
         except Exception as e:
-            console.print(f"[red]MCP run failed: {e}[/red]")
+            console.print(f"[red]MCP run failed: {e}[/ red]")
             import traceback
 
             traceback.print_exc()