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

crackerjack/services/patterns/security/unsafe_operations.py

@@ -0,0 +1,216 @@
+"""Unsafe operation detection and remediation patterns.
+
+This module contains patterns for detecting and fixing unsafe operations
+including weak cryptography, insecure random usage, subprocess shell injection,
+and other dangerous programming practices.
+"""
+
+import re
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "detect_crypto_weak_algorithms": ValidatedPattern(
+        name="detect_crypto_weak_algorithms",
+        pattern=r"\b(?:md4|md5|sha1|des|3des|rc4)\b",
+        replacement="[WEAK_CRYPTO_ALGORITHM]",
+        description="Detect weak cryptographic algorithms",
+        flags=re.IGNORECASE,
+        global_replace=True,
+        test_cases=[
+            ("hashlib.md5()", "hashlib.[WEAK_CRYPTO_ALGORITHM]()"),
+            ("using DES encryption", "using [WEAK_CRYPTO_ALGORITHM] encryption"),
+            ("SHA256 is good", "SHA256 is good"),
+            ("MD4 hashing", "[WEAK_CRYPTO_ALGORITHM] hashing"),
+        ],
+    ),
+    "detect_insecure_random_usage": ValidatedPattern(
+        name="detect_insecure_random_usage",
+        pattern=r"\brandom\.(?:random|choice)\([^)]*\)",
+        replacement="[INSECURE_RANDOM]()",
+        description="Detect insecure random module usage for security-sensitive"
+        " operations",
+        global_replace=True,
+        test_cases=[
+            ("random.random()", "[INSECURE_RANDOM]()"),
+            ("random.choice(items)", "[INSECURE_RANDOM]()"),
+            ("secrets.choice(items)", "secrets.choice(items)"),
+            ("my_random.choice()", "my_random.choice()"),
+        ],
+    ),
+    "detect_regex_redos_vulnerable": ValidatedPattern(
+        name="detect_regex_redos_vulnerable",
+        pattern=r"\([^)]+\)[\*\+]",
+        replacement="[REDOS_VULNERABLE_PATTERN]",
+        description="Detect regex patterns vulnerable to ReDoS attacks (simplified"
+        " detection)",
+        global_replace=True,
+        test_cases=[
+            ("(a+)*", "[REDOS_VULNERABLE_PATTERN]"),
+            ("(a*)+", "[REDOS_VULNERABLE_PATTERN]"),
+            ("(abc)+", "[REDOS_VULNERABLE_PATTERN]"),
+            ("simple+", "simple+"),
+        ],
+    ),
+    "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",
+        description="Detect security-related keywords in issue messages "
+        "(case insensitive)",
+        flags=re.IGNORECASE,
+        test_cases=[
+            ("Bandit security issue found", "MATCH security issue found"),
+            ("VULNERABILITY detected", "MATCH detected"),
+            ("hardcoded path found", "MATCH path found"),
+            ("shell=True usage", "MATCH usage"),
+            ("B108 violation", "MATCH violation"),
+            ("normal message", "normal message"),
+        ],
+    ),
+    "detect_subprocess_shell_injection": ValidatedPattern(
+        name="detect_subprocess_shell_injection",
+        pattern=r"\bsubprocess\.\w+\([^)]*shell\s*=\s*True[^)]*\)",
+        replacement="[SHELL_INJECTION_RISK]",
+        description="Detect subprocess calls with shell=True",
+        global_replace=True,
+        test_cases=[
+            ("subprocess.run(cmd, shell=True)", "[SHELL_INJECTION_RISK]"),
+            ("subprocess.call(command, shell=True)", "[SHELL_INJECTION_RISK]"),
+            (
+                "subprocess.run(cmd, shell=False)",
+                "subprocess.run(cmd, shell=False)",
+            ),
+        ],
+    ),
+    "detect_subprocess_usage": ValidatedPattern(
+        name="detect_subprocess_usage",
+        pattern=r"subprocess\.(Popen|run)",
+        replacement="MATCH",
+        test_cases=[
+            ("subprocess.Popen(cmd)", "MATCH(cmd)"),
+            ("subprocess.run(['cmd'])", "MATCH(['cmd'])"),
+            ("not_subprocess.other()", "not_subprocess.other()"),
+        ],
+        description="Detect subprocess module usage for resource management integration",
+    ),
+    "detect_unsafe_pickle_usage": ValidatedPattern(
+        name="detect_unsafe_pickle_usage",
+        pattern=r"\bpickle\.(loads?)\s*\(",
+        replacement=r"[UNSAFE_PICKLE_USAGE].\1(",
+        description="Detect potentially unsafe pickle usage",
+        global_replace=True,
+        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)"),
+        ],
+    ),
+    "fix_insecure_random_choice": ValidatedPattern(
+        name="fix_insecure_random_choice",
+        pattern=r"random\.choice\(([^)]+)\)",
+        replacement=r"secrets.choice(\1)",
+        description="Replace insecure random.choice with secrets.choice",
+        global_replace=True,
+        test_cases=[
+            ("random.choice(options)", "secrets.choice(options)"),
+            ("item = random.choice(items)", "item = secrets.choice(items)"),
+            ("secrets.choice(options)", "secrets.choice(options)"),
+        ],
+    ),
+    "fix_subprocess_call_shell": ValidatedPattern(
+        name="fix_subprocess_call_shell",
+        pattern=r"subprocess\.call\(([^,]+),\s*shell=True\)",
+        replacement=r"subprocess.call(\1.split())",
+        description="Remove shell=True from subprocess.call calls",
+        global_replace=True,
+        test_cases=[
+            ("subprocess.call(cmd, shell=True)", "subprocess.call(cmd.split())"),
+            (
+                "subprocess.call('ls -la', shell=True)",
+                "subprocess.call('ls -la'.split())",
+            ),
+            (
+                "subprocess.call(command, shell=False)",
+                "subprocess.call(command, shell=False)",
+            ),
+        ],
+    ),
+    "fix_subprocess_popen_shell": ValidatedPattern(
+        name="fix_subprocess_popen_shell",
+        pattern=r"subprocess\.Popen\(([^,]+), \s*shell=True\)",
+        replacement=r"subprocess.Popen(\1.split())",
+        description="Remove shell=True from subprocess.Popen calls",
+        global_replace=True,
+        test_cases=[
+            ("subprocess.Popen(cmd, shell=True)", "subprocess.Popen(cmd.split())"),
+            (
+                "subprocess.Popen('ls -la', shell=True)",
+                "subprocess.Popen('ls -la'.split())",
+            ),
+            (
+                "subprocess.Popen(command, shell=False)",
+                "subprocess.Popen(command, shell=False)",
+            ),
+        ],
+    ),
+    "fix_subprocess_run_shell": ValidatedPattern(
+        name="fix_subprocess_run_shell",
+        pattern=r"subprocess\.run\(([^,]+),\s*shell=True\)",
+        replacement=r"subprocess.run(\1.split())",
+        description="Remove shell=True from subprocess.run calls",
+        global_replace=True,
+        test_cases=[
+            ("subprocess.run(cmd, shell=True)", "subprocess.run(cmd.split())"),
+            (
+                "subprocess.run('ls -la', shell=True)",
+                "subprocess.run('ls -la'.split())",
+            ),
+            (
+                "subprocess.run(command, shell=False)",
+                "subprocess.run(command, shell=False)",
+            ),
+        ],
+    ),
+    "fix_unsafe_yaml_load": ValidatedPattern(
+        name="fix_unsafe_yaml_load",
+        pattern=r"\byaml\.load\(",
+        replacement="yaml.safe_load(",
+        description="Replace unsafe yaml.load with yaml.safe_load",
+        global_replace=True,
+        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)"),
+            (
+                "my_yaml.load(content)",
+                "my_yaml.load(content)",
+            ),
+        ],
+    ),
+    "fix_weak_md5_hash": ValidatedPattern(
+        name="fix_weak_md5_hash",
+        pattern=r"\bhashlib\.md5\(",
+        replacement="hashlib.sha256(",
+        description="Replace weak MD5 hashing with SHA256",
+        global_replace=True,
+        test_cases=[
+            ("hashlib.md5(data)", "hashlib.sha256(data)"),
+            ("hash = hashlib.md5(content)", "hash = hashlib.sha256(content)"),
+            ("hashlib.sha256(data)", "hashlib.sha256(data)"),
+        ],
+    ),
+    "fix_weak_sha1_hash": ValidatedPattern(
+        name="fix_weak_sha1_hash",
+        pattern=r"\bhashlib\.sha1\(",
+        replacement="hashlib.sha256(",
+        description="Replace weak SHA1 hashing with SHA256",
+        global_replace=True,
+        test_cases=[
+            ("hashlib.sha1(data)", "hashlib.sha256(data)"),
+            ("hash = hashlib.sha1(content)", "hash = hashlib.sha256(content)"),
+            ("hashlib.sha256(data)", "hashlib.sha256(data)"),
+        ],
+    ),
+}

crackerjack/services/patterns/templates.py

@@ -0,0 +1,62 @@
+"""Template parsing and processing patterns."""
+
+import re
+
+from .core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "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",
+            ),
+        ],
+    ),
+}

crackerjack/services/patterns/testing/__init__.py

@@ -0,0 +1,18 @@
+"""Testing pattern modules.
+
+This package contains pattern collections for parsing and analyzing
+pytest test output and test error patterns.
+"""
+
+from ..core import ValidatedPattern
+from .error_patterns import PATTERNS as ERROR_PATTERNS
+from .pytest_output import PATTERNS as PYTEST_OUTPUT_PATTERNS
+
+# Merge all testing patterns into a single registry
+PATTERNS: dict[str, ValidatedPattern] = PYTEST_OUTPUT_PATTERNS | ERROR_PATTERNS
+
+__all__ = [
+    "PATTERNS",
+    "PYTEST_OUTPUT_PATTERNS",
+    "ERROR_PATTERNS",
+]

crackerjack/services/patterns/testing/error_patterns.py

@@ -0,0 +1,107 @@
+"""Test error pattern matching.
+
+This module contains patterns for identifying and parsing various error
+patterns in test failures, including assertions, imports, fixtures, and more.
+"""
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "fixture_not_found_pattern": ValidatedPattern(
+        name="fixture_not_found_pattern",
+        pattern=r"fixture '(\w+)' not found",
+        replacement=r"fixture '\1' not found",
+        test_cases=[
+            ("fixture 'temp_pkg_path' not found", "fixture 'temp_pkg_path' not found"),
+            ("fixture 'console' not found", "fixture 'console' not found"),
+            ("fixture 'tmp_path' not found", "fixture 'tmp_path' not found"),
+        ],
+        description="Match pytest fixture not found error patterns",
+    ),
+    "import_error_pattern": ValidatedPattern(
+        name="import_error_pattern",
+        pattern=r"ImportError|ModuleNotFoundError",
+        replacement=r"ImportError",
+        test_cases=[
+            ("ImportError: No module named", "ImportError: No module named"),
+            ("ModuleNotFoundError: No module", "ImportError: No module"),
+            ("Other error types", "Other error types"),
+        ],
+        description="Match import error patterns in test failures",
+    ),
+    "assertion_error_pattern": ValidatedPattern(
+        name="assertion_error_pattern",
+        pattern=r"assert .+ ==",
+        replacement=r"AssertionError",
+        test_cases=[
+            (
+                "AssertionError: Values differ",
+                "AssertionError: Values differ",
+            ),
+            ("assert result == expected", "AssertionError expected"),
+            ("Normal code", "Normal code"),
+        ],
+        description="Match assertion error patterns in test failures",
+    ),
+    "attribute_error_pattern": ValidatedPattern(
+        name="attribute_error_pattern",
+        pattern=r"AttributeError: .+ has no attribute",
+        replacement=r"AttributeError: has no attribute",
+        test_cases=[
+            (
+                "AttributeError: 'Mock' has no attribute 'test'",
+                "AttributeError: has no attribute 'test'",
+            ),
+            (
+                "AttributeError: 'NoneType' has no attribute 'value'",
+                "AttributeError: has no attribute 'value'",
+            ),
+            ("Normal error", "Normal error"),
+        ],
+        description="Match attribute error patterns in test failures",
+    ),
+    "mock_spec_error_pattern": ValidatedPattern(
+        name="mock_spec_error_pattern",
+        pattern=r"MockSpec|spec.*Mock",
+        replacement=r"MockSpec",
+        test_cases=[
+            ("MockSpec error occurred", "MockSpec error occurred"),
+            ("spec for Mock failed", "MockSpec failed"),
+            ("Normal mock usage", "Normal mock usage"),
+        ],
+        description="Match mock specification error patterns in test failures",
+    ),
+    "hardcoded_path_pattern": ValidatedPattern(
+        name="hardcoded_path_pattern",
+        pattern=r"'/test/path'|/test/path",
+        replacement=r"str(tmp_path)",
+        test_cases=[
+            ("'/test/path'", "str(tmp_path)"),
+            ("/test/path", "str(tmp_path)"),
+            ("'/other/path'", "'/other/path'"),
+        ],
+        description="Match hardcoded test path patterns that should use tmp_path",
+    ),
+    "missing_name_pattern": ValidatedPattern(
+        name="missing_name_pattern",
+        pattern=r"name '(\w+)' is not defined",
+        replacement=r"name '\1' is not defined",
+        test_cases=[
+            ("name 'pytest' is not defined", "name 'pytest' is not defined"),
+            ("name 'Mock' is not defined", "name 'Mock' is not defined"),
+            ("name 'Path' is not defined", "name 'Path' is not defined"),
+        ],
+        description="Match undefined name patterns in test failures",
+    ),
+    "pydantic_validation_pattern": ValidatedPattern(
+        name="pydantic_validation_pattern",
+        pattern=r"ValidationError|validation error",
+        replacement=r"ValidationError",
+        test_cases=[
+            ("ValidationError: field required", "ValidationError: field required"),
+            ("validation error in field", "ValidationError in field"),
+            ("Normal validation", "Normal validation"),
+        ],
+        description="Match Pydantic validation error patterns in test failures",
+    ),
+}

