crackerjack 0.30.3__py3-none-any.whl → 0.31.4__py3-none-any.whl

crackerjack/mcp/tools/intelligence_tool_registry.py

@@ -0,0 +1,80 @@
+"""Intelligence tool registry for MCP server."""
+
+from .intelligence_tools import (
+    analyze_agent_performance,
+    execute_smart_agent_task,
+    get_intelligence_system_status,
+    get_smart_agent_recommendation,
+)
+
+
+def register_intelligence_tools(mcp_app) -> None:
+    """Register intelligence system tools with the MCP server."""
+
+    @mcp_app.tool()
+    async def execute_smart_task(
+        task_description: str,
+        context_type: str = "general",
+        strategy: str = "single_best",
+        max_agents: int = 3,
+        use_learning: bool = True,
+    ):
+        """Execute a task using intelligent agent selection.
+
+        Args:
+            task_description: Description of the task to execute
+            context_type: Type of task context (architecture, refactoring, testing, etc.)
+            strategy: Execution strategy (single_best, parallel, sequential, consensus)
+            max_agents: Maximum number of agents to consider
+            use_learning: Whether to apply adaptive learning
+
+        Returns:
+            Dictionary with execution results and metadata
+        """
+        return await execute_smart_agent_task(
+            task_description,
+            context_type,
+            strategy,
+            max_agents,
+            use_learning,
+        )
+
+    @mcp_app.tool()
+    async def get_agent_recommendation(
+        task_description: str,
+        context_type: str = "general",
+        include_analysis: bool = True,
+    ):
+        """Get intelligent agent recommendation for a task without executing it.
+
+        Args:
+            task_description: Description of the task
+            context_type: Type of task context
+            include_analysis: Whether to include complexity analysis
+
+        Returns:
+            Dictionary with recommendation details
+        """
+        return await get_smart_agent_recommendation(
+            task_description,
+            context_type,
+            include_analysis,
+        )
+
+    @mcp_app.tool()
+    async def intelligence_system_status():
+        """Get comprehensive status of the intelligent agent system.
+
+        Returns:
+            Dictionary with system status and statistics
+        """
+        return await get_intelligence_system_status()
+
+    @mcp_app.tool()
+    async def agent_performance_analysis():
+        """Analyze agent performance and learning insights.
+
+        Returns:
+            Dictionary with performance analysis and insights
+        """
+        return await analyze_agent_performance()

crackerjack/mcp/tools/intelligence_tools.py

