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

crackerjack/agents/dry_agent.py

@@ -1,7 +1,7 @@
-import re
 import typing as t
 from pathlib import Path
 
+from ..services.regex_patterns import SAFE_PATTERNS
 from .base import (
     FixResult,
     Issue,
@@ -12,8 +12,6 @@ from .base import (
 
 
 class DRYAgent(SubAgent):
-    """Agent specialized in detecting and fixing DRY (Don't Repeat Yourself) violations."""
-
     def get_supported_types(self) -> set[IssueType]:
         return {IssueType.DRY_VIOLATION}
 
@@ -42,7 +40,6 @@ class DRYAgent(SubAgent):
             return self._create_dry_error_result(e)
 
     def _validate_dry_issue(self, issue: Issue) -> FixResult | None:
-        """Validate the DRY violation issue has required information."""
         if not issue.file_path:
             return FixResult(
                 success=False,
@@ -50,7 +47,6 @@ class DRYAgent(SubAgent):
                 remaining_issues=["No file path specified for DRY violation"],
             )
 
-        # At this point, issue.file_path is not None due to the check above
         file_path = Path(issue.file_path)
         if not file_path.exists():
             return FixResult(
@@ -62,7 +58,6 @@ class DRYAgent(SubAgent):
         return None
 
     async def _process_dry_violation(self, file_path: Path) -> FixResult:
-        """Process DRY violation detection and fixing for a file."""
         content = self.context.get_file_content(file_path)
         if not content:
             return FixResult(
@@ -88,7 +83,6 @@ class DRYAgent(SubAgent):
         content: str,
         violations: list[dict[str, t.Any]],
     ) -> FixResult:
-        """Apply DRY fixes and save changes."""
         fixed_content = self._apply_dry_fixes(content, violations)
 
         if fixed_content == content:
@@ -114,7 +108,6 @@ class DRYAgent(SubAgent):
         )
 
     def _create_no_fixes_result(self) -> FixResult:
-        """Create result for when no fixes could be applied."""
         return FixResult(
             success=False,
             confidence=0.5,
@@ -127,7 +120,6 @@ class DRYAgent(SubAgent):
         )
 
     def _create_dry_error_result(self, error: Exception) -> FixResult:
-        """Create result for DRY processing errors."""
         return FixResult(
             success=False,
             confidence=0.0,
@@ -139,46 +131,41 @@ class DRYAgent(SubAgent):
         content: str,
         file_path: Path,
     ) -> list[dict[str, t.Any]]:
-        """Detect various types of DRY violations in the code."""
         violations: list[dict[str, t.Any]] = []
 
-        # Detect error response patterns
         violations.extend(self._detect_error_response_patterns(content))
 
-        # Detect path conversion patterns
         violations.extend(self._detect_path_conversion_patterns(content))
 
-        # Detect file existence patterns
         violations.extend(self._detect_file_existence_patterns(content))
 
-        # Detect exception handling patterns
         violations.extend(self._detect_exception_patterns(content))
 
         return violations
 
     def _detect_error_response_patterns(self, content: str) -> list[dict[str, t.Any]]:
-        """Detect repetitive error response patterns."""
         violations: list[dict[str, t.Any]] = []
         lines = content.split("\n")
 
-        # Pattern: return f'{"error": "message", "success": false}'
-        error_pattern = re.compile(
-            r'return\s+f?[\'\"]\{[\'\""]error[\'\""]:\s*[\'\""]([^\'\"]*)[\'\""].*\}[\'\""]',
-        )
+        error_pattern = SAFE_PATTERNS["detect_error_response_patterns"]
 
         error_responses: list[dict[str, t.Any]] = []
         for i, line in enumerate(lines):
-            match = error_pattern.search(line.strip())
-            if match:
-                error_responses.append(
-                    {
-                        "line_number": i + 1,
-                        "content": line.strip(),
-                        "error_message": match.group(1),
-                    },
-                )
-
-        if len(error_responses) >= 3:  # Only flag if 3+ similar patterns
+            if error_pattern.test(line.strip()):
+                # Extract error message using the pattern's compiled regex access
+                # Access the compiled pattern from SAFE_PATTERNS to get groups
+                compiled_pattern = error_pattern._get_compiled_pattern()
+                match = compiled_pattern.search(line.strip())
+                if match:
+                    error_responses.append(
+                        {
+                            "line_number": i + 1,
+                            "content": line.strip(),
+                            "error_message": match.group(1),
+                        },
+                    )
+
+        if len(error_responses) >= 3:
             violations.append(
                 {
                     "type": "error_response_pattern",
@@ -190,14 +177,10 @@ class DRYAgent(SubAgent):
         return violations
 
     def _detect_path_conversion_patterns(self, content: str) -> list[dict[str, t.Any]]:
-        """Detect repetitive path conversion patterns."""
         violations: list[dict[str, t.Any]] = []
         lines = content.split("\n")
 
-        # Pattern: Path(path) if isinstance(path, str) else path
-        path_pattern = re.compile(
-            r"Path\([^)]+\)\s+if\s+isinstance\([^)]+,\s*str\)\s+else\s+[^)]+",
-        )
+        path_pattern = SAFE_PATTERNS["detect_path_conversion_patterns"]
 
         path_conversions: list[dict[str, t.Any]] = [
             {
@@ -205,7 +188,7 @@ class DRYAgent(SubAgent):
                 "content": line.strip(),
             }
             for i, line in enumerate(lines)
-            if path_pattern.search(line)
+            if path_pattern.test(line)
         ]
 
         if len(path_conversions) >= 2:
@@ -220,12 +203,10 @@ class DRYAgent(SubAgent):
         return violations
 
     def _detect_file_existence_patterns(self, content: str) -> list[dict[str, t.Any]]:
-        """Detect repetitive file existence check patterns."""
         violations: list[dict[str, t.Any]] = []
         lines = content.split("\n")
 
-        # Pattern: if not *.exists():
-        existence_pattern = re.compile(r"if\s+not\s+\w+\.exists\(\):")
+        existence_pattern = SAFE_PATTERNS["detect_file_existence_patterns"]
 
         existence_checks: list[dict[str, t.Any]] = [
             {
@@ -233,7 +214,7 @@ class DRYAgent(SubAgent):
                 "content": line.strip(),
             }
             for i, line in enumerate(lines)
-            if existence_pattern.search(line.strip())
+            if existence_pattern.test(line.strip())
         ]
 
         if len(existence_checks) >= 3:
@@ -248,17 +229,14 @@ class DRYAgent(SubAgent):
         return violations
 
     def _detect_exception_patterns(self, content: str) -> list[dict[str, t.Any]]:
-        """Detect repetitive exception handling patterns."""
         violations: list[dict[str, t.Any]] = []
         lines = content.split("\n")
 
-        # Pattern: except Exception as e: return {"error": str(e)}
-        exception_pattern = re.compile(r"except\s+\w*Exception\s+as\s+\w+:")
+        exception_pattern = SAFE_PATTERNS["detect_exception_patterns"]
 
         exception_handlers: list[dict[str, t.Any]] = []
         for i, line in enumerate(lines):
-            if exception_pattern.search(line.strip()):
-                # Look ahead for error return pattern
+            if exception_pattern.test(line.strip()):
                 if (
                     i + 1 < len(lines)
                     and "error" in lines[i + 1]
@@ -284,105 +262,152 @@ class DRYAgent(SubAgent):
         return violations
 
     def _apply_dry_fixes(self, content: str, violations: list[dict[str, t.Any]]) -> str:
-        """Apply fixes for detected DRY violations."""
         lines = content.split("\n")
         modified = False
 
         for violation in violations:
-            if violation["type"] == "error_response_pattern":
-                lines, changed = self._fix_error_response_pattern(lines, violation)
-                modified = modified or changed
-            elif violation["type"] == "path_conversion_pattern":
-                lines, changed = self._fix_path_conversion_pattern(lines, violation)
-                modified = modified or changed
+            lines, changed = self._apply_violation_fix(lines, violation)
+            modified = modified or changed
 
         return "\n".join(lines) if modified else content
 
+    def _apply_violation_fix(
+        self, lines: list[str], violation: dict[str, t.Any]
+    ) -> tuple[list[str], bool]:
+        """Apply fix for a specific violation type."""
+        violation_type = violation["type"]
+
+        if violation_type == "error_response_pattern":
+            return self._fix_error_response_pattern(lines, violation)
+        elif violation_type == "path_conversion_pattern":
+            return self._fix_path_conversion_pattern(lines, violation)
+
+        return lines, False
+
     def _fix_error_response_pattern(
         self,
         lines: list[str],
         violation: dict[str, t.Any],
     ) -> tuple[list[str], bool]:
-        """Fix error response patterns by adding utility function."""
-        # Add utility function at the top of the file (after imports)
-        utility_function = '''
+        # Add utility functions to the file
+        utility_lines = self._add_error_response_utilities(lines)
+
+        # Apply pattern replacements to affected lines
+        self._apply_error_pattern_replacements(lines, violation, len(utility_lines))
+
+        return lines, True
+
+    def _add_error_response_utilities(self, lines: list[str]) -> list[str]:
+        """Add utility functions for error responses and path conversion."""
+        utility_function = """
 def _create_error_response(message: str, success: bool = False) -> str:
-    """Utility function to create standardized error responses."""
+
     import json
     return json.dumps({"error": message, "success": success})
-'''
 
-        # Find the right place to insert (after imports)
+def _ensure_path(path: str | Path) -> Path:
+
+    return Path(path) if isinstance(path, str) else path
+"""
+
+        insert_pos = self._find_utility_insert_position(lines)
+        utility_lines = utility_function.strip().split("\n")
+
+        for i, util_line in enumerate(utility_lines):
+            lines.insert(insert_pos + i, util_line)
+
+        return [line for line in utility_lines]
+
+    def _find_utility_insert_position(self, lines: list[str]) -> int:
+        """Find the best position to insert utility functions."""
         insert_pos = 0
         for i, line in enumerate(lines):
             if line.strip().startswith(("import ", "from ")):
                 insert_pos = i + 1
             elif line.strip() and not line.strip().startswith("#"):
                 break
+        return insert_pos
 
-        # Insert utility function
-        utility_lines = utility_function.strip().split("\n")
-        for i, util_line in enumerate(utility_lines):
-            lines.insert(insert_pos + i, util_line)
+    def _apply_error_pattern_replacements(
+        self, lines: list[str], violation: dict[str, t.Any], utility_lines_count: int
+    ) -> None:
+        """Apply pattern replacements to lines with error response patterns."""
+        path_pattern = SAFE_PATTERNS["fix_path_conversion_with_ensure_path"]
 
-        # Replace error response patterns
         for instance in violation["instances"]:
             line_number: int = int(instance["line_number"])
-            line_idx = line_number - 1 + len(utility_lines)  # Adjust for inserted lines
+            line_idx = line_number - 1 + utility_lines_count
+
             if line_idx < len(lines):
                 original_line: str = lines[line_idx]
-                # Extract the error message
-                error_msg: str = str(instance["error_message"])
-                # Replace with utility function call
-                indent = len(original_line) - len(original_line.lstrip())
-                new_line = (
-                    " " * indent + f'return _create_error_response("{error_msg}")'
-                )
+                new_line: str = path_pattern.apply(original_line)
                 lines[line_idx] = new_line
 
-        return lines, True
-
     def _fix_path_conversion_pattern(
         self,
         lines: list[str],
         violation: dict[str, t.Any],
     ) -> tuple[list[str], bool]:
         """Fix path conversion patterns by adding utility function."""
-        # Add utility function
-        utility_function = '''
-def _ensure_path(path: str | Path) -> Path:
-    """Utility function to ensure a path is a Path object."""
-    return Path(path) if isinstance(path, str) else path
-'''
+        utility_function_added = self._check_ensure_path_exists(lines)
+        adjustment = 0
 
-        # Find insertion point (after imports)
-        insert_pos = 0
-        for i, line in enumerate(lines):
-            if line.strip().startswith(("import ", "from ")):
-                insert_pos = i + 1
-            elif line.strip() and not line.strip().startswith("#"):
-                break
+        if not utility_function_added:
+            adjustment = self._add_ensure_path_utility(lines)
+
+        modified = self._apply_path_pattern_replacements(
+            lines, violation, adjustment, utility_function_added
+        )
+
+        return lines, modified
+
+    def _check_ensure_path_exists(self, lines: list[str]) -> bool:
+        """Check if _ensure_path utility function already exists."""
+        return any(
+            "_ensure_path" in line and "def _ensure_path" in line for line in lines
+        )
+
+    def _add_ensure_path_utility(self, lines: list[str]) -> int:
+        """Add the _ensure_path utility function and return adjustment count."""
+        insert_pos = self._find_utility_insert_position(lines)
+
+        utility_lines = [
+            "",
+            "def _ensure_path(path: str | Path) -> Path:",
+            '    """Convert string path to Path object if needed."""',
+            "    return Path(path) if isinstance(path, str) else path",
+            "",
+        ]
 
-        # Insert utility function
-        utility_lines = utility_function.strip().split("\n")
         for i, util_line in enumerate(utility_lines):
             lines.insert(insert_pos + i, util_line)
 
-        # Replace path conversion patterns
-        path_pattern = re.compile(
-            r"Path\([^)]+\)\s+if\s+isinstance\([^)]+,\s*str\)\s+else\s+([^)]+)",
-        )
+        return len(utility_lines)
 
+    def _apply_path_pattern_replacements(
+        self,
+        lines: list[str],
+        violation: dict[str, t.Any],
+        adjustment: int,
+        utility_function_added: bool,
+    ) -> bool:
+        """Replace path conversion patterns with utility function calls."""
+        path_pattern = SAFE_PATTERNS["fix_path_conversion_simple"]
+
+        modified = False
         for instance in violation["instances"]:
             line_number: int = int(instance["line_number"])
-            line_idx = line_number - 1 + len(utility_lines)
+            line_idx = line_number - 1 + (0 if utility_function_added else adjustment)
+
             if line_idx < len(lines):
                 original_line: str = lines[line_idx]
-                # Replace pattern with utility function call
-                new_line: str = path_pattern.sub(r"_ensure_path(\1)", original_line)
-                lines[line_idx] = new_line
+                new_line = path_pattern.apply(original_line)
 
-        return lines, True
+                if new_line != original_line:
+                    lines[line_idx] = new_line
+                    modified = True
+
+        return modified
 
 
 agent_registry.register(DRYAgent)

crackerjack/agents/formatting_agent.py

@@ -1,4 +1,3 @@
-import re
 from pathlib import Path
 
 from .base import (
@@ -14,11 +13,6 @@ from .base import (
 class FormattingAgent(SubAgent):
     def __init__(self, context: AgentContext) -> None:
         super().__init__(context)
-        self.supported_tools = [
-            "ruff",
-            "trailing-whitespace",
-            "end-of-file-fixer",
-        ]
 
     def get_supported_types(self) -> set[IssueType]:
         return {IssueType.FORMATTING, IssueType.IMPORT_ERROR}
@@ -213,7 +207,6 @@ class FormattingAgent(SubAgent):
         return fixes
 
     def _validate_and_get_file_content(self, path: Path) -> str | None:
-        """Validate file exists and retrieve its content."""
         if not path.exists() or not path.is_file():
             return None
 
@@ -221,22 +214,16 @@ class FormattingAgent(SubAgent):
         return content or None
 
     def _apply_content_formatting(self, content: str) -> str:
-        """Apply all formatting fixes to content."""
-        # Remove trailing whitespace
-        content = re.sub(r"[ \t]+$", "", content, flags=re.MULTILINE)
+        from crackerjack.services.regex_patterns import apply_formatting_fixes
+
+        content = apply_formatting_fixes(content)
 
-        # Ensure file ends with newline
         if content and not content.endswith("\n"):
             content += "\n"
 
-        # Normalize excessive blank lines
-        content = re.sub(r"\n{3,}", "\n\n", content)
-
-        # Convert tabs to spaces
         return self._convert_tabs_to_spaces(content)
 
     def _convert_tabs_to_spaces(self, content: str) -> str:
-        """Convert tab characters to 4 spaces."""
         lines = content.split("\n")
         fixed_lines = [line.expandtabs(4) for line in lines]
         return "\n".join(fixed_lines)