monkeybrain-runtime 1.0.0__py3-none-any.whl

src/deepdive/elasticsearch_adapter.py

@@ -0,0 +1,110 @@
+"""Elasticsearch Adapter — aggregation and search persistence.
+
+The Aggregation Layer persists everything in Elasticsearch.
+Provides full-text search, semantic search, analytics, and dashboards.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from src.monkey_brain.persistence.adapters import IStoreAdapter
+from src.monkey_brain.persistence.events import PersistenceEvent, EventType
+
+
+class ElasticsearchAdapter(IStoreAdapter):
+    """Elasticsearch persistence adapter for aggregation."""
+    
+    def __init__(self, url: str = "http://localhost:9200"):
+        self._url = url
+        self._client = None
+        self._connected = False
+    
+    @property
+    def name(self) -> str:
+        return "elasticsearch"
+    
+    async def connect(self) -> None:
+        try:
+            from elasticsearch import AsyncElasticsearch
+            self._client = AsyncElasticsearch([self._url])
+            await self._client.ping()
+            self._connected = True
+        except ImportError:
+            self._connected = False
+        except Exception:
+            self._connected = False
+    
+    async def disconnect(self) -> None:
+        if self._client:
+            await self._client.close()
+        self._connected = False
+    
+    async def health(self) -> dict[str, Any]:
+        return {
+            "status": "healthy" if self._connected else "unhealthy",
+            "url": self._url,
+        }
+    
+    async def persist(self, event: PersistenceEvent) -> dict[str, Any]:
+        if not self._connected:
+            return {"status": "disconnected"}
+        
+        index = f"agentos-{event.entity_type}"
+        doc = {
+            "event_type": event.event_type.value,
+            "entity_type": event.entity_type,
+            "entity_id": event.entity_id,
+            "data": event.data,
+            "timestamp": event.timestamp,
+            "source": event.source,
+        }
+        
+        try:
+            result = await self._client.index(index=index, document=doc)
+            return {"status": "indexed", "index": index, "id": result["_id"]}
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+    
+    async def query(self, entity_type: str, entity_id: str | None = None) -> Any:
+        if not self._connected:
+            return None
+        
+        index = f"agentos-{entity_type}"
+        
+        if entity_id:
+            try:
+                result = await self._client.get(index=index, id=entity_id)
+                return result["_source"]
+            except Exception:
+                return None
+        
+        try:
+            result = await self._client.search(index=index, body={"query": {"match_all": {}}, "size": 100})
+            return [hit["_source"] for hit in result["hits"]["hits"]]
+        except Exception:
+            return []
+    
+    async def search(self, index: str, query: dict[str, Any], size: int = 100) -> list[dict]:
+        """Full-text search."""
+        if not self._connected:
+            return []
+        
+        try:
+            result = await self._client.search(index=index, body={"query": query, "size": size})
+            return [hit["_source"] for hit in result["hits"]["hits"]]
+        except Exception:
+            return []
+    
+    async def aggregate(self, index: str, aggs: dict[str, Any]) -> dict[str, Any]:
+        """Run aggregation query."""
+        if not self._connected:
+            return {}
+        
+        try:
+            result = await self._client.search(index=index, body={"size": 0, "aggs": aggs})
+            return result.get("aggregations", {})
+        except Exception:
+            return {}
+    
+    def is_connected(self) -> bool:
+        return self._connected

src/deepdive/fleet_analytics.py

@@ -0,0 +1,131 @@
+"""Fleet Analytics — cross-node analytics and metrics.
+
+Aggregates metrics and analytics across all edge nodes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class NodeMetrics:
+    """Metrics from a single edge node."""
+    
+    node_id: str = ""
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    executions: int = 0
+    success_rate: float = 0.0
+    avg_latency_ms: float = 0.0
+    capabilities_active: int = 0
+    memory_usage_bytes: int = 0
+    cpu_usage_percent: float = 0.0
+    storage_usage_bytes: int = 0
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class FleetMetrics:
+    """Aggregated metrics across all nodes."""
+    
+    fleet_id: str = ""
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    total_nodes: int = 0
+    total_executions: int = 0
+    avg_success_rate: float = 0.0
+    avg_latency_ms: float = 0.0
+    total_capabilities: int = 0
+    total_memory_bytes: int = 0
+    total_storage_bytes: int = 0
+    node_metrics: list[NodeMetrics] = field(default_factory=list)
+
+
+class FleetAnalytics:
+    """Aggregates analytics across edge nodes.
+    
+    Responsibilities:
+    - Collect node metrics
+    - Aggregate fleet-wide analytics
+    - Track trends over time
+    - Support dashboards
+    
+    Aggregation never performs cognition.
+    Aggregation never controls execution.
+    """
+    
+    def __init__(self, elasticsearch_adapter: Any = None):
+        self._es = elasticsearch_adapter
+        self._node_metrics: dict[str, list[NodeMetrics]] = {}
+        self._fleet_metrics: list[FleetMetrics] = []
+    
+    def record_node_metrics(self, metrics: NodeMetrics) -> None:
+        """Record metrics from an edge node."""
+        if metrics.node_id not in self._node_metrics:
+            self._node_metrics[metrics.node_id] = []
+        self._node_metrics[metrics.node_id].append(metrics)
+        
+        if len(self._node_metrics[metrics.node_id]) > 1000:
+            self._node_metrics[metrics.node_id] = self._node_metrics[metrics.node_id][-500:]
+    
+    def aggregate_fleet(self, fleet_id: str = "default") -> FleetMetrics:
+        """Aggregate metrics across all nodes."""
+        all_metrics = []
+        for node_metrics in self._node_metrics.values():
+            if node_metrics:
+                all_metrics.append(node_metrics[-1])
+        
+        if not all_metrics:
+            return FleetMetrics(fleet_id=fleet_id)
+        
+        fleet = FleetMetrics(
+            fleet_id=fleet_id,
+            total_nodes=len(all_metrics),
+            total_executions=sum(m.executions for m in all_metrics),
+            avg_success_rate=sum(m.success_rate for m in all_metrics) / len(all_metrics),
+            avg_latency_ms=sum(m.avg_latency_ms for m in all_metrics) / len(all_metrics),
+            total_capabilities=sum(m.capabilities_active for m in all_metrics),
+            total_memory_bytes=sum(m.memory_usage_bytes for m in all_metrics),
+            total_storage_bytes=sum(m.storage_usage_bytes for m in all_metrics),
+            node_metrics=all_metrics,
+        )
+        
+        self._fleet_metrics.append(fleet)
+        return fleet
+    
+    def get_node_history(self, node_id: str, limit: int = 100) -> list[NodeMetrics]:
+        return self._node_metrics.get(node_id, [])[-limit:]
+    
+    def get_fleet_history(self, limit: int = 100) -> list[FleetMetrics]:
+        return self._fleet_metrics[-limit:]
+    
+    async def persist_to_elasticsearch(self) -> dict[str, Any]:
+        """Persist aggregated metrics to Elasticsearch."""
+        if not self._es:
+            return {"status": "no_elasticsearch"}
+        
+        if self._fleet_metrics:
+            from src.monkey_brain.persistence.events import PersistenceEvent, EventType
+            latest = self._fleet_metrics[-1]
+            event = PersistenceEvent(
+                event_type=EventType.METRIC_RECORDED,
+                entity_type="fleet_metrics",
+                entity_id=latest.fleet_id,
+                data={
+                    "total_nodes": latest.total_nodes,
+                    "total_executions": latest.total_executions,
+                    "avg_success_rate": latest.avg_success_rate,
+                    "avg_latency_ms": latest.avg_latency_ms,
+                },
+            )
+            return await self._es.persist(event)
+        
+        return {"status": "no_data"}
+    
+    def summary(self) -> dict:
+        return {
+            "nodes_tracked": len(self._node_metrics),
+            "total_fleet_snapshots": len(self._fleet_metrics),
+        }

src/deepdive/knowledge_aggregator.py

@@ -0,0 +1,130 @@
+"""Knowledge Aggregation — cross-node knowledge synchronization.
+
+Aggregates knowledge and learnings across edge nodes.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from uuid import uuid4
+
+
+@dataclass
+class KnowledgeEntry:
+    """A knowledge entry from an edge node."""
+    
+    entry_id: str = field(default_factory=lambda: f"kb-{uuid4().hex[:12]}")
+    node_id: str = ""
+    knowledge_type: str = ""  # policy | capability | pattern | error | success
+    content: dict[str, Any] = field(default_factory=dict)
+    confidence: float = 0.0
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class AggregatedKnowledge:
+    """Aggregated knowledge across nodes."""
+    
+    aggregation_id: str = field(default_factory=lambda: f"agg-{uuid4().hex[:12]}")
+    knowledge_type: str = ""
+    entries: list[KnowledgeEntry] = field(default_factory=list)
+    total_nodes: int = 0
+    avg_confidence: float = 0.0
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+
+class KnowledgeAggregator:
+    """Aggregates knowledge across edge nodes.
+    
+    Responsibilities:
+    - Collect knowledge from nodes
+    - Merge similar knowledge
+    - Rank by confidence
+    - Support knowledge sync
+    
+    Aggregation never performs cognition.
+    Aggregation never controls execution.
+    """
+    
+    def __init__(self, elasticsearch_adapter: Any = None):
+        self._es = elasticsearch_adapter
+        self._entries: dict[str, list[KnowledgeEntry]] = {}
+    
+    def add_entry(self, entry: KnowledgeEntry) -> None:
+        """Add a knowledge entry from a node."""
+        key = f"{entry.knowledge_type}:{entry.node_id}"
+        if key not in self._entries:
+            self._entries[key] = []
+        self._entries[key].append(entry)
+        
+        if len(self._entries[key]) > 100:
+            self._entries[key] = self._entries[key][-50:]
+    
+    def aggregate(self, knowledge_type: str) -> AggregatedKnowledge:
+        """Aggregate knowledge of a specific type."""
+        entries = []
+        nodes = set()
+        
+        for key, node_entries in self._entries.items():
+            if key.startswith(knowledge_type):
+                entries.extend(node_entries)
+                for e in node_entries:
+                    nodes.add(e.node_id)
+        
+        entries.sort(key=lambda e: e.confidence, reverse=True)
+        
+        return AggregatedKnowledge(
+            knowledge_type=knowledge_type,
+            entries=entries[:100],
+            total_nodes=len(nodes),
+            avg_confidence=sum(e.confidence for e in entries) / len(entries) if entries else 0.0,
+        )
+    
+    def get_by_node(self, node_id: str) -> list[KnowledgeEntry]:
+        entries = []
+        for node_entries in self._entries.values():
+            entries.extend([e for e in node_entries if e.node_id == node_id])
+        return entries
+    
+    def get_by_type(self, knowledge_type: str) -> list[KnowledgeEntry]:
+        entries = []
+        for key, node_entries in self._entries.items():
+            if key.startswith(knowledge_type):
+                entries.extend(node_entries)
+        return entries
+    
+    async def persist_to_elasticsearch(self) -> dict[str, Any]:
+        """Persist aggregated knowledge to Elasticsearch."""
+        if not self._es:
+            return {"status": "no_elasticsearch"}
+        
+        aggregated = self.aggregate("policy")
+        if aggregated.entries:
+            from src.monkey_brain.persistence.events import PersistenceEvent, EventType
+            event = PersistenceEvent(
+                event_type=EventType.ENTITY_CREATED,
+                entity_type="knowledge_aggregation",
+                entity_id=aggregated.aggregation_id,
+                data={
+                    "knowledge_type": aggregated.knowledge_type,
+                    "total_nodes": aggregated.total_nodes,
+                    "avg_confidence": aggregated.avg_confidence,
+                    "entry_count": len(aggregated.entries),
+                },
+            )
+            return await self._es.persist(event)
+        
+        return {"status": "no_data"}
+    
+    def summary(self) -> dict:
+        types = set()
+        for key in self._entries:
+            ktype = key.split(":")[0]
+            types.add(ktype)
+        return {
+            "total_entries": sum(len(v) for v in self._entries.values()),
+            "knowledge_types": list(types),
+        }

src/homeostasis/__init__.py

@@ -0,0 +1,19 @@
+"""Control Plane — deployment, configuration, and fleet management.
+
+Control Plane never executes cognition.
+Control Plane never performs execution.
+"""
+
+from src.homeostasis.control_plane import (
+    ControlPlane,
+    NodeInfo,
+    NodeStatus,
+    DeploymentManifest,
+)
+
+__all__ = [
+    "ControlPlane",
+    "NodeInfo",
+    "NodeStatus",
+    "DeploymentManifest",
+]

src/homeostasis/control_plane.py

@@ -0,0 +1,159 @@
+"""Control Plane — deployment, configuration, and fleet management.
+
+The Control Plane never executes cognition.
+The Control Plane never performs execution.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+from uuid import uuid4
+
+
+class NodeStatus(str, Enum):
+    ONLINE = "online"
+    OFFLINE = "offline"
+    DEGRADED = "degraded"
+    UPDATING = "updating"
+
+
+@dataclass
+class NodeInfo:
+    """Information about an edge node."""
+    
+    node_id: str = field(default_factory=lambda: f"node-{uuid4().hex[:8]}")
+    name: str = ""
+    status: NodeStatus = NodeStatus.OFFLINE
+    version: str = ""
+    last_heartbeat: str = ""
+    capabilities: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class DeploymentManifest:
+    """Deployment manifest for edge nodes."""
+    
+    manifest_id: str = field(default_factory=lambda: f"deploy-{uuid4().hex[:8]}")
+    version: str = ""
+    target_nodes: list[str] = field(default_factory=list)
+    capabilities: list[str] = field(default_factory=list)
+    policy_updates: dict[str, Any] = field(default_factory=dict)
+    config_updates: dict[str, Any] = field(default_factory=dict)
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class ControlPlane:
+    """Control Plane for AgentOS fleet management.
+    
+    Responsibilities:
+    - Node registration and heartbeat
+    - Deployment management
+    - Configuration distribution
+    - Capability distribution
+    - Policy distribution
+    - Fleet monitoring
+    
+    Control Plane never executes cognition.
+    Control Plane never performs execution.
+    """
+    
+    def __init__(self):
+        self._nodes: dict[str, NodeInfo] = {}
+        self._deployments: list[DeploymentManifest] = []
+        self._configs: dict[str, dict[str, Any]] = {}
+        self._policies: dict[str, dict[str, Any]] = {}
+        self._lemon = None
+    
+    def set_lemon(self, lemon) -> None:
+        self._lemon = lemon
+    
+    # --- Node Management ---
+    
+    def register_node(self, node_id: str, name: str = "", version: str = "", **metadata: Any) -> NodeInfo:
+        node = NodeInfo(node_id=node_id, name=name, version=version, status=NodeStatus.ONLINE, metadata=metadata)
+        self._nodes[node_id] = node
+        if self._lemon:
+            self._lemon.counter("control_plane.nodes_registered")
+        return node
+    
+    def heartbeat(self, node_id: str) -> bool:
+        if node_id in self._nodes:
+            self._nodes[node_id].last_heartbeat = datetime.now(timezone.utc).isoformat()
+            self._nodes[node_id].status = NodeStatus.ONLINE
+            return True
+        return False
+    
+    def get_node(self, node_id: str) -> NodeInfo | None:
+        return self._nodes.get(node_id)
+    
+    def get_all_nodes(self) -> list[NodeInfo]:
+        return list(self._nodes.values())
+    
+    def get_online_nodes(self) -> list[NodeInfo]:
+        return [n for n in self._nodes.values() if n.status == NodeStatus.ONLINE]
+    
+    # --- Deployment ---
+    
+    def create_deployment(
+        self,
+        version: str,
+        target_nodes: list[str] | None = None,
+        capabilities: list[str] | None = None,
+        **kwargs: Any,
+    ) -> DeploymentManifest:
+        manifest = DeploymentManifest(
+            version=version,
+            target_nodes=target_nodes or list(self._nodes.keys()),
+            capabilities=capabilities or [],
+            **kwargs,
+        )
+        self._deployments.append(manifest)
+        if self._lemon:
+            self._lemon.counter("control_plane.deployments_created")
+        return manifest
+    
+    def get_deployments(self, limit: int = 10) -> list[DeploymentManifest]:
+        return self._deployments[-limit:]
+    
+    # --- Configuration ---
+    
+    def set_config(self, key: str, value: dict[str, Any]) -> None:
+        self._configs[key] = value
+        if self._lemon:
+            self._lemon.counter("control_plane.configs_updated")
+    
+    def get_config(self, key: str) -> dict[str, Any] | None:
+        return self._configs.get(key)
+    
+    def get_all_configs(self) -> dict[str, dict[str, Any]]:
+        return dict(self._configs)
+    
+    # --- Policy Distribution ---
+    
+    def set_policy(self, policy_id: str, policy_data: dict[str, Any]) -> None:
+        self._policies[policy_id] = policy_data
+        if self._lemon:
+            self._lemon.counter("control_plane.policies_updated")
+    
+    def get_policy(self, policy_id: str) -> dict[str, Any] | None:
+        return self._policies.get(policy_id)
+    
+    def get_all_policies(self) -> dict[str, dict[str, Any]]:
+        return dict(self._policies)
+    
+    # --- Summary ---
+    
+    def summary(self) -> dict:
+        return {
+            "nodes": len(self._nodes),
+            "online_nodes": len(self.get_online_nodes()),
+            "deployments": len(self._deployments),
+            "configs": len(self._configs),
+            "policies": len(self._policies),
+        }

src/introspection/__init__.py

@@ -0,0 +1,38 @@
+"""Lemon — Observability Layer for AgentOS.
+
+Complete end-to-end visibility into every aspect of the runtime.
+
+Provides:
+- Distributed tracing (Trace, Span)
+- Metrics collection (counters, gauges, histograms)
+- Structured logging (JSON, trace-enriched)
+- Health monitoring (healthy, degraded, unhealthy)
+- Alerting (rules, firing, resolution)
+
+Lemon observes everything.
+Lemon changes nothing.
+"""
+
+from src.introspection.lemon import Lemon
+from src.introspection.tracing import Tracer, Trace, Span
+from src.introspection.metrics import MetricsCollector, Metric
+from src.introspection.logging import StructuredLogger, LogEntry
+from src.introspection.health import HealthMonitor, HealthCheck
+from src.introspection.alerting import AlertManager, Alert, AlertRule, AlertSeverity
+
+__all__ = [
+    "Lemon",
+    "Tracer",
+    "Trace",
+    "Span",
+    "MetricsCollector",
+    "Metric",
+    "StructuredLogger",
+    "LogEntry",
+    "HealthMonitor",
+    "HealthCheck",
+    "AlertManager",
+    "Alert",
+    "AlertRule",
+    "AlertSeverity",
+]