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

crackerjack/mcp/tools/utility_tools.py

@@ -19,7 +19,7 @@ def register_utility_tools(mcp_app: t.Any) -> None:
 
 def _clean_file_if_old(
     file_path: Path, cutoff_time: float, dry_run: bool, file_type: str
-) -> dict | None:
+) -> dict[str, t.Any] | None:
     with suppress(OSError):
         if file_path.stat().st_mtime < cutoff_time:
             file_size = file_path.stat().st_size
@@ -29,7 +29,9 @@ def _clean_file_if_old(
     return None
 
 
-def _clean_temp_files(cutoff_time: float, dry_run: bool) -> tuple[list[dict], int]:
+def _clean_temp_files(
+    cutoff_time: float, dry_run: bool
+) -> tuple[list[dict[str, t.Any]], int]:
     import tempfile
 
     cleaned_files = []
@@ -49,7 +51,7 @@ def _clean_temp_files(cutoff_time: float, dry_run: bool) -> tuple[list[dict], in
 
 def _clean_progress_files(
     context: t.Any, cutoff_time: float, dry_run: bool
-) -> tuple[list[dict], int]:
+) -> tuple[list[dict[str, t.Any]], int]:
     cleaned_files = []
     total_size = 0
 
@@ -65,9 +67,9 @@ def _clean_progress_files(
     return cleaned_files, total_size
 
 
-def _parse_cleanup_options(kwargs: str) -> tuple[dict, str | None]:
+def _parse_cleanup_options(kwargs: str) -> tuple[dict[str, t.Any], str | None]:
     try:
-        extra_kwargs = json.loads(kwargs) if kwargs.strip() else {}
+        extra_kwargs: dict[str, t.Any] = json.loads(kwargs) if kwargs.strip() else {}
         return extra_kwargs, None
     except json.JSONDecodeError as e:
         return {}, f"Invalid JSON in kwargs: {e}"
@@ -91,7 +93,7 @@ def _register_clean_tool(mcp_app: t.Any) -> None:
             return _create_error_response(f"Cleanup failed: {e}")
 
 
-def _parse_clean_configuration(args: str, kwargs: str) -> dict:
+def _parse_clean_configuration(args: str, kwargs: str) -> dict[str, t.Any]:
     extra_kwargs, parse_error = _parse_cleanup_options(kwargs)
     if parse_error:
         return {"error": parse_error}
@@ -103,7 +105,9 @@ def _parse_clean_configuration(args: str, kwargs: str) -> dict:
     }
 
 
-def _execute_cleanup_operations(context: t.Any, clean_config: dict) -> dict:
+def _execute_cleanup_operations(
+    context: t.Any, clean_config: dict[str, t.Any]
+) -> dict[str, t.Any]:
     from datetime import datetime, timedelta
 
     cutoff_time = (
@@ -130,7 +134,9 @@ def _execute_cleanup_operations(context: t.Any, clean_config: dict) -> dict:
     return {"all_cleaned_files": all_cleaned_files, "total_size": total_size}
 
 
-def _create_cleanup_response(clean_config: dict, cleanup_results: dict) -> str:
+def _create_cleanup_response(
+    clean_config: dict[str, t.Any], cleanup_results: dict[str, t.Any]
+) -> str:
     all_cleaned_files = cleanup_results["all_cleaned_files"]
 
     return json.dumps(
@@ -208,16 +214,16 @@ def _register_config_tool(mcp_app: t.Any) -> None:
         if parse_error:
             return _create_error_response(parse_error)
 
-        args_parts = args.strip().split() if args.strip() else ["list"]
+        args_parts = args.strip().split() if args.strip() else ["list[t.Any]"]
         action = args_parts[0].lower()
 
         try:
-            if action == "list":
+            if action == "list[t.Any]":
                 config_info = _handle_config_list(context)
                 result = {
                     "success": True,
                     "command": "config_crackerjack",
-                    "action": "list",
+                    "action": "list[t.Any]",
                     "configuration": config_info,
                 }
             elif action == "get" and len(args_parts) > 1:
@@ -226,7 +232,7 @@ def _register_config_tool(mcp_app: t.Any) -> None:
                 result = _handle_config_validate(context)
             else:
                 return _create_error_response(
-                    f"Invalid action '{action}'. Valid actions: list, get < key >, validate"
+                    f"Invalid action '{action}'. Valid actions: list[t.Any], get < key >, validate"
                 )
 
             return json.dumps(result, indent=2)
@@ -235,7 +241,7 @@ def _register_config_tool(mcp_app: t.Any) -> None:
             return _create_error_response(f"Config operation failed: {e}")
 
 
-def _run_hooks_analysis(orchestrator: t.Any, options: t.Any) -> dict:
+def _run_hooks_analysis(orchestrator: t.Any, options: t.Any) -> dict[str, t.Any]:
     fast_result = orchestrator.run_fast_hooks_only(options)
     comprehensive_result = orchestrator.run_comprehensive_hooks_only(options)
 
@@ -245,7 +251,7 @@ def _run_hooks_analysis(orchestrator: t.Any, options: t.Any) -> dict:
     }
 
 
-def _run_tests_analysis(orchestrator: t.Any, options: t.Any) -> dict:
+def _run_tests_analysis(orchestrator: t.Any, options: t.Any) -> dict[str, t.Any]:
     test_result = orchestrator.run_testing_phase(options)
     return {"status": "passed" if test_result else "failed"}
 

crackerjack/mcp/tools/workflow_executor.py

@@ -13,35 +13,65 @@ async def execute_crackerjack_workflow(
 ) -> dict[str, t.Any]:
     job_id = str(uuid.uuid4())[:8]
 
-    # Configure extended timeout for long-running test operations
-    execution_timeout = kwargs.get("execution_timeout", 900)  # 15 minutes default
-    if kwargs.get("test", False) or kwargs.get("testing", False):
-        execution_timeout = max(execution_timeout, 1200)  # 20 minutes for test runs
+    # Initialize progress immediately
+    await _update_progress(
+        job_id,
+        {"status": "started", "args": args, "timestamp": time.time()},
+        0,
+        message="Crackerjack execution started",
+    )
+
+    # Start execution in background - no timeout!
+    context = get_context()
+    asyncio.create_task(_execute_crackerjack_background(job_id, args, kwargs, context))
+
+    # Return job_id immediately for progress monitoring
+    return {
+        "job_id": job_id,
+        "status": "running",
+        "message": "Execution started. Use get_job_progress(job_id) to monitor progress.",
+        "timestamp": time.time(),
+    }
+
 
+async def _execute_crackerjack_background(
+    job_id: str,
+    args: str,
+    kwargs: dict[str, t.Any],
+    context: t.Any,
+) -> None:
+    """Execute crackerjack workflow in background with progress updates."""
     try:
-        # Add overall execution timeout with keep-alive
-        return await asyncio.wait_for(
-            _execute_crackerjack_sync(job_id, args, kwargs, get_context()),
-            timeout=execution_timeout,
+        result = await _execute_crackerjack_sync(job_id, args, kwargs, context)
+
+        # Update final progress with result
+        await _update_progress(
+            job_id,
+            {
+                "status": result.get("status", "completed"),
+                "result": result,
+                "timestamp": time.time(),
+                "final": True,
+            },
+            100,
+            message=f"Execution {result.get('status', 'completed')}",
         )
-    except TimeoutError:
-        return {
-            "job_id": job_id,
-            "status": "timeout",
-            "error": f"Execution timed out after {execution_timeout} seconds",
-            "timestamp": time.time(),
-        }
     except Exception as e:
         import traceback
 
-        error_details = traceback.format_exc()
-        return {
-            "job_id": job_id,
-            "status": "failed",
-            "error": f"Execution failed: {e}",
-            "traceback": error_details,
-            "timestamp": time.time(),
-        }
+        # Update progress with error
+        await _update_progress(
+            job_id,
+            {
+                "status": "failed",
+                "error": str(e),
+                "traceback": traceback.format_exc(),
+                "timestamp": time.time(),
+                "final": True,
+            },
+            -1,
+            message=f"Execution failed: {e}",
+        )
 
 
 async def _execute_crackerjack_sync(
@@ -81,7 +111,6 @@ async def _initialize_execution(
         context,
     )
 
-    # Ensure WebSocket server is running for progress tracking
     await _ensure_websocket_server_running(job_id, context)
 
     working_dir = kwargs.get("working_directory", ".")
@@ -228,9 +257,8 @@ async def _run_workflow_iterations(
     context: t.Any,
 ) -> dict[str, t.Any]:
     options = _create_workflow_options(kwargs)
-    max_iterations = kwargs.get("max_iterations", 10)
+    max_iterations = kwargs.get("max_iterations", 5)
 
-    # Start keep-alive task to prevent TCP timeouts
     keep_alive_task = asyncio.create_task(_keep_alive_heartbeat(job_id, context))
 
     try:
@@ -250,7 +278,6 @@ async def _execute_iterations_loop(
     max_iterations: int,
     context: t.Any,
 ) -> dict[str, t.Any]:
-    """Execute the main iterations loop."""
     for iteration in range(max_iterations):
         _update_iteration_progress(job_id, iteration, max_iterations, context)
 
@@ -276,7 +303,6 @@ async def _execute_iterations_loop(
 def _update_iteration_progress(
     job_id: str, iteration: int, max_iterations: int, context: t.Any
 ) -> None:
-    """Update progress for current iteration."""
     _update_progress(
         job_id,
         {
@@ -296,7 +322,6 @@ async def _handle_iteration_success(
     kwargs: dict[str, t.Any],
     context: t.Any,
 ) -> dict[str, t.Any]:
-    """Handle successful iteration."""
     coverage_result = None
     if kwargs.get("boost_coverage", False):
         coverage_result = await _attempt_coverage_improvement(
@@ -306,7 +331,6 @@ async def _handle_iteration_success(
 
 
 async def _cleanup_keep_alive_task(keep_alive_task: asyncio.Task[t.Any]) -> None:
-    """Clean up the keep-alive task."""
     if not keep_alive_task.cancelled():
         keep_alive_task.cancel()
         try:
@@ -316,10 +340,8 @@ async def _cleanup_keep_alive_task(keep_alive_task: asyncio.Task[t.Any]) -> None
 
 
 async def _keep_alive_heartbeat(job_id: str, context: t.Any) -> None:
-    """Send periodic keep-alive messages to prevent TCP timeouts."""
     try:
         while True:
-            # Send heartbeat every 60 seconds (well under 2-minute TCP timeout)
             await asyncio.sleep(60)
             _update_progress(
                 job_id,
@@ -332,7 +354,6 @@ async def _keep_alive_heartbeat(job_id: str, context: t.Any) -> None:
                 context,
             )
     except asyncio.CancelledError:
-        # Task was cancelled, cleanup
         _update_progress(
             job_id,
             {
@@ -404,23 +425,27 @@ async def _execute_single_iteration(
                 raise ValueError(
                     "Method run_complete_workflow_async returned None instead of awaitable"
                 )
-            return await result
+            workflow_result: bool = await result
+            return workflow_result
         elif hasattr(orchestrator, "run_complete_workflow"):
             result = orchestrator.run_complete_workflow(options)
             if result is None:
                 raise ValueError(
                     "Method run_complete_workflow returned None instead of awaitable"
                 )
-            return await result
+            workflow_result: bool = await result
+            return workflow_result
         elif hasattr(orchestrator, "execute_workflow"):
             result = orchestrator.execute_workflow(options)
             if result is None:
                 raise ValueError(
                     "Method execute_workflow returned None instead of awaitable"
                 )
-            return await result
+            workflow_result: bool = await result
+            return workflow_result
         elif hasattr(orchestrator, "run"):
-            return orchestrator.run(options)
+            run_result: bool = orchestrator.run(options)
+            return run_result
         else:
             raise ValueError(
                 f"Orchestrator {type(orchestrator)} has no recognized workflow execution method"
@@ -606,11 +631,9 @@ def _create_failure_result(
 
 
 async def _ensure_websocket_server_running(job_id: str, context: t.Any) -> None:
-    """Ensure WebSocket server is running for progress tracking during crackerjack:run."""
     try:
         from crackerjack.mcp.progress_components import ServiceManager
 
-        # Initialize and start services if needed
         service_manager = ServiceManager()
         await service_manager.ensure_services_running()
 
@@ -624,7 +647,6 @@ async def _ensure_websocket_server_running(job_id: str, context: t.Any) -> None:
             context,
         )
     except Exception as e:
-        # Don't fail the whole workflow if WebSocket server fails to start
         _update_progress(
             job_id,
             {

crackerjack/mcp/websocket/app.py

@@ -5,6 +5,10 @@ from fastapi import FastAPI
 
 from .endpoints import register_endpoints
 from .jobs import JobManager
+from .monitoring_endpoints import (
+    MonitoringWebSocketManager,
+    create_monitoring_endpoints,
+)
 from .websocket_handler import register_websocket_routes
 
 
@@ -33,4 +37,8 @@ def create_websocket_app(job_manager: JobManager, progress_dir: Path) -> FastAPI
 
     register_websocket_routes(app, job_manager, progress_dir)
 
+    # Register monitoring endpoints
+    monitoring_ws_manager = MonitoringWebSocketManager()
+    create_monitoring_endpoints(app, job_manager, progress_dir, monitoring_ws_manager)
+
     return app