crackerjack 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/agents/performance_helpers.py

@@ -1,5 +1,3 @@
-"""Performance analysis helper classes and utilities."""
-
 import ast
 import typing as t
 from dataclasses import dataclass
@@ -7,16 +5,12 @@ 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]] = []
@@ -29,7 +23,6 @@ class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
         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))
 
@@ -44,7 +37,6 @@ class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
     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,
@@ -63,8 +55,7 @@ class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
     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
+        if current_depth >= 3:
             self.complexity_hotspots.append(
                 loop_info
                 | {
@@ -74,11 +65,9 @@ class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
             )
 
     def _calculate_complexity_factor(self, depth: int) -> int:
-        """Calculate relative complexity factor for optimization prioritization."""
-        return depth**2  # Exponential growth factor
+        return depth**2
 
     def _get_optimization_priority(self, depth: int) -> str:
-        """Determine optimization priority based on nesting depth."""
         if depth >= 4:
             return "critical"
         elif depth == 3:
@@ -88,7 +77,6 @@ class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
         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):
@@ -100,15 +88,13 @@ class EnhancedNestedLoopAnalyzer(ast.NodeVisitor):
             }
             if node.iter.func.id == "range":
                 iterable_info["optimization_hint"] = (
-                    "Consider list comprehension or vectorization"
+                    "Consider list[t.Any] 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
@@ -131,22 +117,18 @@ class EnhancedListOpAnalyzer(ast.NodeVisitor):
         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):
@@ -155,8 +137,6 @@ class EnhancedListOpAnalyzer(ast.NodeVisitor):
             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)
 
@@ -164,7 +144,7 @@ class EnhancedListOpAnalyzer(ast.NodeVisitor):
             {
                 "line_number": node.lineno,
                 "type": "list_concat_in_loop",
-                "pattern": f"list += [{list_size} items]",
+                "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",
@@ -175,13 +155,12 @@ class EnhancedListOpAnalyzer(ast.NodeVisitor):
         )
 
     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}",
+                "pattern": f"list[t.Any] += {var_name}",
                 "loop_depth": self.loop_depth,
                 "impact_factor": impact_factor,
                 "optimization": "extend",
@@ -190,8 +169,7 @@ class EnhancedListOpAnalyzer(ast.NodeVisitor):
         )
 
     def _calculate_performance_impact(self) -> int:
-        """Calculate expected performance impact based on context."""
-        base_impact = 2  # Baseline improvement factor
+        base_impact = 2
 
         if self.loop_depth > 1:
             base_impact *= self.loop_depth**2
@@ -199,17 +177,15 @@ class EnhancedListOpAnalyzer(ast.NodeVisitor):
         if self._is_hot_loop():
             base_impact *= 5
 
-        return min(base_impact, 50)  # Cap at 50x impact
+        return min(base_impact, 50)
 
     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
 

crackerjack/agents/proactive_agent.py

@@ -37,7 +37,7 @@ class ProactiveAgent(SubAgent):
         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}"
+        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
@@ -53,5 +53,3 @@ class ProactiveAgent(SubAgent):
 
     def get_cached_patterns(self) -> dict[str, t.Any]:
         return self._pattern_cache.copy()
-
-    # Removed unused methods: clear_pattern_cache, get_planning_confidence

crackerjack/agents/refactoring_agent.py

@@ -25,15 +25,12 @@ class RefactoringAgent(SubAgent):
 
     async def can_handle(self, issue: Issue) -> float:
         if issue.type == IssueType.COMPLEXITY:
-            # Enhanced confidence for complexity reduction
             return 0.9 if self._has_complexity_markers(issue) else 0.85
         if issue.type == IssueType.DEAD_CODE:
-            # Enhanced confidence for dead code detection
             return 0.8 if self._has_dead_code_markers(issue) else 0.75
         return 0.0
 
     def _has_complexity_markers(self, issue: Issue) -> bool:
-        """Check if issue shows signs of high complexity that we can handle."""
         if not issue.message:
             return False
 
@@ -52,7 +49,6 @@ class RefactoringAgent(SubAgent):
         )
 
     def _has_dead_code_markers(self, issue: Issue) -> bool:
-        """Check if issue shows signs of dead code that we can handle."""
         if not issue.message:
             return False
 
@@ -407,13 +403,11 @@ class RefactoringAgent(SubAgent):
         self,
         node: ast.FunctionDef | ast.AsyncFunctionDef,
     ) -> int:
-        """Enhanced cognitive complexity calculator with more accurate scoring."""
         calculator = self._create_complexity_calculator()
         calculator.visit(node)
         return calculator.complexity
 
     def _create_complexity_calculator(self) -> "ComplexityCalculator":
-        """Create and configure the complexity calculator."""
         from . import refactoring_helpers
 
         return refactoring_helpers.ComplexityCalculator()
@@ -423,20 +417,17 @@ class RefactoringAgent(SubAgent):
         content: str,
         complex_functions: list[dict[str, t.Any]],
     ) -> str:
-        # First try specific function refactoring
         refactored_content = self._refactor_complex_functions(
             content, complex_functions
         )
         if refactored_content != content:
             return refactored_content
 
-        # Apply enhanced complexity reduction strategies
         return self._apply_enhanced_strategies(content)
 
     def _refactor_complex_functions(
         self, content: str, complex_functions: list[dict[str, t.Any]]
     ) -> str:
-        """Refactor complex functions by applying specific patterns."""
         lines = content.split("\n")
 
         for func_info in complex_functions:
@@ -462,12 +453,10 @@ class RefactoringAgent(SubAgent):
         return content
 
     def _apply_enhanced_strategies(self, content: str) -> str:
-        """Apply enhanced complexity reduction strategies."""
         enhanced_content = self._apply_enhanced_complexity_patterns(content)
         return enhanced_content
 
     def _apply_enhanced_complexity_patterns(self, content: str) -> str:
-        """Apply enhanced complexity reduction patterns using SAFE_PATTERNS."""
         operations = [
             self._extract_nested_conditions,
             self._simplify_boolean_expressions,
@@ -482,23 +471,20 @@ class RefactoringAgent(SubAgent):
         return modified_content
 
     def _extract_nested_conditions(self, content: str) -> str:
-        """Extract deeply nested conditions into helper methods."""
         lines = content.split("\n")
         modified_lines = []
 
         for i, line in enumerate(lines):
             stripped = line.strip()
 
-            # Look for complex conditions that could be extracted
             if (
                 stripped.startswith("if ")
                 and (" and " in stripped or " or " in stripped)
                 and len(stripped) > 80
             ):
-                # This is a candidate for extraction
                 indent = " " * (len(line) - len(line.lstrip()))
                 helper_name = f"_is_complex_condition_{i}"
-                modified_lines.append(f"{indent}if self.{helper_name}():")
+                modified_lines.append(f"{indent}if self.{helper_name}(): ")
                 continue
 
             modified_lines.append(line)
@@ -506,18 +492,15 @@ class RefactoringAgent(SubAgent):
         return "\n".join(modified_lines)
 
     def _simplify_boolean_expressions(self, content: str) -> str:
-        """Simplify complex boolean expressions using SAFE_PATTERNS."""
-        # Look for long boolean chains and suggest extraction
         lines = content.split("\n")
         modified_lines = []
 
         for line in lines:
             if " and " in line and " or " in line and len(line.strip()) > 100:
-                # Mark for potential extraction
                 if line.strip().startswith("if "):
                     indent = " " * (len(line) - len(line.lstrip()))
                     method_name = "_validate_complex_condition"
-                    modified_lines.append(f"{indent}if self.{method_name}():")
+                    modified_lines.append(f"{indent}if self.{method_name}(): ")
                     continue
 
             modified_lines.append(line)
@@ -525,46 +508,35 @@ class RefactoringAgent(SubAgent):
         return "\n".join(modified_lines)
 
     def _extract_validation_patterns(self, content: str) -> str:
-        """Extract common validation patterns to separate methods."""
-        # Look for repeated validation patterns
         if "validation_extract" in SAFE_PATTERNS:
             content = SAFE_PATTERNS["validation_extract"].apply(content)
         else:
-            # Use safe pattern matching instead of raw regex
             pattern_obj = SAFE_PATTERNS["match_validation_patterns"]
             if pattern_obj.test(content):
                 matches = len(
                     [line for line in content.split("\n") if pattern_obj.test(line)]
                 )
-                if matches > 2:  # Found repeated pattern
-                    # Could extract to helper method
+                if matches > 2:
                     pass
 
         return content
 
     def _simplify_data_structures(self, content: str) -> str:
-        """Simplify complex data structure operations."""
-        # Look for complex dictionary/list comprehensions
         lines = content.split("\n")
         modified_lines = []
 
         for line in lines:
             stripped = line.strip()
 
-            # Check for complex list comprehensions
             if (
                 "[" in stripped
                 and "for" in stripped
                 and "if" in stripped
                 and len(stripped) > 80
             ):
-                # Consider extracting to separate method
-                # Could add logic to extract comprehension
                 pass
 
-            # Check for large dictionary literals
-            elif stripped.count(":") > 5 and stripped.count(",") > 5:
-                # Could extract to builder method
+            elif stripped.count(": ") > 5 and stripped.count(", ") > 5:
                 pass
 
             modified_lines.append(line)
@@ -583,7 +555,7 @@ class RefactoringAgent(SubAgent):
         "detection_reasoning": "",
     }
 
