Simplified pattern matching

Author: 3coins

README.md

@@ -45,16 +45,16 @@ router.observe_chat_msg("room-id", on_regular_message)
 
 ### Command Pattern Matching
 
-The `observe_slash_cmd_msg` method supports flexible command pattern matching:
+The `observe_slash_cmd_msg` method supports regex pattern matching:
 
 ```python
 # Exact match: Only matches "/help"
 router.observe_slash_cmd_msg("room-id", "help", callback)
 
-# Wildcard match: Matches "/ai-generate", "/ai-review", etc.
-router.observe_slash_cmd_msg("room-id", "ai-*", callback)
+# Regex pattern: Matches "/ai-generate", "/ai-review", etc.
+router.observe_slash_cmd_msg("room-id", "ai-.*", callback)
 
-# Regex pattern: Matches "/export-json", "/export-csv", "/export-xml"
+# Regex with groups: Matches "/export-json", "/export-csv", "/export-xml"
 router.observe_slash_cmd_msg("room-id", r"export-(json|csv|xml)", callback)
 ```
 

jupyter_ai_router/router.py

@@ -21,6 +21,23 @@
 from .utils import get_first_word
 
 
+def matches_pattern(word: str, pattern: str) -> bool:
+    """
+    Check if a word matches a regex pattern.
+
+    Args:
+        word: The word to match (e.g., "help", "ai-generate")
+        pattern: The regex pattern to match against (e.g., "help", "ai-.*", "export-(json|csv)")
+
+    Returns:
+        True if the word matches the pattern
+    """
+    try:
+        return bool(re.match(f"^{pattern}$", word))
+    except re.error:
+        return False
+
+
 class MessageRouter(LoggingConfigurable):
     """
     Router that manages ychat message routing.
@@ -63,10 +80,11 @@ def observe_slash_cmd_msg(
 
         Args:
             room_id: The chat room ID
-            command_pattern: Command pattern to match (without leading slash). Supports:
+            command_pattern: Regex pattern to match commands (without leading slash).
+                Examples:
                 - Exact match: "help" matches "/help"
-                - Wildcard: "ai-*" matches "/ai-generate", "/ai-review", etc.
-                - Regex: Any valid Python regex pattern like "export-(json|csv)"
+                - Pattern match: "ai-.*" matches "/ai-generate", "/ai-review", etc.
+                - Multiple options: "export-(json|csv)" matches "/export-json", "/export-csv"
             callback: Function called with (room_id: str, command: str, message: Message) for matching commands
         """
         if room_id not in self.slash_cmd_observers:
@@ -171,63 +189,25 @@ def _route_message(self, room_id: str, message: Message) -> None:
             parts = message.body.split(None, 1)  # Split into max 2 parts
             command = parts[0] if parts else ""
             trimmed_body = parts[1] if len(parts) > 1 else ""
-            
+
             # Create a copy of the message with trimmed body (command removed)
             trimmed_message = replace(message, body=trimmed_body)
-            
+
             # Remove forward slash from command for cleaner API
             clean_command = command[1:] if command.startswith("/") else command
-            
+
             # Route to slash command observers
-            self._notify_slash_cmd_observers(room_id, trimmed_message, command, clean_command)
+            self._notify_slash_cmd_observers(room_id, trimmed_message, clean_command)
         else:
             self._notify_msg_observers(room_id, message)
 
-    def _command_matches(self, command: str, pattern: str) -> bool:
-        """
-        Check if a command matches a pattern.
-        
-        Args:
-            command: The actual command with slash (e.g., "/help")
-            pattern: The pattern to match against without slash (e.g., "help", "ai-*", regex)
-            
-        Returns:
-            True if the command matches the pattern
-        """
-        # Convert pattern to include slash for matching
-        # Pattern "help" should match command "/help"
-        if not pattern.startswith("/"):
-            full_pattern = "/" + pattern
-        else:
-            # Handle case where pattern accidentally includes slash
-            full_pattern = pattern
-            
-        # Exact match
-        if command == full_pattern:
-            return True
-            
-        # Wildcard pattern (convert to regex)
-        if "*" in full_pattern:
-            # Escape special regex chars except *, then convert * to .*
-            escaped_pattern = re.escape(full_pattern).replace(r"\*", ".*")
-            regex_pattern = f"^{escaped_pattern}$"
-            try:
-                return bool(re.match(regex_pattern, command))
-            except re.error:
-                return False
-        
-        # Try as regex pattern (add slash if not present)
-        try:
-            return bool(re.match(full_pattern, command))
-        except re.error:
-            return False
 
-    def _notify_slash_cmd_observers(self, room_id: str, message: Message, original_command: str, clean_command: str) -> None:
+    def _notify_slash_cmd_observers(self, room_id: str, message: Message, clean_command: str) -> None:
         """Notify observers registered for slash commands."""
         room_observers = self.slash_cmd_observers.get(room_id, {})
-        
+
         for registered_pattern, callbacks in room_observers.items():
