Updates slash cmd to observers to filter on specific commands

Author: 3coins

.gitignore

@@ -123,3 +123,6 @@ dmypy.json
 
 # Yarn cache
 .yarn/
+
+# For local testing
+playground/

jupyter_ai_router/router.py

@@ -9,6 +9,8 @@
 
 from typing import Any, Callable, Dict, List, TYPE_CHECKING
 from functools import partial
+import re
+from dataclasses import replace
 from jupyterlab_chat.models import Message
 from pycrdt import ArrayEvent
 from traitlets.config import LoggingConfigurable
@@ -34,7 +36,7 @@ def __init__(self, *args, **kwargs):
 
         # Callback lists
         self.chat_init_observers: List[Callable[[str, "YChat"], Any]] = []
-        self.slash_cmd_observers: Dict[str, List[Callable[[str, Message], Any]]] = {}
+        self.slash_cmd_observers: Dict[str, Dict[str, List[Callable[[str, str, Message], Any]]]] = {}
         self.chat_msg_observers: Dict[str, List[Callable[[str, Message], Any]]] = {}
 
         # Active chat rooms
@@ -54,19 +56,27 @@ def observe_chat_init(self, callback: Callable[[str, "YChat"], Any]) -> None:
         self.log.info("Registered new chat initialization callback")
 
     def observe_slash_cmd_msg(
-        self, room_id: str, callback: Callable[[str, Message], Any]
+        self, room_id: str, command_pattern: str, callback: Callable[[str, str, Message], Any]
     ) -> None:
         """
-        Register a callback for when slash commands are received.
+        Register a callback for when specific slash commands are received.
 
         Args:
-            callback: Function called with (room_id: str, message: Message) for slash commands
+            room_id: The chat room ID
+            command_pattern: Command pattern to match (without leading slash). Supports:
+                - Exact match: "help" matches "/help"
+                - Wildcard: "ai-*" matches "/ai-generate", "/ai-review", etc.
+                - Regex: Any valid Python regex pattern like "export-(json|csv)"
+            callback: Function called with (room_id: str, command: str, message: Message) for matching commands
         """
         if room_id not in self.slash_cmd_observers:
-            self.slash_cmd_observers[room_id] = []
+            self.slash_cmd_observers[room_id] = {}
+        
+        if command_pattern not in self.slash_cmd_observers[room_id]:
+            self.slash_cmd_observers[room_id][command_pattern] = []
 
-        self.slash_cmd_observers[room_id].append(callback)
-        self.log.info("Registered slash command callback")
+        self.slash_cmd_observers[room_id][command_pattern].append(callback)
+        self.log.info(f"Registered slash command callback for pattern: {command_pattern}")
 
     def observe_chat_msg(
         self, room_id: str, callback: Callable[[str, Message], Any]
@@ -157,10 +167,73 @@ def _route_message(self, room_id: str, message: Message) -> None:
 
         # Check if it's a slash command
         if first_word and first_word.startswith("/"):
-            self._notify_slash_cmd_observers(room_id, message)
+            # Extract command and create trimmed message
+            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)
         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:
+        """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):
+                for callback in callbacks:
+                    try:
+                        callback(room_id, clean_command, message)
+                    except Exception as e:
+                        self.log.error(f"Slash command observer error for pattern '{registered_pattern}': {e}")
+
     def _notify_chat_init_observers(self, room_id: str, ychat: "YChat") -> None:
         """Notify all new chat observers."""
         for callback in self.chat_init_observers:
@@ -169,15 +242,6 @@ def _notify_chat_init_observers(self, room_id: str, ychat: "YChat") -> None:
             except Exception as e:
                 self.log.error(f"New chat observer error for {room_id}: {e}")
 
-    def _notify_slash_cmd_observers(self, room_id: str, message: Message) -> None:
-        """Notify all slash command observers."""
-        callbacks = self.slash_cmd_observers.get(room_id, [])
-        for callback in callbacks:
-            try:
-                callback(room_id, message)
-            except Exception as e:
-                self.log.error(f"Slash command observer error for {room_id}: {e}")
-
     def _notify_msg_observers(self, room_id: str, message: Message) -> None:
         """Notify all message observers."""
         callbacks = self.chat_msg_observers.get(room_id, [])