monkeybrain-runtime 1.0.0__py3-none-any.whl

src/cerebellum/capabilities/productivity/productivity.py

@@ -0,0 +1,158 @@
+"""Productivity Capabilities — calendar, project management, documentation integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class GoogleCalendarCapability(Capability):
+    """Google Calendar integration via Google Calendar API v3."""
+    
+    def __init__(self, api_key: str = "", calendar_id: str = "primary"):
+        super().__init__(name='google_calendar')
+        self._api_key = api_key
+        self._calendar_id = calendar_id
+        self._base_url = "https://www.googleapis.com/calendar/v3"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'list')
+        async with httpx.AsyncClient() as client:
+            if operation == 'list':
+                response = await client.get(
+                    f"{self._base_url}/calendars/{self._calendar_id}/events",
+                    params={"key": self._api_key, "maxResults": state.get('max_results', 10)}
+                )
+                return response.json()
+            elif operation == 'create':
+                response = await client.post(
+                    f"{self._base_url}/calendars/{self._calendar_id}/events",
+                    params={"key": self._api_key},
+                    json=state.get('event', {})
+                )
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class JiraCapability(Capability):
+    """Jira integration via Jira REST API v2/v3."""
+    
+    def __init__(self, base_url: str = "", email: str = "", api_token: str = ""):
+        super().__init__(name='jira')
+        self._base_url = base_url
+        self._email = email
+        self._api_token = api_token
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'search')
+        async with httpx.AsyncClient() as client:
+            if operation == 'search':
+                response = await client.get(
+                    f"{self._base_url}/rest/api/3/search",
+                    params={"jql": state.get('jql', ''), "maxResults": state.get('max_results', 10)},
+                    auth=(self._email, self._api_token)
+                )
+                return response.json()
+            elif operation == 'create':
+                response = await client.post(
+                    f"{self._base_url}/rest/api/3/issue",
+                    json=state.get('issue', {}),
+                    auth=(self._email, self._api_token)
+                )
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class NotionCapability(Capability):
+    """Notion integration via Notion API v1."""
+    
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='notion')
+        self._api_key = api_key
+        self._base_url = "https://api.notion.com/v1"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'query')
+        async with httpx.AsyncClient() as client:
+            headers = {"Authorization": f"Bearer {self._api_key}", "Notion-Version": "2022-06-28"}
+            if operation == 'query':
+                response = await client.post(
+                    f"{self._base_url}/databases/{state.get('database_id', '')}/query",
+                    headers=headers,
+                    json=state.get('filter', {})
+                )
+                return response.json()
+            elif operation == 'create_page':
+                response = await client.post(
+                    f"{self._base_url}/pages",
+                    headers=headers,
+                    json=state.get('page', {})
+                )
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class TrelloCapability(Capability):
+    """Trello integration via Trello REST API."""
+    
+    def __init__(self, api_key: str = "", token: str = ""):
+        super().__init__(name='trello')
+        self._api_key = api_key
+        self._token = token
+        self._base_url = "https://api.trello.com/1"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'get_cards')
+        params = {"key": self._api_key, "token": self._token}
+        async with httpx.AsyncClient() as client:
+            if operation == 'get_cards':
+                response = await client.get(
+                    f"{self._base_url}/boards/{state.get('board_id', '')}/cards",
+                    params=params
+                )
+                return response.json()
+            elif operation == 'create_card':
+                params.update(state.get('card', {}))
+                response = await client.post(f"{self._base_url}/cards", params=params)
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class ClickUpCapability(Capability):
+    """ClickUp integration via ClickUp API v2."""
+    
+    def __init__(self, api_key: str = ""):
+        super().__init__(name='clickup')
+        self._api_key = api_key
+        self._base_url = "https://api.clickup.com/api/v2"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{self._base_url}/team/{state.get('team_id', '')}/task",
+                headers={"Authorization": self._api_key}
+            )
+            return response.json()
+
+
+class AsanaCapability(Capability):
+    """Asana integration via Asana REST API."""
+    
+    def __init__(self, access_token: str = ""):
+        super().__init__(name='asana')
+        self._access_token = access_token
+        self._base_url = "https://app.asana.com/api/1.0"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{self._base_url}/projects/{state.get('project_id', '')}/tasks",
+                headers={"Authorization": f"Bearer {self._access_token}"}
+            )
+            return response.json()

src/cerebellum/capabilities/robotics/robotics.py

@@ -0,0 +1,124 @@
+"""Robotics Capabilities — industrial protocol integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class MQTTCapability(Capability):
+    """MQTT message broker integration."""
+    
+    def __init__(self, broker_url: str = "mqtt://localhost:1883", client_id: str = ""):
+        super().__init__(name='mqtt')
+        self._broker_url = broker_url
+        self._client_id = client_id
+    
+    async def execute(self, state, **kwargs):
+        topic = state.get('topic', '')
+        payload = state.get('payload', '')
+        operation = state.get('operation', 'publish')
+        
+        try:
+            import paho.mqtt.client as mqtt
+            client = mqtt.Client(client_id=self._client_id)
+            
+            if operation == 'publish':
+                client.connect(self._broker_url.replace('mqtt://', '').split(':')[0])
+                client.publish(topic, payload)
+                client.disconnect()
+                return {"status": "published", "topic": topic}
+            elif operation == 'subscribe':
+                return {"status": "subscribed", "topic": topic, "message": "Use callback for async subscription"}
+        except Exception as e:
+            return {"error": str(e), "success": False}
+        
+        return {"status": "configured", "protocol": "mqtt"}
+
+
+class OPCUACapability(Capability):
+    """OPC-UA industrial protocol integration."""
+    
+    def __init__(self, endpoint: str = "opc.tcp://localhost:4840"):
+        super().__init__(name='opcua')
+        self._endpoint = endpoint
+    
+    async def execute(self, state, **kwargs):
+        node_id = state.get('node_id', '')
+        operation = state.get('operation', 'read')
+        
+        try:
+            from asyncua import Client
+            client = Client(url=self._endpoint)
+            await client.connect()
+            
+            if operation == 'read':
+                node = await client.get_node(node_id)
+                value = await node.read_value()
+                await client.disconnect()
+                return {"value": value, "node_id": node_id}
+            elif operation == 'write':
+                node = await client.get_node(node_id)
+                await node.write_value(state.get('value'))
+                await client.disconnect()
+                return {"status": "written", "node_id": node_id}
+        except Exception as e:
+            return {"error": str(e), "success": False}
+        
+        return {"status": "configured", "protocol": "opcua"}
+
+
+class ModbusCapability(Capability):
+    """Modbus industrial protocol integration."""
+    
+    def __init__(self, host: str = "localhost", port: int = 502):
+        super().__init__(name='modbus')
+        self._host = host
+        self._port = port
+    
+    async def execute(self, state, **kwargs):
+        try:
+            from pymodbus.client import ModbusTcpClient
+            client = ModbusTcpClient(self._host, port=self._port)
+            client.connect()
+            
+            address = state.get('address', 0)
+            count = state.get('count', 1)
+            result = client.read_holding_registers(address, count)
+            
+            client.close()
+            return {"registers": result.registers, "address": address}
+        except Exception as e:
+            return {"error": str(e), "success": False}
+
+
+class CANBusCapability(Capability):
+    """CAN Bus industrial protocol integration."""
+    
+    def __init__(self, interface: str = "can0"):
+        super().__init__(name='can_bus')
+        self._interface = interface
+    
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "protocol": "can_bus", "interface": self._interface}
+
+
+class EdgeXFoundryCapability(Capability):
+    """EdgeX Foundry IoT platform integration."""
+    
+    def __init__(self, api_url: str = "http://localhost:48082"):
+        super().__init__(name='edgex_foundry')
+        self._api_url = api_url
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'list_devices')
+        async with httpx.AsyncClient() as client:
+            if operation == 'list_devices':
+                response = await client.get(f"{self._api_url}/api/v3/device")
+                return response.json()
+            elif operation == 'get_device':
+                device_id = state.get('device_id', '')
+                response = await client.get(f"{self._api_url}/api/v3/device/{device_id}")
+                return response.json()
+            return {"status": "unknown_operation"}

