iflow-mcp_hulupeep_ruvscan-mcp 0.5.0__py3-none-any.whl

mcp/monitoring.py

@@ -0,0 +1,126 @@
+"""
+Monitoring and observability for RuvScan
+"""
+
+from typing import Dict, Any, List
+from datetime import datetime
+import logging
+import time
+from dataclasses import dataclass, field
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class RequestMetrics:
+    """Metrics for a single request"""
+    endpoint: str
+    method: str
+    status_code: int
+    duration_ms: float
+    timestamp: datetime = field(default_factory=datetime.utcnow)
+
+class MetricsCollector:
+    """Collect and aggregate metrics"""
+
+    def __init__(self):
+        self.requests: List[RequestMetrics] = []
+        self.endpoint_counts = defaultdict(int)
+        self.endpoint_durations = defaultdict(list)
+        self.error_counts = defaultdict(int)
+        self.start_time = datetime.utcnow()
+
+    def record_request(
+        self,
+        endpoint: str,
+        method: str,
+        status_code: int,
+        duration_ms: float
+    ):
+        """Record a request"""
+        metrics = RequestMetrics(
+            endpoint=endpoint,
+            method=method,
+            status_code=status_code,
+            duration_ms=duration_ms
+        )
+
+        self.requests.append(metrics)
+        self.endpoint_counts[endpoint] += 1
+        self.endpoint_durations[endpoint].append(duration_ms)
+
+        if status_code >= 400:
+            self.error_counts[endpoint] += 1
+
+    def get_summary(self) -> Dict[str, Any]:
+        """Get metrics summary"""
+        total_requests = len(self.requests)
+        uptime = (datetime.utcnow() - self.start_time).total_seconds()
+
+        # Calculate average durations
+        avg_durations = {}
+        for endpoint, durations in self.endpoint_durations.items():
+            avg_durations[endpoint] = sum(durations) / len(durations) if durations else 0
+
+        # Calculate error rates
+        error_rates = {}
+        for endpoint, errors in self.error_counts.items():
+            total = self.endpoint_counts[endpoint]
+            error_rates[endpoint] = (errors / total * 100) if total > 0 else 0
+
+        return {
+            "uptime_seconds": uptime,
+            "total_requests": total_requests,
+            "requests_per_second": total_requests / uptime if uptime > 0 else 0,
+            "endpoint_counts": dict(self.endpoint_counts),
+            "average_duration_ms": avg_durations,
+            "error_rates_percent": error_rates,
+            "total_errors": sum(self.error_counts.values())
+        }
+
+    def get_recent_requests(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get recent requests"""
+        recent = self.requests[-limit:]
+        return [
+            {
+                "endpoint": r.endpoint,
+                "method": r.method,
+                "status_code": r.status_code,
+                "duration_ms": r.duration_ms,
+                "timestamp": r.timestamp.isoformat()
+            }
+            for r in recent
+        ]
+
+# Global metrics collector
+metrics_collector = MetricsCollector()
+
+class RequestTimer:
+    """Context manager for timing requests"""
+
+    def __init__(self, endpoint: str, method: str):
+        self.endpoint = endpoint
+        self.method = method
+        self.start_time = None
+        self.status_code = 200
+
+    def __enter__(self):
+        self.start_time = time.time()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        duration_ms = (time.time() - self.start_time) * 1000
+
+        if exc_type is not None:
+            self.status_code = 500
+
+        metrics_collector.record_request(
+            self.endpoint,
+            self.method,
+            self.status_code,
+            duration_ms
+        )
+
+    def set_status(self, status_code: int):
+        """Set the status code"""
+        self.status_code = status_code

mcp/reasoning/__init__.py

@@ -0,0 +1,6 @@
+"""Reasoning layer for RuvScan"""
+
+from .fact_cache import FACTCache
+from .safla_agent import SAFLAAgent
+
+__all__ = ['FACTCache', 'SAFLAAgent']

mcp/reasoning/embeddings.py

@@ -0,0 +1,208 @@
+"""
+Embedding generation service
+Supports OpenAI, Anthropic, and local models
+"""
+
+from typing import List, Optional, Dict, Any
+import numpy as np
+import logging
+import os
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+class EmbeddingProvider(Enum):
+    """Supported embedding providers"""
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    LOCAL = "local"
+
+class EmbeddingService:
+    """
+    Service for generating embeddings from text
+    """
+
+    def __init__(
+        self,
+        provider: str = "openai",
+        model: str = "text-embedding-3-small",
+        api_key: Optional[str] = None
+    ):
+        self.provider = EmbeddingProvider(provider)
+        self.model = model
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.dimension = 1536  # Default for OpenAI
+
+        self._init_client()
+
+    def _init_client(self):
+        """Initialize the embedding client"""
+        if self.provider == EmbeddingProvider.OPENAI:
+            try:
+                from openai import OpenAI
+                self.client = OpenAI(api_key=self.api_key)
+                logger.info(f"Initialized OpenAI client with model {self.model}")
+            except ImportError:
+                logger.error("OpenAI package not installed")
+                raise
+        elif self.provider == EmbeddingProvider.ANTHROPIC:
+            logger.warning("Anthropic embeddings not yet implemented")
+            self.client = None
+        else:
+            logger.warning("Local embeddings not yet implemented")
+            self.client = None
+
+    async def embed_text(self, text: str) -> np.ndarray:
+        """
+        Generate embedding for a single text
+
+        Args:
+            text: Input text
+
+        Returns:
+            Numpy array of embedding vector
+        """
+        if not text or not text.strip():
+            logger.warning("Empty text provided for embedding")
+            return np.zeros(self.dimension)
+
+        try:
+            if self.provider == EmbeddingProvider.OPENAI:
+                return await self._embed_openai(text)
+            else:
+                # Fallback to random embedding for development
+                logger.warning(f"Using random embedding for provider {self.provider}")
+                return np.random.randn(self.dimension)
+
+        except Exception as e:
+            logger.error(f"Error generating embedding: {e}")
+            return np.zeros(self.dimension)
+
+    async def embed_batch(self, texts: List[str]) -> List[np.ndarray]:
+        """
+        Generate embeddings for multiple texts
+
+        Args:
+            texts: List of input texts
+
+        Returns:
+            List of numpy arrays
+        """
+        embeddings = []
+
+        # Process in batches for efficiency
+        batch_size = 100
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i + batch_size]
+
+            if self.provider == EmbeddingProvider.OPENAI:
+                batch_embeddings = await self._embed_openai_batch(batch)
+                embeddings.extend(batch_embeddings)
+            else:
+                # Fallback
+                for text in batch:
+                    embeddings.append(np.random.randn(self.dimension))
+
+        return embeddings
+
+    async def _embed_openai(self, text: str) -> np.ndarray:
+        """Generate OpenAI embedding"""
+        try:
+            response = self.client.embeddings.create(
+                input=text,
+                model=self.model
+            )
+
+            embedding = response.data[0].embedding
+            return np.array(embedding, dtype=np.float64)
+
+        except Exception as e:
+            logger.error(f"OpenAI embedding error: {e}")
+            raise
+
+    async def _embed_openai_batch(self, texts: List[str]) -> List[np.ndarray]:
+        """Generate OpenAI embeddings in batch"""
+        try:
+            response = self.client.embeddings.create(
+                input=texts,
+                model=self.model
+            )
+
+            embeddings = [
+                np.array(data.embedding, dtype=np.float64)
+                for data in response.data
+            ]
+
+            return embeddings
+
+        except Exception as e:
+            logger.error(f"OpenAI batch embedding error: {e}")
+            raise
+
+    def embed_repo_summary(self, repo_data: Dict[str, Any]) -> np.ndarray:
+        """
+        Generate embedding for repository summary
+
+        Args:
+            repo_data: Repository data dictionary
+
+        Returns:
+            Embedding vector
+        """
+        # Combine relevant fields
+        text_parts = []
+
+        if repo_data.get('name'):
+            text_parts.append(f"Repository: {repo_data['name']}")
+
+        if repo_data.get('description'):
+            text_parts.append(f"Description: {repo_data['description']}")
+
+        if repo_data.get('topics'):
+            topics = ', '.join(repo_data['topics'])
+            text_parts.append(f"Topics: {topics}")
+
+        if repo_data.get('readme'):
+            # Use first 1000 chars of README
+            readme_excerpt = repo_data['readme'][:1000]
+            text_parts.append(f"README: {readme_excerpt}")
+
+        combined_text = "\n".join(text_parts)
+
+        # Generate embedding synchronously for now
+        # In production, this should be async
+        import asyncio
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        return loop.run_until_complete(self.embed_text(combined_text))
+
+    def cosine_similarity(self, vec_a: np.ndarray, vec_b: np.ndarray) -> float:
+        """
+        Compute cosine similarity between two vectors
+
+        Args:
+            vec_a: First vector
+            vec_b: Second vector
+
+        Returns:
+            Similarity score [0, 1]
+        """
+        dot_product = np.dot(vec_a, vec_b)
+        norm_a = np.linalg.norm(vec_a)
+        norm_b = np.linalg.norm(vec_b)
+
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+
+        similarity = dot_product / (norm_a * norm_b)
+
+        # Normalize to [0, 1]
+        return (similarity + 1) / 2
+
+    def get_dimension(self) -> int:
+        """Get embedding dimension"""
+        return self.dimension

mcp/reasoning/fact_cache.py

@@ -0,0 +1,212 @@
+"""
+FACT (Framework for Autonomous Context Tracking) Cache Implementation
+Deterministic reasoning trace and prompt replay
+"""
+
+import hashlib
+import json
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+class FACTCache:
+    """
+    Deterministic caching layer for reproducible reasoning
+    Implements prompt replay and reasoning trace storage
+    """
+
+    def __init__(self, db_manager=None):
+        self.db = db_manager
+        self.version = "0.5.0"
+
+    def generate_hash(self, prompt: str, context: Optional[Dict] = None) -> str:
+        """
+        Generate deterministic hash for prompt + context
+
+        Args:
+            prompt: Input prompt text
+            context: Optional context dictionary
+
+        Returns:
+            SHA256 hash string
+        """
+        content = prompt
+        if context:
+            # Sort keys for deterministic hashing
+            content += json.dumps(context, sort_keys=True)
+
+        return hashlib.sha256(content.encode()).hexdigest()
+
+    def get(self, prompt: str, context: Optional[Dict] = None) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve cached response if exists
+
+        Args:
+            prompt: Input prompt
+            context: Optional context
+
+        Returns:
+            Cached entry or None
+        """
+        if not self.db:
+            return None
+
+        try:
+            cache_hash = self.generate_hash(prompt, context)
+            entry = self.db.get_fact_cache(prompt)
+
+            if entry:
+                logger.info(f"FACT cache hit: {cache_hash[:16]}...")
+                return entry
+
+            logger.info(f"FACT cache miss: {cache_hash[:16]}...")
+            return None
+
+        except Exception as e:
+            logger.error(f"FACT cache retrieval error: {e}")
+            return None
+
+    def set(
+        self,
+        prompt: str,
+        response: str,
+        context: Optional[Dict] = None,
+        metadata: Optional[Dict] = None
+    ) -> str:
+        """
+        Store response in FACT cache
+
+        Args:
+            prompt: Input prompt
+            response: Response to cache
+            context: Optional context
+            metadata: Additional metadata
+
+        Returns:
+            Cache hash
+        """
+        if not self.db:
+            return ""
+
+        try:
+            cache_hash = self.generate_hash(prompt, context)
+
+            # Prepare metadata
+            cache_metadata = {
+                "version": self.version,
+                "timestamp": datetime.utcnow().isoformat(),
+                "context": context,
+                **(metadata or {})
+            }
+
+            # Store in database
+            self.db.add_fact_cache(prompt, response, cache_metadata)
+
+            logger.info(f"FACT cache stored: {cache_hash[:16]}...")
+            return cache_hash
+
+        except Exception as e:
+            logger.error(f"FACT cache storage error: {e}")
+            return ""
+
+    def trace_reasoning(
+        self,
+        query: str,
+        steps: List[Dict[str, Any]],
+        final_result: str
+    ) -> Dict[str, Any]:
+        """
+        Create reasoning trace for deterministic replay
+
+        Args:
+            query: Original query
+            steps: List of reasoning steps
+            final_result: Final reasoning output
+
+        Returns:
+            Reasoning trace dictionary
+        """
+        trace = {
+            "query": query,
+            "steps": steps,
+            "final_result": final_result,
+            "timestamp": datetime.utcnow().isoformat(),
+            "version": self.version
+        }
+
+        # Store trace
+        trace_json = json.dumps(trace, indent=2)
+        self.set(
+            prompt=f"reasoning_trace:{query}",
+            response=trace_json,
+            metadata={"type": "reasoning_trace", "steps_count": len(steps)}
+        )
+
+        return trace
+
+    def replay_reasoning(self, query: str) -> Optional[Dict[str, Any]]:
+        """
+        Replay cached reasoning trace
+
+        Args:
+            query: Original query
+
+        Returns:
+            Reasoning trace or None
+        """
+        entry = self.get(f"reasoning_trace:{query}")
+
+        if not entry:
+            return None
+
+        try:
+            trace = json.loads(entry['response'])
+            logger.info(f"Replaying reasoning trace with {len(trace['steps'])} steps")
+            return trace
+        except Exception as e:
+            logger.error(f"Error replaying reasoning trace: {e}")
+            return None
+
+    def validate_determinism(self, prompt: str, new_response: str) -> bool:
+        """
+        Validate that new response matches cached response (determinism check)
+
+        Args:
+            prompt: Input prompt
+            new_response: New response to validate
+
+        Returns:
+            True if deterministic (matches cache)
+        """
+        cached = self.get(prompt)
+
+        if not cached:
+            # No cached version, store this one
+            self.set(prompt, new_response)
+            return True
+
+        # Check if responses match
+        cached_response = cached.get('response', '')
+        is_deterministic = cached_response == new_response
+
+        if not is_deterministic:
+            logger.warning(f"Determinism violation detected for prompt: {prompt[:50]}...")
+
+        return is_deterministic
+
+    def get_cache_stats(self) -> Dict[str, Any]:
+        """
+        Get cache statistics
+
+        Returns:
+            Statistics dictionary
+        """
+        # TODO: Implement cache statistics from database
+        return {
+            "version": self.version,
+            "total_entries": 0,
+            "hit_rate": 0.0,
+            "avg_response_size": 0
+        }