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

crackerjack/services/regex_patterns.py

@@ -1,16 +1,3 @@
-"""
-Centralized regex patterns with validation to prevent bad regex issues.
-
-CRITICAL: All regex patterns in this codebase MUST be defined here with comprehensive
-testing to prevent spacing and replacement syntax errors.
-
-Optimized for performance, safety, and maintainability with:
-- Thread-safe compiled pattern caching
-- Iterative application for complex multi-word cases
-- Safety limits to prevent catastrophic backtracking
-- Performance monitoring capabilities
-"""
-
 import re
 import threading
 import time
@@ -18,43 +5,34 @@ import typing as t
 from dataclasses import dataclass, field
 from re import Pattern
 
-# Safety constants
-MAX_INPUT_SIZE = 10 * 1024 * 1024  # 10MB max input size
-MAX_ITERATIONS = 10  # Max iterations for iterative application
-PATTERN_CACHE_SIZE = 100  # Max cached compiled patterns
+MAX_INPUT_SIZE = 10 * 1024 * 1024
+MAX_ITERATIONS = 10
+PATTERN_CACHE_SIZE = 100
 
 
 class CompiledPatternCache:
-    """Thread-safe cache for compiled regex patterns."""
-
     _lock = threading.RLock()
     _cache: dict[str, Pattern[str]] = {}
     _max_size = PATTERN_CACHE_SIZE
 
     @classmethod
     def get_compiled_pattern(cls, pattern: str) -> Pattern[str]:
-        """Get compiled pattern from cache, compiling if necessary."""
         return cls.get_compiled_pattern_with_flags(pattern, pattern, 0)
 
     @classmethod
     def get_compiled_pattern_with_flags(
         cls, cache_key: str, pattern: str, flags: int
     ) -> Pattern[str]:
-        """Get compiled pattern with flags from cache, compiling if necessary."""
         with cls._lock:
             if cache_key in cls._cache:
                 return cls._cache[cache_key]
 
-            # Compile new pattern
             try:
                 compiled = re.compile(pattern, flags)
             except re.error as e:
-                # Maintain backward compatibility with existing error message format
                 raise ValueError(f"Invalid regex pattern '{pattern}': {e}")
 
-            # Add to cache with size limit
             if len(cls._cache) >= cls._max_size:
-                # Remove oldest entry (simple FIFO eviction)
                 oldest_key = next(iter(cls._cache))
                 del cls._cache[oldest_key]
 
@@ -63,38 +41,32 @@ class CompiledPatternCache:
 
     @classmethod
     def clear_cache(cls) -> None:
-        """Clear the pattern cache (useful for testing)."""
         with cls._lock:
             cls._cache.clear()
 
     @classmethod
     def get_cache_stats(cls) -> dict[str, int | list[str]]:
-        """Get cache statistics for monitoring."""
         with cls._lock:
             return {
                 "size": len(cls._cache),
                 "max_size": cls._max_size,
-                "patterns": list(cls._cache.keys()),
+                "patterns": list[t.Any](cls._cache.keys()),
             }
 
 
 def validate_pattern_safety(pattern: str) -> list[str]:
-    """Validate pattern for potential safety issues."""
     warnings = []
 
-    # Check for potentially problematic constructs
     if ".*.*" in pattern:
         warnings.append("Multiple .* constructs may cause performance issues")
 
     if ".+.+" in pattern:
         warnings.append("Multiple .+ constructs may cause performance issues")
 
-    # Check for nested quantifiers
     nested_quantifiers = re.findall(r"[+*?]\??[+*?]", pattern)
     if nested_quantifiers:
         warnings.append(f"Nested quantifiers detected: {nested_quantifiers}")
 
-    # Check for alternation with overlapping cases
     if "|" in pattern and pattern.count("|") > 10:
         warnings.append("Many alternations may cause performance issues")
 
@@ -103,48 +75,37 @@ def validate_pattern_safety(pattern: str) -> list[str]:
 
 @dataclass
 class ValidatedPattern:
-    """A regex pattern that has been tested and validated."""
-
     name: str
     pattern: str
     replacement: str
-    test_cases: list[tuple[str, str]]  # (input, expected_output)
+    test_cases: list[tuple[str, str]]
     description: str = ""
-    global_replace: bool = False  # If True, replace all matches
-    flags: int = 0  # Regex flags (re.IGNORECASE, re.MULTILINE, etc.)
+    global_replace: bool = False
+    flags: int = 0
     _compiled_pattern: Pattern[str] | None = field(default=None, init=False)
 
-    def __post_init__(self):
-        """Validate pattern on creation."""
+    def __post_init__(self) -> None:
         self._validate()
 
     def _validate(self) -> None:
-        """Ensure pattern works with all test cases."""
         try:
-            # Use cached compilation for validation
             self._get_compiled_pattern()
         except ValueError as e:
-            # Maintain backward compatibility with error message format
             if "Invalid regex pattern" in str(e):
-                # Replace the pattern string with the name in the error message
                 error_msg = str(e).replace(f"'{self.pattern}'", f"'{self.name}'")
                 raise ValueError(error_msg) from e
-            raise  # Re-raise other errors
+            raise
 
-        # Check for forbidden replacement syntax
         if r"\g < " in self.replacement or r" >" in self.replacement:
             raise ValueError(
                 f"Bad replacement syntax in '{self.name}': {self.replacement}. "
-                "Use \\g<1> not \\g < 1 >"
+                "Use \\g<1> not \\g<1>"  # REGEX OK: educational example
             )
 
-        # Check for safety warnings
         warnings = validate_pattern_safety(self.pattern)
         if warnings:
-            # For now, just store warnings - could log them in the future
             pass
 
-        # Validate all test cases
         for input_text, expected in self.test_cases:
             try:
                 count = 0 if self.global_replace else 1
@@ -158,15 +119,12 @@ class ValidatedPattern:
                 raise ValueError(f"Pattern '{self.name}' failed on '{input_text}': {e}")
 
     def _get_compiled_pattern(self) -> Pattern[str]:
-        """Get cached compiled pattern with flags."""
-        # Create cache key that includes flags
-        cache_key = f"{self.pattern}|flags:{self.flags}"
+        cache_key = f"{self.pattern}|flags: {self.flags}"
         return CompiledPatternCache.get_compiled_pattern_with_flags(
             cache_key, self.pattern, self.flags
         )
 
     def _apply_internal(self, text: str, count: int = 1) -> str:
-        """Internal method for applying pattern with compiled regex."""
         if len(text) > MAX_INPUT_SIZE:
             raise ValueError(
                 f"Input text too large: {len(text)} bytes > {MAX_INPUT_SIZE}"
@@ -175,17 +133,10 @@ class ValidatedPattern:
         return self._get_compiled_pattern().sub(self.replacement, text, count=count)
 
     def apply(self, text: str) -> str:
-        """Apply the validated pattern safely."""
         count = 0 if self.global_replace else 1
         return self._apply_internal(text, count)
 
     def apply_iteratively(self, text: str, max_iterations: int = MAX_ITERATIONS) -> str:
-        """
-        Apply pattern repeatedly until no more changes occur.
-
-        Useful for cases like 'pytest - hypothesis - specialist' -> 'pytest-hypothesis-specialist'
-        where multiple passes are needed.
-        """
         if max_iterations <= 0:
             raise ValueError("max_iterations must be positive")
 
@@ -193,18 +144,14 @@ class ValidatedPattern:
         for _ in range(max_iterations):
             new_result = self.apply(result)
             if new_result == result:
-                # No more changes, done
                 break
             result = new_result
         else:
-            # Reached max iterations without convergence
-            # This might indicate a problematic pattern, but we return the current result
             pass
 
         return result
 
     def apply_with_timeout(self, text: str, timeout_seconds: float = 1.0) -> str:
-        """Apply pattern with timeout protection."""
         import signal
 
         def timeout_handler(signum: int, frame: t.Any) -> None:
@@ -212,8 +159,6 @@ class ValidatedPattern:
                 f"Pattern '{self.name}' timed out after {timeout_seconds}s"
             )
 
-        # Note: signal-based timeout only works on Unix and in main thread
-        # For broader compatibility, we could use threading.Timer instead
         old_handler = signal.signal(signal.SIGALRM, timeout_handler)
         signal.alarm(int(timeout_seconds))
 
@@ -226,12 +171,10 @@ class ValidatedPattern:
         return result
 
     def test(self, text: str) -> bool:
-        """Test if pattern matches text without applying replacement."""
         compiled = self._get_compiled_pattern()
         return bool(compiled.search(text))
 
     def search(self, text: str) -> re.Match[str] | None:
-        """Search for the first match and return a Match object or None."""
         if len(text) > MAX_INPUT_SIZE:
             raise ValueError(
                 f"Input text too large: {len(text)} bytes > {MAX_INPUT_SIZE}"
@@ -239,7 +182,6 @@ class ValidatedPattern:
         return self._get_compiled_pattern().search(text)
 
     def findall(self, text: str) -> list[str]:
-        """Find all matches of the pattern in text safely."""
         if len(text) > MAX_INPUT_SIZE:
             raise ValueError(
                 f"Input text too large: {len(text)} bytes > {MAX_INPUT_SIZE}"
@@ -249,7 +191,6 @@ class ValidatedPattern:
     def get_performance_stats(
         self, text: str, iterations: int = 100
     ) -> dict[str, float]:
-        """Get performance statistics for this pattern on given text."""
         times = []
 
         for _ in range(iterations):
@@ -266,7 +207,6 @@ class ValidatedPattern:
         }
 
 
-# All validated patterns - ADD NEW PATTERNS HERE WITH TESTS
 SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "fix_command_spacing": ValidatedPattern(
         name="fix_command_spacing",
@@ -275,20 +215,20 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Fix spacing in 'python -m command' patterns",
         test_cases=[
             ("python - m crackerjack", "python -m crackerjack"),
-            ("python -m crackerjack", "python -m crackerjack"),  # No change
-            ("python  -  m  pytest", "python -m pytest"),
+            ("python -m crackerjack", "python -m crackerjack"),
+            ("python - m pytest", "python -m pytest"),
             ("other python - m stuff", "other python -m stuff"),
         ],
     ),
     "fix_long_flag_spacing": ValidatedPattern(
         name="fix_long_flag_spacing",
-        pattern=r"-\s*-\s*(\w+(?:-\w+)*)",
+        pattern=r"-\s*-\s*(\w+(?: -\w+)*)",
         replacement=r"--\1",
         description="Fix spacing in long flags like '--help'",
         test_cases=[
             ("- - help", "--help"),
-            ("- - ai-agent", "--ai-agent"),
-            ("--help", "--help"),  # No change
+            ("- - ai-fix", "--ai-fix"),
+            ("--help", "--help"),
             ("- - start-websocket-server", "--start-websocket-server"),
         ],
     ),
@@ -300,7 +240,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("python -m crackerjack - t", "python -m crackerjack -t"),
             ("- q", "-q"),
-            ("-t", "-t"),  # No change
+            ("-t", "-t"),
             ("some - x flag", "some -x flag"),
         ],
     ),
@@ -314,10 +254,10 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "pytest - hypothesis - specialist",
                 "pytest-hypothesis - specialist",
-            ),  # Only fixes first
+            ),
             ("backend - architect", "backend-architect"),
-            ("python-pro", "python-pro"),  # No change
-            ("end - of - file-fixer", "end-of - file-fixer"),  # Only fixes first
+            ("python-pro", "python-pro"),
+            ("end - of - file-fixer", "end-of - file-fixer"),
         ],
     ),
     "fix_hyphenated_names_global": ValidatedPattern(
@@ -328,9 +268,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("python - pro", "python-pro"),
-            ("end - of - file", "end-of - file"),  # Single pass: only first match
-            ("already-hyphenated", "already-hyphenated"),  # No change
-            ("start - middle - end", "start-middle - end"),  # Single pass
+            ("end - of - file", "end-of - file"),
+            ("already-hyphenated", "already-hyphenated"),
+            ("start - middle - end", "start-middle - end"),
         ],
     ),
     "fix_spaced_hyphens": ValidatedPattern(
@@ -338,19 +278,19 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         pattern=r"(\w+)\s+-\s+(\w+)",
         replacement=r"\1-\2",
         description="Fix spaced hyphens with spaces around dashes (use apply_iteratively for multi-word)",
-        global_replace=True,  # Apply to all matches in one pass
+        global_replace=True,
         test_cases=[
             ("python - pro", "python-pro"),
             (
                 "pytest - hypothesis - specialist",
                 "pytest-hypothesis - specialist",
-            ),  # Single pass: only first match
+            ),
             (
                 "end - of - file - fixer",
                 "end-of - file-fixer",
-            ),  # Global finds: "end-of" and "file-fixer"
-            ("already-hyphenated", "already-hyphenated"),  # No change
-            ("mixed-case with - spaces", "mixed-case with-spaces"),  # Partial fix
+            ),
+            ("already-hyphenated", "already-hyphenated"),
+            ("mixed-case with - spaces", "mixed-case with-spaces"),
         ],
     ),
     "fix_debug_log_pattern": ValidatedPattern(
@@ -360,7 +300,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Fix spacing in debug log patterns",
         test_cases=[
             ("crackerjack - debug-12345.log", "crackerjack-debug-12345.log"),
-            ("crackerjack-debug.log", "crackerjack-debug.log"),  # No change
+            ("crackerjack-debug.log", "crackerjack-debug.log"),
             ("old crackerjack - debug files", "old crackerjack-debug files"),
         ],
     ),
@@ -372,7 +312,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("job - {self.web_job_id}.json", "job-{self.web_job_id}.json"),
             ("job - abc123.json", "job-abc123.json"),
-            ("job-existing.json", "job-existing.json"),  # No change
+            ("job-existing.json", "job-existing.json"),
         ],
     ),
     "fix_markdown_bold": ValidatedPattern(
@@ -383,10 +323,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("* *Bold Text * *", "**Bold Text**"),
             ("* *🧪 pytest-specialist * *", "**🧪 pytest-specialist**"),
-            ("**Already Bold**", "**Already Bold**"),  # No change
+            ("**Already Bold**", "**Already Bold**"),
         ],
     ),
-    # Security token masking patterns
     "mask_pypi_token": ValidatedPattern(
         name="mask_pypi_token",
         pattern=r"\bpypi-[a-zA-Z0-9_-]{12,}\b",
@@ -400,11 +339,11 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
                 "Using token: pypi-AgEIcHlwaS5vcmcCJGE4M2Y3ZjI for upload",
                 "Using token: pypi-**** for upload",
             ),
-            ("pypi-short", "pypi-short"),  # Too short, no change
+            ("pypi-short", "pypi-short"),
             (
                 "not pypi-AgEIcHlwaS5vcmcCJGE4M2Y3ZjI",
                 "not pypi-****",
-            ),  # Space-separated, should match pypi token
+            ),
             (
                 "Multiple pypi-token1234567890 and pypi-anothertokenhere",
                 "Multiple pypi-**** and pypi-****",
@@ -424,11 +363,11 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
                 "GITHUB_TOKEN=ghp_1234567890abcdef1234567890abcdef1234",
                 "GITHUB_TOKEN=ghp_****",
             ),
-            ("ghp_short", "ghp_short"),  # Too short, no change
+            ("ghp_short", "ghp_short"),
             (
                 "ghp_1234567890abcdef1234567890abcdef12345",
                 "ghp_1234567890abcdef1234567890abcdef12345",
-            ),  # Too long, no match due to word boundary
+            ),
             (
                 "Multiple ghp_1234567890abcdef1234567890abcdef1234 and"
                 " ghp_abcdef1234567890abcdef12345678901234",
@@ -448,23 +387,23 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "Short token abc123def456",
                 "Short token abc123def456",
-            ),  # Too short, no change
+            ),
             (
                 "File path "
                 "/very/long/path/that/should/not/be/masked/even/though/its/long",
                 "File path "
                 "/very/long/path/that/should/not/be/masked/even/though/its/long",
-            ),  # Contains slashes
+            ),
             ("API_KEY=verylongapikeyhere1234567890123456", "API_KEY=****"),
             (
                 "Long-token_with-underscores_123456789012345678",
                 "****",
-            ),  # Entire string matches as one long token
+            ),
         ],
     ),
     "mask_token_assignment": ValidatedPattern(
         name="mask_token_assignment",
-        pattern=r"(?i)\b(token\s*[=:]\s*)['\"]([^'\"]{8,})['\"]",
+        pattern=r"(?i)\b(token\s*[=: ]\s*)['\"]([^'\"]{8,})['\"]",
         replacement=r"\1'****'",
         description="Mask token assignments in various formats (case insensitive)",
         global_replace=True,
@@ -473,17 +412,17 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("token='long_secret_token_here'", "token='****'"),
             ('token: "another_secret_token"', "token: '****'"),
             ("token = 'spaced_assignment_token'", "token = '****'"),
-            ('token="short"', 'token="short"'),  # Too short, no change
+            ('token="short"', 'token="short"'),
             (
                 "not_token='should_not_be_masked'",
                 "not_token='should_not_be_masked'",
-            ),  # Wrong key
-            ('TOKEN="UPPERCASE_TOKEN_HERE"', "TOKEN='****'"),  # Case insensitive
+            ),
+            ('TOKEN="UPPERCASE_TOKEN_HERE"', "TOKEN='****'"),
         ],
     ),
     "mask_password_assignment": ValidatedPattern(
         name="mask_password_assignment",
-        pattern=r"(?i)\b(password\s*[=:]\s*)['\"]([^'\"]{8,})['\"]",
+        pattern=r"(?i)\b(password\s*[=: ]\s*)['\"]([^'\"]{8,})['\"]",
         replacement=r"\1'****'",
         description="Mask password assignments in various formats (case insensitive)",
         global_replace=True,
@@ -492,15 +431,14 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("password='my_long_password'", "password='****'"),
             ('password: "another_secret_password"', "password: '****'"),
             ("password = 'spaced_password_assignment'", "password = '****'"),
-            ('password="short"', 'password="short"'),  # Too short, no change
+            ('password="short"', 'password="short"'),
             (
                 "not_password='should_not_be_masked'",
                 "not_password='should_not_be_masked'",
-            ),  # Wrong key
-            ('PASSWORD="UPPERCASE_PASSWORD"', "PASSWORD='****'"),  # Case insensitive
+            ),
+            ('PASSWORD="UPPERCASE_PASSWORD"', "PASSWORD='****'"),
         ],
     ),
-    # Version management patterns
     "update_pyproject_version": ValidatedPattern(
         name="update_pyproject_version",
         pattern=r'^(version\s*=\s*["\'])([^"\']+)(["\'])$',
@@ -513,11 +451,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ('version="1.0.0-beta"', 'version="NEW_VERSION"'),
             ("version = '2.1.0'", "version = 'NEW_VERSION'"),
             ("version='10.20.30'", "version='NEW_VERSION'"),
-            # Should not match non-version lines
-            ('name = "my-package"', 'name = "my-package"'),  # No change
+            ('name = "my-package"', 'name = "my-package"'),
         ],
     ),
-    # Formatting agent patterns
     "remove_trailing_whitespace": ValidatedPattern(
         name="remove_trailing_whitespace",
         pattern=r"[ \t]+$",
@@ -525,11 +461,11 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Remove trailing whitespace from lines",
         global_replace=True,
         test_cases=[
-            ("line with spaces   ", "line with spaces"),
+            ("line with spaces ", "line with spaces"),
             ("line with tabs\t\t", "line with tabs"),
-            ("normal line", "normal line"),  # No change
-            ("mixed   \t  ", "mixed"),
-            ("", ""),  # Empty lines
+            ("normal line", "normal line"),
+            ("mixed \t ", "mixed"),
+            ("", ""),
         ],
     ),
     "normalize_multiple_newlines": ValidatedPattern(
@@ -541,11 +477,10 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("line1\n\n\nline2", "line1\n\nline2"),
             ("line1\n\n\n\n\nline2", "line1\n\nline2"),
-            ("line1\n\nline2", "line1\n\nline2"),  # No change
-            ("line1\nline2", "line1\nline2"),  # No change
+            ("line1\n\nline2", "line1\n\nline2"),
+            ("line1\nline2", "line1\nline2"),
         ],
     ),
-    # Security agent patterns - subprocess fixes
     "fix_subprocess_run_shell": ValidatedPattern(
         name="fix_subprocess_run_shell",
         pattern=r"subprocess\.run\(([^,]+),\s*shell=True\)",
@@ -561,7 +496,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "subprocess.run(command, shell=False)",
                 "subprocess.run(command, shell=False)",
-            ),  # No change
+            ),
         ],
     ),
     "fix_subprocess_call_shell": ValidatedPattern(
@@ -579,12 +514,12 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "subprocess.call(command, shell=False)",
                 "subprocess.call(command, shell=False)",
-            ),  # No change
+            ),
         ],
     ),
     "fix_subprocess_popen_shell": ValidatedPattern(
         name="fix_subprocess_popen_shell",
-        pattern=r"subprocess\.Popen\(([^,]+),\s*shell=True\)",
+        pattern=r"subprocess\.Popen\(([^,]+), \s*shell=True\)",
         replacement=r"subprocess.Popen(\1.split())",
         description="Remove shell=True from subprocess.Popen calls",
         global_replace=True,
@@ -597,10 +532,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "subprocess.Popen(command, shell=False)",
                 "subprocess.Popen(command, shell=False)",
-            ),  # No change
+            ),
         ],
     ),
-    # Security agent patterns - unsafe library usage
     "fix_unsafe_yaml_load": ValidatedPattern(
         name="fix_unsafe_yaml_load",
         pattern=r"\byaml\.load\(",
@@ -610,11 +544,11 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("yaml.load(file)", "yaml.safe_load(file)"),
             ("data = yaml.load(content)", "data = yaml.safe_load(content)"),
-            ("yaml.safe_load(content)", "yaml.safe_load(content)"),  # No change
+            ("yaml.safe_load(content)", "yaml.safe_load(content)"),
             (
                 "my_yaml.load(content)",
                 "my_yaml.load(content)",
-            ),  # No change (not yaml module)
+            ),
         ],
     ),
     "fix_weak_md5_hash": ValidatedPattern(
@@ -626,7 +560,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("hashlib.md5(data)", "hashlib.sha256(data)"),
             ("hash = hashlib.md5(content)", "hash = hashlib.sha256(content)"),
-            ("hashlib.sha256(data)", "hashlib.sha256(data)"),  # No change
+            ("hashlib.sha256(data)", "hashlib.sha256(data)"),
         ],
     ),
     "fix_weak_sha1_hash": ValidatedPattern(
@@ -638,7 +572,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("hashlib.sha1(data)", "hashlib.sha256(data)"),
             ("hash = hashlib.sha1(content)", "hash = hashlib.sha256(content)"),
-            ("hashlib.sha256(data)", "hashlib.sha256(data)"),  # No change
+            ("hashlib.sha256(data)", "hashlib.sha256(data)"),
         ],
     ),
     "fix_insecure_random_choice": ValidatedPattern(
@@ -650,27 +584,26 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("random.choice(options)", "secrets.choice(options)"),
             ("item = random.choice(items)", "item = secrets.choice(items)"),
-            ("secrets.choice(options)", "secrets.choice(options)"),  # No change
+            ("secrets.choice(options)", "secrets.choice(options)"),
         ],
     ),
     "remove_debug_prints_with_secrets": ValidatedPattern(
         name="remove_debug_prints_with_secrets",
-        pattern=r"print\s*\([^)]*(?:password|secret|key|token)[^)]*\)",
+        pattern=r"print\s*\([^)]*(?: password|secret|key|token)[^)]*\)",
         replacement="",
         description="Remove debug print statements that contain sensitive information",
         global_replace=True,
         test_cases=[
-            ('print("password:", password)', ""),
+            ('print("password: ", password)', ""),
             ("print(f'Token: {token}')", ""),
             ("print('Debug secret value')", ""),
             (
                 "print('Normal debug message')",
                 "print('Normal debug message')",
-            ),  # No change
+            ),
             ('print("API key is", key)', ""),
         ],
     ),
-    # Test specialist agent patterns
     "normalize_assert_statements": ValidatedPattern(
         name="normalize_assert_statements",
         pattern=r"assert (.+?)\s*==\s*(.+)",
@@ -679,30 +612,27 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("assert result==expected", "assert result == expected"),
-            ("assert value  ==  other", "assert value == other"),
+            ("assert value == other", "assert value == other"),
             ("assert result== expected", "assert result == expected"),
             ("assert result ==expected", "assert result == expected"),
             (
                 "assert result == expected",
                 "assert result == expected",
-            ),  # No change (already spaced)
+            ),
         ],
     ),
-    # Job ID validation patterns
     "validate_job_id_alphanumeric": ValidatedPattern(
         name="validate_job_id_alphanumeric",
         pattern=r"^[a-zA-Z0-9_-]+$",
-        replacement="VALID",  # Dummy replacement for validation patterns
+        replacement="VALID",
         description="Validate job ID contains only alphanumeric characters, "
         "underscores, and hyphens",
         test_cases=[
-            # For validation patterns, we test against strings that SHOULD match
-            ("valid_job-123", "VALID"),  # Valid ID
-            ("another_valid-job_456", "VALID"),  # Valid ID
-            ("job_123", "VALID"),  # Valid ID
+            ("valid_job-123", "VALID"),
+            ("another_valid-job_456", "VALID"),
+            ("job_123", "VALID"),
         ],
     ),
-    # Service configuration patterns
     "remove_coverage_fail_under": ValidatedPattern(
         name="remove_coverage_fail_under",
         pattern=r"--cov-fail-under=\d+\.?\d*\s*",
@@ -713,7 +643,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("--cov-fail-under=85 --verbose", "--verbose"),
             ("--cov-fail-under=90.5 -x", "-x"),
             ("--verbose --cov-fail-under=80 ", "--verbose "),
-            ("--no-cov", "--no-cov"),  # No change
+            ("--no-cov", "--no-cov"),
         ],
     ),
     "update_coverage_requirement": ValidatedPattern(
@@ -725,11 +655,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("--cov-fail-under=85", "--cov-fail-under=NEW_COVERAGE"),
             ("--cov-fail-under=90.5", "--cov-fail-under=NEW_COVERAGE"),
-            ("--verbose", "--verbose"),  # No change
+            ("--verbose", "--verbose"),
         ],
     ),
-    # Path security validation patterns - designed for testing existence, not
-    # replacement
     "detect_directory_traversal_basic": ValidatedPattern(
         name="detect_directory_traversal_basic",
         pattern=r"\.\./",
@@ -738,7 +666,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("../config.txt", "[TRAVERSAL]config.txt"),
-            ("normal/path", "normal/path"),  # No change
+            ("normal/path", "normal/path"),
             ("../../etc/passwd", "[TRAVERSAL][TRAVERSAL]etc/passwd"),
         ],
     ),
@@ -751,7 +679,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("..\\config.txt", "[TRAVERSAL]config.txt"),
             ("../config.txt", "[TRAVERSAL]config.txt"),
-            ("normal/path", "normal/path"),  # No change
+            ("normal/path", "normal/path"),
         ],
     ),
     "detect_url_encoded_traversal": ValidatedPattern(
@@ -762,7 +690,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("path/%2e%2e%2f/config", "path/[TRAVERSAL]/config"),
-            ("normal/path", "normal/path"),  # No change
+            ("normal/path", "normal/path"),
             ("%2e%2e%2fpasswd", "[TRAVERSAL]passwd"),
         ],
     ),
@@ -774,7 +702,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("path/%252e%252e%252f/config", "path/[TRAVERSAL]/config"),
-            ("normal/path", "normal/path"),  # No change
+            ("normal/path", "normal/path"),
         ],
     ),
     "detect_null_bytes_url": ValidatedPattern(
@@ -785,7 +713,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("file.txt%00.jpg", "file.txt[NULL].jpg"),
-            ("normal.txt", "normal.txt"),  # No change
+            ("normal.txt", "normal.txt"),
         ],
     ),
     "detect_null_bytes_literal": ValidatedPattern(
@@ -796,7 +724,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("file.txt\\x00", "file.txt[NULL]"),
-            ("normal.txt", "normal.txt"),  # No change
+            ("normal.txt", "normal.txt"),
         ],
     ),
     "detect_utf8_overlong_null": ValidatedPattern(
@@ -807,7 +735,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("file.txt%c0%80", "file.txt[NULL]"),
-            ("normal.txt", "normal.txt"),  # No change
+            ("normal.txt", "normal.txt"),
         ],
     ),
     "detect_sys_directory_pattern": ValidatedPattern(
@@ -818,7 +746,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/sys/", "[DANGER]"),
             ("/sys/devices", "[DANGER]"),
-            ("/usr/sys", "/usr/sys"),  # No change
+            ("/usr/sys", "/usr/sys"),
         ],
     ),
     "detect_proc_directory_pattern": ValidatedPattern(
@@ -829,7 +757,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/proc/", "[DANGER]"),
             ("/proc/self", "[DANGER]"),
-            ("/usr/proc", "/usr/proc"),  # No change
+            ("/usr/proc", "/usr/proc"),
         ],
     ),
     "detect_etc_directory_pattern": ValidatedPattern(
@@ -840,7 +768,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/etc/", "[DANGER]"),
             ("/etc/passwd", "[DANGER]"),
-            ("/usr/etc", "/usr/etc"),  # No change
+            ("/usr/etc", "/usr/etc"),
         ],
     ),
     "detect_boot_directory_pattern": ValidatedPattern(
@@ -851,7 +779,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/boot/", "[DANGER]"),
             ("/boot/grub", "[DANGER]"),
-            ("/usr/boot", "/usr/boot"),  # No change
+            ("/usr/boot", "/usr/boot"),
         ],
     ),
     "detect_dev_directory_pattern": ValidatedPattern(
@@ -862,7 +790,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/dev/", "[DANGER]"),
             ("/dev/null", "[DANGER]"),
-            ("/usr/dev", "/usr/dev"),  # No change
+            ("/usr/dev", "/usr/dev"),
         ],
     ),
     "detect_root_directory_pattern": ValidatedPattern(
@@ -873,7 +801,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/root/", "[DANGER]"),
             ("/root/.ssh", "[DANGER]"),
-            ("/usr/root", "/usr/root"),  # No change
+            ("/usr/root", "/usr/root"),
         ],
     ),
     "detect_var_log_directory_pattern": ValidatedPattern(
@@ -884,7 +812,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/var/log/", "[DANGER]"),
             ("/var/log/messages", "[DANGER]"),
-            ("/usr/var/log", "/usr/var/log"),  # No change
+            ("/usr/var/log", "/usr/var/log"),
         ],
     ),
     "detect_bin_directory_pattern": ValidatedPattern(
@@ -895,7 +823,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/bin/", "[DANGER]"),
             ("/usr/bin/", "[DANGER]"),
-            ("/usr/local/bin", "/usr/local/bin"),  # No change
+            ("/usr/local/bin", "/usr/local/bin"),
         ],
     ),
     "detect_sbin_directory_pattern": ValidatedPattern(
@@ -906,7 +834,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("/sbin/", "[DANGER]"),
             ("/usr/sbin/", "[DANGER]"),
-            ("/usr/local/sbin", "/usr/local/sbin"),  # No change
+            ("/usr/local/sbin", "/usr/local/sbin"),
         ],
     ),
     "detect_parent_directory_in_path": ValidatedPattern(
@@ -917,7 +845,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         global_replace=True,
         test_cases=[
             ("../config", "[PARENT]/config"),
-            ("safe/path", "safe/path"),  # No change
+            ("safe/path", "safe/path"),
             ("path/../other", "path/[PARENT]/other"),
         ],
     ),
@@ -928,7 +856,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Detect traversal attempts in temp directories",
         test_cases=[
             ("/tmp/safe/../etc/passwd", "[SUSPICIOUS]etc/passwd"),  # nosec B108
-            ("/tmp/normal/file.txt", "/tmp/normal/file.txt"),  # No change  # nosec B108
+            ("/tmp/normal/file.txt", "/tmp/normal/file.txt"),  # nosec B108
         ],
     ),
     "detect_suspicious_var_traversal": ValidatedPattern(
@@ -938,15 +866,14 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Detect traversal attempts in var directories",
         test_cases=[
             ("/var/lib/../etc/passwd", "[SUSPICIOUS]etc/passwd"),
-            ("/var/lib/normal.txt", "/var/lib/normal.txt"),  # No change
+            ("/var/lib/normal.txt", "/var/lib/normal.txt"),
         ],
     ),
-    # Tool output parsing patterns - for development tool output processing
     "ruff_check_error": ValidatedPattern(
         name="ruff_check_error",
         pattern=r"^(.+?): (\d+): (\d+): ([A-Z]\d+) (.+)$",
         replacement=r"File: \1, Line: \2, Col: \3, Code: \4, Message: \5",
-        description="Parse ruff-check error output: file:line:col:code message",
+        description="Parse ruff-check error output: file: line: col: code message",
         test_cases=[
             (
                 "crackerjack/core.py: 123: 45: E501 line too long",
@@ -979,7 +906,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="pyright_error",
         pattern=r"^(.+?): (\d+): (\d+) - error: (.+)$",
         replacement=r"File: \1, Line: \2, Col: \3, Error: \4",
-        description="Parse pyright error output: file:line:col - error: message",
+        description="Parse pyright error output: file: line: col - error: message",
         test_cases=[
             (
                 "src/app.py: 45: 12 - error: Undefined variable",
@@ -999,7 +926,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="pyright_warning",
         pattern=r"^(.+?): (\d+): (\d+) - warning: (.+)$",
         replacement=r"File: \1, Line: \2, Col: \3, Warning: \4",
-        description="Parse pyright warning output: file:line:col - warning: message",
+        description="Parse pyright warning output: file: line: col - warning: message",
         test_cases=[
             (
                 "src/app.py: 45: 12 - warning: Unused variable",
@@ -1091,7 +1018,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="mypy_error",
         pattern=r"^(.+?): (\d+): error: (.+)$",
         replacement=r"File: \1, Line: \2, Error: \3",
-        description="Parse mypy error output: file:line: error: message",
+        description="Parse mypy error output: file: line: error: message",
         test_cases=[
             (
                 "src/app.py: 45: error: Name 'undefined_var' is not defined",
@@ -1112,15 +1039,15 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="mypy_note",
         pattern=r"^(.+?): (\d+): note: (.+)$",
         replacement=r"File: \1, Line: \2, Note: \3",
-        description="Parse mypy note output: file:line: note: message",
+        description="Parse mypy note output: file: line: note: message",
         test_cases=[
             (
                 "src/app.py: 45: note: Expected type Union[int, str]",
                 "File: src/app.py, Line: 45, Note: Expected type Union[int, str]",
             ),
             (
-                "test.py: 1: note: See https://mypy.readthedocs.io/",
-                "File: test.py, Line: 1, Note: See https://mypy.readthedocs.io/",
+                "test.py: 1: note: See https: //mypy.readthedocs.io/",
+                "File: test.py, Line: 1, Note: See https: //mypy.readthedocs.io/",
             ),
             (
                 "./main.py: 999: note: Consider using Optional[...]",
@@ -1132,7 +1059,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="vulture_unused",
         pattern=r"^(.+?): (\d+): unused (.+) '(.+)'",
         replacement=r"File: \1, Line: \2, Unused \3: '\4'",
-        description="Parse vulture unused code detection: file:line: unused type"
+        description="Parse vulture unused code detection: file: line: unused type"
         " 'name'",
         test_cases=[
             (
@@ -1153,13 +1080,13 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="complexipy_complex",
         pattern=r"^(.+?): (\d+): (\d+) - (.+) is too complex \((\d+)\)",
         replacement=r"File: \1, Line: \2, Col: \3, Function: \4, Complexity: \5",
-        description="Parse complexipy complexity detection: file:line:col - function "
+        description="Parse complexipy complexity detection: file: line: col - function "
         "is too complex (score)",
         test_cases=[
             (
                 "src/app.py: 45: 1 - complex_function is too complex (15)",
-                "File: src/app.py, Line: 45, Col: 1, Function: complex_function,"
-                " Complexity: 15",
+                "File: src/app.py, Line: 45, Col: 1, Function: complex_function, "
+                "Complexity: 15",
             ),
             (
                 "test.py: 1: 1 - nested_loops is too complex (20)",
@@ -1173,12 +1100,10 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ),
         ],
     ),
-    # Test output parsing patterns for test_progress_streamer.py
-    # These patterns are used for matching/extraction, not replacement
     "pytest_test_start": ValidatedPattern(
         name="pytest_test_start",
         pattern=r"^(.+?):: ?(.+?):: ?(.+?) (PASSED|FAILED|SKIPPED|ERROR)$",
-        replacement=r"\1::\2::\3",  # Extract file::class::method
+        replacement=r"\1::\2::\3",
         description="Parse pytest test start line with file, class, and method "
         "(3-part format)",
         test_cases=[
@@ -1199,7 +1124,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "pytest_test_result": ValidatedPattern(
         name="pytest_test_result",
         pattern=r"^(.+?) (PASSED|FAILED|SKIPPED|ERROR)(?: \[.*?\])?\s*$",
-        replacement=r"\1",  # Extract just the test identifier
+        replacement=r"\1",
         description="Parse pytest test result line with test identifier",
         test_cases=[
             ("test_file.py::test_method PASSED", "test_file.py::test_method"),
@@ -1213,7 +1138,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "pytest_collection_count": ValidatedPattern(
         name="pytest_collection_count",
         pattern=r"collected (\d+) items?",
-        replacement=r"\1",  # Extract just the count
+        replacement=r"\1",
         description="Parse pytest test collection count",
         test_cases=[
             ("collected 5 items", "5"),
@@ -1221,13 +1146,13 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "collected 42 items for execution",
                 "42 for execution",
-            ),  # Only the match is replaced
+            ),
         ],
     ),
     "pytest_session_start": ValidatedPattern(
         name="pytest_session_start",
         pattern=r"test session starts",
-        replacement=r"test session starts",  # Identity replacement
+        replacement=r"test session starts",
         description="Match pytest session start indicator",
         test_cases=[
             ("test session starts", "test session starts"),
@@ -1237,24 +1162,24 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "pytest_coverage_total": ValidatedPattern(
         name="pytest_coverage_total",
         pattern=r"TOTAL\s+\d+\s+\d+\s+(\d+)%",
-        replacement=r"\1",  # Extract just the percentage
+        replacement=r"\1",
         description="Parse pytest coverage total percentage",
         test_cases=[
-            ("TOTAL      123    45    85%", "85"),
-            ("TOTAL  1000  250  75%", "75"),
-            ("TOTAL      50     0   100%", "100"),
+            ("TOTAL 123 45 85%", "85"),
+            ("TOTAL 1000 250 75%", "75"),
+            ("TOTAL 50 0 100%", "100"),
         ],
     ),
     "pytest_detailed_test": ValidatedPattern(
         name="pytest_detailed_test",
         pattern=r"^(.+\.py)::(.+) (PASSED|FAILED|SKIPPED|ERROR)",
-        replacement=r"\1::\2",  # Extract file and test name
+        replacement=r"\1::\2",
         description="Parse detailed pytest test output with file, test name, and "
         "status",
         test_cases=[
             (
                 "test_file.py::test_method PASSED [50%]",
-                "test_file.py::test_method [50%]",  # Only the matched part is replaced
+                "test_file.py::test_method [50%]",
             ),
             (
                 "tests/core.py::TestClass::test_func FAILED [75%] [0.1s]",
@@ -1266,7 +1191,6 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ),
         ],
     ),
-    # Code cleaning patterns (from code_cleaner.py)
     "docstring_triple_double": ValidatedPattern(
         name="docstring_triple_double",
         pattern=r'^\s*""".*?"""\s*$',
@@ -1274,13 +1198,13 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         flags=re.MULTILINE | re.DOTALL,
         description="Remove triple-quoted docstrings with double quotes",
         test_cases=[
-            ('    """This is a docstring"""    ', ""),
+            (' """This is a docstring""" ', ""),
             ('"""Module docstring"""', ""),
-            ('    """\n    Multi-line\n    docstring\n    """', ""),
+            (' """\n Multi-line\n docstring\n """', ""),
             (
                 'regular_code = "not a docstring"',
                 'regular_code = "not a docstring"',
-            ),  # No change
+            ),
         ],
     ),
     "docstring_triple_single": ValidatedPattern(
@@ -1290,39 +1214,43 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         flags=re.MULTILINE | re.DOTALL,
         description="Remove triple-quoted docstrings with single quotes",
         test_cases=[
-            ("    '''This is a docstring'''    ", ""),
+            (" '''This is a docstring''' ", ""),
             ("'''Module docstring'''", ""),
-            ("    '''\n    Multi-line\n    docstring\n    '''", ""),
+            (" '''\n Multi-line\n docstring\n '''", ""),
             (
                 "regular_code = 'not a docstring'",
                 "regular_code = 'not a docstring'",
-            ),  # No change
+            ),
         ],
     ),
     "spacing_after_comma": ValidatedPattern(
         name="spacing_after_comma",
-        pattern=r",([^ \n])",
+        pattern=r", ([^ \n])",
         replacement=r", \1",
         global_replace=True,
         description="Add space after comma if missing",
         test_cases=[
-            ("def func(a,b,c):", "def func(a, b, c):"),
-            ("items = [1,2,3,4]", "items = [1, 2, 3, 4]"),
-            ("already, spaced, properly", "already, spaced, properly"),  # No change
-            ("mixed,spacing, here", "mixed, spacing, here"),
+            ("def func(a, b, c): ", "def func(a, b, c): "),
+            ("items = [1, 2, 3, 4]", "items = [1, 2, 3, 4]"),
+            ("already, spaced, properly", "already, spaced, properly"),
+            ("mixed, spacing, here", "mixed, spacing, here"),
         ],
     ),
     "spacing_after_colon": ValidatedPattern(
         name="spacing_after_colon",
-        pattern=r"(?<!:):([^ \n:])",
-        replacement=r": \1",
+        pattern=r"(?<!https)(?<!http)(?<!ftp)(?<!file)(?<!: )(\b[a-zA-Z_][a-zA-Z0-9_]*):([a-zA-Z0-9_][^ \n:]*)",
+        replacement=r"\1: \2",
         global_replace=True,
-        description="Add space after colon if missing (avoid double colons)",
+        description="Add space after colon if missing (avoid double colons, URLs, and protocols)",
         test_cases=[
-            ("def func(x:int, y:str):", "def func(x: int, y: str):"),
-            ("dict_item = {'key':'value'}", "dict_item = {'key': 'value'}"),
-            ("already: spaced: properly", "already: spaced: properly"),  # No change
-            ("class::method", "class::method"),  # No change (double colon)
+            ("def func(x: int, y: str): ", "def func(x: int, y: str): "),
+            ("dict_item = {'key': 'value'}", "dict_item = {'key': 'value'}"),
+            ("already: spaced: properly", "already: spaced: properly"),
+            ("class::method", "class::method"),
+            ("https://github.com", "https://github.com"),
+            ("http://example.com", "http://example.com"),
+            ("ftp://server.com", "ftp://server.com"),
+            ("repo:local", "repo: local"),
         ],
     ),
     "multiple_spaces": ValidatedPattern(
@@ -1332,80 +1260,79 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Replace multiple spaces with single space",
         global_replace=True,
         test_cases=[
-            ("def   func(  x,   y ):", "def func( x, y ):"),
-            ("single space only", "single space only"),  # No change
-            ("lots    of     spaces", "lots of spaces"),
-            ("\tkeep\ttabs\tbut   fix   spaces", "\tkeep\ttabs\tbut fix spaces"),
+            ("def func( x, y ): ", "def func( x, y ): "),
+            ("single space only", "single space only"),
+            ("lots of spaces", "lots of spaces"),
+            ("\tkeep\ttabs\tbut fix spaces", "\tkeep\ttabs\tbut fix spaces"),
         ],
     ),
     "preserved_comments": ValidatedPattern(
         name="preserved_comments",
         pattern=r"(#.*?(?: coding: | encoding: | type: | noqa | pragma).*)",
-        replacement=r"\1",  # Identity replacement - used for matching only
+        replacement=r"\1",
         description="Match preserved code comments (encoding, type hints, etc.)",
         test_cases=[
-            ("# coding: utf-8", "# coding: utf-8"),  # No change - identity replacement
+            ("# coding: utf-8", "# coding: utf-8"),
             (
                 "# encoding: latin-1",
                 "# encoding: latin-1",
-            ),  # No change - identity replacement
-            ("# type: ignore", "# type: ignore"),  # No change - identity replacement
-            ("# noqa: E501", "# noqa: E501"),  # No change - identity replacement
+            ),
+            ("# type: ignore", "# type: ignore"),
+            ("# noqa: E501", "# noqa: E501"),
             (
                 "# pragma: no cover",
                 "# pragma: no cover",
-            ),  # No change - identity replacement
-            ("# regular comment", "# regular comment"),  # No change - no match
+            ),
+            ("# regular comment", "# regular comment"),
         ],
     ),
     "todo_pattern": ValidatedPattern(
         name="todo_pattern",
         pattern=r"(#.*?TODO.*)",
-        replacement=r"\1",  # Identity replacement - used for matching only
+        replacement=r"\1",
         flags=re.IGNORECASE,
         description="Match TODO comments for validation",
         test_cases=[
             (
                 "# TODO: Fix this bug",
                 "# TODO: Fix this bug",
-            ),  # No change - identity replacement
+            ),
             (
                 "# todo: implement later",
                 "# todo: implement later",
-            ),  # No change - identity replacement
+            ),
             (
                 "# TODO refactor this method",
                 "# TODO refactor this method",
-            ),  # No change - identity replacement
+            ),
             (
                 "# FIXME: another issue",
                 "# FIXME: another issue",
-            ),  # No change - no match
-            ("# regular comment", "# regular comment"),  # No change - no match
+            ),
+            ("# regular comment", "# regular comment"),
         ],
     ),
-    # DRY agent patterns - for code duplication detection
     "detect_error_response_patterns": ValidatedPattern(
         name="detect_error_response_patterns",
         pattern=r'return\s+.*[\'\"]\{.*[\'\""]error[\'\""].*\}.*[\'\""]',
-        replacement=r"MATCH",  # Dummy replacement for detection patterns
+        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}'),  # No 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",  # Dummy replacement for detection 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')"),  # No match
+            ("Path('/tmp/file')", "Path('/tmp/file')"),
             (
                 "Path(input_path) if isinstance(input_path, str) else input_path",
                 "MATCH",
@@ -1414,35 +1341,35 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     ),
     "detect_file_existence_patterns": ValidatedPattern(
         name="detect_file_existence_patterns",
-        pattern=r"if\s+not\s+\w+\.exists\(\):",
-        replacement=r"MATCH",  # Dummy replacement for detection 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():"),  # No match
+            ("if not file.exists(): ", "MATCH"),
+            ("if not path.exists(): ", "MATCH"),
+            ("if not file_path.exists(): ", "MATCH"),
+            ("if file.exists(): ", "if file.exists(): "),
         ],
     ),
     "detect_exception_patterns": ValidatedPattern(
         name="detect_exception_patterns",
-        pattern=r"except\s+\w*Exception\s+as\s+\w+:",
-        replacement=r"MATCH",  # Dummy replacement for detection 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 Exception as e: ", "MATCH"),
+            ("except BaseException as error: ", "MATCH"),
             (
-                "except ValueError as error:",
-                "except ValueError as error:",
-            ),  # No match - doesn't match pattern
-            ("try:", "try:"),  # No match
+                "except ValueError as error: ",
+                "except ValueError as error: ",
+            ),
+            ("try: ", "try: "),
         ],
     ),
     "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+([^)]+)",
+        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",
@@ -1457,7 +1384,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     ),
     "fix_path_conversion_simple": ValidatedPattern(
         name="fix_path_conversion_simple",
-        pattern=r"Path\(([^)]+)\)\s+if\s+isinstance\(\1,\s*str\)\s+else\s+\1",
+        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",
@@ -1470,12 +1397,11 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ),
         ],
     ),
-    # Security agent patterns - NEW PATTERNS FOR SECURITY_AGENT.PY
     "detect_security_keywords": ValidatedPattern(
         name="detect_security_keywords",
         pattern=r"(?i)(bandit|security|vulnerability|hardcoded|"
         r"shell=true|b108|b602|b301|b506|unsafe|injection)",
-        replacement=r"MATCH",  # Dummy replacement for detection patterns
+        replacement=r"MATCH",
         description="Detect security-related keywords in issue messages "
         "(case insensitive)",
         flags=re.IGNORECASE,
@@ -1485,7 +1411,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("hardcoded path found", "MATCH path found"),
             ("shell=True usage", "MATCH usage"),
             ("B108 violation", "MATCH violation"),
-            ("normal message", "normal message"),  # No match
+            ("normal message", "normal message"),
         ],
     ),
     "detect_hardcoded_temp_paths_basic": ValidatedPattern(
@@ -1499,7 +1425,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (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"),  # No change
+            ("/regular/path", "/regular/path"),
         ],
     ),
     "replace_hardcoded_temp_paths": ValidatedPattern(
@@ -1511,7 +1437,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         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")'),  # No change
+            ('Path("/regular/path")', 'Path("/regular/path")'),
         ],
     ),
     "replace_hardcoded_temp_strings": ValidatedPattern(
@@ -1523,7 +1449,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ('"/tmp/myfile.txt"', 'str(Path(tempfile.gettempdir()) / "myfile.txt")'),
             ('"/tmp/data.log"', 'str(Path(tempfile.gettempdir()) / "data.log")'),
-            ('"/regular/path"', '"/regular/path"'),  # No change
+            ('"/regular/path"', '"/regular/path"'),
         ],
     ),
     "replace_hardcoded_temp_single_quotes": ValidatedPattern(
@@ -1536,7 +1462,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("'/tmp/myfile.txt'", "str(Path(tempfile.gettempdir()) / 'myfile.txt')"),
             ("'/tmp/data.log'", "str(Path(tempfile.gettempdir()) / 'data.log')"),
-            ("'/regular/path'", "'/regular/path'"),  # No change
+            ("'/regular/path'", "'/regular/path'"),
         ],
     ),
     "replace_test_path_patterns": ValidatedPattern(
@@ -1546,7 +1472,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         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")'),  # No change
+            ('Path("/other/path")', 'Path("/other/path")'),
         ],
     ),
     "detect_hardcoded_secrets": ValidatedPattern(
@@ -1560,7 +1486,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ('password = "secret123"', "[SECRET_DETECTED]"),
             ("api_key = 'abc123def'", "[SECRET_DETECTED]"),
             ('TOKEN = "my-token-here"', "[SECRET_DETECTED]"),
-            ("username = 'user123'", "username = 'user123'"),  # No match
+            ("username = 'user123'", "username = 'user123'"),
         ],
     ),
     "extract_variable_name_from_assignment": ValidatedPattern(
@@ -1571,7 +1497,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("password = 'secret'", "password"),
             ("api_key = 'value'", "api_key"),
-            ("   token   =", "token"),  # Matches just the word part
+            (" token =", "token"),
             ("complex_variable_name = value", "complex_variable_name"),
         ],
     ),
@@ -1584,11 +1510,10 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("random.random()", "[INSECURE_RANDOM]()"),
             ("random.choice(options)", "[INSECURE_RANDOM]()"),
-            ("secrets.choice(options)", "secrets.choice(options)"),  # No change
-            ("my_random.choice()", "my_random.choice()"),  # No change
+            ("secrets.choice(options)", "secrets.choice(options)"),
+            ("my_random.choice()", "my_random.choice()"),
         ],
     ),
-    # Input validation patterns for security-critical validation
     "validate_sql_injection_patterns": ValidatedPattern(
         name="validate_sql_injection_patterns",
         pattern=r"\b(union|select|insert|update|delete|drop|create|alter|"
@@ -1601,7 +1526,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("UNION SELECT", "[SQL_INJECTION] [SQL_INJECTION]"),
             ("drop table", "[SQL_INJECTION] table"),
-            ("normal text", "normal text"),  # No change
+            ("normal text", "normal text"),
             ("exec command", "[SQL_INJECTION] command"),
             ("execute procedure", "[SQL_INJECTION] procedure"),
         ],
@@ -1615,7 +1540,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("--comment", "[SQL_COMMENT]comment"),
             ("/* comment */", "[SQL_COMMENT] comment [SQL_COMMENT]"),
-            ("normal-text", "normal-text"),  # No change (single hyphen)
+            ("normal-text", "normal-text"),
             ("---triple", "[SQL_COMMENT]triple"),
         ],
     ),
@@ -1629,8 +1554,8 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("or 1=1", "[BOOLEAN_INJECTION]1"),
             ("AND password=", "[BOOLEAN_INJECTION]"),
-            ("normal or text", "normal or text"),  # No change (no equals)
-            ("value=test", "value=test"),  # No change (no boolean operator)
+            ("normal or text", "normal or text"),
+            ("value=test", "value=test"),
         ],
     ),
     "validate_sql_server_specific": ValidatedPattern(
@@ -1643,7 +1568,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("xp_cmdshell", "[SQLSERVER_EXPLOIT]"),
             ("SP_EXECUTESQL", "[SQLSERVER_EXPLOIT]"),
-            ("normal text", "normal text"),  # No change
+            ("normal text", "normal text"),
         ],
     ),
     "validate_code_eval_injection": ValidatedPattern(
@@ -1656,7 +1581,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("eval(code)", "[CODE_EVAL](code)"),
             ("exec(command)", "[CODE_EVAL](command)"),
             ("execfile(script)", "[CODE_EVAL](script)"),
-            ("evaluate()", "evaluate()"),  # No change (not exact match)
+            ("evaluate()", "evaluate()"),
         ],
     ),
     "validate_code_dynamic_access": ValidatedPattern(
@@ -1670,7 +1595,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("getattr(obj, name)", "[DYNAMIC_ACCESS](obj, name)"),
             ("setattr(obj, name)", "[DYNAMIC_ACCESS](obj, name)"),
             ("delattr(obj, name)", "[DYNAMIC_ACCESS](obj, name)"),
-            ("mygetattr", "mygetattr"),  # No change (not exact match)
+            ("mygetattr", "mygetattr"),
         ],
     ),
     "validate_code_system_commands": ValidatedPattern(
@@ -1684,7 +1609,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("os.system(cmd)", "[SYSTEM_COMMAND](cmd)"),
             ("os.popen(cmd)", "[SYSTEM_COMMAND](cmd)"),
             ("commands.getoutput", "[SYSTEM_COMMAND]getoutput"),
-            ("mysubprocess", "mysubprocess"),  # No change (not exact match)
+            ("mysubprocess", "mysubprocess"),
         ],
     ),
     "validate_code_compilation": ValidatedPattern(
@@ -1696,7 +1621,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("compile(source)", "[CODE_COMPILE]source)"),
             ("code.compile(source)", "[CODE_COMPILE](source)"),
-            ("compiled", "compiled"),  # No change (not exact match)
+            ("compiled", "compiled"),
         ],
     ),
     "validate_job_id_format": ValidatedPattern(
@@ -1717,7 +1642,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         name="validate_env_var_name_format",
         pattern=r"^[A-Z_][A-Z0-9_]*$",
         replacement="VALID_ENV_VAR_NAME",
-        description="Validate environment variable name format - uppercase letters,"
+        description="Validate environment variable name format - uppercase letters, "
         " numbers, underscores only, must start with letter or underscore",
         test_cases=[
             ("VALID_VAR", "VALID_ENV_VAR_NAME"),
@@ -1727,7 +1652,6 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("_PRIVATE_VAR", "VALID_ENV_VAR_NAME"),
         ],
     ),
-    # Config file update patterns
     "update_repo_revision": ValidatedPattern(
         name="update_repo_revision",
         pattern=r'("repo": "[^"]+?".*?"rev": )"([^"]+)"',
@@ -1737,137 +1661,135 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         flags=re.DOTALL,
         test_cases=[
             (
-                '"repo": "https://github.com/user/repo".*"rev": "old_rev"',
-                '"repo": "https://github.com/user/repo".*"rev": "NEW_REVISION"',
+                '"repo": "https: //github.com/user/repo".*"rev": "old_rev"',
+                '"repo": "https: //github.com/user/repo".*"rev": "NEW_REVISION"',
             ),
             (
-                '"repo": "git@github.com:user/repo.git", "branch": "main", "rev": '
+                '"repo": "git@github.com: user/repo.git", "branch": "main", "rev": '
                 '"abc123"',
-                '"repo": "git@github.com:user/repo.git", "branch": "main", "rev":'
-                ' "NEW_REVISION"',
+                '"repo": "git@github.com: user/repo.git", "branch": "main", "rev": '
+                '"NEW_REVISION"',
             ),
             (
-                '{"repo": "https://example.com/repo", "description": "test", "rev": '
+                '{"repo": "https: //example.com/repo", "description": "test", "rev": '
                 '"456def"}',
-                '{"repo": "https://example.com/repo", "description": "test", "rev":'
-                ' "NEW_REVISION"}',
+                '{"repo": "https: //example.com/repo", "description": "test", "rev": '
+                '"NEW_REVISION"}',
             ),
         ],
     ),
-    # URL sanitization patterns for security
     "sanitize_localhost_urls": ValidatedPattern(
         name="sanitize_localhost_urls",
-        pattern=r"https?://localhost:\d+[^\s]*",
+        pattern=r"https?: //localhost: \d+[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize localhost URLs with ports for security",
         global_replace=True,
         test_cases=[
-            ("http://localhost:8000/api/test", "[INTERNAL_URL]"),
-            ("https://localhost:3000/dashboard", "[INTERNAL_URL]"),
+            ("http: //localhost: 8000/api/test", "[INTERNAL_URL]"),
+            ("https: //localhost: 3000/dashboard", "[INTERNAL_URL]"),
             (
-                "Visit http://localhost:8080/admin for details",
+                "Visit http: //localhost: 8080/admin for details",
                 "Visit [INTERNAL_URL] for details",
             ),
-            ("https://example.com/test", "https://example.com/test"),  # No change
+            ("https: //example.com/test", "https: //example.com/test"),
         ],
     ),
     "sanitize_127_urls": ValidatedPattern(
         name="sanitize_127_urls",
-        pattern=r"https?://127\.0\.0\.1:\d+[^\s]*",
+        pattern=r"https?: //127\.0\.0\.1: \d+[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize 127.0.0.1 URLs with ports for security",
         global_replace=True,
         test_cases=[
-            ("http://127.0.0.1:8000/api", "[INTERNAL_URL]"),
-            ("https://127.0.0.1:3000/test", "[INTERNAL_URL]"),
-            ("Connect to http://127.0.0.1:5000/status", "Connect to [INTERNAL_URL]"),
+            ("http: //127.0.0.1: 8000/api", "[INTERNAL_URL]"),
+            ("https: //127.0.0.1: 3000/test", "[INTERNAL_URL]"),
+            ("Connect to http: //127.0.0.1: 5000/status", "Connect to [INTERNAL_URL]"),
             (
-                "https://192.168.1.1:8080/test",
-                "https://192.168.1.1:8080/test",
-            ),  # No change
+                "https: //192.168.1.1: 8080/test",
+                "https: //192.168.1.1: 8080/test",
+            ),
         ],
     ),
     "sanitize_any_localhost_urls": ValidatedPattern(
         name="sanitize_any_localhost_urls",
-        pattern=r"https?://0\.0\.0\.0:\d+[^\s]*",
+        pattern=r"https?: //0\.0\.0\.0: \d+[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize 0.0.0.0 URLs with ports for security",
         global_replace=True,
         test_cases=[
-            ("http://0.0.0.0:8000/api", "[INTERNAL_URL]"),
-            ("https://0.0.0.0:3000/test", "[INTERNAL_URL]"),
-            ("https://1.1.1.1:8080/test", "https://1.1.1.1:8080/test"),  # No change
+            ("http: //0.0.0.0: 8000/api", "[INTERNAL_URL]"),
+            ("https: //0.0.0.0: 3000/test", "[INTERNAL_URL]"),
+            ("https: //1.1.1.1: 8080/test", "https: //1.1.1.1: 8080/test"),
         ],
     ),
     "sanitize_ws_localhost_urls": ValidatedPattern(
         name="sanitize_ws_localhost_urls",
-        pattern=r"ws://localhost:\d+[^\s]*",
+        pattern=r"ws: //localhost: \d+[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize WebSocket localhost URLs with ports for security",
         global_replace=True,
         test_cases=[
-            ("ws://localhost:8675/websocket", "[INTERNAL_URL]"),
-            ("ws://localhost:3000/socket", "[INTERNAL_URL]"),
-            ("Connect to ws://localhost:8000/ws", "Connect to [INTERNAL_URL]"),
+            ("ws: //localhost: 8675/websocket", "[INTERNAL_URL]"),
+            ("ws: //localhost: 3000/socket", "[INTERNAL_URL]"),
+            ("Connect to ws: //localhost: 8000/ws", "Connect to [INTERNAL_URL]"),
             (
-                "wss://example.com:443/socket",
-                "wss://example.com:443/socket",
-            ),  # No change
+                "wss: //example.com: 443/socket",
+                "wss: //example.com: 443/socket",
+            ),
         ],
     ),
     "sanitize_ws_127_urls": ValidatedPattern(
         name="sanitize_ws_127_urls",
-        pattern=r"ws://127\.0\.0\.1:\d+[^\s]*",
+        pattern=r"ws: //127\.0\.0\.1: \d+[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize WebSocket 127.0.0.1 URLs with ports for security",
         global_replace=True,
         test_cases=[
-            ("ws://127.0.0.1:8675/websocket", "[INTERNAL_URL]"),
-            ("ws://127.0.0.1:3000/socket", "[INTERNAL_URL]"),
+            ("ws: //127.0.0.1: 8675/websocket", "[INTERNAL_URL]"),
+            ("ws: //127.0.0.1: 3000/socket", "[INTERNAL_URL]"),
             (
-                "ws://192.168.1.1:8080/socket",
-                "ws://192.168.1.1:8080/socket",
-            ),  # No change
+                "ws: //192.168.1.1: 8080/socket",
+                "ws: //192.168.1.1: 8080/socket",
+            ),
         ],
     ),
     "sanitize_simple_localhost_urls": ValidatedPattern(
         name="sanitize_simple_localhost_urls",
-        pattern=r"http://localhost[^\s]*",
+        pattern=r"http: //localhost[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize simple localhost URLs without explicit ports for security",
         global_replace=True,
         test_cases=[
-            ("http://localhost/api/test", "[INTERNAL_URL]"),
-            ("http://localhost/dashboard", "[INTERNAL_URL]"),
-            ("Visit http://localhost/admin", "Visit [INTERNAL_URL]"),
+            ("http: //localhost/api/test", "[INTERNAL_URL]"),
+            ("http: //localhost/dashboard", "[INTERNAL_URL]"),
+            ("Visit http: //localhost/admin", "Visit [INTERNAL_URL]"),
             (
-                "https://localhost:443/test",
-                "https://localhost:443/test",
-            ),  # No change (different pattern)
+                "https: //localhost: 443/test",
+                "https: //localhost: 443/test",
+            ),
         ],
     ),
     "sanitize_simple_ws_localhost_urls": ValidatedPattern(
         name="sanitize_simple_ws_localhost_urls",
-        pattern=r"ws://localhost[^\s]*",
+        pattern=r"ws: //localhost[^\s]*",
         replacement="[INTERNAL_URL]",
         description="Sanitize simple WebSocket localhost URLs without explicit ports"
         " for security",
         global_replace=True,
         test_cases=[
-            ("ws://localhost/websocket", "[INTERNAL_URL]"),
-            ("ws://localhost/socket", "[INTERNAL_URL]"),
-            ("Connect to ws://localhost/ws", "Connect to [INTERNAL_URL]"),
+            ("ws: //localhost/websocket", "[INTERNAL_URL]"),
+            ("ws: //localhost/socket", "[INTERNAL_URL]"),
+            ("Connect to ws: //localhost/ws", "Connect to [INTERNAL_URL]"),
             (
-                "wss://localhost:443/socket",
-                "wss://localhost:443/socket",
-            ),  # No change (different pattern)
+                "wss: //localhost: 443/socket",
+                "wss: //localhost: 443/socket",
+            ),
         ],
     ),
