Add GitHub MCP microservice for repository queries

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

@@ -5,6 +5,7 @@
 from app.core.config import settings
 from .prompts.intent_analysis import GITHUB_INTENT_ANALYSIS_PROMPT
 from .tools.search import handle_web_search
+from .tools.repository_query import handle_repo_query
 # TODO: Implement all tools
 from .tools.contributor_recommendation import handle_contributor_recommendation
 # from .tools.repository_query import handle_repo_query
@@ -55,7 +56,25 @@ async def classify_intent(self, user_query: str) -> Dict[str, Any]:
             response = await self.llm.ainvoke([HumanMessage(content=prompt)])
 
             import json
-            result = json.loads(response.content.strip())
+            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)
 
             classification = result.get("classification")
             if classification not in self.tools:
@@ -104,7 +123,7 @@ async def execute(self, query: str) -> Dict[str, Any]:
             if classification == "contributor_recommendation":
                 result = await handle_contributor_recommendation(query)
             elif classification == "repo_support":
-                result = "Not implemented"
+                result = await handle_repo_query(query)
                 # result = await handle_repo_query(query)
             elif classification == "issue_creation":
                 result = "Not implemented"

backend/app/agents/devrel/github/prompts/intent_analysis.py

@@ -1,9 +1,9 @@
 GITHUB_INTENT_ANALYSIS_PROMPT = """You are an expert GitHub DevRel AI assistant. Analyze the user query and classify the intent.
 
 AVAILABLE FUNCTIONS:
-- web_search: Search the web for information  
-- contributor_recommendation: Finding the right people to review PRs, assign issues, or collaborate (supports both issue URLs and general queries)
-- repo_support: Questions about codebase structure, dependencies, impact analysis, architecture
+- web_search: Search the web for general information not available through GitHub API
+- contributor_recommendation: Finding the right people to review PRs, assign issues, or collaborate
+- repo_support: Questions about repository information, structure, stats, issues, stars, forks, description, or any repository metadata
 - issue_creation: Creating bug reports, feature requests, or tracking items
 - documentation_generation: Generating docs, READMEs, API docs, guides, or explanations
 - find_good_first_issues: Finding beginner-friendly issues to work on across repositories
@@ -12,24 +12,26 @@
 USER QUERY: {user_query}
 
 Classification guidelines:
+- repo_support: ANY questions about repository information, stats, issues count, stars, forks, description, URL, or repository metadata. This includes "how many issues", "what are the stars", "repository details", etc.
 - contributor_recommendation: 
   * "who should review this PR/issue?"
   * "find experts in React/Python/ML"
   * "recommend assignees for stripe integration"
   * "best people for database optimization"
   * URLs like github.com/owner/repo/issues/123
   * "I need help with RabbitMQ, can you suggest some people?"
-- repo_support: Code structure, dependencies, impact analysis, architecture  
 - issue_creation: Creating bugs, features, tracking items
 - documentation_generation: Docs, READMEs, guides, explanations
 - find_good_first_issues: Beginners, newcomers, "good first issue"
-- web_search: General information needing external search
+- web_search: Only for information that cannot be found through GitHub API (like news, articles, external documentation)
 - general_github_help: General GitHub questions not covered above
 
+IMPORTANT: Repository information queries (issues count, stars, forks, description) should ALWAYS use repo_support, not web_search.
+
 CRITICAL: Return ONLY raw JSON. No markdown, no code blocks, no explanation text.
 
 {{
   "classification": "function_name_from_list_above",
   "reasoning": "Brief explanation of why you chose this function",
   "confidence": "high|medium|low"
-}}"""
+}}"""

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

@@ -0,0 +1,71 @@
+import logging
+from typing import Dict, Any, Optional
+import aiohttp
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class GitHubMCPClient:
+
+    #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
+        self.session: Optional[aiohttp.ClientSession] = None
+
+    async def __aenter__(self):
+        # Async context manager entry
+        self.session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=15))
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        # Async context manager exit
+        if self.session:
+            await self.session.close()
+
+    async def get_repo_info(self, owner: str, repo: str) -> Dict[str, Any]:
+
+        if not self.session:
+            raise RuntimeError("Client not initialized. Use async context manager.")
+
+        try:
+            payload = {
+                "owner": owner,
+                "repo": repo
+            }
+
+            async with self.session.post(
+                f"{self.mcp_server_url}/repo_info",
+                json=payload,
+                headers={"Content-Type": "application/json"}
+            ) as response:
+                if response.status == 200:
+                    result = await response.json()
+                    if result.get("status") == "success":
+                        return result.get("data", {})
+                    else:
+                        return {"error": result.get("error", "Unknown error")}
+                else:
+                    logger.error(f"MCP server error: {response.status}")
+                    return {"error": f"MCP server error: {response.status}"}
+
+        except aiohttp.ClientError as e:
+            logger.error(f"Error communicating with MCP server: {e}")
+            return {"error": f"Communication error: {str(e)}"}
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            return {"error": f"Unexpected error: {str(e)}"}
+
+    async def is_server_available(self) -> bool:
+
+        if not self.session:
+            return False
+
+        try:
+            async with self.session.get(f"{self.mcp_server_url}/health", timeout=5) as response:
+                return response.status == 200
+
+        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+            logger.debug(f"Health check failed: {e}")
+            return False

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

@@ -0,0 +1,96 @@
+import os
+import logging
+from dotenv import load_dotenv, find_dotenv
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from .github_mcp_service import GitHubMCPService
+from typing import Optional
+
+dotenv_path = find_dotenv(usecwd=True)
+if dotenv_path:
+    load_dotenv(dotenv_path=dotenv_path)
+else:
+    load_dotenv()
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="GitHub MCP Server", version="1.0.0")
+
+github_service: Optional[GitHubMCPService] = None
+try:
+    token = os.getenv("GITHUB_TOKEN") or os.getenv("GH_TOKEN")
+    if not token:
+        logger.warning("GITHUB_TOKEN/GH_TOKEN not set; GitHub API calls may be rate-limited or fail.")
+    github_service = GitHubMCPService(token=token)
+    logger.info("GitHub service initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize GitHub service: {e}")
+    github_service = None
+
+class RepoInfoRequest(BaseModel):
+    owner: str
+    repo: str
+
+class RepoInfoResponse(BaseModel):
+    status: str
+    data: dict
+    error: str = None
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "github-mcp"}
+
+@app.post("/mcp")
+async def mcp_endpoint(request: dict):
+    """MCP protocol endpoint"""
+    try:
+        method = request.get("method")
+        params = request.get("params", {})
+
+        if method == "tools/call":
+            tool_name = params.get("name")
+            arguments = params.get("arguments", {})
+
+            if tool_name == "get_repo_info":
+                owner = arguments.get("owner")
+                repo = arguments.get("repo")
+
+                if not owner or not repo:
+                    return {"error": "Missing owner or repo parameter"}
+
+                if not github_service:
+                    return {"error": "GitHub service not available"}
+                result = github_service.repo_query(owner, repo)
+                return {"result": result}
+            else:
+                return {"error": f"Unknown tool: {tool_name}"}
+        else:
+            return {"error": f"Unknown method: {method}"}
+
+    except Exception as e:
+        logger.exception("Error in MCP endpoint")
+        return {"error": str(e)}
+
+@app.post("/repo_info")
+async def get_repo_info(request: RepoInfoRequest):
+
+    try:
+        if not github_service:
+            raise HTTPException(status_code=500, detail="GitHub service not available")
+
+        result = github_service.repo_query(request.owner, request.repo)
+
+        if "error" in result:
+            return RepoInfoResponse(status="error", data={}, error=result["error"])
+
+        return RepoInfoResponse(status="success", data=result)
+
+    except Exception as e:
+        logger.error(f"Error getting repo info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

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

@@ -0,0 +1,64 @@
+import os
+import requests
+from dotenv import load_dotenv
+
+dotenv_path = os.path.join(os.path.dirname(__file__), '..', '..', '..', '..', '..', '.env')
+
+load_dotenv(dotenv_path=dotenv_path)
+
+class GitHubMCPService:
+    def __init__(self, token: str = None):
+        """
+        Initializes the GitHub MCP Service.
+        It retrieves the GitHub token from the environment variables.
+        """
+        self.token = token or os.getenv("GITHUB_TOKEN")
+        if not self.token:
+            raise ValueError("GitHub token required; export as GITHUB_TOKEN or place in backend/.env file")
+        self.base_url = "https://api.github.com"
+
+    def repo_query(self, owner: str, repo: str) -> dict:
+
+        url = f"{self.base_url}/repos/{owner}/{repo}"
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "User-Agent": "DevrAI-GitHubMCPService/0.1"
+        }
+
+        try:
+            resp = requests.get(url, headers=headers, timeout=15)
+            resp.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            return {"error": "Request failed", "message": str(e)}
+
+        data = resp.json()
+
+        license_info = data.get("license")
+        license_name = license_info.get("name") if license_info else "No license specified"
+
+        return {
+            # Core Info
+            "full_name": data.get("full_name"),
+            "description": data.get("description"),
+            "html_url": data.get("html_url"),
+            "homepage": data.get("homepage"),
+
+            # Stats
+            "stars": data.get("stargazers_count"),
+            "forks": data.get("forks_count"),
+            "watchers": data.get("watchers_count"),
+            "open_issues": data.get("open_issues_count"),
+
+            # Details
+            "language": data.get("language"),
+            "topics": data.get("topics", []),
+            "default_branch": data.get("default_branch"),
+            "license": license_name,
+
+            # Timestamps
+            "created_at": data.get("created_at"),
+            "updated_at": data.get("updated_at"),
+            "pushed_at": data.get("pushed_at"),
+        }

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

@@ -0,0 +1,46 @@
+from ..services.github_mcp_client import GitHubMCPClient
+import re
+
+#GitHub URL forms: https(s)://github.com/owner/repo[.git][...], git@github.com:owner/repo[.git]
+GH_URL_RE = re.compile(
+    r'(?:https?://|git@)github\.com[/:]'
+    r'([A-Za-z0-9](?:-?[A-Za-z0-9]){0,38})/'
+    r'([A-Za-z0-9._-]+?)(?:\.git)?(?:/|$)',
+    re.IGNORECASE,
+)
+
+OWNER_REPO_RE = re.compile(
+    r'\b([A-Za-z0-9](?:-?[A-Za-z0-9]){0,38})/([A-Za-z0-9._-]{1,100})\b'
+)
+
+async def handle_repo_query(user_query: str) -> dict:
+    m = GH_URL_RE.search(user_query) or OWNER_REPO_RE.search(user_query)
+    if not m:
+        return {"status": "error", "message": "Usage: include a GitHub owner/repo (e.g., AOSSIE-Org/Devr.AI) or a GitHub URL."}
+
+    owner, repo = m.group(1), m.group(2)
+
+    # Use the GitHub MCP client to communicate with the MCP server
+    async with GitHubMCPClient() as client:
+        if not await client.is_server_available():
+            return {
+                "status": "error", 
+                "message": "GitHub MCP server not available. Please ensure the MCP server is running."
+            }
+
+        result = await client.get_repo_info(owner, repo)
+
+        if "error" in result:
+            return {
+                "status": "error", 
+                "owner": owner, 
+                "repo": repo, 
+                "message": result["error"]
+            }
+
+        return {
+            "status": "success", 
+            "owner": owner, 
+            "repo": repo, 
+            "data": result
+        }

backend/integrations/discord/cogs.py

@@ -17,11 +17,9 @@ def __init__(self, bot: DiscordBot, queue_manager: AsyncQueueManager):
         self.bot = bot
         self.queue = queue_manager
 
-    @commands.Cog.listener()
-    async def on_ready(self):
-        if not self.cleanup_expired_tokens.is_running():
-            print("--> Starting the token cleanup task...")
-            self.cleanup_expired_tokens.start()
+    def cog_load(self):
+        """Called when the cog is loaded"""
+        self.cleanup_expired_tokens.start()
 
     def cog_unload(self):
         self.cleanup_expired_tokens.cancel()