monkeybrain-cerebellum 1.0.0__tar.gz

monkeybrain_cerebellum-1.0.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: monkeybrain-cerebellum
+Version: 1.0.0
+Summary: MonkeyBrain Cerebellum — Capability framework for the Cognitive Operating System
+Author: Prashun Javeri
+License: Proprietary
+Keywords: ai,capabilities,cognitive-os,agent,framework
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic
+Requires-Dist: httpx
+Provides-Extra: ai
+Requires-Dist: openai; extra == "ai"
+Requires-Dist: anthropic; extra == "ai"
+Provides-Extra: databases
+Requires-Dist: motor; extra == "databases"
+Requires-Dist: pymongo; extra == "databases"
+Requires-Dist: redis[asyncio]; extra == "databases"
+Requires-Dist: neo4j; extra == "databases"
+Requires-Dist: influxdb-client; extra == "databases"
+Provides-Extra: enterprise
+Requires-Dist: elasticsearch[async]; extra == "enterprise"
+Provides-Extra: all
+Requires-Dist: monkeybrain-cerebellum[ai,databases,enterprise]; extra == "all"
+
+# MonkeyBrain Cerebellum
+
+Capability framework for the MonkeyBrain Cognitive Operating System.
+
+## Features
+
+- **Capability** base class for execution primitives
+- **CapabilityRegistry** for discovery and management
+- **Peripheral** abstraction for I/O
+- **Lifecycle** management
+- **FallbackEngine** for graceful degradation
+- **SecureKeystore** for API keys
+- **24 capability categories** across AI, databases, enterprise, and more
+
+## Installation
+
+```bash
+pip install monkeybrain-cerebellum
+
+# With optional dependencies
+pip install monkeybrain-cerebellum[ai]       # AI providers
+pip install monkeybrain-cerebellum[databases] # Database drivers
+pip install monkeybrain-cerebellum[enterprise] # Elasticsearch
+pip install monkeybrain-cerebellum[all]       # Everything
+```
+
+## Quick Start
+
+```python
+from cerebellum import Capability, CapabilityRegistry
+
+class MyCapability(Capability):
+    name = "my-capability"
+    
+    async def execute(self, state, inputs):
+        return {"result": "done"}
+
+registry = CapabilityRegistry()
+registry.register(MyCapability())
+```
+
+## License
+
+Proprietary

monkeybrain_cerebellum-1.0.0/README.md

@@ -0,0 +1,44 @@
+# MonkeyBrain Cerebellum
+
+Capability framework for the MonkeyBrain Cognitive Operating System.
+
+## Features
+
+- **Capability** base class for execution primitives
+- **CapabilityRegistry** for discovery and management
+- **Peripheral** abstraction for I/O
+- **Lifecycle** management
+- **FallbackEngine** for graceful degradation
+- **SecureKeystore** for API keys
+- **24 capability categories** across AI, databases, enterprise, and more
+
+## Installation
+
+```bash
+pip install monkeybrain-cerebellum
+
+# With optional dependencies
+pip install monkeybrain-cerebellum[ai]       # AI providers
+pip install monkeybrain-cerebellum[databases] # Database drivers
+pip install monkeybrain-cerebellum[enterprise] # Elasticsearch
+pip install monkeybrain-cerebellum[all]       # Everything
+```
+
+## Quick Start
+
+```python
+from cerebellum import Capability, CapabilityRegistry
+
+class MyCapability(Capability):
+    name = "my-capability"
+    
+    async def execute(self, state, inputs):
+        return {"result": "done"}
+
+registry = CapabilityRegistry()
+registry.register(MyCapability())
+```
+
+## License
+
+Proprietary

monkeybrain_cerebellum-1.0.0/cerebellum/__init__.py

@@ -0,0 +1,35 @@
+"""MonkeyBrain Cerebellum — Capability framework.
+
+The Cerebellum provides:
+- Capability base class and manifest
+- Capability registry for discovery and management
+- Peripheral abstraction for I/O
+- Lifecycle management
+- Fallback engine for graceful degradation
+- Secure keystore for API keys
+"""
+
+from cerebellum.capability import Capability, CapabilityManifest
+from cerebellum.registry import CapabilityRegistry
+from cerebellum.peripheral import Peripheral
+from cerebellum.lifecycle import CapabilityLifecycle
+from cerebellum.metadata import CapabilityMetadata
+from cerebellum.config import CerebellumConfig
+from cerebellum.fallback_engine import FallbackEngine
+from cerebellum.keystore import SecureKeystore
+from cerebellum.key_manager import KeyManager
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "Capability",
+    "CapabilityManifest",
+    "CapabilityRegistry",
+    "Peripheral",
+    "CapabilityLifecycle",
+    "CapabilityMetadata",
+    "CerebellumConfig",
+    "FallbackEngine",
+    "SecureKeystore",
+    "KeyManager",
+]

monkeybrain_cerebellum-1.0.0/cerebellum/adapter.py

@@ -0,0 +1,84 @@
+"""Adapter — transforms data between capability and peripheral.
+
+Adapters handle:
+- Data format conversion
+- Protocol translation
+- Schema mapping
+- Error transformation
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from uuid import uuid4
+
+from cerebellum.peripheral import Peripheral
+
+
+@dataclass
+class AdapterSchema:
+    """Schema for adapter data transformation."""
+    
+    name: str = ""
+    fields: list[dict[str, Any]] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class Adapter:
+    """Transforms data between capability and peripheral.
+    
+    Responsibilities:
+    - Read from peripheral and transform
+    - Transform and write to peripheral
+    - Map data schemas
+    
+    The Adapter never:
+    - Makes execution decisions
+    - Manages connections
+    - Owns execution policy
+    """
+    
+    def __init__(
+        self,
+        name: str,
+        peripheral: Peripheral,
+        schema: AdapterSchema | None = None,
+    ):
+        self.name = name
+        self.peripheral = peripheral
+        self.schema = schema or AdapterSchema()
+        self._id = f"adapter-{uuid4().hex[:8]}"
+    
+    @property
+    def id(self) -> str:
+        return self._id
+    
+    async def read(self, query: dict[str, Any]) -> dict[str, Any]:
+        """Read from peripheral and transform.
+        
+        Override this method to implement read logic.
+        """
+        raise NotImplementedError(f"Adapter '{self.name}' must implement read()")
+    
+    async def write(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Transform and write to peripheral.
+        
+        Override this method to implement write logic.
+        """
+        raise NotImplementedError(f"Adapter '{self.name}' must implement write()")
+    
+    async def transform(self, data: dict[str, Any]) -> dict[str, Any]:
+        """Transform data without I/O.
+        
+        Override this method to implement transformation logic.
+        """
+        return data
+    
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self._id,
+            "name": self.name,
+            "peripheral": self.peripheral.name,
+            "schema": self.schema.name,
+        }

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/agent/agents.py

@@ -0,0 +1,65 @@
+"""Agent Capabilities — agent-to-agent communication."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class OpenClawCapability(Capability):
+    def __init__(self, api_url: str = ""):
+        super().__init__(name='openclaw')
+        self._api_url = api_url
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "agent": "openclaw"}
+
+
+class ExternalAgentCapability(Capability):
+    def __init__(self, agent_url: str = ""):
+        super().__init__(name='external_agent')
+        self._agent_url = agent_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._agent_url, json=state)
+            return response.json()
+
+
+class AgentToAgentCapability(Capability):
+    def __init__(self):
+        super().__init__(name='agent_to_agent')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "communication": "agent_to_agent"}
+
+
+class RemoteAgentExecutionCapability(Capability):
+    def __init__(self, remote_url: str = ""):
+        super().__init__(name='remote_agent_execution')
+        self._remote_url = remote_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(f"{self._remote_url}/execute", json=state)
+            return response.json()
+
+
+class AgentDiscoveryCapability(Capability):
+    def __init__(self, registry_url: str = ""):
+        super().__init__(name='agent_discovery')
+        self._registry_url = registry_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"{self._registry_url}/agents")
+            return response.json()
+
+
+class AgentRegistryCapability(Capability):
+    def __init__(self, registry_url: str = ""):
+        super().__init__(name='agent_registry')
+        self._registry_url = registry_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(f"{self._registry_url}/register", json=state)
+            return response.json()

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/ai/providers.py

@@ -0,0 +1,106 @@
+"""AI Provider Capabilities — LLM and AI integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class OpenAICapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='openai')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers={"Authorization": f"Bearer {self._api_key}"},
+                json={"model": state.get("model", "gpt-4"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class AnthropicCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='anthropic')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://api.anthropic.com/v1/messages",
+                headers={"x-api-key": self._api_key, "anthropic-version": "2023-06-01"},
+                json={"model": state.get("model", "claude-3"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class GeminiCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='gemini')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "google_gemini"}
+
+
+class AzureOpenAICapability(Capability):
+    def __init__(self, endpoint: str = "", api_key: str = ""):
+        super().__init__(name='azure_openai')
+        self._endpoint = endpoint
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "azure_openai"}
+
+
+class AWSBedrockCapability(Capability):
+    def __init__(self, region: str = "us-east-1"):
+        super().__init__(name='aws_bedrock')
+        self._region = region
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "aws_bedrock"}
+
+
+class OllamaCapability(Capability):
+    def __init__(self, url: str = "http://localhost:11434"):
+        super().__init__(name='ollama')
+        self._url = url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{self._url}/api/chat",
+                json={"model": state.get("model", "gemma3:latest"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class HuggingFaceCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='huggingface')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "huggingface"}
+
+
+class OpenRouterCapability(Capability):
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='openrouter')
+        self._api_key = api_key
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers={"Authorization": f"Bearer {self._api_key}"},
+                json={"model": state.get("model", "openai/gpt-4o-mini"), "messages": [{"role": "user", "content": state.get("prompt", "")}]}
+            )
+            return response.json()
+
+
+class LocalModelCapability(Capability):
+    def __init__(self, model_path: str = ""):
+        super().__init__(name='local_model')
+        self._model_path = model_path
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "provider": "local_model"}

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/api/graphql.py

@@ -0,0 +1,35 @@
+"""GraphQL API Capability — GraphQL integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class GraphQLCapability(Capability):
+    """GraphQL API integration capability."""
+    
+    def __init__(self, endpoint: str = "", api_key: str = ""):
+        super().__init__(name='graphql')
+        self._endpoint = endpoint
+        self._api_key = api_key
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute GraphQL query."""
+        import httpx
+        
+        endpoint = state.get('endpoint', self._endpoint)
+        query = state.get('query', '')
+        variables = state.get('variables', {})
+        
+        headers = {'Content-Type': 'application/json'}
+        if self._api_key:
+            headers['Authorization'] = f'Bearer {self._api_key}'
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                endpoint,
+                headers=headers,
+                json={'query': query, 'variables': variables}
+            )
+            return response.json()

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/api/rest_api.py

@@ -0,0 +1,45 @@
+"""REST API Capability — HTTP REST integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class RestAPICapability(Capability):
+    """REST API integration capability."""
+    
+    def __init__(self, base_url: str = "", api_key: str = ""):
+        super().__init__(name='rest_api')
+        self._base_url = base_url
+        self._api_key = api_key
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Execute REST API call."""
+        import httpx
+        
+        url = state.get('url', self._base_url)
+        method = state.get('method', 'GET')
+        headers = state.get('headers', {})
+        data = state.get('data')
+        
+        if self._api_key:
+            headers['Authorization'] = f'Bearer {self._api_key}'
+        
+        async with httpx.AsyncClient() as client:
+            if method.upper() == 'GET':
+                response = await client.get(url, headers=headers)
+            elif method.upper() == 'POST':
+                response = await client.post(url, headers=headers, json=data)
+            elif method.upper() == 'PUT':
+                response = await client.put(url, headers=headers, json=data)
+            elif method.upper() == 'DELETE':
+                response = await client.delete(url, headers=headers)
+            else:
+                return {'status': 'error', 'error': f'Unsupported method: {method}'}
+            
+            return {
+                'status_code': response.status_code,
+                'data': response.json() if response.headers.get('content-type', '').startswith('application/json') else response.text,
+                'headers': dict(response.headers),
+            }

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/api/webhook.py

@@ -0,0 +1,30 @@
+"""Webhook Capability — webhook integration."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class WebhookCapability(Capability):
+    """Webhook integration capability."""
+    
+    def __init__(self, url: str = "", secret: str = ""):
+        super().__init__(name='webhook')
+        self._url = url
+        self._secret = secret
+    
+    async def execute(self, state: dict[str, Any], **kwargs) -> dict[str, Any]:
+        """Send webhook."""
+        import httpx
+        
+        url = state.get('url', self._url)
+        payload = state.get('payload', {})
+        headers = state.get('headers', {'Content-Type': 'application/json'})
+        
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload, headers=headers)
+            return {
+                'status_code': response.status_code,
+                'success': 200 <= response.status_code < 300,
+            }

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/browser/browsers.py

@@ -0,0 +1,27 @@
+"""Browser Capabilities — web browser integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class PlaywrightCapability(Capability):
+    def __init__(self):
+        super().__init__(name='playwright')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "browser": "playwright"}
+
+
+class SeleniumCapability(Capability):
+    def __init__(self):
+        super().__init__(name='selenium')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "browser": "selenium"}
+
+
+class PuppeteerCapability(Capability):
+    def __init__(self):
+        super().__init__(name='puppeteer')
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "browser": "puppeteer"}

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/cloud/cloud.py

@@ -0,0 +1,46 @@
+"""Cloud Capabilities — cloud provider integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class AWSCapability(Capability):
+    def __init__(self, region: str = "us-east-1"):
+        super().__init__(name='aws')
+        self._region = region
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "aws", "region": self._region}
+
+
+class AzureCapability(Capability):
+    def __init__(self, subscription_id: str = ""):
+        super().__init__(name='azure')
+        self._subscription_id = subscription_id
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "azure"}
+
+
+class GoogleCloudCapability(Capability):
+    def __init__(self, project_id: str = ""):
+        super().__init__(name='google_cloud')
+        self._project_id = project_id
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "google_cloud"}
+
+
+class CloudflareCapability(Capability):
+    def __init__(self, api_token: str = ""):
+        super().__init__(name='cloudflare')
+        self._api_token = api_token
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "cloudflare"}
+
+
+class DigitalOceanCapability(Capability):
+    def __init__(self, api_token: str = ""):
+        super().__init__(name='digitalocean')
+        self._api_token = api_token
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "cloud": "digitalocean"}

monkeybrain_cerebellum-1.0.0/cerebellum/capabilities/communication/communication.py

@@ -0,0 +1,62 @@
+"""Communication Capabilities — messaging integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from cerebellum.capability import Capability
+
+
+class EmailCapability(Capability):
+    def __init__(self, smtp_host: str = "", smtp_port: int = 587):
+        super().__init__(name='email')
+        self._smtp_host = smtp_host
+        self._smtp_port = smtp_port
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "communication": "email"}
+
+
+class SlackCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='slack')
+        self._webhook_url = webhook_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._webhook_url, json={"text": state.get("message", "")})
+            return {"status": "sent" if response.status_code == 200 else "failed"}
+
+
+class DiscordCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='discord')
+        self._webhook_url = webhook_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._webhook_url, json={"content": state.get("message", "")})
+            return {"status": "sent" if response.status_code == 204 else "failed"}
+
+
+class TelegramCapability(Capability):
+    def __init__(self, bot_token: str = ""):
+        super().__init__(name='telegram')
+        self._bot_token = bot_token
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"https://api.telegram.org/bot{self._bot_token}/sendMessage",
+                json={"chat_id": state.get("chat_id", ""), "text": state.get("message", "")}
+            )
+            return response.json()
+
+
+class MicrosoftTeamsCapability(Capability):
+    def __init__(self, webhook_url: str = ""):
+        super().__init__(name='microsoft_teams')
+        self._webhook_url = webhook_url
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self._webhook_url, json={"text": state.get("message", "")})
+            return {"status": "sent" if response.status_code == 200 else "failed"}