-    # Integration script patterns for resource management
     "detect_tempfile_usage": ValidatedPattern(
         name="detect_tempfile_usage",
-        pattern=r"tempfile\.(?:mkdtemp|NamedTemporaryFile|TemporaryDirectory)",
-        replacement="MATCH",  # Dummy replacement for detection patterns
+        pattern=r"tempfile\.(mkdtemp|NamedTemporaryFile|TemporaryDirectory)",
+        replacement="MATCH",
         test_cases=[
             ("tempfile.mkdtemp()", "MATCH()"),
             ("tempfile.NamedTemporaryFile()", "MATCH()"),
@@ -1875,14 +1797,14 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "not_tempfile.other()",
                 "not_tempfile.other()",
-            ),  # No match leaves original
+            ),
         ],
         description="Detect tempfile module usage for resource management integration",
     ),
     "detect_subprocess_usage": ValidatedPattern(
         name="detect_subprocess_usage",
-        pattern=r"subprocess\.(?:Popen|run)",
-        replacement="MATCH",  # Dummy replacement for detection patterns
+        pattern=r"subprocess\.(Popen|run)",
+        replacement="MATCH",
         test_cases=[
             ("subprocess.Popen(cmd)", "MATCH(cmd)"),
             ("subprocess.run(['cmd'])", "MATCH(['cmd'])"),
@@ -1893,7 +1815,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "detect_asyncio_create_task": ValidatedPattern(
         name="detect_asyncio_create_task",
         pattern=r"asyncio\.create_task",
-        replacement="MATCH",  # Dummy replacement for detection patterns
+        replacement="MATCH",
         test_cases=[
             ("asyncio.create_task(coro)", "MATCH(coro)"),
             ("not_asyncio.other()", "not_asyncio.other()"),
@@ -1904,35 +1826,35 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "detect_file_open_operations": ValidatedPattern(
         name="detect_file_open_operations",
         pattern=r"(\.open\(|with open\()",
-        replacement=r"MATCH",  # Dummy replacement for detection patterns
+        replacement=r"MATCH",
         test_cases=[
             ("file.open()", "fileMATCH)"),
-            ("with open('file.txt'):", "MATCH'file.txt'):"),
-            ("other_method()", "other_method()"),  # No change
+            ("with open('file.txt'): ", "MATCH'file.txt'): "),
+            ("other_method()", "other_method()"),
         ],
         description="Detect file open operations for resource management integration",
     ),
     "match_async_function_definition": ValidatedPattern(
         name="match_async_function_definition",
-        pattern=r"(async def \w+\([^)]*\)[^:]*:)",
+        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():"),
+            ("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+).*:",
+        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():"),
+            ("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",
     ),
@@ -1987,21 +1909,20 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ),
             (
                 "file.write_text(data, encoding='utf-8')",
-                "await SafeFileOperations.safe_write_text(file, data, encoding='utf-8',"
-                " atomic=True)",
+                "await SafeFileOperations.safe_write_text(file, data, encoding='utf-8', "
+                "atomic=True)",
             ),
         ],
         description="Replace path.write_text with SafeFileOperations.safe_write_text",
     ),
-    # Agent-specific patterns - DocumentationAgent
     "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"),
+            ("12 agents", "12 agents"),
+            ("5 agents", "5 agents"),
         ],
         description="Match agent count patterns for documentation consistency",
         flags=re.IGNORECASE,
@@ -2012,8 +1933,8 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         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"),
+            ("12 specialized agents", "12 specialized agents"),
+            ("5 specialized agents", "5 specialized agents"),
         ],
         description="Match specialized agent count patterns for documentation "
         "consistency",
@@ -2021,7 +1942,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     ),
     "total_agents_config_pattern": ValidatedPattern(
         name="total_agents_config_pattern",
-        pattern=r'total_agents["\'][\s]*:\s*(\d+)',
+        pattern=r'total_agents["\'][\s]*: \s*(\d+)',
         replacement=r'total_agents": \1',
         test_cases=[
             ('total_agents": 9', 'total_agents": 9'),
@@ -2037,8 +1958,8 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         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"),
+            ("12 sub-agents", "12 sub-agents"),
+            ("5 sub-agents", "5 sub-agents"),
         ],
         description="Match sub-agent count patterns for documentation consistency",
         flags=re.IGNORECASE,
@@ -2071,7 +1992,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     ),
     "update_total_agents_config": ValidatedPattern(
         name="update_total_agents_config",
-        pattern=r'total_agents["\'][\s]*:\s*\d+',
+        pattern=r'total_agents["\'][\s]*: \s*\d+',
         replacement=r'total_agents": NEW_COUNT',
         test_cases=[
             ('total_agents": 9', 'total_agents": NEW_COUNT'),
@@ -2093,7 +2014,6 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Update sub-agent count references (NEW_COUNT replaced"
         " dynamically)",
     ),
-    # Agent-specific patterns - TestSpecialistAgent
     "fixture_not_found_pattern": ValidatedPattern(
         name="fixture_not_found_pattern",
         pattern=r"fixture '(\w+)' not found",
@@ -2112,7 +2032,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("ImportError: No module named", "ImportError: No module named"),
             ("ModuleNotFoundError: No module", "ImportError: No module"),
-            ("Other error types", "Other error types"),  # No change
+            ("Other error types", "Other error types"),
         ],
         description="Match import error patterns in test failures",
     ),
@@ -2124,9 +2044,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "AssertionError: Values differ",
                 "AssertionError: Values differ",
-            ),  # No change
+            ),
             ("assert result == expected", "AssertionError expected"),
-            ("Normal code", "Normal code"),  # No change
+            ("Normal code", "Normal code"),
         ],
         description="Match assertion error patterns in test failures",
     ),
@@ -2143,7 +2063,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
                 "AttributeError: 'NoneType' has no attribute 'value'",
                 "AttributeError: has no attribute 'value'",
             ),
-            ("Normal error", "Normal error"),  # No change
+            ("Normal error", "Normal error"),
         ],
         description="Match attribute error patterns in test failures",
     ),
@@ -2154,7 +2074,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("MockSpec error occurred", "MockSpec error occurred"),
             ("spec for Mock failed", "MockSpec failed"),
-            ("Normal mock usage", "Normal mock usage"),  # No change
+            ("Normal mock usage", "Normal mock usage"),
         ],
         description="Match mock specification error patterns in test failures",
     ),
@@ -2165,7 +2085,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("'/test/path'", "str(tmp_path)"),
             ("/test/path", "str(tmp_path)"),
-            ("'/other/path'", "'/other/path'"),  # No change
+            ("'/other/path'", "'/other/path'"),
         ],
         description="Match hardcoded test path patterns that should use tmp_path",
     ),
@@ -2187,21 +2107,20 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("ValidationError: field required", "ValidationError: field required"),
             ("validation error in field", "ValidationError in field"),
-            ("Normal validation", "Normal validation"),  # No change
+            ("Normal validation", "Normal validation"),
         ],
         description="Match Pydantic validation error patterns in test failures",
     ),
-    # Agent-specific patterns - PerformanceAgent
     "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)"),
+            (" items += [new_item]", " items.append(new_item)"),
             ("results += [result]", "results.append(result)"),
-            ("  data += [value, other]", "  data.append(value, other)"),
+            (" data += [value, other]", " data.append(value, other)"),
         ],
-        description="Replace inefficient list concatenation with append for"
+        description="Replace inefficient list[t.Any] concatenation with append for"
         " performance",
     ),
     "string_concatenation_pattern": ValidatedPattern(
@@ -2209,28 +2128,27 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         pattern=r"(\s*)(\w+)\s*\+=\s*(.+)",
         replacement=r"\1\2_parts.append(\3)",
         test_cases=[
-            ("    text += new_text", "    text_parts.append(new_text)"),
+            (" text += new_text", " text_parts.append(new_text)"),
             ("result += line", "result_parts.append(line)"),
-            ("  output += data", "  output_parts.append(data)"),
+            (" output += data", " output_parts.append(data)"),
         ],
-        description="Replace string concatenation with list append for performance "
+        description="Replace string concatenation with list[t.Any] append for performance "
         "optimization",
     ),
-    # Enhanced performance patterns for PerformanceAgent optimization
     "nested_loop_detection_pattern": ValidatedPattern(
         name="nested_loop_detection_pattern",
-        pattern=r"(\s*)(for\s+\w+\s+in\s+.*:)",
+        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 j in other: ",
+                " # Performance: Potential nested loop - check complexity\n "
+                "for j in other: ",
             ),
             (
-                "for i in items:",
+                "for i in items: ",
                 "# Performance: Potential nested loop - check complexity\nfor i"
-                " in items:",
+                " in items: ",
             ),
         ],
         description="Detect loop patterns that might be nested creating O(n²)"
@@ -2239,32 +2157,31 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     ),
     "list_extend_optimization_pattern": ValidatedPattern(
         name="list_extend_optimization_pattern",
-        pattern=r"(\s*)(\w+)\s*\+=\s*\[([^]]+(?:,\s*[^]]+)*)\]",
+        pattern=r"(\s*)(\w+)\s*\+=\s*\[([^]]+(?: , \s*[^]]+)*)\]",
         replacement=r"\1\2.extend([\3])",
         test_cases=[
-            ("    items += [a, b, c]", "    items.extend([a, b, c])"),
+            (" items += [a, b, c]", " items.extend([a, b, c])"),
             ("results += [x, y]", "results.extend([x, y])"),
-            ("  data += [single_item]", "  data.extend([single_item])"),
+            (" data += [single_item]", " data.extend([single_item])"),
         ],
-        description="Replace list concatenation with extend for better performance with multiple items",
+        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"
+        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",
+                ' text = "".join([])',
+                ' text = "" # Performance: Use empty string directly instead of join',
             ),
             (
                 "result = ''.join([])",
-                "result = ''  # Performance: Use empty string directly instead of join",
+                "result = '' # Performance: Use empty string directly instead of join",
             ),
         ],
-        description="Replace inefficient empty list join with direct empty string"
+        description="Replace inefficient empty list[t.Any] join with direct empty string"
         " assignment",
     ),
     "repeated_len_in_loop_pattern": ValidatedPattern(
@@ -2274,9 +2191,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         r"repeatedly\n\1\2",
         test_cases=[
             (
-                "    len(items)",
-                "    # Performance: Consider caching len(items) if used repeatedly\n"
-                "    len(items)",
+                " len(items)",
+                " # Performance: Consider caching len(items) if used repeatedly\n"
+                " len(items)",
             ),
             (
                 "len(data)",
@@ -2289,23 +2206,22 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
     "list_comprehension_optimization_pattern": ValidatedPattern(
         name="list_comprehension_optimization_pattern",
         pattern=r"(\s*)(\w+)\.append\(([^)]+)\)",
-        replacement=r"\1# Performance: Consider list comprehension if this is in a "
+        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 comprehension if this is in a "
-                "simple loop\n    results.append(item * 2)",
+                " 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 comprehension if this is in a simple"
+                "# Performance: Consider list[t.Any] comprehension if this is in a simple"
                 " loop\ndata.append(value)",
             ),
         ],
-        description="Suggest list comprehensions for simple append patterns",
+        description="Suggest list[t.Any] comprehensions for simple append patterns",
     ),
-    # Enhanced security patterns for improved SecurityAgent capabilities
     "detect_crypto_weak_algorithms": ValidatedPattern(
         name="detect_crypto_weak_algorithms",
         pattern=r"\b(?:md4|md5|sha1|des|3des|rc4)\b",
@@ -2316,7 +2232,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("hashlib.md5()", "hashlib.[WEAK_CRYPTO_ALGORITHM]()"),
             ("using DES encryption", "using [WEAK_CRYPTO_ALGORITHM] encryption"),
-            ("SHA256 is good", "SHA256 is good"),  # No change
+            ("SHA256 is good", "SHA256 is good"),
             ("MD4 hashing", "[WEAK_CRYPTO_ALGORITHM] hashing"),
         ],
     ),
@@ -2336,7 +2252,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 'username = "user"',
                 'username = "user"',
-            ),  # No match - not a credential field
+            ),
         ],
     ),
     "detect_subprocess_shell_injection": ValidatedPattern(
@@ -2351,7 +2267,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             (
                 "subprocess.run(cmd, shell=False)",
                 "subprocess.run(cmd, shell=False)",
-            ),  # No change
+            ),
         ],
     ),
     "detect_regex_redos_vulnerable": ValidatedPattern(
@@ -2365,7 +2281,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("(a+)*", "[REDOS_VULNERABLE_PATTERN]"),
             ("(a*)+", "[REDOS_VULNERABLE_PATTERN]"),
             ("(abc)+", "[REDOS_VULNERABLE_PATTERN]"),
-            ("simple+", "simple+"),  # No change - not vulnerable
+            ("simple+", "simple+"),
         ],
     ),
     "fix_hardcoded_jwt_secret": ValidatedPattern(
@@ -2380,7 +2296,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
                 'JWT_SECRET = os.getenv("JWT_SECRET", "")',
             ),
             ('jwt_secret = "my-secret"', 'jwt_secret = os.getenv("JWT_SECRET", "")'),
