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

crackerjack/agents/performance_agent.py

@@ -0,0 +1,325 @@
+import time
+import typing as t
+from pathlib import Path
+
+from .base import (
+    AgentContext,
+    FixResult,
+    Issue,
+    IssueType,
+    SubAgent,
+    agent_registry,
+)
+from .helpers.performance.performance_ast_analyzer import PerformanceASTAnalyzer
+from .helpers.performance.performance_pattern_detector import PerformancePatternDetector
+from .helpers.performance.performance_recommender import PerformanceRecommender
+from .semantic_helpers import (
+    SemanticInsight,
+    create_semantic_enhancer,
+    get_session_enhanced_recommendations,
+)
+
+
+class PerformanceAgent(SubAgent):
+    """Agent for detecting and fixing performance issues.
+
+    Enhanced with semantic context to detect performance patterns across
+    the codebase and find similar bottlenecks that may not be immediately visible.
+    """
+
+    def __init__(self, context: AgentContext) -> None:
+        super().__init__(context)
+        self.semantic_enhancer = create_semantic_enhancer(context.project_path)
+        self.semantic_insights: dict[str, SemanticInsight] = {}
+        self.performance_metrics: dict[str, t.Any] = {}
+
+        # Initialize helper modules
+        self._pattern_detector = PerformancePatternDetector(context)
+        self._ast_analyzer = PerformanceASTAnalyzer(context)
+        self._recommender = PerformanceRecommender(context)
+
+    def get_supported_types(self) -> set[IssueType]:
+        return {IssueType.PERFORMANCE}
+
+    async def can_handle(self, issue: Issue) -> float:
+        if issue.type != IssueType.PERFORMANCE:
+            return 0.0
+
+        confidence = 0.85
+        message_lower = issue.message.lower()
+
+        if any(
+            pattern in message_lower
+            for pattern in (
+                "nested loop",
+                "o(n²)",
+                "string concatenation",
+                "list[t.Any] concatenation",
+                "inefficient",
+                "complexity",
+            )
+        ):
+            confidence = 0.9
+
+        return confidence
+
+    async def analyze_and_fix(self, issue: Issue) -> FixResult:
+        self.log(f"Analyzing performance issue: {issue.message}")
+        start_time = time.time()
+
+        validation_result = self._validate_performance_issue(issue)
+        if validation_result:
+            return validation_result
+
+        if issue.file_path is None:
+            return FixResult(
+                success=False,
+                confidence=0.0,
+                remaining_issues=["No file path provided for performance issue"],
+            )
+
+        file_path = Path(issue.file_path)
+
+        try:
+            result = await self._process_performance_optimization(file_path)
+
+            analysis_time = time.time() - start_time
+            self.performance_metrics[str(file_path)] = {
+                "analysis_duration": analysis_time,
+                "optimizations_applied": result.fixes_applied,
+                "timestamp": time.time(),
+            }
+
+            if result.success and result.fixes_applied:
+                stats_summary = self._generate_optimization_summary()
+                result.recommendations = result.recommendations + [stats_summary]
+
+            return result
+        except Exception as e:
+            return self._create_performance_error_result(e)
+
+    @staticmethod
+    def _validate_performance_issue(issue: Issue) -> FixResult | None:
+        if not issue.file_path:
+            return FixResult(
+                success=False,
+                confidence=0.0,
+                remaining_issues=["No file path specified for performance issue"],
+            )
+
+        file_path = Path(issue.file_path)
+        if not file_path.exists():
+            return FixResult(
+                success=False,
+                confidence=0.0,
+                remaining_issues=[f"File not found: {file_path}"],
+            )
+
+        return None
+
+    async def _process_performance_optimization(self, file_path: Path) -> FixResult:
+        content = self.context.get_file_content(file_path)
+        if not content:
+            return FixResult(
+                success=False,
+                confidence=0.0,
+                remaining_issues=[f"Could not read file: {file_path}"],
+            )
+
+        # Detect traditional performance issues using helper
+        performance_issues = self._pattern_detector.detect_performance_issues(
+            content, file_path
+        )
+
+        # Enhance with semantic performance pattern detection
+        semantic_issues = await self._detect_semantic_performance_issues(
+            content, file_path
+        )
+        performance_issues.extend(semantic_issues)
+
+        if not performance_issues:
+            return FixResult(
+                success=True,
+                confidence=0.7,
+                recommendations=["No performance issues detected"],
+            )
+
+        return await self._apply_and_save_optimizations(
+            file_path,
+            content,
+            performance_issues,
+        )
+
+    async def _apply_and_save_optimizations(
+        self,
+        file_path: Path,
+        content: str,
+        issues: list[dict[str, t.Any]],
+    ) -> FixResult:
+        # Delegate to recommender helper
+        optimized_content = self._recommender.apply_performance_optimizations(
+            content, issues
+        )
+
+        if optimized_content == content:
+            return self._create_no_optimization_result()
+
+        success = self.context.write_file_content(file_path, optimized_content)
+        if not success:
+            return FixResult(
+                success=False,
+                confidence=0.0,
+                remaining_issues=[f"Failed to write optimized file: {file_path}"],
+            )
+
+        # Get summary from recommender
+        stats_summary = self._recommender.generate_optimization_summary()
+
+        return FixResult(
+            success=True,
+            confidence=0.8,
+            fixes_applied=[
+                f"Optimized {len(issues)} performance issues",
+                "Applied algorithmic improvements",
+                stats_summary,
+            ],
+            files_modified=[str(file_path)],
+            recommendations=await self._generate_enhanced_recommendations(issues),
+        )
+
+    @staticmethod
+    def _create_no_optimization_result() -> FixResult:
+        return FixResult(
+            success=False,
+            confidence=0.6,
+            remaining_issues=["Could not automatically optimize performance"],
+            recommendations=[
+                "Manual optimization required",
+                "Consider algorithm complexity improvements",
+                "Review data structure choices",
+                "Profile code execution for bottlenecks",
+            ],
+        )
+
+    @staticmethod
+    def _create_performance_error_result(error: Exception) -> FixResult:
+        return FixResult(
+            success=False,
+            confidence=0.0,
+            remaining_issues=[f"Error processing file: {error}"],
+        )
+
+    async def _detect_semantic_performance_issues(
+        self, content: str, file_path: Path
+    ) -> list[dict[str, t.Any]]:
+        """Detect performance issues using semantic analysis of similar code patterns."""
+        issues = []
+
+        try:
+            # Delegate to AST analyzer helper
+            critical_functions = (
+                self._ast_analyzer.extract_performance_critical_functions(content)
+            )
+
+            for func in critical_functions:
+                if (
+                    func["estimated_complexity"] > 2
+                ):  # Focus on potentially complex functions
+                    # Search for similar performance patterns
+                    insight = await self.semantic_enhancer.find_similar_patterns(
+                        f"performance {func['signature']} {func['body_sample']}",
+                        current_file=file_path,
+                        min_similarity=0.6,
+                        max_results=8,
+                    )
+
+                    if insight.total_matches > 1:
+                        # Delegate analysis to AST analyzer helper
+                        analysis = self._ast_analyzer.analyze_performance_patterns(
+                            insight, func
+                        )
+                        if analysis["issues_found"]:
+                            issues.append(
+                                {
+                                    "type": "semantic_performance_pattern",
+                                    "function": func,
+                                    "similar_patterns": insight.related_patterns,
+                                    "performance_analysis": analysis,
+                                    "confidence_score": insight.high_confidence_matches
+                                    / max(insight.total_matches, 1),
+                                    "suggestion": analysis["optimization_suggestion"],
+                                }
+                            )
+
+                            # Store insight for recommendation enhancement
+                            self.semantic_insights[func["name"]] = insight
+
+        except Exception as e:
+            self.log(f"Warning: Semantic performance analysis failed: {e}")
+
+        return issues
+
+    def _generate_optimization_summary(self) -> str:
+        """Generate a summary of optimization results."""
+        total_files = len(self.performance_metrics)
+        total_optimizations = sum(
+            metrics.get("optimizations_applied", 0)
+            for metrics in self.performance_metrics.values()
+        )
+
+        total_time = sum(
+            metrics.get("analysis_duration", 0)
+            for metrics in self.performance_metrics.values()
+        )
+
+        return (
+            f"Performance optimization summary: "
+            f"{total_optimizations} optimizations applied across {total_files} files "
+            f"in {total_time:.2f}s total"
+        )
+
+    async def _generate_enhanced_recommendations(
+        self, issues: list[dict[str, t.Any]]
+    ) -> list[str]:
+        """Generate enhanced recommendations including semantic insights."""
+        recommendations = ["Test performance improvements with benchmarks"]
+
+        # Add semantic insights
+        semantic_issues = [
+            issue for issue in issues if issue["type"] == "semantic_performance_pattern"
+        ]
+        if semantic_issues:
+            recommendations.append(
+                f"Semantic analysis found {len(semantic_issues)} similar performance patterns "
+                "across codebase - consider applying optimizations consistently"
+            )
+
+            # Store insights for session continuity
+            for issue in semantic_issues:
+                if "semantic_insight" in issue:
+                    await self.semantic_enhancer.store_insight_to_session(
+                        issue["semantic_insight"], "PerformanceAgent"
+                    )
+
+        # Enhance with session-stored insights
+        recommendations = await get_session_enhanced_recommendations(
+            recommendations, "PerformanceAgent", self.context.project_path
+        )
+
+        # Add insights from stored semantic analysis
+        for func_name, insight in self.semantic_insights.items():
+            if insight.high_confidence_matches > 0:
+                enhanced_recs = self.semantic_enhancer.enhance_recommendations(
+                    [],  # Start with empty list to get just semantic recommendations
+                    insight,
+                )
+                recommendations.extend(enhanced_recs)
+
+                # Log semantic context for debugging
+                summary = self.semantic_enhancer.get_semantic_context_summary(insight)
+                self.log(f"Performance semantic context for {func_name}: {summary}")
+
+        return recommendations
+
+
+agent_registry.register(PerformanceAgent)

