Add regex pattern support for error detection

This commit extends the error detection system with regex pattern matching,
enabling complex error patterns with variable parts (URLs, IPs, hostnames).

Changes:
- Add regex_matches section to errors.yaml
  - DNS lookup errors: 'dial tcp:.*no such host'
  - Connection refused errors
  - Timeout errors (context deadline, i/o timeout, net/http timeout)
  - Handles user's example: Get "https://fred.brew.sh/...": dial tcp: lookup fred.brew.sh on 8.8.8.8:53: no such host

- Update ErrorDetector class
  - Add regex_patterns list to store compiled regex objects
  - Compile patterns with re.IGNORECASE flag for case-insensitive matching
  - Check messages against regex patterns in is_error() method
  - Update extract_error_info() to return pattern_type ("fuzzy", "exact", or "regex")

- Extend test suite with regex pattern tests
  - Test regex pattern loading and compilation
  - Test DNS lookup error detection (user's example)
  - Test connection refused errors
  - Test timeout errors
  - Test case-insensitive regex matching
  - Test error info extraction with pattern_type

Now supports three pattern types:
- Fuzzy: Fast substring matching for simple patterns
- Exact: Precise prefix/exact matching
- Regex: Flexible pattern matching for complex errors with variable parts

Tested with user's DNS error example - successfully detected!

Author: claude

pystackql/core/error_detector.py

@@ -8,6 +8,7 @@
 """
 
 import os
+import re
 import yaml
 
 
@@ -22,6 +23,7 @@ def __init__(self):
         """Initialize the ErrorDetector by loading error patterns from errors.yaml."""
         self.fuzzy_patterns = []
         self.exact_patterns = []
+        self.regex_patterns = []  # List of compiled regex pattern objects
         self._load_error_patterns()
 
     def _load_error_patterns(self):
@@ -57,6 +59,18 @@ def _load_error_patterns(self):
                             for pattern in errors['exact_matches']
                             if pattern
                         ]
+
+                    # Load regex patterns (compile them for efficiency)
+                    if 'regex_matches' in errors:
+                        self.regex_patterns = []
+                        for pattern in errors['regex_matches']:
+                            if pattern:
+                                try:
+                                    # Compile with IGNORECASE flag for case-insensitive matching
+                                    compiled = re.compile(pattern, re.IGNORECASE)
+                                    self.regex_patterns.append((pattern, compiled))
+                                except re.error as regex_err:
+                                    print(f"Warning: Invalid regex pattern '{pattern}': {regex_err}")
         except Exception as e:
             # If we can't load the error patterns, continue with empty lists
             # This ensures the module doesn't break existing functionality
@@ -86,6 +100,11 @@ def is_error(self, message):
             if message == pattern or message.startswith(pattern):
                 return True
 
+        # Check regex matches
+        for pattern_str, compiled_pattern in self.regex_patterns:
+            if compiled_pattern.search(message):
+                return True
+
         return False
 
     def extract_error_info(self, message):
@@ -102,20 +121,31 @@ def extract_error_info(self, message):
 
         message_lower = message.lower()
         detected_pattern = None
+        pattern_type = None
 
-        # Find which pattern was matched
+        # Find which pattern was matched (check in order: fuzzy, exact, regex)
         for pattern in self.fuzzy_patterns:
             if pattern in message_lower:
                 detected_pattern = pattern
+                pattern_type = "fuzzy"
                 break
 
         if not detected_pattern:
             for pattern in self.exact_patterns:
                 if message == pattern or message.startswith(pattern):
                     detected_pattern = pattern
+                    pattern_type = "exact"
+                    break
+
+        if not detected_pattern:
+            for pattern_str, compiled_pattern in self.regex_patterns:
+                if compiled_pattern.search(message):
+                    detected_pattern = pattern_str
+                    pattern_type = "regex"
                     break
 
         return {
             "error": message,
-            "detected_pattern": detected_pattern
+            "detected_pattern": detected_pattern,
+            "pattern_type": pattern_type
         }

pystackql/errors.yaml

@@ -7,6 +7,7 @@
 # Pattern Types:
 # - fuzzy_matches: Substring matching (case-insensitive)
 # - exact_matches: Exact string matching (case-sensitive)
+# - regex_matches: Regular expression matching (for complex patterns with variable parts)
 
 errors:
   # Fuzzy matches - will match if the pattern appears anywhere in the message
@@ -30,3 +31,22 @@ errors:
     - "Error:"
     - "FAILED"
     - "FAILURE"
+
+  # Regex matches - regular expressions for complex error patterns
+  # Use standard Python regex syntax (case-insensitive by default)
+  regex_matches:
+    # Network/DNS errors
+    - 'dial tcp:.*no such host'
+    - 'Get ".*".*dial tcp.*lookup.*no such host'
+
+    # Connection errors
+    - 'dial tcp.*connection refused'
+    - 'unable to connect to.*connection refused'
+
+    # Timeout errors
+    - 'context deadline exceeded'
+    - 'timeout.*waiting for'
+
+    # Generic network errors
+    - 'dial tcp.*i/o timeout'
+    - 'net/http.*timeout'

tests/test_error_detection.py

@@ -125,6 +125,70 @@ def test_non_string_handling(self):
         assert not self.detector.is_error([])
         assert not self.detector.is_error({})
 
+    def test_regex_pattern_loading(self):
+        """Test that regex patterns are loaded and compiled."""
+        assert len(self.detector.regex_patterns) > 0
+        # Check that patterns are tuples of (pattern_str, compiled_regex)
+        for item in self.detector.regex_patterns:
+            assert isinstance(item, tuple)
+            assert len(item) == 2
+            pattern_str, compiled = item
+            assert isinstance(pattern_str, str)
+            # Check it's a compiled regex
+            assert hasattr(compiled, 'search')
+
+    def test_regex_dns_error_detection(self):
+        """Test detection of DNS lookup errors using regex."""
+        messages = [
+            'Get "https://fred.brew.sh/api/formula/stackql.json?": dial tcp: lookup fred.brew.sh on 8.8.8.8:53: no such host',
+            'dial tcp: lookup example.com on 1.1.1.1:53: no such host',
+            'Get "http://api.example.com": dial tcp: lookup api.example.com on 192.168.1.1:53: no such host',
+        ]
+        for msg in messages:
+            assert self.detector.is_error(msg), f"Should detect DNS error in: {msg}"
+
+    def test_regex_connection_refused(self):
+        """Test detection of connection refused errors using regex."""
+        messages = [
+            'dial tcp 192.168.1.1:5432: connection refused',
+            'dial tcp [::1]:8080: connection refused',
+            'unable to connect to server: connection refused',
+        ]
+        for msg in messages:
+            assert self.detector.is_error(msg), f"Should detect connection error in: {msg}"
+
+    def test_regex_timeout_errors(self):
+        """Test detection of timeout errors using regex."""
+        messages = [
+            'context deadline exceeded',
+            'dial tcp 10.0.0.1:443: i/o timeout',
+            'net/http: request canceled while waiting for connection (Client.Timeout exceeded)',
+            'timeout while waiting for response',
+        ]
+        for msg in messages:
+            assert self.detector.is_error(msg), f"Should detect timeout error in: {msg}"
+
+    def test_regex_case_insensitive(self):
+        """Test that regex matching is case-insensitive."""
+        messages = [
+            'DIAL TCP: NO SUCH HOST',
+            'Context Deadline Exceeded',
+            'Connection Refused',
+        ]
+        for msg in messages:
+            assert self.detector.is_error(msg), f"Should detect error (case-insensitive) in: {msg}"
+
+    def test_extract_error_info_with_regex(self):
+        """Test error info extraction for regex matches."""
+        msg = 'Get "https://example.com": dial tcp: lookup example.com on 8.8.8.8:53: no such host'
+        info = self.detector.extract_error_info(msg)
+        assert info is not None
+        assert info["error"] == msg
+        assert info["pattern_type"] == "regex"
+        assert info["detected_pattern"] is not None
+        # Should match one of the DNS error patterns
+        assert "no such host" in info["detected_pattern"]
+
 
 class TestOutputFormatterErrorDetection:
     """Tests for error detection integration in OutputFormatter."""