finalising

config/redis.py

@@ -0,0 +1,225 @@
+"""
+Redis Connection Utility
+
+Provides Redis client with connection pooling and helper methods for caching.
+Falls back gracefully when Redis is unavailable.
+"""
+
+import os
+import logging
+import hashlib
+import json
+from typing import Optional, Any
+from redis import Redis, ConnectionPool, RedisError
+
+logger = logging.getLogger(__name__)
+
+# Redis configuration from environment
+REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
+DEFAULT_TTL = 86400  # 24 hours in seconds
+
+# Global connection pool
+_redis_pool: Optional[ConnectionPool] = None
+_redis_client: Optional[Redis] = None
+
+
+def get_redis_client() -> Optional[Redis]:
+    """
+    Get Redis client with connection pooling.
+    Returns None if Redis is unavailable.
+    """
+    global _redis_pool, _redis_client
+    
+    if _redis_client is not None:
+        return _redis_client
+    
+    try:
+        if _redis_pool is None:
+            _redis_pool = ConnectionPool.from_url(
+                REDIS_URL,
+                max_connections=10,
+                decode_responses=True,
+                socket_timeout=5,
+                socket_connect_timeout=5
+            )
+        
+        _redis_client = Redis(connection_pool=_redis_pool)
+        
+        # Test connection
+        _redis_client.ping()
+        logger.info(f"Redis connected successfully at {REDIS_URL}")
+        return _redis_client
+        
+    except RedisError as e:
+        logger.warning(f"Redis connection failed: {e}. Caching will be disabled.")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error connecting to Redis: {e}")
+        return None
+
+
+def generate_cache_key(prefix: str, data: dict) -> str:
+    """
+    Generate a consistent cache key from a data dictionary.
+    
+    Args:
+        prefix: Key prefix (e.g., "triage", "prediction")
+        data: Dictionary containing the data to hash
+        
+    Returns:
+        Cache key string
+    """
+    # Create a stable JSON representation
+    json_str = json.dumps(data, sort_keys=True, separators=(',', ':'))
+    
+    # Generate SHA256 hash
+    hash_obj = hashlib.sha256(json_str.encode('utf-8'))
+    hash_hex = hash_obj.hexdigest()[:16]  # Use first 16 chars
+    
+    return f"{prefix}:{hash_hex}"
+
+
+def cache_get(key: str) -> Optional[Any]:
+    """
+    Get value from Redis cache.
+    
+    Args:
+        key: Cache key
+        
+    Returns:
+        Cached value (parsed from JSON) or None if not found or error
+    """
+    client = get_redis_client()
+    if client is None:
+        return None
+    
+    try:
+        value = client.get(key)
+        if value is None:
+            return None
+        
+        # Parse JSON
+        return json.loads(value)
+        
+    except RedisError as e:
+        logger.warning(f"Redis get error for key '{key}': {e}")
+        return None
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to decode cached value for key '{key}': {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error getting cache key '{key}': {e}")
+        return None
+
+
+def cache_set(key: str, value: Any, ttl: int = DEFAULT_TTL) -> bool:
+    """
+    Set value in Redis cache with TTL.
+    
+    Args:
+        key: Cache key
+        value: Value to cache (will be JSON serialized)
+        ttl: Time to live in seconds (default: 24 hours)
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    client = get_redis_client()
+    if client is None:
+        return False
+    
+    try:
+        # Serialize to JSON
+        json_value = json.dumps(value)
+        
+        # Set with expiration
+        client.setex(key, ttl, json_value)
+        logger.debug(f"Cached key '{key}' with TTL {ttl}s")
+        return True
+        
+    except RedisError as e:
+        logger.warning(f"Redis set error for key '{key}': {e}")
+        return False
+    except (TypeError, ValueError) as e:
+        logger.error(f"Failed to serialize value for key '{key}': {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error setting cache key '{key}': {e}")
+        return False
+
+
+def cache_delete(key: str) -> bool:
+    """
+    Delete value from Redis cache.
+    
+    Args:
+        key: Cache key
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    client = get_redis_client()
+    if client is None:
+        return False
+    
+    try:
+        client.delete(key)
+        logger.debug(f"Deleted cache key '{key}'")
+        return True
+        
+    except RedisError as e:
+        logger.warning(f"Redis delete error for key '{key}': {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error deleting cache key '{key}': {e}")
+        return False
+
+
+def cache_exists(key: str) -> bool:
+    """
+    Check if key exists in Redis cache.
+    
+    Args:
+        key: Cache key
+        
+    Returns:
+        True if key exists, False otherwise
+    """
+    client = get_redis_client()
+    if client is None:
+        return False
+    
+    try:
+        return client.exists(key) > 0
+        
+    except RedisError as e:
+        logger.warning(f"Redis exists error for key '{key}': {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error checking cache key '{key}': {e}")
+        return False
+
+
+def get_cache_stats() -> dict:
+    """
+    Get Redis cache statistics.
+    
+    Returns:
+        Dictionary with cache stats or empty dict if unavailable
+    """
+    client = get_redis_client()
+    if client is None:
+        return {"status": "unavailable"}
+    
+    try:
+        info = client.info("stats")
+        return {
+            "status": "connected",
+            "total_keys": client.dbsize(),
+            "hits": info.get("keyspace_hits", 0),
+            "misses": info.get("keyspace_misses", 0),
+            "evicted_keys": info.get("evicted_keys", 0),
+        }
+    except RedisError as e:
+        logger.warning(f"Failed to get cache stats: {e}")
+        return {"status": "error", "error": str(e)}

main.py

@@ -10,8 +10,11 @@ Designed for Hugging Face Spaces deployment.
 import logging
 import os
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Depends
 from fastapi.middleware.cors import CORSMiddleware
+
+# Import authentication middleware
+from middleware import require_api_key_or_auth, get_optional_user
 from pydantic import BaseModel
 from typing import List, Dict, Any, Optional
 from datetime import datetime, timezone
@@ -167,13 +170,38 @@ async def root():
 # =============================================================================
 
 @app.post("/triage")
-async def triage_issue(request: TriageRequest):
+async def triage_issue(request: TriageRequest, auth: dict = Depends(require_api_key_or_auth)):
     """
     Classify and triage a GitHub issue using AI.
     
     Passes directly to ai_triage_service.classify_issue()
+    Requires authentication (API key or JWT token).
+    
+    Implements Redis caching with 24-hour TTL.
     """
     try:
+        # Import Redis utilities (lazy import to avoid startup dependencies)
+        from config.redis import generate_cache_key, cache_get, cache_set
+        
+        # Generate cache key from request data
+        cache_data = {
+            "title": request.title,
+            "body": request.body or "",
+            "isPR": request.isPR
+        }
+        cache_key = generate_cache_key("triage", cache_data)
+        
+        # Check cache first
+        cached_result = cache_get(cache_key)
+        if cached_result is not None:
+            logger.info(f"Cache HIT for triage request: {cache_key}")
+            # Add cache metadata
+            cached_result["_cached"] = True
+            cached_result["_cache_key"] = cache_key
+            return cached_result
+        
+        logger.info(f"Cache MISS for triage request: {cache_key}")
+        
         # Create Issue object matching the original service expectation
         issue = Issue(
             id=request.id or "temp-id",
@@ -187,7 +215,17 @@ async def triage_issue(request: TriageRequest):
             isPR=request.isPR
         )
         
+        # Call AI service (cache miss)
         result = await ai_triage_service.classify_issue(issue)
+        
+        # Cache the result with 24-hour TTL (86400 seconds)
+        cache_set(cache_key, result, ttl=86400)
+        logger.info(f"Cached triage result: {cache_key}")
+        
+        # Add cache metadata
+        result["_cached"] = False
+        result["_cache_key"] = cache_key
+        
         return result
     except Exception as e:
         logger.error(f"Triage error: {e}")
@@ -199,11 +237,12 @@ async def triage_issue(request: TriageRequest):
 # =============================================================================
 
 @app.post("/chat")
-async def chat(request: ChatRequest):
+async def chat(request: ChatRequest, auth: dict = Depends(require_api_key_or_auth)):
     """
     AI chat endpoint for general assistance.
     
     Passes directly to ai_chat_service.chat()
+    Requires authentication (API key or JWT token).
     """
     try:
         response = await ai_chat_service.chat(
@@ -222,11 +261,12 @@ async def chat(request: ChatRequest):
 # =============================================================================
 
 @app.post("/rag/chat")
-async def rag_chat(request: RAGChatRequest):
+async def rag_chat(request: RAGChatRequest, auth: dict = Depends(require_api_key_or_auth)):
     """
     Answer questions using RAG (Retrieval-Augmented Generation).
     
     Passes directly to rag_chatbot_service.answer_question()
+    Requires authentication.
     """
     try:
         result = await rag_chatbot_service.answer_question(
@@ -242,11 +282,12 @@ async def rag_chat(request: RAGChatRequest):
 
 
 @app.post("/rag/index")
-async def rag_index(request: RAGIndexRequest):
+async def rag_index(request: RAGIndexRequest, auth: dict = Depends(require_api_key_or_auth)):
     """
     Index a repository for RAG search.
     
     Passes directly to rag_chatbot_service.index_repository()
+    Requires authentication.
     """
     try:
         result = await rag_chatbot_service.index_repository(
@@ -275,11 +316,12 @@ async def rag_suggestions(repo_name: Optional[str] = None):
 # =============================================================================
 
 @app.post("/mentor-match")
-async def mentor_match(request: MentorMatchRequest):
+async def mentor_match(request: MentorMatchRequest, auth: dict = Depends(require_api_key_or_auth)):
     """
     Find mentor matches for a user.
     
     Passes directly to mentor_matching_service.find_mentors_for_user()
+    Requires authentication.
     """
     try:
         matches = mentor_matching_service.find_mentors_for_user(
@@ -299,11 +341,12 @@ async def mentor_match(request: MentorMatchRequest):
 # =============================================================================
 
 @app.post("/hype")
-async def generate_hype(request: HypeRequest):
+async def generate_hype(request: HypeRequest, auth: dict = Depends(require_api_key_or_auth)):
     """
     Generate hype/celebration message for a PR.
     
     Passes directly to hype_generator_service.generate_hype()
+    Requires authentication.
     """
     try:
         result = hype_generator_service.generate_hype(

requirements.txt

@@ -44,6 +44,9 @@ asyncio-throttle>=1.0.2
 # JWT Authentication
 PyJWT>=2.8.0
 
+# Redis Cache
+redis>=5.0.0
+
 # Turso (libsql) Database - try both package names
 libsql-experimental>=0.0.55
-libsql_client
+libsql_client