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

iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+mcp/__init__.py,sha256=dWs4CTMlszA3kkivHnL6Rz0SnheoDGrh_--HBkJ4Ixg,171
+mcp/mcp_stdio_server.py,sha256=v-LHyZVrBRiFnr2zTQhIkwbn4E1mcojv504DHP1rBZs,6164
+mcp/monitoring.py,sha256=MS6fwF1p-YjMZjeokssjM2vF4cPNjWYbzQ9-9NbJo0w,3757
+mcp/server.py,sha256=CE_4mQVa1-5GXpC0KCfpXqjQomKX27mJSxlfQlkCH5Q,8552
+mcp/bindings/__init__.py,sha256=AVE5Lad6YApYZ8CNH7saAsPaHTPyKBL2d677hjcUJTc,118
+mcp/bindings/rust_client.py,sha256=LWcT1bc3cPKZSOYhcV8X_zSoHWvQb8KCUpUlXTOqEqQ,4984
+mcp/endpoints/query.py,sha256=4OxYyNPmK7FdKDHHv5wp6AIMGQ_IvSs8alvemsVNitI,4853
+mcp/endpoints/scan.py,sha256=_7Yf5uNZEmwRbDz7s5NrZnYSuXCZ9vDLleUgDFaWWQY,3226
+mcp/reasoning/__init__.py,sha256=cctZeASsyKAOBFkaAbTDLIQiDBuR62ZU8b8A6DL8cPc,144
+mcp/reasoning/embeddings.py,sha256=B_xjRzn98bVzsHa3XErKWys7fzdTjTNfRgvnoHPe7ng,6235
+mcp/reasoning/fact_cache.py,sha256=dititHNTgjRQePw3e3ljbYLhxzRHYNRsrmfFdH3mtZ8,5738
+mcp/reasoning/safla_agent.py,sha256=l0wqcNfL4jTa4W4Fl7U_nRZz4YXxcWCn0rKLrb3M5tw,9420
+mcp/storage/__init__.py,sha256=S0bzRxAhvEBvYi8Z7dTxjFDzc5DqtiS-dDUHhV9zQC8,349
+mcp/storage/db.py,sha256=SiwOjnzUHi4YKHwgFK5tnHkYp9NuXPN0vWMRUW2ipS4,7196
+mcp/storage/models.py,sha256=ujTeJQZ9KAPzH0yUyunwc8zuGwMshhQ_0Ug5B1q4RLQ,2213
+iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/METADATA,sha256=iEwl08ewL_lktVQF2JrBP4dQ9xhkjQprKaaOOsX4el4,39046
+iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/entry_points.txt,sha256=GT06cmvaZZh6KZOrpBzF8X7MpZ1Y1mBBHhLXmEMLBXo,77
+iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/RECORD,,

iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_hulupeep_ruvscan_mcp-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+iflow-mcp-hulupeep-ruvscan-mcp = mcp.mcp_stdio_server:main

mcp/__init__.py

@@ -0,0 +1,7 @@
+"""
+RuvScan MCP Server Package
+"""
+
+__version__ = "0.5.0"
+__author__ = "Colm Byrne / Flout Labs"
+__description__ = "Sublinear-intelligence MCP server for GitHub scanning"

mcp/bindings/__init__.py

@@ -0,0 +1,5 @@
+"""Bindings for external services"""
+
+from .rust_client import RustSublinearClient
+
+__all__ = ['RustSublinearClient']

mcp/bindings/rust_client.py

@@ -0,0 +1,166 @@
+"""
+gRPC client for Rust sublinear engine
+"""
+
+import grpc
+from typing import List, Dict, Any, Tuple
+import logging
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+class RustSublinearClient:
+    """
+    gRPC client for communicating with Rust sublinear engine
+    """
+
+    def __init__(self, host: str = "localhost", port: int = 50051):
+        self.host = host
+        self.port = port
+        self.channel = None
+        self.stub = None
+
+    async def connect(self):
+        """Establish gRPC connection"""
+        try:
+            address = f"{self.host}:{self.port}"
+            self.channel = grpc.aio.insecure_channel(address)
+            # TODO: Initialize stub when proto definitions are added
+            logger.info(f"Connected to Rust engine at {address}")
+        except Exception as e:
+            logger.error(f"Failed to connect to Rust engine: {e}")
+            raise
+
+    async def compute_similarity(
+        self,
+        query_embedding: np.ndarray,
+        corpus_embeddings: List[np.ndarray],
+        distortion: float = 0.5
+    ) -> List[Tuple[int, float]]:
+        """
+        Compute sublinear similarity between query and corpus
+
+        Args:
+            query_embedding: Query vector
+            corpus_embeddings: List of corpus vectors
+            distortion: JL distortion parameter
+
+        Returns:
+            List of (index, similarity_score) tuples
+        """
+        logger.info(f"Computing sublinear similarity for {len(corpus_embeddings)} vectors")
+
+        try:
+            # TODO: Implement gRPC call when proto is defined
+            # For now, use placeholder local computation
+
+            # Placeholder: Use simple cosine similarity
+            similarities = []
+            for idx, corpus_vec in enumerate(corpus_embeddings):
+                sim = self._cosine_similarity(query_embedding, corpus_vec)
+                similarities.append((idx, sim))
+
+            # Sort by similarity descending
+            similarities.sort(key=lambda x: x[1], reverse=True)
+
+            logger.info(f"Computed {len(similarities)} similarities")
+            return similarities
+
+        except Exception as e:
+            logger.error(f"Similarity computation error: {e}")
+            raise
+
+    async def compare_vectors(
+        self,
+        vec_a: np.ndarray,
+        vec_b: np.ndarray,
+        distortion: float = 0.5
+    ) -> Dict[str, Any]:
+        """
+        Compare two vectors using sublinear algorithm
+
+        Args:
+            vec_a: First vector
+            vec_b: Second vector
+            distortion: JL distortion parameter
+
+        Returns:
+            Comparison result with similarity and complexity
+        """
+        try:
+            # TODO: Implement gRPC call
+
+            similarity = self._cosine_similarity(vec_a, vec_b)
+
+            return {
+                "similarity": float(similarity),
+                "complexity": f"O(log {len(vec_a)})",
+                "method": "sublinear_jl",
+                "distortion": distortion
+            }
+
+        except Exception as e:
+            logger.error(f"Vector comparison error: {e}")
+            raise
+
+    async def analyze_matrix(
+        self,
+        matrix: np.ndarray
+    ) -> Dict[str, Any]:
+        """
+        Analyze matrix properties for optimal algorithm selection
+
+        Args:
+            matrix: Matrix to analyze
+
+        Returns:
+            Analysis result
+        """
+        try:
+            # TODO: Implement gRPC call
+
+            # Placeholder analysis
+            is_sparse = np.count_nonzero(matrix) / matrix.size < 0.3
+            is_symmetric = np.allclose(matrix, matrix.T)
+
+            return {
+                "is_sparse": is_sparse,
+                "is_symmetric": is_symmetric,
+                "is_diagonally_dominant": self._check_diagonal_dominance(matrix),
+                "recommended_method": "neumann" if is_sparse else "direct",
+                "complexity_estimate": "O(log n)"
+            }
+
+        except Exception as e:
+            logger.error(f"Matrix analysis error: {e}")
+            raise
+
+    def _cosine_similarity(self, a: np.ndarray, b: np.ndarray) -> float:
+        """Compute cosine similarity between two vectors"""
+        dot_product = np.dot(a, b)
+        norm_a = np.linalg.norm(a)
+        norm_b = np.linalg.norm(b)
+
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+
+        return float(dot_product / (norm_a * norm_b))
+
+    def _check_diagonal_dominance(self, matrix: np.ndarray) -> bool:
+        """Check if matrix is diagonally dominant"""
+        n = matrix.shape[0]
+
+        for i in range(n):
+            diagonal = abs(matrix[i, i])
+            row_sum = sum(abs(matrix[i, j]) for j in range(n) if j != i)
+
+            if diagonal <= row_sum:
+                return False
+
+        return True
+
+    async def close(self):
+        """Close gRPC connection"""
+        if self.channel:
+            await self.channel.close()
+            logger.info("Closed connection to Rust engine")

mcp/endpoints/query.py

@@ -0,0 +1,144 @@
+"""
+Query endpoint implementation
+Handles leverage discovery queries
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import List, Optional
+import logging
+import numpy as np
+
+from ..reasoning.embeddings import EmbeddingService
+from ..reasoning.fact_cache import FACTCache
+from ..reasoning.safla_agent import SAFLAAgent
+from ..bindings.rust_client import RustSublinearClient
+from ..storage.db import RuvScanDB
+from ..storage.models import LeverageCard
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Initialize services
+embedding_service = EmbeddingService()
+fact_cache = FACTCache()
+safla_agent = SAFLAAgent(fact_cache)
+rust_client = RustSublinearClient()
+
+class QueryRequest(BaseModel):
+    """Request to query for leverage"""
+    intent: str = Field(..., min_length=10)
+    max_results: int = Field(10, gt=0, le=100)
+    min_score: float = Field(0.7, ge=0.0, le=1.0)
+
+@router.post("/query", response_model=List[LeverageCard])
+async def query_leverage(request: QueryRequest):
+    """
+    Query for leverage cards based on user intent
+
+    Uses sublinear similarity and SAFLA reasoning to find relevant repos
+    """
+    logger.info(f"Querying intent: {request.intent[:100]}...")
+
+    try:
+        # Check FACT cache first
+        cached = fact_cache.get(f"query:{request.intent}")
+        if cached:
+            logger.info("Returning cached query results")
+            import json
+            return json.loads(cached['response'])
+
+        # Generate embedding for intent
+        logger.info("Generating embedding for query intent")
+        intent_embedding = await embedding_service.embed_text(request.intent)
+
+        # Get all repo embeddings from database
+        # TODO: Implement database retrieval
+        # For now, create mock data
+        mock_repos = create_mock_repos()
+
+        # Compute similarities using Rust engine
+        logger.info(f"Computing sublinear similarity against {len(mock_repos)} repos")
+        corpus_embeddings = [repo['embedding'] for repo in mock_repos]
+
+        similarities = await rust_client.compute_similarity(
+            intent_embedding,
+            corpus_embeddings,
+            distortion=0.5
+        )
+
+        # Filter by minimum score
+        filtered = [
+            (idx, score) for idx, score in similarities
+            if score >= request.min_score
+        ][:request.max_results]
+
+        logger.info(f"Found {len(filtered)} repos above threshold {request.min_score}")
+
+        # Generate leverage cards with SAFLA reasoning
+        leverage_cards = []
+        for idx, score in filtered:
+            repo_data = mock_repos[idx]
+
+            # Generate SAFLA reasoning
+            card = safla_agent.generate_leverage_card(
+                repo_data=repo_data,
+                query_intent=request.intent,
+                similarity_score=score
+            )
+
+            leverage_cards.append(LeverageCard(**card))
+
+        # Cache results
+        import json
+        fact_cache.set(
+            f"query:{request.intent}",
+            json.dumps([card.dict() for card in leverage_cards]),
+            metadata={"query_length": len(request.intent)}
+        )
+
+        logger.info(f"Returning {len(leverage_cards)} leverage cards")
+        return leverage_cards
+
+    except Exception as e:
+        logger.error(f"Query error: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+def create_mock_repos() -> List[dict]:
+    """Create mock repository data for testing"""
+    return [
+        {
+            "id": 1,
+            "full_name": "ruvnet/sublinear-time-solver",
+            "name": "sublinear-time-solver",
+            "org": "ruvnet",
+            "description": "TRUE O(log n) matrix solver with consciousness exploration",
+            "capabilities": ["O(log n) solving", "WASM acceleration", "MCP integration"],
+            "embedding": np.random.randn(1536),
+            "stars": 150,
+            "language": "Rust"
+        },
+        {
+            "id": 2,
+            "full_name": "ruvnet/FACT",
+            "name": "FACT",
+            "org": "ruvnet",
+            "description": "Framework for Autonomous Context Tracking - deterministic caching",
+            "capabilities": ["Deterministic caching", "Prompt replay", "Context management"],
+            "embedding": np.random.randn(1536),
+            "stars": 85,
+            "language": "Python"
+        },
+        {
+            "id": 3,
+            "full_name": "ruvnet/MidStream",
+            "name": "MidStream",
+            "org": "ruvnet",
+            "description": "Real-time streaming and inflight data processing",
+            "capabilities": ["Streaming", "Real-time processing", "Async channels"],
+            "embedding": np.random.randn(1536),
+            "stars": 120,
+            "language": "Rust"
+        }
+    ]

mcp/endpoints/scan.py

@@ -0,0 +1,112 @@
+"""
+Scan endpoint implementation
+Handles GitHub repository scanning
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional
+import logging
+import httpx
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class ScanRequest(BaseModel):
+    """Request to scan GitHub org/user/topic"""
+    source_type: str = Field(..., pattern="^(org|user|topic)$")
+    source_name: str
+    limit: int = Field(50, gt=0, le=1000)
+
+class ScanResponse(BaseModel):
+    """Scan response"""
+    status: str
+    source_type: str
+    source_name: str
+    estimated_repos: int
+    message: str
+    job_id: Optional[str] = None
+
+@router.post("/scan", response_model=ScanResponse)
+async def scan_repos(request: ScanRequest):
+    """
+    Trigger GitHub scanning for org/user/topic
+
+    This endpoint initiates concurrent Go workers to fetch and analyze repos
+    """
+    logger.info(f"Scanning {request.source_type}: {request.source_name}")
+
+    try:
+        # TODO: Implement actual Go scanner triggering
+        # For now, return a mock response
+
+        # In production, this would:
+        # 1. Queue a scan job
+        # 2. Trigger Go workers via REST/gRPC
+        # 3. Store job in database
+        # 4. Return job ID for tracking
+
+        return ScanResponse(
+            status="initiated",
+            source_type=request.source_type,
+            source_name=request.source_name,
+            estimated_repos=request.limit,
+            message=f"Scan initiated for {request.source_type}/{request.source_name}",
+            job_id=f"scan_{request.source_type}_{request.source_name}"
+        )
+
+    except Exception as e:
+        logger.error(f"Scan error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/ingest")
+async def ingest_repo_data(repo_data: dict):
+    """
+    Ingest repository data from Go scanner workers
+
+    This endpoint receives repo metadata, README, and other data
+    from concurrent Go scanner workers
+    """
+    logger.info(f"Ingesting repo data: {repo_data.get('full_name', 'unknown')}")
+
+    try:
+        # TODO: Implement actual ingestion
+        # 1. Validate repo data
+        # 2. Generate embeddings
+        # 3. Store in database
+        # 4. Update scan job status
+
+        return {
+            "status": "ingested",
+            "repo": repo_data.get("full_name"),
+            "message": "Repository data ingested successfully"
+        }
+
+    except Exception as e:
+        logger.error(f"Ingest error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/scan/{job_id}/status")
+async def get_scan_status(job_id: str):
+    """
+    Get status of a scan job
+
+    Returns current progress, repos found, and completion status
+    """
+    logger.info(f"Checking scan status: {job_id}")
+
+    try:
+        # TODO: Query database for job status
+
+        return {
+            "job_id": job_id,
+            "status": "in_progress",
+            "repos_found": 0,
+            "repos_processed": 0,
+            "completion_percentage": 0.0
+        }
+
+    except Exception as e:
+        logger.error(f"Status check error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

mcp/mcp_stdio_server.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+RuvScan MCP Server (STDIO Transport)
+For use with Claude Code CLI, Codex, and Claude Desktop
+"""
+
+import asyncio
+import os
+import sys
+from typing import Any
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+# Initialize FastMCP server
+mcp = FastMCP("ruvscan")
+
+# Get API endpoint from environment (defaults to localhost if running locally)
+RUVSCAN_API = os.getenv("RUVSCAN_API_URL", "http://localhost:8000")
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN", "")
+
+
+@mcp.tool()
+async def scan_github(
+    source_type: str,
+    source_name: str,
+    limit: int = 50
+) -> str:
+    """Scan GitHub organization, user, or topic for repositories.
+
+    Args:
+        source_type: Type of source - 'org', 'user', or 'topic'
+        source_name: Name of the organization, user, or topic keyword
+        limit: Maximum number of repositories to scan (default: 50)
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                f"{RUVSCAN_API}/scan",
+                json={
+                    "source_type": source_type,
+                    "source_name": source_name,
+                    "limit": limit
+                },
+                headers={"Authorization": f"Bearer {GITHUB_TOKEN}"} if GITHUB_TOKEN else {},
+                timeout=30.0
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            return f"""Scan initiated for {source_type}: {source_name}
+Status: {data.get('status', 'unknown')}
+Estimated repositories: {data.get('estimated_repos', limit)}
+Message: {data.get('message', 'Processing')}
+"""
+        except Exception as e:
+            return f"Error scanning GitHub: {str(e)}"
+
+
+@mcp.tool()
+async def query_leverage(
+    intent: str,
+    max_results: int = 10,
+    min_score: float = 0.7
+) -> str:
+    """Query for leverage opportunities based on your intent or problem.
+
+    Args:
+        intent: Your problem statement or what you're trying to build
+        max_results: Maximum number of results to return (default: 10)
+        min_score: Minimum relevance score from 0-1 (default: 0.7)
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                f"{RUVSCAN_API}/query",
+                json={
+                    "intent": intent,
+                    "max_results": max_results,
+                    "min_score": min_score
+                },
+                timeout=30.0
+            )
+            response.raise_for_status()
+            cards = response.json()
+
+            if not cards:
+                return f"No leverage opportunities found for: {intent}"
+
+            results = []
+            for card in cards:
+                result = f"""
+Repository: {card['repo']}
+Relevance Score: {card['relevance_score']:.2f}
+Complexity: {card.get('runtime_complexity', 'N/A')}
+
+Summary: {card['summary']}
+
+Why This Helps: {card['outside_box_reasoning']}
+
+How to Use: {card['integration_hint']}
+
+Capabilities: {', '.join(card['capabilities'])}
+{'(Cached Result)' if card.get('cached') else ''}
+"""
+                results.append(result)
+
+            return "\n" + "="*80 + "\n".join(results)
+
+        except Exception as e:
+            return f"Error querying leverage: {str(e)}"
+
+
+@mcp.tool()
+async def compare_repositories(
+    repo_a: str,
+    repo_b: str
+) -> str:
+    """Compare two GitHub repositories using sublinear similarity.
+
+    Args:
+        repo_a: First repository in format 'org/repo'
+        repo_b: Second repository in format 'org/repo'
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                f"{RUVSCAN_API}/compare",
+                json={
+                    "repo_a": repo_a,
+                    "repo_b": repo_b
+                },
+                timeout=30.0
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            return f"""
+Repository Comparison (O(log n) complexity)
+
+{repo_a} vs {repo_b}
+
+Similarity Score: {data.get('similarity_score', 0):.2f}
+Complexity: {data.get('complexity', 'O(log n)')}
+
+Analysis: {data.get('analysis', 'Comparison complete')}
+"""
+        except Exception as e:
+            return f"Error comparing repositories: {str(e)}"
+
+
+@mcp.tool()
+async def analyze_reasoning(repo: str) -> str:
+    """Analyze and replay the reasoning chain for a repository using FACT cache.
+
+    Args:
+        repo: Repository name in format 'org/repo'
+    """
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                f"{RUVSCAN_API}/analyze",
+                params={"repo": repo},
+                timeout=30.0
+            )
+            response.raise_for_status()
+            data = response.json()
+
+            trace = data.get('reasoning_trace', [])
+            if not trace:
+                return f"No reasoning trace available for {repo}"
+
+            result = f"Reasoning Chain for {repo}:\n\n"
+            for step in trace:
+                result += f"- {step}\n"
+
+            if data.get('cached'):
+                result += "\n(Retrieved from FACT deterministic cache)"
+
+            return result
+
+        except Exception as e:
+            return f"Error analyzing reasoning: {str(e)}"
+
+
+@mcp.resource("ruvscan://status")
+async def get_status() -> str:
+    """Get RuvScan server status and health."""
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(f"{RUVSCAN_API}/health", timeout=5.0)
+            response.raise_for_status()
+            data = response.json()
+
+            return f"""RuvScan Server Status
+
+Status: {data.get('status', 'unknown')}
+Version: {data.get('version', '0.5.0')}
+Service: {data.get('service', 'RuvScan MCP Server')}
+API Endpoint: {RUVSCAN_API}
+"""
+        except Exception as e:
+            return f"Server unreachable: {str(e)}\n\nMake sure the RuvScan API server is running:\ndocker-compose up -d"
+
+
+def main():
+    """Run the MCP server using stdio transport."""
+    # Initialize and run the server
+    mcp.run(transport='stdio')
+
+
+if __name__ == "__main__":
+    main()