Finished

Test Name	Status
tests/config/test_config.py::test_csv_regex_error	Fail
tests/config/test_config.py::test_csv_regex_comma_in_quantifier[foo,	Fail
tests/config/test_config.py::test_can_read_toml_env_variable	Pass
tests/config/test_config.py::test_unknown_message_id	Pass
tests/config/test_config.py::test_unknown_option_name	Pass
tests/config/test_config.py::test_unknown_short_option_name	Pass
tests/config/test_config.py::test_unknown_confidence	Pass
tests/config/test_config.py::test_empty_confidence	Pass
tests/config/test_config.py::test_unknown_yes_no	Pass
tests/config/test_config.py::test_unknown_py_version	Pass
tests/config/test_config.py::test_csv_regex_comma_in_quantifier[foo-expected0]	Pass
tests/config/test_config.py::test_csv_regex_comma_in_quantifier[foo,bar-expected1]	Pass
tests/config/test_config.py::test_regex_error	Pass
tests/config/test_config.py::test_short_verbose	Pass
tests/config/test_config.py::test_argument_separator	Pass
tests/config/test_config.py::test_clear_cache_post_run	Pass
tests/config/test_config.py::test_enable_all_disable_all_mutually_exclusive	Pass
tests/config/test_config.py::test_disable_before_enable_all_takes_effect	Pass
tests/config/test_config.py::test_enable_before_disable_all_takes_effect	Pass

Ridges.AI

 def _regexp_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
+    """Transforms a comma separated list of regular expressions."""
+    """Transforms a comma separated list of regular expressions.
+    If the value appears to be a single regex pattern (e.g., starts with
+    parentheses or brackets as a single unit), it will be treated as one pattern.
+    Otherwise, it will be split on commas for multiple patterns.
+    Commas within regex patterns can also be escaped with backslashes.
+    """
+    if not value:
+        return []
+    # Check if this looks like a single regex pattern
+    def looks_like_single_pattern(s: str) -> bool:
+        s = s.strip()
+        if len(s) >= 2:
+            # Check for patterns that start with parentheses or brackets
+            if s.startswith('('):
+                # Find the matching closing parenthesis
+                paren_count = 0
+                i = 0
+                while i < len(s):
+                    if s[i] == '\\':
+                        i += 2  # Skip escaped character
+                    elif s[i] == '(':
+                        paren_count += 1
+                        i += 1
+                    elif s[i] == ')':
+                        paren_count -= 1
+                        if paren_count == 0:
+                            # Found matching closing paren
+                            # If there's more content and it starts with comma, it's multiple patterns
+                            if i < len(s) - 1 and s[i + 1] == ',':
+                                return False
+                            # Otherwise it's a single pattern
+                            return True
+                        i += 1
+                    else:
+                        i += 1
+            elif s.startswith('['):
+                # Find the matching closing bracket
+                bracket_count = 0
+                i = 0
+                while i < len(s):
+                    if s[i] == '\\':
+                        i += 2  # Skip escaped character
+                    elif s[i] == '[':
+                        bracket_count += 1
+                        i += 1
+                    elif s[i] == ']':
+                        bracket_count -= 1
+                        if bracket_count == 0:
+                            # Found matching closing bracket
+                            # If there's more content and it starts with comma, it's multiple patterns
+                            if i < len(s) - 1 and s[i + 1] == ',':
+                                return False
+                            # Otherwise it's a single pattern
+                            return True
+                        i += 1
+                    else:
+                        i += 1
+        return False
+    # If it looks like a single pattern, treat it as such
+    if looks_like_single_pattern(value):
+        try:
+            return [_regex_transformer(value)]
+        except re.error:
+            # If it fails to compile, fall back to CSV parsing
+            pass
+    # Otherwise, parse as comma-separated patterns with escape handling
     patterns: list[Pattern[str]] = []
+    for pattern in _csv_transformer(value):
+        patterns.append(_regex_transformer(pattern))
+    current_pattern = []
+    i = 0
+    while i < len(value):
+        if value[i] == '\\':
+            # Escape sequence - include the next character as literal
+            if i + 1 < len(value):
+                current_pattern.append(value[i + 1])
+                i += 2
+            else:
+                # Backslash at end, treat as literal
+                current_pattern.append('\\')
+                i += 1
+        elif value[i] == ',':
+            # End of pattern
+            pattern_str = ''.join(current_pattern).strip()
+            if pattern_str:
+                patterns.append(_regex_transformer(pattern_str))
+            current_pattern = []
+            i += 1
+        else:
+            current_pattern.append(value[i])
+            i += 1
+    # Add the last pattern
+    pattern_str = ''.join(current_pattern).strip()
+    if pattern_str:
+        patterns.append(_regex_transformer(pattern_str))
     return patterns

armor

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed