crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/agents/coordinator.py

@@ -1,14 +1,10 @@
 import asyncio
 import hashlib
-import logging
 import typing as t
 from collections import defaultdict
 from itertools import starmap
 
-from crackerjack.services.cache import CrackerjackCache
-from crackerjack.services.debug import get_ai_agent_debugger
-
-from .base import (
+from crackerjack.agents.base import (
     AgentContext,
     FixResult,
     Issue,
@@ -16,24 +12,28 @@ from .base import (
     SubAgent,
     agent_registry,
 )
-from .tracker import get_agent_tracker
+from crackerjack.agents.error_middleware import agent_error_boundary
+from crackerjack.agents.tracker import get_agent_tracker
+from crackerjack.services.cache import CrackerjackCache
+from crackerjack.services.debug import get_ai_agent_debugger
+from crackerjack.services.logging import get_logger
 
-# Static mapping for O(1) agent lookup by issue type
-ISSUE_TYPE_TO_AGENTS = {
+ISSUE_TYPE_TO_AGENTS: dict[IssueType, list[str]] = {
+    IssueType.FORMATTING: ["FormattingAgent"],
+    IssueType.TYPE_ERROR: ["TestCreationAgent", "RefactoringAgent"],
+    IssueType.SECURITY: ["SecurityAgent"],
+    IssueType.TEST_FAILURE: ["TestSpecialistAgent", "TestCreationAgent"],
+    IssueType.IMPORT_ERROR: ["ImportOptimizationAgent"],
     IssueType.COMPLEXITY: ["RefactoringAgent"],
     IssueType.DEAD_CODE: ["RefactoringAgent", "ImportOptimizationAgent"],
-    IssueType.SECURITY: ["SecurityAgent"],
-    IssueType.PERFORMANCE: ["PerformanceAgent", "RefactoringAgent"],
-    IssueType.TEST_FAILURE: ["TestCreationAgent", "TestSpecialistAgent"],
-    IssueType.TYPE_ERROR: ["TestCreationAgent", "RefactoringAgent"],
-    IssueType.FORMATTING: ["FormattingAgent", "ImportOptimizationAgent"],
+    IssueType.DEPENDENCY: ["ImportOptimizationAgent"],
+    IssueType.DRY_VIOLATION: ["DRYAgent"],
+    IssueType.PERFORMANCE: ["PerformanceAgent"],
     IssueType.DOCUMENTATION: ["DocumentationAgent"],
-    IssueType.DRY_VIOLATION: ["DRYAgent", "RefactoringAgent"],
-    IssueType.IMPORT_ERROR: ["ImportOptimizationAgent", "RefactoringAgent"],
-    IssueType.COVERAGE_IMPROVEMENT: ["TestCreationAgent", "TestSpecialistAgent"],
-    IssueType.TEST_ORGANIZATION: ["TestSpecialistAgent", "TestCreationAgent"],
-    IssueType.DEPENDENCY: ["RefactoringAgent"],
+    IssueType.TEST_ORGANIZATION: ["TestSpecialistAgent"],
+    IssueType.COVERAGE_IMPROVEMENT: ["TestCreationAgent"],
     IssueType.REGEX_VALIDATION: ["SecurityAgent", "RefactoringAgent"],
+    IssueType.SEMANTIC_CONTEXT: ["SemanticAgent", "ArchitectAgent"],
 }
 
 
@@ -43,7 +43,7 @@ class AgentCoordinator:
     ) -> None:
         self.context = context
         self.agents: list[SubAgent] = []
-        self.logger = logging.getLogger(__name__)
+        self.logger = get_logger(__name__)
         self._issue_cache: dict[str, FixResult] = {}
         self._collaboration_threshold = 0.7
         self.tracker = get_agent_tracker()
@@ -292,39 +292,27 @@ class AgentCoordinator:
             metadata={"issue_type": issue.type.value, "severity": issue.severity.value},
         )
 
-        try:
-            # Use cached analysis for better performance
-            result = await self._cached_analyze_and_fix(agent, issue)
-            if result.success:
-                self.logger.info(f"{agent.name} successfully fixed issue")
-            else:
-                self.logger.warning(f"{agent.name} failed to fix issue")
-
-            self.tracker.track_agent_complete(agent.name, result)
-
-            self.debugger.log_agent_activity(
-                agent_name=agent.name,
-                activity="processing_completed",
-                issue_id=issue.id,
-                confidence=result.confidence,
-                result={
-                    "success": result.success,
-                    "remaining_issues": len(result.remaining_issues),
-                },
-                metadata={"fix_applied": result.success},
-            )
+        result = await self._execute_agent(agent, issue)
+        if result.success:
+            self.logger.info(f"{agent.name} successfully fixed issue")
+        else:
+            self.logger.warning(f"{agent.name} failed to fix issue")
 
-            return result
-        except Exception as e:
-            self.logger.exception(f"{agent.name} threw exception: {e}")
-            error_result = FixResult(
-                success=False,
-                confidence=0.0,
-                remaining_issues=[f"{agent.name} failed with exception: {e}"],
-            )
+        self.tracker.track_agent_complete(agent.name, result)
+
+        self.debugger.log_agent_activity(
+            agent_name=agent.name,
+            activity="processing_completed",
+            issue_id=issue.id,
+            confidence=result.confidence,
+            result={
+                "success": result.success,
+                "remaining_issues": len(result.remaining_issues),
+            },
+            metadata={"fix_applied": result.success},
+        )
 
-            self.tracker.track_agent_complete(agent.name, error_result)
-            return error_result
+        return result
 
     def _group_issues_by_type(
         self,
@@ -347,6 +335,11 @@ class AgentCoordinator:
         issue_hash = self._create_issue_hash(issue)
         return f"{agent_name}:{issue_hash}"
 
+    @agent_error_boundary
+    async def _execute_agent(self, agent: SubAgent, issue: Issue) -> FixResult:
+        """Execute agent analysis with centralized error handling."""
+        return await self._cached_analyze_and_fix(agent, issue)
+
     async def _cached_analyze_and_fix(self, agent: SubAgent, issue: Issue) -> FixResult:
         """Analyze and fix issue with intelligent caching."""
         cache_key = self._get_cache_key(agent.name, issue)
@@ -450,12 +443,15 @@ class AgentCoordinator:
 
         try:
             plan = await architect.plan_before_action(primary_issue)
-            plan = self._enrich_architectural_plan(plan, all_issues)
+            # Ensure plan is properly typed as dict[str, Any]
+            if not isinstance(plan, dict):
+                plan = {"strategy": "default", "confidence": 0.5}
+            enriched_plan = self._enrich_architectural_plan(plan, all_issues)
 
             self.logger.info(
-                f"Created architectural plan: {plan.get('strategy', 'unknown')}"
+                f"Created architectural plan: {enriched_plan.get('strategy', 'unknown')}"
             )
-            return plan  # type: ignore[no-any-return]
+            return enriched_plan
 
         except Exception as e:
             self.logger.exception(f"Failed to create architectural plan: {e}")

crackerjack/agents/dry_agent.py

@@ -3,15 +3,32 @@ from pathlib import Path
 
 from ..services.regex_patterns import SAFE_PATTERNS
 from .base import (
+    AgentContext,
     FixResult,
     Issue,
     IssueType,
     SubAgent,
     agent_registry,
 )
+from .semantic_helpers import (
+    SemanticInsight,
+    create_semantic_enhancer,
+    get_session_enhanced_recommendations,
+)
 
 
 class DRYAgent(SubAgent):
+    """Agent for detecting and fixing DRY (Don't Repeat Yourself) violations.
+
+    Enhanced with semantic context to detect conceptual duplicates beyond
+    just syntactic pattern matching.
+    """
+
+    def __init__(self, context: AgentContext) -> None:
+        super().__init__(context)
+        self.semantic_enhancer = create_semantic_enhancer(context.project_path)
+        self.semantic_insights: dict[str, SemanticInsight] = {}
+
     def get_supported_types(self) -> set[IssueType]:
         return {IssueType.DRY_VIOLATION}
 
@@ -66,8 +83,13 @@ class DRYAgent(SubAgent):
                 remaining_issues=[f"Could not read file: {file_path}"],
             )
 
+        # Detect traditional pattern-based violations
         violations = self._detect_dry_violations(content, file_path)
 
+        # Enhance with semantic duplicate detection
+        semantic_violations = await self._detect_semantic_violations(content, file_path)
+        violations.extend(semantic_violations)
+
         if not violations:
             return FixResult(
                 success=True,
@@ -75,9 +97,9 @@ class DRYAgent(SubAgent):
                 recommendations=["No DRY violations detected"],
             )
 
-        return self._apply_and_save_dry_fixes(file_path, content, violations)
+        return await self._apply_and_save_dry_fixes(file_path, content, violations)
 
-    def _apply_and_save_dry_fixes(
+    async def _apply_and_save_dry_fixes(
         self,
         file_path: Path,
         content: str,
@@ -96,6 +118,28 @@ class DRYAgent(SubAgent):
                 remaining_issues=[f"Failed to write fixed file: {file_path}"],
             )
 
+        # Enhance recommendations with semantic insights and session continuity
+        recommendations = ["Verify functionality after DRY fixes"]
+        if hasattr(self, "current_semantic_insight") and self.current_semantic_insight:
+            recommendations = self.semantic_enhancer.enhance_recommendations(
+                recommendations, self.current_semantic_insight
+            )
+            # Log semantic context for debugging
+            summary = self.semantic_enhancer.get_semantic_context_summary(
+                self.current_semantic_insight
+            )
+            self.log(f"Semantic context: {summary}")
+
+            # Store insight for session continuity
+            await self.semantic_enhancer.store_insight_to_session(
+                self.current_semantic_insight, "DRYAgent"
+            )
+
+        # Enhance with session-stored insights
+        recommendations = await get_session_enhanced_recommendations(
+            recommendations, "DRYAgent", self.context.project_path
+        )
+
         return FixResult(
             success=True,
             confidence=0.8,
@@ -104,7 +148,7 @@ class DRYAgent(SubAgent):
                 "Consolidated repetitive patterns",
             ],
             files_modified=[str(file_path)],
-            recommendations=["Verify functionality after DRY fixes"],
+            recommendations=recommendations,
         )
 
     def _create_no_fixes_result(self) -> FixResult:
@@ -397,5 +441,145 @@ def _ensure_path(path: str | Path) -> Path:
 
         return modified
 
+    async def _detect_semantic_violations(
+        self, content: str, file_path: Path
+    ) -> list[dict[str, t.Any]]:
+        """Detect semantic code duplicates using vector similarity."""
+        violations = []
+
+        try:
+            # Extract key code functions for semantic analysis
+            code_elements = self._extract_code_functions(content)
+
+            for element in code_elements:
+                if element["type"] == "function" and len(element["body"]) > 50:
+                    # Search for semantically similar functions
+                    insight = await self.semantic_enhancer.find_duplicate_patterns(
+                        element["signature"]
+                        + "\n"
+                        + element["body"][:200],  # Include body sample
+                        current_file=file_path,
+                    )
+
+                    if insight.high_confidence_matches > 0:
+                        violations.append(
+                            {
+                                "type": "semantic_duplicate",
+                                "element": element,
+                                "similar_patterns": insight.related_patterns[
+                                    :3
+                                ],  # Top 3 matches
+                                "confidence_score": insight.high_confidence_matches
+                                / insight.total_matches
+                                if insight.total_matches > 0
+                                else 0,
+                                "suggestion": "Consider extracting common functionality to shared utility",
+                            }
+                        )
+
+                        # Store insight for recommendation enhancement
+                        self.current_semantic_insight = insight
+
+        except Exception as e:
+            self.log(f"Warning: Semantic violation detection failed: {e}")
+
+        return violations
+
+    def _extract_code_functions(self, content: str) -> list[dict[str, t.Any]]:
+        """Extract functions from code for semantic analysis."""
+        functions: list[dict[str, t.Any]] = []
+        lines = content.split("\n")
+        current_function = None
+
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+
+            if self._should_skip_line(stripped, current_function, line):
+                continue
+
+            indent = len(line) - len(line.lstrip())
+
+            if self._is_function_definition(stripped):
+                current_function = self._handle_function_definition(
+                    functions, current_function, stripped, indent, i
+                )
+            elif current_function:
+                current_function = self._handle_function_body_line(
+                    functions, current_function, line, stripped, indent, i
+                )
+
+        # Add last function if exists
+        if current_function:
+            current_function["end_line"] = len(lines)
+            functions.append(current_function)
+
+        return functions
+
+    def _should_skip_line(
+        self, stripped: str, current_function: dict[str, t.Any] | None, line: str
+    ) -> bool:
+        """Check if line should be skipped during function extraction."""
+        if not stripped or stripped.startswith("#"):
+            if current_function:
+                current_function["body"] += line + "\n"
+            return True
+        return False
+
+    def _is_function_definition(self, stripped: str) -> bool:
+        """Check if line is a function definition."""
+        return stripped.startswith("def ") and "(" in stripped
+
+    def _handle_function_definition(
+        self,
+        functions: list[dict[str, t.Any]],
+        current_function: dict[str, t.Any] | None,
+        stripped: str,
+        indent: int,
+        line_index: int,
+    ) -> dict[str, t.Any]:
+        """Handle a new function definition."""
+        # Save previous function if exists
+        if current_function:
+            functions.append(current_function)
+
+        func_name = stripped.split("(")[0].replace("def ", "").strip()
+        return {
+            "type": "function",
+            "name": func_name,
+            "signature": stripped,
+            "start_line": line_index + 1,
+            "body": "",
+            "indent_level": indent,
+        }
+
+    def _handle_function_body_line(
+        self,
+        functions: list[dict[str, t.Any]],
+        current_function: dict[str, t.Any],
+        line: str,
+        stripped: str,
+        indent: int,
+        line_index: int,
+    ) -> dict[str, t.Any] | None:
+        """Handle a line within a function body."""
+        # Check if we're still inside the function
+        if self._is_line_inside_function(current_function, indent, stripped):
+            current_function["body"] += line + "\n"
+            return current_function
+        else:
+            # Function ended
+            current_function["end_line"] = line_index
+            functions.append(current_function)
+            return None
+
+    def _is_line_inside_function(
+        self, current_function: dict[str, t.Any], indent: int, stripped: str
+    ) -> bool:
+        """Check if line is still inside the current function."""
+        return indent > current_function["indent_level"] or (
+            indent == current_function["indent_level"]
+            and stripped.startswith(('"', "'", "@"))
+        )
+
 
 agent_registry.register(DRYAgent)

crackerjack/agents/enhanced_coordinator.py

@@ -0,0 +1,279 @@
+"""
+Enhanced AgentCoordinator with Claude Code external agent integration.
+
+This module extends the base AgentCoordinator to seamlessly integrate with
+Claude Code's external agents while maintaining full compatibility with
+the existing crackerjack agent system.
+"""
+
+import typing as t
+
+from .base import AgentContext, FixResult, Issue
+from .claude_code_bridge import ClaudeCodeBridge
+from .coordinator import AgentCoordinator
+
+
+class EnhancedAgentCoordinator(AgentCoordinator):
+    """
+    AgentCoordinator enhanced with Claude Code external agent integration.
+
+    This coordinator maintains all the functionality of the base AgentCoordinator
+    while adding intelligent consultation with external Claude Code agents
+    when handling complex issues.
+    """
+
+    def __init__(
+        self,
+        context: AgentContext,
+        cache: t.Any = None,
+        enable_external_agents: bool = True,
+    ) -> None:
+        super().__init__(context, cache)
+        self.claude_bridge = ClaudeCodeBridge(context)
+        self.external_agents_enabled = enable_external_agents
+        self._external_consultation_stats: dict[str, int] = {
+            "consultations_requested": 0,
+            "consultations_successful": 0,
+            "improvements_achieved": 0,
+        }
+
+        self.logger.info(
+            f"Enhanced coordinator initialized with external agents: {enable_external_agents}"
+        )
+
+    def enable_external_agents(self, enabled: bool = True) -> None:
+        """Enable or disable external Claude Code agent consultation."""
+        self.external_agents_enabled = enabled
+        self.logger.info(f"External agents {'enabled' if enabled else 'disabled'}")
+
+    def get_external_consultation_stats(self) -> dict[str, int]:
+        """Get statistics about external agent consultations."""
+        return self._external_consultation_stats.copy()
+
+    async def handle_issues_proactively(self, issues: list[Issue]) -> FixResult:
+        """
+        Enhanced proactive handling with external agent consultation.
+
+        This method extends the base proactive handling to:
+        1. Identify issues that would benefit from external consultation
+        2. Pre-consult with relevant Claude Code agents for strategic guidance
+        3. Apply the combined internal/external strategy
+        """
+        if not self.external_agents_enabled:
+            return await super().handle_issues_proactively(issues)
+
+        if not self.agents:
+            self.initialize_agents()
+
+        if not issues:
+            return FixResult(success=True, confidence=1.0)
+
+        self.logger.info(f"Enhanced proactive handling of {len(issues)} issues")
+
+        # Pre-analyze issues for external consultation opportunities
+        strategic_consultations = await self._pre_consult_for_strategy(issues)
+
+        # Create enhanced architectural plan incorporating external guidance
+        architectural_plan = await self._create_enhanced_architectural_plan(
+            issues, strategic_consultations
+        )
+
+        # Apply fixes with enhanced strategy
+        overall_result = await self._apply_enhanced_fixes_with_plan(
+            issues, architectural_plan, strategic_consultations
+        )
+
+        # Post-process with external validation if needed
+        validated_result = await self._validate_with_external_agents(
+            overall_result, architectural_plan
+        )
+
+        self._update_consultation_stats(strategic_consultations, validated_result)
+
+        return validated_result
+
+    async def _pre_consult_for_strategy(self, issues: list[Issue]) -> dict[str, t.Any]:
+        """Pre-consult with external agents for strategic guidance."""
+        strategic_consultations: dict[str, t.Any] = {
+            "crackerjack_architect_guidance": None,
+            "specialist_recommendations": {},
+            "coordination_strategy": "internal_first",
+        }
+
+        # Identify complex issues that need architectural guidance
+        complex_issues = [
+            issue
+            for issue in issues
+            if self.claude_bridge.should_consult_external_agent(issue, 0.0)
+        ]
+
+        if not complex_issues:
+            return strategic_consultations
+
+        # Consult crackerjack-architect for overall strategy if available
+        if self.claude_bridge.verify_agent_availability("crackerjack-architect"):
+            self._external_consultation_stats["consultations_requested"] += 1
+
+            # Use the first complex issue as representative for strategic planning
+            primary_issue = complex_issues[0]
+            architect_consultation = await self.claude_bridge.consult_external_agent(
+                primary_issue,
+                "crackerjack-architect",
+                {"context": "strategic_planning"},
+            )
+
+            if architect_consultation.get("status") == "success":
+                strategic_consultations["crackerjack_architect_guidance"] = (
+                    architect_consultation
+                )
+                strategic_consultations["coordination_strategy"] = "architect_guided"
+                self._external_consultation_stats["consultations_successful"] += 1
+
+        return strategic_consultations
+
+    async def _create_enhanced_architectural_plan(
+        self, issues: list[Issue], strategic_consultations: dict[str, t.Any]
+    ) -> dict[str, t.Any]:
+        """Create architectural plan enhanced with external agent guidance."""
+        # Start with the base architectural plan
+        base_plan = await self._create_architectural_plan(issues)
+
+        # Enhance with external guidance if available
+        architect_guidance = strategic_consultations.get(
+            "crackerjack_architect_guidance"
+        )
+        if architect_guidance and architect_guidance.get("status") == "success":
+            # Integrate external architectural guidance
+            base_plan["external_guidance"] = architect_guidance
+            base_plan["enhanced_patterns"] = architect_guidance.get("patterns", [])
+            base_plan["external_validation"] = architect_guidance.get(
+                "validation_steps", []
+            )
+
+            # Update strategy based on external guidance
+            if "strategy" in architect_guidance:
+                base_plan["strategy"] = "external_specialist_guided"
+
+        return base_plan
+
+    async def _apply_enhanced_fixes_with_plan(
+        self,
+        issues: list[Issue],
+        plan: dict[str, t.Any],
+        strategic_consultations: dict[str, t.Any],
+    ) -> FixResult:
+        """Apply fixes using enhanced strategy with external guidance."""
+        # Use the base implementation but with enhanced plan
+        return await self._apply_fixes_with_plan(issues, plan)
+
+    async def _validate_with_external_agents(
+        self, result: FixResult, plan: dict[str, t.Any]
+    ) -> FixResult:
+        """Post-validate results with external agents if configured."""
+        external_validation = plan.get("external_validation", [])
+
+        if not external_validation or not self.external_agents_enabled:
+            return result
+
+        # Add validation recommendations from external agents
+        validation_recommendations = [
+            f"External validation: {validation_step}"
+            for validation_step in external_validation
+        ]
+
+        enhanced_result = FixResult(
+            success=result.success,
+            confidence=min(
+                result.confidence + 0.1, 1.0
+            ),  # Slight confidence boost for external validation
+            fixes_applied=result.fixes_applied.copy(),
+            remaining_issues=result.remaining_issues.copy(),
+            recommendations=result.recommendations + validation_recommendations,
+            files_modified=result.files_modified.copy(),
+        )
+
+        return enhanced_result
+
+    def _update_consultation_stats(
+        self, strategic_consultations: dict[str, t.Any], result: FixResult
+    ) -> None:
+        """Update statistics about external consultations."""
+        if strategic_consultations.get("crackerjack_architect_guidance"):
+            if result.success and result.confidence > 0.8:
+                self._external_consultation_stats["improvements_achieved"] += 1
+
+    async def _handle_with_single_agent_enhanced(
+        self, agent: t.Any, issue: Issue
+    ) -> FixResult:
+        """Enhanced single agent handling with external consultation."""
+        # Check if this agent should consult external experts
+        internal_result = await super()._handle_with_single_agent(agent, issue)
+
+        # If the agent is proactive and has external consultation capability, enhance it
+        if (
+            hasattr(agent, "claude_bridge")
+            and self.external_agents_enabled
+            and not internal_result.success
+        ):
+            # Try external consultation for failed fixes
+            recommended_agents = self.claude_bridge.get_recommended_external_agents(
+                issue
+            )
+            if recommended_agents:
+                self._external_consultation_stats["consultations_requested"] += 1
+
+                # Consult the top recommended external agent
+                consultation = await self.claude_bridge.consult_external_agent(
+                    issue, recommended_agents[0]
+                )
+
+                if consultation.get("status") == "success":
+                    self._external_consultation_stats["consultations_successful"] += 1
+                    enhanced_result = self.claude_bridge.create_enhanced_fix_result(
+                        internal_result, [consultation]
+                    )
+                    return enhanced_result
+
+        return internal_result
+
+    def get_enhanced_agent_capabilities(self) -> dict[str, dict[str, t.Any]]:
+        """Get capabilities including external agent integration."""
+        base_capabilities = self.get_agent_capabilities()
+
+        # Add information about external agent integration
+        enhanced_info = {
+            "external_agents_enabled": self.external_agents_enabled,
+            "available_external_agents": [
+                agent
+                for agent in (
+                    "crackerjack-architect",
+                    "python-pro",
+                    "security-auditor",
+                    "refactoring-specialist",
+                    "crackerjack-test-specialist",
+                )
+                if self.claude_bridge.verify_agent_availability(agent)
+            ],
+            "consultation_stats": self.get_external_consultation_stats(),
+            "claude_code_bridge": {
+                "agent_mapping_coverage": len(self.claude_bridge._get_agent_mapping()),
+                "consultation_threshold": self.claude_bridge._get_consultation_threshold(),
+            },
+        }
+
+        return base_capabilities | {"_enhanced_coordinator_info": enhanced_info}
+
+
+def create_enhanced_coordinator(
+    context: AgentContext, cache: t.Any = None, enable_external_agents: bool = True
+) -> EnhancedAgentCoordinator:
+    """
+    Factory function to create an enhanced coordinator.
+
+    This function provides a clean interface for creating coordinators
+    with external agent integration while maintaining compatibility
+    with existing code.
+    """
+    return EnhancedAgentCoordinator(
+        context=context, cache=cache, enable_external_agents=enable_external_agents
+    )