feat: Proactive contributor assistance with lightweight pattern detection

backend/app/classification/classification_router.py

@@ -7,6 +7,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 class ClassificationRouter:
     """Simple DevRel triage - determines if message needs DevRel assistance"""
 
@@ -17,20 +18,87 @@ def __init__(self, llm_client=None):
             google_api_key=settings.gemini_api_key
         )
 
-    async def should_process_message(self, message: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
+    # 🔥 NEW: Proactive lightweight pattern detection
+    def _simple_pattern_match(self, message: str):
+        """
+        Lightweight proactive detection before calling LLM.
+        Returns classification dict if matched, else None.
+        """
+
+        msg = message.lower().strip()
+
+        greetings = ["hi", "hello", "hey"]
+        thanks = ["thanks", "thank you"]
+        onboarding_keywords = ["new here", "how to start", "beginner", "first time"]
+        issue_keywords = ["good first issue", "beginner issue", "start contributing"]
+
+        if msg in greetings:
+            return {
+                "needs_devrel": True,
+                "priority": "low",
+                "reasoning": "Greeting detected - proactive onboarding opportunity",
+                "original_message": message,
+                "proactive_type": "greeting"
+            }
+
+        if any(k in msg for k in onboarding_keywords):
+            return {
+                "needs_devrel": True,
+                "priority": "high",
+                "reasoning": "Onboarding request detected",
+                "original_message": message,
+                "proactive_type": "onboarding"
+            }
+
+        if any(k in msg for k in issue_keywords):
+            return {
+                "needs_devrel": True,
+                "priority": "medium",
+                "reasoning": "Contributor looking for issues",
+                "original_message": message,
+                "proactive_type": "issue_suggestion"
+            }
+
+        if any(t in msg for t in thanks):
+            return {
+                "needs_devrel": False,
+                "priority": "low",
+                "reasoning": "Acknowledgment message - no processing needed",
+                "original_message": message,
+                "proactive_type": "acknowledgment"
+            }
+
+        return None
+
+    async def should_process_message(
+        self,
+        message: str,
+        context: Dict[str, Any] = None
+    ) -> Dict[str, Any]:
         """Simple triage: Does this message need DevRel assistance?"""
+
         try:
+            # 🔥 Step 1: Lightweight proactive pattern check
+            pattern_result = self._simple_pattern_match(message)
+            if pattern_result:
+                logger.info("Pattern-based proactive classification triggered")
+                return pattern_result
+
+            # 🔥 Step 2: Fallback to LLM
             triage_prompt = DEVREL_TRIAGE_PROMPT.format(
                 message=message,
-                context=context or 'No additional context'
+                context=context or "No additional context"
             )
 
-            response = await self.llm.ainvoke([HumanMessage(content=triage_prompt)])
+            response = await self.llm.ainvoke(
+                [HumanMessage(content=triage_prompt)]
+            )
 
             response_text = response.content.strip()
-            if '{' in response_text:
-                json_start = response_text.find('{')
-                json_end = response_text.rfind('}') + 1
+
+            if "{" in response_text:
+                json_start = response_text.find("{")
+                json_end = response_text.rfind("}") + 1
                 json_str = response_text[json_start:json_end]
 
                 import json

backend/integrations/discord/bot.py

@@ -7,6 +7,7 @@
 
 logger = logging.getLogger(__name__)
 
+
 class DiscordBot(commands.Bot):
     """Discord bot with LangGraph agent integration"""
 
@@ -31,10 +32,12 @@ def __init__(self, queue_manager: AsyncQueueManager, **kwargs):
 
     def _register_queue_handlers(self):
         """Register handlers for queue messages"""
-        self.queue_manager.register_handler("discord_response", self._handle_agent_response)
+        self.queue_manager.register_handler(
+            "discord_response",
+            self._handle_agent_response
+        )
 
     async def on_ready(self):
-        """Bot ready event"""
         logger.info(f'Enhanced Discord bot logged in as {self.user}')
         print(f'Bot is ready! Logged in as {self.user}')
         try:
@@ -44,7 +47,6 @@ async def on_ready(self):
             print(f"Failed to sync slash commands: {e}")
 
     async def on_message(self, message):
-        """Handles regular chat messages, but ignores slash commands."""
         if message.author == self.user:
             return
 
@@ -67,9 +69,50 @@ async def on_message(self, message):
         except Exception as e:
             logger.error(f"Error processing message: {str(e)}")
 
-    async def _handle_devrel_message(self, message, triage_result: Dict[str, Any]):
-        """This now handles both new requests and follow-ups in threads."""
+    async def _handle_devrel_message(
+        self,
+        message,
+        triage_result: Dict[str, Any]
+    ):
+        """Handles both proactive responses and agent requests"""
+
         try:
+            # 🔥 PROACTIVE LAYER
+            if "proactive_type" in triage_result:
+                proactive_type = triage_result["proactive_type"]
+
+                if proactive_type == "greeting":
+                    await message.channel.send(
+                        f"Hi {message.author.mention}! 👋\n"
+                        "Welcome to the community!\n"
+                        "If you're new, I can guide you on how to start contributing 🚀"
+                    )
+                    return
+
+                if proactive_type == "onboarding":
+                    await message.channel.send(
+                        f"Awesome {message.author.mention}! 🎉\n"
+                        "Here’s how you can start:\n"
+                        "1️⃣ Look for `good first issue`\n"
+                        "2️⃣ Set up the project locally\n"
+                        "3️⃣ Read CONTRIBUTING.md\n\n"
+                        "Would you like me to suggest beginner-friendly issues?"
+                    )
+                    return
+
+                if proactive_type == "issue_suggestion":
+                    await message.channel.send(
+                        f"{message.author.mention} 🔍\n"
+                        "You can check open issues labeled `good first issue`.\n"
+                        "Would you like me to fetch some right now?"
+                    )
+                    return
+
+                if proactive_type == "acknowledgment":
+                    return
+
+            # 🔥 NORMAL AGENT FLOW (Fallback)
+
             user_id = str(message.author.id)
             thread_id = await self._get_or_create_thread(message, user_id)
 
@@ -88,27 +131,39 @@ async def _handle_devrel_message(self, message, triage_result: Dict[str, Any]):
                 "author": {
                     "username": message.author.name,
                     "display_name": message.author.display_name,
-                    "avatar_url": str(message.author.avatar.url) if message.author.avatar else None
+                    "avatar_url": str(message.author.avatar.url)
+                    if message.author.avatar else None
                 }
             }