-            if self._command_matches(original_command, registered_pattern):
+            if matches_pattern(clean_command, registered_pattern):
                 for callback in callbacks:
                     try:
                         callback(room_id, clean_command, message)

jupyter_ai_router/tests/test_message_router.py

@@ -6,7 +6,7 @@
 from unittest.mock import Mock, MagicMock
 from jupyterlab_chat.models import Message
 from jupyterlab_chat.ychat import YChat
-from jupyter_ai_router.router import MessageRouter
+from jupyter_ai_router.router import MessageRouter, matches_pattern
 from jupyter_ai_router.utils import get_first_word, is_persona
 
 
@@ -131,34 +131,27 @@ def test_cleanup(self):
         assert len(self.router.slash_cmd_observers) == 0
         assert len(self.router.chat_msg_observers) == 0
 
-    def test_observe_slash_cmd_patterns(self):
-        """Test registering specific slash command callback with patterns."""
-        room_id = "test-room"
-        command_pattern = "help"
-        self.router.observe_slash_cmd_msg(room_id, command_pattern, self.mock_specific_cmd_callback)
-        
-        assert command_pattern in self.router.slash_cmd_observers[room_id]
-        assert self.mock_specific_cmd_callback in self.router.slash_cmd_observers[room_id][command_pattern]
 
-    def test_command_matches_exact(self):
+    def test_matches_pattern_exact(self):
         """Test exact command matching."""
-        assert self.router._command_matches("/help", "help") is True
-        assert self.router._command_matches("/help", "status") is False
-
-    def test_command_matches_wildcard(self):
-        """Test wildcard command matching."""
-        assert self.router._command_matches("/ai-generate", "ai-*") is True
-        assert self.router._command_matches("/ai-review", "ai-*") is True
-        assert self.router._command_matches("/help", "ai-*") is False
-        assert self.router._command_matches("/export-csv", "export-*") is True
-
-    def test_command_matches_regex(self):
-        """Test regex command matching."""
+        assert matches_pattern("help", "help") is True
+        assert matches_pattern("help", "status") is False
+
+    def test_matches_pattern_regex(self):
+        """Test regex pattern matching."""
+        # Pattern with .* (formerly wildcard)
+        assert matches_pattern("ai-generate", "ai-.*") is True
+        assert matches_pattern("ai-review", "ai-.*") is True
+        assert matches_pattern("help", "ai-.*") is False
+        assert matches_pattern("export-csv", "export-.*") is True
+
+    def test_matches_pattern_regex_groups(self):
+        """Test regex command matching with groups."""
         pattern = r"export-(json|csv|xml)"
-        assert self.router._command_matches("/export-json", pattern) is True
-        assert self.router._command_matches("/export-csv", pattern) is True
-        assert self.router._command_matches("/export-xml", pattern) is True
-        assert self.router._command_matches("/export-pdf", pattern) is False
+        assert matches_pattern("export-json", pattern) is True
+        assert matches_pattern("export-csv", pattern) is True
+        assert matches_pattern("export-xml", pattern) is True
+        assert matches_pattern("export-pdf", pattern) is False
 
     def test_specific_command_routing_exact(self):
         """Test routing of specific slash commands with exact match."""
@@ -183,10 +176,10 @@ def test_specific_command_routing_exact(self):
         self.router._route_message(room_id, status_msg)
         self.mock_specific_cmd_callback.assert_not_called()
 
-    def test_specific_command_routing_wildcard(self):
-        """Test routing of specific slash commands with wildcard pattern."""
+    def test_specific_command_routing_regex(self):
+        """Test routing of specific slash commands with regex pattern."""
         room_id = "test-room"
-        self.router.observe_slash_cmd_msg(room_id, "ai-*", self.mock_specific_cmd_callback)
+        self.router.observe_slash_cmd_msg(room_id, "ai-.*", self.mock_specific_cmd_callback)
 
         # Test matching commands
         generate_msg = Message(id="1", body="/ai-generate code", sender="user", time=123)
@@ -267,7 +260,7 @@ def test_multiple_patterns_different_commands(self):
         export_callback = Mock()
 
         self.router.observe_slash_cmd_msg(room_id, "help", help_callback)
-        self.router.observe_slash_cmd_msg(room_id, "export-*", export_callback)
+        self.router.observe_slash_cmd_msg(room_id, "export-.*", export_callback)
 
         help_msg = Message(id="1", body="/help topic", sender="user", time=123)
         self.router._route_message(room_id, help_msg)
@@ -304,7 +297,7 @@ def test_specific_command_error_handling(self):
     def test_invalid_regex_pattern(self):
         """Test handling of invalid regex patterns."""
         # Invalid regex should not match anything
-        assert self.router._command_matches("/help", "[invalid") is False
+        assert matches_pattern("help", "[invalid") is False
 
     def test_message_trimming_and_command_cleaning(self):
         """Test that messages are properly trimmed and commands cleaned."""