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

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
 

crackerjack/mcp/enhanced_progress_monitor.py

@@ -1,5 +1,6 @@
 import asyncio
 import time
+import typing as t
 from contextlib import suppress
 from datetime import datetime
 from pathlib import Path
@@ -29,7 +30,7 @@ class MetricCard(Widget):
         value: str = " --",
         trend: str = "",
         color: str = "white",
-        **kwargs,
+        **kwargs: t.Any,
     ) -> None:
         super().__init__(**kwargs)
         self.label = label
@@ -43,7 +44,7 @@ class MetricCard(Widget):
 
 
 class AgentActivityWidget(Widget):
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: t.Any) -> None:
         super().__init__(**kwargs)
         self.border_title = "🤖 AI Agent Activity"
         self.border_title_align = "left"
@@ -93,7 +94,7 @@ class AgentActivityWidget(Widget):
         table.zebra_stripes = True
         table.styles.max_height = 6
 
-    def update_metrics(self, data: dict) -> None:
+    def update_metrics(self, data: dict[str, t.Any]) -> None:
         with suppress(Exception):
             activity = data.get("agent_activity", {})
             activity.get("agent_registry", {})
@@ -116,14 +117,14 @@ class AgentActivityWidget(Widget):
             self.query_one(
                 "#confidence-metric",
                 MetricCard,
-            ).value = f"{avg_confidence:.0%}"
+            ).value = f"{avg_confidence: .0%}"
             self.query_one("#cache-hits-metric", MetricCard).value = str(cache_hits)
 
             self._update_coordinator_status(activity)
 
             self._update_agent_table(active_agents)
 
-    def _update_coordinator_status(self, activity: dict) -> None:
+    def _update_coordinator_status(self, activity: dict[str, t.Any]) -> None:
         status = activity.get("coordinator_status", "idle")
         total_agents = activity.get("agent_registry", {}).get("total_agents", 0)
 
@@ -135,7 +136,7 @@ class AgentActivityWidget(Widget):
             f"{icon} Coordinator: {status.title()} ({total_agents} agents available)",
         )
 
-    def _update_agent_table(self, agents: list) -> None:
+    def _update_agent_table(self, agents: list[t.Any]) -> None:
         table = self.query_one("#agents-detail-table", DataTable)
         table.clear()
 
@@ -147,8 +148,8 @@ class AgentActivityWidget(Widget):
             name = agent.get("agent_type", "Unknown")
             status = agent.get("status", "idle")
             issue_type = agent.get("issue_type", "-")
-            confidence = f"{agent.get('confidence', 0):.0%}"
-            time_elapsed = f"{agent.get('processing_time', 0):.1f}s"
+            confidence = f"{agent.get('confidence', 0): .0%}"
+            time_elapsed = f"{agent.get('processing_time', 0): .1f}s"
 
             status_emoji = {
                 "processing": "🔄",
@@ -176,7 +177,7 @@ class AgentActivityWidget(Widget):
 
 
 class JobProgressPanel(Widget):
-    def __init__(self, job_data: dict, **kwargs) -> None:
+    def __init__(self, job_data: dict[str, t.Any], **kwargs) -> None:
         super().__init__(**kwargs)
         self.job_data = job_data
         self.start_time = time.time()
@@ -198,10 +199,12 @@ class JobProgressPanel(Widget):
 
         with Horizontal():
             with Vertical(id="job-progress-section"):
-                yield self._compose_progress_section()
+                for widget in self._compose_progress_section():
+                    yield widget
 
             with Vertical(id="job-metrics-section"):
-                yield self._compose_metrics_section()
+                for widget in self._compose_metrics_section():
+                    yield widget
 
     def _compose_progress_section(self) -> ComposeResult:
         iteration = self.job_data.get("iteration", 1)
@@ -247,16 +250,16 @@ class JobProgressPanel(Widget):
         if total_issues > 0:
             success_rate = (fixed / total_issues) * 100
             yield Label(
-                f"Success Rate: {success_rate:.1f}%",
+                f"Success Rate: {success_rate: .1f}%",
                 classes="success-rate",
             )
 
     def _format_time(self, seconds: float) -> str:
         if seconds < 60:
-            return f"{seconds:.0f}s"
+            return f"{seconds: .0f}s"
         if seconds < 3600:
-            return f"{seconds / 60:.0f}m {seconds % 60:.0f}s"
-        return f"{seconds / 3600:.0f}h {(seconds % 3600) / 60:.0f}m"
+            return f"{seconds / 60: .0f}m {seconds % 60: .0f}s"
+        return f"{seconds / 3600: .0f}h {(seconds % 3600) / 60: .0f}m"
 
 
 class ServiceHealthPanel(Widget):
@@ -279,7 +282,7 @@ class ServiceHealthPanel(Widget):
         )
         table.zebra_stripes = True
 
-    def update_services(self, services: list[dict]) -> None:
+    def update_services(self, services: list[dict[str, t.Any]]) -> None:
         table = self.query_one("#services-table", DataTable)
         table.clear()
 
@@ -308,7 +311,7 @@ class ServiceHealthPanel(Widget):
 
             if isinstance(last_check, int | float):
                 last_check_str = datetime.fromtimestamp(last_check).strftime(
-                    "%H:%M:%S",
+                    "%H: %M: %S",
                 )
             else:
                 last_check_str = str(last_check)
@@ -323,12 +326,12 @@ class ServiceHealthPanel(Widget):
 
     def _format_uptime(self, seconds: float) -> str:
         if seconds < 60:
-            return f"{seconds:.0f}s"
+            return f"{seconds: .0f}s"
         if seconds < 3600:
-            return f"{seconds / 60:.0f}m"
+            return f"{seconds / 60: .0f}m"
         if seconds < 86400:
-            return f"{seconds / 3600:.1f}h"
-        return f"{seconds / 86400:.1f}d"
+            return f"{seconds / 3600: .1f}h"
+        return f"{seconds / 86400: .1f}d"
 
 
 class EnhancedCrackerjackDashboard(App):
@@ -336,7 +339,7 @@ class EnhancedCrackerjackDashboard(App):
     CSS_PATH = Path(__file__).parent / "enhanced_progress_monitor.tcss"
 
     def __init__(
-        self, progress_dir: Path, websocket_url: str = "ws://localhost:8675"
+        self, progress_dir: Path, websocket_url: str = "ws: //localhost: 8675"
     ) -> None:
         super().__init__()
         self.progress_dir = progress_dir
@@ -367,7 +370,7 @@ class EnhancedCrackerjackDashboard(App):
             jobs_result = await self.data_collector.discover_jobs()
             jobs_data = jobs_result.get("data", {})
 
-            services = self.service_manager.check_all_services()
+            services = self.service_manager.collect_services_data()
             self.query_one("#service-panel", ServiceHealthPanel).update_services(
                 services,
             )
@@ -385,8 +388,8 @@ class EnhancedCrackerjackDashboard(App):
         except Exception as e:
             self.console.print(f"[red]Dashboard update error: {e}[/]")
 
-    def _aggregate_agent_data(self, jobs: list[dict]) -> dict:
-        aggregated = {
+    def _aggregate_agent_data(self, jobs: list[dict[str, t.Any]]) -> dict[str, t.Any]:
+        aggregated: dict[str, dict[str, t.Any]] = {
             "agent_activity": {
                 "active_agents": [],
                 "coordinator_status": "idle",
@@ -418,7 +421,7 @@ class EnhancedCrackerjackDashboard(App):
 
         return aggregated
 
-    def _update_job_panels(self, jobs: list[dict]) -> None:
+    def _update_job_panels(self, jobs: list[dict[str, t.Any]]) -> None:
         container = self.query_one("#jobs-container", Container)
 
         with suppress(Exception):
@@ -445,7 +448,7 @@ class EnhancedCrackerjackDashboard(App):
 
 async def run_enhanced_progress_monitor(
     progress_dir: Path | None = None,
-    websocket_url: str = "ws://localhost:8675",
+    websocket_url: str = "ws: //localhost: 8675",
     dev_mode: bool = False,
 ) -> None:
     if progress_dir is None:
@@ -474,6 +477,6 @@ if __name__ == "__main__":
     import tempfile
 
     progress_dir = Path(sys.argv[1]) if len(sys.argv) > 1 else None
-    websocket_url = sys.argv[2] if len(sys.argv) > 2 else "ws://localhost:8675"
+    websocket_url = sys.argv[2] if len(sys.argv) > 2 else "ws: //localhost: 8675"
 
     asyncio.run(run_enhanced_progress_monitor(progress_dir, websocket_url))