-            priority_map = {"high": QueuePriority.HIGH,
-                            "medium": QueuePriority.MEDIUM,
-                            "low": QueuePriority.LOW
-                            }
-            priority = priority_map.get(triage_result.get("priority"), QueuePriority.MEDIUM)
+
+            priority_map = {
+                "high": QueuePriority.HIGH,
+                "medium": QueuePriority.MEDIUM,
+                "low": QueuePriority.LOW
+            }
+
+            priority = priority_map.get(
+                triage_result.get("priority"),
+                QueuePriority.MEDIUM
+            )
+
             await self.queue_manager.enqueue(agent_message, priority)
 
-            # --- "PROCESSING" MESSAGE RESTORED ---
             if thread_id:
                 thread = self.get_channel(int(thread_id))
                 if thread:
-                    await thread.send("I'm processing your request, please hold on...")
-            # ------------------------------------
+                    await thread.send(
+                        "I'm processing your request, please hold on..."
+                    )
 
         except Exception as e:
             logger.error(f"Error handling DevRel message: {str(e)}")
 
-    async def _get_or_create_thread(self, message, user_id: str) -> Optional[str]:
+    async def _get_or_create_thread(
+        self,
+        message,
+        user_id: str
+    ) -> Optional[str]:
         try:
             if user_id in self.active_threads:
                 thread_id = self.active_threads[user_id]
@@ -118,28 +173,43 @@ async def _get_or_create_thread(self, message, user_id: str) -> Optional[str]:
                 else:
                     del self.active_threads[user_id]
 
-            # This part only runs if it's not a follow-up message in an active thread.
             if isinstance(message.channel, discord.TextChannel):
                 thread_name = f"DevRel Chat - {message.author.display_name}"
-                thread = await message.create_thread(name=thread_name, auto_archive_duration=60)
+                thread = await message.create_thread(
+                    name=thread_name,
+                    auto_archive_duration=60
+                )
                 self.active_threads[user_id] = str(thread.id)
-                await thread.send(f"Hello {message.author.mention}! I've created this thread to help you. How can I assist?")
+                await thread.send(
+                    f"Hello {message.author.mention}! "
+                    "I've created this thread to help you."
+                )
                 return str(thread.id)
+
         except Exception as e:
             logger.error(f"Failed to create thread: {e}")
+
         return str(message.channel.id)
 
-    async def _handle_agent_response(self, response_data: Dict[str, Any]):
+    async def _handle_agent_response(
+        self,
+        response_data: Dict[str, Any]
+    ):
         try:
             thread_id = response_data.get("thread_id")
             response_text = response_data.get("response", "")
+
             if not thread_id or not response_text:
                 return
+
             thread = self.get_channel(int(thread_id))
             if thread:
                 for i in range(0, len(response_text), 2000):
                     await thread.send(response_text[i:i+2000])
             else:
-                logger.error(f"Thread {thread_id} not found for agent response")
+                logger.error(
+                    f"Thread {thread_id} not found for agent response"
+                )
+
         except Exception as e:
             logger.error(f"Error handling agent response: {str(e)}")