src/cerebellum/capabilities/runtime/runtimes.py

@@ -0,0 +1,92 @@
+"""Runtime Capabilities — code execution integrations."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class PythonCapability(Capability):
+    """Python code execution capability."""
+    
+    def __init__(self):
+        super().__init__(name='python')
+    
+    async def execute(self, state, **kwargs):
+        code = state.get('code', '')
+        try:
+            result = subprocess.run(
+                [sys.executable, '-c', code],
+                capture_output=True,
+                text=True,
+                timeout=state.get('timeout', 30)
+            )
+            return {
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "returncode": result.returncode,
+                "success": result.returncode == 0
+            }
+        except subprocess.TimeoutExpired:
+            return {"error": "Execution timed out", "success": False}
+        except Exception as e:
+            return {"error": str(e), "success": False}
+
+
+import sys
+
+
+class ShellCapability(Capability):
+    """Shell command execution capability."""
+    
+    def __init__(self):
+        super().__init__(name='shell')
+    
+    async def execute(self, state, **kwargs):
+        command = state.get('command', '')
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=state.get('timeout', 30)
+            )
+            return {
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "returncode": result.returncode,
+                "success": result.returncode == 0
+            }
+        except subprocess.TimeoutExpired:
+            return {"error": "Execution timed out", "success": False}
+        except Exception as e:
+            return {"error": str(e), "success": False}
+
+
+class ProcessCapability(Capability):
+    """Process execution capability."""
+    
+    def __init__(self):
+        super().__init__(name='process')
+    
+    async def execute(self, state, **kwargs):
+        command = state.get('command', [])
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                timeout=state.get('timeout', 30)
+            )
+            return {
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "returncode": result.returncode,
+                "success": result.returncode == 0
+            }
+        except subprocess.TimeoutExpired:
+            return {"error": "Execution timed out", "success": False}
+        except Exception as e:
+            return {"error": str(e), "success": False}

src/cerebellum/capabilities/search/search.py

@@ -0,0 +1,63 @@
+"""Search Capabilities — web, document, and semantic search integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class WebSearchCapability(Capability):
+    """Web search integration using search APIs."""
+    
+    def __init__(self, api_key: str = "", engine: str = "google"):
+        super().__init__(name='web_search')
+        self._api_key = api_key
+        self._engine = engine
+        self._base_url = "https://www.googleapis.com/customsearch/v1" if engine == "google" else "https://api.search.brave.com/res/v1/web/search"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        query = state.get('query', '')
+        async with httpx.AsyncClient() as client:
+            if self._engine == "google":
+                response = await client.get(
+                    self._base_url,
+                    params={"key": self._api_key, "cx": state.get('search_engine_id', ''), "q": query, "num": state.get('num_results', 10)}
+                )
+            else:
+                response = await client.get(
+                    self._base_url,
+                    headers={"X-Subscription-Token": self._api_key},
+                    params={"q": query, "count": state.get('num_results', 10)}
+                )
+            return response.json()
+
+
+class DocumentSearchCapability(Capability):
+    """Document search using full-text search."""
+    
+    def __init__(self):
+        super().__init__(name='document_search')
+        self._documents = {}
+    
+    def index(self, doc_id: str, content: str, metadata: dict = None):
+        self._documents[doc_id] = {"content": content, "metadata": metadata or {}}
+    
+    async def execute(self, state, **kwargs):
+        query = state.get('query', '').lower()
+        results = []
+        for doc_id, doc in self._documents.items():
+            if query in doc['content'].lower():
+                results.append({"id": doc_id, "content": doc['content'][:200], "score": 1.0})
+        return {"results": results, "count": len(results)}
+
+
+class SemanticSearchCapability(Capability):
+    """Semantic search using vector embeddings."""
+    
+    def __init__(self):
+        super().__init__(name='semantic_search')
+    
+    async def execute(self, state, **kwargs):
+        query = state.get('query', '')
+        return {"results": [], "count": 0, "message": "Semantic search requires embedding model"}

src/cerebellum/capabilities/source_control/source_control.py

@@ -0,0 +1,113 @@
+"""Source Control Capabilities — Git platform integrations."""
+
+from __future__ import annotations
+
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class GitHubCapability(Capability):
+    """GitHub integration via GitHub REST API v3."""
+    
+    def __init__(self, token: str = ""):
+        super().__init__(name='github')
+        self._token = token
+        self._base_url = "https://api.github.com"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'list_repos')
+        headers = {"Authorization": f"token {self._token}", "Accept": "application/vnd.github.v3+json"}
+        async with httpx.AsyncClient() as client:
+            if operation == 'list_repos':
+                response = await client.get(f"{self._base_url}/user/repos", headers=headers)
+                return response.json()
+            elif operation == 'get_issue':
+                owner = state.get('owner', '')
+                repo = state.get('repo', '')
+                issue_number = state.get('issue_number', '')
+                response = await client.get(f"{self._base_url}/repos/{owner}/{repo}/issues/{issue_number}", headers=headers)
+                return response.json()
+            elif operation == 'create_issue':
+                owner = state.get('owner', '')
+                repo = state.get('repo', '')
+                response = await client.post(
+                    f"{self._base_url}/repos/{owner}/{repo}/issues",
+                    headers=headers,
+                    json=state.get('issue', {})
+                )
+                return response.json()
+            elif operation == 'list_pull_requests':
+                owner = state.get('owner', '')
+                repo = state.get('repo', '')
+                response = await client.get(f"{self._base_url}/repos/{owner}/{repo}/pulls", headers=headers)
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class GitLabCapability(Capability):
+    """GitLab integration via GitLab API v4."""
+    
+    def __init__(self, token: str = "", base_url: str = "https://gitlab.com/api/v4"):
+        super().__init__(name='gitlab')
+        self._token = token
+        self._base_url = base_url
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'list_projects')
+        headers = {"PRIVATE-TOKEN": self._token}
+        async with httpx.AsyncClient() as client:
+            if operation == 'list_projects':
+                response = await client.get(f"{self._base_url}/projects", headers=headers)
+                return response.json()
+            elif operation == 'get_merge_request':
+                project_id = state.get('project_id', '')
+                mr_iid = state.get('mr_iid', '')
+                response = await client.get(f"{self._base_url}/projects/{project_id}/merge_requests/{mr_iid}", headers=headers)
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class BitbucketCapability(Capability):
+    """Bitbucket integration via Bitbucket REST API 2.0."""
+    
+    def __init__(self, username: str = "", app_password: str = ""):
+        super().__init__(name='bitbucket')
+        self._username = username
+        self._app_password = app_password
+        self._base_url = "https://api.bitbucket.org/2.0"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'list_repos')
+        async with httpx.AsyncClient() as client:
+            if operation == 'list_repos':
+                response = await client.get(
+                    f"{self._base_url}/repositories/{self._username}",
+                    auth=(self._username, self._app_password)
+                )
+                return response.json()
+            return {"status": "unknown_operation"}
+
+
+class AzureDevOpsCapability(Capability):
+    """Azure DevOps integration via Azure DevOps REST API."""
+    
+    def __init__(self, organization: str = "", token: str = ""):
+        super().__init__(name='azure_devops')
+        self._organization = organization
+        self._token = token
+        self._base_url = f"https://dev.azure.com/{organization}"
+    
+    async def execute(self, state, **kwargs):
+        import httpx
+        operation = state.get('operation', 'list_projects')
+        async with httpx.AsyncClient() as client:
+            if operation == 'list_projects':
+                response = await client.get(
+                    f"{self._base_url}/_apis/projects",
+                    headers={"Authorization": f"Basic {self._token}"}
+                )
+                return response.json()
+            return {"status": "unknown_operation"}

src/cerebellum/capabilities/storage/storage.py

@@ -0,0 +1,94 @@
+"""Storage Capabilities — file system and cloud storage integrations."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+from src.cerebellum.capability import Capability
+
+
+class LocalFileSystemCapability(Capability):
+    """Local file system operations."""
+    
+    def __init__(self, base_path: str = "/"):
+        super().__init__(name='local_filesystem')
+        self._base_path = base_path
+    
+    async def execute(self, state, **kwargs):
+        operation = state.get('operation', 'read')
+        path = os.path.join(self._base_path, state.get('path', ''))
+        
+        if operation == 'read':
+            with open(path, 'r') as f:
+                return {"content": f.read(), "path": path}
+        elif operation == 'write':
+            with open(path, 'w') as f:
+                f.write(state.get('content', ''))
+            return {"status": "written", "path": path}
+        elif operation == 'list':
+            files = os.listdir(path)
+            return {"files": files, "count": len(files)}
+        elif operation == 'exists':
+            return {"exists": os.path.exists(path)}
+        return {"status": "unknown_operation"}
+
+
+class S3Capability(Capability):
+    """Amazon S3 integration via boto3."""
+    
+    def __init__(self, bucket: str = "", region: str = "us-east-1"):
+        super().__init__(name='s3')
+        self._bucket = bucket
+        self._region = region
+    
+    async def execute(self, state, **kwargs):
+        import boto3
+        s3 = boto3.client('s3', region_name=self._region)
+        operation = state.get('operation', 'list_objects')
+        
+        if operation == 'list_objects':
+            response = s3.list_objects_v2(Bucket=self._bucket, Prefix=state.get('prefix', ''))
+            return {"objects": [obj['Key'] for obj in response.get('Contents', [])]}
+        elif operation == 'get_object':
+            response = s3.get_object(Bucket=self._bucket, Key=state.get('key', ''))
+            return {"content": response['Body'].read().decode('utf-8')}
+        elif operation == 'put_object':
+            s3.put_object(Bucket=self._bucket, Key=state.get('key', ''), Body=state.get('body', ''))
+            return {"status": "uploaded"}
+        return {"status": "unknown_operation"}
+
+
+class AzureBlobCapability(Capability):
+    """Azure Blob Storage integration."""
+    
+    def __init__(self, connection_string: str = "", container: str = ""):
+        super().__init__(name='azure_blob')
+        self._connection_string = connection_string
+        self._container = container
+    
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "storage": "azure_blob", "container": self._container}
+
+
+class GCSCapability(Capability):
+    """Google Cloud Storage integration."""
+    
+    def __init__(self, bucket: str = ""):
+        super().__init__(name='gcs')
+        self._bucket = bucket
+    
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "storage": "gcs", "bucket": self._bucket}
+
+
+class MinioCapability(Capability):
+    """MinIO S3-compatible storage integration."""
+    
+    def __init__(self, endpoint: str = "", access_key: str = "", secret_key: str = ""):
+        super().__init__(name='minio')
+        self._endpoint = endpoint
+        self._access_key = access_key
+        self._secret_key = secret_key
+    
+    async def execute(self, state, **kwargs):
+        return {"status": "configured", "storage": "minio"}