crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/intelligence/agent_selector.py

@@ -1,9 +1,3 @@
-"""Smart Agent Selection Engine.
-
-Intelligently selects the best agents for tasks based on context analysis,
-capability matching, and priority scoring.
-"""
-
 import logging
 import re
 import typing as t
@@ -19,8 +13,6 @@ from .agent_registry import (
 
 
 class TaskContext(Enum):
-    """Context categories for tasks."""
-
     CODE_QUALITY = "code_quality"
     ARCHITECTURE = "architecture"
     TESTING = "testing"
@@ -35,32 +27,26 @@ class TaskContext(Enum):
 
 @dataclass
 class TaskDescription:
-    """Description of a task to be executed."""
-
     description: str
     context: TaskContext | None = None
     keywords: list[str] | None = None
     file_patterns: list[str] | None = None
     error_types: list[str] | None = None
-    priority: int = 50  # 0-100, higher is more important
+    priority: int = 50
 
 
 @dataclass
 class AgentScore:
-    """Score for an agent's suitability for a task."""
-
     agent: RegisteredAgent
-    base_score: float  # 0-1 based on capability match
-    context_score: float  # 0-1 based on context match
-    priority_bonus: float  # 0-1 based on agent priority
-    confidence_factor: float  # Multiplier from agent metadata
-    final_score: float  # Combined weighted score
-    reasoning: str  # Explanation of the score
+    base_score: float
+    context_score: float
+    priority_bonus: float
+    confidence_factor: float
+    final_score: float
+    reasoning: str
 
 
 class AgentSelector:
-    """Intelligent agent selection engine."""
-
     def __init__(self, registry: AgentRegistry | None = None) -> None:
         self.logger = logging.getLogger(__name__)
         self.registry = registry
@@ -68,49 +54,39 @@ class AgentSelector:
         self._initialize_task_patterns()
 
     def _initialize_task_patterns(self) -> None:
-        """Initialize patterns for task analysis."""
         self._task_patterns = {
-            # Architecture patterns
-            r"architect|design|structure|pattern|refactor.*complex": [
+            r"architect | design | structure | pattern | refactor.* complex": [
                 AgentCapability.ARCHITECTURE,
                 AgentCapability.REFACTORING,
             ],
-            # Code quality patterns
-            r"refurb|ruff|format|lint|style|clean.*code": [
+            r"refurb | ruff | format | lint | style | clean.* code": [
                 AgentCapability.FORMATTING,
                 AgentCapability.CODE_ANALYSIS,
             ],
-            # Testing patterns
-            r"test|pytest|coverage|mock|fixture": [
+            r"test | pytest | coverage | mock | fixture": [
                 AgentCapability.TESTING,
             ],
-            # Security patterns
-            r"security|vulnerability|audit|bandit|safe": [
+            r"security | vulnerability | audit | bandit | safe": [
                 AgentCapability.SECURITY,
             ],
-            # Performance patterns
-            r"performance|optimize|speed|efficient|complexity": [
+            r"performance | optimize | speed | efficient | complexity": [
                 AgentCapability.PERFORMANCE,
                 AgentCapability.CODE_ANALYSIS,
             ],
-            # Documentation patterns
-            r"document|readme|comment|explain|changelog": [
+            r"document | readme | comment | explain | changelog": [
                 AgentCapability.DOCUMENTATION,
             ],
-            # Refactoring patterns
-            r"refactor|improve|simplify|dry.*violation": [
+            r"refactor | improve | simplify | dry.* violation": [
                 AgentCapability.REFACTORING,
                 AgentCapability.CODE_ANALYSIS,
             ],
-            # Debugging patterns
-            r"debug|fix|error|bug|failure": [
+            r"debug | fix | error | bug | failure": [
                 AgentCapability.DEBUGGING,
                 AgentCapability.CODE_ANALYSIS,
             ],
         }
 
     async def get_registry(self) -> AgentRegistry:
-        """Get or initialize the agent registry."""
         if self.registry is None:
             self.registry = await get_agent_registry()
         return self.registry
@@ -120,7 +96,6 @@ class AgentSelector:
         task: TaskDescription,
         max_candidates: int = 5,
     ) -> AgentScore | None:
-        """Select the single best agent for a task."""
         candidates = await self.select_agents(task, max_candidates)
         return candidates[0] if candidates else None
 
@@ -129,61 +104,53 @@ class AgentSelector:
         task: TaskDescription,
         max_candidates: int = 3,
     ) -> list[AgentScore]:
-        """Select the best agents for a task, ordered by score."""
         registry = await self.get_registry()
 
-        # Analyze task to determine required capabilities
         required_capabilities = self._analyze_task_capabilities(task)
 
-        # Score all agents
         scores: list[AgentScore] = []
 
         for agent in registry.list_all_agents():
             score = await self._score_agent_for_task(agent, task, required_capabilities)
-            if score.final_score > 0.1:  # Minimum threshold
+            if score.final_score > 0.1:
                 scores.append(score)
 
-        # Sort by final score (descending)
         scores.sort(key=lambda s: s.final_score, reverse=True)
 
-        # Return top candidates
         selected = scores[:max_candidates]
 
         self.logger.debug(
             f"Selected {len(selected)} agents for task '{task.description[:50]}...': "
-            f"{[f'{s.agent.metadata.name}({s.final_score:.2f})' for s in selected]}"
+            f"{[f'{s.agent.metadata.name}({s.final_score: .2f})' for s in selected]}"
         )
 
         return selected
 
     def _analyze_task_capabilities(self, task: TaskDescription) -> set[AgentCapability]:
-        """Analyze a task to determine required capabilities."""
         capabilities = set()
 
-        # Apply different analysis methods
         capabilities.update(self._analyze_text_patterns(task))
         capabilities.update(self._analyze_context(task))
         capabilities.update(self._analyze_file_patterns(task))
         capabilities.update(self._analyze_error_types(task))
 
-        # Fallback
         return capabilities or {AgentCapability.CODE_ANALYSIS}
 
     def _analyze_text_patterns(self, task: TaskDescription) -> set[AgentCapability]:
-        """Analyze text patterns in task description and keywords."""
         text = task.description.lower()
         if task.keywords:
             text += " " + " ".join(task.keywords).lower()
 
         capabilities = set()
         for pattern, caps in self._task_patterns.items():
-            if re.search(pattern, text, re.IGNORECASE):
+            if re.search(
+                pattern, text, re.IGNORECASE
+            ):  # REGEX OK: dynamic pattern matching from config
                 capabilities.update(caps)
 
         return capabilities
 
     def _analyze_context(self, task: TaskDescription) -> set[AgentCapability]:
-        """Analyze task context to determine capabilities."""
         if not task.context:
             return set()
 
@@ -218,7 +185,6 @@ class AgentSelector:
         return set(context_map.get(task.context, []))
 
     def _analyze_file_patterns(self, task: TaskDescription) -> set[AgentCapability]:
-        """Analyze file patterns to determine capabilities."""
         if not task.file_patterns:
             return set()
 
@@ -227,13 +193,12 @@ class AgentSelector:
             pattern_lower = pattern.lower()
             if any(ext in pattern_lower for ext in (".py", ".pyi")):
                 capabilities.add(AgentCapability.CODE_ANALYSIS)
-            if any(test in pattern_lower for test in ("test_", "_test", "tests/")):
+            if any(test in pattern_lower for test in ("test_", "_test", "tests /")):
                 capabilities.add(AgentCapability.TESTING)
 
         return capabilities
 
     def _analyze_error_types(self, task: TaskDescription) -> set[AgentCapability]:
-        """Analyze error types to determine capabilities."""
         if not task.error_types:
             return set()
 
@@ -259,29 +224,23 @@ class AgentSelector:
         task: TaskDescription,
         required_capabilities: set[AgentCapability],
     ) -> AgentScore:
-        """Score an agent's suitability for a task."""
-        # Base score: capability overlap
         agent_capabilities = agent.metadata.capabilities
         overlap = len(required_capabilities & agent_capabilities)
         max_overlap = len(required_capabilities)
 
         base_score = overlap / max_overlap if max_overlap > 0 else 0.0
 
-        # Context score: how well the agent matches the task context
         context_score = self._calculate_context_score(agent, task)
 
-        # Priority bonus: normalized agent priority (0-1)
         priority_bonus = min(agent.metadata.priority / 100.0, 1.0)
 
-        # Confidence factor from agent metadata
         confidence_factor = agent.metadata.confidence_factor
 
-        # Calculate weighted final score
         weights = {
-            "base": 0.4,  # Capability match is most important
-            "context": 0.3,  # Context matching
-            "priority": 0.2,  # Agent priority (source-based)
-            "bonus": 0.1,  # Additional considerations
+            "base": 0.4,
+            "context": 0.3,
+            "priority": 0.2,
+            "bonus": 0.1,
         }
 
         weighted_score = (
@@ -290,10 +249,8 @@ class AgentSelector:
             + priority_bonus * weights["priority"]
         )
 
-        # Apply confidence factor
         final_score = weighted_score * confidence_factor
 
-        # Generate reasoning
         reasoning = self._generate_score_reasoning(
             agent, base_score, context_score, priority_bonus, required_capabilities
         )
@@ -311,7 +268,6 @@ class AgentSelector:
     def _calculate_context_score(
         self, agent: RegisteredAgent, task: TaskDescription
     ) -> float:
-        """Calculate how well an agent matches the task context."""
         score = 0.0
 
         agent_name_lower = agent.metadata.name.lower()
@@ -325,7 +281,6 @@ class AgentSelector:
         return min(score, 1.0)
 
     def _score_name_matches(self, agent_name_lower: str, task_text: str) -> float:
-        """Score direct name matches between agent and task."""
         if any(keyword in agent_name_lower for keyword in task_text.split()):
             return 0.3
         return 0.0
@@ -333,7 +288,6 @@ class AgentSelector:
     def _score_description_matches(
         self, agent: RegisteredAgent, task_text: str
     ) -> float:
-        """Score description word overlap."""
         if not agent.metadata.description:
             return 0.0
 
@@ -348,7 +302,6 @@ class AgentSelector:
     def _score_keyword_matches(
         self, agent: RegisteredAgent, task: TaskDescription
     ) -> float:
-        """Score keyword/tag overlap."""
         if not task.keywords or not agent.metadata.tags:
             return 0.0
 
@@ -361,7 +314,6 @@ class AgentSelector:
         return 0.0
 
     def _score_special_patterns(self, agent_name_lower: str, task_text: str) -> float:
-        """Score special pattern bonuses."""
         score = 0.0
 
         if "architect" in agent_name_lower and (
@@ -383,14 +335,11 @@ class AgentSelector:
         priority_bonus: float,
         required_capabilities: set[AgentCapability],
     ) -> str:
-        """Generate human-readable reasoning for the score."""
         parts = []
 
-        # Capability match
         overlap = len(required_capabilities & agent.metadata.capabilities)
         parts.append(f"Capabilities: {overlap}/{len(required_capabilities)} match")
 
-        # Context relevance
         if context_score > 0.5:
             parts.append("High context relevance")
         elif context_score > 0.2:
@@ -398,7 +347,6 @@ class AgentSelector:
         else:
             parts.append("Low context relevance")
 
-        # Source priority
         source_desc = {
             "crackerjack": "Built-in specialist",
             "user": "User agent",
@@ -406,7 +354,6 @@ class AgentSelector:
         }
         parts.append(source_desc.get(agent.metadata.source.value, "Unknown source"))
 
-        # Special strengths
         if agent.metadata.capabilities:
             top_caps = list(agent.metadata.capabilities)[:2]
             cap_names = [cap.value.replace("_", " ") for cap in top_caps]
@@ -415,11 +362,9 @@ class AgentSelector:
         return " | ".join(parts)
 
     async def analyze_task_complexity(self, task: TaskDescription) -> dict[str, t.Any]:
-        """Analyze task complexity and provide recommendations."""
         registry = await self.get_registry()
         required_capabilities = self._analyze_task_capabilities(task)
 
-        # Get all agents that could handle this task
         all_scores = []
         for agent in registry.list_all_agents():
             score = await self._score_agent_for_task(agent, task, required_capabilities)
@@ -453,13 +398,12 @@ class AgentSelector:
     def _assess_complexity(
         self, capabilities: set[AgentCapability], scores: list[AgentScore]
     ) -> str:
-        """Assess the complexity level of a task."""
         if len(capabilities) >= 4:
             return "high"
         elif len(capabilities) >= 2:
             return "medium"
         elif not scores or scores[0].final_score < 0.3:
-            return "high"  # No good matches = complex
+            return "high"
 
         return "low"
 
@@ -468,33 +412,28 @@ class AgentSelector:
         capabilities: set[AgentCapability],
         scores: list[AgentScore],
     ) -> list[str]:
-        """Generate recommendations based on analysis."""
         recommendations = []
 
         if not scores:
-            recommendations.append(
-                "No suitable agents found - consider manual approach"
-            )
+            recommendations.append("No suitable agents found-consider manual approach")
             return recommendations
 
         top_score = scores[0].final_score
 
         if top_score > 0.8:
             recommendations.append(
-                "Excellent agent match found - high confidence execution"
+                "Excellent agent match found-high confidence execution"
             )
         elif top_score > 0.6:
-            recommendations.append("Good agent match - should handle task well")
+            recommendations.append("Good agent match-should handle task well")
         elif top_score > 0.4:
-            recommendations.append("Moderate match - may need supervision")
+            recommendations.append("Moderate match-may need supervision")
         else:
-            recommendations.append("Weak matches - consider alternative approaches")
+            recommendations.append("Weak matches-consider alternative approaches")
 
-        # Multi-agent recommendations
         if len(capabilities) > 2:
             recommendations.append("Consider multi-agent approach for complex task")
 
-        # Source diversity
         sources = {score.agent.metadata.source for score in scores[:3]}
         if len(sources) > 1:
             recommendations.append("Multiple agent sources available for redundancy")

crackerjack/intelligence/integration.py

@@ -1,9 +1,3 @@
-"""Integration layer for Intelligent Agent Selection System.
-
-Provides high-level API for integrating the intelligent agent system with
-existing crackerjack workflows and MCP tools.
-"""
-
 import logging
 import typing as t
 from dataclasses import dataclass
@@ -22,8 +16,6 @@ from .agent_selector import TaskContext, TaskDescription
 
 @dataclass
 class SmartAgentResult:
-    """Result from smart agent execution."""
-
     success: bool
     result: t.Any
     agents_used: list[str]
@@ -34,27 +26,22 @@ class SmartAgentResult:
 
 
 class IntelligentAgentSystem:
-    """High-level interface to the intelligent agent system."""
-
     def __init__(self) -> None:
         self.logger = logging.getLogger(__name__)
         self._initialized = False
 
     async def initialize(self) -> None:
-        """Initialize the intelligent agent system."""
         if self._initialized:
             return
 
         self.logger.info("Initializing Intelligent Agent System")
 
-        # Initialize all components
         self.registry = await get_agent_registry()
         self.orchestrator = await get_agent_orchestrator()
         self.learning_system = await get_learning_system()
 
         self._initialized = True
 
-        # Log system status
         stats = self.registry.get_agent_stats()
         self.logger.info(
             f"System initialized: {stats['total_agents']} agents available "
@@ -68,16 +55,13 @@ class IntelligentAgentSystem:
         strategy: ExecutionStrategy = ExecutionStrategy.SINGLE_BEST,
         context_data: AgentContext | None = None,
     ) -> SmartAgentResult:
-        """Execute a task using intelligent agent selection."""
         await self.initialize()
 
-        # Create task description
         task = TaskDescription(
             description=description,
             context=context,
         )
 
-        # Get learning recommendations
         candidates = await self.orchestrator.selector.select_agents(
             task, max_candidates=5
         )
@@ -87,19 +71,14 @@ class IntelligentAgentSystem:
             task, candidate_names
         )
 
-        # Apply learning to boost scores
         for candidate in candidates:
             agent_name = candidate.agent.metadata.name
             if agent_name in learning_recommendations:
-                learning_boost = (
-                    learning_recommendations[agent_name] * 0.2
-                )  # 20% boost max
+                learning_boost = learning_recommendations[agent_name] * 0.2
                 candidate.final_score = min(1.0, candidate.final_score + learning_boost)
 
-        # Re-sort by updated scores
         candidates.sort(key=lambda c: c.final_score, reverse=True)
 
-        # Create execution request
         request = ExecutionRequest(
             task=task,
             strategy=strategy,
@@ -107,10 +86,8 @@ class IntelligentAgentSystem:
             context=context_data,
         )
 
-        # Execute with orchestrator
         result = await self.orchestrator.execute(request)
 
-        # Record results for learning
         if candidates:
             best_candidate = candidates[0]
             await self.learning_system.record_execution(
@@ -122,7 +99,6 @@ class IntelligentAgentSystem:
                 error_message=result.error_message,
             )
 
-        # Create smart result
         return SmartAgentResult(
             success=result.success,
             result=result.primary_result,
@@ -139,10 +115,8 @@ class IntelligentAgentSystem:
         context: AgentContext,
         use_learning: bool = True,
     ) -> FixResult:
-        """Handle a crackerjack Issue using intelligent agent selection."""
         await self.initialize()
 
-        # Convert issue to task description
         task_context = self._map_issue_to_task_context(issue)
 
         task = TaskDescription(
@@ -152,18 +126,15 @@ class IntelligentAgentSystem:
             priority=self._map_severity_to_priority(issue.severity),
         )
 
-        # Execute smart task
         smart_result = await self.execute_smart_task(
             description=task.description,
             context=task_context,
             context_data=context,
         )
 
-        # Convert result back to FixResult
         if smart_result.success and isinstance(smart_result.result, FixResult):
             return smart_result.result
 
-        # Create fallback FixResult
         return FixResult(
             success=smart_result.success,
             confidence=smart_result.confidence,
@@ -181,7 +152,6 @@ class IntelligentAgentSystem:
         description: str,
         context: TaskContext | None = None,
     ) -> tuple[str, float] | None:
-        """Get the best agent for a task without executing it."""
         await self.initialize()
 
         task = TaskDescription(description=description, context=context)
@@ -192,14 +162,12 @@ class IntelligentAgentSystem:
         return None
 
     async def analyze_task_complexity(self, description: str) -> dict[str, t.Any]:
-        """Analyze a task's complexity and provide recommendations."""
         await self.initialize()
 
         task = TaskDescription(description=description)
         return await self.orchestrator.selector.analyze_task_complexity(task)
 
     def _map_issue_to_task_context(self, issue: Issue) -> TaskContext | None:
-        """Map crackerjack Issue type to TaskContext."""
         from crackerjack.agents.base import IssueType
 
         mapping = {
@@ -220,7 +188,6 @@ class IntelligentAgentSystem:
         return mapping.get(issue.type) or TaskContext.GENERAL
 
     def _map_severity_to_priority(self, severity: t.Any) -> int:
-        """Map crackerjack Priority to task priority."""
         from crackerjack.agents.base import Priority
 
         mapping = {
@@ -232,7 +199,6 @@ class IntelligentAgentSystem:
         return mapping.get(severity) or 50
 
     async def get_system_status(self) -> dict[str, t.Any]:
-        """Get comprehensive system status."""
         await self.initialize()
 
         registry_stats = self.registry.get_agent_stats()
@@ -247,12 +213,10 @@ class IntelligentAgentSystem:
         }
 
 
-# Global intelligent agent system
 _intelligent_system_instance: IntelligentAgentSystem | None = None
 
 
 async def get_intelligent_agent_system() -> IntelligentAgentSystem:
-    """Get or create the global intelligent agent system."""
     global _intelligent_system_instance
 
     if _intelligent_system_instance is None:
@@ -261,12 +225,10 @@ async def get_intelligent_agent_system() -> IntelligentAgentSystem:
     return _intelligent_system_instance
 
 
-# Convenience functions for common use cases
 async def smart_fix_issue(
     issue: Issue,
     context: AgentContext,
 ) -> FixResult:
-    """Fix an issue using intelligent agent selection."""
     system = await get_intelligent_agent_system()
     return await system.handle_crackerjack_issue(issue, context)
 
@@ -276,7 +238,6 @@ async def smart_execute_task(
     context: TaskContext | None = None,
     strategy: ExecutionStrategy = ExecutionStrategy.SINGLE_BEST,
 ) -> SmartAgentResult:
-    """Execute a task using intelligent agent selection."""
     system = await get_intelligent_agent_system()
     return await system.execute_smart_task(description, context, strategy)
 
@@ -285,6 +246,5 @@ async def get_smart_recommendation(
     description: str,
     context: TaskContext | None = None,
 ) -> tuple[str, float] | None:
-    """Get a smart agent recommendation without executing."""
     system = await get_intelligent_agent_system()
     return await system.get_best_agent_for_task(description, context)

crackerjack/interactive.py

@@ -311,12 +311,12 @@ class WorkflowManager:
 
     def _handle_task_without_executor(self, task: Task) -> bool:
         task.skip()
-        self.console.print(f"[yellow]⏭️ Skipped {task.name} (no executor)[/yellow]")
+        self.console.print(f"[yellow]⏭️ Skipped {task.name} (no executor)[/ yellow]")
         return True
 
     def _execute_task_with_executor(self, task: Task) -> bool:
         task.start()
-        self.console.print(f"[blue]🔄 Running {task.name}...[/blue]")
+        self.console.print(f"[blue]🔄 Running {task.name}...[/ blue]")
 
         try:
             return self._try_execute_task(task)
@@ -334,9 +334,9 @@ class WorkflowManager:
     def _display_task_result(self, task: Task, success: bool) -> None:
         if success:
             duration_str = f" ({task.duration: .1f}s)" if task.duration else ""
-            self.console.print(f"[green]✅ {task.name}{duration_str}[/green]")
+            self.console.print(f"[green]✅ {task.name}{duration_str}[/ green]")
         else:
-            self.console.print(f"[red]❌ {task.name} failed[/red]")
+            self.console.print(f"[red]❌ {task.name} failed[/ red]")
 
     def _handle_task_exception(self, task: Task, e: Exception) -> bool:
         error = CrackerjackError(
@@ -344,7 +344,7 @@ class WorkflowManager:
             error_code=ErrorCode.COMMAND_EXECUTION_ERROR,
         )
         task.fail(error)
-        self.console.print(f"[red]💥 {task.name} crashed: {e}[/red]")
+        self.console.print(f"[red]💥 {task.name} crashed: {e}[/ red]")
         return False
 
     def display_task_tree(self) -> None:
@@ -587,11 +587,11 @@ class InteractiveCLI:
         )
         self.create_dynamic_workflow(options)
 
-        self.console.print("[bold blue]🚀 Starting Interactive Workflow[/bold blue]")
+        self.console.print("[bold blue]🚀 Starting Interactive Workflow[/ bold blue]")
         self.workflow.display_task_tree()
 
         if not Confirm.ask("Continue with workflow?"):
-            self.console.print("[yellow]Workflow cancelled by user[/yellow]")
+            self.console.print("[yellow]Workflow cancelled by user[/ yellow]")
             return False
 
         return self._execute_workflow_loop()
@@ -626,7 +626,7 @@ class InteractiveCLI:
         ]
 
         if pending_tasks:
-            self.console.print("[red]❌ Workflow stuck - unresolved dependencies[/red]")
+            self.console.print("[red]❌ Workflow stuck-unresolved dependencies[/ red]")
             return False
         return True
 
@@ -645,7 +645,7 @@ class InteractiveCLI:
     def _display_workflow_summary(self) -> None:
         summary = self.workflow.get_workflow_summary()
 
-        self.console.print("\n[bold]📊 Workflow Summary[/bold]")
+        self.console.print("\n[bold]📊 Workflow Summary[/ bold]")
 
         table = Table(show_header=True, header_style="bold magenta")
         table.add_column("Status", style="cyan")