ainativelang 1.2.8__py3-none-any.whl

adapters/__init__.py

@@ -0,0 +1,29 @@
+"""
+Adapters: pluggable backends for R (db, api), P (pay), Sc (scrape).
+Replace mock adapters with real implementations (Prisma, Stripe, etc.).
+"""
+from .base import (
+    AdapterRegistry,
+    APIAdapter,
+    AuthAdapter,
+    CacheAdapter,
+    DBAdapter,
+    PayAdapter,
+    QueueAdapter,
+    ScrapeAdapter,
+    TxnAdapter,
+)
+from .mock import mock_registry
+
+__all__ = [
+    "AdapterRegistry",
+    "DBAdapter",
+    "APIAdapter",
+    "AuthAdapter",
+    "CacheAdapter",
+    "PayAdapter",
+    "QueueAdapter",
+    "ScrapeAdapter",
+    "TxnAdapter",
+    "mock_registry",
+]

adapters/agent.py

@@ -0,0 +1,85 @@
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+from runtime.adapters.base import RuntimeAdapter, AdapterError
+
+
+class AgentAdapter(RuntimeAdapter):
+  """Extension/OpenClaw agent coordination adapter (local, file-backed).
+
+  This adapter is:
+  - extension-level and noncanonical,
+  - local-only and file-backed,
+  - sandboxed under AINL_AGENT_ROOT (default: /tmp/ainl_agents).
+  """
+
+  def _root(self) -> Path:
+    raw = os.getenv("AINL_AGENT_ROOT", "/tmp/ainl_agents")
+    # Disallow using filesystem root as sandbox; that defeats the boundary.
+    if os.path.abspath(raw) == os.path.sep:
+      raise AdapterError("AINL_AGENT_ROOT must not be filesystem root")
+    root = Path(raw).resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+  def _safe_path(self, rel: str) -> Path:
+    root = self._root()
+    target = (root / str(rel)).resolve()
+    if target != root and root not in target.parents:
+      raise AdapterError("agent path escapes AINL_AGENT_ROOT sandbox")
+    return target
+
+  def call(self, target: str, args: List[Any], context: Dict[str, Any]) -> Any:
+    verb = (target or "").strip()
+
+    if verb == "send_task":
+      if not args:
+        raise AdapterError("agent.send_task requires at least one argument (task envelope)")
+
+      envelope = args[0]
+      if not isinstance(envelope, dict):
+        raise AdapterError("agent.send_task expects first argument to be a JSON object envelope")
+
+      # Optional second argument must not be treated as an arbitrary path; reject
+      # attempts to override the tasks file location to preserve the AINL_AGENT_ROOT
+      # sandbox boundary.
+      if len(args) > 1:
+        raise AdapterError("agent.send_task does not accept explicit path arguments; tasks file is fixed under AINL_AGENT_ROOT")
+
+      # Tasks file path is fixed by convention; callers should not control it.
+      path = self._safe_path("tasks/openclaw_agent_tasks.jsonl")
+
+      try:
+        line = json.dumps(envelope, sort_keys=True)
+      except Exception as e:
+        raise AdapterError(f"agent.send_task could not serialize envelope: {e}") from e
+
+      path.parent.mkdir(parents=True, exist_ok=True)
+      with path.open("a", encoding="utf-8") as f:
+        f.write(line + "\n")
+
+      task_id = str(envelope.get("task_id") or "")
+      return task_id
+
+    if verb == "read_result":
+      if not args:
+        raise AdapterError("agent.read_result requires task_id")
+      task_id = str(args[0])
+      # Treat task_id as an identifier, not a path fragment.
+      if "/" in task_id or ".." in task_id:
+        raise AdapterError("agent.read_result task_id must not contain path separators or escape AINL_AGENT_ROOT sandbox")
+      rel_path = f"results/{task_id}.json"
+      path = self._safe_path(rel_path)
+      if not path.exists() or not path.is_file():
+        raise AdapterError("agent.read_result target does not exist")
+      try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+      except Exception as e:
+        raise AdapterError(f"agent.read_result failed to parse JSON: {e}") from e
+      if not isinstance(data, dict):
+        raise AdapterError("agent.read_result expects JSON object result")
+      return data
+
+    raise AdapterError(f"agent supports only send_task/read_result (got {target!r})")

adapters/base.py

@@ -0,0 +1,183 @@
+"""
+Adapter interfaces for AI-Native Lang runtime.
+Implement these to plug in real backends (Prisma, Stripe, HTTP, cache, queue, txn, auth).
+"""
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class DBAdapter(ABC):
+    """Backend for db.F (find), db.G (get one), db.P (create), db.D (delete)."""
+
+    @abstractmethod
+    def find(self, entity: str, fields: str = "*") -> List[Dict[str, Any]]:
+        """Return list of entities (e.g. db.F Product *)."""
+        pass
+
+    def get(self, entity: str, id_value: Any) -> Optional[Dict[str, Any]]:
+        """Return one entity by id (e.g. db.G Product 1)."""
+        rows = self.find(entity, "*")
+        for r in rows:
+            if r.get("id") == id_value:
+                return r
+        return None
+
+    def create(self, entity: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create one entity (e.g. db.P Order {...})."""
+        raise NotImplementedError("db.P")
+
+    def delete(self, entity: str, id_value: Any) -> bool:
+        """Delete one entity (e.g. db.D Order 1)."""
+        raise NotImplementedError("db.D")
+
+
+class APIAdapter(ABC):
+    """Backend for api.G (GET), api.P (POST), etc."""
+
+    @abstractmethod
+    def get(self, path: str) -> Any:
+        """HTTP GET path -> response body."""
+        pass
+
+    def post(self, path: str, body: Optional[Dict] = None) -> Any:
+        """HTTP POST path with body."""
+        raise NotImplementedError("api.P")
+
+
+class PayAdapter(ABC):
+    """Backend for P (payment intent)."""
+
+    @abstractmethod
+    def create_intent(
+        self,
+        name: str,
+        amount: str,
+        currency: str,
+        desc: str = "",
+    ) -> Dict[str, Any]:
+        """Create payment intent; return { client_secret, ... }."""
+        pass
+
+
+class ScrapeAdapter(ABC):
+    """Backend for Sc (scrape)."""
+
+    @abstractmethod
+    def scrape(self, name: str, url: str, selectors: Dict[str, str]) -> Dict[str, Any]:
+        """Run scraper; return dict of field -> value."""
+        pass
+
+
+class CacheAdapter(ABC):
+    """Backend for cache capability steps."""
+
+    @abstractmethod
+    def get(self, namespace: str, key: str) -> Any:
+        """Lookup cache value by namespace+key; return None on miss."""
+        pass
+
+    @abstractmethod
+    def set(self, namespace: str, key: str, value: Any, ttl_s: int = 0) -> None:
+        """Store cache value with optional ttl in seconds."""
+        pass
+
+
+class QueueAdapter(ABC):
+    """Backend for queue capability steps."""
+
+    @abstractmethod
+    def push(self, queue: str, value: Any) -> str:
+        """Push value to queue and return message id."""
+        pass
+
+
+class TxnAdapter(ABC):
+    """Backend for transaction capability steps."""
+
+    @abstractmethod
+    def begin(self, name: str) -> str:
+        """Start transaction scope and return transaction id."""
+        pass
+
+    @abstractmethod
+    def commit(self, name: str) -> None:
+        """Commit transaction scope."""
+        pass
+
+    @abstractmethod
+    def rollback(self, name: str) -> None:
+        """Rollback transaction scope."""
+        pass
+
+
+class AuthAdapter(ABC):
+    """Backend for auth capability checks."""
+
+    @abstractmethod
+    def validate(self, token_or_value: str) -> bool:
+        """Return True when auth value/token is valid."""
+        pass
+
+
+class AdapterRegistry:
+    """Holds runtime adapters. Used by ExecutionEngine."""
+
+    def __init__(
+        self,
+        db: Optional[DBAdapter] = None,
+        api: Optional[APIAdapter] = None,
+        pay: Optional[PayAdapter] = None,
+        scrape: Optional[ScrapeAdapter] = None,
+        cache: Optional[CacheAdapter] = None,
+        queue: Optional[QueueAdapter] = None,
+        txn: Optional[TxnAdapter] = None,
+        auth: Optional[AuthAdapter] = None,
+    ):
+        self.db = db
+        self.api = api
+        self.pay = pay
+        self.scrape = scrape
+        self.cache = cache
+        self.queue = queue
+        self.txn = txn
+        self.auth = auth
+
+    def get_db(self) -> DBAdapter:
+        if self.db is None:
+            raise RuntimeError("No db adapter registered")
+        return self.db
+
+    def get_api(self) -> APIAdapter:
+        if self.api is None:
+            raise RuntimeError("No api adapter registered")
+        return self.api
+
+    def get_pay(self) -> PayAdapter:
+        if self.pay is None:
+            raise RuntimeError("No pay adapter registered")
+        return self.pay
+
+    def get_scrape(self) -> ScrapeAdapter:
+        if self.scrape is None:
+            raise RuntimeError("No scrape adapter registered")
+        return self.scrape
+
+    def get_cache(self) -> CacheAdapter:
+        if self.cache is None:
+            raise RuntimeError("No cache adapter registered")
+        return self.cache
+
+    def get_queue(self) -> QueueAdapter:
+        if self.queue is None:
+            raise RuntimeError("No queue adapter registered")
+        return self.queue
+
+    def get_txn(self) -> TxnAdapter:
+        if self.txn is None:
+            raise RuntimeError("No txn adapter registered")
+        return self.txn
+
+    def get_auth(self) -> AuthAdapter:
+        if self.auth is None:
+            raise RuntimeError("No auth adapter registered")
+        return self.auth

adapters/core.py

@@ -0,0 +1,146 @@
+# Core builtin adapter for AINL
+# Provides fundamental operations: now, math, string, collection utilities
+
+import time
+
+def core_now(frame, *args):
+    """Return current timestamp (seconds)."""
+    return time.time()
+
+def add(frame, a, b):
+    return a + b
+
+def sub(frame, a, b):
+    return a - b
+
+def mul(frame, a, b):
+    return a * b
+
+def div(frame, a, b):
+    if b == 0:
+        raise ZeroDivisionError("division by zero")
+    return a / b
+
+def int_div(frame, a, b):
+    return a // b
+
+def mod(frame, a, b):
+    return a % b
+
+def pow_(frame, a, b):
+    return a ** b
+
+def len_(frame, value):
+    if isinstance(value, (list, tuple, str, dict)):
+        return len(value)
+    raise TypeError("len() expects a collection")
+
+def concat(frame, a, b):
+    return str(a) + str(b)
+
+def join(frame, sep, items):
+    return sep.join(str(x) for x in items)
+
+def stringify(frame, value):
+    return str(value)
+
+def lt(frame, a, b):
+    return a < b
+
+def gt(frame, a, b):
+    return a > b
+
+def lte(frame, a, b):
+    return a <= b
+
+def gte(frame, a, b):
+    return a >= b
+
+def eq(frame, a, b):
+    return a == b
+
+def ne(frame, a, b):
+    return a != b
+
+# --- String operations ---
+def split(frame, s, sep):
+    """Split string by separator (string). Returns list."""
+    if not isinstance(s, str):
+        s = str(s)
+    if not isinstance(sep, str):
+        sep = str(sep)
+    return s.split(sep)
+
+def contains(frame, s, substr):
+    """Return True if substr in s."""
+    return substr in s
+
+def starts_with(frame, s, prefix):
+    return s.startswith(prefix)
+
+def ends_with(frame, s, suffix):
+    return s.endswith(suffix)
+
+def substr(frame, s, start, length=None):
+    """Return substring. If length omitted, to end."""
+    if not isinstance(s, str):
+        s = str(s)
+    if length is None:
+        return s[start:]
+    return s[start:start+length]
+
+def replace(frame, s, old, new):
+    return s.replace(old, new)
+
+def to_lower(frame, s):
+    return s.lower()
+
+def to_upper(frame, s):
+    return s.upper()
+
+def trim(frame, s):
+    return s.strip()
+
+# Map of verbs to functions
+VERBS = {
+    'now': core_now,
+    'add': add,
+    'sub': sub,
+    'mul': mul,
+    'div': div,
+    'idiv': int_div,
+    'mod': mod,
+    'pow': pow_,
+    'len': len_,
+    'concat': concat,
+    'join': join,
+    'stringify': stringify,
+    'lt': lt,
+    'gt': gt,
+    'lte': lte,
+    'gte': gte,
+    'eq': eq,
+    'ne': ne,
+    # string
+    'split': split,
+    'contains': contains,
+    'starts_with': starts_with,
+    'ends_with': ends_with,
+    'substr': substr,
+    'replace': replace,
+    'to_lower': to_lower,
+    'to_upper': to_upper,
+    'trim': trim,
+}
+
+def core_registry():
+    return {
+        "desc": "Core builtins",
+        "module": "adapters.core",
+        "verbs": {verb: {} for verb in VERBS.keys()}
+    }
+
+def get(verb):
+    if verb in VERBS:
+        return VERBS[verb]
+    raise KeyError(f"Unknown core verb: {verb}")

adapters/core_patch.py

@@ -0,0 +1,10 @@
+# Patch to ensure core adapter is present in openclaw_monitor_registry
+# This module should be imported before the engine is created.
+
+from . import core
+from . import openclaw_integration as oi
+
+# Call the function to get the registry dict and inject core if missing
+_reg = oi.openclaw_monitor_registry()
+if 'core' not in _reg:
+    _reg['core'] = core.core_registry()

adapters/crm.py

@@ -0,0 +1,183 @@
+"""Local CRM HTTP adapter: GitHub intelligence + lead upsert (paths configurable via env)."""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+import requests
+
+from runtime.adapters.base import RuntimeAdapter, AdapterError
+
+from adapters.openclaw_defaults import DEFAULT_CRM_API_BASE
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_BASE = os.getenv("CRM_API_BASE", DEFAULT_CRM_API_BASE).rstrip("/")
+PATH_DIGEST = os.getenv("CRM_PATH_GITHUB_INTEL_DIGEST", "/api/github-intelligence/digests")
+PATH_FIND = os.getenv("CRM_PATH_GITHUB_INTEL_FIND", "/api/github-intelligence")
+PATH_LEADS = os.getenv("CRM_PATH_LEADS_UPSERT", "/api/leads")
+
+
+def _dry_run(context: Dict[str, Any]) -> bool:
+    v = context.get("dry_run")
+    if v in (True, 1, "1", "true", "True", "yes"):
+        return True
+    return os.environ.get("AINL_DRY_RUN", "").strip().lower() in ("1", "true", "yes")
+
+
+class _JsonFileCache:
+    def __init__(self) -> None:
+        self.path = Path(os.getenv("MONITOR_CACHE_JSON", "/tmp/monitor_state.json")).expanduser()
+
+    def _load(self) -> Dict[str, Any]:
+        try:
+            with open(self.path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return data if isinstance(data, dict) else {}
+        except (OSError, json.JSONDecodeError):
+            return {}
+
+    def _save(self, data: Dict[str, Any]) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.path, "w", encoding="utf-8") as f:
+                json.dump(data, f)
+        except OSError as e:
+            logger.warning("crm cache save failed: %s", e)
+
+    def get(self, namespace: str, key: str) -> Any:
+        return self._load().get(namespace, {}).get(key)
+
+    def set(self, namespace: str, key: str, value: Any) -> None:
+        data = self._load()
+        data.setdefault(namespace, {})[key] = value
+        self._save(data)
+
+
+def _as_dict(data: Any) -> Dict[str, Any]:
+    if isinstance(data, dict):
+        return data
+    if isinstance(data, str):
+        try:
+            o = json.loads(data)
+            return o if isinstance(o, dict) else {}
+        except json.JSONDecodeError:
+            return {}
+    return {}
+
+
+class CrmAdapter(RuntimeAdapter):
+    """
+    Adapter group: crm
+    Verbs: create_github_intelligence_digest, find_github_intelligence, upsert_lead
+    """
+
+    def __init__(self) -> None:
+        self.base = DEFAULT_BASE
+        self._cache = _JsonFileCache()
+        self._session = requests.Session()
+
+    def call(self, target: str, args: List[Any], context: Dict[str, Any]) -> Any:
+        verb = str(target or "").strip().lower()
+        dry = _dry_run(context)
+
+        if verb == "create_github_intelligence_digest":
+            if len(args) < 3:
+                raise AdapterError(
+                    "create_github_intelligence_digest requires generatedAt, newCount, repos"
+                )
+            generated_at = str(args[0])
+            try:
+                new_count = int(args[1]) if args[1] is not None else 0
+            except (TypeError, ValueError):
+                new_count = 0
+            repos = args[2]
+            if not isinstance(repos, list):
+                repos = []
+            body = {"generatedAt": generated_at, "newCount": new_count, "repos": repos}
+            if dry:
+                logger.info("[dry_run] crm.create_github_intelligence_digest — no POST")
+                return 0
+            url = f"{self.base}{PATH_DIGEST}"
+            r = self._session.post(url, json=body, timeout=30)
+            if r.status_code not in (200, 201):
+                logger.warning("CRM digest POST %s %s", r.status_code, (r.text or "")[:300])
+                return 0
+            try:
+                data = r.json()
+            except json.JSONDecodeError:
+                return 0
+            if isinstance(data, dict):
+                for k in ("id", "digestId", "reportId"):
+                    if k in data and data[k] is not None:
+                        try:
+                            return int(data[k])
+                        except (TypeError, ValueError):
+                            continue
+            return 1
+
+        if verb == "find_github_intelligence":
+            since = args[0] if len(args) > 0 else None
+            try:
+                limit = int(args[1]) if len(args) > 1 and args[1] is not None else 20
+            except (TypeError, ValueError):
+                limit = 20
+            params: Dict[str, Any] = {"limit": limit}
+            if since not in (None, ""):
+                params["since"] = str(since)
+            sig = json.dumps(params, sort_keys=True)
+            ck = "find:" + hashlib.md5(sig.encode("utf-8")).hexdigest()
+            hit = self._cache.get("crm", ck)
+            if isinstance(hit, dict) and time.time() - float(hit.get("ts", 0)) < 60:
+                return hit.get("data", [])
+            if dry:
+                return []
+            url = f"{self.base}{PATH_FIND}"
+            r = self._session.get(url, params=params, timeout=30)
+            if r.status_code != 200:
+                logger.warning("CRM find_github_intelligence GET %s", r.status_code)
+                return []
+            try:
+                data = r.json()
+            except json.JSONDecodeError:
+                return []
+            if isinstance(data, list):
+                out = data
+            elif isinstance(data, dict) and isinstance(data.get("items"), list):
+                out = data["items"]
+            elif isinstance(data, dict) and isinstance(data.get("results"), list):
+                out = data["results"]
+            else:
+                out = []
+            self._cache.set("crm", ck, {"ts": time.time(), "data": out})
+            return out
+
+        if verb == "upsert_lead":
+            if not args:
+                raise AdapterError("upsert_lead requires lead_data: dict")
+            lead = _as_dict(args[0])
+            if dry:
+                logger.info("[dry_run] crm.upsert_lead — no POST")
+                return 0
+            url = f"{self.base}{PATH_LEADS}"
+            r = self._session.post(url, json=lead, timeout=30)
+            if r.status_code not in (200, 201):
+                logger.warning("CRM upsert_lead POST %s", r.status_code)
+                return 0
+            try:
+                data = r.json()
+            except json.JSONDecodeError:
+                return 1
+            if isinstance(data, dict) and data.get("id") is not None:
+                try:
+                    return int(data["id"])
+                except (TypeError, ValueError):
+                    pass
+            return 1
+
+        raise AdapterError(f"crm unknown target: {target}")

adapters/demo_mock.py

@@ -0,0 +1,65 @@
+"""Mock adapters plus email/calendar/social for demo runtime usage."""
+from typing import Any, Dict, List, Optional
+import time
+
+from runtime.adapters.base import AdapterRegistry, RuntimeAdapter
+
+from .mock import (
+    MockAPIAdapter,
+    MockAuthAdapter,
+    MockCacheAdapter,
+    MockDBAdapter,
+    MockPayAdapter,
+    MockQueueAdapter,
+    MockTxnAdapter,
+)
+
+
+class _MockEmailAdapter(RuntimeAdapter):
+    def call(self, target: str, args: List[Any], context: Dict[str, Any]) -> Any:
+        if str(target or "").upper() != "G":
+            return []
+        now = int(time.time())
+        return [
+            {"id": "e1", "subject": "Update", "date": now - 300},
+            {"id": "e2", "subject": "News", "date": now - 60},
+        ]
+
+
+class _MockCalendarAdapter(RuntimeAdapter):
+    def call(self, target: str, args: List[Any], context: Dict[str, Any]) -> Any:
+        if str(target or "").upper() != "G":
+            return []
+        now = int(time.time())
+        return [
+            {"id": "ev1", "title": "Meeting", "start": now + 3600},
+            {"id": "ev2", "title": "Lunch", "start": now + 7200},
+        ]
+
+
+class _MockSocialAdapter(RuntimeAdapter):
+    def call(self, target: str, args: List[Any], context: Dict[str, Any]) -> Any:
+        if str(target or "").upper() != "G":
+            return []
+        now = int(time.time())
+        return [
+            {"id": "m1", "text": "Hello", "ts": now - 90},
+            {"id": "m2", "text": "World", "ts": now - 30},
+        ]
+
+
+def mock_registry(types: Optional[Dict[str, Dict[str, Any]]] = None) -> AdapterRegistry:
+    reg = AdapterRegistry(
+        allowed=["core", "db", "api", "pay", "scrape", "cache", "queue", "txn", "auth", "email", "calendar", "social"]
+    )
+    reg.register("db", MockDBAdapter(types))
+    reg.register("api", MockAPIAdapter())
+    reg.register("cache", MockCacheAdapter())
+    reg.register("queue", MockQueueAdapter())
+    reg.register("auth", MockAuthAdapter())
+    reg.register("pay", MockPayAdapter())
+    reg.register("txn", MockTxnAdapter())
+    reg.register("email", _MockEmailAdapter())
+    reg.register("calendar", _MockCalendarAdapter())
+    reg.register("social", _MockSocialAdapter())
+    return reg