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

crackerjack/services/patterns/__init__.py

@@ -0,0 +1,142 @@
+"""Centralized pattern registry for safe regex operations.
+
+This module provides backward compatibility with the old regex_patterns.py
+by automatically loading all patterns from domain-specific modules.
+
+The patterns are organized by domain:
+- formatting: Text formatting and spacing patterns
+- versioning: Version number extraction and updates
+- validation: Input validation patterns
+- utilities: General utility extraction patterns
+- url_sanitization: URL sanitization for localhost addresses
+- agents: Agent count management patterns
+- templates: Template processing patterns
+- code: Code-related patterns (imports, paths, performance, detection, replacement)
+- documentation: Documentation patterns (docstrings, badges, comments)
+- tool_output: Linter/checker output parsing (ruff, pyright, bandit, mypy, vulture, complexipy)
+- testing: Test output and error patterns
+- security: Security patterns (credentials, path_traversal, unsafe_operations, code_injection)
+
+For backward compatibility, the main SAFE_PATTERNS dict contains all patterns.
+"""
+
+# Import standalone modules
+# Import subdirectories
+from . import (
+    agents,
+    code,
+    documentation,
+    formatting,
+    security,
+    templates,
+    testing,
+    tool_output,
+    url_sanitization,
+    utilities,
+    validation,
+    versioning,
+)
+from .core import (
+    MAX_INPUT_SIZE,
+    MAX_ITERATIONS,
+    PATTERN_CACHE_SIZE,
+    CompiledPatternCache,
+    ValidatedPattern,
+    validate_pattern_safety,
+)
+
+# Build the complete SAFE_PATTERNS registry for backward compatibility
+_merged_patterns = (
+    formatting.PATTERNS
+    | versioning.PATTERNS
+    | validation.PATTERNS
+    | utilities.PATTERNS
+    | url_sanitization.PATTERNS
+    | agents.PATTERNS
+    | templates.PATTERNS
+    | code.PATTERNS
+    | documentation.PATTERNS
+    | tool_output.PATTERNS
+    | testing.PATTERNS
+    | security.PATTERNS
+)
+SAFE_PATTERNS: dict[str, ValidatedPattern] = _merged_patterns  # type: ignore[assignment]
+
+# Import utility functions for backward compatibility
+from .operations import (
+    RegexPatternsService,
+    apply_formatting_fixes,
+    apply_pattern_iteratively,
+    apply_safe_replacement,
+    apply_security_fixes,
+    apply_test_fixes,
+    clear_all_caches,
+    detect_dangerous_directory_patterns,
+    detect_null_byte_patterns,
+    detect_path_traversal_patterns,
+    detect_suspicious_path_patterns,
+    find_pattern_for_text,
+    fix_multi_word_hyphenation,
+    get_all_pattern_stats,
+    get_cache_info,
+    get_pattern_description,
+    is_valid_job_id,
+    remove_coverage_fail_under,
+    sanitize_internal_urls,
+    update_coverage_requirement,
+    update_pyproject_version,
+    update_repo_revision,
+    validate_all_patterns,
+    validate_path_security,
+)
+
+# Export everything for convenience
+__all__ = [
+    # Core classes and utilities
+    "ValidatedPattern",
+    "CompiledPatternCache",
+    "validate_pattern_safety",
+    "MAX_INPUT_SIZE",
+    "MAX_ITERATIONS",
+    "PATTERN_CACHE_SIZE",
+    # Main registry (backward compatibility)
+    "SAFE_PATTERNS",
+    # Module namespaces for organized access
+    "formatting",
+    "versioning",
+    "validation",
+    "utilities",
+    "url_sanitization",
+    "agents",
+    "templates",
+    "code",
+    "documentation",
+    "tool_output",
+    "testing",
+    "security",
+    # Utility functions (backward compatibility)
+    "validate_all_patterns",
+    "find_pattern_for_text",
+    "apply_safe_replacement",
+    "get_pattern_description",
+    "fix_multi_word_hyphenation",
+    "update_pyproject_version",
+    "apply_formatting_fixes",
+    "apply_security_fixes",
+    "apply_test_fixes",
+    "is_valid_job_id",
+    "remove_coverage_fail_under",
+    "update_coverage_requirement",
+    "update_repo_revision",
+    "sanitize_internal_urls",
+    "apply_pattern_iteratively",
+    "get_all_pattern_stats",
+    "clear_all_caches",
+    "get_cache_info",
+    "detect_path_traversal_patterns",
+    "detect_null_byte_patterns",
+    "detect_dangerous_directory_patterns",
+    "detect_suspicious_path_patterns",
+    "validate_path_security",
+    "RegexPatternsService",
+]

