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

crackerjack/mcp/tools/core_tools.py

@@ -1,10 +1,16 @@
 import typing as t
 
-from crackerjack.mcp.context import get_context
+from crackerjack.mcp.context import MCPServerContext, get_context
+from crackerjack.mcp.rate_limiter import RateLimitMiddleware
 from crackerjack.services.input_validator import (
+    SecureInputValidator,
     get_input_validator,
 )
 
+if t.TYPE_CHECKING:
+    from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+    from crackerjack.models.config import WorkflowOptions
+
 
 async def create_task_with_subagent(
     description: str,
@@ -12,10 +18,8 @@ async def create_task_with_subagent(
     subagent_type: str,
 ) -> dict[str, t.Any]:
     try:
-        # Input validation with security checks
         validator = get_input_validator()
 
-        # Validate description
         desc_result = validator.validate_command_args(description)
         if not desc_result.valid:
             return {
@@ -24,7 +28,6 @@ async def create_task_with_subagent(
                 "validation_type": desc_result.validation_type,
             }
 
-        # Validate prompt
         prompt_result = validator.validate_command_args(prompt)
         if not prompt_result.valid:
             return {
@@ -33,7 +36,6 @@ async def create_task_with_subagent(
                 "validation_type": prompt_result.validation_type,
             }
 
-        # Validate subagent_type (should be safe identifier)
         subagent_result = validator.sanitizer.sanitize_string(
             subagent_type, max_length=100, strict_alphanumeric=True
         )
@@ -44,7 +46,6 @@ async def create_task_with_subagent(
                 "validation_type": subagent_result.validation_type,
             }
 
-        # Use sanitized values
         sanitized_description = desc_result.sanitized_value or description
         sanitized_prompt = prompt_result.sanitized_value or prompt
         sanitized_subagent = subagent_result.sanitized_value
@@ -72,7 +73,9 @@ async def create_task_with_subagent(
         }
 
 
-async def _validate_stage_request(context, rate_limiter) -> str | None:
+async def _validate_stage_request(
+    context: MCPServerContext | None, rate_limiter: RateLimitMiddleware | None
+) -> str | None:
     if not context:
         return '{"error": "Server context not available", "success": false}'
 
@@ -83,17 +86,15 @@ async def _validate_stage_request(context, rate_limiter) -> str | None:
     return None
 
 
-def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict] | str:
+def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict[str, t.Any]] | str:
     try:
         validator = get_input_validator()
 
-        # Validate stage argument
         stage_validation = _validate_stage_argument(validator, args)
         if isinstance(stage_validation, str):
             return stage_validation
         stage = stage_validation
 
-        # Validate and parse kwargs
         kwargs_validation = _validate_kwargs_argument(validator, kwargs)
         if isinstance(kwargs_validation, str):
             return kwargs_validation
@@ -105,15 +106,14 @@ def _parse_stage_args(args: str, kwargs: str) -> tuple[str, dict] | str:
         return f'{{"error": "Stage argument parsing failed: {e}", "success": false}}'
 
 
-def _validate_stage_argument(validator, args: str) -> str:
-    """Validate and sanitize the stage argument."""
+def _validate_stage_argument(validator: SecureInputValidator, args: str) -> str:
     stage_result = validator.sanitizer.sanitize_string(
         args.strip(), max_length=50, strict_alphanumeric=True
     )
     if not stage_result.valid:
         return f'{{"error": "Invalid stage argument: {stage_result.error_message}", "success": false}}'
 
-    stage = stage_result.sanitized_value.lower()
+    stage: str = str(stage_result.sanitized_value).lower()
     valid_stages = {"fast", "comprehensive", "tests", "cleaning", "init"}
 
     if stage not in valid_stages:
@@ -122,9 +122,10 @@ def _validate_stage_argument(validator, args: str) -> str:
     return stage
 
 
-def _validate_kwargs_argument(validator, kwargs: str) -> dict | str:
-    """Validate and parse the kwargs argument."""
-    extra_kwargs = {}
+def _validate_kwargs_argument(
+    validator: SecureInputValidator, kwargs: str
+) -> dict[str, t.Any] | str:
+    extra_kwargs: dict[str, t.Any] = {}
     if not kwargs.strip():
         return extra_kwargs
 
@@ -134,7 +135,6 @@ def _validate_kwargs_argument(validator, kwargs: str) -> dict | str:
 
     extra_kwargs = kwargs_result.sanitized_value
 
-    # Additional validation on JSON structure
     if not isinstance(extra_kwargs, dict):
         return f'{{"error": "kwargs must be a JSON object, got {type(extra_kwargs).__name__}", "success": false}}'
 
@@ -146,31 +146,171 @@ def _configure_stage_options(stage: str) -> "WorkflowOptions":
 
     options = WorkflowOptions()
     if stage in {"fast", "comprehensive"}:
-        options.skip_hooks = False
+        options.hooks.skip_hooks = False
     elif stage == "tests":
         options.testing.test = True
     elif stage == "cleaning":
         options.cleaning.clean = True
     elif stage == "init":
-        options.skip_hooks = True
+        options.hooks.skip_hooks = True
     return options
 
 
-def _execute_stage(orchestrator, stage: str, options) -> bool:
+def _execute_stage(
+    orchestrator: "WorkflowOrchestrator", stage: str, options: "WorkflowOptions"
+) -> bool:
+    # Convert WorkflowOptions to OptionsProtocol
+    adapted_options = _adapt_workflow_options_to_protocol(options)
+
     if stage == "fast":
-        return orchestrator.run_fast_hooks_only(options)
+        return orchestrator.run_fast_hooks_only(adapted_options)
     if stage == "comprehensive":
-        return orchestrator.run_comprehensive_hooks_only(options)
+        return orchestrator.run_comprehensive_hooks_only(adapted_options)
     if stage == "tests":
-        return orchestrator.run_testing_phase(options)
+        return orchestrator.run_testing_phase(adapted_options)
     if stage == "cleaning":
-        return orchestrator.run_cleaning_phase(options)
-    if stage == "init":
-        return _execute_init_stage(orchestrator)
+        return orchestrator.run_cleaning_phase(adapted_options)
     return False
 
 
-def _execute_init_stage(orchestrator) -> bool:
+def _adapt_workflow_options_to_protocol(options: "WorkflowOptions") -> t.Any:
+    """Adapt WorkflowOptions to match OptionsProtocol."""
+    return _AdaptedOptions(options)  # type: ignore
+
+
+class _AdaptedOptions:
+    """Adapter class to convert WorkflowOptions to OptionsProtocol."""
+
+    def __init__(self, opts: "WorkflowOptions"):
+        self.opts = opts
+
+    # Git properties
+    @property
+    def commit(self) -> bool:
+        return getattr(self.opts.git, "commit", False)
+
+    @property
+    def create_pr(self) -> bool:
+        return getattr(self.opts.git, "create_pr", False)
+
+    # Execution properties
+    @property
+    def interactive(self) -> bool:
+        return getattr(self.opts.execution, "interactive", False)
+
+    @property
+    def no_config_updates(self) -> bool:
+        return getattr(self.opts.execution, "no_config_updates", False)
+
+    @property
+    def verbose(self) -> bool:
+        return getattr(self.opts.execution, "verbose", False)
+
+    @property
+    def async_mode(self) -> bool:
+        return getattr(self.opts.execution, "async_mode", False)
+
+    # Testing properties
+    @property
+    def test(self) -> bool:
+        return getattr(self.opts.testing, "test", False)
+
+    @property
+    def benchmark(self) -> bool:
+        return getattr(self.opts.testing, "benchmark", False)
+
+    @property
+    def test_workers(self) -> int:
+        return getattr(self.opts.testing, "test_workers", 0)
+
+    @property
+    def test_timeout(self) -> int:
+        return getattr(self.opts.testing, "test_timeout", 0)
+
+    # Publishing properties
+    @property
+    def publish(self) -> t.Any | None:
+        return getattr(self.opts.publishing, "publish", None)
+
+    @property
+    def bump(self) -> t.Any | None:
+        return getattr(self.opts.publishing, "bump", None)
+
+    @property
+    def all(self) -> t.Any | None:
+        return getattr(self.opts.publishing, "all", None)
+
+    @property
+    def no_git_tags(self) -> bool:
+        return getattr(self.opts.publishing, "no_git_tags", False)
+
+    @property
+    def skip_version_check(self) -> bool:
+        return getattr(self.opts.publishing, "skip_version_check", False)
+
+    # AI properties
+    @property
+    def ai_agent(self) -> bool:
+        return getattr(self.opts.ai, "ai_agent", False)
+
+    @property
+    def start_mcp_server(self) -> bool:
+        return getattr(self.opts.ai, "start_mcp_server", False)
+
+    # Hook properties
+    @property
+    def skip_hooks(self) -> bool:
+        return getattr(self.opts.hooks, "skip_hooks", False)
+
+    @property
+    def update_precommit(self) -> bool:
+        return getattr(self.opts.hooks, "update_precommit", False)
+
+    @property
+    def experimental_hooks(self) -> bool:
+        return getattr(self.opts.hooks, "experimental_hooks", False)
+
+    @property
+    def enable_pyrefly(self) -> bool:
+        return getattr(self.opts.hooks, "enable_pyrefly", False)
+
+    @property
+    def enable_ty(self) -> bool:
+        return getattr(self.opts.hooks, "enable_ty", False)
+
+    # Cleaning properties
+    @property
+    def clean(self) -> bool:
+        return getattr(self.opts.cleaning, "clean", False)
+
+    # Progress properties
+    @property
+    def track_progress(self) -> bool:
+        return getattr(self.opts.progress, "track_progress", False)
+
+    # Default/static properties
+    @property
+    def cleanup(self) -> t.Any | None:
+        return None
+
+    @property
+    def cleanup_pypi(self) -> bool:
+        return False
+
+    @property
+    def coverage(self) -> bool:
+        return False
+
+    @property
+    def keep_releases(self) -> int:
+        return 10
+
+    @property
+    def fast(self) -> bool:
+        return False
+
+
+def _execute_init_stage(orchestrator: "WorkflowOrchestrator") -> bool:
     try:
         from pathlib import Path
 
@@ -188,7 +328,8 @@ def _execute_init_stage(orchestrator) -> bool:
 
         results = init_service.initialize_project_full(target_path=Path.cwd())
 
-        return results.get("success", False)
+        success_result: bool = bool(results.get("success", False))
+        return success_result
 
     except Exception as e:
         if hasattr(orchestrator, "console"):
@@ -197,7 +338,7 @@ def _execute_init_stage(orchestrator) -> bool:
 
 
 def register_core_tools(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def run_crackerjack_stage(args: str, kwargs: str) -> str:
         context = get_context()
         rate_limiter = context.rate_limiter if context else None
@@ -258,8 +399,8 @@ def _detect_errors_and_suggestions(
 ) -> tuple[list[str], list[str]]:
     import re
 
-    detected_errors = []
-    suggestions = []
+    detected_errors: list[str] = []
+    suggestions: list[str] = []
 
     for error_type, pattern in _get_error_patterns():
         if re.search(pattern, text, re.IGNORECASE):
@@ -271,7 +412,7 @@ def _detect_errors_and_suggestions(
 
 
 def register_analyze_errors_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def analyze_errors(output: str = "", include_suggestions: bool = True) -> str:
         context = get_context()
         if not context:

crackerjack/mcp/tools/error_analyzer.py

@@ -25,7 +25,8 @@ def _get_cached_patterns(context: t.Any, use_cache: bool) -> list[t.Any]:
     with suppress(Exception):
         cache = getattr(context, "cache", None)
         if cache and hasattr(cache, "get_error_patterns"):
-            return cache.get_error_patterns()
+            patterns: list[t.Any] = cache.get_error_patterns()
+            return patterns
 
     return []
 
@@ -70,7 +71,7 @@ def _build_error_analysis(patterns: list[t.Any], context: t.Any) -> dict[str, t.
 
 
 def _categorize_error_patterns(patterns: list[t.Any]) -> dict[str, list[t.Any]]:
-    categories = {
+    categories: dict[str, list[t.Any]] = {
         "syntax_errors": [],
         "import_errors": [],
         "type_errors": [],

crackerjack/mcp/tools/execution_tools.py

@@ -15,7 +15,7 @@ def register_execution_tools(mcp_app: t.Any) -> None:
 
 
 def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def execute_crackerjack(args: str, kwargs: str) -> str:
         context = get_context()
 
@@ -29,13 +29,11 @@ def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
 
         extra_kwargs = kwargs_result["kwargs"]
 
-        # Add extended timeout for long-running operations
         if "execution_timeout" not in extra_kwargs:
-            # Default to 15 minutes, extend to 20 minutes for test operations
             if extra_kwargs.get("test", False) or extra_kwargs.get("testing", False):
-                extra_kwargs["execution_timeout"] = 1200  # 20 minutes for tests
+                extra_kwargs["execution_timeout"] = 1200
             else:
-                extra_kwargs["execution_timeout"] = 900  # 15 minutes default
+                extra_kwargs["execution_timeout"] = 900
 
         try:
             result = await execute_crackerjack_workflow(args, extra_kwargs)
@@ -53,7 +51,7 @@ def _register_execute_crackerjack_tool(mcp_app: t.Any) -> None:
 
 
 def _register_smart_error_analysis_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     async def smart_error_analysis(use_cache: bool = True) -> str:
         context = get_context()
 
@@ -71,7 +69,7 @@ def _register_smart_error_analysis_tool(mcp_app: t.Any) -> None:
 
 
 def _register_init_crackerjack_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     def init_crackerjack(args: str = "", kwargs: str = "{}") -> str:
         try:
             target_path, force, error = _parse_init_arguments(args, kwargs)
@@ -86,7 +84,7 @@ def _register_init_crackerjack_tool(mcp_app: t.Any) -> None:
 
 
 def _register_agent_suggestions_tool(mcp_app: t.Any) -> None:
-    @mcp_app.tool()
+    @mcp_app.tool()  # type: ignore[misc]
     def suggest_agents(
         task_description: str = "",
         project_type: str = "python",
@@ -139,7 +137,7 @@ def _parse_kwargs(kwargs: str) -> dict[str, t.Any]:
 def _parse_init_arguments(args: str, kwargs: str) -> tuple[t.Any, bool, str | None]:
     try:
         target_path = args.strip() or "."
-        kwargs_dict = json.loads(kwargs) if kwargs.strip() else {}
+        kwargs_dict: dict[str, t.Any] = json.loads(kwargs) if kwargs.strip() else {}
         force = kwargs_dict.get("force") or False
 
         from pathlib import Path
@@ -165,7 +163,7 @@ def _execute_initialization(target_path: t.Any, force: bool) -> dict[str, t.Any]
     from crackerjack.services.git import GitService
 
     filesystem = FileSystemService()
-    git_service = GitService()
+    git_service = GitService(console)
     return InitializationService(
         console, filesystem, git_service, target_path
     ).initialize_project_full(force=force)

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