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

crackerjack/agents/test_specialist_agent.py

@@ -0,0 +1,486 @@
+import re
+from pathlib import Path
+
+from .base import (
+    AgentContext,
+    FixResult,
+    Issue,
+    IssueType,
+    SubAgent,
+    agent_registry,
+)
+
+
+class TestSpecialistAgent(SubAgent):
+    def __init__(self, context: AgentContext) -> None:
+        super().__init__(context)
+        self.common_test_patterns = {
+            "fixture_not_found": r"fixture '(\w+)' not found",
+            "import_error": r"ImportError|ModuleNotFoundError",
+            "assertion_error": r"AssertionError|assert .+ ==",
+            "attribute_error": r"AttributeError: .+ has no attribute",
+            "mock_spec_error": r"MockSpec|spec.*Mock",
+            "hardcoded_path": r"'/test/path'|/test/path",
+            "missing_import": r"name '(\w+)' is not defined",
+            "pydantic_validation": r"ValidationError|validation error",
+        }
+
+    def get_supported_types(self) -> set[IssueType]:
+        return {IssueType.TEST_FAILURE, IssueType.IMPORT_ERROR}
+
+    async def can_handle(self, issue: Issue) -> float:
+        if issue.type not in self.get_supported_types():
+            return 0.0
+
+        perfect_match_score = self._check_perfect_test_matches(issue.message)
+        if perfect_match_score > 0:
+            return perfect_match_score
+
+        pattern_score = self._check_test_patterns(issue.message)
+        if pattern_score > 0:
+            return pattern_score
+
+        file_score = self._check_test_file_path(issue.file_path)
+        if file_score > 0:
+            return file_score
+
+        return self._check_general_test_failure(issue.type)
+
+    def _check_perfect_test_matches(self, message: str) -> float:
+        message_lower = message.lower()
+        test_keywords = [
+            "failed test",
+            "test failed",
+            "pytest",
+            "fixture",
+            "assertion",
+            "mock",
+            "conftest",
+        ]
+
+        return (
+            1.0 if any(keyword in message_lower for keyword in test_keywords) else 0.0
+        )
+
+    def _check_test_patterns(self, message: str) -> float:
+        for pattern in self.common_test_patterns.values():
+            if re.search(pattern, message, re.IGNORECASE):
+                return 0.9
+        return 0.0
+
+    def _check_test_file_path(self, file_path: str | None) -> float:
+        if file_path and ("test_" in file_path or "/tests/" in file_path):
+            return 0.8
+        return 0.0
+
+    def _check_general_test_failure(self, issue_type: IssueType) -> float:
+        return 0.7 if issue_type == IssueType.TEST_FAILURE else 0.0
+
+    async def analyze_and_fix(self, issue: Issue) -> FixResult:
+        self.log(f"Analyzing test issue: {issue.message}")
+
+        try:
+            fixes_applied, files_modified = await self._apply_issue_fixes(issue)
+            recommendations = self._get_failure_recommendations(fixes_applied)
+
+            return self._create_fix_result(
+                fixes_applied,
+                files_modified,
+                recommendations,
+            )
+
+        except Exception as e:
+            self.log(f"Error fixing test issue: {e}", "ERROR")
+            return self._create_error_fix_result(e)
+
+    async def _apply_issue_fixes(self, issue: Issue) -> tuple[list[str], list[str]]:
+        fixes_applied: list[str] = []
+        files_modified: list[str] = []
+
+        failure_type = self._identify_failure_type(issue)
+        self.log(f"Identified failure type: {failure_type}")
+
+        targeted_fixes = await self._apply_targeted_fixes(failure_type, issue)
+        fixes_applied.extend(targeted_fixes)
+
+        file_fixes, file_modified = await self._apply_file_fixes(issue)
+        fixes_applied.extend(file_fixes)
+        if file_modified and issue.file_path:
+            files_modified.append(issue.file_path)
+
+        general_fixes = await self._apply_general_test_fixes()
+        fixes_applied.extend(general_fixes)
+
+        return fixes_applied, files_modified
+
+    async def _apply_targeted_fixes(self, failure_type: str, issue: Issue) -> list[str]:
+        if failure_type == "fixture_not_found":
+            return await self._fix_missing_fixtures(issue)
+        if failure_type == "import_error":
+            return await self._fix_import_errors(issue)
+        if failure_type == "hardcoded_path":
+            return await self._fix_hardcoded_paths(issue)
+        if failure_type == "mock_spec_error":
+            return await self._fix_mock_issues(issue)
+        if failure_type == "pydantic_validation":
+            return await self._fix_pydantic_issues(issue)
+        return []
+
+    async def _apply_file_fixes(self, issue: Issue) -> tuple[list[str], bool]:
+        if not issue.file_path or not (
+            "test_" in issue.file_path or "/tests/" in issue.file_path
+        ):
+            return [], False
+
+        file_fixes = await self._fix_test_file_issues(issue.file_path)
+        return file_fixes, len(file_fixes) > 0
+
+    def _get_failure_recommendations(self, fixes_applied: list[str]) -> list[str]:
+        if fixes_applied:
+            return []
+
+        return [
+            "Check test file imports and fixture definitions",
+            "Verify mock objects are properly configured",
+            "Ensure test data paths use tmp_path fixture",
+            "Review assertion statements for correctness",
+        ]
+
+    def _create_fix_result(
+        self,
+        fixes_applied: list[str],
+        files_modified: list[str],
+        recommendations: list[str],
+    ) -> FixResult:
+        success = len(fixes_applied) > 0
+        confidence = 0.8 if success else 0.4
+
+        return FixResult(
+            success=success,
+            confidence=confidence,
+            fixes_applied=fixes_applied,
+            files_modified=files_modified,
+            recommendations=recommendations,
+        )
+
+    def _create_error_fix_result(self, error: Exception) -> FixResult:
+        return FixResult(
+            success=False,
+            confidence=0.0,
+            remaining_issues=[f"Failed to fix test issue: {error}"],
+        )
+
+    def _identify_failure_type(self, issue: Issue) -> str:
+        message = issue.message
+
+        for pattern_name, pattern in self.common_test_patterns.items():
+            if re.search(pattern, message, re.IGNORECASE):
+                return pattern_name
+
+        return "unknown"
+
+    async def _fix_missing_fixtures(self, issue: Issue) -> list[str]:
+        fixes: list[str] = []
+
+        match = re.search(r"fixture '(\w+)' not found", issue.message)
+        if not match:
+            return fixes
+
+        fixture_name = match.group(1)
+        self.log(f"Attempting to fix missing fixture: {fixture_name}")
+
+        if fixture_name == "temp_pkg_path":
+            fixes.extend(await self._add_temp_pkg_path_fixture(issue.file_path))
+        elif fixture_name == "console":
+            fixes.extend(await self._add_console_fixture(issue.file_path))
+        elif fixture_name in ("tmp_path", "tmpdir"):
+            fixes.extend(await self._add_temp_path_fixture(issue.file_path))
+
+        return fixes
+
+    async def _fix_import_errors(self, issue: Issue) -> list[str]:
+        if not self._is_valid_file_path(issue.file_path) or issue.file_path is None:
+            return []
+
+        file_path = Path(issue.file_path)
+        content = self.context.get_file_content(file_path)
+        if not content:
+            return []
+
+        lines = content.split("\n")
+        fixes, modified = self._apply_import_fixes(lines, content, issue.file_path)
+
+        if modified:
+            self._save_import_fixes(file_path, lines, issue.file_path)
+
+        return fixes
+
+    def _is_valid_file_path(self, file_path: str | None) -> bool:
+        return file_path is not None and Path(file_path).exists()
+
+    def _apply_import_fixes(
+        self,
+        lines: list[str],
+        content: str,
+        file_path: str,
+    ) -> tuple[list[str], bool]:
+        fixes: list[str] = []
+        modified = False
+
+        if self._needs_pytest_import(content):
+            self._add_pytest_import(lines)
+            fixes.append(f"Added missing pytest import to {file_path}")
+            modified = True
+
+        if self._needs_pathlib_import(content):
+            lines.insert(0, "from pathlib import Path")
+            fixes.append(f"Added missing pathlib import to {file_path}")
+            modified = True
+
+        if self._needs_mock_import(content):
+            lines.insert(0, "from unittest.mock import Mock")
+            fixes.append(f"Added missing Mock import to {file_path}")
+            modified = True
+
+        return fixes, modified
+
+    def _needs_pytest_import(self, content: str) -> bool:
+        return "pytest" not in content and "import pytest" not in content
+
+    def _needs_pathlib_import(self, content: str) -> bool:
+        return "Path(" in content and "from pathlib import Path" not in content
+
+    def _needs_mock_import(self, content: str) -> bool:
+        return "Mock()" in content and "from unittest.mock import Mock" not in content
+
+    def _add_pytest_import(self, lines: list[str]) -> None:
+        import_section_end = self._find_import_section_end(lines)
+        lines.insert(import_section_end, "import pytest")
+
+    def _find_import_section_end(self, lines: list[str]) -> int:
+        import_section_end = 0
+        for i, line in enumerate(lines):
+            if line.strip().startswith(("import ", "from ")):
+                import_section_end = i + 1
+            elif line.strip() == "" and import_section_end > 0:
+                break
+        return import_section_end
+
+    def _save_import_fixes(
+        self,
+        file_path: Path,
+        lines: list[str],
+        file_path_str: str,
+    ) -> None:
+        if self.context.write_file_content(file_path, "\n".join(lines)):
+            self.log(f"Fixed imports in {file_path_str}")
+
+    async def _fix_hardcoded_paths(self, issue: Issue) -> list[str]:
+        fixes: list[str] = []
+
+        if not issue.file_path:
+            return fixes
+
+        file_path = Path(issue.file_path)
+        content = self.context.get_file_content(file_path)
+        if not content:
+            return fixes
+
+        original_content = content
+
+        content = (
+            content.replace('Path("/test/path")', "tmp_path")
+            .replace('"/test/path"', "str(tmp_path)")
+            .replace("'/test/path'", "str(tmp_path)")
+        )
+
+        if content != original_content:
+            if self.context.write_file_content(file_path, content):
+                fixes.append(f"Fixed hardcoded paths in {issue.file_path}")
+                self.log(f"Fixed hardcoded paths in {issue.file_path}")
+
+        return fixes
+
+    async def _fix_mock_issues(self, issue: Issue) -> list[str]:
+        fixes: list[str] = []
+
+        if (
+            not self._is_valid_mock_issue_file(issue.file_path)
+            or issue.file_path is None
+        ):
+            return fixes
+
+        file_path = Path(issue.file_path)
+        content = self.context.get_file_content(file_path)
+        if not content:
+            return fixes
+
+        original_content = content
+        content, mock_fixes = self._apply_mock_fixes_to_content(
+            content,
+            issue.file_path,
+        )
+        fixes.extend(mock_fixes)
+
+        if content != original_content:
+            self._save_mock_fixes(file_path, content, issue.file_path)
+
+        return fixes
+
+    def _is_valid_mock_issue_file(self, file_path: str | None) -> bool:
+        return file_path is not None
+
+    def _apply_mock_fixes_to_content(
+        self,
+        content: str,
+        file_path: str,
+    ) -> tuple[str, list[str]]:
+        fixes: list[str] = []
+
+        if self._needs_console_mock_fix(content):
+            content = self._fix_console_mock_usage(content)
+            fixes.append(f"Fixed Mock usage in {file_path}")
+
+        return content, fixes
+
+    def _needs_console_mock_fix(self, content: str) -> bool:
+        return "console = Mock()" in content and "Console" not in content
+
+    def _fix_console_mock_usage(self, content: str) -> str:
+        content = content.replace("console = Mock()", "console = Console()")
+        return self._ensure_console_import(content)
+
+    def _ensure_console_import(self, content: str) -> str:
+        if "from rich.console import Console" in content:
+            return content
+
+        lines = content.split("\n")
+        lines = self._add_console_import_to_lines(lines)
+        return "\n".join(lines)
+
+    def _add_console_import_to_lines(self, lines: list[str]) -> list[str]:
+        for i, line in enumerate(lines):
+            if line.startswith("from rich") or "rich" in line:
+                lines.insert(i + 1, "from rich.console import Console")
+                return lines
+
+        lines.insert(0, "from rich.console import Console")
+        return lines
+
+    def _save_mock_fixes(
+        self,
+        file_path: Path,
+        content: str,
+        file_path_str: str,
+    ) -> None:
+        if self.context.write_file_content(file_path, content):
+            self.log(f"Fixed Mock issues in {file_path_str}")
+
+    async def _fix_pydantic_issues(self, issue: Issue) -> list[str]:
+        return []
+
+    async def _add_temp_pkg_path_fixture(self, file_path: str | None) -> list[str]:
+        if not file_path:
+            return []
+
+        fixes: list[str] = []
+        path = Path(file_path)
+        content = self.context.get_file_content(path)
+        if not content:
+            return fixes
+
+        if "@pytest.fixture" in content and "temp_pkg_path" in content:
+            return fixes
+
+        fixture_code = '''
+@pytest.fixture
+def temp_pkg_path(tmp_path) -> Path:
+    """Create temporary package path."""
+    return tmp_path
+'''
+
+        lines = content.split("\n")
+
+        for i, line in enumerate(lines):
+            if line.startswith("class Test") and i > 0:
+                lines.insert(i + 1, fixture_code)
+                break
+        else:
+            lines.append(fixture_code)
+
+        if self.context.write_file_content(path, "\n".join(lines)):
+            fixes.append(f"Added temp_pkg_path fixture to {file_path}")
+
+        return fixes
+
+    async def _add_console_fixture(self, file_path: str | None) -> list[str]:
+        if not file_path:
+            return []
+
+        fixes: list[str] = []
+        path = Path(file_path)
+        content = self.context.get_file_content(path)
+        if not content:
+            return fixes
+
+        fixture_code = '''
+@pytest.fixture
+def console() -> Console:
+    """Create console instance for testing."""
+    return Console()
+'''
+
+        lines = content.split("\n")
+        lines.append(fixture_code)
+
+        if "from rich.console import Console" not in content:
+            lines.insert(0, "from rich.console import Console")
+
+        if self.context.write_file_content(path, "\n".join(lines)):
+            fixes.append(f"Added console fixture to {file_path}")
+
+        return fixes
+
+    async def _add_temp_path_fixture(self, file_path: str | None) -> list[str]:
+        return [
+            f"Note: tmp_path is a built-in pytest fixture - check fixture usage in {file_path}",
+        ]
+
+    async def _fix_test_file_issues(self, file_path: str) -> list[str]:
+        fixes: list[str] = []
+
+        path = Path(file_path)
+        content = self.context.get_file_content(path)
+        if not content:
+            return fixes
+
+        original_content = content
+
+        if "import pytest" not in content:
+            lines = content.split("\n")
+            lines.insert(0, "import pytest")
+            content = "\n".join(lines)
+            fixes.append(f"Added pytest import to {file_path}")
+
+        content = re.sub(r"assert (.+) == (.+)", r"assert \1 == \2", content)
+
+        if content != original_content:
+            if self.context.write_file_content(path, content):
+                self.log(f"Applied general fixes to {file_path}")
+
+        return fixes
+
+    async def _apply_general_test_fixes(self) -> list[str]:
+        fixes: list[str] = []
+
+        returncode, _, stderr = await self.run_command(
+            ["uv", "run", "python", "-m", "pytest", "--collect-only", "-q"],
+        )
+
+        if returncode != 0 and "ImportError" in stderr:
+            fixes.append("Identified import issues in test collection")
+
+        return fixes
+
+
+agent_registry.register(TestSpecialistAgent)

