Added changes suggested by mentor

minimized regex use in github_toolkit.py and some changes in react_prompt

Author: DhruvK278

backend/app/agents/devrel/github/github_toolkit.py

@@ -1,26 +1,24 @@
 import logging
 import os
+import json
+import re
 from typing import Dict, Any
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import HumanMessage
 from app.core.config import settings
 from .prompts.intent_analysis import GITHUB_INTENT_ANALYSIS_PROMPT
 from .tools.search import handle_web_search
 from .tools.github_support import handle_github_supp
-# TODO: Implement all tools
 from .tools.contributor_recommendation import handle_contributor_recommendation
-# from .tools.repository_query import handle_repo_query
-# from .tools.issue_creation import handle_issue_creation
-# from .tools.documentation_generation import handle_documentation_generation
 from .tools.general_github_help import handle_general_github_help
+
 logger = logging.getLogger(__name__)
 
 DEFAULT_ORG = os.getenv("GITHUB_ORG")
 
+
 def normalize_org(org_from_user: str = None) -> str:
-    """
-    Always fallback to env org if user does not specify one.
-    """
+    """Fallback to env org if user does not specify one."""
     if org_from_user and org_from_user.strip():
         return org_from_user.strip()
     return DEFAULT_ORG
@@ -52,41 +50,29 @@ def __init__(self):
         ]
 
     async def classify_intent(self, user_query: str) -> Dict[str, Any]:
-        """
-        Classify intent and return classification with reasoning.
-
-        Args:
-            user_query: The user's request or question
-
-        Returns:
-            Dictionary containing classification, reasoning, and confidence
-        """
+        """Classify intent and return classification with reasoning."""
         logger.info(f"Classifying intent for query: {user_query[:100]}")
 
         try:
             prompt = GITHUB_INTENT_ANALYSIS_PROMPT.format(user_query=user_query)
             response = await self.llm.ainvoke([HumanMessage(content=prompt)])
 
-            import json
-            import re
-
             content = response.content.strip()
 
-            candidates = []
-            cb = re.search(r'```(?:json)?\s*({[\s\S]*?})\s*```', content, flags=re.IGNORECASE)
-            if cb:
-                candidates.append(cb.group(1))
-            candidates.extend(m.group(0) for m in re.finditer(r'\{[\s\S]*?\}', content))
-
-            result = None
-            for payload in candidates:
-                try:
-                    result = json.loads(payload)
-                    break
-                except json.JSONDecodeError:
-                    continue
-            if result is None:
-                raise json.JSONDecodeError("No valid JSON object found in LLM response", content, 0)
+            try:
+                result = json.loads(content)
+            except json.JSONDecodeError:
+                match = re.search(r"\{.*\}", content, re.DOTALL)
+                if match:
+                    result = json.loads(match.group())
+                else:
+                    logger.error(f"Invalid JSON in LLM response: {content}")
+                    return {
+                        "classification": "general_github_help",
+                        "reasoning": "Failed to parse LLM response as JSON",
+                        "confidence": "low",
+                        "query": user_query
+                    }
 
             classification = result.get("classification")
             if classification not in self.tools:
@@ -96,21 +82,12 @@ async def classify_intent(self, user_query: str) -> Dict[str, Any]:
 
             result["query"] = user_query
 
-            logger.info(f"Classified intent as for query: {user_query} is: {classification}")
+            logger.info(f"Classified intent for query: {user_query} -> {classification}")
             logger.info(f"Reasoning: {result.get('reasoning', 'No reasoning provided')}")
             logger.info(f"Confidence: {result.get('confidence', 'unknown')}")
 
             return result
 
-        except json.JSONDecodeError as e:
-            logger.error(f"Error parsing JSON response from LLM: {str(e)}")
-            logger.error(f"Raw response: {response.content}")
-            return {
-                "classification": "general_github_help",
-                "reasoning": f"Failed to parse LLM response: {str(e)}",
-                "confidence": "low",
-                "query": user_query
-            }
         except Exception as e:
             logger.error(f"Error in intent classification: {str(e)}")
             return {
@@ -121,9 +98,7 @@ async def classify_intent(self, user_query: str) -> Dict[str, Any]:
             }
 
     async def execute(self, query: str) -> Dict[str, Any]:
-        """
-        Main execution method - classifies intent and delegates to appropriate tools
-        """
+        """Main execution method - classifies intent and delegates to appropriate tools"""
         logger.info(f"Executing GitHub toolkit for query: {query[:100]}")
 
         try:
@@ -140,13 +115,10 @@ async def execute(self, query: str) -> Dict[str, Any]:
                 result["org_used"] = org
             elif classification == "repo_support":
                 result = "Not implemented"
-                # result = await handle_repo_query(query)
             elif classification == "issue_creation":
                 result = "Not implemented"
-                # result = await handle_issue_creation(query)
             elif classification == "documentation_generation":
                 result = "Not implemented"
-                # result = await handle_documentation_generation(query)
             elif classification == "web_search":
                 result = await handle_web_search(query)
             else:

backend/app/agents/devrel/github/services/github_mcp_client.py

@@ -7,9 +7,7 @@
 logger = logging.getLogger(__name__)
 
 class GitHubMCPClient:
-    """
-    Client for communicating with the GitHub MCP server.
-    """
+    """Client for communicating with the GitHub MCP server."""
 
     def __init__(self, mcp_server_url: str = "http://localhost:8001"):
         self.mcp_server_url = mcp_server_url
@@ -91,9 +89,7 @@ async def list_org_repos(self, org: str) -> Union[List[Dict[str, Any]], Dict[str
 
 
     async def is_server_available(self) -> bool:
-        """
-        Health check for MCP server.
-        """
+        """Health check for MCP server."""
         if not self.session:
             return False
 

backend/app/agents/devrel/github/services/github_mcp_service.py

@@ -49,12 +49,8 @@ def repo_query(self, owner: str, repo: str) -> dict:
         }
 
     def list_repo_issues(self, owner: str, repo: str, state: str = "open") -> list:
-        """
-        Fetch issues from a given repository.
-        :param owner: repository owner (user/org)
-        :param repo: repository name
-        :param state: 'open', 'closed', or 'all'
-        """
+        """Fetch issues from a given repository."""
+        
         url = f"{self.base_url}/repos/{owner}/{repo}/issues?state={state}&per_page=50"
         headers = self._headers()
         try:

backend/app/agents/devrel/github/tools/github_support.py

@@ -37,13 +37,13 @@ async def handle_github_supp(query: str, org: Optional[str] = None):
         if match:
             org, repo_name = match.group(1), match.group(2)
 
-        # --- owner/repo format ---
+        # owner/repo format 
         if not repo_name:
             match = OWNER_REPO_RE.search(query)
             if match:
                 org, repo_name = match.group(1), match.group(2)
 
-        # ---"<name> repo" pattern ---
+        # "<name> repo" pattern
         if not repo_name:
             match = REPO_NAME_RE.search(query)
             if match:
@@ -53,7 +53,7 @@ async def handle_github_supp(query: str, org: Optional[str] = None):
         # Fallback org if none detected
         org = org or DEFAULT_ORG
 
-        # --- Top repos ---
+        # Top repos
         if "top" in q and "repo" in q:
             repos = await github_mcp_service.get_org_repositories(org)
             if isinstance(repos, dict) and "error" in repos:
@@ -65,7 +65,7 @@ async def handle_github_supp(query: str, org: Optional[str] = None):
                 "repositories": repos,
             }
 
-        # --- Issues, stars, forks, stats ---
+        # Issues, stars, forks, stats
         if any(word in q for word in ["issue", "star", "fork", "stat", "stats"]):
             if repo_name:
                 if "issue" in q:
@@ -92,7 +92,7 @@ async def handle_github_supp(query: str, org: Optional[str] = None):
                         return {"status": "error", "message": f"Failed to fetch repositories for {org}", "details": repos}
                     return {"status": "success", "message": f"Repositories for {org}", "repositories": repos}
 
-        # --- General repo list (fallback) ---
+        # General repo list 
         repos = await github_mcp_service.get_org_repositories(org)
         if isinstance(repos, dict) and "error" in repos:
             return {

backend/app/agents/devrel/prompts/react_prompt.py

@@ -13,7 +13,7 @@
 {tool_results}
 
 AVAILABLE ACTIONS:
-1. web_search - Search the web for external information (ONLY if you cannot find info in GitHub or FAQs)
+1. web_search - Search the web for external information
 2. faq_handler - Answer common questions from knowledge base  
 3. onboarding - Welcome new users and guide exploration
 4. github_toolkit - Handle ANY GitHub-related queries such as: