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

crackerjack/mcp/tools/monitoring_tools.py

@@ -29,7 +29,7 @@ from crackerjack.services.websocket_resource_limiter import (
 )
 
 
-def _suggest_agent_for_context(state_manager) -> dict[str, t.Any]:
+def _suggest_agent_for_context(state_manager: t.Any) -> dict[str, t.Any]:
     suggestions = {
         "recommended_agent": None,
         "reason": "",
@@ -95,12 +95,12 @@ def _create_error_response(message: str, success: bool = False) -> str:
     return json.dumps({"error": message, "success": success})
 
 
-def _get_stage_status_dict(state_manager) -> dict[str, str]:
+def _get_stage_status_dict(state_manager: t.Any) -> dict[str, str]:
     stages = ["fast", "comprehensive", "tests", "cleaning"]
     return {stage: state_manager.get_stage_status(stage) for stage in stages}
 
 
-def _get_session_info(state_manager) -> dict[str, t.Any]:
+def _get_session_info(state_manager: t.Any) -> dict[str, t.Any]:
     return {
         "total_iterations": getattr(state_manager, "iteration_count", 0),
         "current_iteration": getattr(state_manager, "current_iteration", 0),
@@ -108,7 +108,7 @@ def _get_session_info(state_manager) -> dict[str, t.Any]:
     }
 
 
-def _determine_next_action(state_manager) -> dict[str, t.Any]:
+async def _determine_next_action(state_manager: t.Any) -> dict[str, t.Any]:
     stage_priorities = [
         ("fast", "Fast hooks not completed"),
         ("tests", "Tests not completed"),
@@ -130,7 +130,7 @@ def _determine_next_action(state_manager) -> dict[str, t.Any]:
     }
 
 
-def _build_server_stats(context) -> dict[str, t.Any]:
+async def _build_server_stats(context: t.Any) -> dict[str, t.Any]:
     return {
         "server_info": {
             "project_path": str(context.config.project_path),
@@ -145,7 +145,7 @@ def _build_server_stats(context) -> dict[str, t.Any]:
             else None,
         },
         "resource_usage": {
-            "temp_files_count": len(list(context.progress_dir.glob("*.json")))
+            "temp_files_count": len(list[t.Any](context.progress_dir.glob("*.json")))
             if context.progress_dir.exists()
             else 0,
             "progress_dir": str(context.progress_dir),
@@ -154,7 +154,7 @@ def _build_server_stats(context) -> dict[str, t.Any]:
     }
 
 
-def _add_state_manager_stats(stats: dict, state_manager) -> None:
+def _add_state_manager_stats(stats: dict[str, t.Any], state_manager: t.Any) -> None:
     if state_manager:
         stats["state_manager"] = {
             "iteration_count": getattr(state_manager, "iteration_count", 0),
@@ -163,8 +163,8 @@ def _add_state_manager_stats(stats: dict, state_manager) -> None:
         }
 
 
-def _get_active_jobs(context) -> list[dict[str, t.Any]]:
-    jobs = []
+def _get_active_jobs(context: t.Any) -> list[dict[str, t.Any]]:
+    jobs: list[dict[str, t.Any]] = []
     if not context.progress_dir.exists():
         return jobs
 
@@ -198,16 +198,12 @@ async def _get_comprehensive_status_secure(
     auth_header: str | None = None,
     verbosity: StatusVerbosity = StatusVerbosity.STANDARD,
 ) -> dict[str, t.Any]:
-    """Get comprehensive status with full security integration."""
-
-    # 1. Authentication
     auth_manager = get_status_authenticator()
     try:
         credentials = await authenticate_status_request(
             auth_header, client_ip, "get_comprehensive_status"
         )
 
-        # Check if operation is allowed for this auth level
         if not auth_manager.is_operation_allowed(
             "get_comprehensive_status", credentials.access_level
         ):
@@ -216,21 +212,20 @@ async def _get_comprehensive_status_secure(
     except Exception as e:
         return {"error": f"Authentication failed: {e}"}
 
-    # 2. Security validation
     try:
         await validate_status_request(client_id, "get_comprehensive_status", {})
     except Exception as e:
         return {"error": f"Security validation failed: {e}"}
 
-    # 3. Resource management with bounded operations
     try:
-        return await execute_bounded_status_operation(
+        result: dict[str, t.Any] = await execute_bounded_status_operation(
             "status_collection",
             client_id,
             _collect_comprehensive_status_internal,
             client_id,
             verbosity,
         )
+        return result
     except Exception as e:
         return {"error": f"Resource limit exceeded: {e}"}
 
@@ -239,18 +234,13 @@ async def _collect_comprehensive_status_internal(
     client_id: str = "mcp_client",
     verbosity: StatusVerbosity = StatusVerbosity.STANDARD,
 ) -> dict[str, t.Any]:
-    """Internal comprehensive status collection using thread-safe collector."""
-
-    # Use thread-safe status collector
     collector = get_thread_safe_status_collector()
 
     try:
-        # Collect status with thread safety and proper timeout handling
         snapshot = await collector.collect_comprehensive_status(
             client_id=client_id,
         )
 
-        # Build final status from snapshot
         status = {
             "services": snapshot.services,
             "jobs": snapshot.jobs,
@@ -263,7 +253,6 @@ async def _collect_comprehensive_status_internal(
             },
         }
 
-        # Add agent suggestions if available
         context = None
         with suppress(RuntimeError):
             context = get_context()
@@ -280,7 +269,6 @@ async def _collect_comprehensive_status_internal(
 
 
 async def _get_comprehensive_status() -> dict[str, t.Any]:
-    """Legacy wrapper for backward compatibility."""
     return await _get_comprehensive_status_secure()
 
 
@@ -294,12 +282,11 @@ def register_monitoring_tools(mcp_app: t.Any) -> None:
 
 
 def _register_stage_status_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]  # type: ignore[misc]
     async def get_stage_status() -> str:
         client_id = "mcp_client"
 
         try:
-            # Security validation
             await validate_status_request(client_id, "get_stage_status", {})
 
             context = get_context()
@@ -310,7 +297,6 @@ def _register_stage_status_tool(mcp_app: t.Any) -> None:
             if not state_manager:
                 return _create_error_response("State manager not available")
 
-            # Use bounded operation for resource protection
             result = await execute_bounded_status_operation(
                 "stage_status",
                 client_id,
@@ -324,8 +310,7 @@ def _register_stage_status_tool(mcp_app: t.Any) -> None:
             return f'{{"error": "Failed to get stage status: {e}"}}'
 
 
-def _build_stage_status(state_manager) -> dict[str, t.Any]:
-    """Build stage status with bounded resource usage."""
+async def _build_stage_status(state_manager: t.Any) -> dict[str, t.Any]:
     return {
         "stages": _get_stage_status_dict(state_manager),
         "session": _get_session_info(state_manager),
@@ -334,12 +319,11 @@ def _build_stage_status(state_manager) -> dict[str, t.Any]:
 
 
 def _register_next_action_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]  # type: ignore[misc]
     async def get_next_action() -> str:
         client_id = "mcp_client"
 
         try:
-            # Security validation
             await validate_status_request(client_id, "get_next_action", {})
 
             context = get_context()
@@ -350,7 +334,6 @@ def _register_next_action_tool(mcp_app: t.Any) -> None:
             if not state_manager:
                 return '{"recommended_action": "initialize", "reason": "No state manager available"}'
 
-            # Use bounded operation for consistency
             action = await execute_bounded_status_operation(
                 "next_action",
                 client_id,
@@ -365,19 +348,16 @@ def _register_next_action_tool(mcp_app: t.Any) -> None:
 
 
 def _register_server_stats_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]  # type: ignore[misc]
     async def get_server_stats() -> str:
         client_id = "mcp_client"
 
         try:
-            # Security validation
             await validate_status_request(client_id, "get_server_stats", {})
 
-            # Use secure status operation with resource limits
             async with await secure_status_operation(
                 client_id, "get_server_stats", timeout=15.0
             ):
-                # Get context
                 context = get_context()
                 if not context:
                     formatter = get_secure_status_formatter()
@@ -386,7 +366,6 @@ def _register_server_stats_tool(mcp_app: t.Any) -> None:
                     )
                     return json.dumps(error_response, indent=2)
 
-                # Get raw stats with bounded operation
                 raw_stats = await execute_bounded_status_operation(
                     "server_stats",
                     client_id,
@@ -394,7 +373,6 @@ def _register_server_stats_tool(mcp_app: t.Any) -> None:
                     context,
                 )
 
-                # Apply secure formatting
                 secure_stats = format_secure_status(
                     raw_stats,
                     project_root=context.config.project_path,
@@ -404,7 +382,6 @@ def _register_server_stats_tool(mcp_app: t.Any) -> None:
                 return json.dumps(secure_stats, indent=2)
 
         except Exception as e:
-            # Use secure error formatting
             formatter = get_secure_status_formatter()
             error_response = formatter.format_error_response(
                 str(e),
@@ -412,23 +389,16 @@ def _register_server_stats_tool(mcp_app: t.Any) -> None:
             return json.dumps(error_response, indent=2)
 
 
-def _build_server_stats_secure(context) -> dict[str, t.Any]:
-    """Build server stats with security controls."""
-
-    # Build base stats
-    stats = _build_server_stats(context)
+async def _build_server_stats_secure(context: t.Any) -> dict[str, t.Any]:
+    stats = await _build_server_stats(context)
 
-    # Add state manager stats
     state_manager = getattr(context, "state_manager", None)
     _add_state_manager_stats(stats, state_manager)
 
-    # Add security status
     security_manager = get_status_security_manager()
     stats["security_status"] = security_manager.get_security_status()
 
-    # Add resource limiter status if available
     with suppress(Exception):
-        # Resource limiter may not be initialized
         resource_limiter = get_websocket_resource_limiter()
         stats["websocket_resources"] = resource_limiter.get_resource_status()
 
@@ -436,25 +406,21 @@ def _build_server_stats_secure(context) -> dict[str, t.Any]:
 
 
 def _register_comprehensive_status_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def get_comprehensive_status() -> str:
         client_id = "mcp_client"
         client_ip = "127.0.0.1"
 
         try:
-            # Use secure status operation with request lock
             async with await secure_status_operation(
                 client_id,
                 "get_comprehensive_status",
             ):
-                # Get raw status data with full security integration
                 raw_status = await _get_comprehensive_status_secure(
                     client_id=client_id,
                     client_ip=client_ip,
-                    # Local-only access (auth_header defaults to None)
                 )
 
-                # Apply secure formatting
                 context = get_context()
                 project_root = context.config.project_path if context else None
 
@@ -467,7 +433,6 @@ def _register_comprehensive_status_tool(mcp_app: t.Any) -> None:
                 return json.dumps(secure_status, indent=2)
 
         except Exception as e:
-            # Use secure error formatting
             formatter = get_secure_status_formatter()
             error_response = formatter.format_error_response(
                 str(e),
@@ -476,7 +441,7 @@ def _register_comprehensive_status_tool(mcp_app: t.Any) -> None:
 
 
 def _register_command_help_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def list_slash_commands() -> str:
         try:
             commands = {
@@ -520,7 +485,7 @@ def _register_command_help_tool(mcp_app: t.Any) -> None:
 
             return json.dumps(
                 {
-                    "available_commands": list(commands.keys()),
+                    "available_commands": list[t.Any](commands.keys()),
                     "command_details": commands,
                     "total_commands": len(commands),
                 },
@@ -529,7 +494,10 @@ def _register_command_help_tool(mcp_app: t.Any) -> None:
 
         except Exception as e:
             return json.dumps(
-                {"error": f"Failed to list slash commands: {e}", "success": False},
+                {
+                    "error": f"Failed to list[t.Any] slash commands: {e}",
+                    "success": False,
+                },
                 indent=2,
             )
 
@@ -545,7 +513,7 @@ def _validate_status_components(components: str) -> tuple[set[str], str | None]:
     return requested, None
 
 
-def _get_services_status() -> dict:
+def _get_services_status() -> dict[str, t.Any]:
     from crackerjack.services.server_manager import (
         find_mcp_server_processes,
         find_websocket_server_processes,
@@ -566,9 +534,9 @@ def _get_services_status() -> dict:
     }
 
 
-def _get_resources_status(context: t.Any) -> dict:
+def _get_resources_status(context: t.Any) -> dict[str, t.Any]:
     temp_files_count = (
-        len(list(context.progress_dir.glob("*.json")))
+        len(list[t.Any](context.progress_dir.glob("*.json")))
         if context.progress_dir.exists()
         else 0
     )
@@ -579,8 +547,10 @@ def _get_resources_status(context: t.Any) -> dict:
     }
 
 
-def _build_filtered_status(requested: set[str], context: t.Any) -> dict:
-    filtered_status = {"timestamp": time.time()}
+async def _build_filtered_status(
+    requested: set[str], context: t.Any
+) -> dict[str, t.Any]:
+    filtered_status: dict[str, t.Any] = {"timestamp": time.time()}
 
     if "services" in requested:
         filtered_status["services"] = _get_services_status()
@@ -595,12 +565,11 @@ def _build_filtered_status(requested: set[str], context: t.Any) -> dict:
 
 
 def _register_filtered_status_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def get_filtered_status(components: str = "all") -> str:
         client_id = "mcp_client"
 
         try:
-            # Security validation with component filter data
             await validate_status_request(
                 client_id, "get_filtered_status", {"components": components}
             )
@@ -612,12 +581,10 @@ def _register_filtered_status_tool(mcp_app: t.Any) -> None:
 
 
 async def _process_filtered_status_request(client_id: str, components: str) -> str:
-    """Process filtered status request with component validation."""
     requested, error = _validate_status_components(components)
     if error:
         return _format_status_error(error)
 
-    # Use secure status operation with timeout
     async with await secure_status_operation(
         client_id, "get_filtered_status", timeout=20.0
     ):
@@ -625,7 +592,6 @@ async def _process_filtered_status_request(client_id: str, components: str) -> s
 
 
 async def _collect_status_data(client_id: str, requested: set[str]) -> str:
-    """Collect status data based on requested components."""
     context = get_context()
 
     if "all" in requested:
@@ -636,7 +602,6 @@ async def _collect_status_data(client_id: str, requested: set[str]) -> str:
         if not context:
             return _format_status_error("Server context not available")
 
-        # Use bounded operation for filtered status
         raw_status = await execute_bounded_status_operation(
             "filtered_status",
             client_id,
@@ -648,8 +613,7 @@ async def _collect_status_data(client_id: str, requested: set[str]) -> str:
     return _apply_secure_formatting(raw_status, context)
 
 
-def _apply_secure_formatting(raw_status: dict, context: t.Any) -> str:
-    """Apply secure formatting to status data."""
+def _apply_secure_formatting(raw_status: dict[str, t.Any], context: t.Any) -> str:
     project_root = context.config.project_path if context else None
     secure_status = format_secure_status(
         raw_status,
@@ -660,6 +624,5 @@ def _apply_secure_formatting(raw_status: dict, context: t.Any) -> str:
 
 
 def _format_status_error(error_message: str) -> str:
-    """Format status error response consistently."""
     formatter = get_secure_status_formatter()
     return json.dumps(formatter.format_error_response(error_message), indent=2)

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()