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

crackerjack/agents/performance_helpers.py

@@ -0,0 +1,229 @@
+"""Performance analysis helper classes and utilities."""
+
+import ast
+import typing as t
+from dataclasses import dataclass
+
+
+@dataclass
+class OptimizationResult:
+    """Result of an optimization operation."""
+
+    lines: list[str]
+    modified: bool
+    optimization_description: str | None = None
+
+
+class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
+    """Analyzer for detecting nested loops with complexity analysis."""
+
+    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:
+        """Process a loop node and track nesting information."""
+        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]:
+        """Create loop information dictionary."""
+        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:
+        """Check if loop is a complexity hotspot and add to hotspots list."""
+        if current_depth >= 3:  # O(n³) or higher
+            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:
+        """Calculate relative complexity factor for optimization prioritization."""
+        return depth**2  # Exponential growth factor
+
+    def _get_optimization_priority(self, depth: int) -> str:
+        """Determine optimization priority based on nesting depth."""
+        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]:
+        """Extract information about the iterable for optimization hints."""
+        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 comprehension or vectorization"
+                )
+
+        return iterable_info
+
+
+class EnhancedListOpAnalyzer(ast.NodeVisitor):
+    """Analyzer for detecting inefficient list operations in loops."""
+
+    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:
+        """Enter loop context and save previous state."""
+        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:
+        """Exit loop context and restore previous state."""
+        self.in_loop, self.loop_depth, self.current_loop_node = self._old_state
+
+    def _should_analyze_aug_assign(self, node: ast.AugAssign) -> bool:
+        """Check if this augmented assignment should be analyzed."""
+        return self.in_loop and isinstance(node.op, ast.Add)
+
+    def _analyze_aug_assign_node(self, node: ast.AugAssign) -> None:
+        """Analyze an augmented assignment node for inefficiencies."""
+        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:
+        """Handle list concatenation with literal list."""
+        # Type narrowing to help pyright understand that node.value is an ast.List
+        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 += [{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:
+        """Handle list concatenation with variable."""
+        var_name = getattr(node.value, "id", "unknown")
+        self.list_ops.append(
+            {
+                "line_number": node.lineno,
+                "type": "list_concat_variable",
+                "pattern": f"list += {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:
+        """Calculate expected performance impact based on context."""
+        base_impact = 2  # Baseline improvement factor
+
+        if self.loop_depth > 1:
+            base_impact *= self.loop_depth**2
+
+        if self._is_hot_loop():
+            base_impact *= 5
+
+        return min(base_impact, 50)  # Cap at 50x impact
+
+    def _is_hot_loop(self) -> bool:
+        """Check if current loop is a hot loop with large range."""
+        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:
+        """Check if the for loop uses a large range."""
+        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

@@ -5,12 +5,6 @@ from .base import AgentContext, FixResult, Issue, SubAgent
 
 
 class ProactiveAgent(SubAgent):
-    """Base class for agents that can plan before executing fixes.
-
-    Proactive agents analyze the codebase and create architectural plans
-    before applying fixes, preventing violations rather than just fixing them.
-    """
-
     def __init__(self, context: AgentContext) -> None:
         super().__init__(context)
         self._planning_cache: dict[str, dict[str, t.Any]] = {}
@@ -18,25 +12,9 @@ class ProactiveAgent(SubAgent):
 
     @abstractmethod
     async def plan_before_action(self, issue: Issue) -> dict[str, t.Any]:
-        """Create an architectural plan before fixing the issue.
-
-        Returns a plan dictionary with:
-        - strategy: How to approach the fix
-        - patterns: Recommended patterns to use
-        - dependencies: Other changes needed
-        - risks: Potential issues to watch for
-        """
         pass
 
     async def analyze_and_fix_proactively(self, issue: Issue) -> FixResult:
-        """Execute proactive fix with planning phase.
-
-        1. Create architectural plan
-        2. Apply fix following the plan
-        3. Validate against plan
-        4. Cache successful patterns
-        """
-        # Check planning cache first
         cache_key = self._get_planning_cache_key(issue)
         if cache_key in self._planning_cache:
             plan = self._planning_cache[cache_key]
@@ -46,10 +24,8 @@ class ProactiveAgent(SubAgent):
             self._planning_cache[cache_key] = plan
             self.log(f"Created new plan for {cache_key}")
 
-        # Execute the fix with the plan
         result = await self._execute_with_plan(issue, plan)
 
-        # Cache successful patterns
         if result.success and result.confidence >= 0.8:
             self._cache_successful_pattern(issue, plan, result)
 
@@ -58,19 +34,14 @@ class ProactiveAgent(SubAgent):
     async def _execute_with_plan(
         self, issue: Issue, plan: dict[str, t.Any]
     ) -> FixResult:
-        """Execute the fix following the architectural plan."""
-        # Default implementation falls back to standard analyze_and_fix
-        # Subclasses should override to use the plan
         return await self.analyze_and_fix(issue)
 
     def _get_planning_cache_key(self, issue: Issue) -> str:
-        """Generate cache key for planning."""
         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:
-        """Cache successful patterns for future reuse."""
         pattern_key = f"{issue.type.value}_{plan.get('strategy', 'default')}"
         self._pattern_cache[pattern_key] = {
             "plan": plan,
@@ -81,24 +52,6 @@ class ProactiveAgent(SubAgent):
         self.log(f"Cached successful pattern: {pattern_key}")
 
     def get_cached_patterns(self) -> dict[str, t.Any]:
-        """Get all cached patterns for inspection."""
         return self._pattern_cache.copy()
 
-    def clear_pattern_cache(self) -> None:
-        """Clear the pattern cache."""
-        self._pattern_cache.clear()
-        self.log("Cleared pattern cache")
-
-    def get_planning_confidence(self, issue: Issue) -> float:
-        """Get confidence in planning ability for this issue."""
-        # Check if we have cached patterns for this issue type
-        issue_patterns = [
-            key for key in self._pattern_cache if key.startswith(issue.type.value)
-        ]
-
-        if issue_patterns:
-            # Higher confidence if we have successful patterns
-            return min(0.9, 0.6 + (len(issue_patterns) * 0.1))
-
-        # Base confidence from can_handle
-        return 0.5
+    # Removed unused methods: clear_pattern_cache, get_planning_confidence