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

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",
+    ),
+}

crackerjack/services/patterns/code/performance.py

@@ -0,0 +1,119 @@
+"""Code pattern descriptions."""
+
+import re
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "list_append_inefficiency_pattern": ValidatedPattern(
+        name="list_append_inefficiency_pattern",
+        pattern=r"(\s*)(\w+)\s*\+=\s*\[([^]]+)\]",
+        replacement=r"\1\2.append(\3)",
+        test_cases=[
+            (" items += [new_item]", " items.append(new_item)"),
+            ("results += [result]", "results.append(result)"),
+            (" data += [value, other]", " data.append(value, other)"),
+        ],
+        description="Replace inefficient list[t.Any] concatenation with append for"
+        " performance",
+    ),
+    "string_concatenation_pattern": ValidatedPattern(
+        name="string_concatenation_pattern",
+        pattern=r"(\s*)(\w+)\s*\+=\s*(.+)",
+        replacement=r"\1\2_parts.append(\3)",
+        test_cases=[
+            (" text += new_text", " text_parts.append(new_text)"),
+            ("result += line", "result_parts.append(line)"),
+            (" output += data", " output_parts.append(data)"),
+        ],
+        description="Replace string concatenation with list[t.Any] append for performance "
+        "optimization",
+    ),
+    "nested_loop_detection_pattern": ValidatedPattern(
+        name="nested_loop_detection_pattern",
+        pattern=r"(\s*)(for\s+\w+\s+in\s+.*: )",
+        replacement=r"\1# Performance: Potential nested loop - check complexity\n\1\2",
+        test_cases=[
+            (
+                " for j in other: ",
+                " # Performance: Potential nested loop - check complexity\n "
+                "for j in other: ",
+            ),
+            (
+                "for i in items: ",
+                "# Performance: Potential nested loop - check complexity\nfor i"
+                " in items: ",
+            ),
+        ],
+        description="Detect loop patterns that might be nested creating O(n²)"
+        " complexity",
+        flags=re.MULTILINE,
+    ),
+    "list_extend_optimization_pattern": ValidatedPattern(
+        name="list_extend_optimization_pattern",
+        pattern=r"(\s*)(\w+)\s*\+=\s*\[([^]]+(?: , \s*[^]]+)*)\]",
+        replacement=r"\1\2.extend([\3])",
+        test_cases=[
+            (" items += [a, b, c]", " items.extend([a, b, c])"),
+            ("results += [x, y]", "results.extend([x, y])"),
+            (" data += [single_item]", " data.extend([single_item])"),
+        ],
+        description="Replace list[t.Any] concatenation with extend for better performance with multiple items",
+    ),
+    "inefficient_string_join_pattern": ValidatedPattern(
+        name="inefficient_string_join_pattern",
+        pattern=r"(\s*)(\w+)\s*=\s*([\"'])([\"'])\s*\.\s*join\(\s*\[\s*\]\s*\)",
+        replacement=r"\1\2 = \3\4 # Performance: Use empty string directly instead"
+        r" of join",
+        test_cases=[
+            (
+                ' text = "".join([])',
+                ' text = "" # Performance: Use empty string directly instead of join',
+            ),
+            (
+                "result = ''.join([])",
+                "result = '' # Performance: Use empty string directly instead of join",
+            ),
+        ],
+        description="Replace inefficient empty list[t.Any] join with direct empty string"
+        " assignment",
+    ),
+    "repeated_len_in_loop_pattern": ValidatedPattern(
+        name="repeated_len_in_loop_pattern",
+        pattern=r"(\s*)(len\(\s*(\w+)\s*\))",
+        replacement=r"\1# Performance: Consider caching len(\3) if used "
+        r"repeatedly\n\1\2",
+        test_cases=[
+            (
+                " len(items)",
+                " # Performance: Consider caching len(items) if used repeatedly\n"
+                " len(items)",
+            ),
+            (
+                "len(data)",
+                "# Performance: Consider caching len(data) if used "
+                "repeatedly\nlen(data)",
+            ),
+        ],
+        description="Suggest caching len() calls that might be repeated",
+    ),
+    "list_comprehension_optimization_pattern": ValidatedPattern(
+        name="list_comprehension_optimization_pattern",
+        pattern=r"(\s*)(\w+)\.append\(([^)]+)\)",
+        replacement=r"\1# Performance: Consider list[t.Any] comprehension if this is in a "
+        r"simple loop\n\1\2.append(\3)",
+        test_cases=[
+            (
+                " results.append(item * 2)",
+                " # Performance: Consider list[t.Any] comprehension if this is in a "
+                "simple loop\n results.append(item * 2)",
+            ),
+            (
+                "data.append(value)",
+                "# Performance: Consider list[t.Any] comprehension if this is in a simple"
+                " loop\ndata.append(value)",
+            ),
+        ],
+        description="Suggest list[t.Any] comprehensions for simple append patterns",
+    ),
+}

crackerjack/services/patterns/code/replacement.py

@@ -0,0 +1,36 @@
+"""Code pattern descriptions."""
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "replace_subprocess_popen_basic": ValidatedPattern(
+        name="replace_subprocess_popen_basic",
+        pattern=r"subprocess\.Popen\(",
+        replacement="managed_proc = resource_ctx.managed_process(subprocess.Popen(",
+        test_cases=[
+            (
+                "subprocess.Popen(cmd)",
+                "managed_proc = resource_ctx.managed_process(subprocess.Popen(cmd)",
+            ),
+            (
+                "result = subprocess.Popen(['ls'])",
+                "result = managed_proc = resource_ctx.managed_process("
+                "subprocess.Popen(['ls'])",
+            ),
+        ],
+        description="Replace subprocess.Popen with managed version",
+    ),
+    "replace_subprocess_popen_assignment": ValidatedPattern(
+        name="replace_subprocess_popen_assignment",
+        pattern=r"(\w+)\s*=\s*subprocess\.Popen\(",
+        replacement=r"process = subprocess.Popen(",
+        test_cases=[
+            ("proc = subprocess.Popen(cmd)", "process = subprocess.Popen(cmd)"),
+            (
+                "my_process = subprocess.Popen(['ls'])",
+                "process = subprocess.Popen(['ls'])",
+            ),
+        ],
+        description="Replace subprocess.Popen assignment with standard variable name",
+    ),
+}