pomera-ai-commander 0.1.0

package/core/regex_pattern_library.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""
+Regex Pattern Library Module
+
+This module provides the 20 regex use cases extracted
+
+Usage:
+    from regex_pattern_library import RegexPatternLibrary
+    
+    library = RegexPatternLibrary()
+    patterns = library.get_all_patterns()
+    validation_patterns = library.get_patterns_by_category("validation")
+"""
+
+import json
+import os
+from typing import List, Dict, Optional
+
+class RegexPatternLibrary:
+    """
+    A comprehensive library of regex patterns for common text processing tasks.
+    Based on the 20 use cases from the RegexUseCases.md document.
+    """
+    
+    def __init__(self):
+        self.patterns = self._get_default_patterns()
+    
+    def _get_default_patterns(self) -> List[Dict[str, str]]:
+        """
+        Returns the complete list of 20 regex patterns organized by category.
+        """
+        return [
+            # Data Validation Patterns (8 patterns)
+            {
+                "find": r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$",
+                "replace": "[EMAIL]",
+                "purpose": "Email Address Validation - Validates standard email format",
+                "category": "validation",
+                "example_input": "user@example.com",
+                "example_output": "[EMAIL]"
+            },
+            {
+                "find": r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$",
+                "replace": "[STRONG_PASSWORD]",
+                "purpose": "Password Strength - Min 8 chars, uppercase, lowercase, digit, special char",
+                "category": "validation",
+                "example_input": "MyPass123!",
+                "example_output": "[STRONG_PASSWORD]"
+            },
+            {
+                "find": r"^\(?(\d{3})\)?[-.\s]?(\d{3})[-.\s]?(\d{4})$",
+                "replace": r"(\1) \2-\3",
+                "purpose": "North American Phone Number - Validates and formats 10-digit phone numbers",
+                "category": "validation",
+                "example_input": "123-456-7890",
+                "example_output": "(123) 456-7890"
+            },
+            {
+                "find": r"^https?:\/\/(?:www\.)?[-a-zA-Z0-9@:%.\_\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$",
+                "replace": "[URL]",
+                "purpose": "URL Structure Validation - Validates HTTP/HTTPS URLs",
+                "category": "validation",
+                "example_input": "https://www.example.com/path",
+                "example_output": "[URL]"
+            },
+            {
+                "find": r"^[a-zA-Z0-9]([._-](?![._-])|[a-zA-Z0-9]){3,18}[a-zA-Z0-9]$",
+                "replace": "[USERNAME]",
+                "purpose": "Username Format - 5-20 chars, alphanumeric start/end, no consecutive special chars",
+                "category": "validation",
+                "example_input": "user_name123",
+                "example_output": "[USERNAME]"
+            },
+            {
+                "find": r"^((25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)$",
+                "replace": "[IP_ADDRESS]",
+                "purpose": "IPv4 Address Validation - Validates IP addresses (0-255 per octet)",
+                "category": "validation",
+                "example_input": "192.168.1.1",
+                "example_output": "[IP_ADDRESS]"
+            },
+            {
+                "find": r"^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$",
+                "replace": "[DATE]",
+                "purpose": "YYYY-MM-DD Date Format - Validates ISO date format",
+                "category": "validation",
+                "example_input": "2024-12-25",
+                "example_output": "[DATE]"
+            },
+            {
+                "find": r"^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|3[47][0-9]{13})$",
+                "replace": "[CREDIT_CARD]",
+                "purpose": "Credit Card Number - Identifies Visa, Mastercard, American Express formats",
+                "category": "validation",
+                "example_input": "4111111111111111",
+                "example_output": "[CREDIT_CARD]"
+            },
+            
+            # Information Extraction Patterns (7 patterns)
+            {
+                "find": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
+                "replace": "[EMAIL]",
+                "purpose": "Extract All Email Addresses - Finds emails anywhere in text",
+                "category": "extraction",
+                "example_input": "Contact us at support@example.com for help",
+                "example_output": "Contact us at [EMAIL] for help"
+            },
+            {
+                "find": r"https?:\/\/[^\s/$.?#].[^\s]*",
+                "replace": "[URL]",
+                "purpose": "Extract All URLs - Finds HTTP/HTTPS URLs in text",
+                "category": "extraction",
+                "example_input": "Visit https://example.com for more info",
+                "example_output": "Visit [URL] for more info"
+            },
+            {
+                "find": r"(?<=\s|^)#(\w+)",
+                "replace": "#[HASHTAG]",
+                "purpose": "Extract Hashtags - Finds social media hashtags",
+                "category": "extraction",
+                "example_input": "Love this #python tutorial!",
+                "example_output": "Love this #[HASHTAG] tutorial!"
+            },
+            {
+                "find": r"(?<=\s|^)@(\w{1,15})\b",
+                "replace": "@[MENTION]",
+                "purpose": "Extract @Mentions - Finds social media mentions (1-15 chars)",
+                "category": "extraction",
+                "example_input": "Thanks @john for the help!",
+                "example_output": "Thanks @[MENTION] for the help!"
+            },
+            {
+                "find": r"^(?P<ip>[\d.]+) (?P<identd>\S+) (?P<user>\S+) \[(?P<timestamp>.*?)\] \"(?P<request>.*?)\" (?P<status_code>\d{3}) (?P<size>\d+|-).*$",
+                "replace": "[LOG_ENTRY]",
+                "purpose": "Log File Parsing - Parses Apache/Nginx log entries with named groups",
+                "category": "extraction",
+                "example_input": '127.0.0.1 - - [10/Oct/2023:13:55:36 +0000] "GET /index.html HTTP/1.1" 200 42',
+                "example_output": "[LOG_ENTRY]"
+            },
+            {
+                "find": r'(?:^|,)("(?:[^"]|"")*"|[^,]*)',
+                "replace": "[CSV_FIELD]",
+                "purpose": "Simple CSV Parsing - Handles quoted fields with commas",
+                "category": "extraction",
+                "example_input": 'field1,"field,2",field3',
+                "example_output": "[CSV_FIELD][CSV_FIELD][CSV_FIELD]"
+            },
+            {
+                "find": r"<h1.*?>(.*?)<\/h1>",
+                "replace": r"\1",
+                "purpose": "HTML Tag Content - Extracts content from H1 tags",
+                "category": "extraction",
+                "example_input": '<h1 class="title">Welcome</h1>',
+                "example_output": "Welcome"
+            },
+            
+            # Text Cleaning Patterns (5 patterns)
+            {
+                "find": r"<[^<]+?>",
+                "replace": "",
+                "purpose": "Strip HTML Tags - Removes all HTML tags from text",
+                "category": "cleaning",
+                "example_input": "<p>This is <b>bold</b> text.</p>",
+                "example_output": "This is bold text."
+            },
+            {
+                "find": r"\b(\w+)\s+\1\b",
+                "replace": r"\1",
+                "purpose": "Remove Duplicate Words - Removes consecutive duplicate words",
+                "category": "cleaning",
+                "example_input": "This is is a test",
+                "example_output": "This is a test"
+            },
+            {
+                "find": r"^\s+|\s+$",
+                "replace": "",
+                "purpose": "Trim Whitespace - Removes leading and trailing whitespace",
+                "category": "cleaning",
+                "example_input": "   text with spaces   ",
+                "example_output": "text with spaces"
+            },
+            {
+                "find": r"^\(?(\d{3})\)?[-.\s]?(\d{3})[-.\s]?(\d{4})$",
+                "replace": r"\1-\2-\3",
+                "purpose": "Normalize Phone Numbers - Converts to XXX-XXX-XXXX format",
+                "category": "cleaning",
+                "example_input": "(123) 456.7890",
+                "example_output": "123-456-7890"
+            },
+            {
+                "find": r"\b(\d{4}[- ]?){3}(\d{4})\b",
+                "replace": r"XXXX-XXXX-XXXX-\2",
+                "purpose": "Mask Sensitive Data - Masks credit card numbers, shows last 4 digits",
+                "category": "cleaning",
+                "example_input": "4111-1111-1111-1111",
+                "example_output": "XXXX-XXXX-XXXX-1111"
+            }
+        ]
+    
+    def get_all_patterns(self) -> List[Dict[str, str]]:
+        """Returns all patterns in the library."""
+        return self.patterns
+    
+    def get_patterns_by_category(self, category: str) -> List[Dict[str, str]]:
+        """
+        Returns patterns filtered by category.
+        
+        Args:
+            category: One of 'validation', 'extraction', 'cleaning'
+        """
+        return [p for p in self.patterns if p.get('category') == category]
+    
+    def get_pattern_by_purpose(self, purpose_keyword: str) -> List[Dict[str, str]]:
+        """
+        Returns patterns that match a purpose keyword.
+        
+        Args:
+            purpose_keyword: Keyword to search for in pattern purposes
+        """
+        return [p for p in self.patterns if purpose_keyword.lower() in p.get('purpose', '').lower()]
+    
+    def get_validation_patterns(self) -> List[Dict[str, str]]:
+        """Returns all validation patterns."""
+        return self.get_patterns_by_category('validation')
+    
+    def get_extraction_patterns(self) -> List[Dict[str, str]]:
+        """Returns all extraction patterns."""
+        return self.get_patterns_by_category('extraction')
+    
+    def get_cleaning_patterns(self) -> List[Dict[str, str]]:
+        """Returns all cleaning patterns."""
+        return self.get_patterns_by_category('cleaning')
+    
+    def update_settings_file(self, settings_file: str = "settings.json") -> bool:
+        """
+        Updates the settings.json file with the pattern library.
+        Only updates if the pattern library is empty or has fewer than 10 patterns.
+        
+        Args:
+            settings_file: Path to the settings.json file
+            
+        Returns:
+            bool: True if updated, False if no update was needed
+        """
+        try:
+            # Check if settings.json exists
+            if not os.path.exists(settings_file):
+                print(f"{settings_file} not found. Creating new file with pattern library.")
+                settings = {"pattern_library": self._convert_to_settings_format()}
+            else:
+                # Load existing settings
+                with open(settings_file, 'r', encoding='utf-8') as f:
+                    settings = json.load(f)
+                    
+            # Check if pattern_library exists and if it needs updating
+            if "pattern_library" not in settings:
+                print("No pattern_library found. Adding complete pattern library.")
+                settings["pattern_library"] = self._convert_to_settings_format()
+            else:
+                current_patterns = settings["pattern_library"]
+                if len(current_patterns) < 10:
+                    print(f"Pattern library has only {len(current_patterns)} patterns. Updating with complete library.")
+                    settings["pattern_library"] = self._convert_to_settings_format()
+                else:
+                    print(f"Pattern library already has {len(current_patterns)} patterns. No update needed.")
+                    return False
+            
+            # Save updated settings
+            with open(settings_file, 'w', encoding='utf-8') as f:
+                json.dump(settings, f, indent=4, ensure_ascii=False)
+            print(f"Successfully updated {settings_file} with {len(settings['pattern_library'])} regex patterns.")
+            return True
+            
+        except Exception as e:
+            print(f"Error updating settings file: {e}")
+            return False
+    
+    def _convert_to_settings_format(self) -> List[Dict[str, str]]:
+        """
+        Converts the internal pattern format to the settings.json format.
+        """
+        return [
+            {
+                "find": pattern["find"],
+                "replace": pattern["replace"],
+                "purpose": pattern["purpose"]
+            }
+            for pattern in self.patterns
+        ]
+    
+    def get_pattern_categories(self) -> List[str]:
+        """Returns a list of all available categories."""
+        categories = set()
+        for pattern in self.patterns:
+            if 'category' in pattern:
+                categories.add(pattern['category'])
+        return sorted(list(categories))
+    
+    def search_patterns(self, query: str) -> List[Dict[str, str]]:
+        """
+        Searches patterns by query string in purpose or find pattern.
+        
+        Args:
+            query: Search query
+            
+        Returns:
+            List of matching patterns
+        """
+        query = query.lower()
+        results = []
+        
+        for pattern in self.patterns:
+            if (query in pattern.get('purpose', '').lower() or 
+                query in pattern.get('find', '').lower()):
+                results.append(pattern)
+                
+        return results
+
+# Convenience functions for direct use
+def get_all_regex_patterns() -> List[Dict[str, str]]:
+    """Returns all 20 regex patterns from the library."""
+    library = RegexPatternLibrary()
+    return library.get_all_patterns()
+
+def update_pattern_library_in_settings(settings_file: str = "settings.json") -> bool:
+    """
+    Updates the pattern library in settings.json if needed.
+    
+    Args:
+        settings_file: Path to settings file
+        
+    Returns:
+        bool: True if updated, False if no update needed
+    """
+    library = RegexPatternLibrary()
+    return library.update_settings_file(settings_file)
+
+if __name__ == "__main__":
+    # Demo usage
+    library = RegexPatternLibrary()
+    
+    print("=== Regex Pattern Library Demo ===")
+    print(f"Total patterns: {len(library.get_all_patterns())}")
+    print(f"Categories: {', '.join(library.get_pattern_categories())}")
+    
+    print("\n=== Validation Patterns ===")
+    for pattern in library.get_validation_patterns():
+        print(f"- {pattern['purpose']}")
+    
+    print("\n=== Updating settings.json ===")
+    library.update_settings_file()