Slack Integration

# slack_mcp_server.py
from fastapi import FastAPI
from mcp.server.fastmcp import FastMCP
import httpx
import os
from datetime import datetime, timedelta

mcp = FastMCP("Slack")

@mcp.tool()
async def search_messages(
    channel: str,
    query: str,
    days: int = 7,
) -> list[dict]:
    """Search recent messages in a Slack channel.
    
    Args:
        channel: Channel name without # (e.g., "eng-infra")
        query: Search query (keywords, phrases)
        days: How many days back to search (default 7)
    
    Returns:
        List of messages with text, user, timestamp, permalink
    """
    bot_token = os.getenv("SLACK_BOT_TOKEN")
    if not bot_token:
        return [{"error": "SLACK_BOT_TOKEN not configured"}]
    
    # 1. Find channel ID from name
    async with httpx.AsyncClient() as client:
        # List channels
        resp = await client.get(
            "https://slack.com/api/conversations.list",
            headers={"Authorization": f"Bearer {bot_token}"},
            params={"exclude_archived": True, "types": "public_channel"},
        )
        resp.raise_for_status()
        data = resp.json()
        
        if not data.get("ok"):
            return [{"error": f"Slack API error: {data.get('error')}"}]
        
        channels = data.get("channels", [])
        channel_id = None
        for ch in channels:
            if ch.get("name") == channel:
                channel_id = ch.get("id")
                break
        
        if not channel_id:
            return [{"error": f"Channel #{channel} not found"}]
        
        # 2. Search messages in channel
        oldest = (datetime.now() - timedelta(days=days)).timestamp()
        resp = await client.get(
            "https://slack.com/api/conversations.history",
            headers={"Authorization": f"Bearer {bot_token}"},
            params={
                "channel": channel_id,
                "oldest": oldest,
                "limit": 100,
            },
        )
        resp.raise_for_status()
        data = resp.json()
        
        if not data.get("ok"):
            return [{"error": f"Slack API error: {data.get('error')}"}]
        
        messages = data.get("messages", [])
    
    # 3. Filter by query (simple text search)
    query_lower = query.lower()
    filtered = [
        msg for msg in messages
        if "text" in msg and query_lower in msg["text"].lower()
    ]
    
    # 4. Format results
    results = []
    for msg in filtered[:10]:  # Limit to 10 most recent
        user_id = msg.get("user", "unknown")
        # Fetch user name (cache this in production)
        user_name = user_id
        if user_id != "unknown":
            try:
                async with httpx.AsyncClient() as client:
                    user_resp = await client.get(
                        "https://slack.com/api/users.info",
                        headers={"Authorization": f"Bearer {bot_token}"},
                        params={"user": user_id},
                    )
                    user_data = user_resp.json()
                    if user_data.get("ok"):
                        user_name = user_data.get("user", {}).get("real_name", user_id)
            except:
                pass
        
        results.append({
            "text": msg.get("text", ""),
            "user": user_name,
            "timestamp": msg.get("ts"),
            "channel": channel,
            "permalink": f"https://your-workspace.slack.com/archives/{channel_id}/p{msg.get('ts', '').replace('.', '')}",
        })
    
    return results

app = FastAPI()
app.mount("/mcp", mcp.sse_app())

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8003)

# Slack MCP server base URL
SLACK_MCP_URL=https://your-slack-mcp-server.railway.app

# No auth token needed for MCP call - Slack bot token is stored in MCP server

from app.mcp.client import mcp_client
from app.core.config import settings

if settings.SLACK_MCP_URL:
    slack_messages = await mcp_client.query_mcp_server(
        server_url=settings.SLACK_MCP_URL,
        tool_name="search_messages",
        args={
            "channel": "eng-infra",
            "query": "rate limiting",
            "days": 7,
        },
        auth_token=None,  # Not needed - bot token in MCP server
    )
else:
    slack_messages = []

[
    {
        "text": "We should add rate limiting to the auth endpoints. 100 req/min per IP.",
        "user": "Alice Johnson",
        "timestamp": "1710086400.123456",
        "channel": "eng-infra",
        "permalink": "https://workspace.slack.com/archives/C01234/p1710086400123456",
    }
]

# Add to app/mcp/client.py:MCPClientManager

async def get_slack_messages(
    self,
    channel: str,
    query: str,
    days: int = 7,
) -> list[dict]:
    """Search recent messages in a Slack channel.
    
    Args:
        channel: Channel name without # (e.g., "eng-infra")
        query:   Search query (keywords, phrases)
        days:    How many days back to search (default 7)
    
    Returns:
        List of message dicts: {text, user, timestamp, channel, permalink}
        Empty list if Slack MCP is not configured or call fails.
    """
    if not settings.SLACK_MCP_URL:
        logger.info(
            "SLACK_MCP_URL not configured — skipping Slack message fetch"
        )
        return []

    return await self.query_mcp_server(
        server_url=settings.SLACK_MCP_URL,
        tool_name="search_messages",
        args={"channel": channel, "query": query, "days": days},
        auth_token=None,  # Bot token stored in MCP server
    )

# 1. Extract channel references from PR
import re

SLACK_CHANNEL_PATTERN = re.compile(r"#([a-z0-9-]+)")