crackerjack/services/patterns/testing/pytest_output.py

@@ -0,0 +1,126 @@
+"""Pytest output parsing patterns.
+
+This module contains patterns for parsing pytest test output, including
+test collection, results, coverage, and session information.
+"""
+
+from ..core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "pytest_test_start": ValidatedPattern(
+        name="pytest_test_start",
+        pattern=r"^(.+?):: ?(.+?):: ?(.+?) (PASSED|FAILED|SKIPPED|ERROR)$",
+        replacement=r"\1::\2::\3",
+        description="Parse pytest test start line with file, class, and method "
+        "(3-part format)",
+        test_cases=[
+            (
+                "test_file.py::TestClass::test_method PASSED",
+                "test_file.py::TestClass::test_method",
+            ),
+            (
+                "tests/test_core.py::TestCore::test_function FAILED",
+                "tests/test_core.py::TestCore::test_function",
+            ),
+            (
+                "src/test.py::MyTest::test_case SKIPPED",
+                "src/test.py::MyTest::test_case",
+            ),
+        ],
+    ),
+    "pytest_test_result": ValidatedPattern(
+        name="pytest_test_result",
+        pattern=r"^(.+?) (PASSED|FAILED|SKIPPED|ERROR)(?: \[.*?\])?\s*$",
+        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"),
+            (
+                "tests/test_core.py::test_func FAILED [100%]",
+                "tests/test_core.py::test_func",
+            ),
+            ("src/test.py::test_case SKIPPED ", "src/test.py::test_case"),
+        ],
+    ),
+    "pytest_collection_count": ValidatedPattern(
+        name="pytest_collection_count",
+        pattern=r"collected (\d+) items?",
+        replacement=r"\1",
+        description="Parse pytest test collection count",
+        test_cases=[
+            ("collected 5 items", "5"),
+            ("collected 1 item", "1"),
+            (
+                "collected 42 items for execution",
+                "42 for execution",
+            ),
+        ],
+    ),
+    "pytest_session_start": ValidatedPattern(
+        name="pytest_session_start",
+        pattern=r"test session starts",
+        replacement=r"test session starts",
+        description="Match pytest session start indicator",
+        test_cases=[
+            ("test session starts", "test session starts"),
+            ("pytest test session starts", "pytest test session starts"),
+        ],
+    ),
+    "pytest_coverage_total": ValidatedPattern(
+        name="pytest_coverage_total",
+        pattern=r"TOTAL\s+\d+\s+\d+\s+(\d+)%",
+        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"),
+        ],
+    ),
+    "pytest_detailed_test": ValidatedPattern(
+        name="pytest_detailed_test",
+        pattern=r"^(.+\.py)::(.+) (PASSED|FAILED|SKIPPED|ERROR)",
+        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%]",
+            ),
+            (
+                "tests/core.py::TestClass::test_func FAILED [75%] [0.1s]",
+                "tests/core.py::TestClass::test_func [75%] [0.1s]",
+            ),
+            (
+                "src/test.py::test_case SKIPPED",
+                "src/test.py::test_case",
+            ),
+        ],
+    ),
+    "remove_coverage_fail_under": ValidatedPattern(
+        name="remove_coverage_fail_under",
+        pattern=r"--cov-fail-under=\d+\.?\d*\s*",
+        replacement="",
+        description="Remove coverage fail-under flags from pytest addopts",
+        global_replace=True,
+        test_cases=[
+            ("--cov-fail-under=85 --verbose", "--verbose"),
+            ("--cov-fail-under=90.5 -x", "-x"),
+            ("--verbose --cov-fail-under=80 ", "--verbose "),
+            ("--no-cov", "--no-cov"),
+        ],
+    ),
+    "update_coverage_requirement": ValidatedPattern(
+        name="update_coverage_requirement",
+        pattern=r"(--cov-fail-under=)\d+\.?\d*",
+        replacement=r"\1NEW_COVERAGE",
+        description="Update coverage fail-under requirement (NEW_COVERAGE placeholder"
+        " replaced dynamically)",
+        test_cases=[
+            ("--cov-fail-under=85", "--cov-fail-under=NEW_COVERAGE"),
+            ("--cov-fail-under=90.5", "--cov-fail-under=NEW_COVERAGE"),
+            ("--verbose", "--verbose"),
+        ],
+    ),
+}

crackerjack/services/patterns/tool_output/__init__.py

@@ -0,0 +1,16 @@
+"""Tool output parsing regex patterns.
+
+This package provides patterns for parsing output from various development tools
+including linters (ruff), type checkers (pyright, mypy), security scanners (bandit),
+dead code detectors (vulture), and complexity analyzers (complexipy).
+"""
+
+from .bandit import PATTERNS as BANDIT_PATTERNS
+from .other import PATTERNS as OTHER_PATTERNS
+from .pyright import PATTERNS as PYRIGHT_PATTERNS
+from .ruff import PATTERNS as RUFF_PATTERNS
+
+# Merge all tool output patterns into a single registry
+PATTERNS = RUFF_PATTERNS | PYRIGHT_PATTERNS | BANDIT_PATTERNS | OTHER_PATTERNS
+
+__all__ = ["PATTERNS"]

crackerjack/services/patterns/tool_output/bandit.py

@@ -0,0 +1,72 @@
+"""Bandit security scanner output parsing patterns.
+
+This module provides regex patterns for parsing Bandit security analysis tool output,
+including issue detection, location information, confidence, and severity levels.
+"""
+
+from ..core import ValidatedPattern
+
+PATTERNS = {
+    "bandit_confidence": ValidatedPattern(
+        name="bandit_confidence",
+        pattern=r"Confidence: (\w+)",
+        replacement=r"Confidence Level: \1",
+        description="Parse bandit confidence level for security issues",
+        test_cases=[
+            ("Confidence: HIGH", "Confidence Level: HIGH"),
+            ("Confidence: MEDIUM", "Confidence Level: MEDIUM"),
+            ("Confidence: LOW", "Confidence Level: LOW"),
+        ],
+    ),
+    "bandit_issue": ValidatedPattern(
+        name="bandit_issue",
+        pattern=r">> Issue: \[([A-Z]\d+): \w+\] (.+)",
+        replacement=r"Security Issue [\1]: \2",
+        description="Parse bandit security issue output with code and message",
+        test_cases=[
+            (
+                ">> Issue: [B602: shell_injection] Use of shell=True",
+                "Security Issue [B602]: Use of shell=True",
+            ),
+            (
+                ">> Issue: [B404: blacklist] Consider possible security implications",
+                "Security Issue [B404]: Consider possible security implications",
+            ),
+            (
+                ">> Issue: [B301: pickle] Pickle library detected",
+                "Security Issue [B301]: Pickle library detected",
+            ),
+        ],
+    ),
+    "bandit_location": ValidatedPattern(
+        name="bandit_location",
+        pattern=r"Location: (.+?): (\d+): (\d+)",
+        replacement=r"Location: File \1, Line \2, Column \3",
+        description="Parse bandit location information for security issues",
+        test_cases=[
+            (
+                "Location: src/main.py: 42: 10",
+                "Location: File src/main.py, Line 42, Column 10",
+            ),
+            (
+                "Location: /app/security.py: 123: 5",
+                "Location: File /app/security.py, Line 123, Column 5",
+            ),
+            (
+                "Location: crackerjack/core.py: 999: 80",
+                "Location: File crackerjack/core.py, Line 999, Column 80",
+            ),
+        ],
+    ),
+    "bandit_severity": ValidatedPattern(
+        name="bandit_severity",
+        pattern=r"Severity: (\w+)",
+        replacement=r"Severity Level: \1",
+        description="Parse bandit severity level for security issues",
+        test_cases=[
+            ("Severity: HIGH", "Severity Level: HIGH"),
+            ("Severity: MEDIUM", "Severity Level: MEDIUM"),
+            ("Severity: LOW", "Severity Level: LOW"),
+        ],
+    ),
+}