-            ('other_var = "value"', 'other_var = "value"'),  # No change
+            ('other_var = "value"', 'other_var = "value"'),
         ],
     ),
     "detect_unsafe_pickle_usage": ValidatedPattern(
@@ -2392,10 +2308,9 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("pickle.load(file)", "[UNSAFE_PICKLE_USAGE].load(file)"),
             ("pickle.loads(data)", "[UNSAFE_PICKLE_USAGE].loads(data)"),
-            ("my_pickle.load(file)", "my_pickle.load(file)"),  # No change
+            ("my_pickle.load(file)", "my_pickle.load(file)"),
         ],
     ),
-    # Agent-specific patterns for validation and analysis
     "extract_range_size": ValidatedPattern(
         name="extract_range_size",
         pattern=r"range\((\d+)\)",
@@ -2404,8 +2319,8 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("range(1000)", "1000"),
             ("range(50)", "50"),
-            ("for i in range(100):", "for i in 100:"),
-            ("other_func(10)", "other_func(10)"),  # No change
+            ("for i in range(100): ", "for i in 100: "),
+            ("other_func(10)", "other_func(10)"),
         ],
     ),
     "match_error_code_patterns": ValidatedPattern(
@@ -2418,30 +2333,30 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
             ("I001", "I001"),
             ("E302", "E302"),
             ("W291", "W291"),
-            ("ABC123", "ABC123"),  # No change
+            ("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*[<>=]",
+        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 not var: ", "if not var: "),
+            ("if item is None: ", "if item is None: "),
             ("if len(items) >", "if len(items) >"),
-            ("other code", "other code"),  # No change
+            ("other code", "other code"),
         ],
     ),
     "match_loop_patterns": ValidatedPattern(
         name="match_loop_patterns",
-        pattern=r"\s*for\s+.*:\s*$|\s*while\s+.*:\s*$",
+        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"),  # No change
+            (" for i in items: ", " for i in items: "),
+            (" while condition: ", " while condition: "),
+            ("regular line", "regular line"),
         ],
     ),
     "match_star_import": ValidatedPattern(
@@ -2452,7 +2367,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("from module import *", "from module import *"),
             ("from my_pkg import *", "from my_pkg import *"),
-            ("from module import specific", "from module import specific"),  # No change
+            ("from module import specific", "from module import specific"),
         ],
     ),
     "clean_unused_import": ValidatedPattern(
@@ -2461,11 +2376,11 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         replacement=r"",
         description="Remove unused import statements (example with unused_module)",
         test_cases=[
-            ("    import unused_module", ""),
+            (" import unused_module", ""),
             (
                 "import other_module",
                 "import other_module",
-            ),  # No change for different module
+            ),
         ],
     ),
     "clean_unused_from_import": ValidatedPattern(
@@ -2479,40 +2394,40 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
                 "from module import used, unused_item",
                 "from module import used, unused_item",
             ),
-            ("from other import needed", "from other import needed"),  # No change
+            ("from other import needed", "from other import needed"),
         ],
     ),
     "clean_import_commas": ValidatedPattern(
         name="clean_import_commas",
-        pattern=r",\s*,",
-        replacement=r",",
+        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", "normal, list"),  # No change
+            ("normal, list[t.Any]", "normal, list[t.Any]"),
         ],
     ),
     "clean_trailing_import_comma": ValidatedPattern(
         name="clean_trailing_import_comma",
-        pattern=r",\s*$",
+        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"),  # No change
+            ("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*",
+        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"),  # No change
+            ("import , module", "import module"),
+            ("from pkg import , item", "from pkg import item"),
+            ("import normal", "import normal"),
         ],
     ),
     "extract_unused_import_name": ValidatedPattern(
@@ -2523,7 +2438,7 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         test_cases=[
             ("unused import 'module_name'", "module_name"),
             ('unused import "other_module"', "other_module"),
-            ("some other text", "some other text"),  # No change
+            ("some other text", "some other text"),
         ],
     ),
     "normalize_whitespace": ValidatedPattern(
@@ -2533,17 +2448,267 @@ SAFE_PATTERNS: dict[str, ValidatedPattern] = {
         description="Normalize multiple whitespace to single space",
         global_replace=True,
         test_cases=[
-            ("import    module", "import module"),
-            ("from  pkg   import  item", "from pkg import item"),
-            ("normal text", "normal text"),  # No change with single spaces
+            ("import module", "import module"),
+            ("from pkg import item", "from pkg import item"),
+            ("normal text", "normal text"),
+        ],
+    ),
+    # Template processing patterns
+    "extract_template_variables": ValidatedPattern(
+        name="extract_template_variables",
+        pattern=r"\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}",
+        replacement=r"\1",
+        description="Extract template variables from {{variable}} patterns",
+        test_cases=[
+            ("Hello {{name}}", "Hello name"),
+            ("{{user_name}}", "user_name"),
+            ("{{ spaced_var }}", "spaced_var"),
+            ("text {{var1}} and {{var2}}", "text var1 and {{var2}}"),
+        ],
+    ),
+    "extract_template_sections": ValidatedPattern(
+        name="extract_template_sections",
+        pattern=r"\{\%\s*section\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\%\}",
+        replacement=r"\1",
+        description="Extract section names from {% section name %} patterns",
+        test_cases=[
+            ("{% section intro %}", "intro"),
+            ("{%  section  main_content  %}", "main_content"),
+            ("text {% section footer %} more", "text footer more"),
+            ("{% section header_1 %}", "header_1"),
+        ],
+    ),
+    "extract_template_blocks": ValidatedPattern(
+        name="extract_template_blocks",
+        pattern=r"\{\%\s*block\s+(\w+)\s*\%\}(.*?)\{\%\s*endblock\s*\%\}",
+        replacement=r"\1",
+        description="Extract block names and content from template blocks",
+        flags=re.DOTALL,
+        test_cases=[
+            ("{% block title %}Hello{% endblock %}", "title"),
+            ("{%  block  content  %}Text content{% endblock %}", "content"),
+            ("{% block main %}Multi\nline{% endblock %}", "main"),
+            (
+                "prefix {% block nav %}nav content{% endblock %} suffix",
+                "prefix nav suffix",
+            ),
+        ],
+    ),
+    "replace_template_block": ValidatedPattern(
+        name="replace_template_block",
+        pattern=r"\{\%\s*block\s+BLOCK_NAME\s*\%\}.*?\{\%\s*endblock\s*\%\}",
+        replacement="REPLACEMENT_CONTENT",
+        description="Replace a specific template block (use with dynamic pattern substitution)",
+        flags=re.DOTALL,
+        test_cases=[
+            ("{% block BLOCK_NAME %}old{% endblock %}", "REPLACEMENT_CONTENT"),
+            (
+                "{%  block  BLOCK_NAME  %}old content{% endblock %}",
+                "REPLACEMENT_CONTENT",
+            ),
+        ],
+    ),
+    # Documentation parsing patterns
+    "extract_markdown_links": ValidatedPattern(
+        name="extract_markdown_links",
+        pattern=r"\[([^\]]+)\]\(([^)]+)\)",
+        replacement=r"\1 -> \2",
+        description="Extract markdown link text and URLs from [text](url) patterns",
+        test_cases=[
+            ("[Click here](http://example.com)", "Click here -> http://example.com"),
+            ("[Local file](./docs/readme.md)", "Local file -> ./docs/readme.md"),
+            (
+                "See [the docs](../reference.md) for more",
+                "See the docs -> ../reference.md for more",
+            ),
+            ("[Multi word link](path/to/file)", "Multi word link -> path/to/file"),
+        ],
+    ),
+    "extract_version_numbers": ValidatedPattern(
+        name="extract_version_numbers",
+        pattern=r"version\s+(\d+\.\d+\.\d+)",
+        replacement=r"\1",
+        description="Extract semantic version numbers from 'version X.Y.Z' patterns",
+        flags=re.IGNORECASE,
+        test_cases=[
+            ("version 1.2.3", "1.2.3"),
+            ("Version 10.0.1", "10.0.1"),
+            ("current version 0.5.0", "current 0.5.0"),
+            ("VERSION 2.11.4", "2.11.4"),
+        ],
+    ),
+    # Docstring parsing patterns
+    "extract_google_docstring_params": ValidatedPattern(
+        name="extract_google_docstring_params",
+        pattern=r"^\s*(\w+)(?:\s*\([^)]+\))?\s*:\s*(.+)$",
+        replacement=r"\1: \2",
+        description="Extract parameter names and descriptions from Google-style docstrings",
+        flags=re.MULTILINE,
+        test_cases=[
+            ("    param1: Description here", "param1: Description here"),
+            ("param2 (str): String parameter", "param2: String parameter"),
+            (
+                "  complex_param (Optional[int]): Complex type",
+                "complex_param: Complex type",
+            ),
+            ("simple: Simple desc", "simple: Simple desc"),
+        ],
+    ),
+    "extract_sphinx_docstring_params": ValidatedPattern(
+        name="extract_sphinx_docstring_params",
+        pattern=r":param\s+(\w+)\s*:\s*(.+)$",
+        replacement=r"\1: \2",
+        description="Extract parameter names and descriptions from Sphinx-style docstrings",
+        flags=re.MULTILINE,
+        test_cases=[
+            (":param name: The name parameter", "name: The name parameter"),
+            (":param user_id: User identifier", "user_id: User identifier"),
+            (
+                ":param  spaced  :  Description with spaces",
+                "spaced: Description with spaces",
+            ),
+            (
+                ":param complex_var: Multi-word description here",
+                "complex_var: Multi-word description here",
+            ),
+        ],
+    ),
+    "extract_docstring_returns": ValidatedPattern(
+        name="extract_docstring_returns",
+        pattern=r"(?:Returns?|Return):\s*(.+?)(?=\n\n|\n\w+:|\Z)",
+        replacement=r"\1",
+        description="Extract return descriptions from docstrings",
+        flags=re.MULTILINE | re.DOTALL,
+        test_cases=[
+            ("Returns: A string value", "A string value"),
+            ("Return: Boolean indicating success", "Boolean indicating success"),
+            ("Returns: Multi-line\n    description", "Multi-line\n    description"),
+            ("Returns: Simple value\n\nArgs:", "Simple value\n\nArgs:"),
+        ],
+    ),
+    # Command processing patterns
+    "enhance_command_blocks": ValidatedPattern(
+        name="enhance_command_blocks",
+        pattern=r"```(?:bash|shell|sh)?\n([^`]+)\n```",
+        replacement=r"```bash\n\1\n```",
+        description="Enhance command blocks with proper bash syntax highlighting",
+        test_cases=[
+            ("```\npython -m test\n```", "```bash\npython -m test\n```"),
+            ("```bash\necho hello\n```", "```bash\necho hello\n```"),
+            ("```sh\nls -la\n```", "```bash\nls -la\n```"),
+            ("```shell\ncd /tmp\n```", "```bash\ncd /tmp\n```"),
+        ],
+    ),
+    "extract_step_numbers": ValidatedPattern(
+        name="extract_step_numbers",
+        pattern=r"^(\s*)(\d+)\.\s*(.+)$",
+        replacement=r"\1**Step \2**: \3",
+        description="Extract and enhance numbered steps in documentation",
+        flags=re.MULTILINE,
+        test_cases=[
+            ("1. First step", "**Step 1**: First step"),
+            ("  2. Indented step", "  **Step 2**: Indented step"),
+            ("10. Double digit step", "**Step 10**: Double digit step"),
+            ("normal text", "normal text"),
+        ],
+    ),
+    "extract_bash_command_blocks": ValidatedPattern(
+        name="extract_bash_command_blocks",
+        pattern=r"```bash\n([^`]+)\n```",
+        replacement=r"\1",
+        description="Extract content from bash command blocks",
+        test_cases=[
+            ("```bash\necho hello\n```", "echo hello"),
+            ("```bash\npython -m test\n```", "python -m test"),
+            ("text\n```bash\nls -la\n```\nmore", "text\nls -la\nmore"),
+            ("```bash\nmulti\nline\ncommand\n```", "multi\nline\ncommand"),
+        ],
+    ),
+    "detect_coverage_badge": ValidatedPattern(
+        name="detect_coverage_badge",
+        pattern=r"!\[Coverage.*?\]\(.*?coverage.*?\)|!\[.*coverage.*?\]\(.*?shields\.io.*?coverage.*?\)|https://img\.shields\.io/badge/coverage-[\d\.]+%25-\w+",
+        replacement="",
+        description="Detect existing coverage badges in README content",
+        flags=re.IGNORECASE,
+        test_cases=[
+            (
+                "![Coverage](https://img.shields.io/badge/coverage-85.0%25-brightgreen)",
+                "",
+            ),
+            (
+                "![Code Coverage](https://img.shields.io/badge/coverage-75.5%25-yellow)",
+                "",
+            ),
+            (
+                "![coverage badge](https://shields.io/badge/coverage-90.0%25-brightgreen)",
+                "",
+            ),
+            ("Some text without badge", "Some text without badge"),
+        ],
+    ),
+    "update_coverage_badge_url": ValidatedPattern(
+        name="update_coverage_badge_url",
+        pattern=r"(!\[Coverage.*?\]\()([^)]+)(\))",
+        replacement=r"\1NEW_BADGE_URL\3",
+        description="Update coverage badge URL in markdown links",
+        test_cases=[
+            ("![Coverage](old_url)", "![Coverage](NEW_BADGE_URL)"),
+            ("![Coverage Badge](old_badge_url)", "![Coverage Badge](NEW_BADGE_URL)"),
+            ("text ![Coverage](url) more", "text ![Coverage](NEW_BADGE_URL) more"),
+            ("no badge here", "no badge here"),
+        ],
+    ),
+    "update_coverage_badge_any": ValidatedPattern(
+        name="update_coverage_badge_any",
+        pattern=r"(!\[.*coverage.*?\]\()([^)]+)(\))",
+        replacement=r"\1NEW_BADGE_URL\3",
+        description="Update any coverage-related badge URL",
+        flags=re.IGNORECASE,
+        test_cases=[
+            ("![Code Coverage](old_url)", "![Code Coverage](NEW_BADGE_URL)"),
+            ("![coverage badge](old_url)", "![coverage badge](NEW_BADGE_URL)"),
+            ("![test coverage](url)", "![test coverage](NEW_BADGE_URL)"),
+            ("![Other Badge](url)", "![Other Badge](url)"),
+        ],
+    ),
+    "update_shields_coverage_url": ValidatedPattern(
+        name="update_shields_coverage_url",
+        pattern=r"(https://img\.shields\.io/badge/coverage-[\d\.]+%25-\w+)",
+        replacement="NEW_BADGE_URL",
+        description="Update shields.io coverage badge URLs directly",
+        test_cases=[
+            (
+                "https://img.shields.io/badge/coverage-85.0%25-brightgreen",
+                "NEW_BADGE_URL",
+            ),
+            ("https://img.shields.io/badge/coverage-75.5%25-yellow", "NEW_BADGE_URL"),
+            (
+                "https://img.shields.io/badge/coverage-90.1%25-brightgreen",
+                "NEW_BADGE_URL",
+            ),
+            (
+                "https://img.shields.io/badge/build-passing-green",
+                "https://img.shields.io/badge/build-passing-green",
+            ),
+        ],
+    ),
+    "extract_coverage_percentage": ValidatedPattern(
+        name="extract_coverage_percentage",
+        pattern=r"coverage-([\d\.]+)%25",
+        replacement="",  # Not used for extraction, just validation
+        description="Search for coverage percentage in badge URL",
+        test_cases=[
+            ("coverage-85.0%25", ""),  # Will use search() to get group(1)
+            ("coverage-75.5%25", ""),
+            ("coverage-100.0%25", ""),
+            ("no coverage here", "no coverage here"),  # No match
         ],
     ),
 }
 
 
 def validate_all_patterns() -> dict[str, bool]:
-    """Validate all patterns and return results."""
-    validate_results = {}
+    validate_results: dict[str, bool] = {}
     for name, pattern in SAFE_PATTERNS.items():
         try:
             pattern._validate()
@@ -2555,12 +2720,10 @@ def validate_all_patterns() -> dict[str, bool]:
 
 
 def find_pattern_for_text(text: str) -> list[str]:
-    """Find which patterns match the given text."""
     return [name for name, pattern in SAFE_PATTERNS.items() if pattern.test(text)]
 
 
 def apply_safe_replacement(text: str, pattern_name: str) -> str:
-    """Apply a safe replacement pattern by name."""
     if pattern_name not in SAFE_PATTERNS:
         raise ValueError(f"Unknown pattern: {pattern_name}")
 
@@ -2568,7 +2731,6 @@ def apply_safe_replacement(text: str, pattern_name: str) -> str:
 
 
 def get_pattern_description(pattern_name: str) -> str:
-    """Get description of a pattern."""
     if pattern_name not in SAFE_PATTERNS:
         return "Unknown pattern"
 
@@ -2576,29 +2738,14 @@ def get_pattern_description(pattern_name: str) -> str:
 
 
 def fix_multi_word_hyphenation(text: str) -> str:
-    """
-    Fix complex multi-word hyphenation cases like 'pytest - hypothesis - specialist'.
-
-    Uses iterative application of the spaced_hyphens pattern to handle multiple words.
-    """
     return SAFE_PATTERNS["fix_spaced_hyphens"].apply_iteratively(text)
 
 
 def update_pyproject_version(content: str, new_version: str) -> str:
-    """
-    Update version in pyproject.toml content with safe regex.
-
-    Args:
-        content: The pyproject.toml file content
-        new_version: The new version to set
-
-    Returns:
-        Updated content with new version
-    """
     import re
 
     pattern_obj = SAFE_PATTERNS["update_pyproject_version"]
-    # Create a temporary pattern with the actual version
+
     temp_pattern = ValidatedPattern(
         name="temp_version_update",
         pattern=pattern_obj.pattern,
@@ -2609,15 +2756,12 @@ def update_pyproject_version(content: str, new_version: str) -> str:
         ],
     )
 
-    # Apply with MULTILINE flag for line-by-line matching
     return re.compile(pattern_obj.pattern, re.MULTILINE).sub(
         temp_pattern.replacement, content
     )
 
 
 def apply_formatting_fixes(content: str) -> str:
-    """Apply standard formatting fixes to content."""
-    # Remove trailing whitespace using MULTILINE flag
     import re
 
     pattern = SAFE_PATTERNS["remove_trailing_whitespace"]
@@ -2625,59 +2769,50 @@ def apply_formatting_fixes(content: str) -> str:
         pattern.replacement, content
     )
 
-    # Normalize multiple newlines
     content = SAFE_PATTERNS["normalize_multiple_newlines"].apply(content)
 
     return content
 
 
 def apply_security_fixes(content: str) -> str:
-    """Apply all security-related fixes to content."""
-    # Fix subprocess shell injections
     content = SAFE_PATTERNS["fix_subprocess_run_shell"].apply(content)
     content = SAFE_PATTERNS["fix_subprocess_call_shell"].apply(content)
     content = SAFE_PATTERNS["fix_subprocess_popen_shell"].apply(content)
 
-    # Fix unsafe library usage
     content = SAFE_PATTERNS["fix_unsafe_yaml_load"].apply(content)
     content = SAFE_PATTERNS["fix_weak_md5_hash"].apply(content)
     content = SAFE_PATTERNS["fix_weak_sha1_hash"].apply(content)
     content = SAFE_PATTERNS["fix_insecure_random_choice"].apply(content)
 
-    # Remove debug prints with secrets
     content = SAFE_PATTERNS["remove_debug_prints_with_secrets"].apply(content)
 
     return content
 
 
 def apply_test_fixes(content: str) -> str:
-    """Apply test-related fixes to content."""
     return SAFE_PATTERNS["normalize_assert_statements"].apply(content)
 
 
 def is_valid_job_id(job_id: str) -> bool:
-    """Validate job ID using safe regex patterns."""
     return SAFE_PATTERNS["validate_job_id_alphanumeric"].test(job_id)
 
 
 def remove_coverage_fail_under(addopts: str) -> str:
-    """Remove coverage fail-under flags from pytest addopts."""
     return SAFE_PATTERNS["remove_coverage_fail_under"].apply(addopts)
 
 
 def update_coverage_requirement(content: str, new_coverage: float) -> str:
-    """Update coverage requirement in content."""
     import re
 
     pattern_obj = SAFE_PATTERNS["update_coverage_requirement"]
-    # Create a temporary pattern with the actual coverage value
+
     temp_pattern = ValidatedPattern(
         name="temp_coverage_update",
         pattern=pattern_obj.pattern,
-        replacement=f"\\1{new_coverage:.0f}",
+        replacement=f"\\1{new_coverage: .0f}",
         description=f"Update coverage to {new_coverage}",
         test_cases=[
-            ("--cov-fail-under=85", f"--cov-fail-under={new_coverage:.0f}"),
+            ("--cov-fail-under=85", f"--cov-fail-under={new_coverage: .0f}"),
         ],
     )
 
@@ -2685,39 +2820,16 @@ def update_coverage_requirement(content: str, new_coverage: float) -> str:
 
 
 def update_repo_revision(content: str, repo_url: str, new_revision: str) -> str:
-    """
-    Update repository revision in config content with safe regex.
-
-    Args:
-        content: The config file content (JSON-like format)
-        repo_url: The repository URL to find and update
-        new_revision: The new revision to set
-
-    Returns:
-        Updated content with new revision
-    """
     import re
 
-    # Create a pattern specific to the repo URL (escaped for safety)
     escaped_url = re.escape(repo_url)
     pattern = rf'("repo": "{escaped_url}".*?"rev": )"([^"]+)"'
     replacement = rf'\1"{new_revision}"'
 
-    # Use DOTALL flag for multiline matching
     return re.compile(pattern, re.DOTALL).sub(replacement, content)
 
 
 def sanitize_internal_urls(text: str) -> str:
-    """
-    Sanitize internal URLs using safe patterns for security.
-
-    Args:
-        text: Text that may contain internal URLs
-
-    Returns:
-        Text with internal URLs replaced with [INTERNAL_URL]
-    """
-    # Apply all URL sanitization patterns
     url_patterns = [
         "sanitize_localhost_urls",
         "sanitize_127_urls",
@@ -2738,17 +2850,15 @@ def sanitize_internal_urls(text: str) -> str:
 def apply_pattern_iteratively(
     text: str, pattern_name: str, max_iterations: int = MAX_ITERATIONS
 ) -> str:
-    """Apply a pattern iteratively until no more changes occur."""
     if pattern_name not in SAFE_PATTERNS:
         raise ValueError(f"Unknown pattern: {pattern_name}")
 
     return SAFE_PATTERNS[pattern_name].apply_iteratively(text, max_iterations)
 
 
-def get_all_pattern_stats() -> dict[str, dict[str, int | float]]:
-    """Get performance statistics for all patterns."""
+def get_all_pattern_stats() -> dict[str, dict[str, float] | dict[str, str]]:
     test_text = "python - m crackerjack - t with pytest - hypothesis - specialist"
-    stats = {}
+    stats: dict[str, dict[str, float] | dict[str, str]] = {}
 
     for name, pattern in SAFE_PATTERNS.items():
         try:
@@ -2761,22 +2871,14 @@ def get_all_pattern_stats() -> dict[str, dict[str, int | float]]:
 
 
 def clear_all_caches() -> None:
-    """Clear all caches (useful for testing and memory management)."""
     CompiledPatternCache.clear_cache()
 
 
 def get_cache_info() -> dict[str, int | list[str]]:
-    """Get information about pattern cache usage."""
     return CompiledPatternCache.get_cache_stats()
 
 
-# Security validation functions
 def detect_path_traversal_patterns(path_str: str) -> list[str]:
-    """
-    Detect directory traversal patterns in a path string.
-
-    Returns list of detected pattern names.
-    """
     detected = []
     traversal_patterns = [
         "detect_directory_traversal_basic",
@@ -2794,11 +2896,6 @@ def detect_path_traversal_patterns(path_str: str) -> list[str]:
 
 
 def detect_null_byte_patterns(path_str: str) -> list[str]:
-    """
-    Detect null byte patterns in a path string.
-
-    Returns list of detected pattern names.
-    """
     detected = []
     null_patterns = [
         "detect_null_bytes_url",
@@ -2815,11 +2912,6 @@ def detect_null_byte_patterns(path_str: str) -> list[str]:
 
 
 def detect_dangerous_directory_patterns(path_str: str) -> list[str]:
-    """
-    Detect dangerous directory access patterns.
-
-    Returns list of detected pattern names.
-    """
     detected = []
     dangerous_patterns = [
         "detect_sys_directory_pattern",
@@ -2842,11 +2934,6 @@ def detect_dangerous_directory_patterns(path_str: str) -> list[str]:
 
 
 def detect_suspicious_path_patterns(path_str: str) -> list[str]:
-    """
-    Detect suspicious path patterns that might indicate attacks.
-
-    Returns list of detected pattern names.
-    """
     detected = []
     suspicious_patterns = [
         "detect_parent_directory_in_path",
@@ -2863,11 +2950,6 @@ def detect_suspicious_path_patterns(path_str: str) -> list[str]:
 
 
 def validate_path_security(path_str: str) -> dict[str, list[str]]:
-    """
-    Comprehensive path security validation using safe patterns.
-
-    Returns dict with categories of detected issues.
-    """
     return {
         "traversal_patterns": detect_path_traversal_patterns(path_str),
         "null_bytes": detect_null_byte_patterns(path_str),
@@ -2876,7 +2958,6 @@ def validate_path_security(path_str: str) -> dict[str, list[str]]:
     }
 
 
-# Validation on module import
 if __name__ == "__main__":
     results = validate_all_patterns()
     if all(results.values()):