crackerjack/agents/tracker.py

@@ -0,0 +1,212 @@
+import time
+import typing as t
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Any
+
+from .base import FixResult, Issue
+
+
+@dataclass
+class AgentActivity:
+    agent_type: str
+    confidence: float
+    status: str
+    current_issue: Issue | None = None
+    start_time: float = field(default_factory=time.time)
+    processing_time: float = 0.0
+    result: FixResult | None = None
+
+
+class AgentTracker:
+    def __init__(self) -> None:
+        self.active_agents: dict[str, AgentActivity] = {}
+        self.completed_activities: list[AgentActivity] = []
+        self.performance_metrics: defaultdict[str, list[float]] = defaultdict(list)
+        self.cache_stats = {"hits": 0, "misses": 0}
+        self.total_issues_processed = 0
+        self.coordinator_status = "idle"
+        self.agent_registry: dict[str, t.Any] = {
+            "total_agents": 0,
+            "initialized_agents": 0,
+            "agent_types": [],
+        }
+
+    def set_coordinator_status(self, status: str) -> None:
+        self.coordinator_status = status
+
+    def register_agents(self, agent_types: list[str]) -> None:
+        self.agent_registry = {
+            "total_agents": len(agent_types),
+            "initialized_agents": len(agent_types),
+            "agent_types": agent_types,
+        }
+
+    def track_agent_evaluation(
+        self,
+        agent_type: str,
+        issue: Issue,
+        confidence: float,
+    ) -> None:
+        self.active_agents[agent_type] = AgentActivity(
+            agent_type=agent_type,
+            confidence=confidence,
+            status="evaluating",
+            current_issue=issue,
+        )
+
+    def track_agent_processing(
+        self,
+        agent_type: str,
+        issue: Issue,
+        confidence: float,
+    ) -> None:
+        if agent_type in self.active_agents:
+            activity = self.active_agents[agent_type]
+            activity.status = "processing"
+            activity.current_issue = issue
+            activity.confidence = confidence
+        else:
+            self.active_agents[agent_type] = AgentActivity(
+                agent_type=agent_type,
+                confidence=confidence,
+                status="processing",
+                current_issue=issue,
+            )
+
+    def track_agent_complete(self, agent_type: str, result: FixResult) -> None:
+        if agent_type not in self.active_agents:
+            return
+
+        activity = self.active_agents[agent_type]
+        activity.status = "completed" if result.success else "failed"
+        activity.result = result
+        activity.processing_time = time.time() - activity.start_time
+
+        self.performance_metrics[agent_type].append(activity.processing_time)
+        self.total_issues_processed += 1
+
+        self.completed_activities.append(activity)
+        del self.active_agents[agent_type]
+
+    def track_cache_hit(self) -> None:
+        self.cache_stats["hits"] += 1
+
+    def track_cache_miss(self) -> None:
+        self.cache_stats["misses"] += 1
+
+    def get_status(self) -> dict[str, Any]:
+        active_agents: list[dict[str, Any]] = []
+
+        for agent_type, activity in self.active_agents.items():
+            agent_data: dict[str, Any] = {
+                "agent_type": agent_type,
+                "confidence": activity.confidence,
+                "status": activity.status,
+                "processing_time": time.time() - activity.start_time,
+                "start_time": activity.start_time,
+            }
+
+            if activity.current_issue:
+                agent_data["current_issue"] = {
+                    "type": activity.current_issue.type.value,
+                    "message": activity.current_issue.message,
+                    "priority": activity.current_issue.severity.value,
+                    "file_path": activity.current_issue.file_path,
+                }
+
+            active_agents.append(agent_data)
+
+        return {
+            "coordinator_status": self.coordinator_status,
+            "active_agents": active_agents,
+            "agent_registry": self.agent_registry.copy(),
+        }
+
+    def get_metrics(self) -> dict[str, Any]:
+        total_completed = len(self.completed_activities)
+        successful = sum(
+            1
+            for activity in self.completed_activities
+            if activity.result and activity.result.success
+        )
+        success_rate = successful / total_completed if total_completed > 0 else 0.0
+
+        all_times: list[float] = []
+        for times in self.performance_metrics.values():
+            all_times.extend(times)
+
+        avg_processing_time = sum(all_times) / len(all_times) if all_times else 0.0
+
+        total_requests = self.cache_stats["hits"] + self.cache_stats["misses"]
+        cache_hit_rate = (
+            self.cache_stats["hits"] / total_requests if total_requests > 0 else 0.0
+        )
+
+        return {
+            "total_issues_processed": self.total_issues_processed,
+            "cache_hits": self.cache_stats["hits"],
+            "cache_misses": self.cache_stats["misses"],
+            "cache_hit_rate": cache_hit_rate,
+            "average_processing_time": avg_processing_time,
+            "success_rate": success_rate,
+            "completed_activities": total_completed,
+        }
+
+    def get_agent_summary(self) -> dict[str, Any]:
+        active_count = len(self.active_agents)
+        cache_hits = self.cache_stats["hits"]
+
+        active_summary: list[dict[str, Any]] = []
+        for agent_type, activity in self.active_agents.items():
+            emoji = self._get_agent_emoji(agent_type)
+            processing_time = time.time() - activity.start_time
+
+            active_summary.append(
+                {
+                    "display": f"{emoji} {agent_type}: {activity.status.title()} ({processing_time:.1f}s)",
+                    "agent_type": agent_type,
+                    "status": activity.status,
+                    "processing_time": processing_time,
+                },
+            )
+
+        return {
+            "active_count": active_count,
+            "cached_fixes": cache_hits,
+            "active_agents": active_summary,
+        }
+
+    def _get_agent_emoji(self, agent_type: str) -> str:
+        return {
+            "FormattingAgent": "🎨",
+            "SecurityAgent": "🔒",
+            "TestSpecialistAgent": "🧪",
+            "TestCreationAgent": "➕",
+        }.get(agent_type, "🤖")
+
+    def reset(self) -> None:
+        self.active_agents.clear()
+        self.completed_activities.clear()
+        self.performance_metrics.clear()
+        self.cache_stats = {"hits": 0, "misses": 0}
+        self.total_issues_processed = 0
+        self.coordinator_status = "idle"
+
+
+_global_tracker = None
+
+
+def get_agent_tracker() -> AgentTracker:
+    global _global_tracker
+    if _global_tracker is None:
+        _global_tracker = AgentTracker()
+    return _global_tracker
+
+
+def reset_agent_tracker() -> None:
+    global _global_tracker
+    if _global_tracker:
+        _global_tracker.reset()
+    else:
+        _global_tracker = AgentTracker()