pr_text = f"{pr_data['title']} {pr_data['body']}"
channels = SLACK_CHANNEL_PATTERN.findall(pr_text)
# Example: "Discussed in #eng-infra" -> ["eng-infra"]

# 2. Build search query from PR metadata
query_keywords = [
    pr_data["title"],
    pr_data.get("body", "")[:100],  # First 100 chars
]
query = " ".join(q for q in query_keywords if q).strip()

# 3. Pull Slack messages from referenced channels
slack_messages = []
for channel in channels[:2]:  # Limit to 2 channels
    if settings.SLACK_MCP_URL:
        messages = await mcp_client.query_mcp_server(
            server_url=settings.SLACK_MCP_URL,
            tool_name="search_messages",
            args={"channel": channel, "query": query, "days": 14},
        )
        slack_messages.extend(messages)

# 4. Format Slack context for AI review prompt
slack_context = ""
if slack_messages:
    slack_context = "\n\nSLACK CONTEXT:\n"
    for msg in slack_messages[:5]:  # Limit to 5 most relevant
        timestamp = datetime.fromtimestamp(float(msg["timestamp"]))
        slack_context += f"""#{msg['channel']} ({timestamp.strftime('%b %d')}) - @{msg['user']}:
\"{msg['text'][:200]}...\"
Permalink: {msg['permalink']}

"""

# 5. Include in AI review
review_prompt = f"""
Review this pull request:

PR Title: {pr_data['title']}
PR Description: {pr_data['body']}
{slack_context}

Diff:
{pr_diff}

If Slack context is present:
1. Verify the PR implements what was discussed in Slack
2. Check for gaps between Slack discussion and implementation
3. Flag if the PR should address additional points raised by the team
"""

# PR Review: Add rate limiting to auth endpoints

## Team Discussion Context
💬 **Slack conversation in #eng-infra (2 days ago)**:

@alice: "We should add rate limiting to the auth endpoints. 100 req/min per IP."
[View in Slack](https://workspace.slack.com/archives/C01234/p1710086400123456)

@bob: "Agreed. Use Redis for tracking, it's already deployed. Check out the example in api-gateway."
[View in Slack](https://workspace.slack.com/archives/C01234/p1710086500789012)

## Implementation Analysis

✅ **Matches team discussion**:
- Rate limiting implemented: 100 requests/min per IP ✓
- Using Redis for tracking ✓

⚠️ **Potential gap**:
- @bob mentioned "check out the example in api-gateway"
- Current implementation uses a custom rate limiter
- Consider: Is this consistent with the api-gateway pattern?

## Suggestions

1. **Verify consistency**: Review api-gateway rate limiter implementation
   to ensure this follows the same pattern (easier to maintain)

2. **Test with real traffic patterns**: 100 req/min might be too low
   for authenticated users. Consider tiered limits:
   - Anonymous: 100 req/min
   - Authenticated: 1000 req/min

3. **Document decision**: Add comment explaining why Redis was chosen
   over alternative approaches

## Verdict
APPROVE_WITH_SUGGESTIONS - Implementation aligns with team discussion,
but verify consistency with existing patterns.

def detect_relevant_channels(
    pr_title: str,
    pr_body: str,
    changed_files: list[str],
) -> list[str]:
    """Detect which Slack channels are relevant for this PR.
    
    Returns:
        List of channel names (without #)
    """
    channels = set()
    
    # 1. Explicit mentions in PR
    text = f"{pr_title} {pr_body}"
    explicit = re.findall(r"#([a-z0-9-]+)", text)
    channels.update(explicit)
    
    # 2. Infer from changed files
    if any(f.startswith("frontend/") for f in changed_files):
        channels.add("eng-frontend")
    if any(f.startswith("backend/") for f in changed_files):
        channels.add("eng-backend")
    if any(f.endswith(".sql") or "migrations/" in f for f in changed_files):
        channels.add("eng-infra")
    
    # 3. Infer from PR labels/keywords
    if "security" in text.lower():
        channels.add("eng-security")
    if "performance" in text.lower():
        channels.add("eng-performance")
    
    return list(channels)[:3]  # Limit to 3 channels

Slack API error: missing_scope

Slack API error: rate_limited

import asyncio
from functools import lru_cache

@lru_cache(maxsize=100)
async def cached_slack_search(channel: str, query: str, days: int):
    """Cache Slack searches for 10 minutes."""
    return await mcp_client.query_mcp_server(...)

# Clear cache every 10 minutes
asyncio.create_task(cache_clear_loop())

import re

def redact_sensitive_info(text: str) -> str:
    """Remove tokens, passwords, emails from Slack messages."""
    # Redact tokens
    text = re.sub(r"(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]+", "<REDACTED_TOKEN>", text)
    text = re.sub(r"[A-Za-z0-9+/]{40,}={0,2}", "<REDACTED_TOKEN>", text)
    
    # Redact emails
    text = re.sub(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", "<EMAIL>", text)
    
    # Redact passwords (common patterns)
    text = re.sub(r"password[:\s]*[\S]+", "password: <REDACTED>", text, flags=re.IGNORECASE)
    
    return text

# Apply to all Slack messages before including in review
for msg in slack_messages:
    msg["text"] = redact_sensitive_info(msg["text"])