empathy-framework 5.1.1__py3-none-any.whl → 5.3.0__py3-none-any.whl

empathy_os/mcp/server.py

@@ -0,0 +1,506 @@
+"""Empathy Framework MCP Server Implementation.
+
+Exposes Empathy workflows as MCP tools for Claude Code integration.
+"""
+import asyncio
+import json
+import logging
+import sys
+from typing import Any
+
+# MCP server will be implemented using stdio transport
+logger = logging.getLogger(__name__)
+
+
+class EmpathyMCPServer:
+    """MCP server for Empathy Framework workflows.
+
+    Exposes workflows, agent dashboard, and telemetry as MCP tools
+    that can be invoked from Claude Code.
+    """
+
+    def __init__(self):
+        """Initialize the MCP server."""
+        self.tools = self._register_tools()
+        self.resources = self._register_resources()
+
+    def _register_tools(self) -> dict[str, dict[str, Any]]:
+        """Register available MCP tools.
+
+        Returns:
+            Dictionary of tool definitions
+        """
+        return {
+            "security_audit": {
+                "name": "security_audit",
+                "description": "Run security audit workflow on codebase. Detects vulnerabilities, dangerous patterns, and security issues. Returns findings with severity levels.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to directory or file to audit"
+                        }
+                    },
+                    "required": ["path"]
+                }
+            },
+            "bug_predict": {
+                "name": "bug_predict",
+                "description": "Run bug prediction workflow. Analyzes code patterns and predicts potential bugs before they occur.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to directory or file to analyze"
+                        }
+                    },
+                    "required": ["path"]
+                }
+            },
+            "code_review": {
+                "name": "code_review",
+                "description": "Run code review workflow. Provides comprehensive code quality analysis with suggestions for improvement.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to directory or file to review"
+                        }
+                    },
+                    "required": ["path"]
+                }
+            },
+            "test_generation": {
+                "name": "test_generation",
+                "description": "Generate tests for code. Can batch generate tests for multiple modules in parallel.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "module": {
+                            "type": "string",
+                            "description": "Path to Python module"
+                        },
+                        "batch": {
+                            "type": "boolean",
+                            "description": "Enable batch mode for parallel generation",
+                            "default": False
+                        }
+                    },
+                    "required": ["module"]
+                }
+            },
+            "performance_audit": {
+                "name": "performance_audit",
+                "description": "Run performance audit workflow. Identifies bottlenecks, memory leaks, and optimization opportunities.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to directory or file to audit"
+                        }
+                    },
+                    "required": ["path"]
+                }
+            },
+            "release_prep": {
+                "name": "release_prep",
+                "description": "Run release preparation workflow. Checks health, security, changelog, and provides release recommendation.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to project root",
+                            "default": "."
+                        }
+                    }
+                }
+            },
+            "auth_status": {
+                "name": "auth_status",
+                "description": "Get authentication strategy status. Shows current configuration, subscription tier, and default mode.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {}
+                }
+            },
+            "auth_recommend": {
+                "name": "auth_recommend",
+                "description": "Get authentication recommendation for a file. Analyzes LOC and suggests optimal auth mode.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {
+                            "type": "string",
+                            "description": "Path to file to analyze"
+                        }
+                    },
+                    "required": ["file_path"]
+                }
+            },
+            "telemetry_stats": {
+                "name": "telemetry_stats",
+                "description": "Get telemetry statistics. Shows cost savings, cache hit rates, and workflow performance.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "days": {
+                            "type": "integer",
+                            "description": "Number of days to analyze",
+                            "default": 30
+                        }
+                    }
+                }
+            },
+            "dashboard_status": {
+                "name": "dashboard_status",
+                "description": "Get agent coordination dashboard status. Shows active agents, pending approvals, recent signals.",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {}
+                }
+            }
+        }
+
+    def _register_resources(self) -> dict[str, dict[str, Any]]:
+        """Register available MCP resources.
+
+        Returns:
+            Dictionary of resource definitions
+        """
+        return {
+            "workflows": {
+                "uri": "empathy://workflows",
+                "name": "Available Workflows",
+                "description": "List of all available Empathy workflows",
+                "mime_type": "application/json"
+            },
+            "auth_config": {
+                "uri": "empathy://auth/config",
+                "name": "Authentication Configuration",
+                "description": "Current authentication strategy configuration",
+                "mime_type": "application/json"
+            },
+            "telemetry": {
+                "uri": "empathy://telemetry",
+                "name": "Telemetry Data",
+                "description": "Cost tracking and performance metrics",
+                "mime_type": "application/json"
+            }
+        }
+
+    async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+        """Execute a tool call.
+
+        Args:
+            tool_name: Name of the tool to execute
+            arguments: Tool arguments
+
+        Returns:
+            Tool execution result
+        """
+        try:
+            if tool_name == "security_audit":
+                return await self._run_security_audit(arguments)
+            elif tool_name == "bug_predict":
+                return await self._run_bug_predict(arguments)
+            elif tool_name == "code_review":
+                return await self._run_code_review(arguments)
+            elif tool_name == "test_generation":
+                return await self._run_test_generation(arguments)
+            elif tool_name == "performance_audit":
+                return await self._run_performance_audit(arguments)
+            elif tool_name == "release_prep":
+                return await self._run_release_prep(arguments)
+            elif tool_name == "auth_status":
+                return await self._get_auth_status()
+            elif tool_name == "auth_recommend":
+                return await self._get_auth_recommend(arguments)
+            elif tool_name == "telemetry_stats":
+                return await self._get_telemetry_stats(arguments)
+            elif tool_name == "dashboard_status":
+                return await self._get_dashboard_status()
+            else:
+                return {
+                    "success": False,
+                    "error": f"Unknown tool: {tool_name}"
+                }
+        except Exception as e:
+            logger.exception(f"Tool execution failed: {tool_name}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    async def _run_security_audit(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Run security audit workflow."""
+        from empathy_os.workflows.security_audit import SecurityAuditWorkflow
+
+        workflow = SecurityAuditWorkflow()
+        result = await workflow.execute(path=args["path"])
+
+        return {
+            "success": result.success,
+            "score": result.final_output.get("health_score"),
+            "findings": result.final_output.get("findings", []),
+            "cost": result.cost_report.total_cost,
+            "provider": result.provider
+        }
+
+    async def _run_bug_predict(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Run bug prediction workflow."""
+        from empathy_os.workflows.bug_predict import BugPredictWorkflow
+
+        workflow = BugPredictWorkflow()
+        result = await workflow.execute(path=args["path"])
+
+        return {
+            "success": result.success,
+            "predictions": result.final_output.get("predictions", []),
+            "cost": result.cost_report.total_cost
+        }
+
+    async def _run_code_review(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Run code review workflow."""
+        from empathy_os.workflows.code_review import CodeReviewWorkflow
+
+        workflow = CodeReviewWorkflow()
+        result = await workflow.execute(target_path=args["path"])
+
+        return {
+            "success": result.success,
+            "feedback": result.final_output.get("feedback"),
+            "score": result.final_output.get("quality_score"),
+            "cost": result.cost_report.total_cost
+        }
+
+    async def _run_test_generation(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Run test generation workflow."""
+        from empathy_os.workflows.test_gen import TestGenerationWorkflow
+
+        workflow = TestGenerationWorkflow()
+        result = await workflow.execute(module_path=args["module"])
+
+        return {
+            "success": result.success,
+            "tests_generated": result.final_output.get("tests_generated", 0),
+            "output_path": result.final_output.get("output_path"),
+            "cost": result.cost_report.total_cost
+        }
+
+    async def _run_performance_audit(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Run performance audit workflow."""
+        from empathy_os.workflows.perf_audit import PerformanceAuditWorkflow
+
+        workflow = PerformanceAuditWorkflow()
+        result = await workflow.execute(path=args["path"])
+
+        return {
+            "success": result.success,
+            "findings": result.final_output.get("findings", []),
+            "score": result.final_output.get("score"),
+            "cost": result.cost_report.total_cost
+        }
+
+    async def _run_release_prep(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Run release preparation workflow."""
+        from empathy_os.workflows.release_prep import ReleasePreparationWorkflow
+
+        workflow = ReleasePreparationWorkflow(skip_approve_if_clean=True)
+        result = await workflow.execute(path=args.get("path", "."))
+
+        return {
+            "success": result.success,
+            "approved": result.final_output.get("approved"),
+            "health_score": result.final_output.get("health_score"),
+            "recommendation": result.final_output.get("recommendation"),
+            "cost": result.cost_report.total_cost
+        }
+
+    async def _get_auth_status(self) -> dict[str, Any]:
+        """Get authentication strategy status."""
+        from empathy_os.models import AuthStrategy
+
+        strategy = AuthStrategy.load()
+
+        return {
+            "success": True,
+            "subscription_tier": strategy.subscription_tier.value,
+            "default_mode": strategy.default_mode.value,
+            "setup_completed": strategy.setup_completed
+        }
+
+    async def _get_auth_recommend(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Get authentication recommendation."""
+        from pathlib import Path
+
+        from empathy_os.models import (
+            count_lines_of_code,
+            get_auth_strategy,
+            get_module_size_category,
+        )
+
+        file_path = Path(args["file_path"])
+        lines = count_lines_of_code(file_path)
+        category = get_module_size_category(lines)
+
+        strategy = get_auth_strategy()
+        recommended = strategy.get_recommended_mode(lines)
+
+        return {
+            "success": True,
+            "file_path": str(file_path),
+            "lines_of_code": lines,
+            "category": category,
+            "recommended_mode": recommended.value
+        }
+
+    async def _get_telemetry_stats(self, args: dict[str, Any]) -> dict[str, Any]:
+        """Get telemetry statistics."""
+        # Placeholder - would integrate with actual telemetry system
+        return {
+            "success": True,
+            "days": args.get("days", 30),
+            "total_cost": 0.0,
+            "savings": 0.0,
+            "cache_hit_rate": 0.0
+        }
+
+    async def _get_dashboard_status(self) -> dict[str, Any]:
+        """Get dashboard status."""
+        # Placeholder - would integrate with actual dashboard
+        return {
+            "success": True,
+            "active_agents": 0,
+            "pending_approvals": 0,
+            "recent_signals": 0
+        }
+
+    def get_tool_list(self) -> list[dict[str, Any]]:
+        """Get list of available tools.
+
+        Returns:
+            List of tool definitions
+        """
+        return list(self.tools.values())
+
+    def get_resource_list(self) -> list[dict[str, Any]]:
+        """Get list of available resources.
+
+        Returns:
+            List of resource definitions
+        """
+        return list(self.resources.values())
+
+
+async def handle_request(server: EmpathyMCPServer, request: dict[str, Any]) -> dict[str, Any]:
+    """Handle an MCP request.
+
+    Args:
+        server: MCP server instance
+        request: MCP request
+
+    Returns:
+        MCP response
+    """
+    method = request.get("method")
+    params = request.get("params", {})
+
+    if method == "tools/list":
+        return {
+            "tools": server.get_tool_list()
+        }
+    elif method == "tools/call":
+        tool_name = params.get("name")
+        arguments = params.get("arguments", {})
+        result = await server.call_tool(tool_name, arguments)
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": json.dumps(result, indent=2)
+                }
+            ]
+        }
+    elif method == "resources/list":
+        return {
+            "resources": server.get_resource_list()
+        }
+    else:
+        return {
+            "error": {
+                "code": -32601,
+                "message": f"Method not found: {method}"
+            }
+        }
+
+
+async def main_loop():
+    """Main MCP server loop using stdio transport."""
+    server = EmpathyMCPServer()
+
+    logger.info("Empathy MCP Server started")
+    logger.info(f"Registered {len(server.tools)} tools")
+
+    while True:
+        try:
+            # Read request from stdin (JSON-RPC format)
+            line = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
+            if not line:
+                break
+
+            request = json.loads(line)
+            response = await handle_request(server, request)
+
+            # Write response to stdout
+            print(json.dumps(response), flush=True)
+
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON: {e}")
+            error_response = {
+                "error": {
+                    "code": -32700,
+                    "message": "Parse error"
+                }
+            }
+            print(json.dumps(error_response), flush=True)
+        except Exception as e:
+            logger.exception("Error handling request")
+            error_response = {
+                "error": {
+                    "code": -32603,
+                    "message": str(e)
+                }
+            }
+            print(json.dumps(error_response), flush=True)
+
+
+def create_server() -> EmpathyMCPServer:
+    """Create and return an Empathy MCP server instance.
+
+    Returns:
+        Configured MCP server
+    """
+    return EmpathyMCPServer()
+
+
+def main():
+    """Entry point for MCP server."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[logging.FileHandler('/tmp/empathy-mcp.log')]
+    )
+
+    try:
+        asyncio.run(main_loop())
+    except KeyboardInterrupt:
+        logger.info("Empathy MCP Server stopped")
+
+
+if __name__ == "__main__":
+    main()

empathy_os/memory/control_panel.py

@@ -29,17 +29,14 @@ Licensed under Fair Source 0.9
 """
 
 import argparse
-import hashlib
 import json
 import logging
-import os
 import re
 import signal
 import ssl
 import sys
 import time
 import warnings
-from collections import defaultdict
 from dataclasses import asdict, dataclass
 from datetime import datetime
 from http.server import BaseHTTPRequestHandler, HTTPServer
@@ -49,6 +46,7 @@ from urllib.parse import parse_qs, urlparse
 
 import structlog
 
+from .control_panel_support import APIKeyAuth, MemoryStats, RateLimiter
 from .long_term import Classification, SecureMemDocsIntegration
 from .redis_bootstrap import (
     RedisStartMethod,
@@ -198,134 +196,6 @@ def _validate_file_path(path: str, allowed_dir: str | None = None) -> Path:
     return resolved
 
 
-class RateLimiter:
-    """Simple in-memory rate limiter by IP address."""
-
-    def __init__(self, window_seconds: int = 60, max_requests: int = 100):
-        """Initialize rate limiter.
-
-        Args:
-            window_seconds: Time window in seconds
-            max_requests: Maximum requests allowed per window
-
-        Raises:
-            ValueError: If window_seconds or max_requests is invalid
-
-        """
-        if window_seconds < 1:
-            raise ValueError(f"window_seconds must be positive, got {window_seconds}")
-
-        if max_requests < 1:
-            raise ValueError(f"max_requests must be positive, got {max_requests}")
-
-        self.window_seconds = window_seconds
-        self.max_requests = max_requests
-        self._requests: dict[str, list[float]] = defaultdict(list)
-
-    def is_allowed(self, client_ip: str) -> bool:
-        """Check if request is allowed for this IP.
-
-        Args:
-            client_ip: The client IP address
-
-        Returns:
-            True if allowed, False if rate limited
-
-        """
-        now = time.time()
-        window_start = now - self.window_seconds
-
-        # Clean old entries
-        self._requests[client_ip] = [ts for ts in self._requests[client_ip] if ts > window_start]
-
-        # Check if over limit
-        if len(self._requests[client_ip]) >= self.max_requests:
-            logger.warning("rate_limit_exceeded", client_ip=client_ip)
-            return False
-
-        # Record this request
-        self._requests[client_ip].append(now)
-        return True
-
-    def get_remaining(self, client_ip: str) -> int:
-        """Get remaining requests for this IP."""
-        now = time.time()
-        window_start = now - self.window_seconds
-        recent = [ts for ts in self._requests[client_ip] if ts > window_start]
-        return max(0, self.max_requests - len(recent))
-
-
-class APIKeyAuth:
-    """Simple API key authentication."""
-
-    def __init__(self, api_key: str | None = None):
-        """Initialize API key auth.
-
-        Args:
-            api_key: The API key to require. If None, reads from
-                     EMPATHY_MEMORY_API_KEY env var. If still None, auth is disabled.
-
-        """
-        self.api_key = api_key or os.environ.get("EMPATHY_MEMORY_API_KEY")
-        self.enabled = bool(self.api_key)
-        self._key_hash: str | None = None
-        if self.enabled and self.api_key:
-            # Store hash of API key for comparison
-            self._key_hash = hashlib.sha256(self.api_key.encode()).hexdigest()
-            logger.info("api_key_auth_enabled")
-        else:
-            logger.info("api_key_auth_disabled", reason="no_key_configured")
-
-    def is_valid(self, provided_key: str | None) -> bool:
-        """Check if provided API key is valid.
-
-        Args:
-            provided_key: The key provided in the request
-
-        Returns:
-            True if valid or auth disabled, False otherwise
-
-        """
-        if not self.enabled:
-            return True
-
-        if not provided_key:
-            return False
-
-        # Constant-time comparison via hash
-        provided_hash = hashlib.sha256(provided_key.encode()).hexdigest()
-        return provided_hash == self._key_hash
-
-
-@dataclass
-class MemoryStats:
-    """Statistics for memory system."""
-
-    # Redis stats
-    redis_available: bool = False
-    redis_method: str = "none"
-    redis_keys_total: int = 0
-    redis_keys_working: int = 0
-    redis_keys_staged: int = 0
-    redis_memory_used: str = "0"
-
-    # Long-term stats
-    long_term_available: bool = False
-    patterns_total: int = 0
-    patterns_public: int = 0
-    patterns_internal: int = 0
-    patterns_sensitive: int = 0
-    patterns_encrypted: int = 0
-
-    # Performance stats
-    redis_ping_ms: float = 0.0
-    storage_bytes: int = 0
-    collection_time_ms: float = 0.0
-
-    # Timestamps
-    collected_at: str = ""
-
-
 @dataclass
 class ControlPanelConfig:
     """Configuration for control panel."""