@@ -0,0 +1,314 @@
+"""MCP tools for the Intelligent Agent Selection System."""
+
+import asyncio
+import logging
+import typing as t
+
+from crackerjack.intelligence import ExecutionStrategy, TaskContext
+from crackerjack.intelligence.integration import get_intelligent_agent_system
+from crackerjack.mcp.context import get_context
+
+
+async def execute_smart_agent_task(
+    task_description: str,
+    context_type: str = "general",
+    strategy: str = "single_best",
+    max_agents: int = 3,
+    use_learning: bool = True,
+) -> dict[str, t.Any]:
+    """Execute a task using intelligent agent selection.
+
+    Args:
+        task_description: Description of the task to execute
+        context_type: Type of task context (architecture, refactoring, testing, etc.)
+        strategy: Execution strategy (single_best, parallel, sequential, consensus)
+        max_agents: Maximum number of agents to consider
+        use_learning: Whether to apply adaptive learning
+
+    Returns:
+        Dictionary with execution results and metadata
+    """
+    get_context()
+    logger = logging.getLogger(__name__)
+
+    try:
+        # Parse context type
+        task_context = None
+        context_map = {
+            "architecture": TaskContext.ARCHITECTURE,
+            "refactoring": TaskContext.REFACTORING,
+            "testing": TaskContext.TESTING,
+            "security": TaskContext.SECURITY,
+            "performance": TaskContext.PERFORMANCE,
+            "documentation": TaskContext.DOCUMENTATION,
+            "code_quality": TaskContext.CODE_QUALITY,
+            "debugging": TaskContext.DEBUGGING,
+            "project_setup": TaskContext.PROJECT_SETUP,
+            "general": TaskContext.GENERAL,
+        }
+
+        if context_type.lower() in context_map:
+            task_context = context_map[context_type.lower()]
+
+        # Parse strategy
+        strategy_map = {
+            "single_best": ExecutionStrategy.SINGLE_BEST,
+            "parallel": ExecutionStrategy.PARALLEL,
+            "sequential": ExecutionStrategy.SEQUENTIAL,
+            "consensus": ExecutionStrategy.CONSENSUS,
+        }
+
+        execution_strategy = strategy_map.get(
+            strategy.lower(), ExecutionStrategy.SINGLE_BEST
+        )
+
+        # Get intelligent agent system
+        system = await get_intelligent_agent_system()
+
+        logger.info(
+            f"Executing smart task: '{task_description[:50]}...' "
+            f"(context: {context_type}, strategy: {strategy})"
+        )
+
+        # Execute task
+        result = await system.execute_smart_task(
+            description=task_description,
+            context=task_context,
+            strategy=execution_strategy,
+        )
+
+        # Prepare response
+        response = {
+            "success": result.success,
+            "agents_used": result.agents_used,
+            "execution_time": result.execution_time,
+            "confidence": result.confidence,
+            "recommendations": result.recommendations,
+            "learning_applied": result.learning_applied,
+            "task_description": task_description,
+            "context_type": context_type,
+            "strategy_used": strategy,
+        }
+
+        # Add result based on type
+        if hasattr(result.result, "__dict__"):
+            # Complex object - convert to dict
+            try:
+                if hasattr(result.result, "success"):
+                    # Looks like FixResult
+                    response["fix_result"] = {
+                        "success": getattr(result.result, "success", False),
+                        "confidence": getattr(result.result, "confidence", 0.0),
+                        "fixes_applied": getattr(result.result, "fixes_applied", []),
+                        "remaining_issues": getattr(
+                            result.result, "remaining_issues", []
+                        ),
+                        "recommendations": getattr(
+                            result.result, "recommendations", []
+                        ),
+                        "files_modified": getattr(result.result, "files_modified", []),
+                    }
+                else:
+                    response["result"] = str(result.result)
+            except Exception:
+                response["result"] = str(result.result)
+        else:
+            response["result"] = result.result
+
+        if result.success:
+            logger.info(
+                f"Smart task completed successfully using {len(result.agents_used)} agents "
+                f"in {result.execution_time:.2f}s"
+            )
+        else:
+            logger.warning(f"Smart task failed: {result.recommendations}")
+
+        return response
+
+    except Exception as e:
+        logger.exception(f"Error in smart agent execution: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "task_description": task_description,
+            "context_type": context_type,
+            "strategy_used": strategy,
+        }
+
+
+async def get_smart_agent_recommendation(
+    task_description: str,
+    context_type: str = "general",
+    include_analysis: bool = True,
+) -> dict[str, t.Any]:
+    """Get agent recommendation for a task without executing it.
+
+    Args:
+        task_description: Description of the task
+        context_type: Type of task context
+        include_analysis: Whether to include complexity analysis
+
+    Returns:
+        Dictionary with recommendation details
+    """
+    logger = logging.getLogger(__name__)
+
+    try:
+        # Parse context type
+        task_context = None
+        context_map = {
+            "architecture": TaskContext.ARCHITECTURE,
+            "refactoring": TaskContext.REFACTORING,
+            "testing": TaskContext.TESTING,
+            "security": TaskContext.SECURITY,
+            "performance": TaskContext.PERFORMANCE,
+            "documentation": TaskContext.DOCUMENTATION,
+            "code_quality": TaskContext.CODE_QUALITY,
+            "debugging": TaskContext.DEBUGGING,
+            "project_setup": TaskContext.PROJECT_SETUP,
+            "general": TaskContext.GENERAL,
+        }
+
+        if context_type.lower() in context_map:
+            task_context = context_map[context_type.lower()]
+
+        # Get intelligent agent system
+        system = await get_intelligent_agent_system()
+
+        # Get recommendation
+        recommendation = await system.get_best_agent_for_task(
+            description=task_description,
+            context=task_context,
+        )
+
+        response = {
+            "task_description": task_description,
+            "context_type": context_type,
+        }
+
+        if recommendation:
+            agent_name, confidence = recommendation
+            response.update(
+                {
+                    "recommended_agent": agent_name,
+                    "confidence": confidence,
+                    "has_recommendation": True,
+                }
+            )
+        else:
+            response.update(
+                {
+                    "recommended_agent": None,
+                    "confidence": 0.0,
+                    "has_recommendation": False,
+                    "message": "No suitable agent found for this task",
+                }
+            )
+
+        # Add complexity analysis if requested
+        if include_analysis:
+            try:
+                analysis = await system.analyze_task_complexity(task_description)
+                response["complexity_analysis"] = analysis
+            except Exception as e:
+                logger.warning(f"Failed to analyze task complexity: {e}")
+                response["complexity_analysis"] = {"error": str(e)}
+
+        logger.debug(f"Generated recommendation for task: {task_description[:50]}...")
+        return response
+
+    except Exception as e:
+        logger.exception(f"Error getting smart recommendation: {e}")
+        return {
+            "task_description": task_description,
+            "context_type": context_type,
+            "error": str(e),
+            "has_recommendation": False,
+        }
+
+
+async def get_intelligence_system_status() -> dict[str, t.Any]:
+    """Get comprehensive status of the intelligent agent system.
+
+    Returns:
+        Dictionary with system status and statistics
+    """
+    logger = logging.getLogger(__name__)
+
+    try:
+        system = await get_intelligent_agent_system()
+        status = await system.get_system_status()
+
+        # Add additional runtime information
+        status["runtime_info"] = {
+            "system_initialized": system._initialized,
+            "components_loaded": {
+                "registry": system.registry is not None,
+                "orchestrator": system.orchestrator is not None,
+                "learning_system": system.learning_system is not None,
+            },
+        }
+
+        logger.debug("Generated intelligence system status")
+        return status
+
+    except Exception as e:
+        logger.exception(f"Error getting intelligence system status: {e}")
+        return {
+            "error": str(e),
+            "initialized": False,
+        }
+
+
+async def analyze_agent_performance() -> dict[str, t.Any]:
+    """Analyze agent performance and learning insights.
+
+    Returns:
+        Dictionary with performance analysis and insights
+    """
+    logger = logging.getLogger(__name__)
+
+    try:
+        system = await get_intelligent_agent_system()
+        await system.initialize()
+
+        # Get learning summary
+        learning_summary = system.learning_system.get_learning_summary()
+
+        # Get orchestrator stats
+        orchestration_stats = system.orchestrator.get_execution_stats()
+
+        # Get agent capabilities overview
+        registry_stats = system.registry.get_agent_stats()
+
+        performance_analysis = {
+            "learning_summary": learning_summary,
+            "orchestration_stats": orchestration_stats,
+            "registry_overview": registry_stats,
+            "analysis_timestamp": asyncio.get_event_loop().time(),
+        }
+
+        # Add insights if available
+        if hasattr(system.learning_system, "_learning_insights"):
+            recent_insights = [
+                {
+                    "type": insight.insight_type,
+                    "agent": insight.agent_name,
+                    "confidence": insight.confidence,
+                    "description": insight.description,
+                }
+                for insight in system.learning_system._learning_insights[
+                    -10:
+                ]  # Last 10 insights
+            ]
+            performance_analysis["recent_insights"] = recent_insights
+
+        logger.debug("Generated agent performance analysis")
+        return performance_analysis
+
+    except Exception as e:
+        logger.exception(f"Error analyzing agent performance: {e}")
+        return {
+            "error": str(e),
+            "analysis_available": False,
+        }