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

crackerjack/agents/helpers/refactoring/code_transformer.py

@@ -0,0 +1,536 @@
+"""Code transformation and refactoring logic."""
+
+import typing as t
+
+from ....services.regex_patterns import SAFE_PATTERNS
+from ...base import AgentContext
+
+
+class CodeTransformer:
+    """Transforms and refactors code to reduce complexity."""
+
+    def __init__(self, context: AgentContext) -> None:
+        """Initialize transformer with agent context.
+
+        Args:
+            context: AgentContext for logging
+        """
+        self.context = context
+
+    def refactor_complex_functions(
+        self, content: str, complex_functions: list[dict[str, t.Any]]
+    ) -> str:
+        """Refactor complex functions.
+
+        Args:
+            content: File content
+            complex_functions: List of complex functions
+
+        Returns:
+            Refactored content
+        """
+        lines = content.split("\n")
+
+        for func_info in complex_functions:
+            func_name = func_info.get("name", "unknown")
+
+            if func_name == "detect_agent_needs":
+                refactored = self.refactor_detect_agent_needs_pattern(content)
+                if refactored != content:
+                    return refactored
+
+            func_content = self._extract_function_content(lines, func_info)
+            if func_content:
+                extracted_helpers = self._extract_logical_sections(
+                    func_content, func_info
+                )
+                if extracted_helpers:
+                    modified_content = self._apply_function_extraction(
+                        content, func_info, extracted_helpers
+                    )
+                    if modified_content != content:
+                        return modified_content
+
+        return content
+
+    def apply_enhanced_strategies(self, content: str) -> str:
+        """Apply enhanced complexity reduction strategies.
+
+        Args:
+            content: File content
+
+        Returns:
+            Refactored content
+        """
+        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.
+
+        Args:
+            content: File content
+
+        Returns:
+            Refactored content
+        """
+        operations = [
+            self._extract_nested_conditions,
+            self._simplify_boolean_expressions,
+            self._extract_validation_patterns,
+            self._simplify_data_structures,
+        ]
+
+        modified_content = content
+        for operation in operations:
+            modified_content = operation(modified_content)
+
+        return modified_content
+
+    @staticmethod
+    def _extract_nested_conditions(content: str) -> str:
+        """Extract nested conditions into helper methods.
+
+        Args:
+            content: File content
+
+        Returns:
+            Transformed content
+        """
+        lines = content.split("\n")
+        modified_lines = []
+
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+
+            if (
+                stripped.startswith("if ")
+                and (" and " in stripped or " or " in stripped)
+                and len(stripped) > 80
+            ):
+                indent = " " * (len(line) - len(line.lstrip()))
+                helper_name = f"_is_complex_condition_{i}"
+                modified_lines.append(f"{indent}if self.{helper_name}():")
+                continue
+
+            modified_lines.append(line)
+
+        return "\n".join(modified_lines)
+
+    @staticmethod
+    def _simplify_boolean_expressions(content: str) -> str:
+        """Simplify complex boolean expressions.
+
+        Args:
+            content: File content
+
+        Returns:
+            Transformed content
+        """
+        lines = content.split("\n")
+        modified_lines = []
+
+        for line in lines:
+            if " and " in line and " or " in line and len(line.strip()) > 100:
+                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}():")
+                    continue
+
+            modified_lines.append(line)
+
+        return "\n".join(modified_lines)
+
+    @staticmethod
+    def _extract_validation_patterns(content: str) -> str:
+        """Extract validation patterns.
+
+        Args:
+            content: File content
+
+        Returns:
+            Transformed content
+        """
+        if "validation_extract" in SAFE_PATTERNS:
+            content = SAFE_PATTERNS["validation_extract"].apply(content)
+        else:
+            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:
+                    pass
+
+        return content
+
+    @staticmethod
+    def _simplify_data_structures(content: str) -> str:
+        """Simplify complex data structures.
+
+        Args:
+            content: File content
+
+        Returns:
+            Transformed content
+        """
+        lines = content.split("\n")
+        modified_lines = []
+
+        for line in lines:
+            stripped = line.strip()
+
+            if (
+                "[" in stripped
+                and "for" in stripped
+                and "if" in stripped
+                and len(stripped) > 80
+            ):
+                pass
+
+            elif stripped.count(": ") > 5 and stripped.count(", ") > 5:
+                pass
+
+            modified_lines.append(line)
+
+        return "\n".join(modified_lines)
+
+    @staticmethod
+    def refactor_detect_agent_needs_pattern(content: str) -> str:
+        """Refactor detect_agent_needs function pattern.
+
+        Args:
+            content: File content
+
+        Returns:
+            Refactored content
+        """
+        detect_func_start = "async def detect_agent_needs("
+        if detect_func_start not in content:
+            return content
+
+        original_pattern = """ recommendations = {
+        "urgent_agents": [],
+        "suggested_agents": [],
+        "workflow_recommendations": [],
+        "detection_reasoning": "",
+    }
+
+    if error_context: """
+
+        replacement_pattern = """ recommendations = {
+        "urgent_agents": [],
+        "suggested_agents": [],
+        "workflow_recommendations": [],
+        "detection_reasoning": "",
+    }
+
+    _add_urgent_agents_for_errors(recommendations, error_context)
+    _add_python_project_suggestions(recommendations, file_patterns)
+    _set_workflow_recommendations(recommendations)
+    _generate_detection_reasoning(recommendations)
+
+    return json.dumps(recommendations, indent=2)"""
+
+        if original_pattern in content:
+            modified_content = content.replace(original_pattern, replacement_pattern)
+            if modified_content != content:
+                return modified_content
+
+        return content
+
+    def _extract_logical_sections(
+        self, func_content: str, func_info: dict[str, t.Any]
+    ) -> list[dict[str, str]]:
+        """Extract logical sections from function.
+
+        Args:
+            func_content: Function content
+            func_info: Function info
+
+        Returns:
+            List of sections
+        """
+        sections: list[dict[str, str]] = []
+        lines = func_content.split("\n")
+        current_section: list[str] = []
+        section_type: str | None = None
+
+        for line in lines:
+            stripped = line.strip()
+
+            if self._should_start_new_section(stripped, section_type):
+                if current_section:
+                    sections.append(
+                        self._create_section(
+                            current_section, section_type, len(sections)
+                        )
+                    )
+
+                current_section, section_type = self._initialize_new_section(
+                    line, stripped
+                )
+            else:
+                current_section.append(line)
+
+        if current_section:
+            sections.append(
+                self._create_section(current_section, section_type, len(sections))
+            )
+
+        return [s for s in sections if len(s["content"].split("\n")) >= 5]
+
+    @staticmethod
+    def _should_start_new_section(
+        stripped: str, current_section_type: str | None
+    ) -> bool:
+        """Check if should start new section.
+
+        Args:
+            stripped: Stripped line
+            current_section_type: Current section type
+
+        Returns:
+            True if should start new section
+        """
+        if stripped.startswith("if ") and len(stripped) > 50:
+            return True
+        return (
+            stripped.startswith(("for ", "while ")) and current_section_type != "loop"
+        )
+
+    @staticmethod
+    def _initialize_new_section(line: str, stripped: str) -> tuple[list[str], str]:
+        """Initialize new section.
+
+        Args:
+            line: Full line
+            stripped: Stripped line
+
+        Returns:
+            Tuple of section lines and type
+        """
+        if stripped.startswith("if ") and len(stripped) > 50:
+            return [line], "conditional"
+        elif stripped.startswith(("for ", "while ")):
+            return [line], "loop"
+        return [line], "general"
+
+    @staticmethod
+    def _create_section(
+        current_section: list[str], section_type: str | None, section_count: int
+    ) -> dict[str, str]:
+        """Create section dict.
+
+        Args:
+            current_section: Section lines
+            section_type: Section type
+            section_count: Section count
+
+        Returns:
+            Section dict
+        """
+        effective_type = section_type or "general"
+        name_prefix = "handle" if effective_type == "conditional" else "process"
+
+        return {
+            "type": effective_type,
+            "content": "\n".join(current_section),
+            "name": f"_{name_prefix}_{effective_type}_{section_count + 1}",
+        }
+
+    @staticmethod
+    def _extract_function_content(lines: list[str], func_info: dict[str, t.Any]) -> str:
+        """Extract function content.
+
+        Args:
+            lines: File lines
+            func_info: Function info
+
+        Returns:
+            Function content
+        """
+        start_line = func_info["line_start"] - 1
+        end_line = func_info.get("line_end", len(lines)) - 1
+
+        if start_line < 0 or end_line >= len(lines):
+            return ""
+
+        return "\n".join(lines[start_line : end_line + 1])
+
+    @staticmethod
+    def _apply_function_extraction(
+        content: str,
+        func_info: dict[str, t.Any],
+        extracted_helpers: list[dict[str, str]],
+    ) -> str:
+        """Apply function extraction refactoring.
+
+        Args:
+            content: File content
+            func_info: Function info
+            extracted_helpers: Helper functions
+
+        Returns:
+            Refactored content
+        """
+        lines = content.split("\n")
+
+        if not CodeTransformer._is_extraction_valid(
+            lines, func_info, extracted_helpers
+        ):
+            return "\n".join(lines)
+
+        return CodeTransformer._perform_extraction(lines, func_info, extracted_helpers)
+
+    @staticmethod
+    def _is_extraction_valid(
+        lines: list[str],
+        func_info: dict[str, t.Any],
+        extracted_helpers: list[dict[str, str]],
+    ) -> bool:
+        """Check if extraction is valid.
+
+        Args:
+            lines: File lines
+            func_info: Function info
+            extracted_helpers: Helpers
+
+        Returns:
+            True if valid
+        """
+        start_line = func_info["line_start"] - 1
+        end_line = func_info.get("line_end", len(lines)) - 1
+
+        return bool(extracted_helpers) and start_line >= 0 and end_line < len(lines)
+
+    @staticmethod
+    def _perform_extraction(
+        lines: list[str],
+        func_info: dict[str, t.Any],
+        extracted_helpers: list[dict[str, str]],
+    ) -> str:
+        """Perform extraction transformation.
+
+        Args:
+            lines: File lines
+            func_info: Function info
+            extracted_helpers: Helpers
+
+        Returns:
+            Transformed content
+        """
+        new_lines = CodeTransformer._replace_function_with_calls(
+            lines, func_info, extracted_helpers
+        )
+        return CodeTransformer._add_helper_definitions(
+            new_lines, func_info, extracted_helpers
+        )
+
+    @staticmethod
+    def _replace_function_with_calls(
+        lines: list[str],
+        func_info: dict[str, t.Any],
+        extracted_helpers: list[dict[str, str]],
+    ) -> list[str]:
+        """Replace function with helper calls.
+
+        Args:
+            lines: File lines
+            func_info: Function info
+            extracted_helpers: Helpers
+
+        Returns:
+            Modified lines
+        """
+        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]]
+        for helper in extracted_helpers:
+            new_func_lines.append(f"{indent}self.{helper['name']}()")
+
+        return lines[:start_line] + new_func_lines + lines[end_line + 1 :]
+
+    @staticmethod
+    def _add_helper_definitions(
+        new_lines: list[str],
+        func_info: dict[str, t.Any],
+        extracted_helpers: list[dict[str, str]],
+    ) -> str:
+        """Add helper definitions to class.
+
+        Args:
+            new_lines: Modified lines
+            func_info: Function info
+            extracted_helpers: Helpers
+
+        Returns:
+            Final content
+        """
+        start_line = func_info["line_start"] - 1
+        class_end = CodeTransformer._find_class_end(new_lines, start_line)
+
+        for helper in extracted_helpers:
+            helper_lines = helper["content"].split("\n")
+            new_lines = (
+                new_lines[:class_end] + [""] + helper_lines + new_lines[class_end:]
+            )
+            class_end += len(helper_lines) + 1
+
+        return "\n".join(new_lines)
+
+    @staticmethod
+    def _find_class_end(lines: list[str], func_start: int) -> int:
+        """Find end of class.
+
+        Args:
+            lines: File lines
+            func_start: Function start
+
+        Returns:
+            Class end line
+        """
+        class_indent = CodeTransformer._find_class_indent(lines, func_start)
+        if class_indent is None:
+            return len(lines)
+        return CodeTransformer._find_class_end_line(lines, func_start, class_indent)
+
+    @staticmethod
+    def _find_class_indent(lines: list[str], func_start: int) -> int | None:
+        """Find class indentation.
+
+        Args:
+            lines: File lines
+            func_start: Function start
+
+        Returns:
+            Class indent or None
+        """
+        for i in range(func_start, -1, -1):
+            if lines[i].strip().startswith("class "):
+                return len(lines[i]) - len(lines[i].lstrip())
+        return None
+
+    @staticmethod
+    def _find_class_end_line(
+        lines: list[str], func_start: int, class_indent: int
+    ) -> int:
+        """Find class end line.
+
+        Args:
+            lines: File lines
+            func_start: Function start
+            class_indent: Class indent
+
+        Returns:
+            Class end line
+        """
+        for i in range(func_start + 1, len(lines)):
+            line = lines[i]
+            if line.strip() and len(line) - len(line.lstrip()) <= class_indent:
+                return i
+        return len(lines)