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

crackerjack/orchestration/coverage_improvement.py

@@ -0,0 +1,223 @@
+"""Coverage improvement orchestration.
+
+This module provides proactive test coverage improvement by analyzing coverage gaps
+and triggering the TestCreationAgent to automatically generate missing tests.
+Integrated into the AI agent workflow after successful test execution.
+"""
+
+import logging
+import typing as t
+from pathlib import Path
+
+from crackerjack.agents.base import Issue, IssueType, Priority
+from crackerjack.agents.test_creation_agent import TestCreationAgent
+from crackerjack.services.coverage_ratchet import CoverageRatchetService
+
+
+class CoverageImprovementOrchestrator:
+    """Orchestrates automatic test coverage improvement."""
+
+    def __init__(self, project_path: Path, console: t.Any = None) -> None:
+        self.project_path = project_path
+        self.logger = logging.getLogger(__name__)
+        self.console = console
+        self.coverage_service = CoverageRatchetService(project_path, console)
+        self.min_coverage_improvement = 2.0  # Minimum 2% improvement target per run
+
+    async def should_improve_coverage(
+        self, current_coverage: float | None = None
+    ) -> bool:
+        """Determine if coverage improvement should be attempted.
+
+        Args:
+            current_coverage: Current coverage percentage, will be detected if None
+
+        Returns:
+            True if coverage improvement should be attempted
+        """
+        try:
+            if current_coverage is None:
+                coverage_status = self.coverage_service.get_status_report()
+                current_coverage = coverage_status.get("current_coverage", 0.0)
+
+            # Always try to improve if coverage is below 100%
+            if current_coverage is not None and current_coverage < 100.0:
+                self.logger.info(
+                    f"Coverage at {current_coverage:.1f}% - improvement recommended"
+                )
+                return True
+
+            self.logger.info("Coverage at 100% - no improvement needed")
+            return False
+
+        except Exception as e:
+            self.logger.warning(f"Could not determine coverage status: {e}")
+            # Default to trying improvement if we can't determine coverage
+            return True
+
+    async def create_coverage_improvement_issue(
+        self, coverage_gap: float | None = None
+    ) -> Issue:
+        """Create an issue for coverage improvement.
+
+        Args:
+            coverage_gap: Percentage gap to 100% coverage
+
+        Returns:
+            Issue configured for coverage improvement
+        """
+        if coverage_gap is None:
+            try:
+                coverage_status = self.coverage_service.get_status_report()
+                current_coverage = coverage_status.get("current_coverage", 0.0)
+                coverage_gap = 100.0 - current_coverage
+            except Exception:
+                coverage_gap = 90.0  # Default gap if we can't determine
+
+        message = (
+            f"Proactive coverage improvement requested. "
+            f"Gap to 100%: {coverage_gap:.1f}%. "
+            f"Target improvement: {min(self.min_coverage_improvement, coverage_gap) if coverage_gap is not None else self.min_coverage_improvement:.1f}%"
+        )
+
+        return Issue(
+            id="coverage_improvement_proactive",
+            type=IssueType.COVERAGE_IMPROVEMENT,
+            severity=Priority.MEDIUM,
+            message=message,
+            file_path=None,  # Project-wide improvement
+            stage="coverage_improvement",
+        )
+
+    async def execute_coverage_improvement(
+        self, agent_context: t.Any
+    ) -> dict[str, t.Any]:
+        """Execute proactive coverage improvement.
+
+        Args:
+            agent_context: AgentContext for the TestCreationAgent
+
+        Returns:
+            Dictionary with improvement results
+        """
+        try:
+            self.logger.info("Starting proactive coverage improvement")
+
+            # Check if improvement is needed
+            if not await self.should_improve_coverage():
+                return self._create_skipped_result("Coverage improvement not needed")
+
+            # Create coverage improvement issue and agent
+            issue = await self.create_coverage_improvement_issue()
+            test_agent = TestCreationAgent(agent_context)
+
+            # Validate agent confidence
+            confidence = await test_agent.can_handle(issue)
+            if confidence < 0.5:
+                return self._create_low_confidence_result(confidence)
+
+            # Execute the coverage improvement
+            fix_result = await test_agent.analyze_and_fix(issue)
+            result = self._create_completion_result(fix_result)
+
+            self._log_and_display_results(fix_result)
+            return result
+
+        except Exception as e:
+            return self._create_error_result(e)
+
+    def _create_skipped_result(self, reason: str) -> dict[str, t.Any]:
+        """Create result dict for skipped coverage improvement."""
+        return {
+            "status": "skipped",
+            "reason": reason,
+            "coverage_at_100": True,
+        }
+
+    def _create_low_confidence_result(self, confidence: float) -> dict[str, t.Any]:
+        """Create result dict for low confidence scenario."""
+        self.logger.warning(f"TestCreationAgent confidence too low: {confidence}")
+        return {
+            "status": "skipped",
+            "reason": "Agent confidence too low",
+            "confidence": confidence,
+        }
+
+    def _create_completion_result(self, fix_result: t.Any) -> dict[str, t.Any]:
+        """Create result dict from fix results."""
+        return {
+            "status": "completed" if fix_result.success else "failed",
+            "confidence": fix_result.confidence,
+            "fixes_applied": fix_result.fixes_applied,
+            "files_modified": fix_result.files_modified,
+            "recommendations": fix_result.recommendations,
+        }
+
+    def _log_and_display_results(self, fix_result: t.Any) -> None:
+        """Log and display the results of coverage improvement."""
+        if fix_result.success:
+            self.logger.info(
+                f"Coverage improvement successful: {len(fix_result.fixes_applied)} fixes applied"
+            )
+            if self.console:
+                self.console.print(
+                    f"[green]📈[/green] Coverage improved: {len(fix_result.fixes_applied)} "
+                    f"tests created in {len(fix_result.files_modified)} files"
+                )
+        else:
+            self.logger.warning("Coverage improvement failed")
+            if self.console:
+                self.console.print(
+                    "[yellow]⚠️[/yellow] Coverage improvement attempt completed with issues"
+                )
+
+    def _create_error_result(self, error: Exception) -> dict[str, t.Any]:
+        """Create result dict for error scenarios."""
+        self.logger.error(f"Coverage improvement failed with error: {error}")
+        return {
+            "status": "error",
+            "error": str(error),
+            "fixes_applied": [],
+            "files_modified": [],
+        }
+
+    async def get_coverage_improvement_recommendations(self) -> list[str]:
+        """Get recommendations for coverage improvement strategies.
+
+        Returns:
+            List of strategic recommendations for improving coverage
+        """
+        recommendations = [
+            "Focus on core business logic functions first",
+            "Add tests for error handling and edge cases",
+            "Consider property-based testing for complex algorithms",
+            "Test integration points and configuration handling",
+            "Add parametrized tests for different input scenarios",
+        ]
+
+        from contextlib import suppress
+
+        with suppress(Exception):
+            # Add coverage-specific recommendations based on current state
+            coverage_status = self.coverage_service.get_status_report()
+            current_coverage = coverage_status.get("current_coverage", 0.0)
+
+            if current_coverage < 25.0:
+                recommendations.insert(
+                    0, "Start with basic import and instantiation tests"
+                )
+            elif current_coverage < 50.0:
+                recommendations.insert(0, "Focus on testing public method interfaces")
+            elif current_coverage < 75.0:
+                recommendations.insert(0, "Add tests for internal helper methods")
+            else:
+                recommendations.insert(0, "Target remaining edge cases and error paths")
+
+        return recommendations
+
+
+async def create_coverage_improvement_orchestrator(
+    project_path: Path, console: t.Any = None
+) -> CoverageImprovementOrchestrator:
+    """Create a coverage improvement orchestrator instance."""
+    return CoverageImprovementOrchestrator(project_path, console)

crackerjack/orchestration/execution_strategies.py

@@ -0,0 +1,341 @@
+import typing as t
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+from rich.console import Console
+
+from crackerjack.config.hooks import HookStrategy
+from crackerjack.models.protocols import OptionsProtocol
+
+
+class ExecutionStrategy(str, Enum):
+    BATCH = "batch"
+    INDIVIDUAL = "individual"
+    ADAPTIVE = "adaptive"
+    SELECTIVE = "selective"
+
+
+class ProgressLevel(str, Enum):
+    BASIC = "basic"
+    DETAILED = "detailed"
+    GRANULAR = "granular"
+    STREAMING = "streaming"
+
+
+class StreamingMode(str, Enum):
+    WEBSOCKET = "websocket"
+    FILE = "file"
+    HYBRID = "hybrid"
+
+
+class AICoordinationMode(str, Enum):
+    SINGLE_AGENT = "single - agent"
+    MULTI_AGENT = "multi - agent"
+    COORDINATOR = "coordinator"
+
+
+class AIIntelligence(str, Enum):
+    BASIC = "basic"
+    ADAPTIVE = "adaptive"
+    LEARNING = "learning"
+
+
+@dataclass
+class OrchestrationConfig:
+    execution_strategy: ExecutionStrategy = ExecutionStrategy.BATCH
+    progress_level: ProgressLevel = ProgressLevel.DETAILED
+    streaming_mode: StreamingMode = StreamingMode.WEBSOCKET
+    ai_coordination_mode: AICoordinationMode = AICoordinationMode.SINGLE_AGENT
+    ai_intelligence: AIIntelligence = AIIntelligence.BASIC
+
+    correlation_tracking: bool = True
+    failure_analysis: bool = True
+    intelligent_retry: bool = True
+
+    max_parallel_hooks: int = 3
+    max_parallel_tests: int = 4
+    timeout_multiplier: float = 1.0
+
+    debug_level: str = "standard"
+    log_individual_outputs: bool = False
+    preserve_temp_files: bool = False
+
+    def to_dict(self) -> dict[str, t.Any]:
+        return {
+            "execution_strategy": self.execution_strategy.value,
+            "progress_level": self.progress_level.value,
+            "streaming_mode": self.streaming_mode.value,
+            "ai_coordination_mode": self.ai_coordination_mode.value,
+            "ai_intelligence": self.ai_intelligence.value,
+            "correlation_tracking": self.correlation_tracking,
+            "failure_analysis": self.failure_analysis,
+            "intelligent_retry": self.intelligent_retry,
+            "max_parallel_hooks": self.max_parallel_hooks,
+            "max_parallel_tests": self.max_parallel_tests,
+            "timeout_multiplier": self.timeout_multiplier,
+            "debug_level": self.debug_level,
+            "log_individual_outputs": self.log_individual_outputs,
+            "preserve_temp_files": self.preserve_temp_files,
+        }
+
+
+class ExecutionContext:
+    def __init__(
+        self,
+        pkg_path: Path,
+        options: OptionsProtocol,
+        previous_failures: list[str] | None = None,
+        changed_files: list[Path] | None = None,
+        iteration_count: int = 1,
+    ) -> None:
+        self.pkg_path = pkg_path
+        self.options = options
+        self.previous_failures = previous_failures or []
+        self.changed_files = changed_files or []
+        self.iteration_count = iteration_count
+
+        self.total_python_files = len(list(pkg_path.rglob(" * .py")))
+        self.total_test_files = len(list(pkg_path.glob("tests / test_ * .py")))
+        self.has_complex_setup = self._detect_complex_setup()
+        self.estimated_hook_duration = self._estimate_hook_duration()
+
+    def _detect_complex_setup(self) -> bool:
+        complex_indicators = [
+            (self.pkg_path / "pyproject.toml").exists(),
+            (self.pkg_path / "setup.py").exists(),
+            (self.pkg_path / "requirements.txt").exists(),
+            len(list(self.pkg_path.rglob(" * .py"))) > 50,
+            len(list(self.pkg_path.glob("tests / test_ * .py"))) > 20,
+        ]
+        return sum(complex_indicators) >= 3
+
+    def _estimate_hook_duration(self) -> float:
+        base_time = 30.0
+        file_factor = self.total_python_files * 0.5
+        test_factor = self.total_test_files * 2.0
+
+        return base_time + file_factor + test_factor
+
+
+class StrategySelector:
+    def __init__(self, console: Console) -> None:
+        self.console = console
+
+    def select_strategy(
+        self,
+        config: OrchestrationConfig,
+        context: ExecutionContext,
+    ) -> ExecutionStrategy:
+        if config.execution_strategy != ExecutionStrategy.ADAPTIVE:
+            return config.execution_strategy
+
+        return self._select_adaptive_strategy(context)
+
+    def _select_adaptive_strategy(self, context: ExecutionContext) -> ExecutionStrategy:
+        if context.iteration_count == 1:
+            return ExecutionStrategy.BATCH
+
+        if len(context.previous_failures) > 5:
+            self.console.print(
+                "[yellow]🧠 Switching to individual execution due to multiple failures[/yellow]",
+            )
+            return ExecutionStrategy.INDIVIDUAL
+
+        if context.changed_files and len(context.changed_files) < 5:
+            self.console.print(
+                "[cyan]🎯 Using selective execution for targeted file changes[/cyan]",
+            )
+            return ExecutionStrategy.SELECTIVE
+
+        if context.has_complex_setup and context.iteration_count > 2:
+            return ExecutionStrategy.INDIVIDUAL
+
+        return ExecutionStrategy.BATCH
+
+    def select_hook_subset(
+        self,
+        strategy: HookStrategy,
+        execution_strategy: ExecutionStrategy,
+        context: ExecutionContext,
+    ) -> HookStrategy:
+        if execution_strategy == ExecutionStrategy.SELECTIVE:
+            return self._create_selective_strategy(strategy, context)
+
+        return strategy
+
+    def _create_selective_strategy(
+        self,
+        strategy: HookStrategy,
+        context: ExecutionContext,
+    ) -> HookStrategy:
+        priority_hooks = set(context.previous_failures)
+
+        if context.changed_files:
+            for file_path in context.changed_files:
+                if file_path.suffix == ".py":
+                    priority_hooks.update(["pyright", "ruff - check", "ruff - format"])
+                if "test" in str(file_path):
+                    priority_hooks.update(["pytest", "coverage"])
+                if str(file_path).endswith(("setup.py", "pyproject.toml")):
+                    priority_hooks.update(["bandit", "creosote", "detect - secrets"])
+
+        selected_hooks = [
+            hook for hook in strategy.hooks if hook.name in priority_hooks
+        ]
+
+        if not selected_hooks:
+            selected_hooks = strategy.hooks[:3]
+
+        self.console.print(
+            f"[cyan]🎯 Selected {len(selected_hooks)} hooks for targeted execution: "
+            f"{', '.join(h.name for h in selected_hooks)}[/cyan]",
+        )
+
+        return HookStrategy(
+            name=f"{strategy.name}_selective",
+            hooks=selected_hooks,
+            timeout=strategy.timeout,
+            retry_policy=strategy.retry_policy,
+            parallel=strategy.parallel,
+            max_workers=min(strategy.max_workers, len(selected_hooks)),
+        )
+
+
+class OrchestrationPlanner:
+    def __init__(self, console: Console) -> None:
+        self.console = console
+        self.strategy_selector = StrategySelector(console)
+
+    def create_execution_plan(
+        self,
+        config: OrchestrationConfig,
+        context: ExecutionContext,
+        hook_strategies: list[HookStrategy],
+    ) -> "ExecutionPlan":
+        execution_strategy = self.strategy_selector.select_strategy(config, context)
+
+        hook_plans = []
+        for strategy in hook_strategies:
+            selected_strategy = self.strategy_selector.select_hook_subset(
+                strategy,
+                execution_strategy,
+                context,
+            )
+            hook_plans.append(
+                {
+                    "strategy": selected_strategy,
+                    "execution_mode": execution_strategy,
+                    "estimated_duration": self._estimate_strategy_duration(
+                        selected_strategy,
+                    ),
+                },
+            )
+
+        test_plan = self._create_test_plan(config, context, execution_strategy)
+
+        ai_plan = self._create_ai_plan(config, context)
+
+        return ExecutionPlan(
+            config=config,
+            execution_strategy=execution_strategy,
+            hook_plans=hook_plans,
+            test_plan=test_plan,
+            ai_plan=ai_plan,
+            estimated_total_duration=sum(
+                plan["estimated_duration"] for plan in hook_plans
+            )
+            + test_plan["estimated_duration"],
+        )
+
+    def _estimate_strategy_duration(self, strategy: HookStrategy) -> float:
+        base_time_per_hook = 10.0
+        return len(strategy.hooks) * base_time_per_hook
+
+    def _create_test_plan(
+        self,
+        config: OrchestrationConfig,
+        context: ExecutionContext,
+        execution_strategy: ExecutionStrategy,
+    ) -> dict[str, t.Any]:
+        if execution_strategy == ExecutionStrategy.INDIVIDUAL:
+            test_mode = "individual_with_progress"
+        elif execution_strategy == ExecutionStrategy.SELECTIVE:
+            test_mode = "selective"
+        else:
+            test_mode = "full_suite"
+
+        return {
+            "mode": test_mode,
+            "parallel_workers": min(
+                config.max_parallel_tests,
+                context.total_test_files,
+            ),
+            "estimated_duration": context.total_test_files * 2.0,
+            "progress_tracking": config.progress_level
+            in (ProgressLevel.DETAILED, ProgressLevel.GRANULAR),
+        }
+
+    def _create_ai_plan(
+        self,
+        config: OrchestrationConfig,
+        context: ExecutionContext,
+    ) -> dict[str, t.Any]:
+        return {
+            "mode": config.ai_coordination_mode,
+            "intelligence_level": config.ai_intelligence,
+            "batch_processing": True,
+            "correlation_tracking": config.correlation_tracking,
+            "failure_analysis": config.failure_analysis,
+            "adaptive_retry": config.intelligent_retry,
+        }
+
+
+@dataclass
+class ExecutionPlan:
+    config: OrchestrationConfig
+    execution_strategy: ExecutionStrategy
+    hook_plans: list[dict[str, t.Any]]
+    test_plan: dict[str, t.Any]
+    ai_plan: dict[str, t.Any]
+    estimated_total_duration: float
+
+    def print_plan_summary(self, console: Console) -> None:
+        console.print("\n" + "=" * 80)
+        console.print(
+            "[bold bright_blue]🎯 ORCHESTRATED EXECUTION PLAN[/bold bright_blue]",
+        )
+        console.print("=" * 80)
+
+        console.print(f"[bold]Strategy: [/bold] {self.execution_strategy.value}")
+        console.print(
+            f"[bold]AI Mode: [/bold] {self.config.ai_coordination_mode.value}",
+        )
+        console.print(
+            f"[bold]Progress Level: [/bold] {self.config.progress_level.value}",
+        )
+        console.print(
+            f"[bold]Estimated Duration: [/bold] {self.estimated_total_duration: .1f}s",
+        )
+
+        console.print("\n[bold cyan]Hook Execution: [/bold cyan]")
+        for i, plan in enumerate(self.hook_plans, 1):
+            strategy = plan["strategy"]
+            console.print(
+                f" {i}. {strategy.name} - {len(strategy.hooks)} hooks "
+                f"({plan['estimated_duration']: .1f}s)",
+            )
+
+        console.print("\n[bold green]Test Execution: [/bold green]")
+        console.print(f" Mode: {self.test_plan['mode']}")
+        console.print(f" Workers: {self.test_plan['parallel_workers']}")
+        console.print(f" Duration: {self.test_plan['estimated_duration']: .1f}s")
+
+        console.print("\n[bold magenta]AI Coordination: [/bold magenta]")
+        console.print(f" Mode: {self.ai_plan['mode'].value}")
+        console.print(f" Intelligence: {self.ai_plan['intelligence_level'].value}")
+        console.print(
+            f" Batch Processing: {'✅' if self.ai_plan['batch_processing'] else '❌'}",
+        )
+
+        console.print("=" * 80)