crackerjack/services/patterns/agents.py

@@ -0,0 +1,107 @@
+"""Agent count and configuration patterns."""
+
+import re
+
+from .core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "agent_count_pattern": ValidatedPattern(
+        name="agent_count_pattern",
+        pattern=r"(\d+)\s+agents",
+        replacement=r"\1 agents",
+        test_cases=[
+            ("9 agents", "9 agents"),
+            ("12 agents", "12 agents"),
+            ("5 agents", "5 agents"),
+        ],
+        description="Match agent count patterns for documentation consistency",
+        flags=re.IGNORECASE,
+    ),
+    "specialized_agent_count_pattern": ValidatedPattern(
+        name="specialized_agent_count_pattern",
+        pattern=r"(\d+)\s+specialized\s+agents",
+        replacement=r"\1 specialized agents",
+        test_cases=[
+            ("9 specialized agents", "9 specialized agents"),
+            ("12 specialized agents", "12 specialized agents"),
+            ("5 specialized agents", "5 specialized agents"),
+        ],
+        description="Match specialized agent count patterns for documentation "
+        "consistency",
+        flags=re.IGNORECASE,
+    ),
+    "total_agents_config_pattern": ValidatedPattern(
+        name="total_agents_config_pattern",
+        pattern=r'total_agents["\'][\s]*: \s*(\d+)',
+        replacement=r'total_agents": \1',
+        test_cases=[
+            ('total_agents": 9', 'total_agents": 9'),
+            ("total_agents': 12", 'total_agents": 12'),
+            ('total_agents" : 5', 'total_agents": 5'),
+        ],
+        description="Match total agents configuration patterns",
+        flags=re.IGNORECASE,
+    ),
+    "sub_agent_count_pattern": ValidatedPattern(
+        name="sub_agent_count_pattern",
+        pattern=r"(\d+)\s+sub-agents",
+        replacement=r"\1 sub-agents",
+        test_cases=[
+            ("9 sub-agents", "9 sub-agents"),
+            ("12 sub-agents", "12 sub-agents"),
+            ("5 sub-agents", "5 sub-agents"),
+        ],
+        description="Match sub-agent count patterns for documentation consistency",
+        flags=re.IGNORECASE,
+    ),
+    "update_agent_count": ValidatedPattern(
+        name="update_agent_count",
+        pattern=r"\b(\d+)\s+agents\b",
+        replacement=r"NEW_COUNT agents",
+        test_cases=[
+            ("9 agents working", "NEW_COUNT agents working"),
+            ("We have 12 agents ready", "We have NEW_COUNT agents ready"),
+            ("All 5 agents are active", "All NEW_COUNT agents are active"),
+        ],
+        description="Update agent count references (NEW_COUNT replaced dynamically)",
+    ),
+    "update_specialized_agent_count": ValidatedPattern(
+        name="update_specialized_agent_count",
+        pattern=r"\b(\d+)\s+specialized\s+agents\b",
+        replacement=r"NEW_COUNT specialized agents",
+        test_cases=[
+            (
+                "9 specialized agents available",
+                "NEW_COUNT specialized agents available",
+            ),
+            ("We have 12 specialized agents", "We have NEW_COUNT specialized agents"),
+            ("All 5 specialized agents work", "All NEW_COUNT specialized agents work"),
+        ],
+        description="Update specialized agent count references (NEW_COUNT replaced"
+        " dynamically)",
+    ),
+    "update_total_agents_config": ValidatedPattern(
+        name="update_total_agents_config",
+        pattern=r'total_agents["\'][\s]*: \s*\d+',
+        replacement=r'total_agents": NEW_COUNT',
+        test_cases=[
+            ('total_agents": 9', 'total_agents": NEW_COUNT'),
+            ("total_agents': 12", 'total_agents": NEW_COUNT'),
+            ('total_agents" : 5', 'total_agents": NEW_COUNT'),
+        ],
+        description="Update total agents configuration (NEW_COUNT replaced"
+        " dynamically)",
+    ),
+    "update_sub_agent_count": ValidatedPattern(
+        name="update_sub_agent_count",
+        pattern=r"\b(\d+)\s+sub-agents\b",
+        replacement=r"NEW_COUNT sub-agents",
+        test_cases=[
+            ("9 sub-agents working", "NEW_COUNT sub-agents working"),
+            ("We have 12 sub-agents ready", "We have NEW_COUNT sub-agents ready"),
+            ("All 5 sub-agents are active", "All NEW_COUNT sub-agents are active"),
+        ],
+        description="Update sub-agent count references (NEW_COUNT replaced"
+        " dynamically)",
+    ),
+}