-    if error_context:"""
+    if error_context: """
 
         replacement_pattern = """ recommendations = {
         "urgent_agents": [],
@@ -609,11 +581,10 @@ class RefactoringAgent(SubAgent):
     def _extract_logical_sections(
         self, func_content: str, func_info: dict[str, t.Any]
     ) -> list[dict[str, str]]:
-        """Extract logical sections from function content for refactoring."""
-        sections = []
+        sections: list[dict[str, str]] = []
         lines = func_content.split("\n")
-        current_section = []
-        section_type = None
+        current_section: list[str] = []
+        section_type: str | None = None
 
         for line in lines:
             stripped = line.strip()
@@ -632,7 +603,6 @@ class RefactoringAgent(SubAgent):
             else:
                 current_section.append(line)
 
-        # Handle final section
         if current_section:
             sections.append(
                 self._create_section(current_section, section_type, len(sections))
@@ -643,7 +613,6 @@ class RefactoringAgent(SubAgent):
     def _should_start_new_section(
         self, stripped: str, current_section_type: str | None
     ) -> bool:
-        """Determine if a line should start a new logical section."""
         if stripped.startswith("if ") and len(stripped) > 50:
             return True
         return (
@@ -653,7 +622,6 @@ class RefactoringAgent(SubAgent):
     def _initialize_new_section(
         self, line: str, stripped: str
     ) -> tuple[list[str], str]:
-        """Initialize a new section based on the line type."""
         if stripped.startswith("if ") and len(stripped) > 50:
             return [line], "conditional"
         elif stripped.startswith(("for ", "while ")):
@@ -662,8 +630,7 @@ class RefactoringAgent(SubAgent):
 
     def _create_section(
         self, current_section: list[str], section_type: str | None, section_count: int
-    ) -> dict[str, str | None]:
-        """Create a section dictionary from the current section data."""
+    ) -> dict[str, str]:
         effective_type = section_type or "general"
         name_prefix = "handle" if effective_type == "conditional" else "process"
 
@@ -674,7 +641,6 @@ class RefactoringAgent(SubAgent):
         }
 
     def _analyze_dead_code(self, tree: ast.AST, content: str) -> dict[str, t.Any]:
-        """Enhanced analysis for dead/unused elements."""
         analysis: dict[str, list[t.Any]] = {
             "unused_imports": [],
             "unused_variables": [],
@@ -694,14 +660,12 @@ class RefactoringAgent(SubAgent):
         return analysis
 
     def _collect_usage_data(self, tree: ast.AST) -> dict[str, t.Any]:
-        """Enhanced collection of usage data from AST."""
         collector = self._create_usage_data_collector()
         analyzer = self._create_enhanced_usage_analyzer(collector)
         analyzer.visit(tree)
         return collector.get_results(analyzer)
 
     def _create_usage_data_collector(self) -> "UsageDataCollector":
-        """Create data collector for usage analysis."""
         from . import refactoring_helpers
 
         return refactoring_helpers.UsageDataCollector()
@@ -709,7 +673,6 @@ class RefactoringAgent(SubAgent):
     def _create_enhanced_usage_analyzer(
         self, collector: "UsageDataCollector"
     ) -> "EnhancedUsageAnalyzer":
-        """Create the enhanced usage analyzer."""
         from . import refactoring_helpers
 
         return refactoring_helpers.EnhancedUsageAnalyzer(collector)
@@ -719,7 +682,6 @@ class RefactoringAgent(SubAgent):
         analysis: dict[str, t.Any],
         analyzer_result: dict[str, t.Any],
     ) -> None:
-        """Process unused imports and add to analysis."""
         import_lines: list[tuple[int, str, str]] = analyzer_result["import_lines"]
         for line_no, name, import_type in import_lines:
             if name not in analyzer_result["used_names"]:
@@ -737,7 +699,6 @@ class RefactoringAgent(SubAgent):
         analysis: dict[str, t.Any],
         analyzer_result: dict[str, t.Any],
     ) -> None:
-        """Process unused functions and add to analysis."""
         all_unused_functions: list[dict[str, t.Any]] = analyzer_result[
             "unused_functions"
         ]
@@ -753,7 +714,6 @@ class RefactoringAgent(SubAgent):
     def _process_unused_classes(
         self, analysis: dict[str, t.Any], analyzer_result: dict[str, t.Any]
     ) -> None:
-        """Process unused classes and add to analysis."""
         if "unused_classes" not in analyzer_result:
             return
 
@@ -770,11 +730,9 @@ class RefactoringAgent(SubAgent):
     def _detect_unreachable_code(
         self, analysis: dict[str, t.Any], tree: ast.AST, content: str
     ) -> None:
-        """Detect unreachable code patterns."""
-
         class UnreachableCodeDetector(ast.NodeVisitor):
-            def __init__(self):
-                self.unreachable_blocks = []
+            def __init__(self) -> None:
+                self.unreachable_blocks: list[dict[str, t.Any]] = []
 
             def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
                 self._check_unreachable_in_function(node)
@@ -787,10 +745,8 @@ class RefactoringAgent(SubAgent):
             def _check_unreachable_in_function(
                 self, node: ast.FunctionDef | ast.AsyncFunctionDef
             ) -> None:
-                """Check for unreachable code after return/raise statements."""
                 for i, stmt in enumerate(node.body):
                     if isinstance(stmt, ast.Return | ast.Raise):
-                        # Check if there are statements after this
                         if i + 1 < len(node.body):
                             next_stmt = node.body[i + 1]
                             self.unreachable_blocks.append(
@@ -813,28 +769,23 @@ class RefactoringAgent(SubAgent):
     def _detect_redundant_code(
         self, analysis: dict[str, t.Any], tree: ast.AST, content: str
     ) -> None:
-        """Detect redundant code patterns."""
         lines = content.split("\n")
 
-        # Look for duplicate code blocks
         line_hashes = {}
         for i, line in enumerate(lines):
             if line.strip() and not line.strip().startswith("#"):
                 line_hash = hash(line.strip())
                 if line_hash in line_hashes:
-                    # Potential duplicate
                     analysis["removable_items"].append(
                         f"potential duplicate code at line {i + 1}"
                     )
                 line_hashes[line_hash] = i
 
-        # Look for empty except blocks
         class RedundantPatternDetector(ast.NodeVisitor):
-            def __init__(self):
-                self.redundant_items = []
+            def __init__(self) -> None:
+                self.redundant_items: list[dict[str, t.Any]] = []
 
             def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
-                # Check for empty except blocks or just 'pass'
                 if len(node.body) == 1 and isinstance(node.body[0], ast.Pass):
                     self.redundant_items.append(
                         {"type": "empty_except", "line": node.lineno}
@@ -842,7 +793,6 @@ class RefactoringAgent(SubAgent):
                 self.generic_visit(node)
 
             def visit_If(self, node: ast.If) -> None:
-                # Check for if True: or if False:
                 if isinstance(node.test, ast.Constant):
                     if node.test.value is True:
                         self.redundant_items.append(
@@ -865,7 +815,6 @@ class RefactoringAgent(SubAgent):
     def _should_remove_import_line(
         self, line: str, unused_import: dict[str, str]
     ) -> bool:
-        """Check if an import line should be removed."""
         if unused_import["type"] == "import":
             return f"import {unused_import['name']}" in line
         elif unused_import["type"] == "from_import":
@@ -879,20 +828,18 @@ class RefactoringAgent(SubAgent):
     def _find_lines_to_remove(
         self, lines: list[str], analysis: dict[str, t.Any]
     ) -> set[int]:
-        """Find line indices that should be removed."""
         lines_to_remove: set[int] = set()
 
         for unused_import in analysis["unused_imports"]:
             line_idx = unused_import["line"] - 1
             if 0 <= line_idx < len(lines):
-                line = t.cast(str, lines[line_idx])
+                line = lines[line_idx]
                 if self._should_remove_import_line(line, unused_import):
                     lines_to_remove.add(line_idx)
 
         return lines_to_remove
 
     def _remove_dead_code_items(self, content: str, analysis: dict[str, t.Any]) -> str:
-        """Enhanced removal of dead code items from content."""
         lines = content.split("\n")
         lines_to_remove = self._collect_all_removable_lines(lines, analysis)
 
@@ -905,7 +852,6 @@ class RefactoringAgent(SubAgent):
     def _collect_all_removable_lines(
         self, lines: list[str], analysis: dict[str, t.Any]
     ) -> set[int]:
-        """Collect all line indices that should be removed."""
         removal_functions = [
             lambda: self._find_lines_to_remove(lines, analysis),
             lambda: self._find_unreachable_lines(lines, analysis),
@@ -921,12 +867,10 @@ class RefactoringAgent(SubAgent):
     def _find_unreachable_lines(
         self, lines: list[str], analysis: dict[str, t.Any]
     ) -> set[int]:
-        """Find line indices for unreachable code."""
         lines_to_remove: set[int] = set()
 
         for item in analysis.get("unreachable_code", []):
             if "line" in item:
-                # Remove the unreachable line (convert to 0-based index)
                 line_idx = item["line"] - 1
                 if 0 <= line_idx < len(lines):
                     lines_to_remove.add(line_idx)
@@ -936,10 +880,8 @@ class RefactoringAgent(SubAgent):
     def _find_redundant_lines(
         self, lines: list[str], analysis: dict[str, t.Any]
     ) -> set[int]:
-        """Find line indices for redundant code patterns."""
         lines_to_remove: set[int] = set()
 
-        # Look for empty except blocks
         for i in range(len(lines)):
             if self._is_empty_except_block(lines, i):
                 empty_pass_idx = self._find_empty_pass_line(lines, i)
@@ -949,12 +891,10 @@ class RefactoringAgent(SubAgent):
         return lines_to_remove
 
     def _is_empty_except_block(self, lines: list[str], line_idx: int) -> bool:
-        """Check if line is an empty except block."""
         stripped = lines[line_idx].strip()
-        return stripped == "except:" or stripped.startswith("except ")
+        return stripped == "except: " or stripped.startswith("except ")
 
     def _find_empty_pass_line(self, lines: list[str], except_idx: int) -> int | None:
-        """Find the pass line in an empty except block."""
         for j in range(except_idx + 1, min(except_idx + 5, len(lines))):
             next_line = lines[j].strip()
             if not next_line:
@@ -967,7 +907,6 @@ class RefactoringAgent(SubAgent):
     def _extract_function_content(
         self, lines: list[str], func_info: dict[str, t.Any]
     ) -> str:
-        """Extract the complete content of a function."""
         start_line = func_info["line_start"] - 1
         end_line = func_info.get("line_end", len(lines)) - 1
 
@@ -982,7 +921,6 @@ class RefactoringAgent(SubAgent):
         func_info: dict[str, t.Any],
         extracted_helpers: list[dict[str, str]],
     ) -> str:
-        """Apply function extraction by replacing original with calls to helpers."""
         lines = content.split("\n")
 
         if not self._is_extraction_valid(lines, func_info, extracted_helpers):
@@ -996,7 +934,6 @@ class RefactoringAgent(SubAgent):
         func_info: dict[str, t.Any],
         extracted_helpers: list[dict[str, str]],
     ) -> bool:
-        """Check if extraction parameters are valid."""
         start_line = func_info["line_start"] - 1
         end_line = func_info.get("line_end", len(lines)) - 1
 
@@ -1008,7 +945,6 @@ class RefactoringAgent(SubAgent):
         func_info: dict[str, t.Any],
         extracted_helpers: list[dict[str, str]],
     ) -> str:
-        """Perform the actual function extraction."""
         new_lines = self._replace_function_with_calls(
             lines, func_info, extracted_helpers
         )
@@ -1020,13 +956,12 @@ class RefactoringAgent(SubAgent):
         func_info: dict[str, t.Any],
         extracted_helpers: list[dict[str, str]],
     ) -> list[str]:
-        """Replace the original function with calls to helper methods."""
         start_line = func_info["line_start"] - 1
         end_line = func_info.get("line_end", len(lines)) - 1
         func_indent = len(lines[start_line]) - len(lines[start_line].lstrip())
         indent = " " * (func_indent + 4)
 
-        new_func_lines = [lines[start_line]]  # Function definition
+        new_func_lines = [lines[start_line]]
         for helper in extracted_helpers:
             new_func_lines.append(f"{indent}self.{helper['name']}()")
 
@@ -1038,7 +973,6 @@ class RefactoringAgent(SubAgent):
         func_info: dict[str, t.Any],
         extracted_helpers: list[dict[str, str]],
     ) -> str:
-        """Add helper method definitions at the end of the class."""
         start_line = func_info["line_start"] - 1
         class_end = self._find_class_end(new_lines, start_line)
 
@@ -1052,14 +986,12 @@ class RefactoringAgent(SubAgent):
         return "\n".join(new_lines)
 
     def _find_class_end(self, lines: list[str], func_start: int) -> int:
-        """Find the end of the class containing the function."""
         class_indent = self._find_class_indent(lines, func_start)
         if class_indent is None:
             return len(lines)
         return self._find_class_end_line(lines, func_start, class_indent)
 
     def _find_class_indent(self, lines: list[str], func_start: int) -> int | None:
-        """Find the indentation level of the class containing the function."""
         for i in range(func_start, -1, -1):
             if lines[i].strip().startswith("class "):
                 return len(lines[i]) - len(lines[i].lstrip())
@@ -1068,7 +1000,6 @@ class RefactoringAgent(SubAgent):
     def _find_class_end_line(
         self, lines: list[str], func_start: int, class_indent: int
     ) -> int:
-        """Find the line where the class ends based on indentation."""
         for i in range(func_start + 1, len(lines)):
             line = lines[i]
             if line.strip() and len(line) - len(line.lstrip()) <= class_indent: