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

empathy_os/cli_router.py

@@ -101,6 +101,14 @@ class HybridRouter:
             "explain": ("docs", "explain"),
             "document": ("docs", "generate"),
             "overview": ("docs", "overview"),
+            "docs-seo": ("workflows", "run seo-optimization --mode audit"),
+            # SEO commands → /workflows skill
+            "seo": ("workflows", "run seo-optimization --mode audit"),
+            "seo-audit": ("workflows", "run seo-optimization --mode audit"),
+            "seo-optimize": ("workflows", "run seo-optimization --mode fix"),
+            "optimize-seo": ("workflows", "run seo-optimization --mode suggest"),
+            "meta-tags": ("workflows", "run seo-optimization --mode audit"),
+            "check-seo": ("workflows", "run seo-optimization --mode audit"),
             # Plan commands → /plan skill
             "plan": ("plan", ""),
             "tdd": ("plan", "tdd"),
@@ -340,6 +348,7 @@ class HybridRouter:
             "code-review": ("dev", "review"),
             "test-gen": ("testing", "gen"),
             "perf-audit": ("workflows", "run perf-audit"),
+            "seo-optimization": ("workflows", "run seo-optimization"),
             "commit": ("dev", "commit"),
             "refactor": ("dev", "refactor"),
             "debug": ("dev", "debug"),

empathy_os/config.py

@@ -61,9 +61,22 @@ def _validate_file_path(path: str, allowed_dir: str | None = None) -> Path:
             raise ValueError(f"path must be within {allowed_dir}")
 
     # Check for dangerous system paths
-    dangerous_paths = ["/etc", "/sys", "/proc", "/dev"]
+    # Note: On macOS, /etc is a symlink to /private/etc, so we check both
+    dangerous_paths = [
+        "/etc",
+        "/sys",
+        "/proc",
+        "/dev",
+        "/private/etc",  # macOS: /etc -> /private/etc
+        "/private/var/root",  # macOS: root's home directory
+        "/usr/bin",  # System binaries
+        "/usr/sbin",  # System admin binaries
+        "/bin",  # Essential binaries
+        "/sbin",  # System binaries
+    ]
+    resolved_str = str(resolved)
     for dangerous in dangerous_paths:
-        if str(resolved).startswith(dangerous):
+        if resolved_str.startswith(dangerous + "/") or resolved_str == dangerous:
             raise ValueError(f"Cannot write to system directory: {dangerous}")
 
     return resolved

empathy_os/core_modules/__init__.py

@@ -0,0 +1,15 @@
+"""Core EmpathyOS Modules.
+
+Modular implementation of EmpathyOS functionality.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+# Core classes
+from ..core import CollaborationState, EmpathyOS
+
+__all__ = [
+    "EmpathyOS",
+    "CollaborationState",
+]

empathy_os/dashboard/simple_server.py

@@ -39,6 +39,8 @@ class DashboardHandler(BaseHTTPRequestHandler):
         # Route requests
         if path == "/" or path == "/index.html":
             self.serve_file("index.html", "text/html")
+        elif path == "/test.html":
+            self.serve_file("test.html", "text/html")
         elif path == "/static/style.css":
             self.serve_file("style.css", "text/css")
         elif path == "/static/app.js":
@@ -132,12 +134,15 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_health(self):
         """System health endpoint."""
         try:
-            coordinator = HeartbeatCoordinator()
-            has_redis = coordinator.memory is not None
+            from empathy_os.memory.short_term import RedisShortTermMemory
 
+            memory = RedisShortTermMemory()
+            has_redis = memory._client is not None
+
+            coordinator = HeartbeatCoordinator(memory=memory)
             active_agents = len(coordinator.get_active_agents()) if has_redis else 0
 
-            gate = ApprovalGate()
+            gate = ApprovalGate(memory=memory)
             pending_approvals = len(gate.get_pending_approvals()) if has_redis else 0
 
             self.send_json(
@@ -155,22 +160,24 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_agents(self):
         """List active agents."""
         try:
-            coordinator = HeartbeatCoordinator()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            coordinator = HeartbeatCoordinator(memory=memory)
             active_agents = coordinator.get_active_agents()
 
             result = []
-            for agent_id in active_agents:
-                heartbeat = coordinator.get_heartbeat(agent_id)
-                if heartbeat:
-                    result.append(
-                        {
-                            "agent_id": agent_id,
-                            "status": heartbeat.status,
-                            "last_seen": heartbeat.timestamp.isoformat(),
-                            "progress": heartbeat.progress,
-                            "current_task": heartbeat.current_task,
-                        }
-                    )
+            for agent in active_agents:
+                result.append(
+                    {
+                        "agent_id": agent.agent_id,
+                        "display_name": agent.display_name,
+                        "status": agent.status,
+                        "last_seen": agent.last_beat.isoformat(),
+                        "progress": agent.progress,
+                        "current_task": agent.current_task,
+                    }
+                )
 
             self.send_json(result)
         except Exception as e:
@@ -180,8 +187,11 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_agent_detail(self, agent_id: str):
         """Get specific agent details."""
         try:
-            coordinator = HeartbeatCoordinator()
-            heartbeat = coordinator.get_heartbeat(agent_id)
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            coordinator = HeartbeatCoordinator(memory=memory)
+            heartbeat = coordinator.get_agent_status(agent_id)
 
             if not heartbeat:
                 self.send_json({"error": f"Agent {agent_id} not found"}, status=404)
@@ -189,9 +199,9 @@ class DashboardHandler(BaseHTTPRequestHandler):
 
             self.send_json(
                 {
-                    "agent_id": agent_id,
+                    "agent_id": heartbeat.agent_id,
                     "status": heartbeat.status,
-                    "last_seen": heartbeat.timestamp.isoformat(),
+                    "last_seen": heartbeat.last_beat.isoformat(),
                     "progress": heartbeat.progress,
                     "current_task": heartbeat.current_task,
                     "metadata": heartbeat.metadata,
@@ -203,8 +213,12 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_signals(self, limit: int):
         """Get recent coordination signals."""
         try:
-            signals = CoordinationSignals()
-            recent = signals.get_recent_signals(limit=limit)
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            # Use broadcast target to get all signals (not just for dashboard)
+            signals = CoordinationSignals(memory=memory, agent_id="*")
+            recent = signals.get_pending_signals()[:limit]
 
             result = [
                 {
@@ -225,15 +239,18 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_events(self, event_type: str | None, limit: int):
         """Get recent events."""
         try:
-            streamer = EventStreamer()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            streamer = EventStreamer(memory=memory)
 
             if event_type:
-                events = list(streamer.get_recent_events(event_type, limit=limit))
+                events = list(streamer.get_recent_events(event_type, count=limit))
             else:
                 # Get events from multiple streams
                 all_events = []
                 for evt_type in ["agent_heartbeat", "coordination_signal", "workflow_progress"]:
-                    events = list(streamer.get_recent_events(evt_type, limit=20))
+                    events = list(streamer.get_recent_events(evt_type, count=20))
                     all_events.extend(events)
 
                 all_events.sort(key=lambda e: e.timestamp, reverse=True)
@@ -258,7 +275,10 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_approvals(self):
         """Get pending approvals."""
         try:
-            gate = ApprovalGate()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            gate = ApprovalGate(memory=memory)
             pending = gate.get_pending_approvals()
 
             result = [
@@ -281,7 +301,10 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_approve(self, request_id: str, reason: str):
         """Approve request."""
         try:
-            gate = ApprovalGate()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            gate = ApprovalGate(memory=memory)
             success = gate.respond_to_approval(
                 request_id=request_id, approved=True, responder="dashboard", reason=reason
             )
@@ -296,7 +319,10 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_reject(self, request_id: str, reason: str):
         """Reject request."""
         try:
-            gate = ApprovalGate()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            gate = ApprovalGate(memory=memory)
             success = gate.respond_to_approval(
                 request_id=request_id, approved=False, responder="dashboard", reason=reason
             )
@@ -311,7 +337,10 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_feedback_workflows(self):
         """Get workflow quality metrics."""
         try:
-            feedback = FeedbackLoop()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            feedback = FeedbackLoop(memory=memory)
 
             workflows = ["code-review", "test-generation", "refactoring"]
             results = []
@@ -340,7 +369,10 @@ class DashboardHandler(BaseHTTPRequestHandler):
     def api_underperforming(self, threshold: float):
         """Get underperforming stages."""
         try:
-            feedback = FeedbackLoop()
+            from empathy_os.memory.short_term import RedisShortTermMemory
+
+            memory = RedisShortTermMemory()
+            feedback = FeedbackLoop(memory=memory)
 
             workflows = ["code-review", "test-generation", "refactoring"]
             all_underperforming = []

empathy_os/mcp/__init__.py

@@ -0,0 +1,10 @@
+"""Empathy Framework MCP Server.
+
+Model Context Protocol integration for Claude Code.
+Exposes Empathy workflows, agents, and telemetry as MCP tools.
+"""
+
+__version__ = "5.1.1"
+__all__ = ["EmpathyMCPServer", "create_server"]
+
+from empathy_os.mcp.server import EmpathyMCPServer, create_server