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

crackerjack/mcp/tools/proactive_tools.py

@@ -1,7 +1,9 @@
 import typing as t
 
 
-def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
+def _create_architectural_assessment(
+    args: str, parsed_kwargs: dict[str, t.Any]
+) -> dict[str, t.Any]:
     assessment = {
         "feature": parsed_kwargs.get("feature", "unknown"),
         "complexity": parsed_kwargs.get("complexity", "medium"),
@@ -56,7 +58,7 @@ def _create_architectural_assessment(args: str, parsed_kwargs: dict) -> dict:
     return assessment
 
 
-def _create_validation_results(file_path: str) -> dict:
+def _create_validation_results(file_path: str) -> dict[str, t.Any]:
     validation = {
         "file_path": file_path,
         "validation_results": [],
@@ -95,7 +97,10 @@ def _create_validation_results(file_path: str) -> dict:
         },
     ]
 
-    validation["validation_results"] = compliance_checks
+    validation["validation_results"] = [
+        f"{check['check']}: {check['status']} - {check['message']}"
+        for check in compliance_checks
+    ]
 
     validation["recommendations"] = [
         "Run full crackerjack quality process: python - m crackerjack-t",
@@ -113,7 +118,7 @@ def _create_validation_results(file_path: str) -> dict:
     return validation
 
 
-def _create_pattern_suggestions(problem_context: str) -> dict:
+def _create_pattern_suggestions(problem_context: str) -> dict[str, t.Any]:
     pattern_suggestions = {
         "context": problem_context,
         "recommended_patterns": [],
@@ -168,7 +173,9 @@ def _create_pattern_suggestions(problem_context: str) -> dict:
     return pattern_suggestions
 
 
-def _add_complexity_patterns(pattern_suggestions: dict, problem_context: str) -> None:
+def _add_complexity_patterns(
+    pattern_suggestions: dict[str, t.Any], problem_context: str
+) -> None:
     if any(
         keyword in problem_context.lower()
         for keyword in ("complex", "refactor", "cleanup")
@@ -197,7 +204,9 @@ def _add_complexity_patterns(pattern_suggestions: dict, problem_context: str) ->
         )
 
 
-def _add_dry_patterns(pattern_suggestions: dict, problem_context: str) -> None:
+def _add_dry_patterns(
+    pattern_suggestions: dict[str, t.Any], problem_context: str
+) -> None:
     if any(
         keyword in problem_context.lower() for keyword in ("duplicate", "repeat", "dry")
     ):
@@ -225,7 +234,9 @@ def _add_dry_patterns(pattern_suggestions: dict, problem_context: str) -> None:
         )
 
 
-def _add_performance_patterns(pattern_suggestions: dict, problem_context: str) -> None:
+def _add_performance_patterns(
+    pattern_suggestions: dict[str, t.Any], problem_context: str
+) -> None:
     if any(
         keyword in problem_context.lower()
         for keyword in ("slow", "performance", "optimize")
@@ -234,7 +245,7 @@ def _add_performance_patterns(pattern_suggestions: dict, problem_context: str) -
             [
                 {
                     "pattern": "list_comprehension",
-                    "description": "Use list comprehensions instead of manual loops",
+                    "description": "Use list[t.Any] comprehensions instead of manual loops",
                     "benefits": [
                         "Better performance",
                         "More readable",
@@ -254,7 +265,9 @@ def _add_performance_patterns(pattern_suggestions: dict, problem_context: str) -
         )
 
 
-def _add_security_patterns(pattern_suggestions: dict, problem_context: str) -> None:
+def _add_security_patterns(
+    pattern_suggestions: dict[str, t.Any], problem_context: str
+) -> None:
     if any(
         keyword in problem_context.lower() for keyword in ("security", "safe", "secure")
     ):
@@ -314,7 +327,7 @@ def _register_plan_development_tool(mcp_app: t.Any) -> None:
         import json
 
         try:
-            parsed_kwargs = json.loads(kwargs) if kwargs else {}
+            parsed_kwargs: dict[str, t.Any] = json.loads(kwargs) if kwargs else {}
             assessment = _create_architectural_assessment(args, parsed_kwargs)
             return json.dumps(assessment, indent=2)
         except Exception as e:
@@ -327,7 +340,7 @@ def _register_validate_architecture_tool(mcp_app: t.Any) -> None:
         import json
 
         try:
-            parsed_kwargs = json.loads(kwargs) if kwargs else {}
+            parsed_kwargs: dict[str, t.Any] = json.loads(kwargs) if kwargs else {}
             file_path = args or parsed_kwargs.get("file_path", "")
             validation = _create_validation_results(file_path)
             return json.dumps(validation, indent=2)

crackerjack/mcp/tools/progress_tools.py

@@ -10,23 +10,20 @@ from crackerjack.services.input_validator import get_input_validator
 def _create_progress_file(job_id: str) -> Path:
     import tempfile
 
-    # Use secure input validation
     job_id_result = get_input_validator().validate_job_id(job_id)
 
     if not job_id_result.valid:
         msg = f"Invalid job_id: {job_id_result.error_message}"
         raise ValueError(msg)
 
-    # Use sanitized job ID
     sanitized_job_id = job_id_result.sanitized_value
 
     context = get_context()
     if context:
         return context.progress_dir / f"job-{sanitized_job_id}.json"
 
-    # Create secure temporary directory
     progress_dir = Path(tempfile.gettempdir()) / "crackerjack-mcp-progress"
-    progress_dir.mkdir(exist_ok=True, mode=0o750)  # Restrictive permissions
+    progress_dir.mkdir(exist_ok=True, mode=0o750)
     return progress_dir / f"job-{sanitized_job_id}.json"
 
 
@@ -99,10 +96,10 @@ def _notify_websocket(final_progress_data: dict[str, t.Any]) -> None:
 
 def _update_progress(
     job_id: str,
-    progress_data: dict[str, t.Any] | str = None,
+    progress_data: dict[str, t.Any] | str | None = None,
     context: t.Any = None,
     iteration: int = 1,
-    max_iterations: int = 10,
+    max_iterations: int = 5,
     overall_progress: int = 0,
     current_stage: str = "initialization",
     stage_progress: int = 0,
@@ -167,10 +164,10 @@ def _handle_get_job_progress(job_id: str) -> str:
 
 
 async def _execute_session_action(
-    state_manager,
+    state_manager: t.Any,
     action: str,
     checkpoint_name: str | None,
-    context,
+    context: t.Any,
 ) -> str:
     if action == "start":
         state_manager.start_session()

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