crackerjack/services/patterns/code/__init__.py

@@ -0,0 +1,15 @@
+"""Code-related patterns."""
+
+from .detection import PATTERNS as DETECTION_PATTERNS
+from .imports import PATTERNS as IMPORT_PATTERNS
+from .paths import PATTERNS as PATH_PATTERNS
+from .performance import PATTERNS as PERFORMANCE_PATTERNS
+from .replacement import PATTERNS as REPLACEMENT_PATTERNS
+
+PATTERNS: dict[str, object] = (
+    IMPORT_PATTERNS
+    | PATH_PATTERNS
+    | PERFORMANCE_PATTERNS
+    | DETECTION_PATTERNS
+    | REPLACEMENT_PATTERNS
+)

crackerjack/services/patterns/code/detection.py

@@ -0,0 +1,118 @@
+"""Code pattern descriptions."""
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "detect_tempfile_usage": ValidatedPattern(
+        name="detect_tempfile_usage",
+        pattern=r"tempfile\.(mkdtemp|NamedTemporaryFile|TemporaryDirectory)",
+        replacement="MATCH",
+        test_cases=[
+            ("tempfile.mkdtemp()", "MATCH()"),
+            ("tempfile.NamedTemporaryFile()", "MATCH()"),
+            ("tempfile.TemporaryDirectory()", "MATCH()"),
+            (
+                "not_tempfile.other()",
+                "not_tempfile.other()",
+            ),
+        ],
+        description="Detect tempfile module usage for resource management integration",
+    ),
+    "detect_asyncio_create_task": ValidatedPattern(
+        name="detect_asyncio_create_task",
+        pattern=r"asyncio\.create_task",
+        replacement="MATCH",
+        test_cases=[
+            ("asyncio.create_task(coro)", "MATCH(coro)"),
+            ("not_asyncio.other()", "not_asyncio.other()"),
+        ],
+        description="Detect asyncio.create_task usage for resource management"
+        " integration",
+    ),
+    "detect_file_open_operations": ValidatedPattern(
+        name="detect_file_open_operations",
+        pattern=r"(\.open\(|with open\()",
+        replacement=r"MATCH",
+        test_cases=[
+            ("file.open()", "fileMATCH)"),
+            ("with open('file.txt'): ", "MATCH'file.txt'): "),
+            ("other_method()", "other_method()"),
+        ],
+        description="Detect file open operations for resource management integration",
+    ),
+    "detect_exception_patterns": ValidatedPattern(
+        name="detect_exception_patterns",
+        pattern=r"except\s+\w*Exception\s+as\s+\w+: ",
+        replacement=r"MATCH",
+        description="Detect exception handling patterns for base Exception class in Python code for DRY violations",
+        test_cases=[
+            ("except Exception as e: ", "MATCH"),
+            ("except BaseException as error: ", "MATCH"),
+            (
+                "except ValueError as error: ",
+                "except ValueError as error: ",
+            ),
+            ("try: ", "try: "),
+        ],
+    ),
+    "match_async_function_definition": ValidatedPattern(
+        name="match_async_function_definition",
+        pattern=r"(async def \w+\([^)]*\)[^: ]*: )",
+        replacement=r"\1",
+        test_cases=[
+            ("async def foo(): ", "async def foo(): "),
+            ("async def bar(a, b) -> None: ", "async def bar(a, b) -> None: "),
+            ("def sync_func(): ", "def sync_func(): "),
+        ],
+        description="Match async function definitions for resource management"
+        " integration",
+    ),
+    "match_class_definition": ValidatedPattern(
+        name="match_class_definition",
+        pattern=r"class (\w+).*: ",
+        replacement=r"\1",
+        test_cases=[
+            ("class MyClass: ", "MyClass"),
+            ("class MyClass(BaseClass): ", "MyClass"),
+            ("class MyClass(Base, Mixin): ", "MyClass"),
+            ("def not_class(): ", "def not_class(): "),
+        ],
+        description="Match class definitions for resource management integration",
+    ),
+    "match_error_code_patterns": ValidatedPattern(
+        name="match_error_code_patterns",
+        pattern=r"F\d{3}|I\d{3}|E\d{3}|W\d{3}",
+        replacement=r"\g<0>",
+        description="Match standard error codes like F403, I001, etc.",
+        test_cases=[
+            ("F403", "F403"),
+            ("I001", "I001"),
+            ("E302", "E302"),
+            ("W291", "W291"),
+            ("ABC123", "ABC123"),
+        ],
+    ),
+    "match_validation_patterns": ValidatedPattern(
+        name="match_validation_patterns",
+        pattern=r"if\s+not\s+\w+\s*: |if\s+\w+\s+is\s+None\s*: |if\s+len\(\w+\)\s*[<>=]",
+        replacement=r"\g<0>",
+        description="Match common validation patterns for extraction",
+        test_cases=[
+            ("if not var: ", "if not var: "),
+            ("if item is None: ", "if item is None: "),
+            ("if len(items) >", "if len(items) >"),
+            ("other code", "other code"),
+        ],
+    ),
+    "match_loop_patterns": ValidatedPattern(
+        name="match_loop_patterns",
+        pattern=r"\s*for\s+.*: \s*$|\s*while\s+.*: \s*$",
+        replacement=r"\g<0>",
+        description="Match for/while loop patterns",
+        test_cases=[
+            (" for i in items: ", " for i in items: "),
+            (" while condition: ", " while condition: "),
+            ("regular line", "regular line"),
+        ],
+    ),
+}

crackerjack/services/patterns/code/imports.py

@@ -0,0 +1,107 @@
+"""Code pattern descriptions."""
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "match_star_import": ValidatedPattern(
+        name="match_star_import",
+        pattern=r"from\s+\w+\s+import\s+\*",
+        replacement=r"\g<0>",
+        description="Match star import statements",
+        test_cases=[
+            ("from module import *", "from module import *"),
+            ("from my_pkg import *", "from my_pkg import *"),
+            ("from module import specific", "from module import specific"),
+        ],
+    ),
+    "clean_unused_import": ValidatedPattern(
+        name="clean_unused_import",
+        pattern=r"^\s*import\s+unused_module\s*$",
+        replacement=r"",
+        description="Remove unused import statements (example with unused_module)",
+        test_cases=[
+            (" import unused_module", ""),
+            (
+                "import other_module",
+                "import other_module",
+            ),
+        ],
+    ),
+    "clean_unused_from_import": ValidatedPattern(
+        name="clean_unused_from_import",
+        pattern=r"^\s*from\s+\w+\s+import\s+.*\bunused_item\b",
+        replacement=r"\g<0>",
+        description="Match from import statements with unused items (example with "
+        "unused_item)",
+        test_cases=[
+            (
+                "from module import used, unused_item",
+                "from module import used, unused_item",
+            ),
+            ("from other import needed", "from other import needed"),
+        ],
+    ),
+    "clean_import_commas": ValidatedPattern(
+        name="clean_import_commas",
+        pattern=r", \s*, ",
+        replacement=r", ",
+        description="Clean double commas in import statements",
+        test_cases=[
+            ("from module import a, , b", "from module import a, b"),
+            ("items = [a, , b]", "items = [a, b]"),
+            ("normal, list[t.Any]", "normal, list[t.Any]"),
+        ],
+    ),
+    "clean_trailing_import_comma": ValidatedPattern(
+        name="clean_trailing_import_comma",
+        pattern=r", \s*$",
+        replacement=r"",
+        description="Remove trailing commas from lines",
+        test_cases=[
+            ("from module import a, b, ", "from module import a, b"),
+            ("import item, ", "import item"),
+            ("normal line", "normal line"),
+        ],
+    ),
+    "clean_import_prefix": ValidatedPattern(
+        name="clean_import_prefix",
+        pattern=r"import\s*, \s*",
+        replacement=r"import ",
+        description="Clean malformed import statements with leading comma",
+        test_cases=[
+            ("import , module", "import module"),
+            ("from pkg import , item", "from pkg import item"),
+            ("import normal", "import normal"),
+        ],
+    ),
+    "extract_unused_import_name": ValidatedPattern(
+        name="extract_unused_import_name",
+        pattern=r"unused import ['\"]([^'\"]+)['\"]",
+        replacement=r"\1",
+        description="Extract import name from vulture unused import messages",
+        test_cases=[
+            ("unused import 'module_name'", "module_name"),
+            ('unused import "other_module"', "other_module"),
+            ("some other text", "some other text"),
+        ],
+    ),
+    "detect_typing_usage": ValidatedPattern(
+        name="detect_typing_usage",
+        pattern=r"\bt\.[A-Z]",
+        replacement="",
+        description="Detect usage of typing module aliases like t.Any, t.Dict, etc.",
+        global_replace=True,
+        test_cases=[
+            (
+                "def func(x: t.Any) -> t.Dict:",
+                "def func(x: ny) -> ict:",
+            ),  # Removes t.A and t.D
+            (
+                "value: t.Optional[str] = None",
+                "value: ptional[str] = None",
+            ),  # Removes t.O
+            ("from typing import Dict", "from typing import Dict"),  # No match
+            ("data = dict()", "data = dict()"),  # No match
+        ],
+    ),
+}

crackerjack/services/patterns/code/paths.py

@@ -0,0 +1,159 @@
+"""Code pattern descriptions."""
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "detect_error_response_patterns": ValidatedPattern(
+        name="detect_error_response_patterns",
+        pattern=r'return\s+.*[\'\"]\{.*[\'\""]error[\'\""].*\}.*[\'\""]',
+        replacement=r"MATCH",
+        description="Detect error response patterns in Python code for DRY violations",
+        test_cases=[
+            ('return \'{"error": "msg"}\'', "MATCH"),
+            ('return f\'{"error": "msg"}\'', "MATCH"),
+            ('return {"success": True}', 'return {"success": True}'),
+            ('return \'{"error": "test message", "code": 500}\'', "MATCH"),
+        ],
+    ),
+    "detect_path_conversion_patterns": ValidatedPattern(
+        name="detect_path_conversion_patterns",
+        pattern=r"Path\([^)]+\)\s+if\s+isinstance\([^)]+, \s*str\)\s+else\s+[^)]+",
+        replacement=r"MATCH",
+        description="Detect path conversion patterns in Python code for DRY violations",
+        test_cases=[
+            ("Path(value) if isinstance(value, str) else value", "MATCH"),
+            ("Path(path) if isinstance(path, str) else path", "MATCH"),
+            ("Path('/tmp/file')", "Path('/tmp/file')"),
+            (
+                "Path(input_path) if isinstance(input_path, str) else input_path",
+                "MATCH",
+            ),
+        ],
+    ),
+    "detect_file_existence_patterns": ValidatedPattern(
+        name="detect_file_existence_patterns",
+        pattern=r"if\s+not\s+\w+\.exists\(\): ",
+        replacement=r"MATCH",
+        description="Detect file existence check patterns in Python code for DRY"
+        " violations",
+        test_cases=[
+            ("if not file.exists(): ", "MATCH"),
+            ("if not path.exists(): ", "MATCH"),
+            ("if not file_path.exists(): ", "MATCH"),
+            ("if file.exists(): ", "if file.exists(): "),
+        ],
+    ),
+    "fix_path_conversion_with_ensure_path": ValidatedPattern(
+        name="fix_path_conversion_with_ensure_path",
+        pattern=r"Path\([^)]+\)\s+if\s+isinstance\([^)]+, \s*str\)\s+else\s+([^)]+)",
+        replacement=r"_ensure_path(\1)",
+        description="Replace path conversion patterns with _ensure_path utility "
+        "function",
+        test_cases=[
+            ("Path(value) if isinstance(value, str) else value", "_ensure_path(value)"),
+            ("Path(path) if isinstance(path, str) else path", "_ensure_path(path)"),
+            (
+                "Path(input_path) if isinstance(input_path, str) else input_path",
+                "_ensure_path(input_path)",
+            ),
+        ],
+    ),
+    "fix_path_conversion_simple": ValidatedPattern(
+        name="fix_path_conversion_simple",
+        pattern=r"Path\(([^)]+)\)\s+if\s+isinstance\(\1, \s*str\)\s+else\s+\1",
+        replacement=r"_ensure_path(\1)",
+        description="Replace simple path conversion patterns with _ensure_path utility "
+        "function",
+        test_cases=[
+            ("Path(value) if isinstance(value, str) else value", "_ensure_path(value)"),
+            ("Path(path) if isinstance(path, str) else path", "_ensure_path(path)"),
+            (
+                "Path(file_path) if isinstance(file_path, str) else file_path",
+                "_ensure_path(file_path)",
+            ),
+        ],
+    ),
+    "detect_hardcoded_temp_paths_basic": ValidatedPattern(
+        name="detect_hardcoded_temp_paths_basic",
+        pattern=r"(?:/tmp/|/temp/|C:\\temp\\|C:\\tmp\\)",  # nosec B108
+        replacement="[TEMP_PATH]/",
+        description="Detect hardcoded temporary directory paths",
+        global_replace=True,
+        test_cases=[
+            ("/tmp/myfile.txt", "[TEMP_PATH]/myfile.txt"),  # nosec B108
+            (r"C:\tmp\data.log", "[TEMP_PATH]/data.log"),
+            ("/temp/cache", "[TEMP_PATH]/cache"),
+            (r"C:\temp\work", "[TEMP_PATH]/work"),
+            ("/regular/path", "/regular/path"),
+        ],
+    ),
+    "replace_hardcoded_temp_paths": ValidatedPattern(
+        name="replace_hardcoded_temp_paths",
+        pattern=r'Path\("/tmp/([^"]+)"\)',
+        replacement=r'Path(tempfile.gettempdir()) / "\1"',
+        description="Replace hardcoded /tmp paths with tempfile.gettempdir()",
+        global_replace=True,
+        test_cases=[
+            ('Path("/tmp/myfile.txt")', 'Path(tempfile.gettempdir()) / "myfile.txt"'),
+            ('Path("/tmp/data.log")', 'Path(tempfile.gettempdir()) / "data.log"'),
+            ('Path("/regular/path")', 'Path("/regular/path")'),
+        ],
+    ),
+    "replace_hardcoded_temp_strings": ValidatedPattern(
+        name="replace_hardcoded_temp_strings",
+        pattern=r'"/tmp/([^"]+)"',
+        replacement=r'str(Path(tempfile.gettempdir()) / "\1")',
+        description="Replace hardcoded /tmp string paths with tempfile equivalent",
+        global_replace=True,
+        test_cases=[
+            ('"/tmp/myfile.txt"', 'str(Path(tempfile.gettempdir()) / "myfile.txt")'),
+            ('"/tmp/data.log"', 'str(Path(tempfile.gettempdir()) / "data.log")'),
+            ('"/regular/path"', '"/regular/path"'),
+        ],
+    ),
+    "replace_hardcoded_temp_single_quotes": ValidatedPattern(
+        name="replace_hardcoded_temp_single_quotes",
+        pattern=r"'/tmp/([^']+)'",
+        replacement=r"str(Path(tempfile.gettempdir()) / '\1')",
+        description="Replace hardcoded /tmp paths (single quotes) with tempfile"
+        " equivalent",
+        global_replace=True,
+        test_cases=[
+            ("'/tmp/myfile.txt'", "str(Path(tempfile.gettempdir()) / 'myfile.txt')"),
+            ("'/tmp/data.log'", "str(Path(tempfile.gettempdir()) / 'data.log')"),
+            ("'/regular/path'", "'/regular/path'"),
+        ],
+    ),
+    "replace_test_path_patterns": ValidatedPattern(
+        name="replace_test_path_patterns",
+        pattern=r'Path\("/test/path"\)',
+        replacement=r"Path(tempfile.gettempdir()) / 'test-path'",
+        description="Replace hardcoded /test/path patterns with tempfile equivalent",
+        test_cases=[
+            ('Path("/test/path")', "Path(tempfile.gettempdir()) / 'test-path'"),
+            ('Path("/other/path")', 'Path("/other/path")'),
+        ],
+    ),
+    "replace_path_open_write": ValidatedPattern(
+        name="replace_path_open_write",
+        pattern=r'(\w+)\.open\(["\']wb?["\'][^)]*\)',
+        replacement=r"atomic_file_write(\1)",
+        test_cases=[
+            ("path.open('w')", "atomic_file_write(path)"),
+            ("file.open('wb')", "atomic_file_write(file)"),
+        ],
+        description="Replace file.open() with atomic_file_write",
+    ),
+    "replace_path_write_text": ValidatedPattern(
+        name="replace_path_write_text",
+        pattern=r"(\w+)\.write_text\(([^)]+)\)",
+        replacement=r"await SafeFileOperations.safe_write_text(\1, \2, atomic=True)",
+        test_cases=[
+            (
+                "path.write_text(content)",
+                "await SafeFileOperations.safe_write_text(path, content, atomic=True)",
+            ),
+        ],
+        description="Replace path.write_text with safe atomic write",
+    ),
+}