crackerjack/agents/performance_helpers.py

@@ -0,0 +1,205 @@
+import ast
+import typing as t
+from dataclasses import dataclass
+
+
+@dataclass
+class OptimizationResult:
+    lines: list[str]
+    modified: bool
+    optimization_description: str | None = None
+
+
+class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.loop_stack: list[tuple[str, ast.AST, int]] = []
+        self.nested_loops: list[dict[str, t.Any]] = []
+        self.complexity_hotspots: list[dict[str, t.Any]] = []
+
+    def visit_For(self, node: ast.For) -> None:
+        self._process_loop_node(node, "nested_for_loop")
+
+    def visit_While(self, node: ast.While) -> None:
+        self._process_loop_node(node, "nested_while_loop")
+
+    def _process_loop_node(self, node: ast.For | ast.While, loop_type: str) -> None:
+        current_depth = len(self.loop_stack) + 1
+        self.loop_stack.append((loop_type.split("_")[1], node, current_depth))
+
+        if current_depth > 1:
+            loop_info = self._create_loop_info(node, loop_type, current_depth)
+            self.nested_loops.append(loop_info)
+            self._check_complexity_hotspot(loop_info, current_depth)
+
+        self.generic_visit(node)
+        self.loop_stack.pop()
+
+    def _create_loop_info(
+        self, node: ast.For | ast.While, loop_type: str, current_depth: int
+    ) -> dict[str, t.Any]:
+        loop_info: dict[str, t.Any] = {
+            "line_number": node.lineno,
+            "type": loop_type,
+            "depth": current_depth,
+            "complexity": f"O(n^{current_depth})",
+            "complexity_factor": self._calculate_complexity_factor(current_depth),
+            "priority": self._get_optimization_priority(current_depth),
+            "node": node,
+        }
+
+        if isinstance(node, ast.For):
+            loop_info["iterable"] = self._extract_iterable_info(node)
+
+        return loop_info
+
+    def _check_complexity_hotspot(
+        self, loop_info: dict[str, t.Any], current_depth: int
+    ) -> None:
+        if current_depth >= 3:
+            self.complexity_hotspots.append(
+                loop_info
+                | {
+                    "severity": "high",
+                    "suggestion": "Critical: Consider algorithmic improvements (memoization, caching, different data structures)",
+                }
+            )
+
+    def _calculate_complexity_factor(self, depth: int) -> int:
+        return depth**2
+
+    def _get_optimization_priority(self, depth: int) -> str:
+        if depth >= 4:
+            return "critical"
+        elif depth == 3:
+            return "high"
+        elif depth == 2:
+            return "medium"
+        return "low"
+
+    def _extract_iterable_info(self, node: ast.For) -> dict[str, t.Any]:
+        iterable_info = {"type": "unknown", "name": None}
+
+        if isinstance(node.iter, ast.Name):
+            iterable_info = {"type": "variable", "name": node.iter.id}
+        elif isinstance(node.iter, ast.Call) and isinstance(node.iter.func, ast.Name):
+            iterable_info = {
+                "type": "function_call",
+                "name": node.iter.func.id,
+            }
+            if node.iter.func.id == "range":
+                iterable_info["optimization_hint"] = (
+                    "Consider list[t.Any] comprehension or vectorization"
+                )
+
+        return iterable_info
+
+
+class EnhancedListOpAnalyzer(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.in_loop = False
+        self.loop_depth = 0
+        self.list_ops: list[dict[str, t.Any]] = []
+        self.current_loop_node: ast.For | ast.While | None = None
+
+    def visit_For(self, node: ast.For) -> None:
+        self._enter_loop_context(node)
+        self.generic_visit(node)
+        self._exit_loop_context()
+
+    def visit_While(self, node: ast.While) -> None:
+        self._enter_loop_context(node)
+        self.generic_visit(node)
+        self._exit_loop_context()
+
+    def visit_AugAssign(self, node: ast.AugAssign) -> None:
+        if self._should_analyze_aug_assign(node):
+            self._analyze_aug_assign_node(node)
+        self.generic_visit(node)
+
+    def _enter_loop_context(self, node: ast.For | ast.While) -> None:
+        self._old_state = (self.in_loop, self.loop_depth, self.current_loop_node)
+        self.in_loop = True
+        self.loop_depth += 1
+        self.current_loop_node = node
+
+    def _exit_loop_context(self) -> None:
+        self.in_loop, self.loop_depth, self.current_loop_node = self._old_state
+
+    def _should_analyze_aug_assign(self, node: ast.AugAssign) -> bool:
+        return self.in_loop and isinstance(node.op, ast.Add)
+
+    def _analyze_aug_assign_node(self, node: ast.AugAssign) -> None:
+        impact_factor = self._calculate_performance_impact()
+
+        if isinstance(node.value, ast.List):
+            self._handle_list_concat(node, impact_factor)
+        elif isinstance(node.value, ast.Name):
+            self._handle_variable_concat(node, impact_factor)
+
+    def _handle_list_concat(self, node: ast.AugAssign, impact_factor: int) -> None:
+        assert isinstance(node.value, ast.List)
+        list_size = len(node.value.elts)
+
+        self.list_ops.append(
+            {
+                "line_number": node.lineno,
+                "type": "list_concat_in_loop",
+                "pattern": f"list[t.Any] += [{list_size} items]",
+                "loop_depth": self.loop_depth,
+                "impact_factor": impact_factor,
+                "optimization": "append" if list_size == 1 else "extend",
+                "performance_gain": f"{impact_factor * 2}x"
+                if list_size > 1
+                else "2-3x",
+            }
+        )
+
+    def _handle_variable_concat(self, node: ast.AugAssign, impact_factor: int) -> None:
+        var_name = getattr(node.value, "id", "unknown")
+        self.list_ops.append(
+            {
+                "line_number": node.lineno,
+                "type": "list_concat_variable",
+                "pattern": f"list[t.Any] += {var_name}",
+                "loop_depth": self.loop_depth,
+                "impact_factor": impact_factor,
+                "optimization": "extend",
+                "performance_gain": f"{impact_factor * 3}x",
+            }
+        )
+
+    def _calculate_performance_impact(self) -> int:
+        base_impact = 2
+
+        if self.loop_depth > 1:
+            base_impact *= self.loop_depth**2
+
+        if self._is_hot_loop():
+            base_impact *= 5
+
+        return min(base_impact, 50)
+
+    def _is_hot_loop(self) -> bool:
+        if not (self.current_loop_node and isinstance(self.current_loop_node, ast.For)):
+            return False
+
+        return self._has_large_range_iterator()
+
+    def _has_large_range_iterator(self) -> bool:
+        if not isinstance(self.current_loop_node, ast.For):
+            return False
+
+        iter_node = self.current_loop_node.iter
+        if not (
+            isinstance(iter_node, ast.Call)
+            and isinstance(iter_node.func, ast.Name)
+            and iter_node.func.id == "range"
+        ):
+            return False
+
+        args = iter_node.args
+        if not (args and isinstance(args[0], ast.Constant)):
+            return False
+
+        value = args[0].value
+        return isinstance(value, int | float) and value > 100

crackerjack/agents/proactive_agent.py

@@ -0,0 +1,55 @@
+import typing as t
+from abc import abstractmethod
+
+from .base import AgentContext, FixResult, Issue, SubAgent
+
+
+class ProactiveAgent(SubAgent):
+    def __init__(self, context: AgentContext) -> None:
+        super().__init__(context)
+        self._planning_cache: dict[str, dict[str, t.Any]] = {}
+        self._pattern_cache: dict[str, t.Any] = {}
+
+    @abstractmethod
+    async def plan_before_action(self, issue: Issue) -> dict[str, t.Any]:
+        pass
+
+    async def analyze_and_fix_proactively(self, issue: Issue) -> FixResult:
+        cache_key = self._get_planning_cache_key(issue)
+        if cache_key in self._planning_cache:
+            plan = self._planning_cache[cache_key]
+            self.log(f"Using cached plan for {cache_key}")
+        else:
+            plan = await self.plan_before_action(issue)
+            self._planning_cache[cache_key] = plan
+            self.log(f"Created new plan for {cache_key}")
+
+        result = await self._execute_with_plan(issue, plan)
+
+        if result.success and result.confidence >= 0.8:
+            self._cache_successful_pattern(issue, plan, result)
+
+        return result
+
+    async def _execute_with_plan(
+        self, issue: Issue, plan: dict[str, t.Any]
+    ) -> FixResult:
+        return await self.analyze_and_fix(issue)
+
+    def _get_planning_cache_key(self, issue: Issue) -> str:
+        return f"{issue.type.value}: {issue.file_path}: {issue.line_number}"
+
+    def _cache_successful_pattern(
+        self, issue: Issue, plan: dict[str, t.Any], result: FixResult
+    ) -> None:
+        pattern_key = f"{issue.type.value}_{plan.get('strategy', 'default')}"
+        self._pattern_cache[pattern_key] = {
+            "plan": plan,
+            "confidence": result.confidence,
+            "files_modified": result.files_modified,
+            "fixes_applied": result.fixes_applied,
+        }
+        self.log(f"Cached successful pattern: {pattern_key}")
+
+    def get_cached_patterns(self) -> dict[str, t.Any]:
+        return self._pattern_cache.copy()