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

crackerjack/mcp/tools/execution_tools_backup.py

@@ -85,7 +85,7 @@ async def _validate_context_and_rate_limit(context: t.Any) -> str | None:
     return None
 
 
-def _handle_task_exception(job_id: str, task: asyncio.Task) -> None:
+def _handle_task_exception(job_id: str, task: asyncio.Task[t.Any]) -> None:
     import tempfile
     from pathlib import Path
 
@@ -405,10 +405,9 @@ def _create_workflow_options(kwargs: dict[str, t.Any]) -> t.Any:
 
     options = WorkflowOptions()
     options.testing.test = kwargs.get("test", True)
-    options.ai_agent = kwargs.get("ai_agent", True)
-    options.skip_hooks = kwargs.get("skip_hooks", False)
+    options.ai.ai_agent = kwargs.get("ai_agent", True)
+    options.hooks.skip_hooks = kwargs.get("skip_hooks", False)
 
-    options.proactive_mode = kwargs.get("proactive_mode", True)
     return options
 
 
@@ -418,8 +417,10 @@ async def _execute_single_iteration(
     options: t.Any,
 ) -> bool:
     if use_advanced_orchestrator:
-        return await orchestrator.execute_orchestrated_workflow(options)
-    return await orchestrator.run_complete_workflow(options)
+        result = await orchestrator.execute_orchestrated_workflow(options)
+        return bool(result)
+    result = await orchestrator.run_complete_workflow(options)
+    return bool(result)
 
 
 def _create_success_result(
@@ -715,6 +716,8 @@ def _register_init_crackerjack_tool(mcp_app: t.Any) -> None:
 
         try:
             results = _execute_initialization(context, target_path, force)
+            if isinstance(results, bool):
+                return json.dumps({"success": results})
             return _create_init_success_response(results, target_path, force)
         except Exception as e:
             return _create_init_exception_response(e, target_path)
@@ -730,18 +733,20 @@ def _parse_init_arguments(args: str, kwargs: str) -> tuple[t.Any, bool, str | No
     target_path = args.strip() or None
 
     try:
-        extra_kwargs = json.loads(kwargs) if kwargs.strip() else {}
+        extra_kwargs: dict[str, t.Any] = json.loads(kwargs) if kwargs.strip() else {}
     except json.JSONDecodeError as e:
         return None, False, _create_init_error_response(f"Invalid JSON in kwargs: {e}")
 
     force = extra_kwargs.get("force", False)
 
     if target_path:
-        target_path = Path(target_path).resolve()
+        target_path_obj = Path(target_path).resolve()
+        target_path = str(target_path_obj)
     else:
-        target_path = Path.cwd()
+        target_path_obj = Path.cwd()
+        target_path = str(target_path_obj)
 
-    if not target_path.exists():
+    if not Path(target_path).exists():
         return (
             None,
             False,
@@ -751,9 +756,7 @@ def _parse_init_arguments(args: str, kwargs: str) -> tuple[t.Any, bool, str | No
     return target_path, force, None
 
 
-def _execute_initialization(
-    context: t.Any, target_path: t.Any, force: bool
-) -> dict[str, t.Any]:
+def _execute_initialization(context: t.Any, target_path: t.Any, force: bool) -> bool:
     from crackerjack.services.filesystem import FileSystemService
     from crackerjack.services.git import GitService
     from crackerjack.services.initialization import InitializationService
@@ -792,15 +795,24 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
         project_type: str = "python",
         current_context: str = "",
     ) -> str:
-        suggestions = {
-            "primary_agents": [],
-            "task_specific_agents": [],
-            "usage_patterns": [],
+        suggestions: dict[str, list[dict[str, str]] | list[str] | str] = {
+            "primary_agents": t.cast(list[dict[str, str]], []),
+            "task_specific_agents": t.cast(list[dict[str, str]], []),
+            "usage_patterns": t.cast(list[str], []),
             "rationale": "",
         }
 
+        # Type cast the lists to ensure proper typing
+        primary_agents: list[dict[str, str]] = t.cast(
+            list[dict[str, str]], suggestions["primary_agents"]
+        )
+        task_specific_agents: list[dict[str, str]] = t.cast(
+            list[dict[str, str]], suggestions["task_specific_agents"]
+        )
+        t.cast(list[str], suggestions["usage_patterns"])
+
         if project_type.lower() == "python" or "python" in task_description.lower():
-            suggestions["primary_agents"].append(
+            primary_agents.append(
                 {
                     "name": "crackerjack-architect",
                     "emoji": "🏗️",
@@ -810,11 +822,11 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
                 }
             )
 
-            suggestions["primary_agents"].append(
+            primary_agents.append(
                 {
                     "name": "python-pro",
                     "emoji": "🐍",
-                    "description": "Modern Python development with type hints, async / await patterns, and clean architecture",
+                    "description": "Modern Python development with type hints, async/await patterns, and clean architecture",
                     "usage": "Use for implementing Python code with best practices",
                     "priority": "HIGH",
                 }
@@ -827,9 +839,9 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
             word in task_lower + context_lower
             for word in ("test", "testing", "coverage", "pytest")
         ):
-            suggestions["task_specific_agents"].append(
+            task_specific_agents.append(
                 {
-                    "name": "crackerjack - test-specialist",
+                    "name": "crackerjack-test-specialist",
                     "emoji": "🧪",
                     "description": "Advanced testing specialist for complex scenarios and coverage optimization",
                     "usage": "Use for test creation, debugging test failures, and coverage improvements",
@@ -837,9 +849,9 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
                 }
             )
 
-            suggestions["task_specific_agents"].append(
+            task_specific_agents.append(
                 {
-                    "name": "pytest - hypothesis-specialist",
+                    "name": "pytest-hypothesis-specialist",
                     "emoji": "🧪",
                     "description": "Advanced testing patterns and property-based testing",
                     "usage": "Use for comprehensive test development and optimization",
@@ -851,12 +863,12 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
             word in task_lower + context_lower
             for word in ("security", "vulnerability", "auth", "permission")
         ):
-            suggestions["task_specific_agents"].append(
+            task_specific_agents.append(
                 {
                     "name": "security-auditor",
                     "emoji": "🔒",
-                    "description": "Security analysis, vulnerability detection, and secure coding practices",
-                    "usage": "Use for security review and vulnerability assessment",
+                    "description": "Security auditing and vulnerability detection specialist",
+                    "usage": "Use for identifying and mitigating security vulnerabilities",
                     "priority": "HIGH",
                 }
             )
@@ -865,12 +877,12 @@ def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
             word in task_lower + context_lower
             for word in ("architecture", "design", "api", "backend")
         ):
-            suggestions["task_specific_agents"].append(
+            task_specific_agents.append(
                 {
                     "name": "backend-architect",
                     "emoji": "🏗️",
-                    "description": "System design, API architecture, and service integration patterns",
-                    "usage": "Use for architectural planning and system design",
+                    "description": "Backend architecture and system design specialist",
+                    "usage": "Use for complex backend design decisions and system architecture",
                     "priority": "MEDIUM",
                 }
             )

crackerjack/mcp/tools/intelligence_tool_registry.py

@@ -1,3 +1,5 @@
+import typing as t
+
 from .intelligence_tools import (
     analyze_agent_performance,
     execute_smart_agent_task,
@@ -6,7 +8,7 @@ from .intelligence_tools import (
 )
 
 
-def register_intelligence_tools(mcp_app) -> None:
+def register_intelligence_tools(mcp_app: t.Any) -> None:
     @mcp_app.tool()
     async def execute_smart_task(
         task_description: str,
@@ -14,7 +16,7 @@ def register_intelligence_tools(mcp_app) -> None:
         strategy: str = "single_best",
         max_agents: int = 3,
         use_learning: bool = True,
-    ):
+    ) -> t.Any:
         return await execute_smart_agent_task(
             task_description,
             context_type,
@@ -28,7 +30,7 @@ def register_intelligence_tools(mcp_app) -> None:
         task_description: str,
         context_type: str = "general",
         include_analysis: bool = True,
-    ):
+    ) -> t.Any:
         return await get_smart_agent_recommendation(
             task_description,
             context_type,
@@ -36,9 +38,9 @@ def register_intelligence_tools(mcp_app) -> None:
         )
 
     @mcp_app.tool()
-    async def intelligence_system_status():
+    async def intelligence_system_status() -> t.Any:
         return await get_intelligence_system_status()
 
     @mcp_app.tool()
-    async def agent_performance_analysis():
+    async def agent_performance_analysis() -> t.Any:
         return await analyze_agent_performance()

crackerjack/mcp/tools/intelligence_tools.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import logging
 import typing as t
 
@@ -173,10 +174,12 @@ async def get_smart_agent_recommendation(
         if include_analysis:
             try:
                 analysis = await system.analyze_task_complexity(task_description)
-                response["complexity_analysis"] = analysis
+                response["complexity_analysis"] = json.dumps(analysis, indent=2)
             except Exception as e:
                 logger.warning(f"Failed to analyze task complexity: {e}")
-                response["complexity_analysis"] = {"error": str(e)}
+                response["complexity_analysis"] = json.dumps(
+                    {"error": str(e)}, indent=2
+                )
 
         logger.debug(f"Generated recommendation for task: {task_description[:50]}...")
         return response

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)